Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
L’accélérateur distribué pour stockage cloud (DACS) expose des métriques au format Prometheus provenant de chaque serveur de cache. Utilisez ces métriques pour surveiller les connexions, la capacité de cache, la latence et le volume des requêtes, les tailles des requêtes et la pression réseau du système d’exploitation.
Important
DACS ne s'intègre pas actuellement au service géré Azure Monitor pour Prometheus. Azure Container Storage ne configure pas automatiquement une cible de scraping pour les DACS. Vous devez configurer votre pipeline de métriques pour scraper le point d’accès Prometheus de chaque serveur de cache.
Point de terminaison de métriques
Avant de commencer, installez le DACS et attendez que les pods du serveur cache soient prêts. Remplacez <cache-namespace> dans les commandes et la configuration par l’espace de noms contenant ces pods.
Chaque pod de serveur cache expose des métriques sur le port 9096 au niveau du /metrics chemin. Scruter chaque pod de serveur de cache afin que votre système de surveillance capture l’état et les compteurs par serveur.
Listez les pods de serveur cache et confirmez le port métrique :
kubectl get pods \
--namespace <cache-namespace> \
--selector app=cacheserver \
--output wide
kubectl get pods \
--namespace <cache-namespace> \
--selector app=cacheserver \
-o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{range .spec.containers[*].ports[*]}{.containerPort}{" "}{end}{"\n"}{end}'
Vérifiez un point de terminaison localement :
CACHE_POD=$(kubectl get pods \
--namespace <cache-namespace> \
--selector app=cacheserver \
-o jsonpath='{.items[0].metadata.name}')
kubectl port-forward \
--namespace <cache-namespace> \
pod/$CACHE_POD \
9096:9096
Dans un autre terminal, récupérez les métriques suivantes :
curl --fail --silent --show-error http://localhost:9096/metrics
Arrêtez la commande de redirection de port une fois que vous avez vérifié le point de terminaison.
Configurez votre pipeline de métriques
Configurez votre collecteur compatible Prometheus pour découvrir les pods de serveur cache dans l’espace de noms DACS et scraper le port 9096 à /metrics. Le collecteur a besoin d’un accès réseau aux adresses IP du pod sur le port 9096 et d’un accès authentifié à l’API Kubernetes. Accordez à son identité get, list et watch les autorisations pour les pods dans l’espace de noms DACS. Pour un collecteur intégré au cluster, liez un rôle avec ces permissions à son compte de service.
La configuration Prometheus suivante est un exemple de collecteur intra-cluster. Cela limite la découverte Kubernetes à l’espace de noms DACS. Remplacez <cache-namespace> par votre espace de noms.
scrape_configs:
- job_name: dacs-cache-server
scrape_interval: 30s
metrics_path: /metrics
kubernetes_sd_configs:
- role: pod
namespaces:
names:
- <cache-namespace>
relabel_configs:
- source_labels: [__meta_kubernetes_namespace]
action: keep
regex: <cache-namespace>
- source_labels: [__meta_kubernetes_pod_label_app]
action: keep
regex: cacheserver
- source_labels: [__meta_kubernetes_pod_phase]
action: keep
regex: Running
- source_labels: [__meta_kubernetes_pod_container_port_number]
action: keep
regex: "9096"
- source_labels: [__meta_kubernetes_pod_name]
target_label: pod
- source_labels: [__meta_kubernetes_namespace]
target_label: namespace
Si votre pipeline utilise un opérateur Prometheus, créez une ressource PodMonitor ou équivalente qui sélectionne app=cacheserver, l’espace de noms DACS et le port de métriques. Utilisez les étiquettes et les noms de port de votre version preview installée.
Après avoir configuré le scraping, vérifiez que votre système de métriques a une cible active pour chaque pod de serveur cache. Conservez les podétiquettes , instance, et namespace afin de pouvoir identifier un seul serveur cache malsain ou saturé.
Informations de référence sur les métriques
Un serveur de cache expose les familles de métriques suivantes :
| Famille métrique | Catégorie | Signification |
|---|---|---|
cache_server_active_connections |
Jauge | Nombre de connexions actives. Pour TCP, cette métrique suit les connexions tout en traitant les requêtes, pas tous les sockets inactifs établis. |
cache_server_cache_size_bytes |
Jauge | La taille des données mises en cache en octets, pas la capacité de cache configurée. |
cache_server_listen_backlog_max |
Jauge | Le backlog d’écoute configuré est transmis à listen(). |
cache_server_accept_queue_overflows_total |
Compteur | Nombre total de débordements de la file d’acceptation depuis TcpExt.ListenOverflows. |
cache_server_listen_drops_total |
Compteur | Chute totale des écoutes depuis TcpExt.ListenDrops. |
cache_server_syn_queue_full_drops_total |
Compteur | Nombre total de pertes de la file de requêtes SYN à partir de TcpExt.TCPReqQFullDrop. |
cache_server_syn_cookies_sent_total |
Compteur | Total des cookies SYN envoyés depuis TcpExt.TCPReqQFullDoCookies. |
cache_server_passive_opens_total |
Compteur | Total PassiveOpens de Tcp.PassiveOpens à nstat. |
cache_server_open_fds |
Jauge | Les handles de fichiers alloués à l’échelle du système depuis /proc/sys/fs/file-nr ; et non les descripteurs de fichiers ouverts par processus. |
cache_server_accept_errors_total |
Compteur | Nombre total d’erreurs accept(), étiquetées selon la valeur errno. Une série est créée lorsqu’une erreur survient ; elle peut être absente sur un serveur en bonne santé. |
cache_server_successful_request_latency_ms |
Histogramme | Latence des requêtes réussies en millisecondes. |
cache_server_request_counter |
Compteur | Nombre de requêtes. |
cache_server_download_request_size_bytes |
Histogramme | Taille des demandes de téléchargement. |
cache_server_upload_request_size_bytes |
Histogramme | Taille des requêtes d’envoi. |
Les familles de métriques histogrammes exposent les séries temporelles standard _bucket, _sum et _count. Les valeurs de compteur se réinitialisent lorsqu’un processus serveur de cache redémarre. Utilisez rate() ou increase() plutôt que comparer les valeurs brutes des compteurs entre les redémarrages.
Utilisez les noms métriques exposés par votre version preview installée, y compris cache_server_request_counter et l’unité _ms de latence. Les outils de vérification de la convention de nommage de Prometheus peuvent signaler ces noms, même si Prometheus peut les collecter et les interroger.
Exemples de requêtes PromQL
Les exemples suivants supposent que votre pipeline de métriques préserve les étiquettes namespace et pod. Pour un espace de travail de métriques partagé, attachez également une étiquette unique cluster aux échantillons de chaque cluster. Les agrégations conservent les trois étiquettes afin que les pods au nom identique ne soient pas combinés entre espaces de noms ou clusters. Si votre collecteur utilise une étiquette de cluster différente, utilisez ce nom à la place. Sans étiquette de cluster, utilisez une source de données limitée à un seul cluster.
Laissez au moins deux raclages avant d’évaluer rate() ou increase(). Sur un serveur inactif, le quantile de latence et la taille moyenne de la requête peuvent renvoyer NaN car aucune requête n’a été observée dans la fenêtre de requête. Cette condition ne signifie pas en soi un échec du scraping. Vérifiez séparément la métrique de la cible up.
Connexions actives par serveur de cache
cache_server_active_connections
Débit de requêtes par serveur de cache
sum by (cluster, namespace, pod) (rate(cache_server_request_counter[5m]))
Dans la version 0.1.0, cache_server_request_counter inclut request_type et status labels. Incluez ces labels dans l’agrégation pour séparer les téléversements, les téléchargements et les échecs. Vérifiez les libellés affichés par votre version installée.
Téléchargements réussis à travers un cache
Pour vérifier l’activité de téléchargement du serveur cache lors de lectures répétées, filtrez les requêtes de téléchargement réussies et agrégez-les sur tous les pods de serveurs appartenant à la ressource Cache sélectionnée :
sum by (cluster, namespace) (
increase(cache_server_request_counter{
cluster="<cluster>",
namespace="<cache-namespace>",
pod=~"<cache-server-pod-regex>",
request_type="Download",
status="Success"
}[5m])
)
Remplacez les espaces réservés cluster, namespace et pod-regex. Faites correspondre uniquement les pods de serveurs appartenant à votre ressource Cache, pas les autres caches dans un espace de noms partagé. Pour une source de données à cluster unique sans étiquette cluster, omettez ce sélecteur. Les valeurs des étiquettes Download et Success sont sensibles à la casse.
Enregistrez une valeur de référence avant les relevés et autorisez au moins deux raclages.
increase() Estime l’activité sur la fenêtre et prend en compte les réinitialisations des compteurs ; ce n’est pas une différence exacte de compteur brut. Une série absente n’est pas une preuve d’activité nulle. Vérifiez l’état du scraping et les labels exposés avant d’interpréter le résultat.
Corréliez cette augmentation avec les métriques de réussite du cache client et isolez le trafic non lié lors de la validation. Ce compteur n’est pas un ratio cache-hit, et une lecture de l’application, à elle seule, réussie ou plus rapide ne prouve pas l’utilisation du cache. La population est asynchrone, donc les lectures répétées immédiates peuvent encore ne rien renvoyer. Voir « Vérifier le chemin de requête DACS ».
Latence de la requête réussie P95 (millisecondes)
histogram_quantile(
0.95,
sum by (le, cluster, namespace, pod) (
rate(cache_server_successful_request_latency_ms_bucket[5m])
)
)
Taille moyenne des demandes de téléchargement
sum by (cluster, namespace, pod) (rate(cache_server_download_request_size_bytes_sum[5m]))
/
sum by (cluster, namespace, pod) (rate(cache_server_download_request_size_bytes_count[5m]))
Débordements de file d’attente
sum by (cluster, namespace, pod) (increase(cache_server_accept_queue_overflows_total[5m]))
Listen et pertes de la file SYN
sum by (cluster, namespace, pod) (
increase(cache_server_listen_drops_total[5m])
+ increase(cache_server_syn_queue_full_drops_total[5m])
)
Alertes recommandées
Créez des alertes qui reflètent le niveau de référence de votre charge de travail et la taille de votre VM serveur de cache. Au minimum, considérez les alertes pour :
- Une cible de scraping DACS qui est hors de ligne ou manquante.
- Augmentations non nulles soutenues
cache_server_accept_queue_overflows_total. - Augmentations soutenues non nulles de
cache_server_listen_drops_totalou decache_server_syn_queue_full_drops_total. - Augmentations de
cache_server_accept_errors_total, regroupées parerrno. - P95 ou P99 : latence des requêtes réussies supérieure à l’objectif de charge de travail.
- Des connexions actives approchant la capacité testée pour cette taille de VM de serveur de cache.
- Changements inattendus de taille de cache ou déséquilibre entre les pods de serveurs de cache.
- Nombre anormalement élevé de descripteurs de fichiers alloués à l’échelle du système N’oubliez pas que
cache_server_open_fdsn’est pas un nombre de descripteurs de fichier par processus.
Établir une base de référence dans des conditions de concurrence attendues avant de fixer des seuils fixes. Corrélez les métriques de pression réseau avec le taux de requête, la taille de la requête, la latence, le CPU du nœud, la mémoire du nœud et les métriques de requêtes et d’octets de Blob Azure.