0Pricing
Kubernetes Basics · Leçon

Métriques avec Prometheus et Grafana

Configurez Prometheus pour collecter les métriques du cluster et des applications, puis visualisez-les avec Grafana.

Métriques avec Prometheus et Grafana est une leçon Kubernetes Basics gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kubernetes Basics, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kubernetes Basics comprend 4 leçons au total.

La puissance des métriques

Les metrics sont des mesures numériques qui décrivent l’état et les performances de vos applications et de votre infrastructure. Considérez-les comme les signes vitaux de vos logiciels !

Elles fournissent des informations précieuses sur :

  • Les performances : à quelle vitesse votre application répond-elle ?
  • L’utilisation des ressources : votre serveur manque-t-il de mémoire ?
  • La disponibilité : votre service est-il actif et accessible aux utilisateurs ?

En suivant les metrics, vous pouvez comprendre les tendances, détecter les anomalies et résoudre les problèmes de manière proactive.

Découvrez Prometheus

Prometheus est un système de surveillance open source conçu pour être fiable et évolutif. C’est un outil essentiel de la pile d’observabilité cloud native.

Ses fonctions principales sont les suivantes :

  • Collecter : récupérer les metrics auprès de cibles configurées (comme vos applications).
  • Stocker : enregistrer ces metrics dans une base de données de séries temporelles.
  • Interroger : vous permettre de poser des questions sur les données collectées.

Prometheus vous aide à comprendre clairement ce qui se passe à l’intérieur de votre cluster Kubernetes.

Le modèle de « collecte » de Prometheus

Prometheus utilise un modèle de type « pull » pour collecter les metrics. Au lieu que les applications transmettent leurs données à Prometheus, Prometheus les « collecte » activement en les récupérant.

Voici le fonctionnement général :

  1. Votre application expose des metrics sur un point de terminaison HTTP précis (souvent /metrics).
  2. Prometheus est configuré avec une liste de cibles (comme l’adresse IP et le port de votre application).
  3. À intervalles réguliers, Prometheus envoie une requête HTTP au point de terminaison /metrics de chaque cible.
  4. La cible répond avec ses metrics actuelles, que Prometheus stocke ensuite.

Métriques : paires clé-valeur

Prometheus stocke les données sous forme de séries temporelles : des flux de valeurs horodatées. Chaque série temporelle est identifiée de manière unique par un nom de métrique et un ensemble de paires clé-valeur appelées étiquettes.

Exemple : http_requests_total{method="GET", path="/api"}

Prometheus propose les principaux types de métriques suivants :

  • Compteur : une métrique cumulative qui ne fait qu’augmenter (par exemple, le nombre total de requêtes).
  • Jauge : une valeur qui peut augmenter ou diminuer (par exemple, l’utilisation actuelle du CPU).
  • Histogramme/Résumé : permet d’échantillonner des observations et de les compter dans des intervalles configurables (par exemple, les durées des requêtes).

Faire « parler » les métriques à vos applications

Pour que Prometheus puisse collecter des metrics, votre application doit les exposer dans un format que Prometheus comprend. Cela se fait généralement via un point de terminaison HTTP.

De nombreux langages de programmation disposent de bibliothèques clientes qui facilitent l’instrumentation de votre code :

  • Incrémenter les compteurs lors d’événements.
  • Définir des jauges pour représenter les états actuels.
  • Observer la durée des opérations.

Examinons un exemple très simple d’application exposant une métrique de type compteur.

Une application Python exposant des métriques

Voici une petite application Python Flask qui expose une métrique simple de type compteur. Elle simule le comptage des consultations de pages.

Exécutez ce code, puis essayez d’accéder à /metrics dans votre navigateur ou votre terminal (par exemple, après l’exécution, ouvrez http://localhost:5000/metrics).

from flask import Flask
from prometheus_client import Counter, generate_latest
import time

app = Flask(__name__)
c = Counter('my_app_requests_total', 'Total requests to my app')

@app.route('/')
def hello():
    c.inc() # Increment the counter
    return "Hello, CoddyKit!"

@app.route('/metrics')
def metrics():
    return generate_latest().decode('utf-8')

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Prometheus dans votre cluster

Dans Kubernetes, le déploiement efficace de Prometheus passe souvent par l’opérateur Prometheus. Cet opérateur facilite la gestion des instances et des configurations de Prometheus.

Principales ressources Kubernetes pour Prometheus :

  • ServiceMonitor : indique à Prometheus où trouver les points de terminaison de métriques (par exemple, quels Services et pods collecter).
  • PodMonitor : similaire à ServiceMonitor, mais cible directement les pods.

Ces ressources permettent à Prometheus de découvrir automatiquement les métriques de vos applications déployées et de les collecter.

Grafana : le maestro des tableaux de bord

Alors que Prometheus collecte et stocke les métriques, Grafana est votre outil de référence pour les visualiser. Il s’agit d’une application web open source d’analyse et de visualisation interactive.

Grafana vous permet de :

  • Créer des tableaux de bord esthétiques et informatifs.
  • Interroger plusieurs sources de données (comme Prometheus).
  • Configurer des alertes fondées sur des seuils de métriques.

Il transforme les données brutes des métriques en informations exploitables.

Grafana et Prometheus : un duo puissant

Grafana ne stocke pas lui-même les données de métriques ; il interroge des sources de données externes. Pour visualiser vos métriques Kubernetes, vous devez configurer Prometheus comme source de données dans Grafana.

Étapes :

  1. Dans Grafana, ajoutez une nouvelle source de données.
  2. Sélectionnez « Prometheus » comme type.
  3. Indiquez l’URL de votre serveur Prometheus.
  4. Commencez à créer des tableaux de bord avec le langage d’interrogation de Prometheus, PromQL !

Cette association vous donne un contrôle total sur la surveillance de votre cluster.

Testez vos connaissances !

Il est temps de vérifier votre compréhension de Prometheus et Grafana !

Récapitulatif : métriques et visualisation

Excellent travail ! Dans cette leçon, vous avez appris :

  • L’importance des metrics pour l’observabilité.
  • Le rôle de Prometheus comme système puissant de collecte et de stockage des métriques de séries temporelles.
  • La manière dont les applications exposent des métriques que Prometheus peut collecter.
  • Le rôle de Grafana dans la création de tableaux de bord pertinents et la visualisation de vos données de métriques.

La compréhension de ces outils est essentielle pour maintenir vos applications Kubernetes en bonne santé et performantes. Continuez à explorer l’instrumentation de vos propres applications !

Questions Fréquemment Posées

La leçon « Métriques avec Prometheus et Grafana » est-elle gratuite ?

Oui — le texte complet de « Métriques avec Prometheus et Grafana » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kubernetes Basics, passe à CoddyKit PRO. Le cours Kubernetes Basics comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Métriques avec Prometheus et Grafana » ?

Configurez Prometheus pour collecter les métriques du cluster et des applications, puis visualisez-les avec Grafana. Tu pratiques Kubernetes Basics avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kubernetes Basics ?

Aucune expérience préalable n'est requise. Kubernetes Basics sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Métriques avec Prometheus et Grafana » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kubernetes Basics ?

Oui. Chaque leçon Kubernetes Basics inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Journalisation avec kubectl logs
  2. Métriques avec Prometheus et Grafana
  3. Contrôles d’état : sondes de vivacité et de disponibilité
  4. Traçage distribué et événements
← Retour à Kubernetes Basics