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à. # Usare AWS Distro OpenTelemetry come collezionista Questa sezione descrive come configurare AWS Distro for OpenTelemetry (ADOT) Collector per eseguire lo scraping da un'applicazione basata su Prometheus e inviare i parametri ad Amazon Managed Service for Prometheus. Per ulteriori informazioni [su AWS OpenTelemetry ADOT](https://aws.amazon.com/otel/) Collector, consulta Distro for. I seguenti argomenti descrivono tre modi diversi per configurare ADOT come raccoglitore per i tuoi parametri, a seconda che i parametri provengano da Amazon EKS, Amazon ECS o un'istanza Amazon EC2. **Topics** + [Configura l'inserimento dei parametri utilizzando AWS Distro for OpenTelemetry su un cluster Amazon Elastic Kubernetes Service](AMP-onboard-ingest-metrics-OpenTelemetry.md) + [Configura l'inserimento dei parametri da Amazon ECS utilizzando AWS Distro for Open Telemetry](AMP-onboard-ingest-metrics-OpenTelemetry-ECS.md) + [Configura l'inserimento di parametri da un'istanza Amazon EC2 utilizzando la scrittura remota](AMP-onboard-ingest-metrics-remote-write-EC2.md) # Configura l'inserimento dei parametri utilizzando AWS Distro for OpenTelemetry su un cluster Amazon Elastic Kubernetes Service Puoi utilizzare il raccoglitore AWS Distro 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](https://aws.amazon.com/otel/) ADOT, consulta Distro for. OpenTelemetry Per ulteriori informazioni sulle applicazioni con strumentazione Prometheus, vedere. [Quali sono i parametri compatibili con Prometheus?](prom-compatible-metrics.md) 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](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) 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](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html). Il raccoglitore rileva automaticamente gli endpoint delle parametri Prometheus su Amazon EKS e utilizza la configurazione disponibile in [.](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#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](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html) 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'`/metrics`endpoint, 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** 1. Crea il ruolo IAM per l'account del servizio seguendo i passaggi riportati in [Configura i ruoli di servizio per l'acquisizione di parametri dai cluster Amazon EKS.](set-up-irsa.md#set-up-irsa-ingest). ADOT Collector utilizzerà questo ruolo per acquisire ed esportare i parametri. 1. Successivamente, modifica la policy di fiducia. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/home). 1. Nel riquadro di navigazione a sinistra, scegli **Ruoli** e trova **amp-iamproxy-ingest-role**quello che hai creato nel passaggio 1. 1. Seleziona la scheda **Relazioni di attendibilità** e scegli **Modifica relazione di attendibilità**. 1. 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. ------ #### [ 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. Scegli la scheda **Autorizzazioni** e assicurati che al ruolo sia associata la seguente policy di autorizzazioni. ------ #### [ JSON ] **** ``` { "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** 1. Fork e clona l'app di esempio dal repository all'indirizzo. [aws-otel-community](https://github.com/aws-observability/aws-otel-community) Quindi, eseguire i seguenti comandi. ``` cd ./sample-apps/prometheus-sample-app docker build . -t prometheus-sample-app:latest ``` 1. Invia questa immagine a un registro come Amazon ECR o DockerHub. 1. 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 ``` 1. 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 ``` 1. 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\$1write** 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\$1write** 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. 1. Inserisci il comando seguente per distribuire il raccoglitore ADOT. ``` kubectl apply -f prometheus-daemonset.yaml ``` 1. Esegui il comando seguente per verificare che ADOT Collector sia stato avviato. Cerca `adot-col` nella colonna `NAMESPACE`. ``` kubectl get pods -n adot-col ``` 1. 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 ``` 1. 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`](https://github.com/okigan/awscurl) Nel comando seguente`AMP_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](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) 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. \$1Questo è particolarmente importante per il valore sostitutivo di relabel\$1configurations. Ad esempio, se inizi con la seguente relabel\$1configuration: ``` 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 per Go](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html). È 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 per Go credenziali e autenticarsi. Devi assicurarti che queste credenziali dispongano delle autorizzazioni di scrittura remota per il servizio gestito da Amazon per Prometheus. # Configura l'inserimento dei parametri da Amazon ECS utilizzando AWS Distro for Open Telemetry Questa sezione spiega come raccogliere metriche da Amazon Elastic Container Service (Amazon ECS) e inserirle in Amazon Managed Service for Prometheus utilizzando Distro for Open Telemetry (ADOT). AWS Descrive anche come visualizzare i tuoi parametri in Grafana gestito da Amazon. ## Prerequisiti **Importante** Prima di iniziare, devi disporre di un ambiente Amazon ECS su un AWS Fargate cluster con impostazioni predefinite, un'area di lavoro del servizio gestito da Amazon per Prometheus e un'area di lavoro Grafana gestito da Amazon. Partiamo dal presupposto che tu abbia familiarità con i carichi di lavoro dei container, il servizio gestito da Amazon per Prometheus e Grafana gestito da Amazon. Per ulteriori informazioni, consulta i collegamenti seguenti: + Per informazioni su come creare un ambiente Amazon ECS su un cluster Fargate con impostazioni predefinite, consulta [Creazione di un cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html) nella *Guida per lo sviluppatore Amazon ECS*. + Per informazioni su come creare un'area di lavoro del servizio gestito da Amazon per Prometheus, consulta [Creazione di un'area di lavoro](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-create-workspace.html) nella *Guida per l'utente del servizio gestito da Amazon per Prometheus*. + Per informazioni su come creare un'area di lavoro Grafana gestito da Amazon, consulta [Creazione di un'area di lavoro](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-create-workspace.html) nella *Guida per l'utente di Grafana gestito da Amazon*. ## Fase 1: definire un'immagine personalizzata del contenitore ADOT Collector Utilizza il seguente file di configurazione come modello per definire la tua immagine del conteiner ADOT Collector. Sostituisci *my-remote-URL* e *my-region* con i tuoi valori`endpoint`. `region` Salva la configurazione in un file denominato *adot-config.yaml*. **Nota** Questa configurazione utilizza l'`sigv4auth`estensione per autenticare le chiamate al servizio gestito da Amazon per Prometheus. Per ulteriori informazioni sulla configurazione`sigv4auth`, consulta [Authenticator -](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/sigv4authextension) Sigv4 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] ``` ## Fase 2: invia l'immagine del contenitore ADOT Collector a un repository Amazon ECR Usa un Dockerfile per creare e inviare l'immagine del container a un repository Amazon Elastic Container Registry (ECR). 1. Crea il Dockerfile per copiare e aggiungere l'immagine del conteiner all'immagine Docker di OTEL. ``` 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. Crea un repository Amazon ECR. ``` # create repo: COLLECTOR_REPOSITORY=$(aws ecr create-repository --repository aws-otel-collector \ --query repository.repositoryUri --output text) ``` 1. Crea la tua immagine di container. ``` # build ADOT collector image: docker build -t $COLLECTOR_REPOSITORY:ecs . ``` **Nota** Ciò presuppone che tu stia costruendo il tuo conteiner nello stesso ambiente in cui verrà eseguito. In caso contrario, potrebbe essere necessario utilizzare il `--platform` parametro durante la creazione dell'immagine. 1. Accedi al repository Amazon ECR. Sostituisci con il tuo valore*my-region*. `region` ``` # sign in to repo: aws ecr get-login-password --region my-region | \ docker login --username AWS --password-stdin $COLLECTOR_REPOSITORY ``` 1. Invia l'immagine del conteiner. ``` # push ADOT collector image: docker push $COLLECTOR_REPOSITORY:ecs ``` ## Passaggio 3: creare una definizione di attività Amazon ECS per eseguire lo scraping di Amazon Managed Service for Prometheus Crea una definizione di attività Amazon ECS per eseguire l'importazione del servizio gestito da Amazon per Prometheus. La definizione dell'attività deve includere un conteiner denominato `adot-collector` e un conteiner denominato`prometheus`. `prometheus` genera parametri e `adot-collector` scrape `prometheus`. **Nota** Il servizio gestito da Amazon per Prometheus funziona come servizio, raccogliendo parametri dai container. I conteiner in questo caso eseguono Prometheus localmente, in modalità Agente, che invia i parametri locali al servizio gestito da Amazon per Prometheus. **Esempio: definizione di attività** Di seguito è riportato un esempio di come potrebbe presentarsi la definizione dell'attività. È possibile utilizzare questo esempio come modello per creare la propria definizione di attività. Sostituisci il `image` valore di `adot-collector` con l'URL del repository e il tag dell'immagine (`$COLLECTOR_REPOSITORY:ecs`). Sostituisci i valori di `region` di `adot-collector` e `prometheus` con i tuoi valori `region`. ``` { "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" } ``` ## Passaggio 4: autorizza la tua attività ad accedere ad Amazon Managed Service for Prometheus Per inviare i parametri eliminati ad Amazon Managed Service for Prometheus, la tua attività Amazon ECS deve disporre delle autorizzazioni corrette per chiamare le operazioni API per te. AWS Devi creare un ruolo IAM e una policy `AmazonPrometheusRemoteWriteAccess` per le tue attività. Per ulteriori informazioni sulla creazione di un ruolo per i processi, consulta [Creazione di un ruolo e una policy IAM per le attività ](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html#create_task_iam_policy_and_role). Dopo esserti collegato `AmazonPrometheusRemoteWriteAccess` al tuo ruolo IAM e aver utilizzato quel ruolo per le tue attività, Amazon ECS può inviare i tuoi parametri eliminati al servizio gestito da Amazon per Prometheus. ## Fase 5: visualizza le tue metriche in Amazon Managed Grafana **Importante** Prima di iniziare, devi eseguire un processo Fargate nella definizione dell'attività Amazon ECS. Altrimenti, il servizio gestito da Amazon per Prometheus non può utilizzare i tuoi parametri. 1. Dal pannello di navigazione del tuo spazio di lavoro Amazon Managed Grafana, scegli **Origini dati** sotto l'icona. AWS 1. Nella scheda **Origini dati**, per **Servizio**, seleziona **Servizio gestito da Amazon per Prometheus** e scegli la tua **regione predefinita**. 1. Scegli **Aggiungi origine dati**. 1. Usa i prefissi `ecs` e `prometheus` per interrogare e visualizzare i tuoi parametri. # Configura l'inserimento di parametri da un'istanza Amazon EC2 utilizzando la scrittura remota Questa sezione spiega come eseguire un server Prometheus con scrittura remota in un'istanza Amazon Elastic Compute Cloud (Amazon EC2). Spiega come raccogliere parametri da un'applicazione demo scritta in Go e inviarle a un'area di lavoro del servizio gestito da Amazon per Prometheus. ## Prerequisiti **Importante** Prima di iniziare, è necessario aver installato Prometheus v2.26 o una versione successiva. Partiamo dal presupposto che tu conosca Prometheus, Amazon EC2 e il servizio gestito da Amazon per Prometheus. Per informazioni su come installare Prometheus, vedi [Guida introduttiva](https://prometheus.io/docs/prometheus/latest/getting_started/) sul sito web di Prometheus. Se non conosci Amazon EC2 o il servizio gestito da Amazon per Prometheus, ti consigliamo di iniziare leggendo le sezioni seguenti: + [Cos'è Amazon Elastic Compute Cloud?](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) + [Cos'è il servizio gestito da Amazon per Prometheus?](https://docs.aws.amazon.com/prometheus/latest/userguide/what-is-Amazon-Managed-Service-Prometheus.html) ## Creazione di un ruolo IAM per Amazon EC2 Per eseguire lo streaming delle metriche, devi prima creare un ruolo IAM con la AWS policy gestita. **AmazonPrometheusRemoteWriteAccess** Quindi, puoi avviare un'istanza con il ruolo e i parametri di streaming nella tua area di lavoro del servizio gestito da Amazon per Prometheus. 1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Nel riquadro di navigazione selezionare **Roles (Ruoli)**, quindi **Create role (Crea ruolo)**. 1. Per il tipo di entità attendibile, scegliere **AWS service (Servizio)**. Per il caso d'uso, scegli **EC2**. Scegli **Successivo: autorizzazioni**. 1. Nella barra di ricerca inserisci **AmazonPrometheusRemoteWriteAccess**. Per **Nome della policy**, seleziona **AmazonPrometheusRemoteWriteAccess**, quindi scegli **Allega policy**. Scegli **Successivo: Tag**. 1. (Facoltativo) Crea tag IAM per il tuo ruolo IAM. Scegli **Prossimo: Rivedi**. 1. Immetti un nome per il ruolo. Scegli **Crea policy**. ## Avviare un'istanza Amazon EC2 Per avviare un'istanza Amazon EC2, segui le istruzioni riportate in [Avvio di un'istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role) nella *Guida per l'utente di Amazon Elastic Compute Cloud per le istanze Linux*. ## Esegui l'applicazione demo Dopo aver creato il tuo ruolo IAM e avviato un'istanza EC2 con il ruolo, puoi eseguire un'applicazione demo per vederlo funzionare. **Per eseguire un'applicazione demo e testare le metriche** 1. Utilizza il seguente modello per creare un file Go denominato `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. Esegui il comando riportato qui di seguito per installare la dipendenza. ``` sudo yum update -y sudo yum install -y golang go get github.com/prometheus/client_golang/prometheus/promhttp ``` 1. Esegui l'applicazione demo. ``` go run main.go ``` L'applicazione demo dovrebbe funzionare sulla porta 8000 e mostrare tutti i parametri di Prometheus esposte. Di seguito è riportato un esempio di questi parametri. ``` 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 ``` ## Creazione di un'area di lavoro del servizio gestito da Amazon per Prometheus. Per creare un'area di lavoro del servizio gestito da Amazon per Prometheus, segui le istruzioni in [Creazione di un'area di lavoro.](AMP-create-workspace.md) ## Esegui un server Prometheus 1. Utilizza il seguente file YAML di esempio come modello per creare un nuovo file denominato `prometheus.yaml`. Infatti`url`, sostituiscilo *my-region* con il valore della tua regione e *my-workspace-id* con l'ID dell'area di lavoro che Amazon Managed Service for Prometheus ha generato per te. Per`region`, sostituiscilo *my-region* con il valore della tua regione. **Esempio: file YAML** ``` 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. Esegui il server Prometheus per inviare i parametri dell'applicazione demo alla tua area di lavoro del servizio gestito da Amazon per Prometheus. ``` prometheus --config.file=prometheus.yaml ``` Il server Prometheus dovrebbe ora inviare i parametri dell'applicazione demo alla tua area di lavoro del servizio gestito da Amazon per Prometheus.