Technical Tutorials

Dans le paysage moderne du développement logiciel, en particulier dans les environnements de microservices et conteneurisés, s'en remettre à de simples vérifications de disponibilité n'est plus suffisant. Les développeurs et les ingénieurs de fiabilité des sites (SRE) ont besoin d'une visibilité approfondie sur les performances du système, l'utilisation des ressources et la santé des applications en temps réel. C'est ici que Prometheus, une boîte à outils open-source de surveillance et d'alerte des systèmes initialement développée chez SoundCloud, s'est imposée comme la norme de facto. Ce guide vous accompagnera dans les étapes essentielles pour mettre en place la surveillance Prometheus pour vos applications, en mettant l'accent sur la mise en œuvre pratique plutôt que sur la seule théorie.

Pourquoi choisir Prometheus ?

Avant de plonger dans la configuration, il est crucial de comprendre pourquoi Prometheus est le choix privilégié de nombreuses équipes d'ingénierie. Contrairement aux outils de surveillance traditionnels qui reposent sur des métriques en mode push ou des logs en mode pull, Prometheus utilise une architecture en mode pull. Cela signifie qu'il récupère (scrape) les métriques de votre application via des points de terminaison HTTP à des intervalles spécifiés. Ce choix de conception offre plusieurs avantages : 1. **Simplicité :** Les agents n'ont pas à gérer les erreurs réseau ; le serveur central gère les tentatives de reconnexion et les problèmes de connectivité. 2. **Facilité de mise à l'échelle :** Les capacités de mise à l'échelle horizontale vous permettent d'ajouter davantage de serveurs sans modifier significativement le code de votre application. 3. **Langage de requête puissant (PromQL) :** Prometheus fournit un langage de requête hautement flexible qui permet une analyse et une agrégation complexes des métriques.

Étape 1 : Instrumenter votre application

Pour surveiller une application, celle-ci doit exposer ses métriques dans un format compréhensible par Prometheus, généralement le format OpenMetrics ou le format d'exposition Prometheus. La plupart des langages populaires disposent de bibliothèques clientes qui rendent ce processus simple. Par exemple, si vous utilisez Go, vous pouvez utiliser la bibliothèque officielle `prometheus/client_golang`. Voici un extrait de code simple démontrant comment exposer un histogramme pour la latence des requêtes HTTP :

package main

import (
    "net/http"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var requestLatency = prometheus.NewHistogramVec(
    prometheus.HistogramOpts{
        Name:    "http_request_duration_seconds",
        Help:    "Duration of HTTP requests.",
        Buckets: prometheus.DefBuckets,
    },
    []string{"method", "status"},
)

func main() {
    prometheus.MustRegister(requestLatency)

    http.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        // ... process request ...
        latency := time.Since(start).Seconds()
        requestLatency.WithLabelValues(r.Method, "200").Observe(latency)
        w.WriteHeader(http.StatusOK)
    })

    http.Handle("/metrics", promhttp.Handler())
    http.ListenAndServe(":8080", nil)
}

Dans ce code, nous définissons une métrique de type histogramme qui suit la durée des appels API, catégorisée par méthode HTTP et code de statut. Le point de terminaison `/metrics` sert ces valeurs au format texte brut requis par Prometheus.

Étape 2 : Configurer Prometheus

Une fois que votre application expose des métriques, vous devez configurer Prometheus pour les récupérer. Cela se fait via le fichier de configuration `prometheus.yml`. Vous définissez des "jobs" qui pointent vers les cibles statiques (vos instances d'application) et définissez l'intervalle de récupération.

global:
  scrape_interval: 15s

evaluation_interval: 15s

scrape_configs:
  - job_name: 'my-application'
    static_configs:
      - targets: ['localhost:8080']

Cette configuration indique à Prometheus de récupérer les métriques depuis `localhost:8080` toutes les 15 secondes. Dans un environnement de production, vous utiliseriez généralement la découverte de services (telle que la découverte de services Kubernetes) pour détecter automatiquement les nouvelles instances de votre application lors de la montée ou de la descente en charge.

Étape 3 : Rédiger des requêtes efficaces avec PromQL

La véritable puissance de Prometheus réside dans son langage de requête, PromQL. Contrairement à SQL qui interroge des bases de données, PromQL interroge des données de séries temporelles. Pour visualiser vos métriques, vous connectez généralement Prometheus à un outil de tableaux de bord comme Grafana. Pour obtenir la latence moyenne des requêtes de votre API, vous pourriez utiliser une requête comme celle-ci :

rate(http_request_duration_seconds_sum{job="my-application"}[5m]) 
/ 
rate(http_request_duration_seconds_count{job="my-application"}[5m])

Cette requête calcule le taux d'augmentation moyen par seconde de la somme totale des latences au cours des 5 dernières minutes, divisé par le nombre de requêtes, vous donnant ainsi efficacement la latence moyenne.

Conclusion

La mise en place de la surveillance Prometheus transforme votre application d'une boîte noire en un système transparent et observable. En instrumentant votre code, en configurant les récupérateurs et en maîtrisant PromQL, vous obtenez les informations nécessaires pour détecter les anomalies avant qu'elles n'affectent les utilisateurs. À mesure que votre infrastructure se développe, ces pratiques forment la colonne vertébrale d'une stratégie d'observabilité robuste, garantissant fiabilité et performance à grande échelle. Commencez petit, instrumentez vos services les plus critiques, et élargissez itérativement votre couverture de surveillance pour construire un système résilient.