Cette page répertorie les métriques disponibles pour Memorystore pour Redis Cluster et décrit ce que chacune mesure.
Métriques de sauvegarde
Cette section liste et décrit les métriques backup et import.
Métriques au niveau du cluster
Cette section liste et décrit les métriques de sauvegarde et d'importation au niveau du cluster.
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/backup/last_backup_start_time
|
Cette métrique indique l'heure de début de la dernière opération de sauvegarde. |
redis.googleapis.com/cluster/backup/last_backup_status |
Cette métrique indique si la dernière tentative de sauvegarde a réussi ou échoué. Les états sont 1 pour Success et 0 pour Failed. |
redis.googleapis.com/cluster/backup/last_backup_duration
|
Cette métrique indique la durée de la dernière opération de sauvegarde (en millisecondes). |
redis.googleapis.com/cluster/backup/last_backup_size |
Cette métrique indique la taille de la dernière sauvegarde (en octets). Cette métrique est un indicateur clé pour surveiller l'efficacité des sauvegardes et la planification de la capacité de stockage. |
redis.googleapis.com/cluster/import/last_import_start_time
|
Cette métrique indique l'heure de début de la dernière opération d'importation. |
redis.googleapis.com/cluster/import/last_import_duration
|
Cette métrique indique la durée de la dernière opération d'importation (en millisecondes). |
Métriques de l'autorité de certification
Cette section liste les métriques associées aux autorités de certification (CA) gérées par le client.
Métriques au niveau du cluster
Ces métriques offrent une vue d'ensemble des certificats associés aux machines d'un cluster.
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/security/rotate_tls_cert_count
|
Cette métrique indique l'état des certificats renouvelés associés aux machines d'un cluster. La métrique peut avoir les états suivants :
|
Métriques Cloud Monitoring
Cette section liste et décrit les métriques Cloud Monitoring disponibles pour les clusters Memorystore pour Redis.
Métriques au niveau du cluster
Ces métriques fournissent une vue d'ensemble de l'état et des performances globales d'un cluster. Vous pouvez utiliser les métriques pour comprendre la capacité et l'utilisation globales d'un cluster, ainsi que pour identifier les goulots d'étranglement potentiels ou les points à améliorer.
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/clients/average_connected_clients
|
Cette métrique mesure le nombre moyen de connexions clientes actives à un cluster au cours d'une période spécifiée. Vous pouvez utiliser la métrique pour surveiller la mise à l'échelle des connexions, identifier les goulots d'étranglement des applications et vous assurer que le cluster est stable. |
redis.googleapis.com/cluster/clients/maximum_connected_clients
|
Cette métrique indique le nombre maximal de connexions client actives sur tous les nœuds d'un cluster. Vous pouvez utiliser cette métrique pour surveiller la charge de connexion la plus élevée sur le cluster à tout moment. Cette étape est essentielle pour garantir des performances élevées du cluster, car un nombre élevé de connexions peut augmenter les temps de réponse. |
redis.googleapis.com/cluster/clients/total_connected_clients
|
Cette métrique suit le nombre actuel de connexions client actives à un cluster. Vous pouvez utiliser cette métrique pour surveiller la charge de votre base de données et éviter les limites de connexion. |
redis.googleapis.com/cluster/stats/total_connections_received_count
|
Cette métrique indique le nombre cumulé de connexions client créées dans un cluster au cours de la dernière minute. Vous pouvez utiliser cette métrique pour analyser la charge de trafic, vous assurer de ne pas dépasser les limites de connexion et déterminer si vous devez mettre à l'échelle le cluster. |
redis.googleapis.com/cluster/stats/total_rejected_connections_count
|
Cette métrique suit le nombre total de connexions à un cluster qui sont refusées, car la limite maxclients est atteinte. |
redis.googleapis.com/cluster/commandstats/total_usec_count
|
Cette métrique mesure le temps CPU total consommé par chaque commande. Cette métrique indique le nombre total de microsecondes utilisées, ce qui donne des informations sur les performances et la latence d'un cluster. |
redis.googleapis.com/cluster/commandstats/total_calls_count
|
Cette métrique mesure le nombre total d'appels associés à une commande spécifique sur un nœud de cluster en une minute. Pour identifier les goulots d'étranglement ou le trafic élevé sur des commandes spécifiques, vous pouvez utiliser la métrique pour surveiller le débit des commandes (commandes par minute) sur les nœuds principaux et de réplique. |
redis.googleapis.com/cluster/cpu/average_utilization |
Cette métrique indique l'utilisation moyenne du processeur pour un cluster (de 0, 0 à 1, 0). Vous pouvez l'utiliser pour identifier les ressources surprovisionnées ou sous-utilisées, gérer les seuils d'autoscaling et détecter les goulots d'étranglement des performances. L'utilisation idéale se situe entre 40 % et 70%. |
redis.googleapis.com/cluster/cpu/maximum_utilization |
Cette métrique indique le pic d'utilisation du processeur sur tous les nœuds d'un cluster (de 0,0 à 1,0). La métrique ne résume que les états Assurez-vous que l'utilisation du processeur ne dépasse pas 0,8 seconde pour le nœud principal et 0,5 seconde pour chaque réplica désigné comme réplica en lecture. Pour en savoir plus, consultez les bonnes pratiques concernant l'utilisation du processeur. |
redis.googleapis.com/cluster/stats/average_expired_keys
|
Cette métrique mesure le nombre moyen d'événements d'expiration de clés pour tous les nœuds principaux d'un cluster. Vous pouvez l'utiliser pour surveiller le nombre de clés qui expirent. |
redis.googleapis.com/cluster/stats/maximum_expired_keys
|
Cette métrique mesure le nombre maximal d'événements d'expiration de clé qui se produisent sur tous les nœuds principaux d'un cluster. |
redis.googleapis.com/cluster/stats/total_expired_keys_count
|
Cette métrique suit le nombre total d'événements d'expiration de clés qui se produisent sur tous les nœuds principaux d'un cluster. Vous pouvez l'utiliser pour surveiller le nombre de clés qui expirent. |
redis.googleapis.com/cluster/stats/average_evicted_keys
|
Cette métrique suit le nombre moyen de clés évincées en raison des contraintes de capacité mémoire dans les segments principaux d'un cluster. |
redis.googleapis.com/cluster/stats/maximum_evicted_keys
|
Cette métrique indique le nombre maximal de clés évincées d'un nœud ou d'un shard d'un cluster principal en raison de la capacité de mémoire. |
redis.googleapis.com/cluster/stats/total_evicted_keys_count
|
Cette métrique indique le nombre total de clés évincées par un nœud d'un cluster principal en raison de la capacité de mémoire. |
redis.googleapis.com/cluster/keyspace/total_keys |
Cette métrique indique le nombre de clés stockées dans un cluster. |
redis.googleapis.com/cluster/stats/average_keyspace_hits
|
Cette métrique indique le nombre moyen de recherches de clés réussies sur tous les nœuds d'un cluster. |
redis.googleapis.com/cluster/stats/maximum_keyspace_hits
|
Cette métrique indique le nombre maximal de recherches de clés réussies dans un nœud de cluster. Vous pouvez utiliser cette métrique pour surveiller les performances du cluster et identifier les points chauds potentiels dans le cluster. |
redis.googleapis.com/cluster/stats/total_keyspace_hits_count
|
Cette métrique suit le nombre cumulé de recherches de clés réussies sur tous les nœuds d'un cluster. |
redis.googleapis.com/cluster/stats/average_keyspace_misses
|
Cette métrique indique le nombre moyen de recherches de clés ayant échoué dans un cluster. Vous pouvez utiliser cette métrique pour suivre la fréquence à laquelle des clés sont demandées, mais ne sont pas trouvées dans le cache. |
redis.googleapis.com/cluster/stats/maximum_keyspace_misses
|
Cette métrique indique le nombre maximal de recherches de clés ayant échoué sur un nœud de cluster. |
redis.googleapis.com/cluster/stats/total_keyspace_misses_count
|
Cette métrique indique le nombre total d'échecs de recherche de clés sur tous les nœuds du cluster. |
redis.googleapis.com/cluster/memory/average_utilization
|
Cette métrique indique l'utilisation moyenne de la mémoire dans un cluster (de 0,0 à 1,0). Vous pouvez utiliser cette métrique pour surveiller la capacité du cluster et définir des seuils d'alerte. Par exemple, vous pouvez définir un seuil d'alerte pour avertir les utilisateurs lorsque la mémoire moyenne dépasse un pourcentage spécifique (par exemple, 80%). |
redis.googleapis.com/cluster/memory/maximum_utilization
|
Cette métrique indique l'utilisation maximale de la mémoire sur tous les nœuds du cluster (de 0,0 à 1,0). Vous pouvez l'utiliser pour identifier le moment où faire évoluer un cluster. Nous vous recommandons de surveiller l'utilisation pour vous assurer qu'elle reste inférieure à 100%. En cas de fortes charges d'écriture, les performances peuvent se dégrader si cette métrique atteint 65% à 85%. |
redis.googleapis.com/cluster/memory/total_used_memory |
Cette métrique indique l'utilisation totale de la mémoire d'un cluster (en octets). Vous pouvez l'utiliser pour surveiller la capacité du cluster. |
redis.googleapis.com/cluster/memory/size |
Cette métrique mesure la RAM totale, utilisée et disponible sur tous les nœuds d'un cluster. Vous pouvez utiliser cette métrique pour surveiller la capacité du cluster et éviter les défaillances de nœuds. |
redis.googleapis.com/cluster/replication/average_ack_lag
|
Cette métrique indique le délai moyen d'accusé de réception (en secondes) des répliques dans un cluster.
Le délai d'accusé de réception est un goulot d'étranglement sur le nœud principal d'un cluster. Ce goulot d'étranglement est dû à ses répliques qui ne peuvent pas suivre le rythme des informations que le nœud principal leur envoie. Dans ce cas, le nœud principal doit attendre la confirmation que les instances répliquées ont reçu les informations. Cela peut ralentir les commits de transaction et avoir un impact sur les performances du nœud principal. |
redis.googleapis.com/cluster/replication/maximum_ack_lag
|
Cette métrique indique le délai d'accusé de réception maximal (en secondes) des répliques dans un cluster. |
redis.googleapis.com/cluster/replication/average_offset_diff
|
Cette métrique indique la différence moyenne de décalage d'accusé de réception de la réplication (en octets) dans un cluster.
La différence de décalage d'accusé de réception de la réplication correspond au nombre d'octets non répliqués entre les réplicas et leurs clusters principaux. |
redis.googleapis.com/cluster/replication/maximum_offset_diff
|
Cette métrique indique la différence maximale de décalage de réplication (en octets) dans un cluster. La différence de décalage de réplication correspond au nombre d'octets non répliqués entre les répliques et leurs clusters principaux. |
redis.googleapis.com/cluster/stats/total_net_input_bytes_count
|
Cette métrique indique le nombre d'octets réseau entrants reçus par les points de terminaison d'un cluster. |
redis.googleapis.com/cluster/stats/total_net_output_bytes_count
|
Cette métrique indique le nombre d'octets réseau sortants envoyés par les points de terminaison d'un cluster. |
Métriques au niveau des nœuds
Ces métriques offrent des insights détaillés sur l'état et les performances des nœuds individuels d'un cluster. Vous pouvez utiliser les métriques pour résoudre les problèmes liés aux nœuds et optimiser leurs performances.
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/node/clients/connected_clients
|
Cette métrique indique le nombre de connexions clientes actives à un nœud de cluster, à l'exclusion des connexions de réplica. Vous pouvez l'utiliser pour surveiller les limites de connexion et identifier les points chauds où un shard reçoit un trafic disproportionné. |
redis.googleapis.com/cluster/node/clients/blocked_clients
|
Cette métrique indique le nombre de connexions client qu'un nœud de cluster bloque. Un nombre élevé ou en augmentation rapide de connexions client bloquées peut indiquer que de nombreux clients sont en attente d'opérations. Cela peut entraîner une latence accrue. |
redis.googleapis.com/cluster/node/server/uptime |
Cette métrique mesure le temps d'activité d'un nœud de cluster. Vous pouvez utiliser la métrique pour suivre la durée pendant laquelle un serveur s'exécute en continu sans redémarrage ni défaillance. |
redis.googleapis.com/cluster/node/stats/connections_received_count
|
Cette métrique suit le nombre total de connexions client créées sur un nœud de cluster au cours d'une période spécifiée. Vous pouvez utiliser la métrique pour surveiller le trafic de connexion vers des nœuds individuels d'un cluster. Vous pouvez ainsi analyser la répartition de la charge et identifier les pics d'activité de connexion. |
redis.googleapis.com/cluster/node/stats/rejected_connections_count
|
Cette métrique indique le nombre de connexions refusées, car un nœud de cluster a atteint la limite maxclients. Vous pouvez utiliser cette métrique pour déterminer si un nœud est soumis à une forte pression de connexion et refuse de nouvelles connexions, car il ne peut pas en gérer davantage. |
redis.googleapis.com/cluster/node/commandstats/usec_count
|
Cette métrique indique le temps total consommé par chaque commande dans un nœud de cluster. Vous pouvez utiliser cette métrique pour analyser les performances des commandes, identifier les commandes lentes et résoudre les problèmes de latence au niveau des nœuds. |
redis.googleapis.com/cluster/node/commandstats/calls_count
|
Cette métrique suit le nombre total d'appels pour une commande sur un nœud de cluster par minute. Vous pouvez utiliser cette métrique pour surveiller la répartition du trafic, identifier les commandes les plus utilisées et résoudre les problèmes de goulots d'étranglement sur les nœuds individuels. |
redis.googleapis.com/cluster/node/cpu/utilization |
Cette métrique indique l'utilisation du processeur pour un nœud de cluster (de 0,0 à 1,0). |
redis.googleapis.com/cluster/node/stats/expired_keys_count
|
Cette métrique indique le nombre total d'événements d'expiration dans un nœud de cluster. Vous pouvez utiliser cette métrique pour surveiller la fréquence à laquelle les clés sont supprimées du cluster, car leur valeur TTL (Time To Live) atteint zéro. |
redis.googleapis.com/cluster/node/stats/evicted_keys_count
|
Cette métrique comptabilise le nombre total de clés qu'un nœud de cluster évince parce que le cluster atteint sa limite de mémoire maximale. Elle permet d'identifier si un cluster est soumis à une pression de mémoire. Un nombre élevé ou croissant de clés évincées indique qu'un cluster manque d'espace. Par conséquent, le cluster supprime des clés pour faire de la place pour de nouvelles données. |
redis.googleapis.com/cluster/node/keyspace/total_keys |
Cette métrique mesure le nombre total de clés stockées par un nœud de cluster. Cette métrique permet de visualiser la distribution et le partitionnement des données entre les nœuds. |
redis.googleapis.com/cluster/node/stats/keyspace_hits_count
|
Cette métrique suit le nombre de recherches de clés réussies sur un nœud de cluster. Vous pouvez utiliser cette métrique pour surveiller l'efficacité du nœud pour récupérer les données en mémoire. |
redis.googleapis.com/cluster/node/stats/keyspace_misses_count
|
Cette métrique suit le nombre de recherches de clés ayant échoué sur un nœud de cluster. |
redis.googleapis.com/cluster/node/memory/utilization |
Cette métrique suit l'utilisation de la mémoire dans un nœud de cluster (de 0,0 à 1,0). Vous pouvez utiliser cette métrique pour éviter les défaillances de nœuds et assurer la stabilité d'un cluster. |
redis.googleapis.com/cluster/node/memory/usage |
Cette métrique mesure l'utilisation totale de la mémoire d'un nœud de cluster. |
redis.googleapis.com/cluster/node/stats/net_input_bytes_count
|
Cette métrique mesure le nombre total d'octets réseau entrants qu'un nœud de cluster reçoit. Vous pouvez utiliser cette métrique pour surveiller le débit réseau, identifier les goulots d'étranglement potentiels et analyser les pics de trafic sur le nœud. |
redis.googleapis.com/cluster/node/stats/net_output_bytes_count
|
Cette métrique mesure le nombre total d'octets réseau sortants qu'un nœud de cluster envoie. Vous pouvez utiliser cette métrique pour surveiller le volume de trafic sortant du réseau pour le nœud à des fins d'optimisation des performances et de planification de la capacité. |
redis.googleapis.com/cluster/node/replication/offset |
Cette métrique mesure les octets de décalage de réplication d'un nœud de cluster. Avant de promouvoir les répliques d'un cluster en clusters principaux, vous pouvez utiliser la métrique pour vérifier si les répliques ont traité toutes les données. Cela permet d'éviter toute perte de données. |
redis.googleapis.com/cluster/node/server/healthy |
Cette métrique détermine si un nœud de cluster est disponible et fonctionne correctement. |
redis.googleapis.com/cluster/node/stats/evicted_clients_count
|
Cette métrique suit le nombre total de clients que Memorystore pour Redis Cluster déconnecte, car la mémoire globale consommée par tous les tampons client dépasse un seuil de mémoire prédéfini. Vous pouvez utiliser ce critère comme mécanisme de protection pour empêcher une utilisation excessive de la mémoire par les clients d'épuiser la mémoire du serveur et de provoquer des plantages. |
redis.googleapis.com/cluster/node/clients/tracking_clients
|
Cette métrique suit le nombre de clients Redis actifs enregistrés pour recevoir des messages de suivi et d'invalidation côté serveur. Vous pouvez l'utiliser pour surveiller et déboguer les implémentations de mise en cache côté client afin de vous assurer que le suivi du serveur fonctionne comme prévu. |
redis.googleapis.com/cluster/node/clients/maxclients |
Cette métrique indique le nombre maximal de connexions client simultanées que Memorystore pour Redis Cluster autorise sur un nœud de cluster. |
redis.googleapis.com/cluster/node/clients/recent_max_input_buffer
|
Cette métrique indique la plus grande mémoire tampon (en octets) utilisée pour traiter une seule commande client entrante parmi toutes les connexions actives. Vous pouvez utiliser la métrique pour suivre la stabilité de la connexion et éviter le gonflement de la mémoire. Si la taille maximale de la mémoire tampon d'entrée d'un client spécifique atteint systématiquement vos limites, cela peut entraîner des blocages réseau ou des déconnexions dans l'ensemble du cluster. |
redis.googleapis.com/cluster/node/clients/recent_max_output_buffer
|
Cette métrique mesure la liste de sortie la plus longue (en octets) parmi les connexions client les plus récentes à un serveur. Cette métrique est un indicateur essentiel de l'état du serveur, car elle identifie les clients qui demandent de grandes quantités de données plus rapidement que le serveur ne peut les leur envoyer. |
redis.googleapis.com/cluster/node/commandstats/rejected_calls_count
|
Cette métrique indique le nombre de commandes (appels) Redis qu'un serveur rejette avant leur exécution. Ces appels sont déclenchés par des conditions préalables, par exemple des erreurs de syntaxe dans la commande ou l'exécution de commandes à mémoire limitée lorsque l'instance est à court de mémoire (OOM). |
redis.googleapis.com/cluster/node/commandstats/failed_calls_count
|
Cette métrique suit le nombre d'opérations ayant échoué sur un nœud de cluster. Vous pouvez utiliser cette métrique pour évaluer si votre application cliente transmet des paramètres incorrects ou si elle n'est pas synchronisée avec le schéma de votre ensemble de données. De plus, vous pouvez déterminer si une augmentation des échecs est corrélée à une dégradation des commandes. |
redis.googleapis.com/cluster/node/keyspace/keys_with_expiration
|
Cette métrique suit le nombre de clés actives dans un cluster pour lesquelles une valeur TTL (Time-To-Live) ou un code temporel d'expiration sont définis. Vous pouvez utiliser la métrique pour surveiller les limites de mise en cache, l'utilisation de la mémoire et la gestion des sessions. |
redis.googleapis.com/cluster/node/memory/dataset_usage |
Cette métrique mesure la quantité de mémoire consommée par les ensembles de données ou les objets de données principaux dans un nœud de cluster. |
redis.googleapis.com/cluster/node/memory/mem_not_counted_for_evict
|
Cette métrique indique la quantité de mémoire qu'un serveur exclut lorsqu'il évalue la mémoire dont il a besoin pour l'éviction de clés. Lorsque Memorystore pour Redis Cluster calcule s'il doit évincer des clés, il compare sa mémoire totale allouée ( |
redis.googleapis.com/cluster/node/memory/number_of_cached_scripts
|
Cette métrique suit le nombre total de scripts EVAL qu'un serveur met en cache sur un nœud de cluster. Vous pouvez utiliser cette métrique pour surveiller la surcharge associée aux scripts Lua dans le cluster. |
redis.googleapis.com/cluster/node/memory/number_of_functions
|
Cette métrique suit le nombre total de fonctions définies sur un nœud de cluster. |
redis.googleapis.com/cluster/node/memory/lua_usage |
Cette métrique suit le nombre d'octets que Lua utilise pour les scripts EVAL sur un nœud de cluster. |
redis.googleapis.com/cluster/node/memory/replica_clients_usage
|
Cette métrique suit la quantité de mémoire (en octets) que les clients de réplique consomment sur un nœud de cluster. Cette métrique mesure la mémoire utilisée par les clients de réplique. Étant donné que les tampons de réplication partagent la mémoire avec le backlog de réplication, la métrique peut indiquer une valeur de |
redis.googleapis.com/cluster/node/memory/normal_clients_usage
|
Cette métrique suit la quantité de mémoire (en octets) que les clients non répliqués utilisent sur un nœud de cluster. Cette métrique mesure la consommation de mémoire des connexions client non répliquées. |
redis.googleapis.com/cluster/node/memory/peak_usage |
Cette métrique suit la mémoire maximale consommée par Memorystore pour Redis Cluster sur un nœud de cluster. Cette métrique mesure la quantité maximale de mémoire (en octets) utilisée par Memorystore pour Redis Cluster depuis son dernier démarrage. |
redis.googleapis.com/cluster/node/memory/rss_usage
|
Cette métrique suit l'utilisation de la taille de l'ensemble résident (RSS) de Memorystore pour Redis Cluster sur un nœud de cluster. Cette métrique représente le nombre d'octets alloués par Memorystore for Redis Cluster. Il est essentiel de surveiller l'utilisation de la mémoire RSS, car elle reflète l'utilisation réelle de la RAM physique et permet de détecter une forte fragmentation de la mémoire. Par exemple, si la mémoire RSS approche de la limite de conteneur du cluster, cela peut entraîner des problèmes OOM. |
redis.googleapis.com/cluster/node/memory/scripts_usage |
Cette métrique suit la surcharge de mémoire associée aux scripts sur un nœud de cluster. Cette métrique mesure le nombre d'octets de surcharge mémoire utilisés par la fonction EVAL. Cette mémoire est considérée comme faisant partie des used_memory globaux du cluster.
|
redis.googleapis.com/cluster/node/memory/maxmemory_policy
|
Cette métrique suit la configuration de la stratégie d'éviction pour un nœud de cluster. Elle indique le paramètre maxmemory-policy actuel du nœud, qui détermine comment Memorystore for Redis Cluster sélectionne les clés à évincer lorsqu'il atteint la limite maxmemory. |
redis.googleapis.com/cluster/node/persistence/aof_enabled
|
Cette métrique indique si la persistance des fichiers en mode Ajout seul (AOF) est activée sur un nœud de cluster. |
redis.googleapis.com/cluster/node/persistence/async_loading
|
Cette métrique indique si Memorystore pour Redis Cluster charge un ensemble de données de réplication de manière asynchrone tout en diffusant les données existantes. Cette métrique suit l'état dans lequel Memorystore for Redis Cluster charge l'ensemble de données. Cela se produit lorsque la configuration repl-diskless-load est activée et définie sur swapdb. |
redis.googleapis.com/cluster/node/persistence/loading |
Cette métrique indique si Memorystore pour Redis Cluster charge un fichier de dump sur un nœud de cluster. Vous pouvez l'utiliser pour évaluer si Memorystore pour Redis Cluster charge des données à partir d'un stockage persistant, tel qu'un instantané de base de données Redis (RDB) ou un fichier AOF. |
redis.googleapis.com/cluster/node/persistence/current_cow_peak
|
Cette métrique suit l'utilisation maximale de la mémoire associée aux opérations de copie à l'écriture (COW) lors d'un processus fork enfant sur un nœud de cluster. Elle mesure la taille maximale (en octets) de la mémoire COW lors de l'exécution d'un fork enfant. Cela se produit lors d'opérations impliquant le fork du processus, comme la création d'un instantané RDB ou l'exécution d'une réécriture AOF. Il est important de surveiller la taille maximale de la copie lors de l'écriture pour la planification de la capacité et pour éviter les problèmes de mémoire insuffisante, car l'utilisation totale de la mémoire du nœud augmente pendant le processus de fork en fonction de la quantité de données modifiées pendant que le fork est actif. |
redis.googleapis.com/cluster/node/persistence/current_cow_size
|
Cette métrique suit la taille actuelle de la mémoire COW lorsqu'un processus enfant fork est actif sur un nœud de cluster. Cette métrique mesure la taille (en octets) de la mémoire copiée lors d'un processus de fork, comme la création d'un instantané RDB ou l'exécution d'une réécriture AOF. Vous pouvez utiliser cette métrique pour surveiller la surcharge de mémoire en temps réel d'une bifurcation en cours. |
redis.googleapis.com/cluster/node/persistence/rdb_last_bgsave_time_sec
|
Cette métrique suit la durée de la dernière opération d'enregistrement en arrière-plan ( Vous pouvez utiliser cette métrique pour surveiller l'impact des opérations de persistance sur les performances, en particulier lors des événements de maintenance ou de scale-out. |
redis.googleapis.com/cluster/node/persistence/rdb_last_cow_size
|
Cette métrique suit la taille de la mémoire COW lors de la dernière opération d'enregistrement RDB sur un nœud de cluster. Cette métrique mesure la quantité de mémoire (en octets) copiée lors de la création du dernier instantané RDB en arrière-plan. Vous pouvez utiliser cette métrique pour déboguer les problèmes potentiels liés aux synchronisations complètes lors des opérations de maintenance ou des mises à jour de configuration, car elle fournit des informations sur la surcharge de mémoire du processus de persistance. |
redis.googleapis.com/cluster/node/persistence/current_fork_percentage
|
Cette métrique suit la progression du processus de fork actuel sur un nœud de cluster. Cette métrique indique le pourcentage d'achèvement des opérations de fork actives, telles que celles utilisées pour les snapshots RDB ou les réécritures AOF. |
redis.googleapis.com/cluster/node/persistence/aof_rewrite_in_progress
|
Cette métrique fournit un état en temps réel (1 pour "vrai" et 0 pour "faux") indiquant si Memorystore pour Redis Cluster effectue une réécriture AOF sur un nœud de cluster. Vous pouvez utiliser cette métrique pour déterminer si les opérations AOF en arrière-plan contribuent à des augmentations notables de la latence ou de l'utilisation de la mémoire. Les opérations de réécriture peuvent déclencher des pics de charge temporaires. |
redis.googleapis.com/cluster/node/persistence/aof_last_cow_size
|
Cette métrique suit la taille de la mémoire COW utilisée lors de la dernière opération de réécriture AOF sur un nœud de cluster. Cette métrique mesure la quantité de mémoire (en octets) que Memorystore for Redis Cluster copie lors de la dernière réécriture AOF en arrière-plan. Vous pouvez utiliser cette métrique pour surveiller la taille de la mémoire COW lors des opérations de persistance. C'est essentiel pour la planification de la capacité, car l'utilisation totale de la mémoire du nœud augmente pendant le processus de fork en fonction de la quantité de données modifiées pendant que le fork est actif. Si vous ne gérez pas la mémoire COW, vous risquez de rencontrer des problèmes de mémoire insuffisante pour le cluster. |
redis.googleapis.com/cluster/node/persistence/aof_last_rewrite_time_sec
|
Cette métrique mesure le temps (en secondes) nécessaire à la dernière opération de réécriture AOF en arrière-plan pour se terminer sur un nœud de cluster. Vous pouvez utiliser cette métrique pour évaluer l'impact sur les performances de la persistance AOF en arrière-plan et pour comprendre la durée des pics de charge transitoires provoqués par les opérations de réécriture. |
redis.googleapis.com/cluster/node/errorstats/errors_count
|
Cette métrique fournit une vue détaillée des erreurs dérivées de la section ERRORSTATS des statistiques internes de Memorystore pour Redis Cluster. Cette métrique mesure la variation du nombre d'erreurs au cours d'un intervalle.
|
redis.googleapis.com/cluster/node/stats/acl_access_denied_auths_count
|
Cette métrique indique le nombre total d'échecs d'authentification avec accès refusé à la liste de contrôle des accès d'accès (LCA) au cours d'un intervalle. |
redis.googleapis.com/cluster/node/stats/expire_cycle_cpu_millisecond_count
|
Cette métrique mesure la quantité cumulée de temps CPU consacrée aux cycles d'expiration actifs au cours d'un intervalle. |
redis.googleapis.com/cluster/node/stats/expired_keys_percentage
|
Cette métrique indique le pourcentage estimé de clés expirées à un moment donné. Cette métrique fournit des informations sur le processus d'expiration. Si le pourcentage est constamment élevé, il est possible que Memorystore for Redis Cluster n'alloue pas suffisamment de cycles de processeur en arrière-plan pour suivre le rythme d'expiration des clés. |
redis.googleapis.com/cluster/node/stats/expired_time_cap_reached_count
|
Cette métrique mesure le nombre cumulé de cycles qui ont atteint la limite de temps au cours d'un intervalle. Une valeur élevée ou croissante pour cette métrique est souvent corrélée à une utilisation élevée de la mémoire par les clés expirées. Pour maintenir l'intégrité de l'ensemble de données, il peut être nécessaire d'utiliser davantage de cycles de processeur en arrière-plan. |
redis.googleapis.com/cluster/node/stats/pubsub_channels
|
Cette métrique indique le nombre global de canaux Pub/Sub disposant d'abonnements client. |
redis.googleapis.com/cluster/node/stats/pubsub_patterns
|
Cette métrique indique le nombre global de formats Pub/Sub disposant d'abonnements client. |
redis.googleapis.com/cluster/node/stats/pubsubshard_channels
|
Cette métrique indique le nombre global de canaux de partition Pub/Sub disposant d'abonnements client. |
redis.googleapis.com/cluster/node/stats/total_fork_count
|
Cette métrique mesure la variation du nombre total de forks au cours d'un intervalle. Cette métrique est un indicateur clé de l'activité en arrière-plan de Memorystore for Redis Cluster. Vous pouvez utiliser cette métrique pour surveiller la fréquence des forks pour la planification de la capacité, car chaque processus de fork implique de la mémoire COW. La mémoire COW augmente l'espace mémoire utilisé global d'un nœud de cluster. |
redis.googleapis.com/cluster/node/stats/tracking_total_keys
|
Cette métrique indique le nombre de clés suivies par Memorystore pour Redis Cluster. Cette métrique fait partie de la fonctionnalité de suivi côté serveur, qui permet aux clients de conserver un cache local invalidé lorsque les clés changent dans Memorystore pour Redis Cluster. |
redis.googleapis.com/cluster/node/stats/tracking_total_items
|
Cette métrique indique le nombre total d'éléments suivis par Memorystore pour Redis Cluster. Cette métrique représente la somme de tous les clients qui regardent chaque clé. |
redis.googleapis.com/cluster/node/stats/tracking_total_prefixes
|
Cette métrique indique le nombre de préfixes suivis dans le tableau prefix de Memorystore pour Redis Cluster. |
redis.googleapis.com/cluster/node/stats/latest_fork_usec
|
Cette métrique indique la durée de la dernière opération de fork (en microsecondes). |
redis.googleapis.com/cluster/node/replication/primary_sync_in_progress
|
Cette métrique indique si un cluster principal se synchronise avec une réplique. La valeur Vous pouvez utiliser cette métrique pour résoudre les problèmes de cohérence des données et comprendre la progression des événements de scale-out ou de maintenance. |
redis.googleapis.com/cluster/node/replication/sync_partial_ok_count
|
Cette métrique mesure le nombre de tentatives de resynchronisation partielle réussies. |
redis.googleapis.com/cluster/node/replication/sync_partial_err_count
|
Cette métrique mesure le nombre de tentatives de resynchronisation partielle ayant échoué. Vous pouvez utiliser la métrique comme indicateur de l'état de la réplication. Lorsqu'une resynchronisation partielle échoue, le réplica doit effectuer une resynchronisation complète. Cela implique de créer un instantané RDB sur le cluster principal et de transférer l'ensemble de l'ensemble de données sur le réseau. |
redis.googleapis.com/cluster/node/replication/sync_full_count
|
Cette métrique mesure la variation du nombre de resynchronisations complètes qu'un cluster principal effectue avec une réplique. Une resynchronisation complète se produit lorsqu'une resynchronisation partielle échoue. Cela se produit lorsque le backlog de réplication sur le cluster principal n'est pas assez important pour contenir les données que le réplica a manquées lors d'une déconnexion. Vous pouvez utiliser cette métrique pour diagnostiquer les problèmes d'état et de capacité de réplication du cluster. |
redis.googleapis.com/cluster/node/memory/maxmemory |
Cette métrique reflète le paramètre de configuration Vous pouvez utiliser cette métrique pour planifier la capacité et résoudre les problèmes de mémoire insuffisante (OOM, Out Of Memory), car elle définit la limite supérieure de l'utilisation de la mémoire pour le stockage des données et la surcharge du serveur. Pour en savoir plus sur les paramètres |
Métriques de réplication interrégionale
Cette section liste et décrit les métriques de la réplication interrégionale.
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/cross_cluster_replication/secondary_replication_links
|
Cette métrique indique le nombre de liens de partitionnement entre les clusters principal et secondaire. Dans un groupe de réplication multirégion, un cluster principal indique le nombre de liens de réplication CRR qu'il possède avec les clusters secondaires du groupe. Pour chaque cluster secondaire, ce nombre doit être égal au nombre de partitions. Si, de manière inattendue, le nombre tombe en dessous du nombre de partitions, cela identifie le nombre de partitions où la réplication entre le réplicateur et le répliqué a cessé. Dans un état idéal, cette métrique devrait avoir le même nombre que le nombre de partitions du cluster principal. |
redis.googleapis.com/cluster/cross_cluster_replication/secondary_maximum_replication_offset_diff |
Cette métrique mesure la différence maximale de décalage de réplication (en octets) entre les shards principaux et secondaires (répliqués) d'un cluster dans différentes régions. |
redis.googleapis.com/cluster/cross_cluster_replication/secondary_average_replication_offset_diff |
Cette métrique mesure la différence moyenne de décalage de réplication (en octets) entre les shards principaux et répliqués d'un cluster dans différentes régions. Des valeurs élevées pour cette métrique indiquent un décalage de réplication, que vous pouvez résoudre en mettant en pause la réplication, puis en la reprenant. |
Métriques JSON
Cette section liste les métriques au niveau des nœuds pour les documents JSON.
Métriques au niveau des nœuds
Ces métriques fournissent des informations détaillées sur le nombre total de documents JSON et la quantité de mémoire qu'ils consomment.
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/node/json/documents_count
|
Cette métrique mesure le nombre total de documents JSON situés sur un nœud de cluster. Vous pouvez utiliser cette métrique pour suivre la distribution et la capacité des données, car elle indique le nombre de documents indexés, supprimés ou fusionnés au niveau du nœud. |
redis.googleapis.com/cluster/node/json/used_memory
|
Cette métrique mesure la quantité de mémoire (en octets ou en pourcentage de la mémoire disponible) consommée par les documents JSON. Vous pouvez utiliser cette métrique pour surveiller la capacité, identifier les nœuds liés à la mémoire et déclencher des actions de scaling. |
Métriques de persistance
Cette section liste et décrit les métriques de persistance.
Métriques de persistance RDB
Cette section liste et décrit les métriques de persistance RDB.
Métriques au niveau du cluster
Cette section liste et décrit les métriques de persistance RDB au niveau du cluster.
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/persistence/rdb_saves_count |
Cette métrique suit le nombre cumulé de fois qu'un instantané de persistance RDB (également appelé enregistrement RDB) est effectué sur un nœud de cluster. Vous pouvez utiliser cette métrique pour surveiller la fréquence et le succès des instantanés RDB pour chaque nœud. La métrique comporte un champ |
redis.googleapis.com/cluster/persistence/rdb_save_ages |
Cette métrique indique l'ancienneté d'un instantané de distribution pour tous les nœuds d'un cluster. En cas d'incident de récupération, vous pouvez utiliser la métrique pour afficher le délai d'obsolescence des données. Dans l'idéal, la distribution doit comporter des valeurs dont le temps de latence est inférieur (ou égal) à la fréquence des instantanés. |
Métriques au niveau des nœuds
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/node/persistence/rdb_bgsave_in_progress
|
Cette métrique indique si un enregistrement RDB en arrière-plan (BGSAVE) est actif sur un nœud de cluster. L'état TRUE signifie que BGSAVE est actif. |
redis.googleapis.com/cluster/node/persistence/rdb_last_bgsave_status
|
Cette métrique indique si l'opération BGSAVE sur un nœud de cluster s'est terminée ou a rencontré une erreur. L'état TRUE signifie que l'opération est terminée. |
redis.googleapis.com/cluster/node/persistence/rdb_saves_count
|
Cette métrique suit le nombre cumulé d'instantanés RDB créés sur un nœud de cluster. Vous pouvez utiliser cette métrique pour surveiller la fréquence et la réussite des instantanés sur le nœud. |
redis.googleapis.com/cluster/node/persistence/rdb_last_save_age
|
Cette métrique mesure le temps, en secondes, écoulé depuis le dernier instantané RDB réussi. Vous pouvez utiliser cette métrique pour surveiller la fraîcheur des données de persistance RDB sur un nœud de cluster. |
redis.googleapis.com/cluster/node/persistence/rdb_next_save_time_until
|
Cette métrique mesure le temps restant, en secondes, avant la prochaine planification d'un instantané RDB sur un nœud de cluster. Vous pouvez l'utiliser pour surveiller la planification de la persistance RDB et suivre le moment où le prochain instantané automatique est pris. |
redis.googleapis.com/cluster/node/persistence/current_save_keys_total
|
Cette métrique suit le nombre total de clés traitées lors de l'opération d'enregistrement RDB en cours sur un nœud de cluster. |
Métriques de persistance de l'AOF
Cette section liste et décrit les métriques de persistance AOF.
Métriques au niveau du cluster
Cette section liste et décrit les métriques de persistance AOF au niveau du cluster.
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/persistence/aof_fsync_lags
|
Cette métrique mesure la différence de temps (ou le décalage) pour tous les nœuds d'un cluster qui s'écoule entre l'écriture des données dans l'AOF et la synchronisation réussie de ces données dans un stockage durable. Lorsque le paramètre |
redis.googleapis.com/cluster/persistence/aof_rewrite_count
|
Cette métrique suit le nombre cumulé de fois où un nœud de cluster déclenche une opération de réécriture AOF. Vous pouvez utiliser cette métrique pour diagnostiquer les problèmes de performances, car une fréquence élevée de réécritures AOF peut entraîner des pics de latence ou une pression sur la mémoire du cluster. La métrique comporte un champ |
Métriques au niveau des nœuds
Cette section liste et décrit les métriques de persistance AOF au niveau des nœuds.
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/node/persistence/aof_last_write_status
|
Cette métrique indique l'état de la dernière opération d'écriture dans le fichier AOF sur un nœud de cluster. Si l'état est TRUE, l'opération d'écriture a réussi. Vous pouvez utiliser cette métrique pour vérifier que Memorystore pour Redis Cluster conserve bien les données.
|
redis.googleapis.com/cluster/node/persistence/aof_last_bgrewrite_status
|
Cette métrique indique l'état de la dernière opération AOF bgrewrite sur un nœud de cluster. Si l'état est TRUE, l'opération a réussi. |
redis.googleapis.com/cluster/node/persistence/aof_fsync_lag
|
Cette métrique mesure la différence de temps (ou le décalage) pour un nœud de cluster qui s'écoule entre l'écriture des données dans l'AOF et la synchronisation réussie de ces données dans le stockage durable. Lorsque le paramètre |
redis.googleapis.com/cluster/node/persistence/aof_rewrites_count
|
Cette métrique suit le nombre cumulé de fois où un nœud de cluster déclenche une opération de réécriture AOF. Vous pouvez utiliser cette métrique pour diagnostiquer les problèmes de performances. Des réécritures AOF fréquentes peuvent entraîner une augmentation de la latence ou une saturation de la mémoire sur le cluster. La métrique comporte un champ |
redis.googleapis.com/cluster/node/persistence/aof_fsync_errors_count
|
Cette métrique suit le nombre cumulé d'échecs de l'appel système fsync() AOF sur un nœud de cluster. Cette métrique ne s'applique qu'aux clusters pour lesquels le paramètre appendfsync est défini sur everysec ou always.
|
Métriques de persistance courantes
Cette section liste et décrit les métriques applicables à la persistance AOF et RDB.
Métriques au niveau des nœuds
Cette section liste et décrit les métriques de persistance AOF et RDB au niveau des nœuds.
| Nom de la métrique | Description |
|---|---|
redis.googleapis.com/cluster/node/persistence/auto_restore_count
|
Cette métrique permet de suivre le nombre cumulé de fois où un nœud de cluster est restauré automatiquement à partir d'un fichier de dump de persistance (AOF ou RDB). La métrique comporte un champ |
Exemples de cas d'utilisation pour les métriques de persistance
Cette section décrit des exemples de cas d'utilisation pour les métriques de persistance AOF et RDB.
Vérifier si les opérations d'écriture AOF entraînent une latence et une pression sur la mémoire
Supposons que vous détectiez une augmentation de la latence ou de l'utilisation de la mémoire sur un cluster ou un nœud du cluster. Dans ce cas, vérifiez si l'utilisation supplémentaire est liée à la persistance AOF.
Les opérations de réécriture AOF peuvent déclencher des pics de charge transitoires. Nous vous recommandons d'inspecter la métrique aof_rewrites_count, car elle fournit le nombre cumulé de réécritures AOF au cours de la durée de vie du cluster ou du nœud de cluster.
Supposons que cette métrique montre que les incréments du nombre de réécritures correspondent à des augmentations de la latence. Pour réduire la fréquence des réécritures, réduisez le taux d'écriture ou augmentez le nombre de segments.
Vérifier si les opérations d'enregistrement RDB entraînent une latence et une pression sur la mémoire
Supposons que vous détectiez une augmentation de la latence ou de l'utilisation de la mémoire sur un cluster ou un nœud du cluster. Dans ce cas, vérifiez si l'utilisation supplémentaire est liée à la persistance RDB.
Les opérations d'enregistrement RDB peuvent déclencher des pics de charge transitoires. Nous vous recommandons d'inspecter la métrique rdb_saves_count, car elle fournit le nombre cumulé d'enregistrements RDB sur la durée de vie du cluster ou du nœud de cluster.
Supposons que cette métrique montre que les incréments du nombre d'enregistrements RDB correspondent à des augmentations de la latence. Pour réduire la fréquence des enregistrements RDB, augmentez l'intervalle des instantanés RDB. Pour réduire les niveaux de charge de référence, effectuer un scaling horizontal du cluster.
Interpréter les métriques pour Memorystore for Redis Cluster
De nombreuses métriques appartiennent aux catégories suivantes : moyenne, maximum et total.
Nous fournissons des variations moyennes et maximales de la même métrique afin que vous puissiez utiliser les deux métriques pour identifier les points chauds de cette famille de métriques.
La valeur totale de la métrique est indépendante des variations moyenne et maximale de la métrique. Cette valeur fournit des insights distincts et sans rapport avec l'objectif des variations pour les points chauds.
Comprendre les métriques moyennes et maximales
Supposons que vous compariez les valeurs des métriques average_keyspace_hits et maximum_keyspace_hits pour un cluster. Plus la différence entre les deux métriques est importante, plus le cluster comporte de points chauds pour les résultats. Si les valeurs des métriques sont proches, cela signifie que les accès sont répartis de manière plus uniforme entre les nœuds du cluster.
Ce principe s'applique à toutes les métriques qui présentent les variantes moyenne et maximum de la même métrique.
Exemple de zone cliquable
Si vous comparez les valeurs des métriques average_keyspace_hits et maximum_keyspace_hits pour tous les shards d'un cluster, vous pouvez déterminer dans quels shards se trouvent les points chauds. Par exemple, supposons que les fragments d'un cluster de six fragments présentent le nombre de résultats suivants :
- Segment 1 : deux hits
- Segment 2 : deux résultats
- Segment 3 : deux résultats
- Segment 4 : deux résultats
- Segment 5 – 2 résultats
- Partition 6 – 8 hits
Dans cet exemple, la métrique average_keyspace_hits renvoie une valeur de 3, mais la métrique maximum_keyspace_hits renvoie une valeur de 8. Les résultats ne sont pas répartis de manière uniforme entre les shards du cluster. Le shard 6 est un point chaud, car il gère un volume de trafic disproportionnellement élevé.