Développement Golang : utilisez Prometheus pour surveiller les performances des applications

Développement Golang : l'utilisation de Prometheus pour surveiller les performances des applications nécessite des exemples de code spécifiques

Résumé : Cet article présente comment utiliser la bibliothèque Prometheus dans le développement Golang pour surveiller les performances des applications et fournit des exemples de code spécifiques pour permettre aux développeurs de démarrer rapidement .

Introduction :

Dans le développement d'applications modernes, la surveillance des performances des applications est une étape très importante. Grâce à la surveillance, nous pouvons comprendre l'état de fonctionnement de l'application en temps réel, découvrir les problèmes à temps et effectuer des ajustements, améliorant ainsi la stabilité et les performances de l'application.

Prometheus est un système de surveillance open source et une base de données de séries chronologiques largement utilisés dans le domaine de la surveillance des applications cloud natives et conteneurisées. Il fournit une multitude de types et de fonctions d'indicateurs de surveillance, qui peuvent nous aider à surveiller les indicateurs de performances des applications en temps réel.

Cet article utilisera un exemple spécifique pour démontrer comment utiliser la bibliothèque Prometheus dans le développement Golang pour la surveillance des performances des applications.

Étape 1 : Installer et configurer Prometheus

Tout d'abord, nous devons installer et configurer Prometheus dans le système. Les binaires peuvent être téléchargés depuis le site officiel (https://prometheus.io/) et installés.

Une fois l'installation terminée, vous devez configurer le fichier de configuration Prometheus prometheus.yml. Dans le fichier de configuration, nous devons définir les objectifs à surveiller et les métriques correspondantes.

Par exemple, si nous voulons surveiller le nombre total de requêtes HTTP et le délai de requête d'une application Golang, nous pouvons ajouter la configuration suivante :

scrape_configs:
  - job_name: 'my_app'
    metrics_path: /metrics
    static_configs:
    - targets: ['localhost:8080']

Étape 2 : Ajouter le code de surveillance Prometheus à l'application Golang

Ensuite, nous vous devez ajouter Prometheus au code lié à l'application Golang. Tout d'abord, nous devons présenter la bibliothèque Prometheus :

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

Ensuite, nous pouvons définir les indicateurs qui doivent être surveillés. Dans notre exemple, nous définissons un indicateur de comptage du nombre total de demandes et un indicateur de comptage des retards de demandes :

var (
   requestsTotal = prometheus.NewCounterVec(
      prometheus.CounterOpts{
         Name: "http_requests_total",
         Help: "Total number of HTTP requests.",
      },
      []string{"handler", "method"},
   )
   requestDuration = prometheus.NewHistogramVec(
      prometheus.HistogramOpts{
         Name: "http_request_duration_seconds",
         Help: "HTTP request duration in seconds.",
         Buckets: []float64{0.1, 0.2, 0.5, 1, 2, 5},
      },
      []string{"handler", "method"},
   )
)

Ensuite, nous devons ajouter le code de surveillance correspondant à la fonction de traitement de l'application. Au début et à la fin de chaque fonction de traitement, nous pouvons utiliser les méthodes de surveillance fournies par Prometheus pour collecter et enregistrer des données.

Par exemple, le code suivant montre comment utiliser Prometheus pour surveiller les requêtes HTTP dans les applications Golang :

func handleHello(w http.ResponseWriter, r *http.Request) {
   start := time.Now()

   // 执行实际的处理逻辑

   elapsedTime := time.Since(start).Seconds()
   requestsTotal.WithLabelValues("/hello", r.Method).Inc()
   requestDuration.WithLabelValues("/hello", r.Method).Observe(elapsedTime)
}

Enfin, nous devons configurer le processeur HTTP de Prometheus afin que Prometheus puisse obtenir les indicateurs que nous avons définis via l'interface HTTP.

func main() {
   http.Handle("/metrics", promhttp.Handler())
   http.HandleFunc("/hello", handleHello)
   http.ListenAndServe(":8080", nil)
}

Étape 3 : Démarrez l'application et accédez à l'interface de surveillance Prometheus

Après avoir terminé les étapes ci-dessus, nous pouvons démarrer notre application et accéder à l'interface de surveillance Prometheus. Saisissez http://localhost:9090 dans le navigateur, puis saisissez le nom de l'indicateur que nous avons défini dans la zone de requête pour afficher les données de l'indicateur de performance correspondant.

Par exemple, nous pouvons vérifier le nombre total de requêtes en interrogeant http_requests_total, et vérifier le délai de requête en interrogeant http_request_duration_seconds.

Résumé :

Cet article explique comment utiliser la bibliothèque Prometheus dans le développement Golang pour surveiller les performances des applications et fournit des exemples de code spécifiques. Grâce à Prometheus, nous pouvons facilement collecter et enregistrer divers indicateurs de l'application, puis les visualiser et les analyser en temps réel via l'interface de surveillance Prometheus.

Bien que cet article ne présente qu'une utilisation de base et des exemples, Prometheus fournit des fonctions et une évolutivité plus riches pour répondre aux exigences de surveillance de différents scénarios et besoins. J'espère que cet article pourra aider les lecteurs intéressés par Prometheus et inspirer davantage d'exploration et de pratique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!