Prerequisiti Abilitazione della raccolta di parametri Prometheus Configurazione avanzata

Configura l'inserimento dei parametri utilizzando AWS Distro for OpenTelemetry su un cluster Amazon Elastic Kubernetes Service

Puoi utilizzare il collettore AWS Distor for OpenTelemetry (ADOT) per acquisire metriche da un'applicazione basata su Prometheus e inviarle ad Amazon Managed Service for Prometheus.

Nota

Per ulteriori informazioni sul AWS collettore ADOT, consulta Distro for. OpenTelemetry

Per ulteriori informazioni sulle applicazioni con strumentazione Prometheus, vedere. Quali sono i parametri compatibili con Prometheus?

La raccolta delle metriche di Prometheus con ADOT coinvolge OpenTelemetry tre componenti: il Prometheus Receiver, il Prometheus Remote Write Exporter e l'estensione di autenticazione Sigv4.

È possibile configurare il ricevitore Prometheus utilizzando la configurazione Prometheus esistente per eseguire il rilevamento dei servizi e lo scraping metrico. Il ricevitore Prometheus analizza i parametri nel formato di esposizione Prometheus. Tutte le applicazioni o gli endpoint che si desidera eseguire lo scraping devono essere configurati con la libreria client Prometheus. Il ricevitore Prometheus supporta il set completo di configurazioni di scraping e re-etichettatura di Prometheus descritte in Configurazione nella documentazione di Prometheus. È possibile incollare queste configurazioni direttamente nelle configurazioni di ADOT Collector.

Prometheus Remote Write Exporter utilizza l'endpoint per inviare i parametri eliminate remote_write all'area di lavoro del portale di gestione. Le richieste HTTP per esportare i dati verranno firmate con SigV4, il protocollo per l'autenticazione sicura, con l'estensione di autenticazione Sigv4 AWS . AWS Per ulteriori informazioni, consulta Processo di firma di Signature versione 4.

Il raccoglitore rileva automaticamente gli endpoint delle parametri Prometheus su Amazon EKS e utilizza la configurazione disponibile in <kubernetes_sd_config>.

La seguente demo è un esempio di questa configurazione su un cluster che esegue Amazon Elastic Kubernetes Service o Kubernetes autogestito. Per eseguire questi passaggi, è necessario disporre AWS delle credenziali di una qualsiasi delle possibili opzioni nella catena di credenziali predefinita. AWS Per ulteriori informazioni, consulta Configurazione dell' AWS SDK for Go. Questa demo utilizza un'app di esempio utilizzata per i test di integrazione del processo. L'app di esempio espone i parametri sull'/metricsendpoint, come la libreria client Prometheus.

Prerequisiti

Prima di iniziare i seguenti passaggi di configurazione dell'importazione, devi configurare il tuo ruolo IAM per l'account del servizio e la policy di fiducia.

Per configurare il ruolo IAM per l'account del servizio e la policy di fiducia

Crea il ruolo IAM per l'account del servizio seguendo i passaggi riportati in Configura i ruoli di servizio per l'acquisizione di metriche dai cluster Amazon EKS..

ADOT Collector utilizzerà questo ruolo per acquisire ed esportare i parametri.
Successivamente, modifica la policy di fiducia. Aprire la console IAM all'indirizzo https://console.aws.amazon.com/iam/.
Nel riquadro di navigazione a sinistra, scegli Ruoli e trova amp-iamproxy-ingest-rolequello che hai creato nel passaggio 1.
Seleziona la scheda Relazioni di attendibilità e scegli Modifica relazione di attendibilità.

Nella policy di relazione di fiducia JSON, sostituisci aws-amp con adot-col e quindi scegli Aggiorna policy di fiducia. Il risultato della policy di fiducia sarà simile al seguente.


{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::account-id:oidc-provider/oidc.eks.region.amazonaws.com/id/openid"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "oidc.eks.region.amazonaws.com/id/openid:sub": "system:serviceaccount:adot-col:amp-iamproxy-ingest-service-account"
        }
      }
    }
  ]
}

Scegli la scheda Autorizzazioni e assicurati che al ruolo sia associata la seguente policy di autorizzazioni.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "aps:RemoteWrite",
                "aps:GetSeries",
                "aps:GetLabels",
                "aps:GetMetricMetadata"
            ],
            "Resource": "*"
        }
    ]
}

Abilitazione della raccolta di parametri Prometheus

Nota

Quando crei uno spazio dei nomi in Amazon EKS, alertmanager e i nodi Exporter sono disabilitati per impostazione predefinita.

Per abilitare la raccolta Prometheus su un cluster Amazon EKS o Kubernetes

Fork e clona l'app di esempio dal repository all'indirizzo. aws-otel-community

Quindi, eseguire i seguenti comandi.
```
cd ./sample-apps/prometheus-sample-app
docker build . -t prometheus-sample-app:latest
```
Invia questa immagine a un registro come Amazon ECR o DockerHub.
Distribuisci l'app di esempio nel cluster copiando questa configurazione di Kubernetes e applicandola. Cambia l'immagine con quella che hai appena inserito sostituendo {{PUBLIC_SAMPLE_APP_IMAGE}} nel file prometheus-sample-app.yaml.
```
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
```
Esegui il comando seguente per verificare che l'app di prova sia stata avviata. Nell'output del comando, vedrai prometheus-sample-app nella NAME colonna.
```
kubectl get all -n aoc-prometheus-pipeline-demo
```
Avvia un'istanza predefinita di ADOT Collector. Per fare ciò, inserisci prima il seguente comando per estrarre la configurazione di Kubernetes per ADOT Collector.
```
curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-daemonset.yaml -o prometheus-daemonset.yaml
```
Quindi modifica il file modello, sostituendo l'endpoint remote_write con la tua area di lavoro del servizio gestito da Amazon per Prometheus per YOUR_ENDPOINT e la tua regione per YOUR_REGION. Usa l'endpoint remote_write visualizzato nella console del servizio gestito da Amazon per Prometheus quando esamini i dettagli della tua area di lavoro.

Dovrai inoltre modificare l'ID del tuo account YOUR_ACCOUNT_ID nella sezione relativa all'account di servizio della configurazione di Kubernetes. AWS

In questo esempio, la configurazione ADOT Collector utilizza un'annotation (scrape=true) per indicare quali endpoint di destinazione eseguire lo scraping. Ciò consente a ADOT Collector di distinguere l'endpoint dell'app di esempio dagli endpoint del sistema kube nel cluster. Puoi rimuoverlo dalle configurazioni di rietichettatura se desideri eliminare un'altra app di esempio.
Inserisci il comando seguente per distribuire il raccoglitore ADOT.
```
kubectl apply -f prometheus-daemonset.yaml
```
Esegui il comando seguente per verificare che ADOT Collector sia stato avviato. Cerca adot-col nella colonna NAMESPACE.
```
kubectl get pods -n adot-col
```

Verifica che la pipeline funzioni utilizzando il logging exporter. Il nostro modello di esempio è già integrato con il logging exporter. Esegui i comandi seguenti:


kubectl get pods -A
kubectl logs -n adot-col name_of_your_adot_collector_pod

Alcune dei parametri estratte dall'app di esempio saranno simili all'esempio seguente.


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

Per verificare se il servizio gestito da Amazon per Prometheus ha ricevuto i parametri, usa awscurl. Questo strumento ti consente di inviare richieste HTTP tramite la riga di comando con l'autenticazione AWS Sigv4, quindi devi avere AWS le credenziali configurate localmente con le autorizzazioni corrette per eseguire query da Amazon Managed Service for Prometheus. Per istruzioni sull'installazione, consulta awscurl. awscurl

Nel comando seguenteAMP_REGION, sostituisci e AMP_ENDPOINT con le informazioni per la tua area di lavoro del servizio gestito da Amazon per 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"]}]}}
```
Se ricevi un parametro come risposta, significa che la configurazione della pipeline è stata completata correttamente e il parametro è stato propagato con successo dall'app di esempio al servizio gestito da Amazon per Prometheus.

Pulizia

Per ripulire questa demo, inserisci i seguenti comandi.


kubectl delete namespace aoc-prometheus-pipeline-demo
kubectl delete namespace adot-col

Configurazione avanzata

Il ricevitore Prometheus supporta il set completo di configurazioni di scraping e re-etichettatura di Prometheus descritte in Configurazione nella documentazione di Prometheus. È possibile incollare queste configurazioni direttamente nelle configurazioni di ADOT Collector.

La configurazione per il ricevitore Prometheus include il rilevamento dei servizi, le configurazioni di scraping e le configurazioni di rietichettatura. La configurazione del ricevitore è simile alla seguente.


receivers:
  prometheus:
    config:
      [[Your Prometheus configuration]]

Di seguito è riportato un esempio di configurazione.


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

Se disponi di una configurazione Prometheus esistente, devi sostituire i caratteri $ con$$ per evitare che i valori vengano sostituiti con variabili di ambiente. *Questo è particolarmente importante per il valore sostitutivo di relabel_configurations. Ad esempio, se inizi con la seguente relabel_configuration:


relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
  regex: (.+);(.+);(.+)
  replacement: ${1}://${2}${3}
  target_label: __param_target

Diventerebbe il seguente:


relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
  regex: (.+);(.+);(.+)
  replacement: $${1}://${2}${3}
  target_label: __param_target

Esportatore di scrittura remota Prometheus ed estensione di autenticazione Sigv4

La configurazione for Prometheus Remote Write Exporter e Sigv4 Authentication Extension è più semplice del ricevitore Prometheus. In questa fase della pipeline, i parametri sono già stati inseriti e siamo pronti per esportare questi dati nel servizio gestito da Amazon per Prometheus. Il requisito minimo per una corretta configurazione per comunicare con il servizio gestito da Amazon per Prometheus è illustrato nell'esempio seguente.


extensions:
  sigv4auth:
    service: "aps"
    region: "user-region"
exporters:
  prometheusremotewrite:
    endpoint: "https://aws-managed-prometheus-endpoint/api/v1/remote_write"
    auth:
      authenticator: "sigv4auth"

Questa configurazione invia una richiesta HTTPS firmata da SigV4 utilizzando le credenziali della catena di credenziali predefinita AWS . AWS AWS Per ulteriori informazioni, consultare la pagina relativa alla configurazione di AWS SDK for Go. È necessario specificare il servizio come aps.

Indipendentemente dal metodo di distribuzione, il raccoglitore ADOT deve avere accesso a una delle opzioni elencate nella catena di credenziali predefinita. AWS L'estensione di autenticazione Sigv4 dipende da e la utilizza per recuperare le AWS SDK for Go credenziali e autenticarsi. Devi assicurarti che queste credenziali dispongano delle autorizzazioni di scrittura remota per il servizio gestito da Amazon per Prometheus.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

ADOT Collectors

Importa da Amazon ECS