Pemberitahuan dan evaluasi aturan yang di-deploy sendiri

Google Cloud Managed Service for Prometheus mendukung evaluasi dan pemberitahuan aturan yang kompatibel dengan Prometheus. Dokumen ini menjelaskan cara menyiapkan evaluasi aturan yang di-deploy sendiri, termasuk komponen evaluator aturan mandiri.

Anda hanya perlu mengikuti petunjuk ini jika ingin menjalankan aturan dan pemberitahuan terhadap penyimpanan data global.

Evaluasi aturan untuk koleksi yang di-deploy sendiri

Setelah men-deploy Managed Service for Prometheus, Anda dapat terus mengevaluasi aturan secara lokal di setiap instance yang di-deploy menggunakan kolom rule_files pada file konfigurasi Prometheus Anda. Namun, jendela kueri maksimum untuk aturan dibatasi oleh durasi server menyimpan data lokal.

Sebagian besar aturan hanya dijalankan selama beberapa menit terakhir data, sehingga menjalankan aturan pada setiap server lokal sering kali merupakan strategi yang valid. Dalam hal ini, tidak diperlukan penyiapan lebih lanjut.

Namun, terkadang ada baiknya mengevaluasi aturan berdasarkan backend metrik global, misalnya, saat semua data untuk aturan tidak ditempatkan di lokasi yang sama dalam instance Prometheus tertentu. Dalam kasus ini, Google Cloud Managed Service for Prometheus juga menyediakan komponen evaluator aturan.

Sebelum memulai

Bagian ini menjelaskan konfigurasi yang diperlukan untuk tugas-tugas yang dijelaskan dalam dokumen ini.

Mengonfigurasi lingkungan Anda

Agar tidak berulang kali memasukkan project ID atau nama cluster Anda, lakukan konfigurasi berikut:

Konfigurasikan alat command line sebagai berikut:
- Konfigurasikan gcloud CLI untuk merujuk ke ID project Google Cloud Anda:
```
gcloud config set project PROJECT_ID
```
- Konfigurasikan kubectl CLI untuk menggunakan cluster Anda:
```
kubectl config set-cluster CLUSTER_NAME
```
Untuk mengetahui informasi selengkapnya tentang alat ini, lihat referensi berikut:
- Ringkasan gcloud CLI
- Perintah kubectl

Menyiapkan namespace

Buat namespace Kubernetes NAMESPACE_NAME untuk resource yang Anda buat sebagai bagian dari aplikasi contoh:

kubectl create ns NAMESPACE_NAME

Memverifikasi kredensial akun layanan

Anda dapat melewati bagian ini jika cluster Kubernetes Anda telah mengaktifkan Workload Identity.

Saat berjalan di GKE, Google Cloud Managed Service for Prometheus akan otomatis mengambil kredensial dari lingkungan berdasarkan akun layanan default Compute Engine. Akun layanan default memiliki izin yang diperlukan, monitoring.metricWriter dan monitoring.viewer, secara default. Jika tidak menggunakan Workload Identity, dan sebelumnya telah menghapus salah satu peran tersebut dari akun layanan node default, Anda harus menambahkan kembali izin yang tidak ada tersebut sebelum melanjutkan.

Jika Anda tidak menjalankan aplikasi di GKE, lihat Memberikan kredensial secara eksplisit.

Mengonfigurasi akun layanan untuk Workload Identity

Anda dapat melewati bagian ini jika cluster Kubernetes Anda tidak mengaktifkan Workload Identity.

Google Cloud Managed Service for Prometheus merekam data metrik menggunakan Cloud Monitoring API. Jika cluster menggunakan Workload Identity, Anda harus memberikan izin ke akun layanan Kubernetes ke Monitoring API. Bagian ini menjelaskan hal berikut:

Membuat akun layanan Google Cloud khusus, gmp-test-sa.
Mengikat akun layanan Google Cloud ke akun layanan Kubernetes default dalam namespace pengujian, NAMESPACE_NAME.
Memberikan izin yang diperlukan ke akun layanan Google Cloud.

Membuat dan mengikat akun layanan

Langkah ini muncul di beberapa tempat dalam dokumentasi Managed Service for Prometheus. Jika sudah melakukan langkah ini sebagai bagian dari tugas sebelumnya, Anda tidak perlu mengulanginya. Lanjutkan ke bagian Mengizinkan akun layanan.

Urutan perintah berikut membuat akun layanan gmp-test-sa dan mengikatnya ke akun layanan Kubernetes default di namespace NAMESPACE_NAME:

gcloud config set project PROJECT_ID \
&&
gcloud iam service-accounts create gmp-test-sa \
&&
gcloud iam service-accounts add-iam-policy-binding \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE_NAME/default]" \
  gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
&&
kubectl annotate serviceaccount \
  --namespace NAMESPACE_NAME \
  default \
  iam.gke.io/gcp-service-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com

Jika Anda menggunakan namespace atau akun layanan GKE yang berbeda, sesuaikan perintah dengan tepat.

Mengizinkan akun layanan

Grup izin terkait dikumpulkan ke dalam peran, dan Anda memberikan peran kepada akun utama, dalam contoh ini, akun layanan Google Cloud. Untuk mengetahui informasi selengkapnya tentang peran Monitoring, lihat Kontrol akses.

Perintah berikut memberikan akun layanan Google Cloud, gmp-test-sa, peran Monitoring API yang diperlukan untuk membaca dan menulis data metrik.

Jika sudah memberikan peran tertentu kepada akun layanan Google Cloud sebagai bagian dari tugas sebelumnya, Anda tidak perlu melakukannya lagi.

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer \
&& \
gcloud projects add-iam-policy-binding PROJECT_ID\
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.metricWriter

Men-debug konfigurasi Workload Identity Anda

Jika Anda mengalami masalah dalam membuat Workload Identity berfungsi, lihat dokumentasi untuk memverifikasi penyiapan Workload Identity Anda dan panduan pemecahan masalah Workload Identity.

Karena salah ketik dan salin-tempel sebagian adalah sumber error yang paling umum saat mengonfigurasi Workload Identity, kami sangat merekomendasikan penggunaan variabel yang dapat diedit dan ikon salin-tempel yang dapat diklik dan disematkan dalam contoh kode dalam petunjuk ini.

Workload Identity di lingkungan produksi

Contoh yang dijelaskan dalam dokumen ini mengikat akun layanan Google Cloud ke akun layanan Kubernetes default dan memberi akun layanan Google Cloud semua izin yang diperlukan untuk menggunakan Monitoring API.

Dalam lingkungan produksi, Anda mungkin ingin menggunakan pendekatan yang lebih terperinci, dengan akun layanan untuk setiap komponen, masing-masing dengan izin minimal. Untuk mengetahui informasi selengkapnya tentang cara mengonfigurasi akun layanan untuk pengelolaan workload-identitas, lihat Menggunakan Workload Identity.

Men-deploy evaluator aturan mandiri

Evaluator aturan Managed Service for Prometheus mengevaluasi aturan pemberitahuan dan pencatatan Prometheus terhadap HTTP API Managed Service for Prometheus dan menulis kembali hasilnya ke Monarch. Prometheus menerima format file konfigurasi dan format file aturan yang sama dengan Prometheus. Tandanya juga hampir sama.

Buat contoh deployment evaluator aturan yang telah dikonfigurasi sebelumnya untuk mengevaluasi aturan pemberitahuan dan pencatatan:

kubectl apply -n NAMESPACE_NAME -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.8.2/manifests/rule-evaluator.yaml

Pastikan pod untuk evaluator aturan berhasil di-deploy:

kubectl -n NAMESPACE_NAME get pod

Jika deployment berhasil, Anda akan melihat output seperti berikut:

NAME                              READY   STATUS    RESTARTS   AGE
...
rule-evaluator-64475b696c-95z29   2/2     Running   0          1m

Setelah memastikan bahwa evaluator aturan berhasil di-deploy, Anda dapat membuat penyesuaian pada manifes yang diinstal untuk melakukan hal berikut:

Tambahkan file aturan kustom.
Konfigurasikan evaluator aturan untuk mengirim pemberitahuan ke Prometheus Alertmanager yang di-deploy sendiri menggunakan kolom alertmanager_config file konfigurasi.

Jika Alertmanager berada di cluster yang berbeda dengan evaluator aturan, Anda mungkin perlu menyiapkan Resource endpoint. Misalnya, jika OperatorConfig Anda menentukan bahwa endpoint Alertmanager dapat ditemukan di objek Endpoint ns=alertmanager/name=alertmanager, Anda dapat membuat objek ini sendiri secara manual atau terprogram dan mengisinya dengan IP yang dapat dijangkau dari cluster lain.

Memberikan kredensial secara eksplisit

Saat berjalan di GKE, evaluator aturan akan otomatis mengambil kredensial dari lingkungan berdasarkan akun layanan node atau penyiapan Workload Identity. Dalam cluster Kubernetes non-GKE, kredensial harus diberikan secara eksplisit kepada evaluator aturan menggunakan flag atau variabel lingkungan GOOGLE_APPLICATION_CREDENTIALS.

Tetapkan konteks ke project target Anda:
```
gcloud config set project PROJECT_ID
```
Buat akun layanan:
```
gcloud iam service-accounts create gmp-test-sa
```
Langkah ini akan membuat akun layanan yang mungkin telah Anda buat di petunjuk Workload Identity.

Berikan izin yang diperlukan ke akun layanan tersebut:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer \
&& \
gcloud projects add-iam-policy-binding PROJECT_ID\
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.metricWriter

Buat dan download kunci untuk akun layanan:

gcloud iam service-accounts keys create gmp-test-sa-key.json \
  --iam-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com

Tambahkan file kunci sebagai rahasia ke cluster non-GKE Anda:

kubectl -n NAMESPACE_NAME create secret generic gmp-test-sa \
  --from-file=key.json=gmp-test-sa-key.json

Buka resource Deployment evaluator aturan untuk mengedit:
```
kubectl -n NAMESPACE_NAME edit deploy rule-evaluator
```
1. Tambahkan teks yang ditampilkan dalam huruf tebal ke referensi:
```
apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: NAMESPACE_NAME
  name: rule-evaluator
spec:
  template
    containers:
    - name: evaluator
      args:
      - --query.credentials-file=/gmp/key.json
      - --export.credentials-file=/gmp/key.json
...
      volumeMounts:
      - name: gmp-sa
        mountPath: /gmp
        readOnly: true
...
    volumes:
    - name: gmp-sa
      secret:
        secretName: gmp-test-sa
...
```
2. Simpan file dan tutup editor. Setelah perubahan diterapkan, pod dibuat ulang dan mulai mengautentikasi ke backend metrik dengan akun layanan yang diberikan.
Atau, daripada menggunakan flag yang ditetapkan dalam contoh ini, Anda dapat menetapkan jalur file kunci menggunakan variabel lingkungan GOOGLE_APPLICATION_CREDENTIALS.
Evaluasi aturan global dan multi-project

Sebaiknya jalankan satu instance evaluator aturan di setiap project dan region Google Cloud, bukan menjalankan satu instance yang dievaluasi terhadap banyak project dan region. Namun, kami mendukung evaluasi aturan multi-project untuk skenario yang memerlukannya.

Saat di-deploy di Google Kubernetes Engine, evaluator aturan menggunakan project Google Cloud yang terkait dengan cluster, yang otomatis terdeteksi. Untuk mengevaluasi aturan yang mencakup project, Anda dapat mengganti project yang dikueri menggunakan tanda --query.project-id dan menentukan project dengan cakupan metrik multi-project. Jika cakupan metrik berisi semua project Anda, aturan akan dievaluasi secara global. Untuk mengetahui informasi selengkapnya, lihat Cakupan Metrik.

Anda juga harus memperbarui izin akun layanan yang digunakan oleh evaluator aturan agar akun layanan dapat membaca dari project pencakupan dan menulis ke semua project yang dipantau dalam cakupan metrik.

Mempertahankan label saat menulis aturan

Untuk data yang ditulis kembali ke Managed Service for Prometheus, evaluator mendukung tanda --export.* dan konfigurasi berbasis external_labels yang sama dengan biner server Managed Service for Prometheus. Sebaiknya Anda menulis aturan agar label project_id, location, cluster, dan namespace dipertahankan dengan tepat sesuai dengan tingkat agregasinya. Jika tidak, performa kueri mungkin akan menurun dan Anda mungkin akan mengalami batas kardinalitas.

Label project_id atau location bersifat wajib. Jika label ini tidak ada, nilai dalam hasil evaluasi aturan akan ditetapkan berdasarkan konfigurasi evaluator aturan. Label cluster atau namespace yang tidak ada tidak diberi nilai.

Deployment ketersediaan tinggi

Evaluator aturan dapat berjalan dalam penyiapan yang sangat tersedia dengan mengikuti pendekatan yang sama seperti yang didokumentasikan untuk server Prometheus.

Pemberitahuan menggunakan metrik Cloud Monitoring

Anda dapat mengonfigurasi evaluator aturan untuk mengirim pemberitahuan tentang metrik sistem Google Cloud menggunakan PromQL. Untuk mengetahui petunjuk cara membuat kueri yang valid, lihat metrik PromQL untuk Cloud Monitoring.