:Use a Prometheus client to monitor applications

Prérequis

• Le service Managed Service for Prometheus est activé pour le cluster ACK. Pour plus d'informations, consultez la rubrique Activer la surveillance Prometheus.

• Un dépôt d'images est créé dans Container Registry. Pour plus d'informations, consultez la section Étape 2 : Créer un dépôt d'images.

Étape 1 : Instrumenter une application

Les clients Prometheus prennent en charge la plupart des langages de programmation. Pour plus d'informations, consultez la page BIBLIOTHÈQUES CLIENT. L'exemple suivant illustre l'instrumentation d'une application Go pour exposer les données de surveillance :

package main
import (
    "flag"
    "fmt"
    "log"
    "math"
    "math/rand"
    "net/http"
    "time"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
    addr              = flag.String("listen-address", ":8080", "The address to listen on for HTTP requests.")
    uniformDomain     = flag.Float64("uniform.domain", 0.0002, "The domain for the uniform distribution.")
    normDomain        = flag.Float64("normal.domain", 0.0002, "The domain for the normal distribution.")
    normMean          = flag.Float64("normal.mean", 0.00001, "The mean for the normal distribution.")
    oscillationPeriod = flag.Duration("oscillation-period", 10*time.Minute, "The duration of the rate oscillation period.")
)

var (
    // Create a summary to track fictional interservice RPC latencies for three distinct services with different latency distributions. 
    // These services are differentiated via a "service" label.
    rpcDurations = prometheus.NewSummaryVec(
        prometheus.SummaryOpts{
            Name:       "rpc_durations_seconds",
            Help:       "RPC latency distributions.",
            Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
        },
        []string{"service"},
    )
    // The same as above, but now as a histogram, and only for the normal
    // distribution. The buckets are targeted to the parameters of the
    // normal distribution, with 20 buckets centered on the mean, each
    // half-sigma wide.
    rpcDurationsHistogram = prometheus.NewHistogram(prometheus.HistogramOpts{
        Name:    "rpc_durations_histogram_seconds",
        Help:    "RPC latency distributions.",
        Buckets: prometheus.LinearBuckets(*normMean-5**normDomain, .5**normDomain, 20),
    })
)

func init() {
    // Register the summary and the histogram with Prometheus's default registry.
    prometheus.MustRegister(rpcDurations)
    prometheus.MustRegister(rpcDurationsHistogram)
    // Add Go module build info.
    prometheus.MustRegister(prometheus.NewBuildInfoCollector())
}

func main() {
    flag.Parse()
    start := time.Now()
    oscillationFactor := func() float64 {
        return 2 + math.Sin(math.Sin(2*math.Pi*float64(time.Since(start))/float64(*oscillationPeriod)))
    }
    // Periodically record some sample latencies for the three services.
    go func() {
        for {
            v := rand.Float64() * *uniformDomain
            rpcDurations.WithLabelValues("uniform").Observe(v)
            time.Sleep(time.Duration(100*oscillationFactor()) * time.Millisecond)
        }
    }()
    go func() {
        for {
            v := (rand.NormFloat64() * *normDomain) + *normMean
            rpcDurations.WithLabelValues("normal").Observe(v)
            // Demonstrate exemplar support with a dummy ID. This
            // would be something like a trace ID in a real
            // application.  Note the necessary type assertion. We
            // already know that rpcDurationsHistogram implements
            // the ExemplarObserver interface and thus don't need to
            // check the outcome of the type assertion.
            rpcDurationsHistogram.(prometheus.ExemplarObserver).ObserveWithExemplar(
                v, prometheus.Labels{"dummyID": fmt.Sprint(rand.Intn(100000))},
            )
            time.Sleep(time.Duration(75*oscillationFactor()) * time.Millisecond)
        }
    }()
    go func() {
        for {
            v := rand.ExpFloat64() / 1e6
            rpcDurations.WithLabelValues("exponential").Observe(v)
            time.Sleep(time.Duration(50*oscillationFactor()) * time.Millisecond)
        }
    }()
    // Expose the registered metrics via HTTP.
    http.Handle("/metrics", promhttp.HandlerFor(
        prometheus.DefaultGatherer,
        promhttp.HandlerOpts{
            // Opt into OpenMetrics to support exemplars.
            EnableOpenMetrics: true,
        },
    ))
    log.Fatal(http.ListenAndServe(*addr, nil))
}

Étape 2 : Empaqueter l'application dans une image de conteneur et transférer l'image vers un dépôt

Empaquetez l'application instrumentée dans une image de conteneur, puis transférez cette image vers un dépôt dans Container Registry.

1. Exécutez la commande suivante pour générer une image :

   docker build -t <Name of the local temporary Docker image>:<Tag of the local temporary Docker image> . --no-cache

   Exemple :

   docker build -t prometheus-demo:v1 . --no-cache

2. Exécutez la commande suivante pour étiqueter l'image :

   sudo docker tag <Name of the local temporary Docker image>:<Tag of the local temporary Docker image> <Registry domain name>/<Namespace>/<Image name>:<Image tag>

   Exemple :

   sudo docker tag prometheus-demo:v1 registry.cn-hangzhou.aliyuncs.com/ringtail/prometheus-demo:v1

3. Exécutez la commande suivante pour transférer l'image vers le dépôt :

   sudo docker push <Registry domain name>/<Namespace>/<Image name>:<Image tag>

   Exemple :

   sudo docker push registry.cn-hangzhou.aliyuncs.com/ringtail/prometheus-demo:v1

4. Consultez l'image dans la console Container Registry.

   1. Connectez-vous à la console Container Registry.

   2. Dans la barre de navigation supérieure, sélectionnez une région.

   3. Dans le volet de navigation de gauche, cliquez sur Instances.

   4. Sur la page Instances, cliquez sur l'instance Personal Edition que vous souhaitez gérer.

   5. Dans le volet de navigation de gauche de la page de gestion de l'instance Personal Edition, choisissez Repository > Repositories.

   6. Sur la page Repositories, recherchez le dépôt à gérer et cliquez sur Manage dans la colonne Actions.

   7. Dans le volet de navigation de gauche, cliquez sur Tags.

      L'image transférée apparaît sur la page Tags.

Étape 3 : Déployer l'application sur un cluster ACK

1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.

2. Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Workloads > Pods.

3. Créez des pods.

   1. Sur la page Pods, cliquez sur Create from YAML.

   2. Sur la page Create, saisissez le code suivant dans l'éditeur de code du champ Template et cliquez sur Create :

      apiVersion: apps/v1 # for versions before 1.8.0 use apps/v1beta1
      kind: Deployment
      metadata:
        name: demo-app
        labels:
          app: demo-app
      spec:
        replicas: 2
        selector:
          matchLabels:
            app: demo-app
        template:
          metadata:
            labels:
              app: demo-app
          spec:
            containers:
            - name: demo-app
              image: <Repository domain name>/<Namespace>/<Image name>:<Image tag>
              command:
              - /random 
              ports:
              - containerPort: 8080

      Exemple :

      apiVersion: apps/v1 # for versions before 1.8.0 use apps/v1beta1
      kind: Deployment
      metadata:
        name: demo-app
        labels:
          app: demo-app
      spec:
        replicas: 2
        selector:
          matchLabels:
            app: demo-app
        template:
          metadata:
            labels:
              app: demo-app
          spec:
            containers:
            - name: demo-app
              image: registry.cn-hangzhou.aliyuncs.com/ringtail/prometheus-demo:v1
              command:
              - /random 
              ports:
              - containerPort: 8080

   Les pods créés apparaissent sur la page Pods.

4. Créez un service.

   1. Dans le volet de navigation de gauche de la page de gestion du cluster, choisissez Network > Services.

   2. Sur la page Services, cliquez sur Create from YAML.

   3. Sur la page Create, copiez le code suivant dans l'éditeur de code du champ Template et cliquez sur Create :

      apiVersion: v1
      kind: Service
      metadata:
        labels:
          app: demo-app
        name: demo-app
        namespace: default
      spec:
        ports:
        - name: http-metrics
          port: 8080
          protocol: TCP
          targetPort: 8080
        selector:
          app: demo-app
        type: ClusterIP 

   Le service créé apparaît sur la page Services.

Étape 4 : Configurer la découverte de service

Configurez la découverte de service dans Managed Service for Prometheus pour capturer les données de l'application Go. L'exemple suivant montre comment configurer la découverte de service dans la console Application Real-Time Monitoring Service (ARMS) :

1. Connectez-vous à la console ARMS.

2. Dans la barre de navigation supérieure, sélectionnez la région où le cluster est déployé.

3. Dans le volet de navigation de gauche, cliquez sur Integration Management. Sur l'onglet Integrated Environments, cliquez sur l'environnement portant le même nom que le cluster.

4. Sur la page Container Service, cliquez sur l'onglet Metric Scraping. Dans le volet de navigation de gauche, cliquez sur Service Monitor.

5. Dans la liste Service Monitor, cliquez sur Create. Dans le panneau Add ServiceMonitor Configuration, copiez le bloc de code suivant dans l'éditeur de code et cliquez sur Create.

   apiVersion: monitoring.coreos.com/v1
   kind: ServiceMonitor
   metadata:
     labels:
       app: demo-app
     name: demo-app
     namespace: default
     annotations:
       arms.prometheus.io/discovery: 'true'
   spec:
     endpoints:
     - interval: 30s
       port: http-metrics
     jobLabel: app
     namespaceSelector:
       matchNames:
       - default
     selector:
       matchLabels:
         app: demo-app

   Le ServiceMonitor configuré apparaît sur l'onglet ServiceMonitor.

Étape 5 : Vérifier si le client Prometheus peut surveiller l'application à l'aide de la métrique

1. Connectez-vous à la console ARMS.

2. Dans la barre de navigation supérieure, sélectionnez la région où le cluster est déployé.

3. Dans le volet de navigation de gauche, choisissez Metrics Center > Metric Overview. Dans la zone de recherche, saisissez rpc_durations_seconds correspondant à la métrique enregistrée à l'Étape 1 : Instrumenter une application et cliquez sur l'icône .

   Si la métrique rpc_durations_seconds est renvoyée, cela signifie que le client Prometheus surveille correctement l'application à l'aide de cette métrique.