Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Configura raccoglitori gestiti per Amazon EKS
Per utilizzare un raccoglitore Amazon Managed Service for Prometheus, devi creare uno scraper che rileva e recupera i parametri nel tuo cluster Amazon EKS. Puoi anche creare uno scraper che si integri con Amazon Managed Streaming for Apache Kafka. Per ulteriori informazioni, consulta [Integrate Amazon MSK.](https://docs.aws.amazon.com/prometheus/latest/userguide/prom-msk-integration.html)
+ Puoi creare uno scraper come parte della creazione del cluster Amazon EKS. Per ulteriori informazioni sulla creazione di un cluster Amazon EKS, inclusa la creazione di uno scraper, consulta [Creazione di un cluster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) nella *Guida per l'utente di Amazon EKS*.
+ Puoi creare il tuo scraper, a livello di codice con l' AWS API o utilizzando. AWS CLI
Un raccoglitore del servizio gestito da Amazon per Prometheus analizza parametri compatibili con Prometheus. Per ulteriori informazioni sui parametri compatibili con Prometheus, consulta [Quali sono i parametri compatibili con Prometheus?](prom-compatible-metrics.md). I cluster Amazon EKS espongono i parametri per il server API. I cluster Amazon EKS con versione Kubernetes `1.28` o superiore espongono anche i parametri relativi a e. `kube-scheduler` `kube-controller-manager` *Per ulteriori informazioni, consulta [Fetch control plane raw metrics in formato Prometheus nella Amazon EKS User Guide](https://docs.aws.amazon.com/eks/latest/userguide/view-raw-metrics.html#scheduler-controller-metrics).*
**Nota**
L'estrazione dei parametri da un cluster può comportare costi per l'utilizzo della rete. Un modo per ottimizzare questi costi consiste nel configurare l'`/metrics`endpoint in modo da comprimere le metriche fornite (ad esempio, con gzip), riducendo i dati che devono essere spostati attraverso la rete. Il modo in cui eseguire questa operazione dipende dall'applicazione o dalla libreria che fornisce le metriche. Alcune librerie sono gzip di default.
I seguenti argomenti descrivono come creare, gestire e configurare scraper.
**Topics**
+ [Creare uno scraper](#AMP-collector-create)
+ [Configurazione del cluster Amazon EKS](#AMP-collector-eks-setup)
+ [Trova ed elimina gli scraper](#AMP-collector-list-delete)
+ [Configurazione dello scraper](#AMP-collector-configuration)
+ [Risoluzione degli errori di configurazione dello scrape](#AMP-collector-troubleshoot)
+ [Limitazioni dello scraper](#AMP-collector-limits)
## Creare uno scraper
Un raccoglitore del servizio gestito da Amazon per Prometheus è costituito da uno scraper che rileva e raccoglie i parametri da un cluster Amazon EKS. Il servizio gestito da Amazon per Prometheus gestisce lo scraper per te, offrendoti la scalabilità, la sicurezza e l'affidabilità di cui hai bisogno, senza dover gestire personalmente istanze, agenti o scraper.
Esistono tre modi per creare uno scraper:
+ Uno scraper viene creato automaticamente quando [crei un cluster Amazon EKS tramite la console Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) e scegli di attivare le metriche di Prometheus.
+ Puoi creare uno scraper dalla console Amazon EKS per un cluster esistente. Apri il cluster nella [console Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters), quindi, nella scheda **Osservabilità**, scegli **Aggiungi scraper**.
*Per ulteriori dettagli sulle impostazioni disponibili, consulta [Attiva i parametri di Prometheus nella Amazon EKS User](https://docs.aws.amazon.com/eks/latest/userguide/prometheus.html#turn-on-prometheus-metrics) Guide.*
+ Puoi creare uno scraper utilizzando l'API o il. AWS AWS CLI
Queste opzioni sono descritte nella procedura seguente.
Esistono alcuni prerequisiti per creare il proprio scraper:
+ Devi avere un cluster Amazon EKS.
+ Il tuo cluster Amazon EKS deve avere il [controllo degli accessi agli endpoint del cluster](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html) impostato per includere l'accesso privato. Può includere aree private e pubbliche, ma deve includere quelle private.
+ [L'Amazon VPC in cui risiede il cluster Amazon EKS deve avere DNS abilitato.](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html)
**Nota**
Il cluster verrà associato allo scraper tramite il relativo nome di risorsa Amazon (ARN). Se elimini un cluster e poi ne crei uno nuovo con lo stesso nome, l'ARN verrà riutilizzato per il nuovo cluster. Per questo motivo, lo scraper tenterà di raccogliere le metriche per il nuovo cluster. [Gli scraper vengono eliminati](#AMP-collector-list-delete) separatamente dall'eliminazione del cluster.
------
#### [ AWS API ]
**Come creare uno scraper utilizzando l' AWS API**
Utilizzate l'operazione `CreateScraper` API per creare uno scraper con l'API. AWS Nell'esempio seguente viene creato uno scraper nella `us-west-2` regione. È necessario sostituire le informazioni relative all'area di lavoro Account AWS, alla sicurezza e al cluster Amazon EKS con le proprie IDs e fornire la configurazione da utilizzare per lo scraper.
**Nota**
Il gruppo di sicurezza e le sottoreti devono essere impostati sul gruppo di sicurezza e sulle sottoreti del cluster a cui ti stai connettendo.
Devi includere minimo due sottoreti in almeno due zone disponibili.
`scrapeConfiguration` è un file YAML di configurazione Prometheus con codifica base64. È possibile scaricare una configurazione generica con l'operazione API `GetDefaultScraperConfiguration`. Per ulteriori informazioni sul formato di, vedere. `scrapeConfiguration` [Configurazione dello 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 ]
**Come creare uno scraper utilizzando AWS CLI**
Utilizzate il `create-scraper` comando per creare un raschietto con. AWS CLI Nell'esempio seguente viene creato uno scraper nella `us-west-2` regione. È necessario sostituire le informazioni relative all'area di lavoro Account AWS, alla sicurezza e al cluster Amazon EKS con le proprie IDs e fornire la configurazione da utilizzare per lo scraper.
**Nota**
Il gruppo di sicurezza e le sottoreti devono essere impostati sul gruppo di sicurezza e sulle sottoreti del cluster a cui ti stai connettendo.
Devi includere minimo due sottoreti in almeno due zone disponibili.
`scrape-configuration` è un file YAML di configurazione Prometheus con codifica base64. È possibile scaricare una configurazione generica con il comando. `get-default-scraper-configuration` Per ulteriori informazioni sul formato di`scrape-configuration`, vedere[Configurazione dello 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'}"
```
------
Di seguito è riportato un elenco completo delle operazioni dello scraper che è possibile utilizzare con l' AWS API:
+ Creare uno scraper con l'operazione [CreateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_CreateScraper.html) API.
+ Elenca i tuoi scraper esistenti con l'operazione [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html) API.
+ Aggiorna l'alias, la configurazione o la destinazione di uno scraper con l'operazione [UpdateScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_UpdateScraper.html)API.
+ Elimina uno scraper con l'operazione [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html) API.
+ Ottieni maggiori dettagli su uno scraper con l'operazione [DescribeScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DescribeScraper.html) API.
+ Ottieni una configurazione generica per gli scraper con l'operazione [GetDefaultScraperConfiguration](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_GetDefaultScraperConfiguration.html) API.
**Nota**
Il cluster Amazon EKS di cui stai effettuando lo scraping deve essere configurato per consentire al servizio gestito da Amazon per Prometheus di accedere ai parametri. Nell'argomento successivo viene descritto come configurare il cluster.
### Configurazione tra più account
Per creare uno scraper tra account quando il cluster Amazon EKS e l'area di lavoro Amazon Managed Service for Prometheus si trovano in account diversi, utilizza la procedura seguente. Ad esempio, hai un account di origine `account_id_source` contenente il cluster Amazon EKS e un account di destinazione `account_id_target` contenente l'area di lavoro Amazon Managed Service for Prometheus.
**Per creare uno scraper in una configurazione tra più account**
1. Nell'account di origine, crea un ruolo `arn:aws:iam::account_id_source:role/Source` e aggiungi la seguente politica di fiducia.
```
{
"Effect": "Allow",
"Principal": {
"Service": [
"scraper.aps.amazonaws.com"
]
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "scraper_ARN"
},
"StringEquals": {
"AWS:SourceAccount": "account_id"
}
}
}
```
1. In ogni combinazione di origine (cluster Amazon EKS) e destinazione (Amazon Managed Service for Prometheus workspace), devi creare un `arn:aws:iam::account_id_target:role/Target` ruolo e aggiungere la seguente politica di fiducia con autorizzazioni per. [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. Crea uno scraper con l'opzione. `--role-configuration`
```
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. Convalida la creazione dello 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"
}
}
}
]
}
```
### Passaggio da un ruolo collegato al servizio RoleConfiguration e viceversa
Se desideri tornare a un ruolo collegato al servizio anziché scrivere su un'area di lavoro Amazon Managed Service for Prometheus, devi aggiornare `UpdateScraper` e fornire un'area di lavoro nello stesso account dello scraper senza il. `RoleConfiguration` `RoleConfiguration` `RoleConfiguration`Verrà rimosso dallo scraper e verrà utilizzato il ruolo collegato al servizio.
Quando si modificano le aree di lavoro nello stesso account dello scraper e si desidera continuare a utilizzare il`RoleConfiguration`, è necessario fornire nuovamente l'attivazione. `RoleConfiguration` `UpdateScraper`
### Creazione di scraper per aree di lavoro abilitate con chiavi gestite dal cliente
Per creare uno scraper per l'inserimento di metriche in un'area di lavoro di Amazon Managed Service for Prometheus con [chiavi gestite dal cliente](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk), usa il con l'origine e la `--role-configuration` destinazione impostate sullo stesso account.
```
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"}'
```
### Errori comuni durante la creazione di raschietti
Di seguito sono riportati i problemi più comuni che si verificano quando si tenta di creare un nuovo scraper.
+ AWS Le risorse richieste non esistono. Il *gruppo di sicurezza*, le *sottoreti e* il *cluster Amazon EKS* specificati devono esistere.
+ Spazio per indirizzi IP insufficiente. Devi avere almeno un indirizzo IP disponibile in ogni sottorete che passi all'`CreateScraper`API.
## Configurazione del cluster Amazon EKS
Il cluster Amazon EKS deve essere configurato per consentire allo scraper di accedere ai parametri. Esistono due opzioni per questa configurazione:
+ Utilizza *le voci di accesso* di Amazon EKS per fornire automaticamente ai collezionisti Amazon Managed Service for Prometheus l'accesso al tuo cluster.
+ Configura manualmente il tuo cluster Amazon EKS per lo scraping dei parametri gestito.
I seguenti argomenti descrivono ciascuno di questi aspetti in modo più dettagliato.
### Configura Amazon EKS per l'accesso allo scraper con voci di accesso
L'utilizzo delle voci di accesso per Amazon EKS è il modo più semplice per consentire ad Amazon Managed Service for Prometheus di accedere alle metriche del cluster.
Il cluster Amazon EKS di cui stai effettuando lo scraping deve essere configurato per consentire l'autenticazione tramite API. La modalità di autenticazione del cluster deve essere impostata su `API` o`API_AND_CONFIG_MAP`. È visualizzabile nella console Amazon EKS nella scheda di **configurazione dell'accesso** dei dettagli del cluster. Per ulteriori informazioni, consulta [Consentire ai ruoli o agli utenti IAM di accedere all'oggetto Kubernetes sul tuo cluster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html) nella Guida per l'utente di *Amazon EKS*.
Puoi creare lo scraper durante la creazione del cluster o dopo averlo creato:
+ **Quando crei un cluster**: puoi configurare questo accesso quando [crei un cluster Amazon EKS tramite la console Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) (segui le istruzioni per creare uno scraper come parte del cluster) e verrà creata automaticamente una politica di accesso che consente ad Amazon Managed Service for Prometheus di accedere ai parametri del cluster.
+ **Aggiunta dopo la creazione di un cluster: se il cluster Amazon EKS esiste già, imposta la modalità di autenticazione su `API` o `API_AND_CONFIG_MAP` e tutti gli scraper creati** [tramite l'API o la CLI di Amazon Managed Service for Prometheus](#AMP-collector-create) o tramite la console Amazon EKS avranno automaticamente la politica di accesso corretta creata per te e gli scraper avranno accesso al tuo cluster.
**Politica di accesso creata**
Quando crei uno scraper e lasci che Amazon Managed Service for Prometheus generi una politica di accesso per te, genera la seguente politica. Per ulteriori informazioni sulle voci di accesso, consulta [Consentire ai ruoli o agli utenti IAM di accedere a Kubernetes](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html) nella *Amazon EKS* User Guide.
```
{
"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"
]
}
]
}
```
### Configurazione manuale di Amazon EKS per l'accesso allo scraper
Se preferisci utilizzare l'opzione per controllare l'accesso `aws-auth ConfigMap` al tuo cluster Kubernetes, puoi comunque consentire agli scraper di Amazon Managed Service for Prometheus di accedere alle tue metriche. I seguenti passaggi consentiranno ad Amazon Managed Service for Prometheus di accedere alle metriche di scrape dal tuo cluster Amazon EKS.
**Nota**
Per ulteriori informazioni `ConfigMap` e per accedere alle voci, consulta [Consentire ai ruoli o agli utenti IAM di accedere a Kubernetes](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html) nella *Amazon EKS* User Guide.
Questa procedura utilizza `kubectl` e la AWS CLI. Per informazioni sull'installazione di `kubectl`, consulta [Installazione di kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) nella *Guida per l'utente di Amazon EKS*.
**Per configurare manualmente il cluster Amazon EKS per lo scraping dei parametri gestito**
1. Crea un file denominato `clusterrole-binding.yml` con il testo seguente:
```
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. Esegui il comando seguente nel tuo cluster.
```
kubectl apply -f clusterrole-binding.yml
```
Ciò creerà l'associazione e la regola del ruolo del cluster. Questo esempio utilizza `aps-collector-role` come nome del ruolo e `aps-collector-user` come nome utente.
1. Il comando seguente fornisce informazioni sullo scraper con l'ID. *scraper-id* Questo è lo scraper creato utilizzando il comando nella sezione precedente.
```
aws amp describe-scraper --scraper-id scraper-id
```
1. Dai risultati di `describe-scraper`, trova il file `roleArn`, che avrà il seguente formato:
```
arn:aws:iam::account-id:role/aws-service-role/scraper.aps.amazonaws.com/AWSServiceRoleForAmazonPrometheusScraper_unique-id
```
Amazon EKS richiede un formato diverso per questo ARN. È necessario modificare il formato dell'ARN restituito da utilizzare nel passaggio successivo. Modificalo in modo che corrisponda a questo formato:
```
arn:aws:iam::account-id:role/AWSServiceRoleForAmazonPrometheusScraper_unique-id
```
Per esempio, questo ARN:
```
arn:aws:iam::111122223333:role/aws-service-role/scraper.aps.amazonaws.com/AWSServiceRoleForAmazonPrometheusScraper_1234abcd-56ef-7
```
Deve essere riscritto come:
```
arn:aws:iam::111122223333:role/AWSServiceRoleForAmazonPrometheusScraper_1234abcd-56ef-7
```
1. Esegui il comando seguente nel cluster, utilizzando `roleArn` modificato dal passaggio precedente, oltre al nome e alla regione del cluster.
```
eksctl create iamidentitymapping --cluster cluster-name --region region-id --arn roleArn --username aps-collector-user
```
Ciò consente allo scraper di accedere al cluster utilizzando il ruolo e l'utente creati nel `clusterrole-binding.yml` file.
## Trova ed elimina gli scraper
Puoi utilizzare l' AWS API o AWS CLI per elencare o eliminare gli scraper presenti nel tuo account.
**Nota**
Assicurati di utilizzare la versione più recente di AWS CLI o SDK. La versione più recente offre le caratteristiche e le funzionalità più recenti, oltre agli aggiornamenti di sicurezza. In alternativa, usa [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), che fornisce sempre un'esperienza a riga di up-to-date comando, automaticamente.
Per elencare tutti gli scraper del tuo account, usa l’operazione API [ListScrapers](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_ListScrapers.html).
In alternativa, con AWS CLI, chiama:
```
aws amp list-scrapers --region aws-region
```
`ListScrapers` restituisce tutti gli scraper del tuo account, ad esempio:
```
{
"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"
}
}
}
]
}
```
Per eliminare uno scraper, trova `scraperId` relativo allo scraper che desideri eliminare, utilizzando l'operazione `ListScrapers`, quindi usa l'operazione [DeleteScraper](https://docs.aws.amazon.com/prometheus/latest/APIReference/API_DeleteScraper.html) per eliminarlo.
In alternativa, con AWS CLI, chiama:
```
aws amp delete-scraper --scraper-id scraperId
```
## Configurazione dello scraper
Puoi controllare il modo in cui il tuo scraper rileva e raccoglie i parametri con una configurazione dello scraper compatibile con Prometheus. Ad esempio, puoi modificare l'intervallo di invio dei parametri all'area di lavoro. Puoi anche utilizzare la rietichettatura per riscrivere dinamicamente le etichette di un parametro. La configurazione dello scraper è un file YAML che fa parte della definizione dello scraper.
Quando viene creato un nuovo scraper, si specifica una configurazione fornendo un file YAML con codifica base64 nella chiamata API. Puoi scaricare un file di configurazione generico con l'`GetDefaultScraperConfiguration`operazione nell'API del servizio gestito da Amazon per Prometheus.
Per modificare la configurazione di uno scraper, è possibile utilizzare l'`UpdateScraper`operazione. Se devi aggiornare l'origine delle metriche (ad esempio, su un cluster Amazon EKS diverso), devi eliminare lo scraper e ricrearlo con la nuova fonte.
**Configurazione supportata**
Per informazioni sul formato di configurazione dello scraper, inclusa una suddivisione dettagliata dei valori possibili, vedere [Configurazione](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) nella documentazione di Prometheus. Le opzioni e le opzioni di configurazione globali descrivono le `` opzioni più comunemente necessarie.
Poiché Amazon EKS è l'unico servizio supportato, l'unico servizio di discovery config (`<*_sd_config>`) supportato è il``.
L'elenco completo delle sezioni di configurazione consentite:
+ ``
+ ``
+ ``
+ ``
+ ``
+ ``
Le limitazioni all'interno di queste sezioni sono elencate dopo il file di configurazione di esempio.
**Esempio di configurazione di un file**
Di seguito è riportato un esempio di file di configurazione YAML con un intervallo di scraping di 30 secondi. Questo esempio include il supporto per le metriche del server dell'API kube kube-controller-manager e per le metriche kube-scheduler. *Per ulteriori informazioni, consulta [Fetch control plane raw metrics in formato Prometheus nella Amazon EKS User Guide](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
```
Di seguito sono riportate le limitazioni specifiche dei raccoglitori gestiti: AWS
+ **Intervallo di scrape**: la configurazione dello scraper non può specificare un intervallo inferiore a 30 secondi.
+ **Destinazioni**: le destinazioni in `static_config` devono essere specificate come indirizzi IP.
+ **Risoluzione DNS**: in relazione al nome di destinazione, l'unico nome di server riconosciuto in questa configurazione è il server API Kubernetes,. `kubernetes.default.svc` Tutti i nomi delle altre macchine devono essere specificati in base all'indirizzo IP.
+ **Autorizzazione**: ometti se non è necessaria alcuna autorizzazione. Se è necessaria, l'autorizzazione deve essere `Bearer` e deve puntare al file`/var/run/secrets/kubernetes.io/serviceaccount/token`. In altre parole, se utilizzata, la sezione di autorizzazione deve avere il seguente aspetto:
```
authorization:
type: Bearer
credentials_file: /var/run/secrets/kubernetes.io/serviceaccount/token
```
**Nota**
`type: Bearer`è l'impostazione predefinita, quindi può essere omessa.
## Risoluzione degli errori di configurazione dello scrape
I raccoglitori del servizio gestito da Amazon per Prometheus rilevano e raccolgono automaticamente i parametri. Ma come puoi risolvere i problemi quando non vedi un parametro che ti aspetti di vedere nella tua area di lavoro del servizio gestito da Amazon per Prometheus?
**Importante**
Verifica che l'accesso privato per il tuo cluster Amazon EKS sia abilitato. Per ulteriori informazioni, consulta [Cluster private Endpoint](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html#cluster-endpoint-private) nella *Amazon EKS User Guide*.
Il `up` parametro è uno strumento utile. Per ogni endpoint rilevato da un raccoglitore del servizio gestito da Amazon per Prometheus, questo parametro viene automaticamente modificato. Esistono tre stati di questo parametro che possono aiutarti a risolvere ciò che accade all'interno del raccoglitore.
+ `up` non è presente: se non è presente alcun `up` parametro per un endpoint, significa che il raccoglitore non è riuscito a trovare l'endpoint.
Se sei sicuro che l'endpoint esista, ci sono diversi motivi per cui il raccoglitore potrebbe non riuscire a trovarlo.
+ Potrebbe essere necessario modificare la configurazione dello scrape. `relabel_config`Potrebbe essere necessario modificare la scoperta.
+ Potrebbe esserci un problema con `role` Used for Discovery.
+ L'Amazon VPC utilizzato dal cluster Amazon EKS potrebbe non avere il [DNS abilitato](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html), il che impedirebbe al raccoglitore di trovare l'endpoint.
+ `up` è presente, ma è sempre 0: se `up` è presente ma è 0, il raccoglitore è in grado di scoprire l'endpoint, ma non riesce a trovare alcun parametro compatibile con Prometheus.
In questo caso, si può provare a utilizzare un `curl` comando direttamente sull'endpoint. Puoi verificare che i dettagli siano corretti, ad esempio il protocollo (`http`o`https`), l'endpoint o la porta che stai utilizzando. Puoi anche verificare che l'endpoint risponda con una `200` risposta valida e segua il formato Prometheus. Infine, il corpo della risposta non può essere più grande della dimensione massima consentita. (Per i limiti relativi ai raccoglitori AWS gestiti, consultate la sezione seguente).
+ `up` è presente e maggiore di 0: se `up` è presente ed è maggiore di 0, i parametri vengono inviati al servizio gestito da Amazon per Prometheus.
Verifica che stai cercando i parametri corretti nel servizio gestito da Amazon per Prometheus (o nella tua dashboard alternativa, come Grafana gestito da Amazon). Puoi utilizzare nuovamente curl per verificare i dati previsti nel tuo endpoint `/metrics`. Verifica anche di non aver superato altri limiti, come il numero di endpoint per scraper. Puoi controllare il numero di endpoint delle metriche che vengono analizzate controllando il conteggio delle `up` metriche, utilizzando. `count(up)`
## Limitazioni dello scraper
Esistono alcune limitazioni agli scraper completamente gestiti forniti da Amazon Managed Service per Prometheus.
+ **Regione**: il cluster EKS, lo scraper gestito e l'area di lavoro del servizio gestito da Amazon per Prometheus devono trovarsi tutti nella stessa AWS regione.
+ **Raccoglitori**: puoi avere un massimo di 10 scraper il servizio gestito da Amazon per Prometheus per regione per account.
**Nota**
Puoi richiedere un aumento di questo limite [richiedendo un aumento della quota](https://console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase).
+ **Risposta ai parametri**: il corpo di una risposta da una richiesta di `/metrics` endpoint non può superare i 50 megabyte (MB).
+ **Endpoint per scraper**: uno scraper può eseguire lo scraper per un massimo di 30.000 `/metrics` endpoint.
+ **Intervallo di scrape**: la configurazione dello scraper non può specificare un intervallo inferiore a 30 secondi.