Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menyerap metrik ke Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus
Metrik harus dimasukkan ke dalam Layanan Terkelola Amazon untuk ruang kerja Prometheus sebelum Anda dapat menanyakan atau memberi tahu metrik tersebut. Bagian ini menjelaskan cara mengatur konsumsi metrik ke dalam ruang kerja Anda.
**catatan**
Metrik yang dimasukkan ke dalam ruang kerja disimpan selama 150 hari secara default, dan kemudian dihapus secara otomatis. Anda dapat menyesuaikan periode retensi dengan mengonfigurasi ruang kerja Anda hingga maksimum 1095 hari (tiga tahun). Untuk informasi selengkapnya, lihat [Mengonfigurasi ruang kerja Anda](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-workspace-configuration.html).
Ada dua metode untuk memasukkan metrik ke dalam Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus.
+ **Menggunakan kolektor AWS terkelola** - Amazon Managed Service for Prometheus menyediakan scraper tanpa agen yang dikelola sepenuhnya untuk mengikis metrik secara otomatis dari cluster Amazon Elastic Kubernetes Service (Amazon EKS) *Anda*. Mengikis secara otomatis menarik metrik dari titik akhir yang kompatibel dengan Prometheus.
+ **Menggunakan kolektor yang dikelola pelanggan** — Anda memiliki banyak pilihan untuk mengelola kolektor Anda sendiri. Dua kolektor yang paling umum digunakan adalah menginstal instance Prometheus Anda sendiri, berjalan dalam mode agen, atau menggunakan Distro untuk. AWS OpenTelemetry Keduanya dijelaskan secara rinci di bagian berikut.
Kolektor mengirim metrik ke Amazon Managed Service untuk Prometheus menggunakan fungsionalitas tulis jarak jauh Prometheus. Anda dapat langsung mengirim metrik ke Amazon Managed Service untuk Prometheus dengan menggunakan Prometheus remote write di aplikasi Anda sendiri. Untuk detail selengkapnya tentang langsung menggunakan remote write, dan konfigurasi penulisan jarak jauh, lihat [remote\$1write di](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#remote_write) dokumentasi Prometheus.
**Topics**
+ [Menelan metrik dengan AWS kolektor terkelola](AMP-collector.md)
+ [Kolektor yang dikelola pelanggan](self-managed-collectors.md)
# Menelan metrik dengan AWS kolektor terkelola
Kasus penggunaan umum untuk Amazon Managed Service untuk Prometheus adalah memantau klaster Kubernetes yang dikelola oleh Amazon Elastic Kubernetes Service (Amazon EKS). Cluster Kubernetes, dan banyak aplikasi yang berjalan di Amazon EKS, secara otomatis mengekspor metriknya untuk diakses oleh scraper yang kompatibel dengan Prometheus.
**catatan**
Amazon EKS mengekspos metrik, metrik, dan `kube-controller-manager` `kube-scheduler` metrik server API dalam sebuah cluster. Banyak teknologi dan aplikasi lain yang berjalan di lingkungan Kubernetes menyediakan metrik yang kompatibel dengan Prometheus. Untuk daftar eksportir yang terdokumentasi dengan baik, lihat [Eksportir dan integrasi dalam](https://prometheus.io/docs/instrumenting/exporters/) dokumentasi Prometheus.
Amazon Managed Service untuk Prometheus menyediakan scraper, *atau* kolektor yang dikelola sepenuhnya, tanpa agen, yang secara otomatis menemukan dan menarik metrik yang kompatibel dengan Prometheus. Anda tidak perlu mengelola, menginstal, menambal, atau memelihara agen atau pencakar. Layanan Terkelola Amazon untuk kolektor Prometheus menyediakan koleksi metrik yang andal, stabil, sangat tersedia, dan diskalakan secara otomatis untuk kluster Amazon EKS Anda. Layanan Terkelola Amazon untuk kolektor yang dikelola Prometheus bekerja dengan kluster Amazon EKS, termasuk EC2 dan Fargate.
Layanan Terkelola Amazon untuk kolektor Prometheus membuat Antarmuka Jaringan Elastis (ENI) per subnet yang ditentukan saat membuat scraper. Kolektor mengikis metrik melalui ini ENIs, dan menggunakannya `remote_write` untuk mendorong data ke Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus menggunakan titik akhir VPC. Data yang tergores tidak pernah bepergian di internet publik.
Topik berikut memberikan informasi selengkapnya tentang cara menggunakan Layanan Terkelola Amazon untuk kolektor Prometheus di klaster Amazon EKS Anda, dan tentang metrik yang dikumpulkan.
**Topics**
+ [Siapkan kolektor terkelola untuk Amazon EKS](AMP-collector-how-to.md)
+ [Siapkan kolektor Prometheus yang dikelola untuk Amazon MSK](prom-msk-integration.md)
+ [Apa itu metrik yang kompatibel dengan Prometheus?](prom-compatible-metrics.md)
+ [Pantau kolektor dengan log penjual](AMP-collector-vended-logs.md)
# Siapkan kolektor terkelola untuk Amazon EKS
Untuk menggunakan Layanan Terkelola Amazon untuk kolektor Prometheus, Anda membuat scraper yang menemukan dan menarik metrik di klaster Amazon EKS Anda. Anda juga dapat membuat scraper yang terintegrasi dengan Amazon Managed Streaming for Apache Kafka. Untuk informasi selengkapnya, lihat [Mengintegrasikan MSK Amazon](https://docs.aws.amazon.com/prometheus/latest/userguide/prom-msk-integration.html).
+ Anda dapat membuat scraper sebagai bagian dari pembuatan cluster Amazon EKS Anda. Untuk informasi selengkapnya tentang membuat klaster Amazon EKS, termasuk membuat scraper, lihat [Membuat klaster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) di *Panduan Pengguna Amazon EKS*.
+ Anda dapat membuat scraper Anda sendiri, secara terprogram dengan AWS API atau dengan menggunakan. AWS CLI
Layanan Terkelola Amazon untuk kolektor Prometheus menggores metrik yang kompatibel dengan Prometheus. Untuk informasi selengkapnya tentang metrik yang kompatibel dengan Prometheus, lihat. [Apa itu metrik yang kompatibel dengan Prometheus?](prom-compatible-metrics.md) Cluster Amazon EKS mengekspos metrik untuk server API. Cluster Amazon EKS yang merupakan versi Kubernetes `1.28` atau lebih tinggi juga mengekspos metrik untuk dan. `kube-scheduler` `kube-controller-manager` *Untuk informasi selengkapnya, lihat [Mengambil metrik mentah bidang kontrol dalam format Prometheus di Panduan Pengguna Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/view-raw-metrics.html#scheduler-controller-metrics).*
**catatan**
Metrik pengikisan dari cluster dapat dikenakan biaya untuk penggunaan jaringan. Salah satu cara untuk mengoptimalkan biaya ini adalah dengan mengonfigurasi `/metrics` titik akhir Anda untuk mengompres metrik yang disediakan (misalnya, dengan gzip), mengurangi data yang harus dipindahkan di seluruh jaringan. Cara melakukannya tergantung pada aplikasi atau pustaka yang menyediakan metrik. Beberapa perpustakaan gzip secara default.
Topik berikut menjelaskan cara membuat, mengelola, dan mengonfigurasi pencakar.
**Topics**
+ [Buat scraper](#AMP-collector-create)
+ [Mengonfigurasi klaster Amazon EKS Anda](#AMP-collector-eks-setup)
+ [Temukan dan hapus pencakar](#AMP-collector-list-delete)
+ [Konfigurasi scraper](#AMP-collector-configuration)
+ [Memecahkan masalah konfigurasi scraper](#AMP-collector-troubleshoot)
+ [Keterbatasan scraper](#AMP-collector-limits)
## Buat scraper
Layanan Dikelola Amazon untuk kolektor Prometheus terdiri dari scraper yang menemukan dan mengumpulkan metrik dari cluster Amazon EKS. Amazon Managed Service for Prometheus mengelola scraper untuk Anda, memberi Anda skalabilitas, keamanan, dan keandalan yang Anda butuhkan, tanpa harus mengelola instans, agen, atau pencakar apa pun sendiri.
Ada tiga cara untuk membuat scraper:
+ Scraper dibuat secara otomatis untuk Anda saat Anda [membuat cluster Amazon EKS melalui konsol Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) dan memilih untuk mengaktifkan metrik Prometheus.
+ Anda dapat membuat scraper dari konsol Amazon EKS untuk cluster yang ada. Buka cluster di [konsol Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters), lalu, pada tab **Observability**, pilih **Add scraper**.
*Untuk detail selengkapnya tentang pengaturan yang tersedia, lihat [Mengaktifkan metrik Prometheus di Panduan Pengguna](https://docs.aws.amazon.com/eks/latest/userguide/prometheus.html#turn-on-prometheus-metrics) Amazon EKS.*
+ Anda dapat membuat scraper menggunakan AWS API atau file. AWS CLI
Opsi-opsi ini dijelaskan dalam prosedur berikut.
Ada beberapa prasyarat untuk membuat scraper Anda sendiri:
+ Anda harus memiliki kluster Amazon EKS yang dibuat.
+ Cluster Amazon EKS Anda harus memiliki [kontrol akses titik akhir cluster](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html) yang disetel untuk menyertakan akses pribadi. Ini dapat mencakup pribadi dan publik, tetapi harus mencakup pribadi.
+ [VPC Amazon tempat klaster Amazon EKS berada harus mengaktifkan DNS.](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html)
**catatan**
Cluster akan dikaitkan dengan scraper dengan nama sumber daya Amazon (ARN). Jika Anda menghapus cluster, dan kemudian membuat yang baru dengan nama yang sama, ARN akan digunakan kembali untuk cluster baru. Karena itu, scraper akan mencoba mengumpulkan metrik untuk cluster baru. Anda [menghapus pencakar](#AMP-collector-list-delete) secara terpisah dari menghapus cluster.
------
#### [ AWS API ]
**Untuk membuat scraper menggunakan API AWS **
Gunakan operasi `CreateScraper` API untuk membuat scraper dengan AWS API. Contoh berikut membuat scraper di `us-west-2` Wilayah. Anda perlu mengganti informasi cluster Akun AWS, ruang kerja, keamanan, dan Amazon EKS dengan milik Anda sendiri IDs, dan menyediakan konfigurasi yang akan digunakan untuk scraper Anda.
**catatan**
Grup keamanan dan subnet harus diatur ke grup keamanan dan subnet untuk cluster yang Anda hubungkan.
Anda harus menyertakan setidaknya dua subnet, setidaknya dalam dua zona ketersediaan.
`scrapeConfiguration`Ini adalah file YAMM konfigurasi Prometheus yang dikodekan base64. Anda dapat mengunduh konfigurasi tujuan umum dengan operasi `GetDefaultScraperConfiguration` API. Untuk informasi lebih lanjut tentang format`scrapeConfiguration`, lihat[Konfigurasi scraper](#AMP-collector-configuration).
```
POST /scrapers HTTP/1.1
Content-Length: 415
Authorization: AUTHPARAMS
X-Amz-Date: 20201201T193725Z
User-Agent: aws-cli/1.18.147 Python/2.7.18 Linux/5.4.58-37.125.amzn2int.x86_64 botocore/1.18.6
{
"alias": "myScraper",
"destination": {
"ampConfiguration": {
"workspaceArn": "arn:aws:aps:us-west-2:account-id:workspace/ws-workspace-id"
}
},
"source": {
"eksConfiguration": {
"clusterArn": "arn:aws:eks:us-west-2:account-id:cluster/cluster-name",
"securityGroupIds": ["sg-security-group-id"],
"subnetIds": ["subnet-subnet-id-1", "subnet-subnet-id-2"]
}
},
"scrapeConfiguration": {
"configurationBlob":
}
}
```
------
#### [ AWS CLI ]
**Untuk membuat scraper menggunakan AWS CLI**
Gunakan `create-scraper` perintah untuk membuat scraper dengan file. AWS CLI Contoh berikut membuat scraper di `us-west-2` Wilayah. Anda perlu mengganti informasi cluster Akun AWS, ruang kerja, keamanan, dan Amazon EKS dengan milik Anda sendiri IDs, dan menyediakan konfigurasi yang akan digunakan untuk scraper Anda.
**catatan**
Grup keamanan dan subnet harus diatur ke grup keamanan dan subnet untuk cluster yang Anda hubungkan.
Anda harus menyertakan setidaknya dua subnet, setidaknya dalam dua zona ketersediaan.
`scrape-configuration`Ini adalah file YAMM konfigurasi Prometheus yang dikodekan base64. Anda dapat mengunduh konfigurasi tujuan umum dengan `get-default-scraper-configuration` perintah. Untuk informasi lebih lanjut tentang format`scrape-configuration`, lihat[Konfigurasi scraper](#AMP-collector-configuration).
```
aws amp create-scraper \
--source eksConfiguration="{clusterArn='arn:aws:eks:us-west-2:account-id:cluster/cluster-name', securityGroupIds=['sg-security-group-id'],subnetIds=['subnet-subnet-id-1', 'subnet-subnet-id-2']}" \
--scrape-configuration configurationBlob= \
--destination ampConfiguration="{workspaceArn='arn:aws:aps:us-west-2:account-id:workspace/ws-workspace-id'}"
```
------
Berikut ini adalah daftar lengkap operasi scraper yang dapat Anda gunakan dengan AWS API:
+ Buat scraper dengan operasi [CreateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_CreateScraper.html)API.
+ Buat daftar scraper yang ada dengan operasi [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html)API.
+ Perbarui alias, konfigurasi, atau tujuan scraper dengan operasi [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html)API.
+ Hapus scraper dengan operasi [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html)API.
+ Dapatkan detail selengkapnya tentang scraper dengan operasi [DescribeScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DescribeScraper.html)API.
+ Dapatkan konfigurasi tujuan umum untuk pencakar dengan operasi [GetDefaultScraperConfiguration](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_GetDefaultScraperConfiguration.html)API.
**catatan**
Cluster Amazon EKS yang Anda gores harus dikonfigurasi untuk memungkinkan Amazon Managed Service untuk Prometheus mengakses metrik. Topik berikutnya menjelaskan cara mengonfigurasi klaster Anda.
### Pengaturan lintas akun
Untuk membuat scraper lintas akun saat klaster Amazon EKS dan Layanan Terkelola Amazon untuk ruang kerja Prometheus berada di akun yang berbeda, gunakan prosedur berikut. Misalnya, Anda memiliki akun sumber yang `account_id_source` berisi kluster Amazon EKS dan akun target yang `account_id_target` berisi ruang kerja Amazon Managed Service for Prometheus.
**Untuk membuat scraper dalam pengaturan lintas akun**
1. Di akun sumber, buat peran `arn:aws:iam::account_id_source:role/Source` dan tambahkan kebijakan kepercayaan berikut.
```
{
"Effect": "Allow",
"Principal": {
"Service": [
"scraper.aps.amazonaws.com"
]
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "scraper_ARN"
},
"StringEquals": {
"AWS:SourceAccount": "account_id"
}
}
}
```
1. Di setiap kombinasi sumber (klaster Amazon EKS) dan target (Layanan Terkelola Amazon untuk ruang kerja Prometheus), Anda perlu membuat `arn:aws:iam::account_id_target:role/Target` peran dan menambahkan kebijakan kepercayaan berikut dengan izin untuk. [AmazonPrometheusRemoteWriteAccess](https://docs.aws.amazon.com/prometheus/latest/userguide/security-iam-awsmanpol.html)
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::account_id_source:role/Source"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"sts:ExternalId": "scraper_ARN"
}
}
}
```
1. Buat scraper dengan `--role-configuration` opsi.
```
aws amp create-scraper \
--source eksConfiguration="{clusterArn='arn:aws:eks:us-west-2:account-id_source:cluster/xarw,subnetIds=[subnet-subnet-id]}" \
--scrape-configuration configurationBlob= \
--destination ampConfiguration="{workspaceArn='arn:aws:aps:us-west-2:account-id_target:workspace/ws-workspace-id'}"\
--role-configuration '{"sourceRoleArn":"arn:aws:iam::account-id_source:role/Source", "targetRoleArn":"arn:aws:iam::account-id_target:role/Target"}'
```
1. Validasi pembuatan scraper.
```
aws amp list-scrapers
{
"scrapers": [
{
"scraperId": "scraper-id",
"arn": "arn:aws:aps:us-west-2:account_id_source:scraper/scraper-id",
"roleArn": "arn:aws:iam::account_id_source:role/aws-service-role/scraper.aps.amazonaws.com/AWSServiceRoleForAmazonPrometheusScraperInternal_cc319052-41a3-4",
"status": {
"statusCode": "ACTIVE"
},
"createdAt": "2024-10-29T16:37:58.789000+00:00",
"lastModifiedAt": "2024-10-29T16:55:17.085000+00:00",
"tags": {},
"source": {
"eksConfiguration": {
"clusterArn": "arn:aws:eks:us-west-2:account_id_source:cluster/xarw",
"securityGroupIds": [
"sg-security-group-id",
"sg-security-group-id"
],
"subnetIds": [
"subnet-subnet_id"
]
}
},
"destination": {
"ampConfiguration": {
"workspaceArn": "arn:aws:aps:us-west-2:account_id_target:workspace/ws-workspace-id"
}
}
}
]
}
```
### Mengubah antara RoleConfiguration dan peran terkait layanan
Jika Anda ingin beralih kembali ke peran terkait layanan alih-alih menulis `RoleConfiguration` ke Layanan Terkelola Amazon untuk ruang kerja Prometheus, Anda harus memperbarui `UpdateScraper` dan menyediakan ruang kerja di akun yang sama dengan scraper tanpa. `RoleConfiguration` `RoleConfiguration`Akan dihapus dari scraper dan peran terkait layanan akan digunakan.
Ketika Anda mengubah ruang kerja di akun yang sama dengan scraper dan Anda ingin terus menggunakan`RoleConfiguration`, Anda harus memberikan on lagi. `RoleConfiguration` `UpdateScraper`
### Membuat scraper untuk ruang kerja yang diaktifkan dengan kunci yang dikelola pelanggan
Untuk membuat scraper untuk memasukkan metrik ke dalam Layanan Terkelola Amazon untuk ruang kerja Prometheus dengan [kunci yang dikelola pelanggan](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk), gunakan dengan sumber dan target yang disetel ke akun yang `--role-configuration` sama.
```
aws amp create-scraper \
--source eksConfiguration="{clusterArn='arn:aws:eks:us-west-2:account-id:cluster/xarw,subnetIds=[subnet-subnet_id]}" \
--scrape-configuration configurationBlob= \
--destination ampConfiguration="{workspaceArn='arn:aws:aps:us-west-2:account-id:workspace/ws-workspace-id'}"\
--role-configuration '{"sourceRoleArn":"arn:aws:iam::account_id:role/Source", "targetRoleArn":"arn:aws:iam::account_id:role/Target"}'
```
### Kesalahan umum saat membuat pencakar
Berikut ini adalah masalah paling umum saat mencoba membuat scraper baru.
+ AWS Sumber daya yang dibutuhkan tidak ada. *Grup keamanan*, *subnet*, dan *klaster Amazon EKS* yang ditentukan harus ada.
+ Ruang alamat IP tidak mencukupi. Anda harus memiliki setidaknya satu alamat IP yang tersedia di setiap subnet yang Anda lewatkan ke `CreateScraper` API.
## Mengonfigurasi klaster Amazon EKS Anda
Cluster Amazon EKS Anda harus dikonfigurasi untuk memungkinkan scraper mengakses metrik. Ada dua opsi untuk konfigurasi ini:
+ Gunakan *entri akses* Amazon EKS untuk secara otomatis menyediakan Layanan Terkelola Amazon untuk akses kolektor Prometheus ke klaster Anda.
+ Konfigurasikan cluster Amazon EKS Anda secara manual untuk pengikisan metrik terkelola.
Topik berikut menjelaskan masing-masing secara lebih rinci.
### Konfigurasikan Amazon EKS untuk akses scraper dengan entri akses
Menggunakan entri akses untuk Amazon EKS adalah cara termudah untuk memberi Amazon Managed Service for Prometheus akses untuk mengikis metrik dari cluster Anda.
Cluster Amazon EKS yang Anda gores harus dikonfigurasi untuk memungkinkan otentikasi API. Mode otentikasi cluster harus diatur ke salah satu `API` atau`API_AND_CONFIG_MAP`. Ini dapat dilihat di konsol Amazon EKS pada tab **konfigurasi Access** pada detail cluster. Untuk informasi selengkapnya, lihat [Mengizinkan peran IAM atau pengguna mengakses objek Kubernetes di klaster Amazon EKS Anda di Panduan Pengguna *Amazon* EKS](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html).
Anda dapat membuat scraper saat membuat cluster, atau setelah membuat cluster:
+ **Saat membuat klaster** — Anda dapat mengonfigurasi akses ini saat [membuat klaster Amazon EKS melalui konsol Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) (ikuti petunjuk untuk membuat scraper sebagai bagian dari cluster), dan kebijakan entri akses akan dibuat secara otomatis, memberikan Layanan Terkelola Amazon untuk Prometheus akses ke metrik klaster.
+ **Menambahkan setelah cluster dibuat** — jika kluster Amazon EKS Anda sudah ada, maka setel mode otentikasi ke salah satu `API` atau`API_AND_CONFIG_MAP`, dan pencakar apa pun yang Anda buat [melalui Layanan Terkelola Amazon untuk API Prometheus atau CLI atau melalui konsol Amazon EKS akan secara otomatis memiliki kebijakan entri](#AMP-collector-create) akses yang benar dibuat untuk Anda, dan pencakar akan memiliki akses ke cluster Anda.
**Kebijakan entri akses dibuat**
Saat Anda membuat scraper dan membiarkan Amazon Managed Service untuk Prometheus membuat kebijakan entri akses untuk Anda, itu akan menghasilkan kebijakan berikut. Untuk informasi selengkapnya tentang entri akses, lihat [Mengizinkan peran IAM atau pengguna mengakses Kubernetes](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html) di Panduan Pengguna *Amazon* EKS.
```
{
"rules": [
{
"effect": "allow",
"apiGroups": [
""
],
"resources": [
"nodes",
"nodes/proxy",
"nodes/metrics",
"services",
"endpoints",
"pods",
"ingresses",
"configmaps"
],
"verbs": [
"get",
"list",
"watch"
]
},
{
"effect": "allow",
"apiGroups": [
"extensions",
"networking.k8s.io"
],
"resources": [
"ingresses/status",
"ingresses"
],
"verbs": [
"get",
"list",
"watch"
]
},
{
"effect": "allow",
"apiGroups": [
"metrics.eks.amazonaws.com"
],
"resources": [
"kcm/metrics",
"ksh/metrics"
],
"verbs": [
"get"
]
},
{
"effect": "allow",
"nonResourceURLs": [
"/metrics"
],
"verbs": [
"get"
]
}
]
}
```
### Mengkonfigurasi Amazon EKS secara manual untuk akses scraper
Jika Anda lebih suka menggunakan akses kontrol `aws-auth ConfigMap` to ke cluster kubernetes Anda, Anda masih dapat memberikan Amazon Managed Service untuk Prometheus scraper akses ke metrik Anda. Langkah-langkah berikut akan memberi Amazon Managed Service for Prometheus akses untuk mengikis metrik dari klaster Amazon EKS Anda.
**catatan**
Untuk informasi selengkapnya tentang `ConfigMap` dan mengakses entri, lihat [Mengizinkan peran IAM atau pengguna mengakses Kubernetes](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html) di Panduan Pengguna *Amazon* EKS.
Prosedur ini menggunakan `kubectl` dan AWS CLI. Untuk informasi tentang menginstal`kubectl`, lihat [Menginstal kubectl di Panduan](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) Pengguna *Amazon EKS*.
**Untuk mengonfigurasi klaster Amazon EKS secara manual untuk pengikisan metrik terkelola**
1. Buat file, bernama`clusterrole-binding.yml`, dengan teks berikut:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: aps-collector-role
rules:
- apiGroups: [""]
resources: ["nodes", "nodes/proxy", "nodes/metrics", "services", "endpoints", "pods", "ingresses", "configmaps"]
verbs: ["describe", "get", "list", "watch"]
- apiGroups: ["extensions", "networking.k8s.io"]
resources: ["ingresses/status", "ingresses"]
verbs: ["describe", "get", "list", "watch"]
- nonResourceURLs: ["/metrics"]
verbs: ["get"]
- apiGroups: ["metrics.eks.amazonaws.com"]
resources: ["kcm/metrics", "ksh/metrics"]
verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: aps-collector-user-role-binding
subjects:
- kind: User
name: aps-collector-user
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: ClusterRole
name: aps-collector-role
apiGroup: rbac.authorization.k8s.io
```
1. Jalankan perintah berikut di cluster Anda:
```
kubectl apply -f clusterrole-binding.yml
```
Ini akan membuat pengikatan dan aturan peran cluster. Contoh ini digunakan `aps-collector-role` sebagai nama peran, dan `aps-collector-user` sebagai nama pengguna.
1. Perintah berikut memberi Anda informasi tentang scraper dengan ID*scraper-id*. Ini adalah scraper yang Anda buat menggunakan perintah di bagian sebelumnya.
```
aws amp describe-scraper --scraper-id scraper-id
```
1. Dari hasil`describe-scraper`, temukan `roleArn` .This akan memiliki format berikut:
```
arn:aws:iam::account-id:role/aws-service-role/scraper.aps.amazonaws.com/AWSServiceRoleForAmazonPrometheusScraper_unique-id
```
Amazon EKS membutuhkan format yang berbeda untuk ARN ini. Anda harus menyesuaikan format ARN yang dikembalikan untuk digunakan pada langkah berikutnya. Edit agar sesuai dengan format ini:
```
arn:aws:iam::account-id:role/AWSServiceRoleForAmazonPrometheusScraper_unique-id
```
Misalnya, ARN ini:
```
arn:aws:iam::111122223333:role/aws-service-role/scraper.aps.amazonaws.com/AWSServiceRoleForAmazonPrometheusScraper_1234abcd-56ef-7
```
Harus ditulis ulang sebagai:
```
arn:aws:iam::111122223333:role/AWSServiceRoleForAmazonPrometheusScraper_1234abcd-56ef-7
```
1. Jalankan perintah berikut di cluster Anda, menggunakan modifikasi `roleArn` dari langkah sebelumnya, serta nama cluster dan wilayah Anda. :
```
eksctl create iamidentitymapping --cluster cluster-name --region region-id --arn roleArn --username aps-collector-user
```
Ini memungkinkan scraper untuk mengakses cluster menggunakan peran dan pengguna yang Anda buat dalam `clusterrole-binding.yml` file.
## Temukan dan hapus pencakar
Anda dapat menggunakan AWS API atau AWS CLI untuk membuat daftar pencakar di akun Anda atau untuk menghapusnya.
**catatan**
Pastikan Anda menggunakan versi terbaru AWS CLI atau SDK. Versi terbaru memberi Anda fitur dan fungsionalitas terbaru, serta pembaruan keamanan. Atau, gunakan [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), yang selalu memberikan pengalaman baris up-to-date perintah, secara otomatis.
Untuk mencantumkan semua pencakar di akun Anda, gunakan operasi [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html)API.
Atau, dengan AWS CLI, hubungi:
```
aws amp list-scrapers --region aws-region
```
`ListScrapers`mengembalikan semua pencakar di akun Anda, misalnya:
```
{
"scrapers": [
{
"scraperId": "s-1234abcd-56ef-7890-abcd-1234ef567890",
"arn": "arn:aws:aps:us-west-2:123456789012:scraper/s-1234abcd-56ef-7890-abcd-1234ef567890",
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/AWSServiceRoleForAmazonPrometheusScraper_1234abcd-2931",
"status": {
"statusCode": "DELETING"
},
"createdAt": "2023-10-12T15:22:19.014000-07:00",
"lastModifiedAt": "2023-10-12T15:55:43.487000-07:00",
"tags": {},
"source": {
"eksConfiguration": {
"clusterArn": "arn:aws:eks:us-west-2:123456789012:cluster/my-cluster",
"securityGroupIds": [
"sg-1234abcd5678ef90"
],
"subnetIds": [
"subnet-abcd1234ef567890",
"subnet-1234abcd5678ab90"
]
}
},
"destination": {
"ampConfiguration": {
"workspaceArn": "arn:aws:aps:us-west-2:123456789012:workspace/ws-1234abcd-5678-ef90-ab12-cdef3456a78"
}
}
}
]
}
```
Untuk menghapus scraper, cari scraper yang ingin Anda hapus, menggunakan `ListScrapers` operasi, dan kemudian gunakan [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html)operasi untuk menghapusnya. `scraperId`
Atau, dengan AWS CLI, hubungi:
```
aws amp delete-scraper --scraper-id scraperId
```
## Konfigurasi scraper
Anda dapat mengontrol bagaimana scraper Anda menemukan dan mengumpulkan metrik dengan konfigurasi scraper yang kompatibel dengan Prometheus. Misalnya, Anda dapat mengubah interval metrik yang dikirim ke ruang kerja. Anda juga dapat menggunakan pelabelan ulang untuk menulis ulang label metrik secara dinamis. Konfigurasi scraper adalah file YAMG yang merupakan bagian dari definisi scraper.
Saat scraper baru dibuat, Anda menentukan konfigurasi dengan menyediakan file YAMM yang dikodekan base64 dalam panggilan API. Anda dapat mengunduh file konfigurasi tujuan umum dengan `GetDefaultScraperConfiguration` operasi di Amazon Managed Service for Prometheus API.
Untuk memodifikasi konfigurasi scraper, Anda dapat menggunakan `UpdateScraper` operasi. Jika Anda perlu memperbarui sumber metrik (misalnya, ke cluster Amazon EKS yang berbeda), Anda harus menghapus scraper dan membuatnya kembali dengan sumber baru.
**Konfigurasi yang didukung**
Untuk informasi tentang format konfigurasi scraper, termasuk rincian rinci dari nilai yang mungkin, lihat [Konfigurasi](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) dalam dokumentasi Prometheus. Opsi konfigurasi global, dan `` opsi menjelaskan opsi yang paling umum dibutuhkan.
Karena Amazon EKS adalah satu-satunya layanan yang didukung, satu-satunya service discovery config (`<*_sd_config>`) yang didukung adalah. ``
Daftar lengkap bagian konfigurasi diperbolehkan:
+ ``
+ ``
+ ``
+ ``
+ ``
+ ``
Keterbatasan dalam bagian ini tercantum setelah file konfigurasi sampel.
**Contoh file konfigurasi**
Berikut ini adalah contoh file konfigurasi YAMAL dengan interval scrape 30 detik. Contoh ini mencakup dukungan untuk metrik server API kube, serta metrik kube-controller-manager dan kube-scheduler. *Untuk informasi selengkapnya, lihat [Mengambil metrik mentah bidang kontrol dalam format Prometheus di Panduan Pengguna Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/view-raw-metrics.html#scheduler-controller-metrics).*
```
global:
scrape_interval: 30s
external_labels:
clusterArn: apiserver-test-2
scrape_configs:
- job_name: pod_exporter
kubernetes_sd_configs:
- role: pod
- job_name: cadvisor
scheme: https
authorization:
type: Bearer
credentials_file: /var/run/secrets/kubernetes.io/serviceaccount/token
kubernetes_sd_configs:
- role: node
relabel_configs:
- action: labelmap
regex: __meta_kubernetes_node_label_(.+)
- replacement: kubernetes.default.svc:443
target_label: __address__
- source_labels: [__meta_kubernetes_node_name]
regex: (.+)
target_label: __metrics_path__
replacement: /api/v1/nodes/$1/proxy/metrics/cadvisor
# apiserver metrics
- scheme: https
authorization:
type: Bearer
credentials_file: /var/run/secrets/kubernetes.io/serviceaccount/token
job_name: kubernetes-apiservers
kubernetes_sd_configs:
- role: endpoints
relabel_configs:
- action: keep
regex: default;kubernetes;https
source_labels:
- __meta_kubernetes_namespace
- __meta_kubernetes_service_name
- __meta_kubernetes_endpoint_port_name
# kube proxy metrics
- job_name: kube-proxy
honor_labels: true
kubernetes_sd_configs:
- role: pod
relabel_configs:
- action: keep
source_labels:
- __meta_kubernetes_namespace
- __meta_kubernetes_pod_name
separator: '/'
regex: 'kube-system/kube-proxy.+'
- source_labels:
- __address__
action: replace
target_label: __address__
regex: (.+?)(\\:\\d+)?
replacement: $1:10249
# Scheduler metrics
- job_name: 'ksh-metrics'
kubernetes_sd_configs:
- role: endpoints
metrics_path: /apis/metrics.eks.amazonaws.com/v1/ksh/container/metrics
scheme: https
bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
relabel_configs:
- source_labels:
- __meta_kubernetes_namespace
- __meta_kubernetes_service_name
- __meta_kubernetes_endpoint_port_name
action: keep
regex: default;kubernetes;https
# Controller Manager metrics
- job_name: 'kcm-metrics'
kubernetes_sd_configs:
- role: endpoints
metrics_path: /apis/metrics.eks.amazonaws.com/v1/kcm/container/metrics
scheme: https
bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
relabel_configs:
- source_labels:
- __meta_kubernetes_namespace
- __meta_kubernetes_service_name
- __meta_kubernetes_endpoint_port_name
action: keep
regex: default;kubernetes;https
```
Berikut ini adalah batasan khusus untuk kolektor yang AWS dikelola:
+ **Interval mengikis** - Konfigurasi scraper tidak dapat menentukan interval gesekan kurang dari 30 detik.
+ **Target** — Target dalam `static_config` harus ditentukan sebagai alamat IP.
+ **Resolusi DNS** — Terkait dengan nama target, satu-satunya nama server yang dikenali dalam konfigurasi ini adalah server api Kubernetes,. `kubernetes.default.svc` Semua nama mesin lainnya harus ditentukan oleh alamat IP.
+ **Otorisasi** - Hilangkan jika tidak ada otorisasi yang diperlukan. Jika diperlukan, otorisasi harus`Bearer`, dan harus menunjuk ke file`/var/run/secrets/kubernetes.io/serviceaccount/token`. Dengan kata lain, jika digunakan, bagian otorisasi harus terlihat seperti berikut:
```
authorization:
type: Bearer
credentials_file: /var/run/secrets/kubernetes.io/serviceaccount/token
```
**catatan**
`type: Bearer`adalah default, sehingga dapat dihilangkan.
## Memecahkan masalah konfigurasi scraper
Layanan Terkelola Amazon untuk kolektor Prometheus secara otomatis menemukan dan mengikis metrik. Tetapi bagaimana Anda bisa memecahkan masalah saat Anda tidak melihat metrik yang Anda harapkan di Layanan Terkelola Amazon untuk ruang kerja Prometheus?
**penting**
Verifikasi bahwa akses pribadi untuk kluster Amazon EKS Anda diaktifkan. Untuk informasi selengkapnya, lihat [Titik akhir pribadi cluster](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html#cluster-endpoint-private) di *Panduan Pengguna Amazon EKS*.
`up`Metrik adalah alat yang bermanfaat. Untuk setiap titik akhir yang ditemukan oleh Amazon Managed Service untuk kolektor Prometheus, secara otomatis menjual metrik ini. Ada tiga status metrik ini yang dapat membantu Anda memecahkan masalah apa yang terjadi di dalam kolektor.
+ `up`tidak ada — Jika tidak ada `up` metrik untuk titik akhir, maka itu berarti kolektor tidak dapat menemukan titik akhir.
Jika Anda yakin bahwa titik akhir ada, ada beberapa alasan mengapa kolektor mungkin tidak dapat menemukannya.
+ Anda mungkin perlu menyesuaikan konfigurasi scrape. Penemuan ini `relabel_config` mungkin perlu disesuaikan.
+ Mungkin ada masalah dengan yang `role` digunakan untuk penemuan.
+ VPC Amazon yang digunakan oleh cluster Amazon EKS mungkin tidak [mengaktifkan DNS](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html), yang akan mencegah kolektor menemukan titik akhir.
+ `up`ada, tetapi selalu 0 — Jika `up` ada, tetapi 0, maka kolektor dapat menemukan titik akhir, tetapi tidak dapat menemukan metrik yang kompatibel dengan Prometheus.
Dalam hal ini, Anda dapat mencoba menggunakan `curl` perintah terhadap titik akhir secara langsung. Anda dapat memvalidasi bahwa Anda memiliki detail yang benar, misalnya, protokol (`http`atau`https`), titik akhir, atau port yang Anda gunakan. Anda juga dapat memeriksa apakah titik akhir merespons dengan respons yang valid, dan mengikuti `200` format Prometheus. Akhirnya, tubuh respons tidak bisa lebih besar dari ukuran maksimum yang diizinkan. (Untuk batasan kolektor AWS terkelola, lihat bagian berikut.)
+ `up`hadir dan lebih besar dari 0 — Jika `up` ada, dan lebih besar dari 0, maka metrik sedang dikirim ke Amazon Managed Service untuk Prometheus.
Validasi bahwa Anda mencari metrik yang benar di Amazon Managed Service untuk Prometheus (atau dasbor alternatif Anda, seperti Grafana yang Dikelola Amazon). Anda dapat menggunakan curl lagi untuk memeriksa data yang diharapkan di titik `/metrics` akhir Anda. Periksa juga apakah Anda belum melampaui batas lain, seperti jumlah titik akhir per scraper. Anda dapat memeriksa jumlah titik akhir metrik yang dikikis dengan memeriksa jumlah metrik, menggunakan. `up` `count(up)`
## Keterbatasan scraper
Ada beberapa batasan untuk pencakar yang dikelola sepenuhnya yang disediakan oleh Amazon Managed Service untuk Prometheus.
+ **Wilayah** — Cluster EKS Anda, scraper terkelola, dan Layanan Terkelola Amazon untuk ruang kerja Prometheus semuanya harus berada di Wilayah yang sama. AWS
+ **Kolektor** - Anda dapat memiliki maksimal 10 Layanan Dikelola Amazon untuk pencakar Prometheus per wilayah per akun.
**catatan**
Anda dapat meminta kenaikan batas ini dengan [meminta kenaikan kuota](https://console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase).
+ **Respons metrik** - Isi respons dari salah satu permintaan `/metrics` titik akhir tidak boleh lebih dari 50 megabyte (MB).
+ **Titik akhir per scraper** - Scraper dapat mengikis maksimum 30.000 titik akhir. `/metrics`
+ **Interval mengikis** - Konfigurasi scraper tidak dapat menentukan interval gesekan kurang dari 30 detik.
# Siapkan kolektor Prometheus yang dikelola untuk Amazon MSK
Untuk menggunakan Layanan Terkelola Amazon untuk kolektor Prometheus, Anda membuat scraper yang menemukan dan menarik metrik di cluster Amazon Managed Streaming for Apache Kafka. Anda juga dapat membuat scraper yang terintegrasi dengan Amazon Elastic Kubernetes Service. Untuk informasi selengkapnya, lihat [Mengintegrasikan Amazon EKS](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-collector-how-to.html).
## Buat scraper
Layanan Dikelola Amazon untuk kolektor Prometheus terdiri dari scraper yang menemukan dan mengumpulkan metrik dari cluster MSK Amazon. Amazon Managed Service for Prometheus mengelola scraper untuk Anda, memberi Anda skalabilitas, keamanan, dan keandalan yang Anda butuhkan, tanpa harus mengelola instans, agen, atau pencakar apa pun sendiri.
Anda dapat membuat scraper menggunakan AWS API atau AWS CLI seperti yang dijelaskan dalam prosedur berikut.
Ada beberapa prasyarat untuk membuat scraper Anda sendiri:
+ Anda harus memiliki kluster MSK Amazon yang dibuat.
+ Konfigurasikan grup keamanan klaster MSK Amazon Anda untuk mengizinkan lalu lintas masuk pada port **11001 (Eksportir JMX) dan 11002 (Node Exporter)** **dalam VPC Amazon Anda, karena scraper memerlukan akses** ke catatan DNS ini untuk mengumpulkan metrik Prometheus.
+ [VPC Amazon tempat klaster MSK Amazon berada harus mengaktifkan DNS.](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html)
**catatan**
Cluster akan dikaitkan dengan scraper dengan nama sumber daya Amazon (ARN). Jika Anda menghapus cluster, dan kemudian membuat yang baru dengan nama yang sama, ARN akan digunakan kembali untuk cluster baru. Karena itu, scraper akan mencoba mengumpulkan metrik untuk cluster baru. Anda [menghapus pencakar](#prom-msk-delete-scraper) secara terpisah dari menghapus cluster.
------
#### [ To create a scraper using the AWS API ]
Gunakan operasi `CreateScraper` API untuk membuat scraper dengan AWS API. Contoh berikut membuat scraper di Wilayah AS Timur (Virginia N.). Ganti *example* konten dengan informasi cluster MSK Amazon Anda, dan berikan konfigurasi scraper Anda.
**catatan**
Konfigurasikan grup keamanan dan subnet agar sesuai dengan kluster target Anda. Sertakan setidaknya dua subnet di dua zona ketersediaan.
```
POST /scrapers HTTP/1.1
Content-Length: 415
Authorization: AUTHPARAMS
X-Amz-Date: 20201201T193725Z
User-Agent: aws-cli/1.18.147 Python/2.7.18 Linux/5.4.58-37.125.amzn2int.x86_64 botocore/1.18.6
{
"alias": "myScraper",
"destination": {
"ampConfiguration": {
"workspaceArn": "arn:aws:aps:us-east-1:123456789012:workspace/ws-workspace-id"
}
},
"source": {
"vpcConfiguration": {
"securityGroupIds": ["sg-security-group-id"],
"subnetIds": ["subnet-subnet-id-1", "subnet-subnet-id-2"]
}
},
"scrapeConfiguration": {
"configurationBlob": base64-encoded-blob
}
}
```
Dalam contoh, `scrapeConfiguration` parameter memerlukan file YAMM konfigurasi Prometheus yang dikodekan base64 yang menentukan catatan DNS dari kluster MSK.
Setiap catatan DNS mewakili titik akhir broker di Availability Zone tertentu, memungkinkan klien untuk terhubung ke broker yang didistribusikan di seluruh pilihan Anda AZs untuk ketersediaan tinggi.
Jumlah catatan DNS di properti klaster MSK Anda sesuai dengan jumlah node broker dan Availability Zone dalam konfigurasi klaster Anda:
+ **Konfigurasi default** - 3 node broker di 3 AZs = 3 catatan DNS
+ **Konfigurasi khusus** - 2 node broker di 2 AZs = 2 catatan DNS
[Untuk mendapatkan catatan DNS untuk cluster MSK Anda, buka konsol MSK di rumah? https://console.aws.amazon.com/msk/ region=us-east-1\$1/home/](https://console.aws.amazon.com/msk/home?region=us-east-1#/home/). Pergi ke cluster MSK Anda. Pilih **Properti**, **Broker**, dan **Titik Akhir**.
Anda memiliki dua opsi untuk mengonfigurasi Prometheus untuk mengikis metrik dari cluster MSK Anda:
1. **Resolusi DNS tingkat cluster (Disarankan)** — Gunakan nama DNS dasar cluster untuk secara otomatis menemukan semua broker. Jika titik akhir broker Anda`b-1.clusterName.xxx.xxx.xxx`, gunakan `clusterName.xxx.xxx.xxx` sebagai catatan DNS. Hal ini memungkinkan Prometheus untuk secara otomatis mengikis semua broker di cluster.
**Titik akhir broker individu** — Tentukan setiap titik akhir broker secara individual untuk kontrol granular. Gunakan pengidentifikasi broker lengkap (b-1, b-2) dalam konfigurasi Anda. Contoh:
```
dns_sd_configs:
- names:
- b-1.clusterName.xxx.xxx.xxx
- b-2.clusterName.xxx.xxx.xxx
- b-3.clusterName.xxx.xxx.xxx
```
**catatan**
Ganti `clusterName.xxx.xxx.xxx` dengan titik akhir klaster MSK Anda yang sebenarnya dari Konsol. AWS
Untuk informasi lebih lanjut, lihat[https://prometheus.io/docs/prometheus/latest/configuration/configuration/#dns_sd_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#dns_sd_config) di dokumentasi *Prometheus*.
Berikut ini adalah contoh file konfigurasi scraper:
```
global:
scrape_interval: 30s
external_labels:
clusterArn: msk-test-1
scrape_configs:
- job_name: msk-jmx
scheme: http
metrics_path: /metrics
scrape_timeout: 10s
dns_sd_configs:
- names:
- dns-record-1
- dns-record-2
- dns-record-3
type: A
port: 11001
relabel_configs:
- source_labels: [__meta_dns_name]
target_label: broker_dns
- source_labels: [__address__]
target_label: instance
regex: '(.*)'
replacement: '${1}'
- job_name: msk-node
scheme: http
metrics_path: /metrics
scrape_timeout: 10s
dns_sd_configs:
- names:
- dns-record-1
- dns-record-2
- dns-record-3
type: A
port: 11002
relabel_configs:
- source_labels: [__meta_dns_name]
target_label: broker_dns
- source_labels: [__address__]
target_label: instance
regex: '(.*)'
replacement: '${1}'
```
Jalankan salah satu perintah berikut untuk mengonversi file YAMM ke base64. Anda juga dapat menggunakan konverter base64 online apa pun untuk mengonversi file.
**Example Linux/macOS**
```
echo -n scraper config updated with dns records | base64
```
**Example Jendela PowerShell**
```
[Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes(scraper config updated with dns records))
```
------
#### [ To create a scraper using the AWS CLI ]
Gunakan `create-scraper` perintah untuk membuat scraper menggunakan file. AWS Command Line Interface Contoh berikut membuat scraper di Wilayah AS Timur (Virginia N.). Ganti *example* konten dengan informasi cluster MSK Amazon Anda, dan berikan konfigurasi scraper Anda.
**catatan**
Konfigurasikan grup keamanan dan subnet agar sesuai dengan kluster target Anda. Sertakan setidaknya dua subnet di dua zona ketersediaan.
```
aws amp create-scraper \
--source vpcConfiguration="{securityGroupIds=['sg-security-group-id'],subnetIds=['subnet-subnet-id-1', 'subnet-subnet-id-2']}" \
--scrape-configuration configurationBlob=base64-encoded-blob \
--destination ampConfiguration="{workspaceArn='arn:aws:aps:us-west-2:123456789012:workspace/ws-workspace-id'}"
```
------
+ Berikut ini adalah daftar lengkap operasi scraper yang dapat Anda gunakan dengan AWS API:
Buat scraper dengan operasi [CreateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_CreateScraper.html)API.
+ Buat daftar scraper yang ada dengan operasi [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html)API.
+ Perbarui alias, konfigurasi, atau tujuan scraper dengan operasi [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html)API.
+ Hapus scraper dengan operasi [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html)API.
+ Dapatkan detail selengkapnya tentang scraper dengan operasi [DescribeScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DescribeScraper.html)API.
## Pengaturan lintas akun
Untuk membuat scraper dalam penyiapan lintas akun saat klaster MSK Amazon tempat Anda ingin mengumpulkan metrik berada di akun yang berbeda dari kolektor Layanan Terkelola Amazon untuk Prometheus, gunakan prosedur di bawah ini.
Misalnya, ketika Anda memiliki dua akun, akun sumber pertama `account_id_source` tempat MSK Amazon berada, dan akun target kedua `account_id_target` tempat Amazon Managed Service untuk ruang kerja Prometheus berada.
**Untuk membuat scraper dalam pengaturan lintas akun**
1. Di akun sumber, buat peran `arn:aws:iam::111122223333:role/Source` dan tambahkan kebijakan kepercayaan berikut.
```
{
"Effect": "Allow",
"Principal": {
"Service": [
"scraper.aps.amazonaws.com"
]
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:aps:aws-region:111122223333:scraper/scraper-id"
},
"StringEquals": {
"AWS:SourceAccount": "111122223333"
}
}
}
```
1. Di setiap kombinasi sumber (klaster MSK Amazon) dan target (Layanan Terkelola Amazon untuk ruang kerja Prometheus), Anda perlu membuat `arn:aws:iam::444455556666:role/Target` peran dan menambahkan kebijakan kepercayaan berikut dengan izin untuk. [AmazonPrometheusRemoteWriteAccess](https://docs.aws.amazon.com/prometheus/latest/userguide/security-iam-awsmanpol.html)
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/Source"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"sts:ExternalId": "arn:aws:aps:aws-region:111122223333:scraper/scraper-id"
}
}
}
```
1. Buat scraper dengan `--role-configuration` opsi.
```
aws amp create-scraper \ --source vpcConfiguration="{subnetIds=[subnet-subnet-id], "securityGroupIds": ["sg-security-group-id"]}" \ --scrape-configuration configurationBlob= \ --destination ampConfiguration="{workspaceArn='arn:aws:aps:aws-region:444455556666:workspace/ws-workspace-id'}"\ --role-configuration '{"sourceRoleArn":"arn:aws:iam::111122223333:role/Source", "targetRoleArn":"arn:aws:iam::444455556666:role/Target"}'
```
1. Validasi pembuatan scraper.
```
aws amp list-scrapers
{
"scrapers": [
{
"scraperId": "s-example123456789abcdef0",
"arn": "arn:aws:aps:aws-region:111122223333:scraper/s-example123456789abcdef0": "arn:aws:iam::111122223333:role/Source",
"status": "ACTIVE",
"creationTime": "2025-10-27T18:45:00.000Z",
"lastModificationTime": "2025-10-27T18:50:00.000Z",
"tags": {},
"statusReason": "Scraper is running successfully",
"source": {
"vpcConfiguration": {
"subnetIds": ["subnet-subnet-id"],
"securityGroupIds": ["sg-security-group-id"]
}
},
"destination": {
"ampConfiguration": {
"workspaceArn": "arn:aws:aps:aws-region:444455556666:workspace/ws-workspace-id'"
}
},
"scrapeConfiguration": {
"configurationBlob": ""
}
}
]
}
```
## Mengubah antara RoleConfiguration dan peran terkait layanan
Jika Anda ingin beralih kembali ke peran terkait layanan alih-alih menulis `RoleConfiguration` ke Layanan Terkelola Amazon untuk ruang kerja Prometheus, Anda harus memperbarui `UpdateScraper` dan menyediakan ruang kerja di akun yang sama dengan scraper tanpa. `RoleConfiguration` `RoleConfiguration`Akan dihapus dari scraper dan peran terkait layanan akan digunakan.
Ketika Anda mengubah ruang kerja di akun yang sama dengan scraper dan Anda ingin terus menggunakan`RoleConfiguration`, Anda harus memberikan on lagi. `RoleConfiguration` `UpdateScraper`
## Temukan dan hapus pencakar
Anda dapat menggunakan AWS API atau AWS CLI untuk membuat daftar pencakar di akun Anda atau untuk menghapusnya.
**catatan**
Pastikan Anda menggunakan versi terbaru AWS CLI atau SDK. Versi terbaru memberi Anda fitur dan fungsionalitas terbaru, serta pembaruan keamanan. Atau, gunakan [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), yang selalu memberikan pengalaman baris up-to-date perintah, secara otomatis.
Untuk mencantumkan semua pencakar di akun Anda, gunakan operasi [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html)API.
Atau, dengan AWS CLI, hubungi:
```
aws amp list-scrapers
```
`ListScrapers`mengembalikan semua pencakar di akun Anda, misalnya:
```
{
"scrapers": [
{
"scraperId": "s-1234abcd-56ef-7890-abcd-1234ef567890",
"arn": "arn:aws:aps:aws-region:123456789012:scraper/s-1234abcd-56ef-7890-abcd-1234ef567890",
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/AWSServiceRoleForAmazonPrometheusScraper_1234abcd-2931",
"status": {
"statusCode": "DELETING"
},
"createdAt": "2023-10-12T15:22:19.014000-07:00",
"lastModifiedAt": "2023-10-12T15:55:43.487000-07:00",
"tags": {},
"source": {
"vpcConfiguration": {
"securityGroupIds": [
"sg-1234abcd5678ef90"
],
"subnetIds": [
"subnet-abcd1234ef567890",
"subnet-1234abcd5678ab90"
]
}
},
"destination": {
"ampConfiguration": {
"workspaceArn": "arn:aws:aps:aws-region:123456789012:workspace/ws-1234abcd-5678-ef90-ab12-cdef3456a78"
}
}
}
]
}
```
Untuk menghapus scraper, cari scraper yang ingin Anda hapus, menggunakan `ListScrapers` operasi, dan kemudian gunakan [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html)operasi untuk menghapusnya. `scraperId`
Atau, dengan AWS CLI, hubungi:
```
aws amp delete-scraper --scraper-id scraperId
```
## Metrik dikumpulkan dari Amazon MSK
Saat Anda berintegrasi dengan Amazon MSK, kolektor Layanan Terkelola Amazon untuk Prometheus secara otomatis mengikis metrik berikut:
### Metrik: pekerjaan jmx\$1exporter dan pod\$1exporter
| Metrik | Deskripsi/Tujuan |
| --- | --- |
| jmx\$1config\$1reload\$1failure\$1total | Jumlah total eksportir JMX gagal memuat ulang file konfigurasinya. |
| jmx\$1scrape\$1duration\$1seconds | Waktu yang dibutuhkan untuk mengikis metrik JMX dalam hitungan detik untuk siklus pengumpulan saat ini. |
| jmx\$1scrape\$1error | Menunjukkan apakah terjadi kesalahan selama pengikisan metrik JMX (1 = kesalahan, 0 = sukses). |
| java\$1lang\$1memory\$1 \$1digunakan HeapMemoryUsage | Jumlah memori heap (dalam byte) yang saat ini digunakan oleh JVM. |
| Java\$1lang\$1memory\$1 \$1max HeapMemoryUsage | Jumlah maksimum memori heap (dalam byte) yang dapat digunakan untuk manajemen memori. |
| java\$1lang\$1memory\$1 \$1digunakan NonHeapMemoryUsage | Jumlah memori non-heap (dalam byte) yang saat ini digunakan oleh JVM. |
| Kafka\$1cluster\$1partition\$1value | Status atau nilai saat ini terkait dengan partisi cluster Kafka, dipecah berdasarkan ID partisi dan topik. |
| kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1assigned\$1partitions | Jumlah partisi yang saat ini ditugaskan untuk konsumen ini. |
| kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1commit\$1latency\$1avg | Rata-rata waktu yang dibutuhkan untuk melakukan offset dalam milidetik. |
| kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1commit\$1rate | Jumlah komit offset per detik. |
| kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1failed\$1rebalance\$1total | Jumlah total rebalances kelompok konsumen yang gagal. |
| kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1last\$1heartbeat\$1seconds\$1ago | Jumlah detik sejak detak jantung terakhir dikirim ke koordinator. |
| kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1rebalance\$1latency\$1avg | Rata-rata waktu yang dibutuhkan untuk menyeimbangkan kembali kelompok konsumen dalam milidetik. |
| kafka\$1consumer\$1consumer\$1coordinator\$1metrics\$1rebalance\$1total | Jumlah total penyeimbangan kembali kelompok konsumen. |
| kafka\$1consumer\$1consumer\$1fetch\$1manager\$1metrics\$1bytes\$1consumed\$1rate | Jumlah rata-rata byte yang dikonsumsi per detik oleh konsumen. |
| kafka\$1consumer\$1consumer\$1fetch\$1manager\$1metrics\$1fetch\$1latency\$1avg | Rata-rata waktu yang dibutuhkan untuk permintaan pengambilan dalam milidetik. |
| kafka\$1consumer\$1consumer\$1fetch\$1manager\$1metrics\$1fetch\$1rate | Jumlah permintaan pengambilan per detik. |
| kafka\$1consumer\$1consumer\$1fetch\$1manager\$1metrics\$1records\$1consumed\$1rate | Rata-rata jumlah catatan yang dikonsumsi per detik. |
| kafka\$1consumer\$1consumer\$1fetch\$1manager\$1metrics\$1records\$1lag\$1max | Kelambatan maksimum dalam hal jumlah catatan untuk partisi apa pun di konsumen ini. |
| kafka\$1consumer\$1consumer\$1metrics\$1connection\$1count | Jumlah koneksi aktif saat ini. |
| kafka\$1consumer\$1consumer\$1metrics\$1incoming\$1byte\$1rate | Jumlah rata-rata byte yang diterima per detik dari semua server. |
| kafka\$1consumer\$1consumer\$1metrics\$1last\$1poll\$1seconds\$1ago | Jumlah detik sejak panggilan polling konsumen terakhir (). |
| kafka\$1consumer\$1consumer\$1metrics\$1request\$1rate | Jumlah permintaan yang dikirim per detik. |
| kafka\$1consumer\$1consumer\$1metrics\$1response\$1rate | Jumlah tanggapan yang diterima per detik. |
| kafka\$1consumer\$1group\$1 \$1Nilai ConsumerLagMetrics | Nilai lag konsumen saat ini untuk kelompok konsumen, menunjukkan seberapa jauh di belakang konsumen. |
| kafka\$1controller\$1 \$1Nilai KafkaController | Keadaan atau nilai pengontrol Kafka saat ini (1 = pengontrol aktif, 0 = tidak aktif). |
| kafka\$1controller\$1 \$1Hitung ControllerEventManager | Jumlah total peristiwa pengontrol yang diproses. |
| kafka\$1controller\$1 ControllerEventManager \$1Berarti | Rata-rata (rata-rata) waktu yang dibutuhkan untuk memproses peristiwa pengontrol. |
| kafka\$1controller\$1 \$1 ControllerStats MeanRate | Tingkat rata-rata operasi statistik pengontrol per detik. |
| kafka\$1coordinator\$1group\$1 \$1Nilai GroupMetadataManager | Status atau nilai manajer metadata grup saat ini untuk grup konsumen. |
| kafka\$1log\$1 \$1Hitung LogFlushStats | Jumlah total operasi log flush. |
| kafka\$1log\$1 LogFlushStats \$1Berarti | Rata-rata (rata-rata) waktu yang dibutuhkan untuk operasi log flush. |
| kafka\$1log\$1 \$1 LogFlushStats MeanRate | Tingkat rata-rata operasi log flush per detik. |
| kafka\$1network\$1 \$1Hitung RequestMetrics | Jumlah total permintaan jaringan yang diproses. |
| kafka\$1network\$1 RequestMetrics \$1Berarti | Rata-rata (rata-rata) waktu yang dibutuhkan untuk memproses permintaan jaringan. |
| RequestMetricskafka\$1jaringan\$1 \$1 MeanRate | Rata-rata tingkat permintaan jaringan per detik. |
| Kafka\$1network\$1Acceptor\$1 MeanRate | Tingkat rata-rata koneksi yang diterima per detik. |
| Kafka\$1Server\$1fetch\$1queue\$1size | Ukuran antrian permintaan pengambilan saat ini. |
| Kafka\$1Server\$1Produce\$1Queue\$1size | Ukuran antrian permintaan produksi saat ini. |
| Kafka\$1Server\$1Request\$1Queue\$1size | Ukuran antrian permintaan umum saat ini. |
| kafka\$1server\$1 \$1Hitung BrokerTopicMetrics | Jumlah total operasi topik broker (pesanin/out, bytes in/out). |
| kafka\$1server\$1 \$1 BrokerTopicMetrics MeanRate | Tingkat rata-rata operasi topik broker per detik. |
| kafka\$1server\$1 \$1 BrokerTopicMetrics OneMinuteRate | Tingkat rata-rata pergerakan satu menit dari operasi topik broker. |
| kafka\$1server\$1 \$1Nilai DelayedOperationPurgatory | Jumlah operasi tertunda saat ini di api penyucian (menunggu untuk diselesaikan). |
| kafka\$1server\$1 \$1 DelayedFetchMetrics MeanRate | Tingkat rata-rata operasi pengambilan tertunda per detik. |
| kafka\$1server\$1 \$1Nilai FetcherLagMetrics | Nilai lag saat ini untuk utas pengambil replika (seberapa jauh di belakang pemimpin). |
| kafka\$1server\$1 \$1 FetcherStats MeanRate | Tingkat rata-rata operasi fetcher per detik. |
| kafka\$1server\$1 \$1Nilai ReplicaManager | Status atau nilai manajer replika saat ini. |
| kafka\$1server\$1 \$1 ReplicaManager MeanRate | Tingkat rata-rata operasi manajer replika per detik. |
| kafka\$1server\$1 \$1byte\$1rate LeaderReplication | Tingkat byte direplikasi per detik untuk partisi di mana broker ini adalah pemimpin. |
| kafka\$1server\$1group\$1coordinator\$1metrics\$1group\$1completed\$1rebalance\$1count | Jumlah total penyeimbangan kembali kelompok konsumen yang diselesaikan. |
| kafka\$1server\$1group\$1coordinator\$1metrics\$1offset\$1commit\$1count | Jumlah total operasi komit offset. |
| kafka\$1server\$1group\$1coordinator\$1metrics\$1offset\$1commit\$1rate | Tingkat operasi komit offset per detik. |
| kafka\$1server\$1socket\$1server\$1metrics\$1connection\$1count | Jumlah koneksi aktif saat ini. |
| kafka\$1server\$1socket\$1server\$1metrics\$1connection\$1creation\$1rate | Tingkat pembuatan koneksi baru per detik. |
| kafka\$1server\$1socket\$1server\$1metrics\$1connection\$1close\$1rate | Tingkat penutupan koneksi per detik. |
| kafka\$1server\$1socket\$1server\$1metrics\$1failed\$1authentication\$1total | Jumlah total upaya otentikasi yang gagal. |
| kafka\$1server\$1socket\$1server\$1metrics\$1incoming\$1byte\$1rate | Tingkat byte masuk per detik. |
| kafka\$1server\$1socket\$1server\$1metrics\$1outgoing\$1byte\$1rate | Tingkat byte keluar per detik. |
| kafka\$1server\$1socket\$1server\$1metrics\$1request\$1rate | Tingkat permintaan per detik. |
| kafka\$1server\$1socket\$1server\$1metrics\$1response\$1rate | Tingkat respons per detik. |
| kafka\$1server\$1socket\$1server\$1metrics\$1network\$1io\$1rate | Tingkat I/O operasi jaringan per detik. |
| kafka\$1server\$1socket\$1server\$1metrics\$1io\$1ratio | Sebagian kecil waktu yang dihabiskan dalam I/O operasi. |
| kafka\$1server\$1controller\$1channel\$1metrics\$1connection\$1count | Jumlah koneksi aktif saat ini untuk saluran pengontrol. |
| kafka\$1server\$1controller\$1channel\$1metrics\$1incoming\$1byte\$1rate | Tingkat byte masuk per detik untuk saluran pengontrol. |
| kafka\$1server\$1controller\$1channel\$1metrics\$1outgoing\$1byte\$1rate | Tingkat byte keluar per detik untuk saluran pengontrol. |
| kafka\$1server\$1controller\$1channel\$1metrics\$1request\$1rate | Tingkat permintaan per detik untuk saluran pengontrol. |
| kafka\$1server\$1replica\$1fetcher\$1metrics\$1connection\$1count | Jumlah koneksi aktif saat ini untuk pengambil replika. |
| kafka\$1server\$1replica\$1fetcher\$1metrics\$1incoming\$1byte\$1rate | Tingkat byte masuk per detik untuk replika fetcher. |
| kafka\$1server\$1replica\$1fetcher\$1metrics\$1request\$1rate | Tingkat permintaan per detik untuk replika fetcher. |
| kafka\$1server\$1replica\$1fetcher\$1metrics\$1failed\$1authentication\$1total | Jumlah total upaya otentikasi gagal untuk pengambil replika. |
| kafka\$1server\$1 \$1Hitung ZooKeeperClientMetrics | Jumlah total operasi ZooKeeper klien. |
| kafka\$1server\$1 ZooKeeperClientMetrics \$1Berarti | Rata-rata latensi operasi ZooKeeper klien. |
| kafka\$1server\$1 \$1Nilai KafkaServer | Status atau nilai server Kafka saat ini (biasanya menunjukkan server sedang berjalan). |
| node\$1cpu\$1seconds\$1total | Total detik yang CPUs dihabiskan dalam setiap mode (pengguna, sistem, idle, dll.), Diuraikan berdasarkan CPU dan mode. |
| node\$1disk\$1read\$1bytes\$1total | Jumlah total byte yang berhasil dibaca dari disk, dipecah berdasarkan perangkat. |
| node\$1disk\$1reads\$1completed\$1total | Jumlah total pembacaan berhasil diselesaikan untuk disk, dipecah berdasarkan perangkat. |
| node\$1disk\$1writes\$1completed\$1total | Jumlah total penulisan berhasil diselesaikan untuk disk, dipecah berdasarkan perangkat. |
| node\$1disk\$1written\$1bytes\$1total | Jumlah total byte yang berhasil ditulis ke disk, dipecah berdasarkan perangkat. |
| node\$1filesystem\$1avail\$1bytes | Ruang sistem file yang tersedia dalam byte untuk pengguna non-root, dipecah berdasarkan perangkat dan titik pemasangan. |
| node\$1filesystem\$1size\$1bytes | Ukuran total sistem file dalam byte, dipecah berdasarkan perangkat dan titik pemasangan. |
| node\$1filesystem\$1free\$1bytes | Ruang sistem file gratis dalam byte, dipecah berdasarkan perangkat dan titik pemasangan. |
| node\$1filesystem\$1files | Jumlah total node file (inode) pada sistem file, dipecah berdasarkan perangkat dan titik pemasangan. |
| node\$1filesystem\$1files\$1free | Jumlah node file gratis (inode) pada sistem file, dipecah berdasarkan perangkat dan titik pemasangan. |
| node\$1filesystem\$1readonly | Menunjukkan apakah sistem file dipasang hanya-baca (1 = hanya-baca, 0 = baca-tulis). |
| node\$1filesystem\$1device\$1error | Menunjukkan apakah terjadi kesalahan saat mendapatkan statistik sistem file (1 = kesalahan, 0 = sukses). |
## Batasan
Integrasi MSK Amazon saat ini dengan Amazon Managed Service untuk Prometheus memiliki batasan berikut:
+ Hanya didukung untuk klaster Amazon MSK Provisioned (tidak tersedia untuk Amazon MSK Tanpa Server)
+ Tidak didukung untuk klaster MSK Amazon dengan akses publik diaktifkan dalam kombinasi dengan KRaft mode metadata
+ Tidak didukung untuk broker Amazon MSK Express
+ Saat ini mendukung pemetaan 1:1 antara kluster MSK Amazon dan Layanan Terkelola Amazon untuk kolektor/ruang kerja Prometheus
# Apa itu metrik yang kompatibel dengan Prometheus?
*Untuk mengikis metrik Prometheus dari aplikasi dan infrastruktur Anda untuk digunakan di Amazon Managed Service for Prometheus, metrik tersebut harus instrumen dan mengekspos metrik yang kompatibel dengan Prometheus dari titik akhir yang kompatibel dengan Prometheus.* `/metrics` Anda dapat menerapkan metrik Anda sendiri, tetapi Anda tidak harus melakukannya. Kubernetes (termasuk Amazon EKS) dan banyak pustaka dan layanan lainnya mengimplementasikan metrik ini secara langsung.
Saat metrik di Amazon EKS diekspor ke titik akhir yang kompatibel dengan Prometheus, metrik tersebut dapat dikikis secara otomatis oleh kolektor Layanan Terkelola Amazon untuk Prometheus.
Untuk informasi selengkapnya, lihat topik berikut:
+ [Untuk informasi selengkapnya tentang pustaka dan layanan yang ada yang mengekspor metrik sebagai metrik Prometheus, lihat Eksportir dan integrasi dalam dokumentasi Prometheus.](https://prometheus.io/docs/instrumenting/exporters/)
+ Untuk informasi selengkapnya tentang mengekspor metrik yang kompatibel dengan Prometheus dari kode Anda sendiri, lihat Menulis [eksportir](https://prometheus.io/docs/instrumenting/writing_exporters/) di dokumentasi Prometheus.
+ Untuk informasi selengkapnya tentang cara menyiapkan Layanan Terkelola Amazon untuk kolektor Prometheus untuk mengikis metrik dari kluster Amazon EKS Anda secara otomatis, lihat. [Siapkan kolektor terkelola untuk Amazon EKS](AMP-collector-how-to.md)
# Pantau kolektor dengan log penjual
Layanan Terkelola Amazon untuk kolektor Prometheus menyediakan log vended untuk membantu Anda memantau dan memecahkan masalah proses pengumpulan metrik. Log ini secara otomatis dikirim ke Amazon CloudWatch Logs dan memberikan visibilitas ke dalam penemuan layanan, pengumpulan metrik, dan operasi ekspor data. Kolektor menjual log untuk tiga komponen utama dari pipa pengumpulan metrik:
**Topics**
+ [Log penemuan layanan](#amp-collector-service-discovery-vended-logs)
+ [Log kolektor](#amp-collector-vended-logs)
+ [Log eksportir](#amp-exporter-vended-logs)
+ [Memahami dan menggunakan log penjual kolektor](#amp-collector-log-details)
## Log penemuan layanan
Log penemuan layanan memberikan informasi tentang proses penemuan target, termasuk:
+ Masalah autentikasi atau izin saat mengakses sumber daya API Kubernetes.
+ Kesalahan konfigurasi dalam pengaturan penemuan layanan.
Contoh berikut menunjukkan otentikasi umum dan kesalahan izin yang mungkin Anda temui selama penemuan layanan:
**Cluster Amazon EKS tidak ada**
Jika klaster Amazon EKS yang ditentukan tidak ada, Anda menerima kesalahan berikut:
```
{
"component": "SERVICE_DISCOVERY",
"timestamp": "2025-04-30T17:25:41.946Z",
"message": {
"log": "Failed to watch Service - Verify your scraper source exists."
},
"scrapeConfigId": "s-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
```
**Izin tidak valid untuk layanan**
Ketika kolektor tidak memiliki izin Kontrol Akses Berbasis Peran (RBAC) yang tepat untuk menonton Layanan, Anda menerima kesalahan ini:
```
{
"component": "SERVICE_DISCOVERY",
"timestamp": "2025-04-30T17:25:41.946Z",
"message": {
"log": "Failed to watch Service - Verify your scraper source permissions are valid."
},
"scrapeConfigId": "s-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
```
**Izin tidak valid untuk titik akhir**
Ketika kolektor tidak memiliki izin Kontrol Akses Berbasis Peran (RBAC) yang tepat untuk menonton Titik Akhir, Anda menerima kesalahan ini:
```
{
"component": "SERVICE_DISCOVERY",
"timestamp": "2025-04-30T17:25:41.946Z",
"message": {
"log": "Failed to watch Endpoints - Verify your scraper source permissions are valid."
},
"scrapeConfigId": "s-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
```
## Log kolektor
Log kolektor memberikan informasi tentang proses pengikisan metrik, termasuk:
+ Kegagalan gesekan karena titik akhir tidak tersedia.
+ Masalah koneksi saat mencoba mengikis target.
+ Batas waktu selama operasi pengikisan.
+ Kesalahan status HTTP dikembalikan oleh target scrape.
Contoh berikut menunjukkan kesalahan kolektor umum yang mungkin Anda temui selama proses pengikisan metrik:
**Titik akhir metrik tidak ada**
Ketika `/metrics` titik akhir tidak tersedia pada instance target, Anda menerima kesalahan ini:
```
{
"component": "COLLECTOR",
"message": {
"log": "Failed to scrape Prometheus endpoint - verify /metrics endpoint is available",
"job": "pod_exporter",
"targetLabels": "{__name__=\"up\", instance=\10.24.34.0\", job=\"pod_exporter\"}"
},
"timestamp": "1752787969551",
"scraperId": "s-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
```
**Koneksi ditolak**
Ketika kolektor tidak dapat membuat koneksi ke titik akhir target, Anda menerima kesalahan ini:
```
{
"scrapeConfigId": "s-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"timestamp": "2025-04-30T17:25:41.946Z",
"message": {
"message": "Scrape failed",
"scrape_pool": "pod_exporter",
"target": "http://10.24.34.0:80/metrics",
"error": "Get \"http://10.24.34.0:80/metrics\": dial tcp 10.24.34.0:80: connect: connection refused"
},
"component": "COLLECTOR"
}
```
## Log eksportir
Log eksportir memberikan informasi tentang proses pengiriman metrik yang dikumpulkan ke Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus, termasuk:
+ Jumlah metrik dan titik data yang diproses.
+ Kegagalan ekspor karena masalah ruang kerja.
+ Kesalahan izin saat mencoba menulis metrik.
+ Kegagalan ketergantungan dalam pipa ekspor.
Contoh berikut menunjukkan kesalahan eksportir umum yang mungkin Anda temui selama proses ekspor metrik:
**Ruang kerja tidak ditemukan**
Ketika ruang kerja target untuk ekspor metrik tidak dapat ditemukan, Anda menerima kesalahan ini:
```
{
"component": "EXPORTER",
"message": {
"log": "Failed to export to the target workspace - Verify your scraper destination.",
"samplesDropped": 5
},
"timestamp": "1752787969664",
"scraperId": "s-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
```
## Memahami dan menggunakan log penjual kolektor
### Struktur log
Semua log penjual kolektor mengikuti struktur yang konsisten dengan bidang ini:
**scrapeConfigId**
Pengidentifikasi unik dari konfigurasi scrape yang menghasilkan log.
**stempel waktu**
Waktu ketika entri log dihasilkan.
**pesan**
Konten pesan log, yang mungkin mencakup bidang terstruktur tambahan.
**komponen**
Komponen yang menghasilkan log (SERVICE\$1DISCOVERY, COLLECTOR, atau EXPORTER)
### Menggunakan log vended untuk pemecahan masalah
Log penjual kolektor membantu Anda memecahkan masalah umum dengan pengumpulan metrik:
1. Masalah penemuan layanan
+ Periksa log **SERVICE\$1DISCOVERY** untuk otentikasi atau kesalahan izin.
+ Verifikasi bahwa kolektor memiliki izin yang diperlukan untuk mengakses sumber daya Kubernetes.
1. Masalah pengikisan metrik
+ Periksa log **COLLECTOR** untuk kegagalan gesekan.
+ Verifikasi bahwa titik akhir target dapat diakses dan mengembalikan metrik.
+ Pastikan bahwa aturan firewall memungkinkan kolektor untuk terhubung ke titik akhir target.
1. Masalah ekspor metrik
+ Periksa log **EKSPORTER** untuk kegagalan ekspor.
+ Verifikasi bahwa ruang kerja ada dan dikonfigurasi dengan benar.
+ Pastikan kolektor memiliki izin yang diperlukan untuk menulis ke ruang kerja.
### Mengakses log penjual kolektor
Log penjual kolektor secara otomatis dikirim ke Amazon CloudWatch Logs. Untuk mengakses log ini:
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Pada panel navigasi, pilih **Grup log**.
1. Temukan dan pilih grup log untuk kolektor Anda:`/aws/prometheus/workspace_id/collector/collector_id`.
1. Jelajahi atau cari peristiwa log untuk menemukan informasi yang relevan.
Anda juga dapat menggunakan Wawasan CloudWatch Log untuk menanyakan dan menganalisis log kolektor Anda. Misalnya, untuk menemukan semua kesalahan penemuan layanan:
```
fields @timestamp, message.message
| filter component = "SERVICE_DISCOVERY" and message.message like /Failed/
| sort @timestamp desc
```
### Praktik terbaik untuk memantau kolektor
Untuk memantau Layanan Terkelola Amazon Anda secara efektif untuk kolektor Prometheus:
1. Siapkan CloudWatch alarm untuk masalah kolektor kritis, seperti kegagalan pengikisan persisten atau kesalahan ekspor. Untuk informasi selengkapnya, lihat [Alarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) di *Panduan CloudWatch Pengguna Amazon*.
1. Buat CloudWatch dasbor untuk memvisualisasikan metrik kinerja kolektor bersama data log yang dijual. Untuk informasi selengkapnya, lihat [Dasbor](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html) di *Panduan CloudWatch Pengguna Amazon*.
1. Tinjau log penemuan layanan secara teratur untuk memastikan target ditemukan dengan benar.
1. Pantau jumlah target yang dijatuhkan untuk mengidentifikasi potensi masalah konfigurasi.
1. Lacak kegagalan ekspor untuk memastikan metrik berhasil dikirim ke ruang kerja Anda.
# Kolektor yang dikelola pelanggan
Bagian ini berisi informasi tentang menelan data dengan menyiapkan kolektor Anda sendiri yang mengirim metrik ke Amazon Managed Service untuk Prometheus menggunakan Prometheus remote write.
Saat Anda menggunakan kolektor Anda sendiri untuk mengirim metrik ke Amazon Managed Service untuk Prometheus, Anda bertanggung jawab untuk mengamankan metrik Anda dan memastikan bahwa proses konsumsi memenuhi kebutuhan ketersediaan Anda.
Sebagian besar kolektor yang dikelola pelanggan menggunakan salah satu alat berikut:
+ **AWS Distro for OpenTelemetry (ADOT)** — ADOT adalah distribusi open source yang didukung penuh, aman, dan siap produksi OpenTelemetry yang menyediakan agen untuk mengumpulkan metrik. Anda dapat menggunakan ADOT untuk mengumpulkan metrik dan mengirimkannya ke Layanan Terkelola Amazon untuk ruang kerja Prometheus. Untuk informasi selengkapnya tentang Kolektor ADOT, lihat [AWS Distro](https://aws.amazon.com/otel/) untuk. OpenTelemetry
+ Agen **Prometheus** — Anda dapat mengatur instance Anda sendiri dari server Prometheus open source, berjalan sebagai agen, untuk mengumpulkan metrik dan meneruskannya ke Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus.
Topik berikut menjelaskan penggunaan kedua alat ini dan menyertakan informasi umum tentang pengaturan kolektor Anda sendiri.
**Topics**
+ [Amankan konsumsi metrik Anda](AMP-secure-metric-ingestion.md)
+ [Menggunakan AWS Distro untuk OpenTelemetry sebagai kolektor](AMP-ingest-with-adot.md)
+ [Menggunakan contoh Prometheus sebagai kolektor](AMP-ingest-with-prometheus.md)
+ [Siapkan Amazon Managed Service untuk Prometheus untuk data ketersediaan tinggi](AMP-ingest-high-availability.md)
# Amankan konsumsi metrik Anda
Layanan Terkelola Amazon untuk Prometheus menyediakan cara untuk membantu Anda mengamankan konsumsi metrik Anda.
## Menggunakan AWS PrivateLink dengan Amazon Managed Service untuk Prometheus
Lalu lintas jaringan untuk memasukkan metrik ke Amazon Managed Service untuk Prometheus dapat dilakukan melalui titik akhir internet publik, atau dengan titik akhir VPC melalui. AWS PrivateLink Menggunakan AWS PrivateLink memastikan bahwa lalu lintas jaringan dari Anda VPCs diamankan dalam AWS jaringan tanpa melalui internet publik. Untuk membuat titik akhir AWS PrivateLink VPC untuk Amazon Managed Service untuk Prometheus, lihat. [Menggunakan Amazon Managed Service untuk Prometheus dengan titik akhir VPC antarmuka](AMP-and-interface-VPC.md)
## Autentikasi dan otorisasi
AWS Identity and Access Management (IAM) adalah layanan web yang membantu Anda mengontrol akses ke sumber daya dengan aman. AWS Anda menggunakan IAM untuk mengontrol siapa yang dapat terautentikasi (masuk) dan berwenang (memiliki izin) untuk menggunakan sumber daya. Amazon Managed Service for Prometheus terintegrasi dengan IAM untuk membantu Anda menjaga keamanan data. Saat menyiapkan Amazon Managed Service untuk Prometheus, Anda perlu membuat beberapa peran IAM yang memungkinkannya menyerap metrik dari server Prometheus, dan yang memungkinkan server Grafana untuk menanyakan metrik yang disimpan di Amazon Managed Service untuk ruang kerja Prometheus. Untuk informasi selengkapnya tentang IAM, lihat [Apa itu IAM?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html).
Fitur AWS keamanan lain yang dapat membantu Anda menyiapkan Amazon Managed Service untuk Prometheus adalah AWS proses penandatanganan Signature Version 4 (SigV4).AWS Signature Version 4 adalah proses untuk menambahkan informasi otentikasi ke AWS permintaan yang dikirim oleh HTTP. Untuk keamanan, sebagian besar permintaan AWS harus ditandatangani dengan kunci akses, yang terdiri dari ID kunci akses dan kunci akses rahasia. Kedua kunci ini umumnya disebut sebagai kredensial keamanan Anda. Untuk informasi selengkapnya tentang SiGv4, lihat proses [penandatanganan Sigv4 Versi Tanda Tangan 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
# Menggunakan AWS Distro untuk OpenTelemetry sebagai kolektor
Bagian ini menjelaskan cara mengonfigurasi Kolektor AWS Distro for OpenTelemetry (ADOT) untuk mengikis dari aplikasi yang diinstrumentasi Prometheus, dan mengirim metrik ke Amazon Managed Service untuk Prometheus. Untuk informasi selengkapnya tentang Kolektor ADOT, lihat [AWS Distro](https://aws.amazon.com/otel/) untuk. OpenTelemetry
Topik berikut menjelaskan tiga cara berbeda untuk mengatur ADOT sebagai kolektor untuk metrik Anda, berdasarkan apakah metrik Anda berasal dari Amazon EKS, Amazon ECS, atau instans Amazon EC2.
**Topics**
+ [Siapkan konsumsi metrik menggunakan AWS Distro untuk klaster Amazon Elastic OpenTelemetry Kubernetes Service](AMP-onboard-ingest-metrics-OpenTelemetry.md)
+ [Siapkan konsumsi metrik dari Amazon ECS menggunakan AWS Distro untuk Open Telemetry](AMP-onboard-ingest-metrics-OpenTelemetry-ECS.md)
+ [Mengatur konsumsi metrik dari instans Amazon EC2 menggunakan penulisan jarak jauh](AMP-onboard-ingest-metrics-remote-write-EC2.md)
# Siapkan konsumsi metrik menggunakan AWS Distro untuk klaster Amazon Elastic OpenTelemetry Kubernetes Service
Anda dapat menggunakan kolektor AWS Distro for OpenTelemetry (ADOT) untuk mengikis metrik dari aplikasi yang diinstrumentasi Prometheus, dan mengirim metrik ke Amazon Managed Service untuk Prometheus.
**catatan**
Untuk informasi selengkapnya tentang kolektor ADOT, lihat [AWS Distro](https://aws.amazon.com/otel/) untuk. OpenTelemetry
Untuk informasi selengkapnya tentang aplikasi yang diinstrumentasi Prometheus, lihat. [Apa itu metrik yang kompatibel dengan Prometheus?](prom-compatible-metrics.md)
Mengumpulkan metrik Prometheus dengan ADOT melibatkan OpenTelemetry tiga komponen: Penerima Prometheus, Eksportir Tulis Jarak Jauh Prometheus, dan Ekstensi Otentikasi Sigv4.
Anda dapat mengonfigurasi Penerima Prometheus menggunakan konfigurasi Prometheus yang ada untuk melakukan penemuan layanan dan pengikisan metrik. Penerima Prometheus menggores metrik dalam format eksposisi Prometheus. Setiap aplikasi atau titik akhir yang ingin Anda kikis harus dikonfigurasi dengan pustaka klien Prometheus. [Penerima Prometheus mendukung set lengkap konfigurasi pengikisan dan pelabelan ulang Prometheus yang dijelaskan dalam Konfigurasi dalam dokumentasi Prometheus.](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) Anda dapat menempelkan konfigurasi ini langsung ke konfigurasi ADOT Collector Anda.
Prometheus Remote Write Exporter menggunakan titik akhir untuk mengirim metrik `remote_write` yang tergores ke ruang kerja portal manajemen Anda. Permintaan HTTP untuk mengekspor data akan ditandatangani dengan AWS SiGv4, AWS protokol untuk otentikasi aman, dengan Ekstensi Otentikasi Sigv4. Untuk informasi selengkapnya, lihat [proses penandatanganan Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).
[Kolektor secara otomatis menemukan titik akhir metrik Prometheus di Amazon EKS dan menggunakan konfigurasi yang ditemukan di.](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config)
Demo berikut adalah contoh konfigurasi ini pada cluster yang menjalankan Amazon Elastic Kubernetes Service atau Kubernetes yang dikelola sendiri. Untuk melakukan langkah-langkah ini, Anda harus memiliki AWS kredensil dari salah satu opsi potensial dalam rantai AWS kredensi default. Untuk informasi selengkapnya, lihat [Mengonfigurasi AWS SDK](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html) for Go. Demo ini menggunakan contoh aplikasi yang digunakan untuk pengujian integrasi proses. Aplikasi sampel mengekspos metrik di `/metrics` titik akhir, seperti pustaka klien Prometheus.
## Prasyarat
Sebelum memulai langkah-langkah penyiapan konsumsi berikut, Anda harus menyiapkan peran IAM Anda untuk akun layanan dan kebijakan kepercayaan.
**Untuk mengatur peran IAM untuk akun layanan dan kebijakan kepercayaan**
1. Buat peran IAM untuk akun layanan dengan mengikuti langkah-langkah di[Menyiapkan peran layanan untuk menelan metrik dari kluster Amazon EKS](set-up-irsa.md#set-up-irsa-ingest).
Kolektor ADOT akan menggunakan peran ini saat menggores dan mengekspor metrik.
1. Selanjutnya, edit kebijakan kepercayaan. Buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/home).
1. Di panel navigasi kiri, pilih **Peran** dan temukan **amp-iamproxy-ingest-role**yang Anda buat di langkah 1.
1. Pilih tab **Trust relationship** dan pilih **Edit trust relationship**.
1. Dalam kebijakan hubungan kepercayaan JSON, ganti `aws-amp` dengan `adot-col` lalu pilih **Perbarui Kebijakan Kepercayaan**. Kebijakan kepercayaan yang Anda hasilkan akan terlihat seperti berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:adot-col:amp-iamproxy-ingest-service-account",
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
}
}
}
]
}
```
------
1. Pilih tab **Izin** dan pastikan bahwa kebijakan izin berikut dilampirkan ke peran.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"aps:RemoteWrite",
"aps:GetSeries",
"aps:GetLabels",
"aps:GetMetricMetadata"
],
"Resource": "*"
}
]
}
```
------
## Mengaktifkan koleksi metrik Prometheus
**catatan**
Saat Anda membuat namespace di Amazon EKS, `alertmanager` dan pengekspor node dinonaktifkan secara default.
**Untuk mengaktifkan koleksi Prometheus di Amazon EKS atau klaster Kubernetes**
1. Fork dan kloning aplikasi sampel dari repositori di. [aws-otel-community](https://github.com/aws-observability/aws-otel-community)
Kemudian jalankan perintah berikut.
```
cd ./sample-apps/prometheus-sample-app
docker build . -t prometheus-sample-app:latest
```
1. Dorong gambar ini ke registri seperti Amazon ECR atau DockerHub.
1. Terapkan aplikasi sampel di cluster dengan menyalin konfigurasi Kubernetes ini dan menerapkannya. Ubah gambar ke gambar yang baru saja Anda dorong `{{PUBLIC_SAMPLE_APP_IMAGE}}` dengan mengganti `prometheus-sample-app.yaml` file.
```
curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-sample-app.yaml -o prometheus-sample-app.yaml
kubectl apply -f prometheus-sample-app.yaml
```
1. Masukkan perintah berikut untuk memverifikasi bahwa aplikasi sampel telah dimulai. Dalam output perintah, Anda akan melihat `prometheus-sample-app` di `NAME` kolom.
```
kubectl get all -n aoc-prometheus-pipeline-demo
```
1. Mulai contoh default dari ADOT Collector. Untuk melakukannya, pertama-tama masukkan perintah berikut untuk menarik konfigurasi Kubernetes untuk ADOT Collector.
```
curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-daemonset.yaml -o prometheus-daemonset.yaml
```
Kemudian edit file template, ganti titik akhir **remote\$1write** untuk Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus untuk dan Wilayah Anda. `YOUR_ENDPOINT` `YOUR_REGION` Gunakan endpoint **remote\$1write** yang ditampilkan di Amazon Managed Service untuk konsol Prometheus saat Anda melihat detail ruang kerja Anda.
Anda juga harus mengubah `YOUR_ACCOUNT_ID` bagian akun layanan konfigurasi Kubernetes ke ID akun Anda AWS .
Dalam contoh ini, konfigurasi ADOT Collector menggunakan anotasi (`scrape=true`) untuk memberi tahu titik akhir target mana yang akan dikikis. Hal ini memungkinkan Kolektor ADOT untuk membedakan titik akhir aplikasi sampel dari titik akhir kube-system di cluster Anda. Anda dapat menghapus ini dari konfigurasi label ulang jika Anda ingin mengikis aplikasi sampel yang berbeda.
1. Masukkan perintah berikut untuk menyebarkan kolektor ADOT.
```
kubectl apply -f prometheus-daemonset.yaml
```
1. Masukkan perintah berikut untuk memverifikasi bahwa kolektor ADOT telah dimulai. Cari `adot-col` di `NAMESPACE` kolom.
```
kubectl get pods -n adot-col
```
1. Verifikasi bahwa pipeline berfungsi dengan menggunakan eksportir logging. Contoh template kami sudah terintegrasi dengan eksportir logging. Masukkan perintah berikut.
```
kubectl get pods -A
kubectl logs -n adot-col name_of_your_adot_collector_pod
```
Beberapa metrik yang tergores dari aplikasi sampel akan terlihat seperti contoh berikut.
```
Resource labels:
-> service.name: STRING(kubernetes-service-endpoints)
-> host.name: STRING(192.168.16.238)
-> port: STRING(8080)
-> scheme: STRING(http)
InstrumentationLibraryMetrics #0
Metric #0
Descriptor:
-> Name: test_gauge0
-> Description: This is my gauge
-> Unit:
-> DataType: DoubleGauge
DoubleDataPoints #0
StartTime: 0
Timestamp: 1606511460471000000
Value: 0.000000
```
1. Untuk menguji apakah Amazon Managed Service untuk Prometheus menerima metrik, gunakan. `awscurl` [Alat ini memungkinkan Anda mengirim permintaan HTTP melalui baris perintah dengan otentikasi AWS Sigv4, jadi Anda harus memiliki AWS kredensyal yang disiapkan secara lokal dengan izin yang benar untuk kueri dari Amazon Managed Service untuk Prometheus Untuk petunjuk tentang penginstalan, lihat awscurl. `awscurl`](https://github.com/okigan/awscurl)
Dalam perintah berikut, ganti`AMP_REGION`, dan `AMP_ENDPOINT` dengan informasi untuk Amazon Managed Service untuk ruang kerja Prometheus.
```
awscurl --service="aps" --region="AMP_REGION" "https://AMP_ENDPOINT/api/v1/query?query=adot_test_gauge0"
{"status":"success","data":{"resultType":"vector","result":[{"metric":{"__name__":"adot_test_gauge0"},"value":[1606512592.493,"16.87214000011479"]}]}}
```
Jika Anda menerima metrik sebagai respons, itu berarti penyiapan pipeline Anda telah berhasil dan metrik telah berhasil disebarkan dari aplikasi sampel ke Amazon Managed Service for Prometheus.
**Membersihkan**
Untuk membersihkan demo ini, masukkan perintah berikut.
```
kubectl delete namespace aoc-prometheus-pipeline-demo
kubectl delete namespace adot-col
```
## Konfigurasi lanjutan
[Penerima Prometheus mendukung set lengkap konfigurasi pengikisan dan pelabelan ulang Prometheus yang dijelaskan dalam Konfigurasi dalam dokumentasi Prometheus.](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) Anda dapat menempelkan konfigurasi ini langsung ke konfigurasi ADOT Collector Anda.
Konfigurasi untuk Penerima Prometheus mencakup penemuan layanan Anda, konfigurasi pengikisan, dan konfigurasi pelabelan ulang. Konfigurasi penerima terlihat seperti berikut ini.
```
receivers:
prometheus:
config:
[[Your Prometheus configuration]]
```
Berikut ini adalah contoh konfigurasi.
```
receivers:
prometheus:
config:
global:
scrape_interval: 1m
scrape_timeout: 10s
scrape_configs:
- job_name: kubernetes-service-endpoints
sample_limit: 10000
kubernetes_sd_configs:
- role: endpoints
tls_config:
ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
insecure_skip_verify: true
bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
```
Jika Anda memiliki konfigurasi Prometheus yang ada, Anda harus mengganti `$` karakter `$$` dengan untuk menghindari nilai diganti dengan variabel lingkungan. \$1Ini sangat penting untuk nilai penggantian relabel\$1configurations. Misalnya, jika Anda memulai dengan relabel\$1configuration berikut:
```
relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
regex: (.+);(.+);(.+)
replacement: ${1}://${2}${3}
target_label: __param_target
```
Itu akan menjadi sebagai berikut:
```
relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
regex: (.+);(.+);(.+)
replacement: $${1}://${2}${3}
target_label: __param_target
```
**Prometheus eksportir tulis jarak jauh dan ekstensi otentikasi Sigv4**
Konfigurasi untuk Prometheus Remote Write Exporter dan Sigv4 Authentication Extension lebih sederhana daripada penerima Prometheus. Pada tahap ini, metrik telah dicerna, dan kami siap untuk mengekspor data ini ke Amazon Managed Service untuk Prometheus. Persyaratan minimum untuk konfigurasi yang berhasil untuk berkomunikasi dengan Amazon Managed Service untuk Prometheus ditampilkan dalam contoh berikut.
```
extensions:
sigv4auth:
service: "aps"
region: "user-region"
exporters:
prometheusremotewrite:
endpoint: "https://aws-managed-prometheus-endpoint/api/v1/remote_write"
auth:
authenticator: "sigv4auth"
```
Konfigurasi ini mengirimkan permintaan HTTPS yang ditandatangani oleh AWS SigV4 menggunakan AWS kredensil dari rantai kredensil default. AWS Untuk informasi selengkapnya, lihat [Mengonfigurasi AWS SDK untuk Go](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html). Anda harus menentukan layanan yang akan menjadi`aps`.
Terlepas dari metode penyebaran, kolektor ADOT harus memiliki akses ke salah satu opsi yang tercantum dalam rantai AWS kredensil default. Ekstensi Otentikasi Sigv4 bergantung pada AWS SDK untuk Go dan menggunakannya untuk mengambil kredensyal dan mengautentikasi. Anda harus memastikan bahwa kredensyal ini memiliki izin menulis jarak jauh untuk Amazon Managed Service for Prometheus.
# Siapkan konsumsi metrik dari Amazon ECS menggunakan AWS Distro untuk Open Telemetry
Bagian ini menjelaskan cara mengumpulkan metrik dari Amazon Elastic Container Service (Amazon ECS) dan memasukkannya ke dalam Amazon Managed Service untuk Prometheus menggunakan Distro for Open Telemetry (ADOT). AWS Ini juga menjelaskan cara memvisualisasikan metrik Anda di Grafana Terkelola Amazon.
## Prasyarat
**penting**
Sebelum memulai, Anda harus memiliki lingkungan Amazon ECS di AWS Fargate klaster dengan pengaturan default, Layanan Terkelola Amazon untuk ruang kerja Prometheus, dan ruang kerja Grafana yang Dikelola Amazon. Kami berasumsi bahwa Anda terbiasa dengan beban kerja kontainer, Layanan Terkelola Amazon untuk Prometheus, dan Grafana yang Dikelola Amazon.
Untuk informasi selengkapnya, lihat tautan berikut:
+ Untuk informasi tentang cara membuat lingkungan Amazon ECS di klaster Fargate dengan setelan default, [lihat Membuat klaster di Panduan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html) Pengembang *Amazon ECS*.
+ Untuk informasi tentang cara membuat Layanan Terkelola Amazon untuk ruang kerja Prometheus, lihat [Membuat ruang kerja di Panduan Pengguna Layanan Terkelola](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-create-workspace.html) *Amazon* untuk Prometheus.
+ Untuk informasi tentang cara membuat ruang kerja Grafana Terkelola Amazon, lihat [Membuat ruang kerja di Panduan Pengguna](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-create-workspace.html) *Grafana Terkelola* Amazon.
## Langkah 1: Tentukan gambar wadah kolektor ADOT khusus
Gunakan file konfigurasi berikut sebagai template untuk menentukan gambar kontainer kolektor ADOT Anda sendiri. Ganti *my-remote-URL* dan *my-region* dengan `region` nilai-nilai `endpoint` dan Anda. Simpan konfigurasi dalam file bernama *adot-config.yaml*.
**catatan**
Konfigurasi ini menggunakan `sigv4auth` ekstensi untuk mengautentikasi panggilan ke Amazon Managed Service untuk Prometheus. Untuk informasi selengkapnya tentang mengonfigurasi`sigv4auth`, lihat [Authenticator - Sigv4](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/sigv4authextension) on. GitHub
```
receivers:
prometheus:
config:
global:
scrape_interval: 15s
scrape_timeout: 10s
scrape_configs:
- job_name: "prometheus"
static_configs:
- targets: [ 0.0.0.0:9090 ]
awsecscontainermetrics:
collection_interval: 10s
processors:
filter:
metrics:
include:
match_type: strict
metric_names:
- ecs.task.memory.utilized
- ecs.task.memory.reserved
- ecs.task.cpu.utilized
- ecs.task.cpu.reserved
- ecs.task.network.rate.rx
- ecs.task.network.rate.tx
- ecs.task.storage.read_bytes
- ecs.task.storage.write_bytes
exporters:
prometheusremotewrite:
endpoint: my-remote-URL
auth:
authenticator: sigv4auth
logging:
loglevel: info
extensions:
health_check:
pprof:
endpoint: :1888
zpages:
endpoint: :55679
sigv4auth:
region: my-region
service: aps
service:
extensions: [pprof, zpages, health_check, sigv4auth]
pipelines:
metrics:
receivers: [prometheus]
exporters: [logging, prometheusremotewrite]
metrics/ecs:
receivers: [awsecscontainermetrics]
processors: [filter]
exporters: [logging, prometheusremotewrite]
```
## Langkah 2: Dorong gambar kontainer kolektor ADOT Anda ke repositori Amazon ECR
Gunakan Dockerfile untuk membuat dan mendorong image container Anda ke repositori Amazon Elastic Container Registry (ECR).
1. Bangun Dockerfile untuk menyalin dan menambahkan gambar kontainer Anda ke gambar OTEL Docker.
```
FROM public.ecr.aws/aws-observability/aws-otel-collector:latest
COPY adot-config.yaml /etc/ecs/otel-config.yaml
CMD ["--config=/etc/ecs/otel-config.yaml"]
```
1. Buat repositori Amazon ECR.
```
# create repo:
COLLECTOR_REPOSITORY=$(aws ecr create-repository --repository aws-otel-collector \
--query repository.repositoryUri --output text)
```
1. Buat gambar kontainer Anda.
```
# build ADOT collector image:
docker build -t $COLLECTOR_REPOSITORY:ecs .
```
**catatan**
Ini mengasumsikan Anda sedang membangun wadah Anda di lingkungan yang sama dengan yang akan dijalankan. Jika tidak, Anda mungkin perlu menggunakan `--platform` parameter saat membangun gambar.
1. Masuk ke repositori Amazon ECR. Ganti *my-region* dengan `region` nilai Anda.
```
# sign in to repo:
aws ecr get-login-password --region my-region | \
docker login --username AWS --password-stdin $COLLECTOR_REPOSITORY
```
1. Dorong gambar kontainer Anda.
```
# push ADOT collector image:
docker push $COLLECTOR_REPOSITORY:ecs
```
## Langkah 3: Buat definisi tugas Amazon ECS untuk mengikis Layanan Terkelola Amazon untuk Prometheus
Buat definisi tugas Amazon ECS untuk mengikis Layanan Terkelola Amazon untuk Prometheus. Definisi tugas Anda harus menyertakan wadah bernama `adot-collector` dan wadah bernama`prometheus`. `prometheus`menghasilkan metrik, dan `adot-collector` goresan`prometheus`.
**catatan**
Layanan Terkelola Amazon untuk Prometheus berjalan sebagai layanan, mengumpulkan metrik dari kontainer. Kontainer dalam hal ini menjalankan Prometheus secara lokal, dalam mode Agen, yang mengirim metrik lokal ke Amazon Managed Service untuk Prometheus.
**Contoh: Definisi tugas**
Berikut ini adalah contoh bagaimana definisi tugas Anda mungkin terlihat. Anda dapat menggunakan contoh ini sebagai template untuk membuat definisi tugas Anda sendiri. Ganti `image` nilai `adot-collector` dengan URL repositori dan tag gambar ()`$COLLECTOR_REPOSITORY:ecs`. Ganti `region` nilai `adot-collector` dan `prometheus` dengan `region` nilai-nilai Anda.
```
{
"family": "adot-prom",
"networkMode": "awsvpc",
"containerDefinitions": [
{
"name": "adot-collector",
"image": "account_id.dkr.ecr.region.amazonaws.com/image-tag",
"essential": true,
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/ecs-adot-collector",
"awslogs-region": "my-region",
"awslogs-stream-prefix": "ecs",
"awslogs-create-group": "True"
}
}
},
{
"name": "prometheus",
"image": "prom/prometheus:main",
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/ecs-prom",
"awslogs-region": "my-region",
"awslogs-stream-prefix": "ecs",
"awslogs-create-group": "True"
}
}
}
],
"requiresCompatibilities": [
"FARGATE"
],
"cpu": "1024"
}
```
## Langkah 4: Berikan izin tugas Anda untuk mengakses Amazon Managed Service untuk Prometheus
Untuk mengirim metrik yang tergores ke Amazon Managed Service for Prometheus, tugas Amazon ECS Anda harus memiliki izin yang benar untuk memanggil operasi API untuk Anda. AWS Anda harus membuat peran IAM untuk tugas-tugas Anda dan melampirkan `AmazonPrometheusRemoteWriteAccess` kebijakan untuk itu. Untuk informasi selengkapnya tentang membuat peran ini dan melampirkan kebijakan, lihat [Membuat peran dan kebijakan IAM untuk tugas Anda](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html#create_task_iam_policy_and_role).
Setelah Anda melampirkan `AmazonPrometheusRemoteWriteAccess` ke peran IAM Anda, dan menggunakan peran itu untuk tugas Anda, Amazon ECS dapat mengirim metrik yang digores ke Amazon Managed Service for Prometheus.
## Langkah 5: Visualisasikan metrik Anda di Amazon Managed Grafana
**penting**
Sebelum memulai, Anda harus menjalankan tugas Fargate pada definisi tugas Amazon ECS Anda. Jika tidak, Layanan Terkelola Amazon untuk Prometheus tidak dapat menggunakan metrik Anda.
1. Dari panel navigasi di ruang kerja Grafana Terkelola Amazon Anda, **pilih Sumber data** di bawah ikon. AWS
1. **Pada tab **Sumber data**, untuk **Layanan, pilih Amazon Managed Service** **for Prometheus** dan pilih Wilayah Default Anda.**
1. Pilih **Tambahkan sumber data**.
1. Gunakan `prometheus` awalan `ecs` dan untuk menanyakan dan melihat metrik Anda.
# Mengatur konsumsi metrik dari instans Amazon EC2 menggunakan penulisan jarak jauh
Bagian ini menjelaskan cara menjalankan server Prometheus dengan penulisan jarak jauh di instance Amazon Elastic Compute Cloud (Amazon EC2). Ini menjelaskan cara mengumpulkan metrik dari aplikasi demo yang ditulis dalam Go dan mengirimkannya ke Layanan Terkelola Amazon untuk ruang kerja Prometheus.
## Prasyarat
**penting**
Sebelum Anda mulai, Anda harus menginstal Prometheus v2.26 atau yang lebih baru. Kami berasumsi bahwa Anda sudah familiar dengan Prometheus, Amazon EC2, dan Amazon Managed Service untuk Prometheus. Untuk informasi tentang cara menginstal Prometheus, lihat [Memulai](https://prometheus.io/docs/prometheus/latest/getting_started/) di situs web Prometheus.
Jika Anda tidak terbiasa dengan Amazon EC2 atau Amazon Managed Service untuk Prometheus, kami sarankan Anda memulai dengan membaca bagian berikut:
+ [Apa itu Amazon Elastic Compute Cloud?](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html)
+ [Apa itu Amazon Managed Service for Prometheus?](https://docs.aws.amazon.com/prometheus/latest/userguide/what-is-Amazon-Managed-Service-Prometheus.html)
## Buat peran IAM untuk Amazon EC2
Untuk mengalirkan metrik, Anda harus terlebih dahulu membuat peran IAM dengan kebijakan AWS terkelola. **AmazonPrometheusRemoteWriteAccess** Kemudian, Anda dapat meluncurkan instance dengan metrik peran dan streaming ke ruang kerja Amazon Managed Service for Prometheus.
1. Buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Dari panel navigasi, pilih **Peran**, lalu pilih **Buat peran**.
1. Untuk jenis entitas tepercaya, pilih **AWS layanan**. Untuk kasus penggunaan, pilih **EC2**. Pilih **Berikutnya: Izin**.
1. Di bilah pencarian, masukkan **AmazonPrometheusRemoteWriteAccess**. Untuk **nama Kebijakan**, pilih **AmazonPrometheusRemoteWriteAccess**, lalu pilih **Lampirkan kebijakan**. Pilih **Selanjutnya: Tag**.
1. (Opsional) Buat tag IAM untuk peran IAM Anda. Pilih **Berikutnya: Tinjauan**.
1. Masukkan nama untuk peran Anda. Pilih **Buat kebijakan**.
## Luncurkan instans Amazon EC2
Untuk meluncurkan instans Amazon EC2, ikuti petunjuk di [Luncurkan instans](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role) di *Panduan Pengguna Amazon Elastic Compute Cloud untuk* Instans Linux.
## Jalankan aplikasi demo
Setelah membuat peran IAM Anda, dan meluncurkan instans EC2 dengan peran tersebut, Anda dapat menjalankan aplikasi demo untuk melihatnya berfungsi.
**Untuk menjalankan aplikasi demo dan menguji metrik**
1. Gunakan template berikut untuk membuat file Go bernama`main.go`.
```
package main
import (
"github.com/prometheus/client_golang/prometheus/promhttp"
"net/http"
)
func main() {
http.Handle("/metrics", promhttp.Handler())
http.ListenAndServe(":8000", nil)
}
```
1. Jalankan perintah berikut untuk menginstal dependensi yang benar.
```
sudo yum update -y
sudo yum install -y golang
go get github.com/prometheus/client_golang/prometheus/promhttp
```
1. Jalankan aplikasi demo.
```
go run main.go
```
Aplikasi demo harus berjalan di port 8000 dan menampilkan semua metrik Prometheus yang terbuka. Berikut ini adalah contoh metrik ini.
```
curl -s http://localhost:8000/metrics
...
process_max_fds 4096# HELP process_open_fds Number of open file descriptors.# TYPE process_open_fds gauge
process_open_fds 10# HELP process_resident_memory_bytes Resident memory size in bytes.# TYPE process_resident_memory_bytes gauge
process_resident_memory_bytes 1.0657792e+07# HELP process_start_time_seconds Start time of the process since unix epoch in seconds.# TYPE process_start_time_seconds gauge
process_start_time_seconds 1.61131955899e+09# HELP process_virtual_memory_bytes Virtual memory size in bytes.# TYPE process_virtual_memory_bytes gauge
process_virtual_memory_bytes 7.77281536e+08# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes.# TYPE process_virtual_memory_max_bytes gauge
process_virtual_memory_max_bytes -1# HELP promhttp_metric_handler_requests_in_flight Current number of scrapes being served.# TYPE promhttp_metric_handler_requests_in_flight gauge
promhttp_metric_handler_requests_in_flight 1# HELP promhttp_metric_handler_requests_total Total number of scrapes by HTTP status code.# TYPE promhttp_metric_handler_requests_total counter
promhttp_metric_handler_requests_total{code="200"} 1
promhttp_metric_handler_requests_total{code="500"} 0
promhttp_metric_handler_requests_total{code="503"} 0
```
## Buat Layanan Terkelola Amazon untuk ruang kerja Prometheus
[Untuk membuat Amazon Managed Service untuk ruang kerja Prometheus, ikuti petunjuk di Buat ruang kerja.](AMP-create-workspace.md)
## Jalankan server Prometheus
1. Gunakan contoh berikut file YAMAL sebagai template untuk membuat file baru bernama`prometheus.yaml`. Untuk`url`, ganti *my-region* dengan nilai Wilayah Anda dan *my-workspace-id* dengan ID ruang kerja yang dihasilkan Amazon Managed Service untuk Prometheus untuk Anda. Untuk`region`, ganti *my-region* dengan nilai Wilayah Anda.
**Contoh: file YAMM**
```
global:
scrape_interval: 15s
external_labels:
monitor: 'prometheus'
scrape_configs:
- job_name: 'prometheus'
static_configs:
- targets: ['localhost:8000']
remote_write:
-
url: https://aps-workspaces.my-region.amazonaws.com/workspaces/my-workspace-id/api/v1/remote_write
queue_config:
max_samples_per_send: 1000
max_shards: 200
capacity: 2500
sigv4:
region: my-region
```
1. Jalankan server Prometheus untuk mengirim metrik aplikasi demo ke Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus.
```
prometheus --config.file=prometheus.yaml
```
Server Prometheus sekarang harus mengirim metrik aplikasi demo ke Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus.
# Menggunakan contoh Prometheus sebagai kolektor
Anda dapat menggunakan instance Prometheus, berjalan *dalam* mode agen (dikenal sebagai agen *Prometheus), untuk mengikis metrik dan mengirimkannya ke Amazon Managed Service untuk ruang kerja Prometheus*.
Topik berikut menjelaskan berbagai cara untuk menyiapkan instance Prometheus yang berjalan dalam mode agen sebagai kolektor untuk metrik Anda.
**Awas**
Saat Anda membuat agen Prometheus, Anda bertanggung jawab atas konfigurasi dan pemeliharaannya. [Hindari mengekspos titik akhir scrape Prometheus ke internet publik dengan mengaktifkan fitur keamanan.](https://prometheus.io/docs/prometheus/latest/configuration/https/)
Jika Anda menyiapkan beberapa instans Prometheus yang memantau kumpulan metrik yang sama dan mengirimkannya ke satu Layanan Terkelola Amazon untuk ruang kerja Prometheus untuk ketersediaan tinggi, Anda perlu menyiapkan deduplikasi. Jika Anda tidak mengikuti langkah-langkah untuk mengatur deduplikasi, Anda akan dikenakan biaya untuk semua sampel data yang dikirim ke Amazon Managed Service untuk Prometheus, termasuk sampel duplikat. Untuk petunjuk tentang pengaturan deduplikasi, lihat. [Mendeduplikasi metrik ketersediaan tinggi yang dikirim ke Amazon Managed Service untuk Prometheus](AMP-ingest-dedupe.md)
**Topics**
+ [Mengatur konsumsi dari server Prometheus baru menggunakan Helm](AMP-onboard-ingest-metrics-new-Prometheus.md)
+ [Siapkan konsumsi dari server Prometheus yang ada di Kubernetes di EC2](AMP-onboard-ingest-metrics-existing-Prometheus.md)
+ [Siapkan konsumsi dari server Prometheus yang ada di Kubernetes di Fargate](AMP-onboard-ingest-metrics-existing-Prometheus-fargate.md)
# Mengatur konsumsi dari server Prometheus baru menggunakan Helm
Petunjuk di bagian ini membuat Anda siap dan menjalankan Layanan Terkelola Amazon untuk Prometheus dengan cepat. Anda menyiapkan server Prometheus baru di klaster Amazon EKS, dan server baru menggunakan konfigurasi default untuk mengirim metrik ke Amazon Managed Service untuk Prometheus. Metode ini memiliki prasyarat berikut:
+ Anda harus memiliki cluster Amazon EKS dari mana server Prometheus baru akan mengumpulkan metrik.
+ Cluster Amazon EKS Anda harus memiliki [driver Amazon EBS CSI](https://docs.aws.amazon.com/eks/latest/userguide/ebs-csi.html) yang diinstal (diperlukan oleh Helm).
+ Anda harus menggunakan Helm CLI 3.0 atau yang lebih baru.
+ Anda harus menggunakan komputer Linux atau macOS untuk melakukan langkah-langkah di bagian berikut.
## Langkah 1: Tambahkan repositori bagan Helm baru
Untuk menambahkan repositori bagan Helm baru, masukkan perintah berikut. Untuk informasi selengkapnya tentang perintah ini, lihat [Helm Repo](https://helm.sh/docs/helm/helm_repo/).
```
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo add kube-state-metrics https://kubernetes.github.io/kube-state-metrics
helm repo update
```
## Langkah 2: Buat namespace Prometheus
Masukkan perintah berikut untuk membuat namespace Prometheus untuk server Prometheus dan komponen pemantauan lainnya. Ganti *prometheus-namespace* dengan nama yang Anda inginkan untuk namespace ini.
```
kubectl create namespace prometheus-namespace
```
## Langkah 3: Siapkan peran IAM untuk akun layanan
Untuk metode orientasi yang kami dokumentasikan, Anda perlu menggunakan peran IAM untuk akun layanan di cluster Amazon EKS tempat server Prometheus berjalan.
Dengan peran IAM untuk akun layanan, Anda dapat mengaitkan peran IAM dengan akun layanan Kubernetes. Akun layanan ini kemudian dapat menyediakan izin AWS ke kontainer-kontainer di setiap pod yang menggunakan akun layanan tersebut. Untuk informasi selengkapnya, lihat [peran IAM untuk akun layanan](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html).
Jika Anda belum mengatur peran ini, ikuti instruksi di [Menyiapkan peran layanan untuk menelan metrik dari kluster Amazon EKS](set-up-irsa.md#set-up-irsa-ingest) untuk mengatur peran. Instruksi di bagian itu memerlukan penggunaan`eksctl`. Untuk informasi selengkapnya, lihat [Memulai dengan Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) —. `eksctl`
**catatan**
Saat Anda tidak menggunakan EKS atau AWS dan hanya menggunakan kunci akses dan kunci rahasia untuk mengakses Layanan Terkelola Amazon untuk Prometheus, Anda tidak dapat menggunakan SigV4 berbasis. `EKS-IAM-ROLE`
## Langkah 4: Siapkan server baru dan mulai menelan metrik
Untuk menginstal server Prometheus baru yang mengirimkan metrik ke Layanan Terkelola Amazon untuk ruang kerja Prometheus, ikuti langkah-langkah berikut.
**Untuk menginstal server Prometheus baru untuk mengirim metrik ke Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus**
1. Gunakan editor teks untuk membuat file bernama `my_prometheus_values_yaml` dengan konten berikut.
+ Ganti *IAM\$1PROXY\$1PROMETHEUS\$1ROLE\$1ARN* dengan ARN dari **amp-iamproxy-ingest-role**yang Anda buat. [Menyiapkan peran layanan untuk menelan metrik dari kluster Amazon EKS](set-up-irsa.md#set-up-irsa-ingest)
+ Ganti *WORKSPACE\$1ID* dengan ID Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus.
+ Ganti *REGION* dengan Wilayah Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus.
```
## The following is a set of default values for prometheus server helm chart which enable remoteWrite to AMP
## For the rest of prometheus helm chart values see: https://github.com/prometheus-community/helm-charts/blob/main/charts/prometheus/values.yaml
##
serviceAccounts:
server:
name: amp-iamproxy-ingest-service-account
annotations:
eks.amazonaws.com/role-arn: ${IAM_PROXY_PROMETHEUS_ROLE_ARN}
server:
remoteWrite:
- url: https://aps-workspaces.${REGION}.amazonaws.com/workspaces/${WORKSPACE_ID}/api/v1/remote_write
sigv4:
region: ${REGION}
queue_config:
max_samples_per_send: 1000
max_shards: 200
capacity: 2500
```
1. Masukkan perintah berikut untuk membuat server Prometheus.
+ Ganti *prometheus-chart-name* dengan nama rilis Prometheus Anda.
+ Ganti *prometheus-namespace* dengan nama namespace Prometheus Anda.
```
helm install prometheus-chart-name prometheus-community/prometheus -n prometheus-namespace \
-f my_prometheus_values_yaml
```
**catatan**
Anda dapat menyesuaikan `helm install` perintah dengan banyak cara. Untuk informasi selengkapnya, lihat [Helm install](https://helm.sh/docs/helm/helm_install/) di dokumentasi *Helm*.
# Siapkan konsumsi dari server Prometheus yang ada di Kubernetes di EC2
Layanan Terkelola Amazon untuk Prometheus mendukung pengambilan metrik dari server Prometheus di cluster yang menjalankan Amazon EKS dan di cluster Kubernetes yang dikelola sendiri yang berjalan di Amazon EC2. Petunjuk terperinci di bagian ini adalah untuk server Prometheus di cluster Amazon EKS. Langkah-langkah untuk klaster Kubernetes yang dikelola sendiri di Amazon EC2 adalah sama, kecuali Anda perlu menyiapkan sendiri peran penyedia OIDC dan IAM untuk akun layanan di klaster Kubernetes.
Instruksi di bagian ini menggunakan Helm sebagai manajer paket Kubernetes.
**Topics**
+ [Langkah 1: Siapkan peran IAM untuk akun layanan](#AMP-onboard-existing-Prometheus-IRSA)
+ [Langkah 2: Tingkatkan server Prometheus Anda yang ada menggunakan Helm](#AMP-onboard-ingest-metrics-existing-remotewrite)
## Langkah 1: Siapkan peran IAM untuk akun layanan
Untuk metode orientasi yang kami dokumentasikan, Anda perlu menggunakan peran IAM untuk akun layanan di cluster Amazon EKS tempat server Prometheus berjalan. Peran ini juga disebut *peran layanan*.
Dengan peran layanan, Anda dapat mengaitkan peran IAM dengan akun layanan Kubernetes. Akun layanan ini kemudian dapat memberikan AWS izin ke kontainer di pod mana pun yang menggunakan akun layanan tersebut. Untuk informasi selengkapnya, lihat [peran IAM untuk akun layanan](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html).
Jika Anda belum mengatur peran ini, ikuti instruksi di [Menyiapkan peran layanan untuk menelan metrik dari kluster Amazon EKS](set-up-irsa.md#set-up-irsa-ingest) untuk mengatur peran.
## Langkah 2: Tingkatkan server Prometheus Anda yang ada menggunakan Helm
Petunjuk di bagian ini mencakup pengaturan penulisan jarak jauh dan sigv4 untuk mengautentikasi dan mengotorisasi server Prometheus untuk menulis jarak jauh ke Layanan Terkelola Amazon Anda untuk ruang kerja Prometheus.
### Menggunakan Prometheus versi 2.26.0 atau yang lebih baru
Ikuti langkah-langkah ini jika Anda menggunakan bagan Helm dengan gambar Prometheus Server versi 2.26.0 atau yang lebih baru.
**Untuk mengatur penulisan jarak jauh dari server Prometheus menggunakan bagan Helm**
1. Buat bagian penulisan jarak jauh baru di file konfigurasi Helm Anda:
+ Ganti `${IAM_PROXY_PROMETHEUS_ROLE_ARN}` dengan ARN dari **amp-iamproxy-ingest-role**yang Anda buat. [Langkah 1: Siapkan peran IAM untuk akun layanan](#AMP-onboard-existing-Prometheus-IRSA) Peran ARN harus memiliki format. `arn:aws:iam::your account ID:role/amp-iamproxy-ingest-role`
+ Ganti `${WORKSPACE_ID}` dengan Layanan Terkelola Amazon Anda untuk ID ruang kerja Prometheus.
+ Ganti `${REGION}` dengan Wilayah Layanan Terkelola Amazon untuk ruang kerja Prometheus (seperti). `us-west-2`
```
## The following is a set of default values for prometheus server helm chart which enable remoteWrite to AMP
## For the rest of prometheus helm chart values see: https://github.com/prometheus-community/helm-charts/blob/main/charts/prometheus/values.yaml
##
serviceAccounts:
server:
name: amp-iamproxy-ingest-service-account
annotations:
eks.amazonaws.com/role-arn: ${IAM_PROXY_PROMETHEUS_ROLE_ARN}
server:
remoteWrite:
- url: https://aps-workspaces.${REGION}.amazonaws.com/workspaces/${WORKSPACE_ID}/api/v1/remote_write
sigv4:
region: ${REGION}
queue_config:
max_samples_per_send: 1000
max_shards: 200
capacity: 2500
```
1. Perbarui konfigurasi Server Prometheus Anda yang ada menggunakan Helm:
+ Ganti `prometheus-chart-name` dengan nama rilis Prometheus Anda.
+ Ganti `prometheus-namespace` dengan namespace Kubernetes tempat Server Prometheus Anda diinstal.
+ Ganti `my_prometheus_values_yaml` dengan path ke file konfigurasi Helm Anda.
+ Ganti `current_helm_chart_version` dengan versi grafik Helm Server Prometheus Anda saat ini. Anda dapat menemukan versi bagan saat ini dengan menggunakan perintah [helm list](https://helm.sh/docs/helm/helm_list/).
```
helm upgrade prometheus-chart-name prometheus-community/prometheus \
-n prometheus-namespace \
-f my_prometheus_values_yaml \
--version current_helm_chart_version
```
### Menggunakan Prometheus versi sebelumnya
Ikuti langkah-langkah ini jika Anda menggunakan versi Prometheus lebih awal dari 2.26.0. Langkah-langkah ini menggunakan pendekatan sespan, karena versi Prometheus sebelumnya tidak mendukung AWS proses penandatanganan Signature Version 4 (SiGv4).AWS
Instruksi ini mengasumsikan bahwa Anda menggunakan Helm untuk menyebarkan Prometheus.
**Untuk mengatur penulisan jarak jauh dari server Prometheus**
1. Di server Prometheus Anda, buat konfigurasi penulisan jarak jauh baru. Pertama, buat file pembaruan baru. Kami akan memanggil file tersebut`amp_ingest_override_values.yaml`.
Tambahkan nilai berikut ke file YAMM.
```
serviceAccounts:
server:
name: "amp-iamproxy-ingest-service-account"
annotations:
eks.amazonaws.com/role-arn: "${SERVICE_ACCOUNT_IAM_INGEST_ROLE_ARN}"
server:
sidecarContainers:
- name: aws-sigv4-proxy-sidecar
image: public.ecr.aws/aws-observability/aws-sigv4-proxy:1.0
args:
- --name
- aps
- --region
- ${REGION}
- --host
- aps-workspaces.${REGION}.amazonaws.com
- --port
- :8005
ports:
- name: aws-sigv4-proxy
containerPort: 8005
statefulSet:
enabled: "true"
remoteWrite:
- url: http://localhost:8005/workspaces/${WORKSPACE_ID}/api/v1/remote_write
```
Ganti `${REGION}` dengan Wilayah Layanan Terkelola Amazon untuk ruang kerja Prometheus.
Ganti `${SERVICE_ACCOUNT_IAM_INGEST_ROLE_ARN}` dengan ARN dari **amp-iamproxy-ingest-role**yang Anda buat. [Langkah 1: Siapkan peran IAM untuk akun layanan](#AMP-onboard-existing-Prometheus-IRSA) Peran ARN harus memiliki format. `arn:aws:iam::your account ID:role/amp-iamproxy-ingest-role`
Ganti `${WORKSPACE_ID}` dengan ID ruang kerja Anda.
1. Tingkatkan bagan Prometheus Helm Anda. Pertama, temukan nama bagan Helm Anda dengan memasukkan perintah berikut. Pada output dari perintah ini, cari bagan dengan nama yang disertakan`prometheus`.
```
helm ls --all-namespaces
```
Masukkan perintah berikut ini.
```
helm upgrade --install prometheus-helm-chart-name prometheus-community/prometheus -n prometheus-namespace -f ./amp_ingest_override_values.yaml
```
Ganti *prometheus-helm-chart-name* dengan nama bagan helm Prometheus yang dikembalikan pada perintah sebelumnya. Ganti *prometheus-namespace* dengan nama namespace Anda.
#### Mengunduh grafik Helm
Jika Anda belum mengunduh bagan Helm secara lokal, Anda dapat menggunakan perintah berikut untuk mengunduhnya.
```
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm pull prometheus-community/prometheus --untar
```
# Siapkan konsumsi dari server Prometheus yang ada di Kubernetes di Fargate
Layanan Terkelola Amazon untuk Prometheus mendukung pengambilan metrik dari server Prometheus di cluster Kubernetes yang dikelola sendiri yang berjalan di Fargate. Untuk menyerap metrik dari server Prometheus di kluster Amazon EKS yang berjalan di Fargate, ganti konfigurasi default dalam file konfigurasi bernama amp\$1ingest\$1override\$1values.yaml sebagai berikut:
```
prometheus-node-exporter:
enabled: false
alertmanager:
enabled: false
serviceAccounts:
server:
name: amp-iamproxy-ingest-service-account
annotations:
eks.amazonaws.com/role-arn: ${IAM_PROXY_PROMETHEUS_ROLE_ARN}
server:
persistentVolume:
enabled: false
remoteWrite:
- url: https://aps-workspaces.${REGION}.amazonaws.com/workspaces/${WORKSPACE_ID}/api/v1/remote_write
sigv4:
region: ${REGION}
queue_config:
max_samples_per_send: 1000
max_shards: 200
capacity: 2500
```
Instal Prometheus menggunakan penggantian dengan perintah berikut:
```
helm install prometheus-for-amp prometheus-community/prometheus \
-n prometheus \
-f amp_ingest_override_values.yaml
```
Perhatikan bahwa dalam konfigurasi bagan Helm kami menonaktifkan pengekspor node dan manajer peringatan serta menjalankan penyebaran server Prometheus.
Anda dapat memverifikasi penginstalan dengan contoh kueri pengujian berikut.
```
$ awscurl --region region --service aps "https://aps-workspaces.region_id.amazonaws.com/workspaces/workspace_id/api/v1/query?query=prometheus_api_remote_read_queries"
{"status":"success","data":{"resultType":"vector","result":[{"metric":{"__name__":"prometheus_api_remote_read_queries","instance":"localhost:9090","job":"prometheus"},"value":[1648461236.419,"0"]}]}}21
```
# Siapkan Amazon Managed Service untuk Prometheus untuk data ketersediaan tinggi
Saat Anda mengirim data ke Amazon Managed Service untuk Prometheus, data akan direplikasi secara otomatis AWS di seluruh Availability Zone di Wilayah, dan disajikan kepada Anda dari sekelompok host yang menyediakan skalabilitas, ketersediaan, dan keamanan. Anda mungkin ingin menambahkan brankas kegagalan ketersediaan tinggi tambahan, tergantung pada pengaturan khusus Anda. Ada dua cara umum agar Anda dapat menambahkan keamanan ketersediaan tinggi ke pengaturan Anda:
+ Jika Anda memiliki beberapa kontainer atau instans yang memiliki data yang sama, Anda dapat mengirim data tersebut ke Amazon Managed Service untuk Prometheus dan data secara otomatis di-de-duplikasi. Ini membantu memastikan bahwa data Anda akan dikirim ke Layanan Terkelola Amazon untuk ruang kerja Prometheus.
Untuk informasi selengkapnya tentang menghilangkan duplikasi data ketersediaan tinggi, lihat. [Mendeduplikasi metrik ketersediaan tinggi yang dikirim ke Amazon Managed Service untuk Prometheus](AMP-ingest-dedupe.md)
+ Jika Anda ingin memastikan bahwa Anda memiliki akses ke data Anda, bahkan ketika AWS Wilayah tidak tersedia, Anda dapat mengirim metrik Anda ke ruang kerja kedua, di Wilayah lain.
Untuk informasi selengkapnya tentang mengirim data metrik ke beberapa ruang kerja, lihat. [Gunakan ruang kerja lintas Wilayah untuk menambahkan ketersediaan tinggi di Amazon Managed Service untuk Prometheus](AMP-send-to-multiple-workspaces.md)
**Topics**
+ [Mendeduplikasi metrik ketersediaan tinggi yang dikirim ke Amazon Managed Service untuk Prometheus](AMP-ingest-dedupe.md)
+ [Kirim data ketersediaan tinggi ke Amazon Managed Service untuk Prometheus dengan Prometheus](Send-high-availability-data.md)
+ [Siapkan data ketersediaan tinggi ke Amazon Managed Service untuk Prometheus menggunakan bagan Helm Operator Prometheus](Send-high-availability-data-operator.md)
+ [Kirim data ketersediaan tinggi ke Amazon Managed Service untuk Prometheus dengan Distro untuk AWS OpenTelemetry](Send-high-availability-data-ADOT.md)
+ [Kirim data ketersediaan tinggi ke Amazon Managed Service untuk Prometheus dengan bagan Helm komunitas Prometheus](Send-high-availability-prom-community.md)
+ [Jawaban atas pertanyaan umum tentang konfigurasi ketersediaan tinggi di Amazon Managed Service untuk Prometheus](HA_FAQ.md)
+ [Gunakan ruang kerja lintas Wilayah untuk menambahkan ketersediaan tinggi di Amazon Managed Service untuk Prometheus](AMP-send-to-multiple-workspaces.md)
# Mendeduplikasi metrik ketersediaan tinggi yang dikirim ke Amazon Managed Service untuk Prometheus
Anda dapat mengirim data dari beberapa agen Prometheus (instance *Prometheus* yang berjalan dalam mode Agen) ke Layanan Terkelola Amazon untuk ruang kerja Prometheus. Jika beberapa instans ini merekam dan mengirimkan metrik yang sama, data Anda akan memiliki ketersediaan yang lebih tinggi (meskipun salah satu agen berhenti mengirim data, Layanan Terkelola Amazon untuk ruang kerja Prometheus akan tetap menerima data dari instance lain). Namun, Anda ingin ruang kerja Amazon Managed Service for Prometheus secara otomatis menghapus duplikasi metrik sehingga Anda tidak melihat metrik beberapa kali, dan tidak dikenakan biaya untuk konsumsi dan penyimpanan data beberapa kali.
**Agar Amazon Managed Service untuk Prometheus dapat secara otomatis menghapus duplikat data dari beberapa agen Prometheus, Anda memberikan kumpulan agen yang mengirimkan data duplikat satu nama cluster, dan setiap instance nama replika.** Nama cluster mengidentifikasi instance sebagai memiliki data bersama, dan nama replika memungkinkan Amazon Managed Service untuk Prometheus mengidentifikasi sumber setiap metrik. Metrik tersimpan terakhir menyertakan label cluster, tetapi bukan replika, sehingga metrik tampaknya berasal dari satu sumber.
**catatan**
Versi Kubernetes tertentu (1,28 dan 1,29) dapat memancarkan metriknya sendiri dengan label. `cluster` Hal ini dapat menyebabkan masalah dengan Amazon Managed Service untuk deduplikasi Prometheus. Lihat [FAQ ketersediaan tinggi](HA_FAQ.md#HA_FAQ_cluster-label) untuk informasi lebih lanjut.
Topik berikut menunjukkan cara mengirim data dan menyertakan `cluster` dan `__replica__` label, sehingga Amazon Managed Service for Prometheus menghapus duplikasi data secara otomatis.
**penting**
Jika Anda tidak mengatur deduplikasi, Anda akan dikenakan biaya untuk semua sampel data yang dikirim ke Amazon Managed Service untuk Prometheus. Sampel data ini termasuk sampel duplikat.
# Kirim data ketersediaan tinggi ke Amazon Managed Service untuk Prometheus dengan Prometheus
Untuk menyiapkan konfigurasi ketersediaan tinggi dengan Prometheus, Anda harus menerapkan label eksternal pada semua instance grup ketersediaan tinggi, sehingga Amazon Managed Service for Prometheus dapat mengidentifikasinya. Gunakan `cluster` label untuk mengidentifikasi agen instance Prometheus sebagai bagian dari grup ketersediaan tinggi. Gunakan `__replica__` label untuk mengidentifikasi setiap replika dalam grup secara terpisah. Anda perlu menerapkan keduanya `__replica__` dan `cluster` label agar de-duplikasi berfungsi.
**catatan**
`__replica__`Label diformat dengan dua simbol garis bawah sebelum dan sesudah kata. `replica`
**Contoh: cuplikan kode**
Dalam cuplikan kode berikut, `cluster` label mengidentifikasi agen `prom-team1` instance Prometheus, dan label mengidentifikasi replika dan. `_replica_` `replica1` `replica2`
```
cluster: prom-team1
__replica__: replica1
```
```
cluster: prom-team1
__replica__: replica2
```
Karena Amazon Managed Service untuk Prometheus menyimpan sampel data dari replika ketersediaan tinggi dengan label ini, itu menghapus label saat sampel diterima`replica`. Ini berarti bahwa Anda hanya akan memiliki pemetaan seri 1:1 untuk seri Anda saat ini, bukan seri per replika. `cluster`Label disimpan.
**catatan**
Versi Kubernetes tertentu (1,28 dan 1,29) dapat memancarkan metriknya sendiri dengan label. `cluster` Hal ini dapat menyebabkan masalah dengan Amazon Managed Service untuk deduplikasi Prometheus. Lihat [FAQ ketersediaan tinggi](HA_FAQ.md#HA_FAQ_cluster-label) untuk informasi lebih lanjut.
# Siapkan data ketersediaan tinggi ke Amazon Managed Service untuk Prometheus menggunakan bagan Helm Operator Prometheus
Untuk menyiapkan konfigurasi ketersediaan tinggi dengan Operator Prometheus di Helm, Anda harus menerapkan label eksternal pada semua instance grup ketersediaan tinggi, sehingga Layanan Terkelola Amazon untuk Prometheus dapat mengidentifikasinya. Anda juga harus mengatur atribut `replicaExternalLabelName` dan `externalLabels` pada bagan Helm Operator Prometheus.
**Contoh: header YAMM**
Di header YAMM berikut, `cluster` ditambahkan `externalLabel` untuk mengidentifikasi agen instans Prometheus sebagai bagian dari grup ketersediaan tinggi, `replicaExternalLabels` dan mengidentifikasi setiap replika dalam grup.
```
replicaExternalLabelName: __replica__
externalLabels:
cluster: prom-dev
```
**catatan**
Versi Kubernetes tertentu (1,28 dan 1,29) dapat memancarkan metriknya sendiri dengan label. `cluster` Hal ini dapat menyebabkan masalah dengan Amazon Managed Service untuk deduplikasi Prometheus. Lihat [FAQ ketersediaan tinggi](HA_FAQ.md#HA_FAQ_cluster-label) untuk informasi lebih lanjut.
# Kirim data ketersediaan tinggi ke Amazon Managed Service untuk Prometheus dengan Distro untuk AWS OpenTelemetry
AWS Distro for OpenTelemetry (ADOT) adalah distribusi proyek yang aman dan siap produksi. OpenTelemetry ADOT memberi Anda sumber APIs, pustaka, dan agen, sehingga Anda dapat mengumpulkan jejak dan metrik terdistribusi untuk pemantauan aplikasi. Untuk informasi tentang ADOT, lihat [Tentang AWS Distro untuk Telemetri Terbuka](https://aws-otel.github.io/about).
Untuk mengatur ADOT dengan konfigurasi ketersediaan tinggi, Anda harus mengkonfigurasi gambar kontainer kolektor ADOT dan menerapkan label eksternal `cluster` dan `__replica__` ke eksportir tulis jarak jauh Prometheus AWS . Eksportir ini mengirimkan metrik tergores Anda ke Layanan Terkelola Amazon untuk ruang kerja Prometheus melalui titik akhir. `remote_write` Saat Anda menyetel label ini pada eksportir penulisan jarak jauh, Anda mencegah metrik duplikat disimpan saat replika redundan berjalan. Untuk informasi lebih lanjut tentang eksportir tulis jarak jauh AWS Prometheus, lihat [Memulai dengan eksportir tulis jarak jauh Prometheus untuk Layanan Terkelola Amazon untuk Prometheus](https://aws-otel.github.io/docs/getting-started/prometheus-remote-write-exporter).
**catatan**
Versi Kubernetes tertentu (1,28 dan 1,29) dapat memancarkan metriknya sendiri dengan label. `cluster` Hal ini dapat menyebabkan masalah dengan Amazon Managed Service untuk deduplikasi Prometheus. Lihat [FAQ ketersediaan tinggi](HA_FAQ.md#HA_FAQ_cluster-label) untuk informasi lebih lanjut.
# Kirim data ketersediaan tinggi ke Amazon Managed Service untuk Prometheus dengan bagan Helm komunitas Prometheus
Untuk menyiapkan konfigurasi ketersediaan tinggi dengan bagan Helm komunitas Prometheus, Anda harus menerapkan label eksternal pada semua instance grup ketersediaan tinggi, sehingga Layanan Terkelola Amazon untuk Prometheus dapat mengidentifikasinya. Berikut adalah contoh bagaimana Anda dapat menambahkan `external_labels` ke satu contoh Prometheus dari bagan Helm komunitas Prometheus.
```
server:
global:
external_labels:
cluster: monitoring-cluster
__replica__: replica-1
```
**catatan**
Jika Anda menginginkan beberapa replika, Anda harus menerapkan bagan beberapa kali dengan nilai replika yang berbeda, karena bagan Helm komunitas Prometheus tidak memungkinkan Anda mengatur nilai replika secara dinamis saat menambah jumlah replika langsung dari grup pengontrol. Jika Anda lebih suka `replica` label disetel secara otomatis, gunakan bagan Helm prometheus-operator.
**catatan**
Versi Kubernetes tertentu (1,28 dan 1,29) dapat memancarkan metriknya sendiri dengan label. `cluster` Hal ini dapat menyebabkan masalah dengan Amazon Managed Service untuk deduplikasi Prometheus. Lihat [FAQ ketersediaan tinggi](HA_FAQ.md#HA_FAQ_cluster-label) untuk informasi lebih lanjut.
# Jawaban atas pertanyaan umum tentang konfigurasi ketersediaan tinggi di Amazon Managed Service untuk Prometheus
## Haruskah saya memasukkan nilai *\$1\$1replica\$1\$1* ke label lain untuk melacak titik sampel?
Dalam pengaturan ketersediaan tinggi, Amazon Managed Service untuk Prometheus memastikan sampel data tidak diduplikasi dengan memilih pemimpin dalam cluster instance Prometheus. Jika replika pemimpin berhenti mengirim sampel data selama 30 detik, Layanan Terkelola Amazon untuk Prometheus secara otomatis menjadikan instance Prometheus lain sebagai replika pemimpin dan menyerap data dari pemimpin baru, termasuk data yang terlewat. Karena itu, jawabannya tidak, tidak disarankan. Melakukannya dapat menyebabkan masalah seperti:
+ Meminta a `count` di **PromQL** dapat mengembalikan nilai yang lebih tinggi dari yang diharapkan selama periode pemilihan pemimpin baru.
+ Jumlah `active series` akan meningkat selama periode memilih pemimpin baru dan mencapai. `active series limits` Lihat [Kuota AMP](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP_quotas.html) untuk info selengkapnya.
## Kubernetes tampaknya memiliki label *klaster* sendiri, dan tidak men-deduplikasi metrik saya. Bagaimana saya bisa memperbaikinya?
Sebuah metrik baru, `apiserver_storage_size_bytes` diperkenalkan di Kubernetes 1.28, dengan label. `cluster` Hal ini dapat menyebabkan masalah dengan deduplikasi di Amazon Managed Service untuk Prometheus, yang bergantung pada label. `cluster` Di Kubernetes 1.3, label diubah namanya menjadi `storage-cluster_id` (juga diganti namanya di tambalan selanjutnya dari 1,28 dan 1,29). Jika klaster Anda memancarkan metrik ini dengan `cluster` label, Amazon Managed Service untuk Prometheus tidak dapat men-dedupe deret waktu terkait. Kami menyarankan Anda meningkatkan klaster Kubernetes Anda ke versi patch terbaru untuk menghindari masalah ini. Sebagai alternatif, Anda dapat memberi label ulang `cluster` label pada `apiserver_storage_size_bytes` metrik Anda sebelum memasukkannya ke Amazon Managed Service for Prometheus.
**catatan**
*Untuk detail selengkapnya tentang perubahan Kubernetes, lihat [Mengganti nama klaster Label menjadi storage\$1cluster\$1id untuk metrik apiserver\$1storage\$1size\$1bytes](https://github.com/kubernetes/kubernetes/pull/124283) dalam proyek Kubernetes. GitHub*
# Gunakan ruang kerja lintas Wilayah untuk menambahkan ketersediaan tinggi di Amazon Managed Service untuk Prometheus
Untuk menambahkan ketersediaan lintas wilayah ke data Anda, Anda dapat mengirim metrik ke beberapa ruang kerja di seluruh Wilayah. AWS Prometheus mendukung banyak penulis dan penulisan lintas wilayah.
Contoh berikut menunjukkan cara mengatur server Prometheus yang berjalan dalam mode Agen untuk mengirim metrik ke dua ruang kerja di Wilayah yang berbeda dengan Helm.
```
extensions:
sigv4auth:
service: "aps"
receivers:
prometheus:
config:
scrape_configs:
- job_name: 'kubernetes-kubelet'
scheme: https
tls_config:
ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
insecure_skip_verify: true
bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
kubernetes_sd_configs:
- role: node
relabel_configs:
- action: labelmap
regex: __meta_kubernetes_node_label_(.+)
- target_label: __address__
replacement: kubernetes.default.svc.cluster.local:443
- source_labels: [__meta_kubernetes_node_name]
regex: (.+)
target_label: __metrics_path__
replacement: /api/v1/nodes/$${1}/proxy/metrics
exporters:
prometheusremotewrite/one:
endpoint: "https://aps-workspaces.workspace_1_region.amazonaws.com/workspaces/ws-workspace_1_id/api/v1/remote_write"
auth:
authenticator: sigv4auth
prometheusremotewrite/two:
endpoint: "https://aps-workspaces.workspace_2_region.amazonaws.com/workspaces/ws-workspace_2_id/api/v1/remote_write"
auth:
authenticator: sigv4auth
service:
extensions: [sigv4auth]
pipelines:
metrics/one:
receivers: [prometheus]
exporters: [prometheusremotewrite/one]
metrics/two:
receivers: [prometheus]
exporters: [prometheusremotewrite/two]
```