:Use a Prometheus client to monitor applications

Requisitos previos

• Managed Service for Prometheus está habilitado para el clúster de ACK. Para obtener más información, consulte Enable Prometheus monitoring.

• Se creó un repositorio de imágenes en Container Registry. Para obtener más información, consulte Step 2: Create an image repository.

Paso 1: Instrumentar una aplicación

Los clientes de Prometheus admiten la mayoría de los lenguajes de programación. Para obtener más información, consulte CLIENT LIBRARIES. El siguiente ejemplo muestra cómo instrumentar una aplicación en Go para exponer datos de monitoreo:

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))
}

Paso 2: Empaquetar la aplicación en una imagen de contenedor y cargar la imagen en un repositorio

Empaquete la aplicación instrumentada en una imagen de contenedor y cargue la imagen en un repositorio de Container Registry.

1. Ejecute el siguiente comando para compilar una imagen:

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

   Ejemplo:

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

2. Ejecute el siguiente comando para etiquetar la imagen:

   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>

   Ejemplo:

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

3. Ejecute el siguiente comando para enviar la imagen al repositorio:

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

   Ejemplo:

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

4. Consulte la imagen en la consola de Container Registry.

   1. Inicie sesión en la consola de Container Registry.

   2. En la barra de navegación superior, seleccione una región.

   3. En el panel de navegación izquierdo, haga clic en Instances.

   4. En la página Instances, haga clic en la instancia Personal Edition que desea gestionar.

   5. En el panel de navegación izquierdo de la página de gestión de la instancia Personal Edition, elija Repository > Repositories.

   6. En la página Repositories, busque el repositorio que desea gestionar y haga clic en Manage en la columna Actions.

   7. En el panel de navegación izquierdo, haga clic en Tags.

      Puede encontrar la imagen cargada en la página Tags.

Paso 3: Desplegar la aplicación en un clúster de ACK

1. Inicie sesión en la consola de ACK. En el panel de navegación izquierdo, haga clic en Clusters.

2. En la página Clusters, haga clic en el nombre de su clúster. En el panel de navegación izquierdo, haga clic en Workloads > Pods.

3. Cree pods.

   1. En la página Pods, haga clic en Create from YAML.

   2. En la página Create, introduzca el siguiente código en el editor de código Template y haga clic en 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

      Ejemplo:

      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

   En la página Pods, puede encontrar los pods que creó.

4. Cree un Service.

   1. En el panel de navegación izquierdo de la página de gestión del clúster, elija Network > Services.

   2. En la página Services, haga clic en Create from YAML.

   3. En la página Create, copie el siguiente código en el editor de código Template y haga clic en 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 

   En la página Services, puede encontrar el Service que creó.

Paso 4: Configurar el descubrimiento de servicios

Configure el descubrimiento de servicios en Managed Service for Prometheus para recopilar datos de la aplicación en Go. El siguiente ejemplo muestra cómo configurar el descubrimiento de servicios en la consola de Application Real-Time Monitoring Service (ARMS):

1. Inicie sesión en la consola de ARMS.

2. En la barra de navegación superior, seleccione la región donde se despliega el clúster.

3. En el panel de navegación izquierdo, haga clic en Integration Management. En la pestaña Integrated Environments, haga clic en el entorno que tiene el mismo nombre que el clúster.

4. En la página Container Service, haga clic en la pestaña Metric Scraping. En el panel de navegación izquierdo, haga clic en Service Monitor.

5. En la lista de Service Monitor, haga clic en Create. En el panel Add ServiceMonitor Configuration, copie el siguiente bloque de código en el editor de código y haga clic en 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

   En la pestaña ServiceMonitor, puede encontrar el ServiceMonitor que configuró.

Paso 5: Comprobar si el cliente de Prometheus puede monitorear la aplicación según la métrica

1. Inicie sesión en la consola de ARMS.

2. En la barra de navegación superior, seleccione la región donde se despliega el clúster.

3. En el panel de navegación izquierdo, elija Metrics Center > Metric Overview. En el cuadro de búsqueda, introduzca rpc_durations_seconds de la métrica registrada en Step 1: Instrument an application y haga clic en el icono .

   Si se devuelve la métrica rpc_durations_seconds, esto indica que el cliente de Prometheus puede monitorear la aplicación según dicha métrica.