Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Ausführliche Anleitung zu Autodiscovery auf Amazon-ECS-Clustern Prometheus bietet Dutzende dynamischer Service-Discovery-Mechanismen, wie in [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) beschrieben. Es gibt jedoch keine integrierte Service-Erkennung für Amazon ECS. Der CloudWatch Agent fügt diesen Mechanismus hinzu. Wenn die Amazon ECS Prometheus Service Discovery aktiviert ist, führt der CloudWatch Agent regelmäßig die folgenden API-Aufrufe an Amazon ECS- und Amazon EC2 EC2-Frontends durch, um die Metadaten der laufenden ECS-Aufgaben im ECS-Zielcluster abzurufen. ``` EC2:DescribeInstances ECS:ListTasks ECS:ListServices ECS:DescribeContainerInstances ECS:DescribeServices ECS:DescribeTasks ECS:DescribeTaskDefinition ``` Die Metadaten werden vom CloudWatch Agenten verwendet, um die Prometheus-Ziele innerhalb des ECS-Clusters zu scannen. Der CloudWatch Agent unterstützt drei Diensterkennungsmodi: + Container-Docker-Label-basierte Service-Erkennung + ECS-Aufgabendefinition, ARN basierte Service-Discovery mit regulären Ausdrücken + ECS-Servicename, reguläre Ausdrucks-basierte Service-Erkennung Alle Modi können zusammen verwendet werden. CloudWatch Der Agent dedupliziert die erkannten Ziele auf der Grundlage von:. `{private_ip}:{port}/{metrics_path}` Alle erkannten Ziele werden in eine Ergebnisdatei geschrieben, die durch das `sd_result_file` Konfigurationsfeld im CloudWatch Agentencontainer angegeben wird. Das Folgende ist eine Beispielergebnisdatei: ``` - 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 ``` Sie können diese Ergebnisdatei direkt in die dateibasierte Service-Erkennung von Prometheus integrieren. Weitere Informationen zur dateibasierten Serviceerkennung von Prometheus finden Sie unter [](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#file_sd_config) Angenommen, die Ergebnisdatei wird in `/tmp/cwagent_ecs_auto_sd.yaml` geschrieben. Die folgende Prometheus-Scrape-Konfiguration verbraucht sie. ``` 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" ] ``` Der CloudWatch Agent fügt außerdem die folgenden zusätzlichen Bezeichnungen für die erkannten Ziele hinzu. + `container_name` + `TaskDefinitionFamily` + `TaskRevision` + `TaskGroup` + `StartedBy` + `LaunchType` + `job` + `__metrics_path__` + Docker-Bezeichnungen Wenn der Cluster den Starttyp EC2 hat, werden die folgenden drei Bezeichnungen hinzugefügt. + `InstanceType` + `VpcId` + `SubnetId` **Anmerkung** Docker-Bezeichnungen, die nicht dem regulären Ausdruck `[a-zA-Z_][a-zA-Z0-9_]*` entsprechen, werden herausgefiltert. Dies stimmt mit den Prometheus-Konventionen überein, die unter `label_name` in der [Konfigurationsdatei](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#labelname) in der Prometheus-Dokumentation aufgeführt sind. ## Beispiele für die ECS-Serviceerkennung Dieser Abschnitt enthält Beispiele, die die Ermittlung von ECS-Services veranschaulichen. **Beispiel 1** ``` "ecs_service_discovery": { "sd_frequency": "1m", "sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml", "docker_label": { } } ``` In diesem Beispiel wird die Docker-Bezeichnungs-basierte Service-Discovery aktiviert. Der CloudWatch Agent fragt die Metadaten der ECS-Aufgaben einmal pro Minute ab und schreibt die erkannten Ziele in die `/tmp/cwagent_ecs_auto_sd.yaml` Datei im CloudWatch Agentencontainer. Der Standardwert von `sd_port_label` im `docker_label`-Abschnitt ist `ECS_PROMETHEUS_EXPORTER_PORT`. Wenn ein laufender Container in den ECS-Aufgaben ein `ECS_PROMETHEUS_EXPORTER_PORT` Docker-Label hat, verwendet der CloudWatch Agent seinen Wert, `container port` um alle exponierten Ports des Containers zu scannen. Bei Übereinstimmung werden der zugeordnete Host-Port plus die private IP des Containers verwendet, um das Prometheus-Exporterziel im folgenden Format zu erstellen: `private_ip:host_port`. Der Standardwert von `sd_metrics_path_label` im `docker_label`-Abschnitt ist `ECS_PROMETHEUS_METRICS_PATH`. Wenn der Container diese Docker-Bezeichnung hat, wird sein Wert als `__metrics_path__` verwendet. Wenn der Container diese Bezeichnung nicht hat, wird der Standardwert `/metrics` verwendet. Der Standardwert von `sd_job_name_label` im `docker_label`-Abschnitt ist `job`. Wenn der Container über diese Docker-Bezeichnung verfügt, wird sein Wert als eine der Beschriftungen für das Ziel angehängt, um den in der Prometheus-Konfiguration angegebenen Standardauftragsnamen zu ersetzen. Der Wert dieses Docker-Labels wird als Log-Stream-Name in der CloudWatch Log-Protokollgruppe verwendet. **Beispiel 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" } } ``` In diesem Beispiel wird die Docker-Bezeichnungs-basierte Service-Discovery aktiviert. Der CloudWatch Agent fragt alle 15 Sekunden die Metadaten der ECS-Aufgaben ab und schreibt die erkannten Ziele in die `/tmp/cwagent_ecs_auto_sd.yaml` Datei im CloudWatch Agentencontainer. Die Container mit einer Docker-Bezeichnung von `ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A` werden gescannt. Der Wert der Docker-Bezeichnung `ECS_PROMETHEUS_JOB_NAME` wird als Auftragsname verwendet. **Beispiel 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" } ] } ``` In diesem Beispiel wird die auf regulären Ausdrücken basierende Serviceerkennung des ECS-Aufgabendefinitions-ARN aktiviert. Der CloudWatch Agent fragt die Metadaten der ECS-Aufgaben alle fünf Minuten ab und schreibt die erkannten Ziele in die `/tmp/cwagent_ecs_auto_sd.yaml` Datei im CloudWatch Agentencontainer. Es werden zwei reguläre ARN Expresionsabschnitte für Aufgabendefinition definiert: + Für den ersten Abschnitt werden die ECS-Aufgaben mit `javajmx` in ihrem ECS-Aufgabendefinitions-ARN für den Container-Port-Scan gefiltert. Wenn die Container innerhalb dieser ECS-Aufgaben den Container-Port auf 9404 oder 9406 verfügbar machen, werden der zugeordnete Host-Port zusammen mit der privaten IP-Adresse des Containers zum Erstellen der Prometheus-Exportziele verwendet. Der Wert von `sd_metrics_path` setzt `__metrics_path__` auf `/metrics`. Der CloudWatch Agent scrapt also die Prometheus-Metriken aus`private_ip:host_port/metrics`, die gescrapten Metriken werden an den Log-Stream unter CloudWatch Logs in der `java-prometheus` Log-Gruppe gesendet. `/aws/ecs/containerinsights/cluster_name/prometheus` + Für den zweiten Abschnitt werden die ECS-Aufgaben mit `appmesh` in ihrem ECS-Aufgabendefinitions-ARN und mit `:23` von `version` für den Container-Port-Scan gefiltert. Für Container mit dem Namen `envoy` legen Sie den Container-Port auf `9901` offen. Der zugeordnete Host-Port wird zusammen mit der privaten IP des Containers verwendet, um die Prometheus-Exporterziele zu erstellen. Der Wert innerhalb dieser ECS-Aufgaben stellt den Container-Port auf 9404 oder 9406 zur Verfügung, der zugeordnete Host-Port zusammen mit der privaten IP des Containers werden verwendet, um die Prometheus-Exportziele zu erstellen. Der Wert von `sd_metrics_path` setzt `__metrics_path__` auf `/stats/prometheus`. Der CloudWatch Agent scrapt also die Prometheus-Metriken aus `private_ip:host_port/stats/prometheus` und sendet die gescrapten Metriken an den Log-Stream unter `envoy-prometheus` CloudWatch Logs in der Log-Gruppe. `/aws/ecs/containerinsights/cluster_name/prometheus` **Beispiel 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.*" } ] } ``` In diesem Beispiel wird die auf regulären Ausdrücken basierende Serviceerkennung für ECS-Servicenamen aktiviert. Der CloudWatch Agent fragt alle fünf Minuten die Metadaten der ECS-Services ab und schreibt die erkannten Ziele in die `/tmp/cwagent_ecs_auto_sd.yaml` Datei im Agentencontainer. CloudWatch Es werden zwei reguläre Expresionsabschnitte des Servicenamens definiert: + Im ersten Abschnitt werden die ECS-Aufgaben, die ECS-Services zugeordnet sind, deren Namen mit dem regulären Ausdruck `^nginx-.*` übereinstimmen, für den Container-Port-Scan gefiltert Wenn die Container innerhalb dieser ECS-Aufgaben den Container-Port auf 9113 verfügbar machen, werden der zugeordnete Host-Port zusammen mit der privaten IP-Adresse des Containers zum Erstellen der Prometheus-Exportziele verwendet. Der Wert von `sd_metrics_path` setzt `__metrics_path__` auf `/metrics`. Der CloudWatch Agent scrapt also die Prometheus-Metriken aus`private_ip:host_port/metrics`, und die gescrapten Metriken werden an den `nginx-prometheus` Protokollstream unter CloudWatch Logs in der Protokollgruppe gesendet. `/aws/ecs/containerinsights/cluster_name/prometheus` + Im zweiten Abschnitt werden die ECS-Aufgaben, die ECS-Services zugeordnet sind, deren Namen mit dem regulären Ausdruck `.*haproxy-service.*` übereinstimmen, für den Container-Port-Scan gefiltert Für Container mit dem Namen `haproxy` legen Sie den Container-Port auf 8404 offen. Der zugeordnete Host-Port wird zusammen mit der privaten IP des Containers verwendet, um die Prometheus-Exporterziele zu erstellen. Der Wert von `sd_metrics_path` setzt `__metrics_path__` auf `/stats/metrics`. Der CloudWatch Agent scrapt also die Prometheus-Metriken aus`private_ip:host_port/stats/metrics`, und die gescrapten Metriken werden an den `haproxy-prometheus` Protokollstream unter CloudWatch Logs in der Protokollgruppe gesendet. `/aws/ecs/containerinsights/cluster_name/prometheus` **Beispiel 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 diesem Beispiel werden beide ECS-Service-Ermittlungsmodi aktiviert. Der CloudWatch Agent fragt alle 90 Sekunden die Metadaten der ECS-Aufgaben ab und schreibt die erkannten Ziele in die `/tmp/cwagent_ecs_auto_sd.yaml` Datei im Agentencontainer. CloudWatch Für die Docker-basierte Service-Discovery-Konfiguration: + Die ECS-Aufgaben mit Docker-Bezeichnugn `MY_PROMETHEUS_EXPORTER_PORT_LABEL` werden für den Prometheus-Port-Scan gefiltert. Der Ziel-Prometheus-Container-Port wird durch den Wert der Bezeichnung `MY_PROMETHEUS_EXPORTER_PORT_LABEL` angegeben. + Der Wert der Docker-Bezeichnung `MY_PROMETHEUS_EXPORTER_PORT_LABEL` wird für `__metrics_path__` verwendet. Wenn der Container diese Docker-Bezeichnung nicht hat, wird der Standardwert `/metrics` verwendet. + Der Wert der Docker-Bezeichnung `MY_PROMETHEUS_EXPORTER_PORT_LABEL` wird als Auftragsbezeichnung verwendet. Wenn der Container nicht über diese Docker-Bezeichnung verfügt, wird der in der Prometheus-Konfiguration definierte Auftragsname verwendet. Für die ECS-Aufgabendefinition ARN-basierte Serviceerkennungskonfiguration: + Die ECS-Aufgaben mit `memcached` im ARN der ECS-Aufgabendefinition werden für den Container-Port-Scan gefiltert. Der Ziel-Container-Port von Prometheus ist 9150, wie durch `sd_metrics_ports` definiert. Der Standard-Metrikpfad `/metrics`wird verwendet. Der Auftragsname, der in der Prometheus-Konfiguration definiert ist, wird verwendet.