:Gunakan klien Prometheus untuk memonitor aplikasi

Langkah 1: Instrumen aplikasi

Klien Prometheus mendukung sebagian besar bahasa pemrograman. Untuk informasi lebih lanjut, lihat PERPUSTAKAAN KLIEN. Contoh berikut menunjukkan cara menginstrumen aplikasi Go untuk mengekspos data pemantauan:

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", "Alamat untuk mendengarkan permintaan HTTP.")
    uniformDomain     = flag.Float64("uniform.domain", 0.0002, "Domain untuk distribusi seragam.")
    normDomain        = flag.Float64("normal.domain", 0.0002, "Domain untuk distribusi normal.")
    normMean          = flag.Float64("normal.mean", 0.00001, "Rata-rata untuk distribusi normal.")
    oscillationPeriod = flag.Duration("oscillation-period", 10*time.Minute, "Durasi periode osilasi laju.")
)

var (
    // Buat ringkasan untuk melacak latensi RPC fiktif antarlayanan untuk tiga layanan berbeda dengan distribusi latensi yang berbeda.
    // Layanan ini dibedakan melalui label "service".
    rpcDurations = prometheus.NewSummaryVec(
        prometheus.SummaryOpts{
            Name:       "rpc_durations_seconds",
            Help:       "Distribusi latensi RPC.",
            Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
        },
        []string{"service"},
    )
    // Sama seperti di atas, tetapi sekarang sebagai histogram, dan hanya untuk distribusi normal.
    // Bucket ditargetkan ke parameter distribusi normal, dengan 20 bucket berpusat pada mean, masing-masing setengah-sigma lebar.
    rpcDurationsHistogram = prometheus.NewHistogram(prometheus.HistogramOpts{
        Name:    "rpc_durations_histogram_seconds",
        Help:    "Distribusi latensi RPC.",
        Buckets: prometheus.LinearBuckets(*normMean-5**normDomain, .5**normDomain, 20),
    })
)

func init() {
    // Daftarkan ringkasan dan histogram dengan registri default Prometheus.
    prometheus.MustRegister(rpcDurations)
    prometheus.MustRegister(rpcDurationsHistogram)
    // Tambahkan informasi build modul Go.
    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)))
    }
    // Secara berkala rekam beberapa latensi sampel untuk ketiga layanan.
    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)
            // Demonstrasi dukungan exemplar dengan ID dummy. Ini
            // akan menjadi sesuatu seperti ID jejak dalam aplikasi nyata. Perhatikan asersi tipe yang diperlukan. Kami
            // sudah tahu bahwa rpcDurationsHistogram mengimplementasikan
            // antarmuka ExemplarObserver dan dengan demikian tidak perlu
            // memeriksa hasil dari asersi tipe.
            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)
        }
    }()
    // Paparkan metrik yang terdaftar melalui HTTP.
    http.Handle("/metrics", promhttp.HandlerFor(
        prometheus.DefaultGatherer,
        promhttp.HandlerOpts{
            // Pilih OpenMetrics untuk mendukung exemplar.
            EnableOpenMetrics: true,
        },
    ))
    log.Fatal(http.ListenAndServe(*addr, nil))
}

Langkah 2: Kemas aplikasi ke dalam gambar kontainer dan unggah gambar ke repositori

Kemas aplikasi yang telah diinstrumen ke dalam gambar kontainer dan unggah gambar tersebut ke repositori di Container Registry.

1. Jalankan perintah berikut untuk membuat gambar:

   docker build -t <Nama gambar Docker sementara lokal>:<Tag gambar Docker sementara lokal> . --no-cache

   Contoh:

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

2. Jalankan perintah berikut untuk memberi tag pada gambar:

   sudo docker tag <Nama gambar Docker sementara lokal>:<Tag gambar Docker sementara lokal> <Nama domain registry>/<Namespace>/<Nama gambar>:<Tag gambar>

   Contoh:

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

3. Jalankan perintah berikut untuk mendorong gambar ke repositori:

   sudo docker push <Nama domain registry>/<Namespace>/<Nama gambar>:<Tag gambar>

   Contoh:

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

4. Lihat gambar di konsol Container Registry.

   1. Masuk ke konsol Container Registry.

   2. Di bilah navigasi atas, pilih wilayah.

   3. Di panel navigasi sisi kiri, klik Instances.

   4. Di halaman Instances, klik instance Personal Edition yang ingin Anda kelola.

   5. Di panel navigasi sisi kiri halaman manajemen instance Personal Edition, pilih Repository > Repositories.

   6. Di halaman Repositories, temukan repositori yang ingin Anda kelola dan klik Manage di kolom Actions.

   7. Di panel navigasi sisi kiri, klik Tags.

      Anda dapat menemukan gambar yang diunggah di halaman Tags.

Langkah 3: Terapkan aplikasi ke kluster ACK

1. Masuk ke konsol ACK. Di panel navigasi sisi kiri, klik Clusters.

2. Di halaman Clusters, temukan kluster yang Anda inginkan dan klik namanya. Di panel sisi kiri, pilih Workloads > Pods.

3. Buat pods.

   1. Di halaman Pods, klik Create from YAML.

   2. Di halaman Create, masukkan kode berikut di editor kode Template dan klik Create:

      apiVersion: apps/v1 # untuk versi sebelum 1.8.0 gunakan 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: <Nama domain repositori>/<Namespace>/<Nama gambar>:<Tag gambar>
              command:
              - /random 
              ports:
              - containerPort: 8080

      Contoh:

      apiVersion: apps/v1 # untuk versi sebelum 1.8.0 gunakan 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

   Di halaman Pods, Anda dapat menemukan pods yang Anda buat.

4. Buat sebuah Service.

   1. Di panel navigasi sisi kiri halaman detail, pilih Network > Services.

   2. Di halaman Services, klik Create from YAML.

   3. Di halaman Create, salin kode berikut ke editor kode Template dan klik 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 

   Di halaman Services, Anda dapat menemukan Service yang Anda buat.

Langkah 4: Konfigurasi penemuan layanan

Konfigurasikan penemuan layanan di Managed Service for Prometheus untuk menangkap data dari aplikasi Go. Contoh berikut menunjukkan cara mengonfigurasi penemuan layanan di konsol Application Real-Time Monitoring Service (ARMS):

1. Masuk ke Konsol ARMS.

2. Di bilah navigasi atas, pilih wilayah tempat kluster diterapkan.

3. Di panel navigasi sisi kiri, klik Integration Management. Di tab Integrated Environments, klik lingkungan yang memiliki nama sama dengan kluster.

4. Di halaman Container Service, klik tab Metric Scraping. Di panel navigasi sisi kiri, klik Service Monitor.

5. Di daftar Service Monitor, klik Create. Di panel Add ServiceMonitor Configuration, salin blok kode berikut ke editor kode dan klik 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

   Di tab ServiceMonitor, Anda dapat menemukan ServiceMonitor yang Anda konfigurasi.

Langkah 5: Periksa apakah klien Prometheus dapat memonitor aplikasi berdasarkan metrik

1. Masuk ke Konsol ARMS.

2. Di bilah navigasi atas, pilih wilayah tempat kluster diterapkan.

3. Di panel navigasi sisi kiri, pilih Metrics Center > Metric Overview. Di kotak pencarian, masukkan rpc_durations_seconds dari metrik yang didaftarkan di Langkah 1: Instrumen aplikasi dan klik ikon .

   Jika metrik rpc_durations_seconds dikembalikan, itu menunjukkan bahwa klien Prometheus dapat memonitor aplikasi berdasarkan metrik.