Embora o Memorystore para Redis forneça métricas em tempo real do lado do servidor para monitorar a capacidade de processamento, a utilização da CPU e o uso da memória, esses dados por si só podem não explicar por que o aplicativo cliente apresenta alta latência em sistemas distribuídos complexos.
As métricas do lado do cliente resolvem isso oferecendo transparência em todo o ciclo de solicitação-resposta. Elas medem um comando desde o momento em que o aplicativo o inicia até o momento em que o aplicativo processa a resposta. Ao capturar esses pontos de dados, é possível determinar com precisão se a latência se origina da lógica do aplicativo, do caminho de rede ou do servidor do Redis.
Antes de começar
Verifique se o aplicativo cliente usa uma conta de serviço e se os seguintes papéis do Identity and Access Management (IAM) estão atribuídos a ela:
roles/cloudtrace.agent(Agente do Cloud Trace)roles/monitoring.metricWriter(Gravador de métricas do Monitoring)
Para mais informações sobre como conceder papéis, consulte o guia de início rápido Conceder um papel do IAM usando o console do Google Cloud .
Ativar a API Cloud Monitoring.
Para exportar métricas do lado do cliente para o Monitoring, seu aplicativo exige que você ative a API Monitoring. Exportar e visualizar essas métricas no Monitoring permite identificar a causa raiz dos gargalos para determinar onde a latência se origina.
Para ativar a API Monitoring, faça o seguinte:
No console do Google Cloud , acesse a página APIs e serviços.
Selecione o projeto em que você criou a instância do Memorystore para Redis.
Clique em Ativar APIs e serviços.
Pesquisar por
monitoring.Nos resultados da pesquisa, clique em API Cloud Monitoring.
Se a mensagem API ativada aparecer, quer dizer que a API já está ativada. Caso contrário, clique em Ativar.
Ative a API Cloud Trace
Para visualizar traces distribuídos no Trace, é necessário ativar a API Trace. Em seguida, use o Trace Explorer para visualizar esses traces, diagnosticar gargalos e isolar a origem da latência no aplicativo.
Para ativar a API Trace, faça o seguinte:
No console do Google Cloud , acesse a página APIs e serviços.
Selecione o projeto em que você criou a instância do Memorystore para Redis.
Clique em Ativar APIs e serviços.
Pesquisar por
trace.Nos resultados da pesquisa, clique em API Cloud Trace.
Se a mensagem API ativada aparecer, quer dizer que a API já está ativada. Caso contrário, clique em Ativar.
Ativar a API Telemetry
Para exportar métricas do lado do cliente usando o protocolo OpenTelemetry (OTLP), é necessário ativar a API Telemetry. Em seguida, use exportadores OTLP padrão no código do cliente, em vez de exportadores Google Cloud específicos do fornecedor.
Os exportadores padrão do OTLP evitam a perda de dados. Eles também simplificam suas dependências e garantem que seus dados permaneçam portáteis em outras plataformas de observabilidade. Depois de escrever o código de telemetria uma vez, é possível rotear os dados para qualquer uma dessas plataformas atualizando a configuração. Não é necessário reescrever o código com um novo conjunto de bibliotecas reservadas para cada plataforma.
Para ativar a API Telemetry, faça o seguinte:
No console do Google Cloud , acesse a página APIs e serviços.
Selecione o projeto em que você criou a instância do Memorystore para Redis.
Clique em Ativar APIs e serviços.
Pesquisar por
telemetry.Nos resultados da pesquisa, clique em API Telemetry.
Se a mensagem API ativada aparecer, quer dizer que a API já está ativada. Caso contrário, clique em Ativar.
Ativar métricas do lado do cliente
Para ativar as métricas do lado do cliente, adicione o SDK do OpenTelemetry e os exportadores OTLP do OpenTelemetry, que têm como destino a API Telemetry, ao código do aplicativo. A instrumentação do OpenTelemetry, que é executada diretamente na biblioteca de cliente do Redis do aplicativo, captura as métricas. Isso permite que o aplicativo registre pontos de dados de latência e os exporte para o Monitoring e o Trace para visualização.
Para ativar as métricas do lado do cliente, use Go, Java, Node.js ou Python. As informações para ativar as métricas de cada linguagem aparecem nas guias a seguir.
Go
Para instalar as dependências necessárias do OpenTelemetry e do exportador OTLP, execute os seguintes comandos no terminal:
go get github.com/gomodule/redigo/redis@latest go get go.opentelemetry.io/otel go get go.opentelemetry.io/otel/sdk go get go.opentelemetry.io/otel/sdk/metric go get go.opentelemetry.io/contrib/detectors/gcp go get go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc go get go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc go get golang.org/x/oauth2/google go get google.golang.org/grpc
Para ativar as métricas do lado do cliente, crie um arquivo
main.goe adicione o seguinte código a ele:Execute o aplicativo por pelo menos um minuto para que o exportador tenha tempo suficiente para agrupar e enviar as métricas publicadas ao Monitoring.
Java
Para instalar as dependências necessárias do OpenTelemetry e do exportador OTLP, adicione o seguinte código ao arquivo
pom.xmldo aplicativo:Para ativar as métricas do lado do cliente, crie um arquivo
RedisTelemetryApp.javae adicione o seguinte código a ele:Execute o aplicativo por pelo menos um minuto para que o exportador tenha tempo suficiente para agrupar e enviar as métricas publicadas ao Monitoring.
Node.js
Para instalar as dependências necessárias do OpenTelemetry e do exportador OTLP, execute os seguintes comandos no terminal:
npm install redis@^4.6.0 \ @grpc/grpc-js@^1.12.0 \ google-auth-library@^9.15.0 \ @opentelemetry/api@^1.9.0 \ @opentelemetry/sdk-trace-node@^2.1.0 \ @opentelemetry/sdk-trace-base@^2.1.0 \ @opentelemetry/sdk-metrics@^2.1.0 \ @opentelemetry/instrumentation@^0.205.0 \ @opentelemetry/instrumentation-redis@^0.67.0 \ @opentelemetry/exporter-trace-otlp-grpc@^0.205.0 \ @opentelemetry/exporter-metrics-otlp-grpc@^0.205.0 \ @opentelemetry/resources@^2.10.0 \ @opentelemetry/resource-detector-gcp@^0.40.0
Para ativar as métricas do lado do cliente, crie um arquivo
server.jse adicione o seguinte código a ele:Execute o aplicativo por pelo menos um minuto para que o exportador tenha tempo suficiente para agrupar e enviar as métricas publicadas ao Monitoring.
Python
Para instalar as dependências necessárias do OpenTelemetry e do exportador OTLP, execute os seguintes comandos no terminal:
pip install redis>=5.0.0 \ opentelemetry-api==1.39.1 \ opentelemetry-sdk==1.39.1 \ opentelemetry-instrumentation-redis==0.60b1 \ opentelemetry-exporter-otlp-proto-grpc \ opentelemetry-resourcedetector-gcp \ google-auth \ requests \ grpcio
Para ativar as métricas do lado do cliente, crie um arquivo
main.pye adicione o seguinte código ao aplicativo:Execute o aplicativo por pelo menos um minuto para que o exportador tenha tempo suficiente para agrupar e enviar as métricas publicadas ao Monitoring.
Ver métricas no Monitoring
Depois de ativar as métricas do lado do cliente e executar o aplicativo por pelo menos um minuto para que o exportador tenha tempo suficiente para agrupar e enviar métricas ao Monitoring, use o Monitoring para visualizar as métricas, agrupá-las por operação ou instância e aplicar agregadores para monitorar o desempenho do aplicativo.
Para conferir as métricas no Monitoring, faça o seguinte:
No console do Google Cloud , acesse a página do Metrics Explorer.
Selecionar o projeto Google Cloud .
Clique em Selecionar uma métrica.
Pesquisar por
workload.googleapis.com/redis.Selecione uma métrica do lado do cliente. Agrupe os dados por
operationeinstanceconforme necessário e escolha um agregador. Para conhecer outras opções, consulte Selecionar métricas ao usar o Metrics Explorer.
Ver traces distribuídos no Trace
Depois que o aplicativo começar a exportar dados, use o Trace para visualizar o ciclo completo de solicitação-resposta dos comandos do Redis. Ao visualizar os traces distribuídos no Trace, é possível diagnosticar gargalos para isolar rapidamente a origem exata da latência no aplicativo.
Para ver traces distribuídos no Trace, faça o seguinte:
No console Google Cloud , acesse a página Explorador de traces.
Selecione um trace recente representado por um ponto no gráfico de dispersão.
Examine a visualização em cascata para isolar a origem da latência identificando os seguintes gargalos:
Duração total da solicitação: a barra de nível superior (principal) mostra o tempo total que você precisa esperar para que a operação seja concluída.
Latência de rede e servidor (RTT): as barras secundárias (como as rotuladas como
GETouSET) mostram o tempo que o comando levou para viajar pela rede e ser executado no servidor do Memorystore para Redis.Bloqueio de conexão do cliente: se houver uma lacuna horizontal grande e vazia antes do início do período filho do Redis, a linha de execução do aplicativo ficará travada aguardando uma conexão TCP disponível do pool de conexões.
Bloqueio de análise do aplicativo: se houver uma lacuna horizontal grande e vazia depois que o período filho do Redis terminar, o aplicativo terá dificuldade para analisar ou processar o payload retornado. Isso geralmente acontece com strings JSON de vários megabytes.
Novas tentativas: se você encontrar vários períodos filhos curtos para o mesmo comando ocorrendo sequencialmente no mesmo trace pai, seu cliente pode ter perda de pacotes de rede e precisa acionar o loop de nova tentativa de espera exponencial.
Resolver problemas
Nesta seção, listamos problemas comuns de desempenho que podem ser identificados usando métricas do lado do cliente, explicamos as causas raiz e fornecemos orientações sobre como resolver os problemas.
| Problema | Causa | Resolver problemas |
|---|---|---|
Seu aplicativo apresenta um pico repentino de latência, mas o Memorystore para Redis parece estar totalmente íntegro.
|
O gargalo está estritamente dentro do aplicativo. As
linhas de execução tentam executar comandos do Redis, mas o pool de conexões está totalmente
esgotado. O redis_client_blocking_latency alto representa
o tempo que o código passa esperando por um soquete TCP disponível antes que o
comando seja enviado à rede. |
Para lidar com o tráfego simultâneo mais alto, aumente os
limites de tamanho do pool de conexões na configuração do cliente do Redis (por exemplo,
MaxActive para Go, MaxTotal para Java ou
max_connections para Node.js e Python). |
A solicitação é concluída, mas o endpoint leva muito mais tempo do que o esperado. Não há problemas associados à integridade da rede ou do servidor.
|
O Memorystore para Redis executa o comando, e a rede transfere o payload rapidamente (RTT baixo). No entanto, o payload retornado é grande (por
exemplo, uma string JSON de 15 MB). O aplicativo apresenta um redis_application_blocking_latency alto porque consome recursos excessivos ao alocar memória e desserializar essa string grande em um objeto. |
Otimize o modelo de dados. Não armazene blobs JSON enormes em chaves únicas.
Divida os dados usando hashes do Redis (HSET) e use
HGET ou HMGET para recuperar apenas os campos específicos
necessários.
|
A latência do aplicativo voltado ao usuário aumenta, mas as métricas do Redis informam uma latência de servidor baixa e check-outs típicos do pool de conexões.
|
Como redis_client_rtt captura apenas o RTT de
solicitações bem-sucedidas, ele não reflete a duração do tempo limite de um pacote
com falha. Quando o aplicativo apresenta quedas de pacotes temporárias ou redefinições de TCP, a lógica de repetição do cliente instrumentado incrementa o
redis_retry_count e aciona o loop de espera exponencial.
Isso introduz um tempo de espera entre as tentativas (por exemplo,
100ms, 200ms ou 400ms). O usuário
enfrenta uma latência total alta, mas a causa raiz é uma perda de pacote
de rede, que aciona atrasos de espera do lado do cliente. |
Verifique se há pacotes descartados, limitação de largura de banda ou anomalias de roteamento entre regiões nos registros de fluxo de VPC. Se você tiver tempos limite agressivos,
verifique se os tempos limite de conexão do cliente (socket_timeout ou
connect_timeout) são maiores do que o RTT esperado para considerar
o jitter de rede temporário. |
Tudo para e todas as camadas do pipeline de telemetria relatam alta latência.
|
O Redis tem uma única linha de execução. Quando você executa um comando de complexidade de tempo O(N), como KEYS *, SMEMBERS em um conjunto massivo ou HGETALL em um hash com milhões de campos, o mecanismo do Redis é pausado para atender a essa solicitação. Enquanto esse comando é executado, todas as outras solicitações de aplicativo são colocadas em fila, causando um pico de latência em todo o sistema. Como o redis_client_rtt personalizado corresponde à
latência do servidor (commands/usec_per_call), o servidor que executa
o comando é o gargalo. |
Abra o Trace e observe os comandos do Redis nos períodos lentos para identificar qual consulta causa o bloqueio. Substitua os comandos de bloqueio por comandos sem bloqueio no código. Para iterar em grandes conjuntos de dados de forma incremental sem bloquear a
linha de execução do servidor, use |
O aplicativo relata uma latência de referência consistente e elevada para todos os comandos do Redis, mesmo quando o tráfego está baixo.
|
O servidor do Redis executa comandos instantaneamente, mas o aplicativo e a
instância são implantados em regiões diferentes (por exemplo,
us-central1 e us-east1). Cada pacote de rede
precisa viajar pela infraestrutura física do Google Cloud entre esses
data centers geográficos. Isso resulta em uma penalidade obrigatória de latência entre regiões
na velocidade da luz para cada ida e volta. |
Para reduzir a latência, implante o aplicativo para que ele resida na mesma região e zona que a instância. Para ver a região do aplicativo e da instância, use o console do Google Cloud . |
A seguir
- Saiba mais sobre as métricas do lado do cliente.
- Saiba mais sobre as métricas do lado do cliente disponíveis para o Memorystore para Redis.