

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.

# CloudWatch Lösung: Kafka-Workload auf Amazon EC2
<a name="Solution-Kafka-On-EC2"></a>

Diese Lösung hilft Ihnen bei der Konfiguration der out-of-the-box Metrikerfassung mithilfe von CloudWatch Agenten für Kafka-Workloads (Broker, Produzenten und Verbraucher), die auf EC2-Instances ausgeführt werden. Darüber hinaus hilft sie Ihnen bei der Einrichtung eines vorkonfigurierten Dashboards. CloudWatch Allgemeine Informationen zu allen CloudWatch Observability-Lösungen finden Sie unter. [CloudWatch Observability-Lösungen](Monitoring-Solutions.md)

**Topics**
+ [Voraussetzungen](#Solution-Kafka-On-EC2-Requirements)
+ [Vorteile](#Solution-Kafka-On-EC2-Benefits)
+ [Kosten](#Solution-Kafka-On-EC2-Costs)
+ [CloudWatch Agentenkonfiguration für diese Lösung](#Solution-Kafka-CloudWatch-Agent)
+ [Bereitstellung des Agenten für Ihre Lösung](#Solution-Kafka-Agent-Deploy)
+ [Erstellen des Kafka-Lösungs-Dashboards](#Solution-Kafka-Dashboard)
+ [Konfigurieren Sie den Agenten für mehrere Kafka-Rollen auf derselben Instance](#Kafka-Multiple-Roles)

## Voraussetzungen
<a name="Solution-Kafka-On-EC2-Requirements"></a>

Diese Lösung ist für folgende Bedingungen relevant:
+ Workload: Kafka v0.8.2.x und höher
+ Computing: Amazon EC2
+ Unterstützt bis zu 500 EC2-Instances für alle Kafka-Workloads in einem bestimmten AWS-Region
+ Aktuelle Version des Agenten CloudWatch 
+ Der SSM-Agent ist auf der EC2-Instance installiert
**Anmerkung**  
AWS Systems Manager (SSM-Agent) ist auf einigen [Amazon Machine Images (AMIs)](https://docs.aws.amazon.com/systems-manager/latest/userguide/ami-preinstalled-agent.html) vorinstalliert, die von vertrauenswürdigen Drittanbietern AWS bereitgestellt werden. Wenn der Agent nicht installiert ist, können Sie ihn manuell installieren, indem Sie das Verfahren für Ihren Betriebssystemtyp verwenden.  
[Manuelle Installation und Deinstallation des SSM-Agenten auf EC2-Instances für Linux](https://docs.aws.amazon.com/systems-manager/latest/userguide/manually-install-ssm-agent-linux.html)
[Manuelle Installation und Deinstallation des SSM-Agenten auf EC2-Instances für macOS](https://docs.aws.amazon.com/systems-manager/latest/userguide/manually-install-ssm-agent-macos.html)
[Manuelle Installation und Deinstallation des SSM-Agenten auf EC2-Instances für Windows Server](https://docs.aws.amazon.com/systems-manager/latest/userguide/manually-install-ssm-agent-windows.html)

## Vorteile
<a name="Solution-Kafka-On-EC2-Benefits"></a>

Die Lösung bietet Kafka-Server-Überwachung und wertvolle Erkenntnisse für die folgenden Anwendungsfälle:
+ Überwachen Sie den Zustand des Kafka-Clusters mithilfe von Replikations- und Synchronisationsmetriken.
+ Verfolgen Sie die Leistung des Brokers anhand von Anforderungsausfällen und Latenzen sowie dem Netzwerkdatenverkehr nach.
+ Überwachen Sie producer/consumer Fehler, Latenzen und Kundenverzögerungen.
+ Analysieren Sie die zugrunde liegende JVM-Leistung für Kafka-Cluster.
+ Wechseln Sie zwischen mehreren Kafka-Clustern, Produzenten und Verbrauchern, die mit der Lösung unter demselben Konto konfiguriert wurden.

Im Folgenden sind die Hauptvorteile der Lösung aufgeführt:
+ Automatisiert die Erfassung von Metriken für Kafka und die zugrunde liegende JVM mithilfe der CloudWatch Agentenkonfiguration, wodurch die manuelle Instrumentierung entfällt.
+ Bietet ein vorkonfiguriertes, konsolidiertes CloudWatch Dashboard für Kafka- und JVM-Metriken. Das Dashboard verarbeitet automatisch Metriken von neuen Kafka-EC2-Instances, die mit der Lösung konfiguriert wurden, auch wenn diese Metriken bei der ersten Erstellung des Dashboards noch nicht vorhanden waren. Außerdem können Sie die Metriken zum einfacheren Fokussieren und Verwalten in logische Anwendungen gruppieren.

Die nachfolgende Abbildung ist ein Beispiel eines Dashboards dieser Lösung.

![\[Kafka Cluster dashboard showing metrics for partitions, producer/consumer performance, and broker status.\]](http://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/monitoring/images/KafkaDashboard.png)


## Kosten
<a name="Solution-Kafka-On-EC2-Costs"></a>

Diese Lösung erstellt und nutzt Ressourcen in Ihrem Konto. Ihnen wird die Standardnutzung berechnet, einschließlich der folgenden Kosten:
+ Alle vom CloudWatch Agenten gesammelten Metriken werden als benutzerdefinierte Metriken berechnet. Die Zahl der von dieser Lösung zu erfassenden Metriken hängt von der Anzahl der EC2-Hosts ab.
  + Jeder für die Lösung konfigurierte Broker-Host veröffentlicht insgesamt 33 Metriken plus eine Metrik (`disk_used_percent`), wobei die Anzahl der Metriken für jeden EC2-Host von der Anzahl der Datenträgerpfade für den Host abhängt.
  + Jeder für die Lösung konfigurierte Produzenten-Host veröffentlicht drei Metriken mit der `topic`-Dimension und drei Metriken ohne die `topic`-Dimension. Bei den Metriken mit der `topic`-Dimension zählt jedes Thema als separate Metrik.
  + Jeder für die Lösung konfigurierte Verbraucher-Host veröffentlicht zwei Metriken mit den `topic`-Dimensionen und drei Metriken ohne die `topic`-Dimensionen. Bei den Metriken mit der Themendimension zählt jedes Thema als separate Metrik.
+ Ein benutzerdefiniertes Dashboard.
+ API-Operationen, die vom CloudWatch Agenten zur Veröffentlichung der Metriken angefordert wurden. Bei der Standardkonfiguration für diese Lösung ruft der CloudWatch Agent die **PutMetricData**einmal pro Minute für jeden EC2-Host auf. Das bedeutet, dass die **PutMetricData**API innerhalb eines 30-Tage-Monats für jeden EC2-Host aufgerufen `30*24*60=43,200` wird.

Weitere Informationen zur CloudWatch Preisgestaltung finden Sie unter [ CloudWatch Amazon-Preise](https://aws.amazon.com/cloudwatch/pricing/).

Mithilfe des Preisrechners können Sie die ungefähren monatlichen Kosten für die Nutzung dieser Lösung abschätzen. 

**Um den Preisrechner zur Schätzung Ihrer monatlichen Kosten für die Lösung zu verwenden**

1. Öffnen Sie den [ CloudWatch Amazon-Preisrechner](https://calculator.aws/#/createCalculator/CloudWatch).

1. Geben Sie im Abschnitt **Metriken** für die **Anzahl der Metriken** den Wert **broker\$1metrics\$1count \$1 producer\$1metrics\$1count \$1 consumer\$1metrics\$1count** ein. Berechnen Sie diese folgendermaßen:
   + `broker_metrics_count` = (33 \$1 durchschnittliche Anzahl von Datenträgerpfaden pro EC2-Host) \$1 number\$1of\$1ec2\$1broker\$1hosts 
   + `producer_metrics_count` = (3 \$1 average\$1number\$1of\$1topics\$1per\$1producer\$1host \$1 3) \$1 number\$1of\$1ec2\$1producer\$1hosts 
   + `consumer_metrics_count` = (2 \$1 average\$1number\$1of\$1topics\$1per\$1consumer\$1host \$1 3) \$1 number\$1of\$1ec2\$1consumer\$1hosts 

1. Geben Sie im **APIs**Abschnitt **Anzahl der API-Anfragen** den Wert ein**43200 \$1 number of EC2 instances configured for this solution**.

   Standardmäßig führt der CloudWatch Agent für jeden EC2-Host eine **PutMetricData**Operation pro Minute durch.

1. Geben Sie im Abschnitt **Dashboards und Alarme** für **Anzahl der Dashboards** **1** ein.

1. Sie finden Ihre geschätzten monatlichen Kosten unten im Preisrechner.

## CloudWatch Agentenkonfiguration für diese Lösung
<a name="Solution-Kafka-CloudWatch-Agent"></a>

Der CloudWatch Agent ist eine Software, die kontinuierlich und autonom auf Ihren Servern und in containerisierten Umgebungen ausgeführt wird. Es sammelt Metriken, Logs und Traces aus Ihrer Infrastruktur und Ihren Anwendungen und sendet sie an CloudWatch X-Ray.

Weitere Informationen über den CloudWatch Agenten finden Sie unter[Erfassen Sie Metriken, Logs und Traces mithilfe des CloudWatch Agenten](Install-CloudWatch-Agent.md).

Die Agentenkonfiguration in dieser Lösung erfasst die grundlegenden Metriken für Kafka, JVM und EC2. Der CloudWatch Agent kann so konfiguriert werden, dass er standardmäßig mehr Kafka- und JVM-Metriken sammelt, als das Dashboard anzeigt. Eine Liste aller Kafka-Metriken, die Sie erfassen können, finden Sie unter [Erfassen von Kafka-Metriken](CloudWatch-Agent-JMX-metrics.md#CloudWatch-Agent-Kafka-metrics). Eine Liste aller JVM-Metriken, die Sie erfassen können, finden Sie unter [Erfassen von JVM-Metriken](CloudWatch-Agent-JMX-metrics.md#CloudWatch-Agent-JVM-metrics). Die Liste der EC2-Metriken finden Sie unter [Vom CloudWatch Agenten auf Linux- und macOS-Instances gesammelte Metriken](metrics-collected-by-CloudWatch-agent.md#linux-metrics-enabled-by-CloudWatch-agent).

**Machen Sie JMX-Ports für die Kafka-Broker-, Produzenten- und Verbraucher-Rollen verfügbar**

Der CloudWatch Agent verwendet JMX, um die Kennzahlen zu den Kafka-Brokern, Herstellern und Verbrauchern zu sammeln. Um das zu ermöglichen, müssen Sie den JMX-Port auf Ihren Servern und Anwendungen aus verfügbar machen.

Für Kafka-Broker müssen Sie mithilfe der `JMX_PORT`-Umgebungsvariable den Port festlegen. Sie müssen die Broker neu starten, nachdem Sie diese Umgebungsvariable festgelegt haben. Sehen Sie sich die Startskripts und Konfigurationsdateien Ihrer Anwendung an, um herauszufinden, wo Sie diese Argumente am besten ergänzen können.

Für Linux- und macOS-Systeme können Sie beispielsweise mithilfe des folgenden Befehls den JMX-Port festlegen. Achten Sie auf die Angabe einer ungenutzten Portnummer.

```
export JMX_PORT=port-number
```

Für Kafka-Produzenten und -Verbraucher hängen die Anweisungen zum Offenlegen des JMX-Ports vom Workload-Typ ab, den Sie für Ihre Produzenten- oder Verbraucher-JVM-Anwendung verwenden. In der Dokumentation Ihrer Anwendung finden Sie diese Anweisungen.

Um einen JMX-Port für die Überwachung und Verwaltung zu aktivieren, müssen Sie allgemein die folgenden Systemeigenschaften für Ihre JVM-Anwendung festlegen. Im folgenden Beispiel wird für nicht authentifiziertes JMX konfiguriert. Wenn Sie aus Sicherheitsgründen JMX mit Kennwortauthentifizierung oder SSL für den Fernzugriff aktivieren policies/requirements müssen, finden Sie in der [JMX-Dokumentation nach, um die erforderliche](https://docs.oracle.com/en/java/javase/17/management/monitoring-and-management-using-jmx-technology.html) Eigenschaft festzulegen.

```
-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=port-number
-Dcom.sun.management.jmxremote.authenticate=false 
-Dcom.sun.management.jmxremote.ssl=false
```

Führen Sie `ps aux | grep jmxremote.port` aus, um den JMX-Port zu überprüfen. Die Ergebnisse sollten zeigen, dass der JMX-Port für JVM-Prozesse festgelegt wurde.

**Agentenkonfiguration für diese Lösung**

Die vom Agenten zu erfassenden Metriken werden in der Agentenkonfiguration definiert. Die Lösung bietet Agenten-Konfigurationen zum Erfassen der empfohlenen Metriken mit geeigneten Dimensionen für das Dashboard der Lösung. Jede Kafka-Rolle, z. B. Broker, Produzent oder Verbraucher, verfügt über eine eigene Agentenkonfiguration, welche die Erfassung von Kafka-Metriken und den zugrunde liegenden JVM- und EC2-Metriken ermöglicht.

Die Schritte zur Bereitstellung der Lösung werden weiter unten in [Bereitstellung des Agenten für Ihre Lösung](#Solution-Kafka-Agent-Deploy) beschrieben. Die folgenden Informationen beschreiben, wie Sie die Agentenkonfiguration für Ihre Umgebung anpassen können.

Sie müssen einige Teile der folgenden Agentenkonfiguration für Ihre Umgebung anpassen:
+ Die JMX-Portnummer ist die Portnummer, die Sie im vorherigen Abschnitt dieser Dokumentation konfiguriert haben. Die Portnummer steht in der Zeile `endpoint` in der Konfiguration.
+ `ClusterName` – Dies wird als Dimension für die erfassten Broker-Metriken verwendet. Geben Sie einen aussagekräftigen Namen ein, der die Gruppierung für die Cluster darstellt, auf denen der Kafka-Broker ausgeführt wird.
+ `ProcessGroupName` – Dies wird als Dimension für die für Broker erfassten JVM-Metriken verwendet. Geben Sie den gleichen Wert an, den Sie für `ClusterName` angeben. Auf diese Weise können die JVM-Metriken derselben Kafka-Broker-Gruppe wie die Broker-Metriken im Lösungs-Dashboard dargestellt werden.
+ `ProducerGroupName` – Dies wird als Dimension für die erfassten Produzentenmetriken verwendet. Geben Sie einen aussagekräftigen Namen ein, der für die Gruppe der Produzenten-Instances steht. Für diesen Wert können Sie Ihre Produzenten-Anwendung oder Ihren Produzenten-Service angeben, den Sie für eine kombinierte Ansicht der Produzenten-Metriken im Lösungs-Dashboard verwenden möchten.
+ `ConsumerGroupName` – Dies wird als Dimension für die erfassten Verbrauchermetriken verwendet. Geben Sie einen aussagekräftigen Namen an, der die Gruppe der Verbraucher-Instances repräsentiert. Dies entspricht nicht dem Konzept der Verbrauchergruppen in Kafka. Dies ist nur eine Gruppierungsdimension, in der Sie Ihre Verbraucheranwendung oder Ihren Service angeben können, den Sie für eine kombinierte Ansicht der Verbrauchermetriken im Lösungs-Dashboard verwenden möchten 

Wenn Sie beispielsweise zwei Kafka-Cluster in demselben Konto ausführen, eine für die `order-processing`-Anwendung und eine weitere für die `inventory-management`-Anwendung, sollten Sie die `ClusterName` und `ProcessGroupName`-Dimensionen in der Agentenkonfiguration jeder Broker-Instance entsprechend festlegen.
+ Legen Sie für die `order-processing`-Cluster-Broker-Instances `ClusterName=order-processing` und `ProcessGroupName=order-processing` fest.
+ Legen Sie für die `inventory-management`-Cluster-Broker-Instances `ClusterName=inventory-management` und `ProcessGroupName=inventory-management` fest. 
+ Legen Sie in ähnlicher Weise `ProducerGroupName` für Produzenten-Instances und `ConsumerGroupName` für Verbraucher-Instances auf der Grundlage ihrer jeweiligen Anwendungen fest.

Wenn Sie die oben genannten Dimensionen korrekt festgelegt haben, gruppiert das Lösungs-Dashboard die Metriken automatisch auf der Grundlage der Dimensionen `ClusterName`, `ProducerGroupName` und `ConsumerGroupName`. Das Dashboard umfasst Drop-down-Optionen, mit denen Sie Metriken für bestimmte Cluster und Gruppen auswählen und aufrufen können, sodass sich die Leistung einzelner Cluster und Gruppen separat überwachen lässt.

Sorgen Sie dafür, dass Sie die entsprechende Agentenkonfiguration auf den richtigen EC2-Instances bereitstellen. Jede Konfiguration wird als separater Parameter im Parameterspeicher von SSM gespeichert, wie weiter unten in [Schritt 2: Speichern Sie die empfohlene CloudWatch Agentenkonfigurationsdatei im Systems Manager Parameter Store](#Solution-Kafka-Agent-Step2) beschrieben.

Die folgenden Anweisungen beschreiben die Situation, in der die Rollen Produzent, Verbraucher und Broker ohne Überschneidungen auf separaten EC2-Instances bereitgestellt werden. Wenn Sie mehrere Kafka-Rollen auf denselben EC2-Instances ausführen, finden Sie weitere Informationen unter [Konfigurieren Sie den Agenten für mehrere Kafka-Rollen auf derselben Instance](#Kafka-Multiple-Roles).

### Agentenkonfiguration für Kafka-Broker-Agenten
<a name="Solution-Kafka-Agent-Broker"></a>

Verwenden Sie die folgende CloudWatch Agentenkonfiguration für EC2-Instances, auf denen Kafka-Broker-Agenten bereitgestellt werden. *ClusterName*Ersetzen Sie ihn durch den Namen des Clusters, der zur Gruppierung dieser Metriken verwendet werden soll, um eine einheitliche Ansicht zu erhalten. Der Wert, für den Sie angeben, *ClusterName* wird sowohl als `ClusterName` Dimension als auch als `ProcessGroupName` Dimension verwendet. *port-number*Ersetzen Sie ihn durch den JMX-Port Ihres Kafka-Servers. Wenn JMX mit Kennwortauthentifizierung oder SSL für den Remotezugriff aktiviert wurde, finden Sie je nach Bedarf unter [Erfassung von Java Management Extensions (JMX)-Metriken](CloudWatch-Agent-JMX-metrics.md) weitere Informationen zur Einrichtung von TLS oder zur Autorisierung.

Die in dieser Konfiguration gezeigten EC2-Metriken (Konfiguration, die außerhalb des JMX-Blocks angezeigt wird) funktionieren nur für Linux- und macOS-Instances. Wenn Sie Windows-Instances nutzen, können Sie diese Metriken in der Konfiguration weglassen. Informationen zu Metriken, die auf Windows-Instances erfasst wurden, finden Sie unter [Vom CloudWatch Agenten auf Windows Server-Instanzen gesammelte Metriken](metrics-collected-by-CloudWatch-agent.md#windows-metrics-enabled-by-CloudWatch-agent).

```
{
  "metrics": {
    "namespace": "CWAgent",
    "append_dimensions": {
      "InstanceId": "${aws:InstanceId}"
    },
    "metrics_collected": {
      "jmx": [
        {
          "endpoint": "localhost:port-number",
          "kafka": {
            "measurement": [
              "kafka.request.time.avg",
              "kafka.request.failed",
              "kafka.request.count",
              "kafka.purgatory.size",
              "kafka.partition.under_replicated",
              "kafka.partition.offline",
              "kafka.network.io",
              "kafka.leader.election.rate",
              "kafka.isr.operation.count"
            ]
          },
          "append_dimensions": {
            "ClusterName": "ClusterName"
          }
        },
        {
          "endpoint": "localhost:port-number",
          "jvm": {
            "measurement": [
              "jvm.classes.loaded",
              "jvm.gc.collections.count",
              "jvm.gc.collections.elapsed",
              "jvm.memory.heap.committed",
              "jvm.memory.heap.max",
              "jvm.memory.heap.used",
              "jvm.memory.nonheap.committed",
              "jvm.memory.nonheap.max",
              "jvm.memory.nonheap.used",
              "jvm.threads.count"
            ]
          },
          "append_dimensions": {
            "ProcessGroupName": "ClusterName"
          }
        }
      ],
      "disk": {
        "measurement": [
          "used_percent"
        ]
      },
      "mem": {
        "measurement": [
          "used_percent"
        ]
      },
      "swap": {
        "measurement": [
          "used_percent"
        ]
      },
      "netstat": {
        "measurement": [
          "tcp_established",
          "tcp_time_wait"
        ]
      }
    }
  }
}
```

### Agentenkonfiguration für Kafka-Produzenten
<a name="Solution-Kafka-Agent-Producer"></a>

Verwenden Sie die folgende CloudWatch Agentenkonfiguration auf Amazon EC2 EC2-Instances, in denen Kafka-Produzenten eingesetzt werden. *ProducerGroupName*Ersetzen Sie es durch den Namen der Anwendung oder Gruppe, die Sie verwenden möchten, um Ihre Metriken zu gruppieren, um eine einheitliche Ansicht zu erhalten. *port-number*Ersetzen Sie es durch den JMX-Port Ihrer Kafka-Producer-Anwendung.

 Die Lösung aktiviert keine JVM-Metriken für Kafka-Produzenten, da das Lösungs-Dashboard keine JVM-Metriken im Zusammenhang mit JVM für Produzenten darstellt. Sie können die Agentenkonfiguration so anpassen, dass auch JVM-Metriken ausgegeben werden. JVM-Metriken, die sich auf Produzenten beziehen, werden jedoch im Lösungs-Dashboard nicht dargestellt.

```
{
  "metrics": {
    "namespace": "CWAgent",
    "append_dimensions": {
      "InstanceId": "${aws:InstanceId}"
    },
    "metrics_collected": {
      "jmx": [
        {
          "endpoint": "localhost:port-number",
          "kafka-producer": {
            "measurement": [
              "kafka.producer.request-rate",
              "kafka.producer.byte-rate",
              "kafka.producer.request-latency-avg",
              "kafka.producer.response-rate",
              "kafka.producer.record-error-rate",
              "kafka.producer.record-send-rate"
            ]
          },
          "append_dimensions": {
            "ProducerGroupName": "ProducerGroupName"
          }
        }
      ]
    }
  }
}
```

### Agentenkonfiguration für Kafka-Verbraucher
<a name="Solution-Kafka-Agent-Consumer"></a>

Verwenden Sie die folgende CloudWatch Agentenkonfiguration auf EC2-Instances, auf denen Kafka-Consumer ausgeführt werden. *ConsumerGroupName*Ersetzen Sie sie durch den Namen der Anwendung oder Gruppe, die zur Gruppierung dieser Metriken verwendet werden soll, um eine einheitliche Ansicht zu erhalten. *port-number*Ersetzen Sie ihn durch den JMX-Port Ihrer Kafka-Consumer-Anwendung.

Die Lösung aktiviert keine JVM-Metriken für Kafka-Verbraucher, da das Lösungs-Dashboard keine JVM-Metriken im Zusammenhang mit JVM für Verbraucher darstellt. Sie können die Agentenkonfiguration so anpassen, dass auch JVM-Metriken ausgegeben werden. JVM-Metriken, die sich auf Verbraucher beziehen, werden jedoch im Lösungs-Dashboard nicht dargestellt.

```
{
  "metrics": {
    "append_dimensions": {
      "InstanceId": "${aws:InstanceId}"
    },
    "metrics_collected": {
      "jmx": [
        {
          "endpoint": "localhost:port-number",
          "kafka-consumer": {
            "measurement": [
              "kafka.consumer.fetch-rate",
              "kafka.consumer.total.bytes-consumed-rate",
              "kafka.consumer.records-consumed-rate",
              "kafka.consumer.bytes-consumed-rate",
              "kafka.consumer.records-lag-max"
            ]
          },
          "append_dimensions": {
            "ConsumerGroupName": "ConsumerGroupName"
          }
        }
      ]
    }
  }
}
```

## Bereitstellung des Agenten für Ihre Lösung
<a name="Solution-Kafka-Agent-Deploy"></a>

Je nach Anwendungsfall gibt es mehrere Ansätze für die Installation des CloudWatch Agenten. Wir empfehlen die Nutzung von Systems Manager für diese Lösung. Es bietet eine Konsolenerfahrung und erleichtert die Verwaltung einer Flotte verwalteter Server innerhalb eines einzigen AWS Kontos. Die Anweisungen in diesem Abschnitt verwenden Systems Manager und sind für den Fall vorgesehen, dass der CloudWatch Agent nicht mit vorhandenen Konfigurationen ausgeführt wird. Sie können überprüfen, ob der CloudWatch Agent ausgeführt wird, indem Sie die Schritte unter befolgen[Stellen Sie sicher, dass der CloudWatch Agent läuft](troubleshooting-CloudWatch-Agent.md#CloudWatch-Agent-troubleshooting-verify-running).

Wenn Sie den CloudWatch Agenten bereits auf den EC2-Hosts ausführen, auf denen der Workload bereitgestellt wird, und die Agentenkonfigurationen verwalten, können Sie die Anweisungen in diesem Abschnitt überspringen und Ihren bestehenden Bereitstellungsmechanismus verwenden, um die Konfiguration zu aktualisieren. Stellen Sie sicher, dass Sie die Agentenkonfiguration gemäß der Rolle (Broker, Produzent oder Verbraucher) mit Ihrer vorhandenen Agentenkonfiguration zusammenführen und dann diese zusammengeführte Konfiguration bereitstellen. Wenn Sie Systems Manager verwenden, um die Konfiguration für den CloudWatch Agenten zu speichern und zu verwalten, können Sie die Konfiguration mit dem vorhandenen Parameterwert zusammenführen. Weitere Informationen finden Sie unter [ CloudWatch Agent-Konfigurationsdateien verwalten](https://docs.aws.amazon.com/prescriptive-guidance/latest/implementing-logging-monitoring-cloudwatch/create-store-cloudwatch-configurations.html).

**Anmerkung**  
Wenn Sie Systems Manager zur Bereitstellung der folgenden CloudWatch Agentenkonfigurationen verwenden, werden alle vorhandenen CloudWatch Agentenkonfigurationen auf Ihren EC2-Instances ersetzt oder überschrieben. Sie können diese Konfiguration an Ihre individuelle Umgebung oder Ihren jeweiligen Anwendungsfall anpassen. Die in dieser Lösung definierten Metriken sind die Mindestwerte, die für das empfohlene Dashboard erforderlich sind. 

Der Bereitstellungsprozess umfasst die folgenden Schritte:
+ Schritt 1: Stellen Sie sicher, dass die EC2-Ziel-Instances über die erforderlichen IAM-Berechtigungen verfügen.
+ Schritt 2: Speichern Sie die empfohlene Agentenkonfigurationsdatei in Systems Manager Parameter Store.
+ Schritt 3: Installieren Sie den CloudWatch Agenten mithilfe eines Stacks auf einer oder mehreren EC2-Instances. CloudFormation 
+ Schritt 4: Stellen Sie sicher, dass das Agenten-Setup richtig konfiguriert ist

Sie müssen diese Schritte je nachdem wiederholen, ob Ihr Broker, Produzent und Verbraucher auf derselben EC2-Instance oder auf verschiedenen Instances bereitgestellt werden. Wenn beispielsweise Kafka-Broker, -Produzent und -Verbraucher ohne Überschneidung auf separaten Instances bereitgestellt werden, müssen Sie diese Schritte dreimal mit den entsprechenden Agenten-Konfigurationen für Broker-, Produzent- und Verbraucher-EC2-Instances wiederholen.

### Schritt 1: Stellen Sie sicher, dass die EC2-Ziel-Instances über die erforderlichen IAM-Berechtigungen verfügen
<a name="Solution-Kafka-Agent-Step1"></a>

Sie müssen Systems Manager die Erlaubnis erteilen, den CloudWatch Agenten zu installieren und zu konfigurieren. Sie müssen dem CloudWatch Agenten auch die Erlaubnis erteilen, Telemetriedaten von Ihrer EC2-Instance an zu veröffentlichen. CloudWatch Stellen Sie sicher, dass der IAM-Rolle, die der Instance zugewiesen ist, die Amazon IAM-Richtlinien **CloudWatchAgentServerPolicy**und die **Amazon SSMManaged InstanceCore** IAM-Richtlinien angehängt sind.
+ Nachdem die Rolle erstellt wurde, weisen Sie Ihren EC2-Instances eine Rolle zu. Folgen Sie den Schritten unter [Starten einer Instance mit einer IAM-Rolle](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role), um beim Starten einer neuen EC2-Instance eine Rolle zuzuweisen. Um einer vorhandenen EC2-Instance eine Rolle zuzuweisen, folgen Sie den Schritten unter [Anfügen einer IAM-Rolle an eine Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).

### Schritt 2: Speichern Sie die empfohlene CloudWatch Agentenkonfigurationsdatei im Systems Manager Parameter Store
<a name="Solution-Kafka-Agent-Step2"></a>

Parameter Store vereinfacht die Installation des CloudWatch Agenten auf einer EC2-Instance, indem Konfigurationsparameter sicher gespeichert und verwaltet werden, sodass keine hartcodierten Werte erforderlich sind. Das gestaltet den Bereitstellungsprozess sicherer und flexibler und ermöglicht eine zentrale Verwaltung und einfachere Aktualisierungen von Konfigurationen über mehrere Instances hinweg.

Gehen Sie wie folgt vor, um die empfohlene CloudWatch Agent-Konfigurationsdatei als Parameter im Parameter Store zu speichern.

**Um die CloudWatch Agenten-Konfigurationsdatei als Parameter zu erstellen**

1. Öffnen Sie die AWS Systems Manager Konsole unter [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).

1. Wählen Sie im Navigationsbereich **Anwendungsmanagement**, **Parameter Store** aus.

1. Befolgen Sie diese Schritte, um einen neuen Parameter für die Konfiguration zu erstellen.

   1. Wählen Sie **Parameter erstellen** aus.

   1. Geben Sie einen Namen für den Parameter ein, in dem Ihre CloudWatch Agentenkonfiguration gespeichert wird, z. B. **AmazonCloudWatch-Kafka-Producer-Configuration** **AmazonCloudWatch-Kafka-Consumer-Configuration** für Produzenten, Verbraucher oder **AmazonCloudWatch-Kafka-Broker-Configuration** Makler. Wenn Sie mehrere Kafka-Rollen auf einer einzigen EC2 haben, benennen Sie die Rollen zur leichteren Identifizierung entsprechend. Dieser Wert dient später dazu, um diese Konfiguration an den Agenten zu verteilen, der auf Ihrer EC2-Instance ausgeführt wird.

   1. Wählen Sie für **Parameterstufe** die Option **Standard** aus. 

   1. Wählen Sie unter **Type** (Typ) die Option **String** (Zeichenfolge) aus.

   1. Wählen Sie als **Datentyp** die Option **Text** aus.

   1. Fügen Sie in das Feld **Wert** den vollständigen Text der CloudWatch Agentenkonfiguration ein. Achten Sie darauf, den JSON-Block für die Kafka-Rolle auszuwählen, die diese Instance hostet. Beachten Sie die unter [Agentenkonfiguration für Kafka-Broker-Agenten](#Solution-Kafka-Agent-Broker), [Agentenkonfiguration für Kafka-Produzenten](#Solution-Kafka-Agent-Producer) und [Agentenkonfiguration für Kafka-Verbraucher](#Solution-Kafka-Agent-Consumer) bereitgestellte Konfiguration, wenn Sie Broker, Produzenten und Verbraucher jeweils speichern. Wenn Sie mehrere Kafka-Rollen auf derselben EC2-Instance ausführen, sorgen Sie dafür, dass Sie die Konfiguration bei Bedarf zusammenführen, wie unter [Konfigurieren Sie den Agenten für mehrere Kafka-Rollen auf derselben Instance](#Kafka-Multiple-Roles) auf derselben Instance beschrieben

   1. Wählen Sie **Parameter erstellen** aus. 

### Schritt 3: Installieren Sie den CloudWatch Agenten und wenden Sie die Konfiguration mithilfe einer CloudFormation Vorlage an
<a name="Solution-Kafka-Agent-Step3"></a>

Sie können AWS CloudFormation damit den Agenten installieren und ihn so konfigurieren, dass er die CloudWatch Agentenkonfiguration verwendet, die Sie in den vorherigen Schritten erstellt haben.

**Um den CloudWatch Agenten für diese Lösung zu installieren und zu konfigurieren**

1. Öffnen Sie den Assistenten CloudFormation **zum schnellen Erstellen von Stacks** über diesen Link: [https://console.aws.amazon.com/cloudformation/Home? \$1/ stacks/quickcreate?templateURL=https://aws-observability-solutions-prod-us-east-1.s3.us-east-1.amazonaws.com/CloudWatchAgent/CFN/v1.0.0/cw agent-installation-template -1.0.0.json](https://console.aws.amazon.com/cloudformation/home?#/stacks/quickcreate?templateURL=https://aws-observability-solutions-prod-us-east-1.s3.us-east-1.amazonaws.com/CloudWatchAgent/CFN/v1.0.0/cw-agent-installation-template-1.0.0.json). 

1. Sorgen Sie dafür, dass die ausgewählte Region auf der Konsole die Region ist, in der die Kafka-Workload ausgeführt wird.

1. Geben Sie unter **Stack-Name** einen Namen für diesen Stack, z. B. **CWAgentInstallationStack**, ein.

1. Gehen Sie im Abschnitt **Parameter** wie folgt vor:

   1. Geben Sie für **CloudWatchAgentConfigSSM** den Namen des Systems Manager Manager-Parameters für die Agentenkonfiguration ein, die Sie zuvor erstellt haben, z. B. **AmazonCloudWatch-Kafka-Broker-Configuration** **AmazonCloudWatch-Kafka-Producer-Configuration** für Makler, Produzenten und **AmazonCloudWatch-Kafka-Consumer-Configuration** Verbraucher.

   1. Um die Ziel-Instances auszuwählen, haben Sie zwei Optionen.

      1. Geben Sie für **InstanceIds**eine durch Kommas getrennte Liste von Instanzen eine Liste der Instanzen IDs an, IDs in denen Sie den CloudWatch Agenten mit dieser Konfiguration installieren möchten. Sie können eine einzelne Instance oder mehrere Instances auflisten.

      1. Wenn Sie die Bereitstellung in großem Umfang durchführen, können Sie die **TagKey**und die entsprechende **TagValue**Option für alle EC2-Instances mit diesem Tag und Wert angeben. Wenn Sie eine angeben **TagKey**, müssen Sie eine entsprechende **TagValue**angeben. (Geben Sie für eine Auto Scaling Scaling-Gruppe **aws:autoscaling:groupName** für die **TagKey**und den Namen der Auto Scaling Scaling-Gruppe an, die **TagValue**auf allen Instances innerhalb der Auto Scaling Scaling-Gruppe bereitgestellt werden soll.)

         Wenn Sie **InstanceIds**sowohl die als auch die **TagKeys**Parameter angeben, haben die **InstanceIds**Vorrang und die Tags werden ignoriert.

1. Überprüfen Sie die Einstellungen und wählen Sie dann **Stack erstellen** aus. 

Wenn Sie die Vorlagendatei zuerst bearbeiten möchten, um sie anzupassen, wählen Sie im **Assistenten zum Erstellen von Stacks** die Option **Eine Vorlagendatei hochladen** aus, um die bearbeitete Vorlage hochzuladen. Weitere Informationen finden Sie unter [Einen Stack auf der CloudFormation Konsole erstellen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html). Sie können den folgenden Link verwenden, um die Vorlage herunterzuladen: [https://aws-observability-solutions-prod-us-east-1.s3.us-east-1.amazonaws.com/CloudWatchAgent/CFN/v1.0.0/cw- agent-installation-template -1.0.0.json](https://aws-observability-solutions-prod-us-east-1.s3.us-east-1.amazonaws.com/CloudWatchAgent/CFN/v1.0.0/cw-agent-installation-template-1.0.0.json). 

**Anmerkung**  
Nach Abschluss dieses Schritts wird dieser Systems Manager Manager-Parameter den CloudWatch Agenten zugeordnet, die in den Zielinstanzen ausgeführt werden. Dies bedeutet, dass:  
Wenn der Systems-Manager-Parameter gelöscht wird, wird der Agent gestoppt.
Wenn der Systems-Manager-Parameter bearbeitet wird, werden die Konfigurationsänderungen automatisch in der geplanten Häufigkeit, die standardmäßig 30 Tage beträgt, für den Agenten übernommen.
Wenn Sie Änderungen an diesem Systems-Manager-Parameter sofort anwenden möchten, müssen Sie diesen Schritt erneut ausführen. Weitere Informationen über Zuordnungen finden Sie unter [Arbeiten mit Zuordnungen in Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-associations.html).

### Schritt 4: Stellen Sie sicher, dass das Agenten-Setup richtig konfiguriert ist
<a name="Solution-Kafka-Agent-Step4"></a>

Sie können überprüfen, ob der CloudWatch Agent installiert ist, indem Sie die Schritte unter befolgen[Stellen Sie sicher, dass der CloudWatch Agent läuft](troubleshooting-CloudWatch-Agent.md#CloudWatch-Agent-troubleshooting-verify-running). Wenn der CloudWatch Agent nicht installiert ist und nicht ausgeführt wird, stellen Sie sicher, dass Sie alles richtig eingerichtet haben.
+ Sorgen Sie dafür, dass Sie der EC2-Instance eine Rolle mit den richtigen Berechtigungen zugewiesen haben, wie unter beschrieben [Schritt 1: Stellen Sie sicher, dass die EC2-Ziel-Instances über die erforderlichen IAM-Berechtigungen verfügen](Solution-Tomcat-On-EC2.md#Solution-Tomcat-Agent-Step1).
+ Stellen Sie sicher, dass Sie JSON für den Systems-Manager-Parameter korrekt konfiguriert haben. Führen Sie die Schritte unter [Fehlerbehebung bei der Installation des CloudWatch Agenten mit CloudFormation](Install-CloudWatch-Agent-New-Instances-CloudFormation.md#CloudWatch-Agent-CloudFormation-troubleshooting) aus.

Wenn alles korrekt eingerichtet ist, sollten Sie sehen, wie die Kafka-Metriken veröffentlicht werden. CloudWatch Sie können in der CloudWatch Konsole nachsehen, ob sie veröffentlicht wurden.

**Um zu überprüfen, ob Kafka-Metriken veröffentlicht werden CloudWatch**

1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Wählen Sie **Metriken**, **Alle Metriken** aus.

1. Stellen Sie sicher, dass Sie die Region ausgewählt haben, in der Sie die Lösung bereitgestellt haben, und wählen Sie **Benutzerdefinierte Namespaces**,. **CWAgent**

1. Suchen Sie nach den Metriken, die im Abschnitt zur Agentenkonfiguration dieses Dokuments erwähnt werden, z. B. `kafka.partition.offline` für Broker, `kafka.consumer.fetch.rate` für Verbraucher oder `kafka.producer.request-rate` für Produzenten. Wenn Sie Ergebnisse für diese Metriken sehen, werden die Metriken unter veröffentlicht. CloudWatch

## Erstellen des Kafka-Lösungs-Dashboards
<a name="Solution-Kafka-Dashboard"></a>

In diesem Dashboard werden die neu ausgegebenen Metriken sowohl für Kafka als auch für die zugrunde liegende JVM dargestellt. Dieses Dashboard bietet eine Übersicht der wichtigsten Faktoren über den Status Ihrer Kafka-Workload, unabhängig von Produzenten, Brokern und Verbrauchern. In der Ansicht der wichtigsten Faktoren wird das Top-10-pro-Metrik-Widget angezeigt. Auf diese Weise erkennen Sie Ausreißer auf einen Blick. 

Das Lösungs-Dashboard stellt keine EC2-Metriken dar. Um EC2-Metriken anzuzeigen, müssen Sie das automatische EC2-Dashboard verwenden, um die von EC2 verkauften Metriken zu sehen, und das EC2-Konsolen-Dashboard verwenden, um die vom Agenten gesammelten EC2-Metriken zu sehen. CloudWatch Weitere Informationen zu automatischen Dashboards für Dienste finden Sie unter. AWS [Ein CloudWatch Dashboard für einen einzelnen AWS Dienst anzeigen](CloudWatch_Automatic_Dashboards_Focus_Service.md)

Um das Dashboard zu erstellen, können Sie die folgenden Optionen nutzen.
+ Verwenden Sie die CloudWatch Konsole, um das Dashboard zu erstellen.
+ Verwenden Sie die AWS CloudFormation Konsole, um das Dashboard bereitzustellen.
+ Laden Sie die AWS CloudFormation Infrastruktur als Code herunter und integrieren Sie sie als Teil Ihrer Continuous Integration (CI) -Automatisierung.

Wenn Sie die CloudWatch Konsole zum Erstellen eines Dashboards verwenden, können Sie eine Vorschau des Dashboards anzeigen, bevor Sie es tatsächlich erstellen und bezahlen.

**Anmerkung**  
Das CloudFormation in dieser Lösung erstellte Dashboard zeigt Metriken aus der Region an, in der die Lösung bereitgestellt wird. Stellen Sie sicher, dass Sie den CloudFormation Stack in der Region erstellen, in der Ihre JVM- und Kafka-Metriken veröffentlicht werden.  
Wenn Sie einen anderen benutzerdefinierten Namespace als `CWAgent` in der CloudWatch Agentenkonfiguration angegeben haben, müssen Sie die CloudFormation Vorlage für das Dashboard so ändern, dass sie durch den von Ihnen verwendeten benutzerdefinierten Namespace `CWAgent` ersetzt wird.

**Um das Dashboard über die Konsole zu erstellen CloudWatch**
**Anmerkung**  
In Lösungs-Dashboards werden derzeit nur Metriken zur Garbage Collection angezeigt, die sich auf den G1 Garbage Collector beziehen. Dabei handelt es sich um den Standard-Collector für die neuesten Java-Versionen. Wenn Sie einen anderen Garbage-Collection-Algorithmus verwenden, sind die Widgets, die sich auf die Garbage Collection beziehen, leer. Sie können diese Widgets jedoch anpassen, indem Sie die CloudFormation Dashboard-Vorlage ändern und den entsprechenden Garbage-Collection-Typ auf die Namensdimension der Metriken anwenden, die sich auf die Garbage-Collection beziehen. Wenn Sie beispielsweise die parallele Garbage Collection verwenden, ändern Sie den Wert **name=\$1"G1 Young Generation\$1"** auf **name=\$1"Parallel GC\$1"** (bei der Garbage-Collection-Anzahlmetrik `jvm.gc.collections.count`).

1. [Öffnen Sie die CloudWatch Konsole „**Dashboard erstellen“** über diesen Link: Home? https://console.aws.amazon.com/cloudwatch/ \$1dashboards? ApacheKafkaOnEcDashboardTemplate=](https://console.aws.amazon.com/cloudwatch/home?#dashboards?dashboardTemplate=ApacheKafkaOnEc2&referrer=os-catalog) 2&referrer=os-catalog. 

1. Sorgen Sie dafür, dass die ausgewählte Region auf der Konsole die Region ist, in der die Kafka-Workload ausgeführt wird.

1. Geben Sie einen Namen für das Dashboard ein und wählen Sie **Dashboard erstellen**.

   Um dieses Dashboard leicht von ähnlichen Dashboards in anderen Regionen zu unterscheiden, empfehlen wir, den Namen der Region in den Namen des Dashboards aufzunehmen, z. B. **KafkaDashboard-us-east-1**.

1. Zeigen Sie eine Vorschau des Dashboards an und wählen Sie **Speichern** aus, um das Dashboard zu erstellen.

**Um das Dashboard zu erstellen über CloudFormation**

1. Öffnen Sie den Assistenten CloudFormation **zum schnellen Erstellen von Stacks** über diesen Link: [https://console.aws.amazon.com/cloudformation/Home? \$1/ stacks/quickcreate?templateURL=https://aws-observability-solutions-prod-us-east-1.s3.us-east-1.amazonaws.com/Kafka\$1EC2/CloudWatch/CFN/v1.0.0/dashboard -template-1.0.0.json](https://console.aws.amazon.com/cloudformation/home?#/stacks/quickcreate?templateURL=https://aws-observability-solutions-prod-us-east-1.s3.us-east-1.amazonaws.com/Kafka_EC2/CloudWatch/CFN/v1.0.0/dashboard-template-1.0.0.json). 

1. Sorgen Sie dafür, dass die ausgewählte Region auf der Konsole die Region ist, in der die Kafka-Workload ausgeführt wird.

1. Geben Sie unter **Stack-Name** einen Namen für diesen Stack, z. B. **KafkaDashboardStack**, ein.

1. Geben Sie im Abschnitt **Parameter** den Namen des Dashboards unter dem Parameter an. **DashboardName**

   Um dieses Dashboard leicht von ähnlichen Dashboards in anderen Regionen zu unterscheiden, empfehlen wir, den Namen der Region in den Namen des Dashboards aufzunehmen, z. B. **KafkaDashboard-us-east-1**.

1. Bestätigen Sie die Zugriffsmöglichkeiten für Transformationen unter **Funktionen und Transformationen**. Beachten Sie, dass dadurch CloudFormation keine IAM-Ressourcen hinzugefügt werden.

1. Überprüfen Sie die Einstellungen und wählen Sie dann **Stack erstellen** aus. 

1. Wenn der Stack-Status **CREATE\$1COMPLETE** lautet, wählen Sie unter dem erstellten Stack die Registerkarte **Ressourcen** und dann den Link unter **Physische ID** aus, um zum Dashboard zu gelangen. Sie können auch in der CloudWatch Konsole auf das Dashboard zugreifen, indem Sie im linken Navigationsbereich der Konsole **Dashboards** auswählen und den Namen des Dashboards unter **Benutzerdefinierte** Dashboards suchen.

Wenn Sie die Vorlagendatei bearbeiten möchten, um sie für beliebige Zwecke anzupassen, können Sie im **Assistenten zum Erstellen von Stacks** die Option **Eine Vorlagendatei hochladen** auswählen, um die bearbeitete Vorlage hochzuladen. Weitere Informationen finden Sie unter [Einen Stack auf der CloudFormation Konsole erstellen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html). Sie können diesen Link verwenden, um die Vorlage herunterzuladen: [https://aws-observability-solutions-prod-us-east-1.s3.us-east-1.amazonaws.com/Kafka\$1EC2/CloudWatch/CFN/v1.0.0/dashboard-template-1.0.0.json](https://aws-observability-solutions-prod-us-east-1.s3.us-east-1.amazonaws.com/Kafka_EC2/CloudWatch/CFN/v1.0.0/dashboard-template-1.0.0.json). 

**Anmerkung**  
In Lösungs-Dashboards werden derzeit nur Metriken zur Garbage Collection angezeigt, die sich auf den G1 Garbage Collector beziehen. Dabei handelt es sich um den Standard-Collector für die neuesten Java-Versionen. Wenn Sie einen anderen Garbage-Collection-Algorithmus verwenden, sind die Widgets, die sich auf die Garbage Collection beziehen, leer. Sie können diese Widgets jedoch anpassen, indem Sie die CloudFormation Dashboard-Vorlage ändern und den entsprechenden Garbage-Collection-Typ auf die Namensdimension der Messwerte anwenden, die sich auf die Müllsammlung beziehen. Wenn Sie beispielsweise die parallele Garbage Collection verwenden, ändern Sie den Wert **name=\$1"G1 Young Generation\$1"** auf **name=\$1"Parallel GC\$1"** (bei der Garbage-Collection-Anzahlmetrik `jvm.gc.collections.count`). 

### Erste Schritte mit dem Kafka-Dashboard
<a name="Solution-Kafka-Dashboard-GetStarted"></a>

Hier finden Sie ein paar Aufgaben, die Sie mit dem neuen Kafka-Dashboard ausprobieren können. Mit diesen Aufgaben können Sie prüfen, ob das Dashboard ordnungsgemäß funktioniert, und Sie erhalten praktische Erfahrung mit der Überwachung eines Kafka-Clusters. Wenn Sie diese Optionen ausprobieren, werden Sie sich mit der Navigation im Dashboard und der Interpretation der visualisierten Metriken vertraut machen.

**Verwenden der Drop-down-Listen**

Das Dashboard bietet oben Drop-down-Listen, mit denen Sie die spezifischen Kafka-Cluster-, Produzenten- und Verbraucher-Gruppen, die Sie überwachen möchten, filtern und auswählen können.
+ Um Metriken für einen bestimmten Kafka-Cluster anzuzeigen, wählen Sie diesen Clusternamen in der Drop-down-Liste **Kafka-Cluster** aus. 
+ Um Metriken für eine bestimmte Kafka-Produzenten-Gruppe anzuzeigen, wählen Sie den Namen der Produzentengruppe in der Drop-down-Liste **Kafka-Produzent** aus. 
+ Um Metriken für eine bestimmte Kafka-Verbraucher-Gruppe anzuzeigen, wählen Sie den Namen der Verbrauchergruppe in der Drop-down-Liste **Kafka-Verbraucher** aus. 

**Überprüfen des Cluster-Zustands**

Suchen Sie im Abschnitt **Cluster-Übersicht** nach den Widgets **Partitionen unter „repliziert“** und **Synchronisierte Replikate**. Diese sollten idealerweise Null sein oder eine kleine Zahl haben. Ein großer Wert für eine dieser Metriken könnte auf Probleme mit dem Kafka-Cluster hinweisen, die zu untersuchen sind. 

**Untersuchen der Broker-Leistung**

Suchen Sie im Abschnitt **Brokers** nach den Widgets **Fehlgeschlagene Abrufanforderungen** und **Fehlgeschlagene Produzentenanforderungen**. Diese zeigen die Anzahl der fehlgeschlagenen Anforderungen für Abruf- bzw. Produktionsvorgänge an. Hohe Ausfallraten könnten auf Probleme mit den Brokern oder der Netzwerkverbindung hinweisen, die weitere Untersuchungen erfordern.

**Überwachen der Produzentenleistung**

Suchen Sie im Abschnitt „**Übersicht über die Produzentengruppe**“ nach den Widgets „**Durchschnittliche Anforderungsrate**“, „**Durchschnittliche Anforderungslatenz**“ und „**Durchschnittliche Send/Error Aufzeichnungsrate**“. Diese geben dir einen Überblick über das Abschneiden der Produzenten in der ausgewählten Gruppe. Im Bereich **Produzenten** kannst du dir auch detaillierte Metriken zu bestimmten Produzenten und Themen ansehen.

**Überwachen der Verzögerung der Verbraucher**

Suchen Sie im Bereich **Verbrauchergruppen-Übersicht** nach dem Widget **Verbraucher-Lag**. Das zeigt, wie weit die Verbraucher bei der Verarbeitung von Nachrichten aus den neuesten Offsets in den Partitionen, die sie abonniert haben, im Rückstand sind. Im Idealfall sollte die Verzögerung bei den Verbrauchern niedrig oder gleich Null sein. Eine starke Verzögerung bei den Verbrauchern könnte darauf hindeuten, dass die Verbraucher nicht in der Lage sind, mit der Geschwindigkeit der Datenproduktion Schritt zu halten, was zu Datenverlusten oder Verzögerungen bei der Verarbeitung führen könnte. Im Bereich **Verbraucher** kannst du dir auch detaillierte Metriken zu bestimmten Verbrauchern und Themen ansehen.

## Konfigurieren Sie den Agenten für mehrere Kafka-Rollen auf derselben Instance
<a name="Kafka-Multiple-Roles"></a>

Die einzelnen Konfigurationen für Kafka-Rollen, die unter [CloudWatch Agentenkonfiguration für diese Lösung](#Solution-Kafka-CloudWatch-Agent) aufgeführt sind, gelten nur, wenn die Rollen Produzent, Verbraucher und Broker auf separaten EC2-Instances bereitgestellt werden, ohne dass es zu Überschneidungen kommt. Wenn Sie mehrere Kafka-Rollen auf denselben Amazon-EC2-Instances ausführen, haben Sie zwei Möglichkeiten:
+ Erstellen Sie eine einzige Agent-Konfigurationsdatei, die alle Metriken für alle auf dieser Instance bereitgestellten Kafka-Rollen auflistet und konfiguriert. Wenn Sie Systems Manager zur Verwaltung der Agentenkonfiguration nutzen möchten, ist dies die bevorzugte Option.

  Wenn Sie diese Option auswählen und die verschiedenen Kafka-Rollen Teil desselben JVM-Prozesses sind, müssen Sie für jede Kafka-Rolle in der Agentenkonfiguration denselben Endpunkt festlegen. Wenn die mehreren Kafka-Rollen Teil verschiedener JVM-Prozesse sind, kann sich der Endpunkt für jede Rolle je nach dem für diesen Prozess festgelegten JMX-Port unterscheiden.
+ Erstellen Sie separate Dateien für die Agentenkonfiguration für jede Kafka-Rolle und konfigurieren Sie den Agenten so, dass er beide Konfigurationsdateien anwendet. Anweisungen zum Anwenden mehrerer Konfigurationsdateien finden Sie unter [Erstellen mehrerer CloudWatch Agenten-Konfigurationsdateien](create-cloudwatch-agent-configuration-file.md#CloudWatch-Agent-multiple-config-files).

Das folgende Beispiel zeigt eine CloudWatch Agentenkonfiguration, bei der die Rollen Producer und Consumer auf einer Instanz als Teil desselben JVM-Prozesses ausgeführt werden. In diesem Fall muss die Portnummer sowohl im Produzenten- als auch im Verbraucher-Bereich der folgenden Konfiguration identisch sein. Falls die beiden Rollen stattdessen als Teil verschiedener JVM-Prozesse ausgeführt würden, könnten Sie je nach JMX-Port jedes einzelnen JVM-Prozesses unterschiedliche Portnummern für jede Rolle angeben.

```
{
  "metrics": {
    "namespace": "CWAgent",
    "append_dimensions": {
      "InstanceId": "${aws:InstanceId}"
    },
    "metrics_collected": {
      "jmx": [
        {
          "endpoint": "localhost:port-number",
          "kafka-producer": {
            "measurement": [
              "kafka.producer.request-rate",
              "kafka.producer.byte-rate",
              "kafka.producer.request-latency-avg",
              "kafka.producer.response-rate",
              "kafka.producer.record-error-rate",
              "kafka.producer.record-send-rate"
            ]
          },
          "append_dimensions": {
            "ProducerGroupName": "ProducerGroupName"
          }
        },
        {
          "endpoint": "localhost:port-number",
          "kafka-consumer": {
            "measurement": [
              "kafka.consumer.fetch-rate",
              "kafka.consumer.total.bytes-consumed-rate",
              "kafka.consumer.records-consumed-rate",
              "kafka.consumer.bytes-consumed-rate",
              "kafka.consumer.records-lag-max"
            ]
          },
          "append_dimensions": {
            "ConsumerGroupName": "ConsumerGroupName"
          }
        }
      ]
    }
  }
}
```