Bien que Memorystore pour Redis fournisse des métriques côté serveur en temps réel pour surveiller le débit, l'utilisation du processeur et l'utilisation de la mémoire, ces données ne suffisent pas à expliquer pourquoi votre application cliente subit une latence élevée dans des systèmes distribués complexes.
Les métriques côté client résolvent ce problème en offrant une transparence sur l'ensemble du cycle requête-réponse. Ils mesurent une commande à partir du moment où l'application l'initie jusqu'à ce qu'elle traite la réponse. En capturant ces points de données, vous pouvez déterminer avec précision si la latence provient de la logique d'application, du chemin réseau ou du serveur Redis.
Avant de commencer
Assurez-vous que votre application cliente utilise un compte de service et que les rôles IAM (Identity and Access Management) suivants lui sont attribués :
roles/cloudtrace.agent(Agent Cloud Trace)roles/monitoring.metricWriter(Rédacteur de métriques Monitoring)
Pour en savoir plus sur l'attribution de rôles, consultez le guide de démarrage rapide Attribuer un rôle IAM à l'aide de la console Google Cloud .
Activer l'API Cloud Monitoring.
Pour exporter des métriques côté client vers Monitoring, votre application nécessite l'activation de l'API Monitoring. L'exportation et la visualisation de ces métriques dans Monitoring vous permettent d'identifier la cause principale des goulots d'étranglement afin de déterminer l'origine de la latence.
Pour activer l'API Monitoring, procédez comme suit :
Dans la console Google Cloud , accédez à la page API et services.
Sélectionnez le projet dans lequel vous avez créé l'instance Memorystore pour Redis.
Cliquez sur Activer les API et les services.
Recherchez
monitoring.Dans les résultats de recherche, cliquez sur API Cloud Monitoring.
Si API activée s'affiche, cela signifie que l'API est déjà activée. Sinon, cliquez sur Activer.
Activer l'API Cloud Trace
Pour afficher les traces distribuées dans Trace, vous devez activer l'API Trace. Vous pouvez ensuite utiliser l'explorateur de traces pour afficher ces traces, diagnostiquer les goulots d'étranglement et isoler la source de latence dans votre application.
Pour activer l'API Trace, procédez comme suit :
Dans la console Google Cloud , accédez à la page API et services.
Sélectionnez le projet dans lequel vous avez créé l'instance Memorystore pour Redis.
Cliquez sur Activer les API et les services.
Recherchez
trace.Dans les résultats de recherche, cliquez sur API Cloud Trace.
Si API activée s'affiche, cela signifie que l'API est déjà activée. Sinon, cliquez sur Activer.
Activer l'API Telemetry
Pour exporter des métriques côté client à l'aide du protocole OpenTelemetry (OTLP), vous devez activer l'API Telemetry. Vous pouvez ensuite utiliser des exportateurs OTLP standards dans votre code client plutôt que des exportateurs Google Cloud spécifiques au fournisseur.
Les exportateurs OTLP standards évitent la perte de données. Ils simplifient également vos dépendances et garantissent que vos données restent portables sur d'autres plates-formes d'observabilité. Une fois que vous avez écrit votre code de télémétrie, vous pouvez acheminer vos données vers n'importe laquelle de ces plates-formes en mettant à jour votre configuration. Vous n'avez pas besoin de réécrire votre code avec un nouvel ensemble de bibliothèques propriétaires pour chaque plate-forme.
Pour activer l'API Telemetry, procédez comme suit :
Dans la console Google Cloud , accédez à la page API et services.
Sélectionnez le projet dans lequel vous avez créé l'instance Memorystore pour Redis.
Cliquez sur Activer les API et les services.
Recherchez
telemetry.Dans les résultats de recherche, cliquez sur API Telemetry.
Si API activée s'affiche, cela signifie que l'API est déjà activée. Sinon, cliquez sur Activer.
Activer les métriques côté client
Pour activer les métriques côté client, ajoutez le SDK OpenTelemetry et les exportateurs OTLP OpenTelemetry, qui ciblent l'API Telemetry, au code de votre application. L'instrumentation OpenTelemetry, qui s'exécute directement dans la bibliothèque cliente Redis de votre application, capture les métriques. Cela permet à votre application d'enregistrer des points de données de latence et de les exporter vers Monitoring et Trace pour les visualiser.
Pour activer les métriques côté client, vous pouvez utiliser Go, Java, Node.js ou Python. Les informations permettant d'activer les métriques pour chaque langage s'affichent dans les onglets suivants.
Go
Pour installer les dépendances requises pour l'exportateur OpenTelemetry et OTLP, exécutez les commandes suivantes dans votre 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
Pour activer les métriques côté client, créez un fichier
main.goet ajoutez-y le code suivant :Exécutez votre application pendant au moins une minute pour laisser à l'exportateur le temps de regrouper et d'envoyer les métriques publiées à Monitoring.
Java
Pour installer les dépendances requises pour OpenTelemetry et l'exportateur OTLP, ajoutez le code suivant au fichier
pom.xmlde votre application :Pour activer les métriques côté client, créez un fichier
RedisTelemetryApp.javaet ajoutez-y le code suivant :Exécutez votre application pendant au moins une minute pour laisser à l'exportateur le temps de regrouper et d'envoyer les métriques publiées à Monitoring.
Node.js
Pour installer les dépendances requises pour l'exportateur OpenTelemetry et OTLP, exécutez les commandes suivantes dans votre 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
Pour activer les métriques côté client, créez un fichier
server.jset ajoutez-y le code suivant :Exécutez votre application pendant au moins une minute pour laisser à l'exportateur le temps de regrouper et d'envoyer les métriques publiées à Monitoring.
Python
Pour installer les dépendances requises pour l'exportateur OpenTelemetry et OTLP, exécutez les commandes suivantes dans votre 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
Pour activer les métriques côté client, créez un fichier
main.pyet ajoutez le code suivant à votre application :Exécutez votre application pendant au moins une minute pour laisser à l'exportateur le temps de regrouper et d'envoyer les métriques publiées à Monitoring.
Afficher les métriques dans Monitoring
Après avoir activé les métriques côté client et exécuté votre application pendant au moins une minute pour laisser à l'exportateur le temps de regrouper et d'envoyer les métriques à Monitoring, utilisez Monitoring pour visualiser vos métriques, les regrouper par opération ou par instance, et appliquer des agrégateurs pour surveiller les performances de votre application.
Pour afficher les métriques dans Monitoring, procédez comme suit :
Dans la console Google Cloud , accédez à la page Explorateur de métriques.
Sélectionnez votre projet Google Cloud .
Cliquez sur Sélectionner une métrique.
Recherchez
workload.googleapis.com/redis.Sélectionnez une métrique côté client. Regroupez les données par
operationetinstancesi nécessaire, puis sélectionnez un agrégateur. Pour découvrir plus d'options, consultez Sélectionner des métriques lors de l'utilisation de l'explorateur de métriques.
Afficher les traces distribuées dans Trace
Une fois que votre application commence à exporter des données, vous pouvez utiliser Trace pour visualiser le cycle complet de requête-réponse de vos commandes Redis. L'affichage de vos traces distribuées dans Trace vous permet de diagnostiquer les goulots d'étranglement afin d'isoler rapidement la source exacte de latence dans votre application.
Pour afficher les traces distribuées dans Trace, procédez comme suit :
Dans la console Google Cloud , accédez à la page Explorateur Trace.
Sélectionnez une trace récente représentée par un point sur le graphique à nuage de points.
Examinez la vue en cascade pour isoler la source de la latence en identifiant les goulots d'étranglement suivants :
Durée totale de la requête : la barre de niveau supérieur (parent) indique le temps total que vous devez attendre pour que l'opération se termine.
Latence du réseau et du serveur (DAR) : les barres enfants (telles que celles libellées
GETouSET) indiquent le temps passé par la commande à traverser le réseau et à s'exécuter sur le serveur Memorystore pour Redis.Blocage de la connexion client : s'il existe un grand espace horizontal vide avant le début de l'intervalle enfant Redis, le thread de l'application est bloqué en attente d'une connexion TCP disponible dans le pool de connexions.
Blocage de l'analyse de l'application : s'il existe un grand espace horizontal vide après la fin de l'intervalle enfant Redis, l'application a du mal à analyser ou à traiter la charge utile renvoyée. Cela se produit souvent avec des chaînes JSON de plusieurs mégaoctets.
Nouvelles tentatives : si vous voyez plusieurs segments enfants courts pour la même commande se produisant de manière séquentielle dans la même trace parente, votre client peut subir une perte de paquets réseau et doit déclencher sa boucle de nouvelle tentative avec intervalle exponentiel entre les tentatives.
Résoudre les problèmes
Cette section liste les problèmes de performances courants que vous pouvez identifier à l'aide des métriques côté client, explique leurs causes principales et fournit des conseils pour le dépannage.
| Problème | Cause | Résoudre les problèmes |
|---|---|---|
Votre application subit un pic de latence soudain, mais Memorystore pour Redis semble parfaitement opérationnel.
|
Le goulot d'étranglement se trouve strictement dans votre application. Vos threads tentent d'exécuter des commandes Redis, mais le pool de connexions est complètement épuisé. La valeur élevée de redis_client_blocking_latency représente le temps que votre code passe à attendre un socket TCP disponible avant que la commande ne soit envoyée au réseau. |
Pour gérer le trafic simultané plus élevé, augmentez les limites de taille du pool de connexions dans la configuration de votre client Redis (par exemple, MaxActive pour Go, MaxTotal pour Java ou max_connections pour Node.js et Python). |
La requête aboutit, mais le point de terminaison prend beaucoup plus de temps que prévu. Aucun problème n'est associé à l'état de votre réseau ou de votre serveur.
|
Memorystore pour Redis exécute la commande et le réseau transfère la charge utile rapidement (DAR faible). Toutefois, la charge utile renvoyée est volumineuse (par exemple, une chaîne JSON de 15 Mo). Votre application rencontre un redis_application_blocking_latency élevé, car elle consomme trop de ressources lors de l'allocation de mémoire et de la désérialisation de cette grande chaîne en objet. |
Optimisez votre modèle de données. Ne stockez pas de blobs JSON volumineux dans des clés uniques.
Décomposez les données à l'aide de hachages Redis (HSET) et utilisez HGET ou HMGET pour ne récupérer que les champs spécifiques dont vous avez besoin.
|
La latence de votre application visible par l'utilisateur augmente, mais vos métriques Redis indiquent une faible latence du serveur et des extractions de pool de connexions standards.
|
Comme redis_client_rtt ne capture que le DAR des requêtes réussies, il ne reflète pas la durée du délai avant expiration d'un paquet ayant échoué. Lorsque votre application subit des pertes de paquets ou des réinitialisations TCP temporaires, la logique de nouvelle tentative de votre client instrumenté incrémente redis_retry_count et déclenche sa boucle d'intervalle exponentiel entre les tentatives.
Cela introduit un temps de veille entre les tentatives (par exemple, 100ms, 200ms ou 400ms). L'utilisateur subit une latence totale élevée, mais la cause principale sous-jacente est une perte de paquets réseau, qui déclenche des délais de veille côté client. |
Vérifiez vos journaux de flux VPC pour détecter les paquets supprimés, la limitation de la bande passante ou les anomalies de routage interrégional. Si vous rencontrez des délais d'expiration agressifs, assurez-vous que les délais d'expiration de la connexion client (socket_timeout ou connect_timeout) sont supérieurs au DAR attendu pour tenir compte de la gigue réseau temporaire. |
Tout s'arrête et toutes les couches du pipeline de télémétrie signalent une latence élevée.
|
Redis est monothread. Lorsque vous exécutez une commande de complexité temporelle O(N), telle que KEYS *, SMEMBERS sur un ensemble massif ou HGETALL sur un hachage avec des millions de champs, le moteur Redis s'interrompt pour répondre à cette requête. Pendant l'exécution de cette commande, toutes les autres requêtes d'application sont mises en file d'attente, ce qui entraîne un pic de latence à l'échelle du système. Comme votre redis_client_rtt personnalisé correspond à la latence du serveur (commands/usec_per_call), le serveur qui exécute la commande est le goulot d'étranglement. |
Ouvrez Trace et examinez les commandes Redis sur les segments lents pour identifier la requête à l'origine du blocage. Remplacez les commandes bloquantes par des commandes non bloquantes dans votre code. Pour effectuer une itération incrémentielle sur de grands ensembles de données sans verrouiller le thread du serveur, utilisez |
Votre application signale une latence de référence élevée et constante pour toutes les commandes Redis, même lorsque le trafic est faible.
|
Le serveur Redis exécute les commandes instantanément, mais votre application et votre instance sont déployées dans des régions différentes (par exemple, us-central1 et us-east1). Chaque paquet réseau doit transiter par l'infrastructure cloud physique de Google Cloud entre ces centres de données géographiques. Cela entraîne une pénalité de latence interrégionale obligatoire liée à la vitesse de la lumière pour chaque aller-retour. |
Pour réduire la latence, déployez votre application dans la même région et la même zone que votre instance. Pour afficher la région de votre application et de votre instance, utilisez la console Google Cloud . |
Étapes suivantes
- En savoir plus sur les métriques côté client
- Découvrez les métriques côté client disponibles pour Memorystore pour Redis.