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à. # Guida dettagliata per l'individuazione automatica dei cluster Amazon ECS Prometheus offre dozzine di meccanismi dinamici di individuazione dei servizi, come descritto in [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config). Tuttavia, non esiste un rilevamento dei servizi integrato per Amazon ECS. L' CloudWatch agente aggiunge questo meccanismo. Quando il rilevamento del servizio Amazon ECS Prometheus è abilitato, l'agente effettua periodicamente CloudWatch le seguenti chiamate API ai frontend Amazon ECS e Amazon EC2 per recuperare i metadati delle attività ECS in esecuzione nel cluster ECS di destinazione. ``` EC2:DescribeInstances ECS:ListTasks ECS:ListServices ECS:DescribeContainerInstances ECS:DescribeServices ECS:DescribeTasks ECS:DescribeTaskDefinition ``` I metadati vengono utilizzati dall' CloudWatch agente per scansionare i target Prometheus all'interno del cluster ECS. L' CloudWatch agente supporta tre modalità di rilevamento dei servizi: + Individuazione del servizio basata sull'etichetta Docker del container + Individuazione del servizio basata su espressioni regolari dell'ARN della definizione dell'attività ECS + Individuazione del servizio basato su espressioni regolari del nome del servizio ECS Tutte le modalità possono essere utilizzate insieme. CloudWatch l'agente deduplica gli obiettivi rilevati in base a:. `{private_ip}:{port}/{metrics_path}` Tutte le destinazioni rilevate vengono scritte in un file di risultati specificato dal campo di `sd_result_file` configurazione all'interno del contenitore dell' CloudWatch agente. Di seguito è riportato un file di esempio: ``` - targets: - 10.6.1.95:32785 labels: __metrics_path__: /metrics ECS_PROMETHEUS_EXPORTER_PORT: "9406" ECS_PROMETHEUS_JOB_NAME: demo-jar-ec2-bridge-dynamic ECS_PROMETHEUS_METRICS_PATH: /metrics InstanceType: t3.medium LaunchType: EC2 SubnetId: subnet-123456789012 TaskDefinitionFamily: demo-jar-ec2-bridge-dynamic-port TaskGroup: family:demo-jar-ec2-bridge-dynamic-port TaskRevision: "7" VpcId: vpc-01234567890 container_name: demo-jar-ec2-bridge-dynamic-port job: demo-jar-ec2-bridge-dynamic - targets: - 10.6.3.193:9404 labels: __metrics_path__: /metrics ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_B: "9404" ECS_PROMETHEUS_JOB_NAME: demo-tomcat-ec2-bridge-mapped-port ECS_PROMETHEUS_METRICS_PATH: /metrics InstanceType: t3.medium LaunchType: EC2 SubnetId: subnet-123456789012 TaskDefinitionFamily: demo-tomcat-ec2-bridge-mapped-port TaskGroup: family:demo-jar-tomcat-bridge-mapped-port TaskRevision: "12" VpcId: vpc-01234567890 container_name: demo-tomcat-ec2-bridge-mapped-port job: demo-tomcat-ec2-bridge-mapped-port ``` Puoi integrare direttamente questo file di risultati con l'individuazione dei servizi basata su file Prometheus. Per ulteriori informazioni sull'individuazione dei servizi basata su file Prometheus, consulta [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#file_sd_config). Supponiamo che il file dei risultati sia scritto su `/tmp/cwagent_ecs_auto_sd.yaml`. La seguente configurazione di scraping Prometheus lo consumerà. ``` global: scrape_interval: 1m scrape_timeout: 10s scrape_configs: - job_name: cwagent-ecs-file-sd-config sample_limit: 10000 file_sd_configs: - files: [ "/tmp/cwagent_ecs_auto_sd.yaml" ] ``` L' CloudWatch agente aggiunge anche le seguenti etichette aggiuntive per le destinazioni scoperte. + `container_name` + `TaskDefinitionFamily` + `TaskRevision` + `TaskGroup` + `StartedBy` + `LaunchType` + `job` + `__metrics_path__` + Etichette Docker Quando il cluster ha il tipo di avvio EC2, vengono aggiunte le seguenti tre etichette. + `InstanceType` + `VpcId` + `SubnetId` **Nota** Le etichette Docker che non corrispondono all'espressione regolare `[a-zA-Z_][a-zA-Z0-9_]*` vengono filtrate. Questo corrisponde alle convenzioni Prometheus elencate in `label_name` in [Configuration file](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#labelname) (File di configurazione) nella documentazione di Prometheus. ## Esempi di configurazione dell'individuazione dei servizi ECS In questa sezione sono inclusi esempi che illustrano l'individuazione dei servizi ECS. **Esempio 1** ``` "ecs_service_discovery": { "sd_frequency": "1m", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "docker_label": { } } ``` Questo esempio abilita l'individuazione dei servizi basata su etichette Docker. L' CloudWatch agente interrogherà i metadati delle attività ECS una volta al minuto e scriverà le destinazioni rilevate nel `/tmp/cwagent_ecs_auto_sd.yaml` file all'interno del contenitore dell'agente. CloudWatch Il valore predefinito di `sd_port_label` nella sezione `docker_label` è `ECS_PROMETHEUS_EXPORTER_PORT`. Se un contenitore in esecuzione nelle attività ECS ha un'etichetta `ECS_PROMETHEUS_EXPORTER_PORT` docker, CloudWatch l'agente utilizza il suo valore `container port` per scansionare tutte le porte esposte del contenitore. Se esiste una corrispondenza, la porta host mappata più l'IP privato del container vengono utilizzati per costruire la destinazione dell'esportatore Prometheus nel seguente formato: `private_ip:host_port`. Il valore predefinito di `sd_metrics_path_label` nella sezione `docker_label` è `ECS_PROMETHEUS_METRICS_PATH`. Se il container ha questa etichetta Docker, il suo valore verrà utilizzato come `__metrics_path__`. Se il container non ha questa etichetta, viene utilizzato il valore predefinito `/metrics`. Il valore predefinito di `sd_job_name_label` nella sezione `docker_label` è `job`. Se il container ha questa etichetta Docker, il suo valore verrà aggiunto come una delle etichette per la destinazione per sostituire il nome del processo predefinito specificato nella configurazione Prometheus. Il valore di questa etichetta docker viene utilizzato come nome del flusso di log nel gruppo CloudWatch Logs log. **Esempio 2** ``` "ecs_service_discovery": { "sd_frequency": "15s", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "docker_label": { "sd_port_label": "ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A", "sd_job_name_label": "ECS_PROMETHEUS_JOB_NAME" } } ``` Questo esempio abilita l'individuazione dei servizi basati su etichette docker. THe CloudWatch l'agente interrogherà i metadati delle attività ECS ogni 15 secondi e scriverà le destinazioni rilevate nel file all'interno del contenitore dell'agente. `/tmp/cwagent_ecs_auto_sd.yaml` CloudWatch I container con un'etichetta Docker di `ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A` verranno scansionati. Il valore dell'etichetta Docker `ECS_PROMETHEUS_JOB_NAME` viene usato come nome del processo. **Esempio 3** ``` "ecs_service_discovery": { "sd_frequency": "5m", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "task_definition_list": [ { "sd_job_name": "java-prometheus", "sd_metrics_path": "/metrics", "sd_metrics_ports": "9404; 9406", "sd_task_definition_arn_pattern": ".*:task-definition/.*javajmx.*:[0-9]+" }, { "sd_job_name": "envoy-prometheus", "sd_metrics_path": "/stats/prometheus", "sd_container_name_pattern": "^envoy$", "sd_metrics_ports": "9901", "sd_task_definition_arn_pattern": ".*:task-definition/.*appmesh.*:23" } ] } ``` Questo esempio abilita l'individuazione del servizio basata su espressioni regolari dell'ARN della definizione dell'attività ECS. L' CloudWatch agente interrogherà i metadati delle attività ECS ogni cinque minuti e scriverà le destinazioni rilevate nel file all'interno del contenitore dell'agente. `/tmp/cwagent_ecs_auto_sd.yaml` CloudWatch Sono definite due sezioni di espressione regolare dell'ARN di definizione dell'attività: + Per la prima sezione, le attività ECS con `javajmx` nel loro ARN di definizione dell'attività ECS vengono filtrati per la scansione della porta del container. Se i contenitori all'interno di queste attività ECS espongono la porta del container su 9404 o 9406, la porta host mappata insieme all'IP privato del container vengono utilizzati per creare le destinazioni dell'esportatore Prometheus. Il valore di `sd_metrics_path` è impostato da `__metrics_path__` a `/metrics`. Quindi l' CloudWatch agente estrarrà le metriche di Prometheus, le metriche eliminate verranno inviate al flusso `private_ip:host_port/metrics` di log in Logs nel gruppo di `java-prometheus` log. CloudWatch `/aws/ecs/containerinsights/cluster_name/prometheus` + Per la seconda sezione, le attività ECS con `appmesh` nel loro ARN di definizione dell'attività ECS e con `version` di `:23` vengono filtrati per la scansione della porta del container. Per i contenitori con il nome `envoy` che espongono la porta del container su `9901`, la porta host mappata insieme all'IP privato del container vengono utilizzati per creare i target dell'esportatore Prometheus. Il valore all'interno di queste attività ECS espongono la porta del container su 9404 o 9406, la porta host mappata insieme all'IP privato del container vengono utilizzati per creare le destinazioni dell'esportatore Prometheus. Il valore di `sd_metrics_path` è impostato da `__metrics_path__` a `/stats/prometheus`. Quindi l' CloudWatch agente raccoglierà le metriche di Prometheus e le invierà al `private_ip:host_port/stats/prometheus` flusso di log in Logs nel gruppo di `envoy-prometheus` log. CloudWatch `/aws/ecs/containerinsights/cluster_name/prometheus` **Esempio 4** ``` "ecs_service_discovery": { "sd_frequency": "5m", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "service_name_list_for_tasks": [ { "sd_job_name": "nginx-prometheus", "sd_metrics_path": "/metrics", "sd_metrics_ports": "9113", "sd_service_name_pattern": "^nginx-.*" }, { "sd_job_name": "haproxy-prometheus", "sd_metrics_path": "/stats/metrics", "sd_container_name_pattern": "^haproxy$", "sd_metrics_ports": "8404", "sd_service_name_pattern": ".*haproxy-service.*" } ] } ``` Questo esempio abilita l'individuazione del servizio basata su espressioni regolari del nome del servizio ECS. L' CloudWatch agente interrogherà i metadati dei servizi ECS ogni cinque minuti e scriverà le destinazioni rilevate nel file all'interno del contenitore dell'agente. `/tmp/cwagent_ecs_auto_sd.yaml` CloudWatch Sono definite due sezioni di espressioni regolari del nome del servizio: + Per la prima sezione, le attività ECS associate ai servizi ECS con nomi corrispondenti all'espressione regolare `^nginx-.*` vengono filtrati per la scansione della porta del container. Se i contenitori all'interno di queste attività ECS espongono la porta del container su 9113, la porta host mappata insieme all'IP privato del container vengono utilizzati per creare le destinazioni dell'esportatore Prometheus. Il valore di `sd_metrics_path` è impostato da `__metrics_path__` a `/metrics`. Quindi l' CloudWatch agente estrarrà le metriche di Prometheus e le metriche eliminate `private_ip:host_port/metrics` verranno inviate al flusso di log in Logs nel gruppo di `nginx-prometheus` log. CloudWatch `/aws/ecs/containerinsights/cluster_name/prometheus` + o per la seconda sezione, le attività ECS associate ai servizi ECS con nomi corrispondenti all'espressione regolare `.*haproxy-service.*` vengono filtrati per la scansione della porta del container. Per i contenitori con il nome `haproxy` che espongono la porta del container su 8404, la porta host mappata insieme all'IP privato del container vengono utilizzati per creare i target dell'esportatore Prometheus. Il valore di `sd_metrics_path` è impostato da `__metrics_path__` a `/stats/metrics`. Quindi l' CloudWatchagente estrarrà le metriche di Prometheus e le metriche eliminate `private_ip:host_port/stats/metrics` verranno inviate al flusso di log in Logs nel gruppo di `haproxy-prometheus` log. CloudWatch `/aws/ecs/containerinsights/cluster_name/prometheus` **Esempio 5** ``` "ecs_service_discovery": { "sd_frequency": "1m30s", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "docker_label": { "sd_port_label": "MY_PROMETHEUS_EXPORTER_PORT_LABEL", "sd_metrics_path_label": "MY_PROMETHEUS_METRICS_PATH_LABEL", "sd_job_name_label": "MY_PROMETHEUS_METRICS_NAME_LABEL" } "task_definition_list": [ { "sd_metrics_ports": "9150", "sd_task_definition_arn_pattern": "*memcached.*" } ] } ``` In questo esempio vengono abilitate entrambe le modalità di individuazione dei servizi ECS. L' CloudWatch agente interrogherà i metadati delle attività ECS ogni 90 secondi e scriverà le destinazioni rilevate nel file all'interno del contenitore dell'agente. `/tmp/cwagent_ecs_auto_sd.yaml` CloudWatch Per la configurazione dell'individuazione del servizio basata su Docker: + Le attività ECS con etichetta Docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` verranno filtrate per la scansione della porta Prometheus. La porta del container Prometheus di destinazione è specificata dal valore dell'etichetta `MY_PROMETHEUS_EXPORTER_PORT_LABEL`. + Il valore dell'etichetta Docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` viene utilizzato per `__metrics_path__`. Se il container non ha questa etichetta Docker, viene utilizzato il valore predefinito `/metrics`. + Il valore dell'etichetta Docker `MY_PROMETHEUS_EXPORTER_PORT_LABEL` viene usato come etichetta del processo. Se il container non dispone di questa etichetta Docker, viene utilizzato il nome del processo definito nella configurazione Prometheus. Per la configurazione dell'individuazione del servizio basata su espressioni regolari dell'ARN della definizione dell'attività ECS: + Le attività ECS con `memcached` nell'ARN di definizione dell'attività ECS vengono filtrati per la scansione della porta del container. La porta del container Prometheus di destinazione è 9150 come definito da `sd_metrics_ports`. Viene utilizzato il percorso dei parametri predefinito `/metrics`. Viene utilizzato il nome del processo definito nella configurazione Prometheus.