Métriques Prometheus : surveillez les performances de votre application
Métriques Prometheus : surveillez les performances de votre application
Qu’est-ce que Prometheus ?
Prometheus est un outil open source qui suit les performances et l’état de santé des systèmes logiciels. Il collecte des points de données, appelés métriques, qui donnent des informations sur le bon fonctionnement d’un système. Ces métriques aident à détecter les problèmes tôt et à analyser le comportement du système. Avec Prometheus, les équipes peuvent repérer les problèmes avant qu’ils n’aient un impact sur les utilisateurs afin de maintenir des services fiables et efficaces.
Que sont les métriques dans Prometheus ?
Dans Prometheus, les métriques sont des valeurs numériques qui suivent des aspects spécifiques du comportement et des performances d’un système au fil du temps. Ces métriques aident à comprendre dans quelle mesure un système fonctionne dans diverses conditions et fournissent également des alertes dans des conditions qui pourraient indiquer des problèmes, comme un pic soudain de trafic ou une baisse des performances du système. Elles peuvent surveiller un large éventail de données, du nombre d’utilisateurs actifs sur un site Web à la quantité de mémoire qu’une application utilise.
Format des métriques dans Prometheus
Les métriques dans Prometheus sont stockées dans un format de série temporelle, chaque métrique étant identifiée par son nom et des paires clé-valeur facultatives appelées labels, qui fournissent un contexte supplémentaire comme les noms de services ou les types d’erreurs. Le format principal des données de métriques dans Prometheus est le Prometheus Exposition Format. Ce format en texte brut est facile à générer et à analyser, composé de lignes de données qui incluent le nom de la métrique, des labels facultatifs, la valeur de la métrique et un horodatage.
Les quatre types de métriques dans Prometheus
Prometheus classe les métriques en quatre types principaux : compteurs, jauges, histogrammes et résumés. Chaque type remplit une fonction spécifique dans la surveillance et fournit des informations différentes sur le comportement de vos systèmes.
Métriques de compteur
Les métriques de compteur dans Prometheus enregistrent le nombre de fois qu’un événement particulier se produit. Elles ne font qu’augmenter au fil du temps ou se réinitialisent à zéro lorsque le processus redémarre. Par conséquent, elles sont utilisées pour suivre des quantités cumulatives comme le nombre de requêtes traitées, de tâches terminées ou d’erreurs journalisées.
Pour implémenter un compteur qui suit le nombre de requêtes reçues par un serveur, vous pouvez utiliser l’extrait de code suivant. Cet exemple configure un compteur pour surveiller le nombre total de requêtes HTTP reçues. Chaque fois que la fonction handle_request est appelée, le compteur est incrémenté.
from prometheus_client import Counter
# Create a counter metric for tracking received requests
request_counter = Counter('http_requests_received_total', 'Total HTTP requests received')
def handle_request(request):
# Process the request
# ...
# Increment the counter by 1 each time this function is called
request_counter.inc()
Bonnes pratiques pour l’utilisation des compteurs
Sensibilisation aux réinitialisations : Sachez que les compteurs se réinitialisent à zéro lorsque le processus redémarre. Concevez votre surveillance pour tenir compte de ces réinitialisations.
Utiliser des labels : Utilisez des labels avec les compteurs pour fournir des informations plus détaillées, comme distinguer les différents types d’erreurs ou de requêtes.
Incrémentation cohérente : Assurez-vous que le compteur est incrémenté au bon endroit dans votre code afin de refléter avec précision les événements que vous suivez.
Surveillance des réinitialisations : Utilisez la fonction rate dans les requêtes pour calculer le taux moyen d’augmentation par seconde d’un compteur, ce qui peut vous aider à comprendre les tendances et à détecter les problèmes, même avec des réinitialisations.
Métriques de jauge
Les métriques de jauge dans Prometheus mesurent des valeurs qui peuvent augmenter et diminuer, comme les températures du CPU, le nombre actuel de processus en cours d’exécution ou les quantités de mémoire libre. Contrairement aux compteurs, qui ne font qu’augmenter, les jauges reflètent l’état actuel du système à un moment précis, ce qui les rend essentielles pour suivre les métriques fluctuantes.
Pour implémenter une jauge qui surveille la quantité de mémoire libre dans un système, vous pouvez utiliser l’extrait de code suivant. Cet exemple configure une jauge pour surveiller la mémoire libre, en mettant à jour la valeur de la jauge en appelant la fonction update_free_memory(), qui doit être déclenchée pour refléter les changements du système.
from prometheus_client import Gauge
# Create a gauge metric to track free memory
free_memory_gauge = Gauge('system_free_memory_bytes', 'Amount of free memory in bytes')
def update_free_memory():
# Assume get_free_memory() is a function that fetches the current free memory
free_memory = get_free_memory()
free_memory_gauge.set(free_memory)
# Update gauge regularly or upon specific system events
update_free_memory()
Conseils pour utiliser les jauges
Mises à jour régulières : Vérifiez que les jauges sont mises à jour régulièrement afin de refléter avec précision l’état actuel du système.
Utilisation contextuelle : Utilisez les jauges pour les métriques qui nécessitent de suivre les hausses et les baisses au fil du temps, comme les moyennes de charge ou les ressources système disponibles.
Éviter les mauvais usages : Veillez à ne pas utiliser les jauges pour des métriques qui ne devraient qu’augmenter ou diminuer, lorsqu’un compteur ou un histogramme serait plus approprié.
Métriques d’histogramme
Les histogrammes dans Prometheus résument la distribution de données numériques sur un ensemble de compartiments prédéfinis. Chaque compartiment représente une plage de valeurs, et l’histogramme compte le nombre de valeurs qui tombent dans chaque compartiment. Ce type de métrique est utile pour suivre des mesures comme les latences des requêtes ou les tailles de réponse, où comprendre la distribution peut fournir plus d’informations que de simplement connaître la moyenne.
Pour implémenter un histogramme qui suit la latence des requêtes HTTP, vous pouvez utiliser l’extrait de code suivant. Cet exemple configure un histogramme avec plusieurs compartiments pour mesurer le temps nécessaire au traitement de chaque requête HTTP. Le bloc with mesure automatiquement la durée du traitement de la requête et l’enregistre dans le compartiment approprié.
from prometheus_client import Histogram
# Define a histogram with buckets for request latency
request_latency_histogram = Histogram('http_request_latency_seconds', 'HTTP request latencies', buckets=[0.1, 0.2, 0.5, 1, 2, 5])
def handle_request(request):
with request_latency_histogram.time():
# Process the request
# This automatically measures the time taken by this block and records it in the histogram
pass
Compartiments d’histogramme et leur importance
Conception des compartiments : Choisir les bons compartiments est crucial pour obtenir des histogrammes utiles. Les compartiments doivent être alignés sur les objectifs et les seuils de performance de votre application. Par exemple, si vous voulez distinguer les requêtes qui prennent 0,1 seconde de celles qui prennent 1 seconde, vos compartiments doivent refléter ces intervalles.
Granularité : Un plus grand nombre de compartiments augmente la granularité de l’histogramme, mais augmente également l’utilisation de la mémoire. Équilibrez le niveau de détail avec l’efficacité des ressources.
Comptage cumulatif : Les histogrammes de Prometheus sont cumulatifs. Cela signifie que chaque compartiment compte le nombre total d’observations qui tombent dans sa plage et dans toutes les plages précédentes. Cela permet de calculer des percentiles, qui sont plus informatifs sur la distribution des données que les moyennes.
Utilisation dans les requêtes : Lors de l’interrogation des histogrammes, des fonctions comme histogram
_quantile()peuvent calculer des quantiles à partir des compartiments cumulatifs, offrant des informations puissantes sur les caractéristiques de performance de votre système.
Métriques de résumé
Les métriques de résumé dans Prometheus offrent un moyen de calculer les quantiles des observations, comme le 90e percentile des latences de requête, directement dans le client. Contrairement aux histogrammes, qui collectent et classent les données dans des compartiments, les résumés calculent des quantiles en flux continu sans compartiments prédéfinis. Cela rend les résumés idéaux pour les situations où des calculs précis de quantiles sont nécessaires, en particulier lorsque des seuils exacts sont importants, comme dans les rapports sur les accords de niveau de service (SLA).
Pour implémenter un résumé qui mesure la latence des requêtes de base de données, vous pouvez utiliser l’extrait de code suivant. Cet exemple configure un résumé pour surveiller le temps que prennent les requêtes de base de données. Le bloc with mesure la durée de la requête et met à jour le résumé avec cette nouvelle observation, facilitant le calcul des quantiles.
from prometheus_client import Summary
# Create a summary to measure database query latencies
db_query_latency = Summary('db_query_latency_seconds', 'Database query latencies')
def query_database(query):
with db_query_latency.time():
# Execute the database query
# The time taken by this block is automatically recorded and calculated in the summary
pass
Différence entre les histogrammes et les résumés
Calcul des quantiles : Les histogrammes estiment les quantiles en fonction des buckets définis, ce qui peut introduire des imprécisions selon la configuration des buckets. Les résumés calculent les quantiles directement à partir des données observées, offrant potentiellement plus de précision.
Charge côté client : Les résumés calculent les quantiles côté client, ce qui peut augmenter la charge de calcul, en particulier avec un grand nombre d’observations. Les histogrammes, avec leurs buckets prédéfinis, peuvent réduire le calcul côté client.
Configuration : Les histogrammes nécessitent une connaissance préalable de la distribution pour définir des buckets appropriés. Les résumés ne nécessitent pas de configuration de buckets, ce qui les rend plus faciles à déployer initialement, mais potentiellement plus gourmands en ressources.
Cas d’utilisation : Les résumés sont préférés lorsque des quantiles précis en temps réel sont nécessaires pour des métriques critiques, tandis que les histogrammes sont souvent mieux adaptés pour capturer la distribution plus large d’une métrique lorsque les seuils exacts sont moins critiques.
Bonnes pratiques pour l’étiquetage et le regroupement des métriques
Utilisation appropriée des étiquettes
Les étiquettes dans Prometheus sont des paires clé-valeur qui attachent des métadonnées aux métriques pour des requêtes plus détaillées et ciblées. Elles sont importantes pour organiser et identifier les métriques selon des dimensions telles que les noms de services, les noms d’hôtes ou les types d’erreurs. Voici quelques bonnes pratiques pour utiliser les étiquettes :
Descriptives et cohérentes : Choisissez des noms d’étiquettes qui décrivent clairement leur objectif et maintenez une cohérence entre vos métriques. Par exemple, utilisez service pour toutes les métriques qui identifient le service auquel elles appartiennent.
Granularité nécessaire : Bien que les étiquettes puissent ajouter des détails importants à vos métriques, un trop grand nombre d’étiquettes peut augmenter les coûts de stockage et diminuer les performances des requêtes. Utilisez les étiquettes judicieusement afin d’équilibrer granularité et performance.
Éviter la forte cardinalité : Les étiquettes à forte cardinalité, comme celles qui pourraient étiqueter chaque utilisateur individuel ou adresse e-mail, peuvent augmenter la taille des données et dégrader les performances. Tenez-vous-en aux étiquettes qui ont un nombre raisonnable de valeurs distinctes.
Cet exemple montre un compteur qui utilise des étiquettes pour distinguer les différentes méthodes et statuts HTTP afin d’effectuer une analyse et une surveillance détaillées.
from prometheus_client import Counter
# Create a counter with labels for HTTP methods and response statuses
http_requests_total = Counter('http_requests_total', 'Total HTTP requests',
['method', 'status'])
def handle_request(request):
# Increment the counter with the appropriate labels
http_requests_total.labels(method=request.method, status=request.response.status_code).inc()
Stratégies de regroupement des métriques
Le regroupement logique des métriques peut améliorer la clarté et les performances des systèmes de surveillance. Voici quelques stratégies :
Catégoriser par type : Regroupez les métriques par type, comme les erreurs, le trafic, la latence, etc., afin de faciliter la recherche et l’analyse des métriques associées.
Regroupement basé sur les services : Organisez les métriques selon le service qu’elles mesurent. Cela aide à isoler rapidement les problèmes au sein d’un service spécifique.
Utiliser une nomenclature hiérarchique : Lors du nommage des métriques, envisagez une structure hiérarchique qui reflète leur regroupement, comme
service_database_queries_totalouservice_http_requests_total.
Avantages d’un regroupement efficace
Performances de requête améliorées : Un regroupement logique peut conduire à des requêtes plus efficaces en réduisant le nombre de métriques qui doivent être analysées pour chaque requête.
Gestion des alertes facilitée : Le regroupement de métriques similaires simplifie la création de règles d’alerte et facilite la gestion des alertes dans différentes parties de votre système.
Meilleure visualisation : Les métriques regroupées sont plus faciles à visualiser dans les tableaux de bord, car les métriques liées peuvent être affichées ensemble, offrant une vue cohérente des performances du système.
Interroger les métriques avec PromQL
Principes de base de PromQL et de sa syntaxe
PromQL, ou Prometheus Query Language, est le puissant langage de requête utilisé par Prometheus pour explorer les données et générer des alertes. PromQL permet d’effectuer des requêtes simples et complexes pour calculer les données exactes nécessaires à partir de vos métriques. La syntaxe de PromQL prend en charge la sélection et l’agrégation de données de séries temporelles en fonction des noms de métriques, des libellés et des intervalles de temps.
Fonctionnalités clés de PromQL :
Requêtes instantanées et de plage : Les requêtes instantanées donnent la valeur actuelle de la série temporelle pour un point précis dans le temps, tandis que les requêtes de plage renvoient les valeurs de la série temporelle pour une plage de temps.
Fonctions et opérateurs : PromQL comprend diverses fonctions et opérateurs intégrés pour calculer des taux, des moyennes et des opérations arithmétiques entre les métriques.
Extraits de code : requêtes courantes pour chaque type de métrique
Métriques de compteur
Cette requête calcule le taux moyen par seconde des requêtes HTTP au cours des 5 dernières minutes, utile pour surveiller la charge de trafic sur vos serveurs.
rate(http_requests_total[5m])
Métriques de jauge
Cette requête instantanée récupère la quantité actuelle de mémoire libre, fournissant un instantané des ressources système.
node_memory_MemFree_bytes
Métriques d’histogramme
La requête suivante calcule le 95e percentile des latences de requête au cours des 10 dernières minutes, ce qui aide à identifier les valeurs aberrantes dans les performances du serveur web.
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[10m]))
Métriques de résumé
La requête ci-dessous calcule la latence médiane des événements traités, ce qui est crucial pour évaluer les performances des systèmes de gestion d’événements.
quantile(0.5, rate(processed_events_latency_seconds_sum[5m]) / rate(processed_events_latency_seconds_count[5m]))
Conseils pour des requêtes efficaces avec PromQL :
Utiliser des plages de temps appropriées : Sélectionnez des plages de temps qui fournissent des informations significatives sans surcharger le système avec de longues requêtes de données historiques.
Exploiter le filtrage par libellés : Utilisez les libellés pour filtrer et affiner les résultats, en vous concentrant sur des sous-ensembles spécifiques de données.
Optimiser les performances : Lors de la rédaction de requêtes, en particulier pour les tableaux de bord ou les alertes, tenez compte de leur impact sur les performances et optimisez-les pour qu’elles s’exécutent efficacement.
Surveiller les performances de la base de données vectorielle Milvus avec Prometheus
Milvus est une base de données vectorielle open source, haute performance et hautement évolutive, capable de stocker, d’indexer et de rechercher des données non structurées à l’échelle du milliard grâce à des vector embeddings de haute dimension. Elle est parfaite pour créer des applications d’IA modernes telles que la génération augmentée par récupération (RAG), la recherche sémantique, la recherche multimodale et les systèmes de recommandation. Milvus fonctionne efficacement dans divers environnements, des ordinateurs portables et appareils périphériques aux systèmes distribués à grande échelle.
Prometheus offre des capacités complètes pour superviser les performances de la base de données vectorielle Milvus. Milvus s’intègre parfaitement à Prometheus grâce à :
Prometheus Endpoint : Collecte les données de divers exporters.
Prometheus Operator : Rationalise la gestion des configurations de monitoring Prometheus.
Kube-Prometheus : Simplifie le monitoring complet des clusters Kubernetes pour un fonctionnement robuste.
L’utilisation de Prometheus vous permet de suivre des métriques critiques des performances de Milvus, telles que les temps de réponse des requêtes et l’utilisation des ressources (CPU, GPU et mémoire), permettant ainsi une résolution proactive des problèmes et une optimisation du système. En outre, l’intégration de Prometheus avec Grafana renforce davantage votre cadre de monitoring, en fournissant des tableaux de bord détaillés pour une analyse approfondie et une maintenance efficace des déploiements Milvus adaptés aux applications GenAI et de recherche de similarité.
Pour des conseils complets sur la configuration de Prometheus pour Milvus et la visualisation des métriques avec Grafana, consultez les ressources ci-dessous :
Conclusion
En conclusion, Prometheus est un outil précieux pour surveiller diverses métriques qui reflètent l’état et les performances des systèmes. En utilisant les capacités de Prometheus pour suivre, analyser et visualiser les données opérationnelles critiques, les équipes peuvent améliorer leurs pratiques de monitoring et s’assurer que leurs systèmes sont non seulement stables, mais également optimisés pour l’efficacité. Que ce soit en configurant des alertes pour détecter précocement les problèmes potentiels ou en utilisant des tableaux de bord détaillés pour obtenir une vue claire des métriques système, Prometheus permet aux développeurs et aux administrateurs de maintenir des services performants et fiables.
FAQ
- Quels sont les quatre types de métriques dans Prometheus ?
Prometheus classe les métriques en quatre types : compteurs, jauges, histogrammes et résumés. Chaque type répond à un objectif de monitoring spécifique, du comptage des occurrences d’événements à la capture de la distribution des mesures au fil du temps.
- Comment choisir entre l’utilisation d’un histogramme et d’un résumé ?
Choisissez les histogrammes lorsque vous devez capturer des distributions et que vous êtes en mesure de définir à l’avance des buckets significatifs. Utilisez les résumés lorsque vous avez besoin de calculs de quantiles précis et que vous n’avez pas besoin de buckets prédéfinis. Le choix dépend de votre cas d’utilisation spécifique et de considérations de performance.
- Qu’est-ce que PromQL et comment est-il utilisé dans Prometheus ?
PromQL, ou Prometheus Query Language, est le langage puissant utilisé pour interroger les métriques dans Prometheus. Il permet aux utilisateurs de sélectionner et d’agréger des données de séries temporelles, d’effectuer des calculs et de tirer des enseignements des métriques en fonction de conditions et de plages temporelles spécifiques.
- Puis-je utiliser Prometheus pour surveiller des applications qui ne sont pas construites selon une architecture de microservices ?
Oui, Prometheus est suffisamment polyvalent pour surveiller un large éventail d’applications, qu’elles soient construites selon une architecture de microservices ou une approche monolithique plus traditionnelle. Il peut être configuré pour collecter des métriques à partir de presque n’importe quelle source qui expose des données au format Prometheus Exposition Format.
- Quelles sont les bonnes pratiques pour étiqueter et regrouper les métriques dans Prometheus ?
Lors de l’étiquetage et du regroupement des métriques, assurez-vous que les labels sont descriptifs et cohérents entre les métriques. Évitez les labels à forte cardinalité qui peuvent dégrader les performances. Regroupez les métriques de manière logique par type ou par service afin d’améliorer la clarté et l’efficacité des requêtes. Cela aide à maintenir un système de monitoring organisé, plus facile à interroger et à gérer.
Ressources supplémentaires
- Qu’est-ce que Prometheus ?
- Que sont les métriques dans Prometheus ?
- Format des métriques dans Prometheus
- Les quatre types de métriques dans Prometheus
- Bonnes pratiques pour l’étiquetage et le regroupement des métriques
- Interroger les métriques avec PromQL
- Surveiller les performances de la base de données vectorielle Milvus avec Prometheus
- Conclusion
- FAQ
- Ressources supplémentaires
Contenu
Commencez gratuitement, évoluez facilement
Essayez la base de données vectorielle entièrement managée conçue pour vos applications GenAI.
Essayer Zilliz Cloud gratuitement