

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.

# Was ist MSK Serverless?
<a name="serverless"></a>

**Anmerkung**  
MSK Serverless ist in den Regionen USA Ost (Nord-Virginia), USA Ost (Ohio), USA West (Oregon), Kanada (Zentral), Asien-Pazifik (Mumbai), Asien-Pazifik (Seoul), Asien-Pazifik (Singapur), Asien-Pazifik (Sydney), Asien-Pazifik (Tokio), Europa (Frankfurt), Europa (Stockholm) Europa (Irland), Europa (London) und Europa (Paris) verfügbar.

MSK Serverless ist ein Cluster-Typ für Amazon MSK, mit dem Sie Apache Kafka ausführen können, ohne die Cluster-Kapazität verwalten und skalieren zu müssen. Die Kapazität wird automatisch bereitgestellt und skaliert, während gleichzeitig die Partitionen in Ihrem Thema verwaltet werden, sodass Sie Daten streamen können, ohne über die richtige Größe oder Skalierung von Clustern nachdenken zu müssen. MSK Serverless bietet ein durchsatzbasiertes Preismodell. Sie zahlen nur für das, was Sie tatsächlich nutzen. Erwägen Sie die Verwendung eines Serverless-Clusters, wenn Ihre Anwendungen On-Demand-Streaming-Kapazität benötigen, die automatisch hoch- und herunterskaliert wird.

MSK Serverless ist vollständig mit Apache Kafka kompatibel, sodass Sie beliebige kompatible Client-Anwendungen zur Erzeugung und Nutzung von Daten verwenden können. Es kann auch in folgende Services integriert werden:
+ AWS PrivateLink um private Konnektivität bereitzustellen
+ AWS Identity and Access Management (IAM) für die Authentifizierung und Autorisierung mit Java- und Nicht-Java-Sprachen. Anweisungen zur Konfiguration von Clients für IAM finden Sie unter [Konfiguration von Clients für die IAM-Zugriffssteuerung](configure-clients-for-iam-access-control.md).
+ AWS Glue Schema Registry für die Schemaverwaltung
+ Amazon Managed Service für Apache Flink für Apache-Flink-basierte Stream-Verarbeitung
+  AWS Lambda für die Verarbeitung von Ereignissen

**Anmerkung**  
MSK Serverless erfordert IAM-Zugriffssteuerung für alle Cluster. Apache Kafka-Zugriffskontrolllisten (ACLs) werden nicht unterstützt. Weitere Informationen finden Sie unter [IAM-Zugriffssteuerung](iam-access-control.md).  
Informationen zu Servicekontingenten, die für MSK Serverless gelten, finden Sie unter [MSK-Serverless-Kontingent](limits.md#serverless-quota).

Im Folgenden finden Sie Informationen zu den ersten Schritten mit Serverless-Clustern und erfahren Sie mehr über die Konfigurations- und Überwachungsoptionen für Serverless-Cluster.

**Topics**
+ [

# MSK-Serverless-Cluster verwenden
](serverless-getting-started.md)
+ [

# Konfigurationseigenschaften für MSK-Serverless-Cluster
](serverless-config.md)
+ [

# Konfigurieren Sie den Dual-Stack-Netzwerktyp
](serverless-config-dual-stack.md)
+ [

# Überwachen Sie serverlose MSK-Cluster
](serverless-monitoring.md)

# MSK-Serverless-Cluster verwenden
<a name="serverless-getting-started"></a>

Dieses Tutorial zeigt Ihnen ein Beispiel dafür, wie Sie einen MSK-Serverless-Cluster erstellen, einen Client-Computer erstellen, der darauf zugreifen kann, und den Client verwenden, um Themen auf dem Cluster zu erstellen und Daten in diese Themen zu schreiben. Dieses Beispiel zeigt nicht alle Optionen, die Sie auswählen können, wenn Sie einen Serverless-Cluster erstellen. In verschiedenen Teilen dieses Tutorials wählen wir aus Gründen der Einfachheit die Standardoptionen. Dies bedeutet nicht, dass dies die einzigen Optionen sind, die funktionieren, um einen Serverless-Cluster einzurichten. Sie können auch die AWS CLI oder die Amazon MSK-API verwenden. Weitere Informationen finden Sie in der [Amazon-MSK-API-Referenz 2.0](https://docs.aws.amazon.com/MSK/2.0/APIReference/what-is-msk.html).

**Topics**
+ [

# Erstellen Sie einen MSK-Serverless-Cluster
](create-serverless-cluster.md)
+ [

# Erstellen Sie eine IAM-Rolle für Themen im MSK Serverless Cluster
](create-iam-role.md)
+ [

# Erstellen Sie einen Client-Computer für den Zugriff auf den MSK Serverless Cluster
](create-serverless-cluster-client.md)
+ [

# Erstellen Sie ein Apache Kafka-Thema
](msk-serverless-create-topic.md)
+ [

# Produzieren und konsumieren Sie Daten in MSK Serverless
](msk-serverless-produce-consume.md)
+ [

# Löschen Sie Ressourcen, die Sie für MSK Serverless erstellt haben
](delete-resources.md)

# Erstellen Sie einen MSK-Serverless-Cluster
<a name="create-serverless-cluster"></a>

In diesem Schritt führen Sie zwei Aufgaben aus. Zunächst erstellen Sie einen MSK-Serverless-Cluster mit Standardeinstellungen. Zweitens sammeln Sie Informationen über den Cluster. Diese Informationen benötigen Sie in späteren Schritten, wenn Sie einen Client erstellen, der Daten an den Cluster senden kann.

**So erstellen Sie einen Serverless-Cluster**

1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon MSK-Konsole zu [https://console.aws.amazon.com/msk/Hause](https://console.aws.amazon.com/msk/home).

1. Wählen Sie **Cluster erstellen**.

1. Lassen Sie für die **Erstellungsmethode** die Option **Schnellerstellung** ausgewählt. Mit der Option **Schnellerstellung** können Sie einen Serverless-Cluster mit Standardeinstellungen erstellen.

1. Geben Sie für **Cluster-Name** einen beschreibenden Namen ein, z. B. **msk-serverless-tutorial-cluster**.

1. Wählen Sie für **Allgemeine Cluster-Eigenschaften** **Serverless** als **Cluster-Typ**. Verwenden Sie die Standardwerte für die übrigen **allgemeinen Cluster**-Eigenschaften.

1. Beachten Sie die Tabelle unter **Alle Cluster-Einstellungen**. In dieser Tabelle sind die Standardwerte für wichtige Einstellungen wie Netzwerk und Verfügbarkeit aufgeführt. Außerdem wird angegeben, ob Sie die einzelnen Einstellungen nach der Erstellung des Clusters ändern können. Um eine Einstellung zu ändern, bevor Sie den Cluster erstellen, sollten Sie unter **Erstellungsmethode** die Option **Benutzerdefiniertes Erstellen** auswählen.
**Anmerkung**  
Mit MSK Serverless Clustern können Sie Clients aus bis zu fünf verschiedenen VPCs Netzwerken verbinden. Damit Client-Anwendungen bei einem Ausfall in eine andere Availability Zone wechseln können, müssen Sie in jeder VPC mindestens zwei Subnetze angeben.

1. Wählen Sie **Cluster erstellen**.

**So sammeln Sie Informationen über den Cluster**

1. Wählen Sie im Abschnitt mit der **Cluster-Zusammenfassung** die Option **Client-Informationen anzeigen**. Diese Schaltfläche bleibt ausgegraut, bis Amazon MSK die Erstellung des Clusters abgeschlossen hat. Möglicherweise müssen Sie einige Minuten warten, bis die Schaltfläche aktiv wird, sodass Sie sie verwenden können.

1. Kopieren Sie die Zeichenfolge unter der Bezeichnung **Endpunkt**. Dies ist Ihre Bootstrap-Server-Zeichenfolge.

1. Wählen Sie die Registerkarte **Eigenschaften** aus.

1. Kopieren Sie im Abschnitt **Netzwerkeinstellungen** die IDs Subnetze und die Sicherheitsgruppe und speichern Sie sie, da Sie diese Informationen später benötigen, um einen Client-Computer zu erstellen.

1. Wählen Sie eines der Subnetze aus. Dadurch wird die Amazon-VPC-Konsole geöffnet. Suchen Sie die ID der Amazon VPC, die dem Subnetz zugeordnet ist. Speichern Sie diese Amazon-VPC-ID zur späteren Verwendung.

**Nächster Schritt**

[Erstellen Sie eine IAM-Rolle für Themen im MSK Serverless Cluster](create-iam-role.md)

# Erstellen Sie eine IAM-Rolle für Themen im MSK Serverless Cluster
<a name="create-iam-role"></a>

In diesem Schritt führen Sie zwei Aufgaben aus. Die erste Aufgabe besteht darin, eine IAM-Richtlinie zu erstellen, die Zugriff auf die Erstellung von Themen auf dem Cluster und das Senden von Daten an diese Themen gewährt. Die zweite Aufgabe besteht darin, eine IAM-Rolle zu erstellen und ihr diese Richtlinie zuzuordnen. In einem späteren Schritt erstellen wir einen Client-Computer, der diese Rolle übernimmt und sie verwendet, um ein Thema auf dem Cluster zu erstellen und Daten an dieses Thema zu senden.

**So erstellen Sie eine IAM-Richtlinie, die es ermöglicht, Themen zu erstellen und in sie zu schreiben**

1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

1. Wählen Sie im Navigationsbereich **Richtlinien**.

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

1. Wählen Sie die Registerkarte **JSON** und ersetzen Sie dann den JSON-Code im Editor-Fenster durch den Folgenden. 

   Ersetzen Sie im folgenden Beispiel Folgendes:
   + *region*mit dem Code des Ortes AWS-Region , an dem Sie Ihren Cluster erstellt haben.
   + Beispiel für eine Konto-ID*123456789012*, mit Ihrer AWS-Konto ID.
   + *msk-serverless-tutorial-cluster*/*c07c74ea-5146-4a03-add1-9baa787a5b14-s3*und *msk-serverless-tutorial-cluster* mit Ihrer serverlosen Cluster-ID und Ihrem Themennamen.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "kafka-cluster:Connect",
                   "kafka-cluster:DescribeCluster"
               ],
               "Resource": [
                   "arn:aws:kafka:us-east-1:123456789012:cluster/msk-serverless-tutorial-cluster/c07c74ea-5146-4a03-add1-9baa787a5b14-s3"
               ]
           },
           {
               "Effect": "Allow",
               "Action": [
                   "kafka-cluster:CreateTopic",
                   "kafka-cluster:WriteData",
                   "kafka-cluster:DescribeTopic"
               ],
               "Resource": [
               "arn:aws:kafka:us-east-1:123456789012:topic/msk-serverless-tutorial-cluster/*"
               ]
           }
       ]
   }
   ```

------

   Anweisungen zum Schreiben sicherer Richtlinien finden Sie unter[IAM-Zugriffssteuerung](iam-access-control.md).

1. Wählen Sie **Next: Tags** (Weiter: Tags) aus.

1. Klicken Sie auf **Weiter: Prüfen**.

1. Geben für den Richtliniennamen einen beschreibenden Namen ein, z. B. **msk-serverless-tutorial-policy**.

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

**So erstellen Sie eine IAM-Rolle und fügen ihr die Richtlinie an**

1. Wählen Sie im Navigationsbereich **Rollen**.

1. Wählen Sie **Rolle erstellen**.

1. Wählen Sie unter **Häufige Anwendungsfälle** die Option **EC2** und dann **Weiter: Berechtigungen**.

1. Geben Sie in das Suchfeld den Namen der Richtlinie ein, die Sie zuvor für dieses Tutorial erstellt haben. Aktivieren Sie anschließend das Kontrollkästchen links neben der Richtlinie.

1. Wählen Sie **Next: Tags** (Weiter: Tags) aus.

1. Klicken Sie auf **Weiter: Prüfen**.

1. Geben Sie für den Rollennamen einen beschreibenden Namen ein, z. B. **msk-serverless-tutorial-role**.

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

**Nächster Schritt**

[Erstellen Sie einen Client-Computer für den Zugriff auf den MSK Serverless Cluster](create-serverless-cluster-client.md)

# Erstellen Sie einen Client-Computer für den Zugriff auf den MSK Serverless Cluster
<a name="create-serverless-cluster-client"></a>

In diesem Schritt führen Sie zwei Aufgaben aus. Die erste Aufgabe besteht darin, eine Amazon-EC2-Instance zu erstellen, die als Apache-Kafka-Client-Computer verwendet werden soll. Die zweite Aufgabe besteht darin, Java- und Apache-Kafka-Tools auf dem Computer zu installieren.

**Erstellen eines Client-Computers**

1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie **Launch Instance (Instance starten)** aus.

1. Geben Sie einen beschreibenden **Namen** für Ihren Client-Computer ein, z. B. **msk-serverless-tutorial-client**

1. Lassen Sie **Amazon Linux 2 AMI (HVM) – Kernel 5.10, SSD Volume Type** als **Amazon Machine Image (AMI)-Typ** ausgewählt.

1. Lassen Sie den **t2.micro**-Instance-Typ ausgewählt.

1. Wählen Sie unter **Schlüsselpaar (Login)** die Option **Neues Schlüsselpaar erstellen**. Geben Sie **MSKServerlessKeyPair** für **Schlüsselpaar-Name** ein. Wählen Sie dann **Schlüsselpaar herunterladen**. Alternativ können Sie ein vorhandenes Schlüsselpaar verwenden.

1. Wählen Sie für **Netzwerkeinstellungen** die Option **Bearbeiten** aus.

1. Geben Sie unter **VPC** die ID der Virtual Private Cloud (VPC) für Ihren Serverless-Cluster ein. Dies ist die VPC, die auf dem Amazon-VPC-Service basiert und dessen ID Sie nach der Erstellung des Clusters gespeichert haben.

1. Wählen Sie für **Subnetz** das Subnetz aus, dessen ID Sie nach der Erstellung des Clusters gespeichert haben.

1. Wählen Sie unter **Firewall (Sicherheitsgruppen)** die Sicherheitsgruppe aus, die dem Cluster zugeordnet ist. Dieser Wert funktioniert, wenn diese Sicherheitsgruppe über eine eingehende Regel verfügt, die Datenverkehr von der Sicherheitsgruppe zu sich selbst zulässt. Mit einer solchen Regel können Mitglieder derselben Sicherheitsgruppe miteinander kommunizieren. Weitere Informationen finden Sie unter [Sicherheitsgruppenregeln](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#SecurityGroupRules) im Amazon-VPC-Benutzerhandbuch.

1. Erweitern Sie den Abschnitt **Erweiterte Details** und wählen Sie die IAM-Rolle aus, die Sie in [Erstellen Sie eine IAM-Rolle für Themen im MSK Serverless Cluster](create-iam-role.md) erstellt haben.

1. Wählen Sie **Launch** (Starten) aus.

1. Wählen Sie im linken Navigationsbereich die Option **Instances** aus. Aktivieren Sie dann das Kontrollkästchen in der Zeile, die die neu erstellte Amazon-EC2-Instance darstellt. Ab diesem Zeitpunkt nennen wir diese Instance den *Client-Computer*.

1. Wählen Sie **Verbinden** und folgen Sie den Anweisungen, um eine Verbindung zum Client-Computer herzustellen.

**So richten Sie die Apache-Kafka-Client-Tools auf dem Client-Computer ein**

1. Installieren Sie Java auf dem Client-Computer, indem Sie den folgenden Befehl ausführen:

   ```
   sudo yum -y install java-11
   ```

1. Führen Sie die folgenden Befehle aus, um die Apache-Kafka-Tools zu erhalten, die wir zum Erstellen von Themen und zum Senden von Daten benötigen:

   ```
   wget https://archive.apache.org/dist/kafka/2.8.1/kafka_2.12-2.8.1.tgz
   ```

   ```
   tar -xzf kafka_2.12-2.8.1.tgz
   ```
**Anmerkung**  
Stellen Sie nach dem Extrahieren des Kafka-Archivs sicher, dass die Skripts im `bin` Verzeichnis über die erforderlichen Ausführungsberechtigungen verfügen. Führen Sie dazu den folgenden Befehl aus.  

   ```
   chmod +x kafka_2.12-2.8.1/bin/*.sh
   ```

1. Wechseln Sie zum Verzeichnis `kafka_2.12-2.8.1/libs` und führen Sie dann den folgenden Befehl aus, um die Amazon-MSK-IAM-JAR-Datei herunterzuladen. Das Amazon-MSK-IAM-JAR ermöglicht dem Client-Computer den Zugriff auf den Cluster.

   ```
   wget https://github.com/aws/aws-msk-iam-auth/releases/download/v2.3.0/aws-msk-iam-auth-2.3.0-all.jar
   ```

   Mit diesem Befehl können Sie auch [andere oder neuere Versionen der Amazon MSK IAM JAR-Datei herunterladen](https://github.com/aws/aws-msk-iam-auth/releases).

1. Wechseln Sie zum Verzeichnis `kafka_2.12-2.8.1/bin`. Kopieren Sie die folgenden Eigenschaften-Einstellungen und fügen Sie sie in eine neue Datei ein. Benennen Sie die Datei `client.properties` und speichern Sie sie.

   ```
   security.protocol=SASL_SSL
   sasl.mechanism=AWS_MSK_IAM
   sasl.jaas.config=software.amazon.msk.auth.iam.IAMLoginModule required;
   sasl.client.callback.handler.class=software.amazon.msk.auth.iam.IAMClientCallbackHandler
   ```

**Nächster Schritt**

[Erstellen Sie ein Apache Kafka-Thema](msk-serverless-create-topic.md)

# Erstellen Sie ein Apache Kafka-Thema
<a name="msk-serverless-create-topic"></a>

In diesem Schritt verwenden Sie den zuvor erstellten Client-Computer, um ein Thema auf dem Serverless-Cluster zu erstellen.

**Topics**
+ [

## Richten Sie Ihre Umgebung für die Erstellung von Themen ein
](#msk-serverless-create-topic-prerequisites)
+ [

## Ein Thema erstellen und Daten dazu schreiben
](#msk-serverless-create-topic-procedure)

## Richten Sie Ihre Umgebung für die Erstellung von Themen ein
<a name="msk-serverless-create-topic-prerequisites"></a>
+ Bevor Sie ein Thema erstellen, stellen Sie sicher, dass Sie die AWS MSK IAM JAR-Datei in das Verzeichnis Ihrer Kafka-Installation heruntergeladen haben. `libs/` Wenn Sie dies noch nicht getan haben, führen Sie den folgenden Befehl in Ihrem Kafka-Verzeichnis aus. `libs/`

  ```
  wget https://github.com/aws/aws-msk-iam-auth/releases/download/v2.3.0/aws-msk-iam-auth-2.3.0-all.jar
  ```

  Diese JAR-Datei ist für die IAM-Authentifizierung mit Ihrem MSK Serverless-Cluster erforderlich.
+ Wenn Sie Kafka-Befehle ausführen, müssen Sie möglicherweise sicherstellen, dass die AWS MSK `classpath` IAM-JAR-Datei enthalten ist. Führen Sie dazu einen der folgenden Schritte aus:
  + Stellen Sie die `CLASSPATH` Umgebungsvariable so ein, dass sie Ihre Kafka-Bibliotheken einschließt, wie im folgenden Beispiel gezeigt.

    ```
    export CLASSPATH=<path-to-your-kafka-installation>/libs/*:<path-to-your-kafka-installation>/libs/aws-msk-iam-auth-2.3.0-all.jar
    ```
  + Führen Sie Kafka-Befehle mit dem vollständigen Java-Befehl mit explicit aus`classpath`, wie im folgenden Beispiel gezeigt.

    ```
    java -cp "<path-to-your-kafka-installation>/libs/*:<path-to-your-kafka-installation>/libs/aws-msk-iam-auth-2.3.0-all.jar" org.apache.kafka.tools.TopicCommand --bootstrap-server $BS --command-config client.properties --create --topic msk-serverless-tutorial --partitions 6
    ```

## Ein Thema erstellen und Daten dazu schreiben
<a name="msk-serverless-create-topic-procedure"></a>

1. Ersetzen Sie im folgenden `export` Befehl *my-endpoint* durch die Bootstrap-Server-Zeichenfolge, die Sie nach der Erstellung des Clusters gespeichert haben. Wechseln Sie dann zum Verzeichnis `kafka_2.12-2.8.1/bin` auf dem Client-Computer und führen Sie den `export`-Befehl aus.

   ```
   export BS=my-endpoint
   ```

1. Führen Sie den folgenden Befehl aus, um ein Thema mit dem Namen `msk-serverless-tutorial` zu erstellen.

   ```
   <path-to-your-kafka-installation>/bin/kafka-topics.sh --bootstrap-server $BS --command-config client.properties --create --topic msk-serverless-tutorial --partitions 6
   ```

**Nächster Schritt**

[Produzieren und konsumieren Sie Daten in MSK Serverless](msk-serverless-produce-consume.md)

# Produzieren und konsumieren Sie Daten in MSK Serverless
<a name="msk-serverless-produce-consume"></a>

In diesem Schritt produzieren und verbrauchen Sie Daten mithilfe des Themas, das Sie im vorherigen Schritt erstellt haben.

**Erstellen und Verbrauchen von Nachrichten**

1. Führen Sie den folgenden Befehl aus, um einen Konsolenproduzenten zu erstellen.

   ```
   <path-to-your-kafka-installation>/bin/kafka-console-producer.sh --broker-list $BS --producer.config client.properties --topic msk-serverless-tutorial
   ```

1. Geben Sie eine beliebige Nachricht ein, und drücken Sie **Enter (Eingabetaste)**. Wiederholen Sie diesen Schritt zwei- oder dreimal. Jedes Mal, wenn Sie eine Zeile eingeben und **Eingabe** drücken, wird diese Zeile als separate Nachricht an Ihren Apache-Kafka-Cluster gesendet.

1. Lassen Sie die Verbindung zum Client-Computer geöffnet und öffnen Sie dann eine zweite separate Verbindung zu diesem Computer in einem neuen Fenster.

1. Verwenden Sie Ihre zweite Verbindung zum Client-Computer, um mit dem folgenden Befehl einen Konsolen-Verbraucher zu erstellen. *my-endpoint*Ersetzen Sie es durch die Bootstrap-Serverzeichenfolge, die Sie nach der Erstellung des Clusters gespeichert haben.

   ```
   <path-to-your-kafka-installation>/bin/kafka-console-consumer.sh --bootstrap-server my-endpoint --consumer.config client.properties --topic msk-serverless-tutorial --from-beginning
   ```

   Sie sehen die Nachrichten, die Sie zuvor eingegeben haben, als Sie den Konsolenproduzentenbefehl verwendet haben.

1. Geben Sie weitere Nachrichten in das Producer-Fenster ein und beobachten Sie, wie sie im Consumer-Fenster angezeigt werden.

Wenn bei der Ausführung dieser Befehle `classpath` Probleme auftreten, stellen Sie sicher, dass Sie sie im richtigen Verzeichnis ausführen. Stellen Sie außerdem sicher, dass sich das AWS MSK IAM-JAR im `libs` Verzeichnis befindet. Alternativ können Sie Kafka-Befehle mit dem vollständigen Java-Befehl mit explicit ausführen`classpath`, wie im folgenden Beispiel gezeigt.

```
java -cp "kafka_2.12-2.8.1/libs/*:kafka_2.12-2.8.1/libs/aws-msk-iam-auth-2.3.0-all.jar" org.apache.kafka.tools.ConsoleProducer —broker-list $BS —producer.config client.properties —topic msk-serverless-tutorial
```

**Nächster Schritt**

[Löschen Sie Ressourcen, die Sie für MSK Serverless erstellt haben](delete-resources.md)

# Löschen Sie Ressourcen, die Sie für MSK Serverless erstellt haben
<a name="delete-resources"></a>

In diesem Schritt löschen Sie die Ressourcen, die Sie in diesem Tutorial erstellt haben.

**So löschen Sie den Cluster**

1. Öffnen Sie die Amazon MSK-Konsole zu [https://console.aws.amazon.com/msk/Hause](https://console.aws.amazon.com/msk/home).

1. Wählen Sie in der Liste der Cluster den Cluster aus, den Sie für dieses Tutorial erstellt haben.

1. Wählen Sie für **Aktionen** die Option **Cluster löschen**.

1. Geben Sie `delete` in das Feld ein und wählen Sie dann **Löschen**.

**So stoppen Sie den Client-Computer**

1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie in der Liste der Amazon-EC2-Instances den Client-Computer aus, den Sie für dieses Tutorial erstellt haben.

1. Wählen Sie **Instance-Status** und dann **Instance beenden**.

1. Wähen Sie **Beenden**.

**So löschen Sie die IAM-Richtlinie und -Rolle**

1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

1. Wählen Sie im Navigationsbereich **Rollen**.

1. Geben Sie in das Suchfeld den Namen der IAM-Rolle ein, die Sie für dieses Tutorial erstellt haben.

1. Wählen Sie die Rolle aus. Wählen Sie dann **Rolle löschen** und bestätigen Sie das Löschen.

1. Wählen Sie im Navigationsbereich **Richtlinien**.

1. Geben Sie in das Suchfeld den Namen der Richtlinie ein, die Sie für dieses Tutorial erstellt haben.

1. Wählen Sie die Richtlinie aus, um die zugehörige Übersichtsseite zu öffnen. Wählen Sie auf der **Übersicht**-Seite der Richtlinie die Option **Richtlinie löschen**.

1. Wählen Sie **Löschen** aus.

# Konfigurationseigenschaften für MSK-Serverless-Cluster
<a name="serverless-config"></a>

Amazon MSK legt die Broker-Konfigurationseigenschaften für Serverless-Cluster fest. Sie können diese Konfigurationseigenschaft-Einstellungen des Brokers nicht ändern. Sie können jedoch die folgenden Konfigurationseigenschaften auf Themenebene festlegen oder ändern. Alle anderen Konfigurationseigenschaften auf Themenebene sind nicht konfigurierbar.


****  

| Konfigurationseigenschaft | Standard | Bearbeitbar | Maximal zulässiger Wert | 
| --- | --- | --- | --- | 
| [cleanup.policy](https://kafka.apache.org/documentation/#topicconfigs_cleanup.policy) | Delete | Ja, aber nur zum Zeitpunkt der Erstellung des Themas. |  | 
|  [compression.type](https://kafka.apache.org/documentation/#topicconfigs_compression.type)  | Produzent | Ja |  | 
|  [max.message.bytes](https://kafka.apache.org/documentation/#topicconfigs_max.message.bytes)  | 1048588 | Ja | 8388608 (8 MiB) | 
|  [message.timestamp.difference.max.ms](https://kafka.apache.org/documentation/#topicconfigs_message.timestamp.difference.max.ms)  | long.max | Ja |  | 
|  [message.timestamp.type](https://kafka.apache.org/documentation/#topicconfigs_message.timestamp.type)  | CreateTime | Ja |  | 
|  [retention.bytes](https://kafka.apache.org/documentation/#topicconfigs_retention.bytes)  | 250 GiB | Ja | Unbegrenzt; setzen Sie ihn auf -1 für unbegrenzte Aufbewahrung | 
|  [retention.ms](https://kafka.apache.org/documentation/#topicconfigs_retention.ms)  | 7 Tage | Ja | Unbegrenzt; setzen Sie ihn auf -1 für unbegrenzte Aufbewahrung | 

Um diese Konfigurationseigenschaften auf Themenebene festzulegen oder zu ändern, können Sie die Befehlszeilentools von Apache Kafka verwenden. Weitere Informationen und Beispiele für [deren Einstellung finden Sie unter 3.2 Konfigurationen auf Themenebene](https://kafka.apache.org/documentation/#topicconfigs) in der offiziellen Apache Kafka-Dokumentation.

**Anmerkung**  
Sie können die segment.bytes-Konfiguration für Themen in MSK Serverless nicht ändern. Eine Kafka Streams-Anwendung versucht jedoch möglicherweise, ein internes Thema mit einem segment.bytes-Konfigurationswert zu erstellen, der sich von dem unterscheidet, was MSK Serverless zulässt. Informationen zur Konfiguration von Kafka Streams mit MSK Serverless finden Sie unter. [Verwenden von Kafka Streams mit MSK Express-Brokern und MSK Serverless](use-kafka-streams-express-brokers-msk-serverless.md)

Wenn Sie die Apache Kafka-Befehlszeilentools mit Amazon MSK Serverless verwenden, stellen Sie sicher, dass Sie die Schritte 1 *bis 4 im Abschnitt So richten Sie Apache Kafka-Client-Tools auf dem Client-Computer der Dokumentation* [Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/create-serverless-cluster-client.html) Serverless Getting Started abgeschlossen haben. Darüber hinaus müssen Sie den Parameter in Ihre Befehle aufnehmen. `--command-config client.properties`

Beispielsweise kann der folgende Befehl verwendet werden, um die Themenkonfigurationseigenschaft retention.bytes so zu ändern, dass eine unbegrenzte Aufbewahrung festgelegt wird:

```
<path-to-your-kafka-client-installation>/bin/kafka-configs.sh —bootstrap-server <bootstrap_server_string> —command-config client.properties --entity-type topics --entity-name <topic_name> --alter --add-config retention.bytes=-1
```

*<bootstrap server string>*Ersetzen Sie in diesem Beispiel durch den Bootstrap-Serverendpunkt für Ihren Amazon MSK Serverless-Cluster und *<topic\$1name>* durch den Namen des Themas, das Sie ändern möchten.

Der `--command-config client.properties` Parameter stellt sicher, dass das Kafka-Befehlszeilentool die entsprechenden Konfigurationseinstellungen für die Kommunikation mit Ihrem Amazon MSK Serverless-Cluster verwendet.

# Konfigurieren Sie den Dual-Stack-Netzwerktyp
<a name="serverless-config-dual-stack"></a>

 Amazon MSK unterstützt den Dual-Stack-Netzwerktyp für bestehende MSK-Serverless-Cluster, die Kafka Version 3.6.0 oder höher verwenden, ohne zusätzliche Kosten. Mit Dual-Stack-Netzwerken können Ihre Cluster sowohl Adressen als auch verwenden. IPv4 IPv6 Dual-Stack-Endpunkte unterstützen ebenfalls, IPv4 sodass die Abwärtskompatibilität gewahrt bleibt. Amazon MSK bietet IPv6 Support über den Dual-Stack-Netzwerktyp, nicht nur als IPv6 -only.

 Standardmäßig stellen Clients mithilfe des IPv4 Netzwerktyps eine Verbindung zu Amazon MSK-Clustern her. Alle neuen Cluster, die Sie erstellen, verwenden IPv4 standardmäßig ebenfalls. Um den Netzwerktyp eines Clusters auf Dual-Stack zu aktualisieren, stellen Sie sicher, dass Sie die im folgenden Abschnitt beschriebenen Voraussetzungen erfüllt haben. Verwenden Sie dann die [UpdateConnectivity](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-connectivity.html#UpdateConnectivity)API, um die Konnektivität auf Dual-Stack zu aktualisieren. 

**Anmerkung**  
Sobald Sie Ihren Cluster so aktualisiert haben, dass er den Dual-Stack-Netzwerktyp verwendet, können Sie ihn nicht mehr wieder auf den IPv4 Netzwerktyp umstellen.

**Topics**
+ [

## Voraussetzungen für die Verwendung des Dual-Stack-Netzwerktyps
](#msks-ipv6-prerequisites)
+ [

## IAM-Berechtigungen für MSK Serverless
](#msks-ipv6-iam-permissions)
+ [

## Verwenden Sie den Dual-Stack-Netzwerktyp für einen Cluster
](#update-msks-network-type)
+ [

## Überlegungen zur Verwendung des Dual-Stack-Netzwerktyps
](#msks-dual-stack-considerations)

## Voraussetzungen für die Verwendung des Dual-Stack-Netzwerktyps
<a name="msks-ipv6-prerequisites"></a>

Bevor Sie den Dual-Stack-Netzwerktyp für Ihre Cluster konfigurieren, stellen Sie sicher, dass alle Subnetze, die Sie bei der Clustererstellung angeben, den Dual-Stack-Netzwerktyp unterstützen müssen. Wenn auch nur ein Subnetz in Ihrem Cluster Dual-Stack nicht unterstützt, können Sie den Netzwerktyp für Ihren Cluster nicht auf Dual-Stack aktualisieren.

## IAM-Berechtigungen für MSK Serverless
<a name="msks-ipv6-iam-permissions"></a>

Sie benötigen die folgenden IAM-Berechtigungen:
+  `ec2:DescribeSubnets` 
+  `ec2:ModifyVpcEndpoint` 

Eine vollständige Liste der Berechtigungen, die für die Ausführung aller Amazon MSK-Aktionen erforderlich sind, finden Sie unter AWS verwaltete Richtlinie: [Amazon MSKFull Access](https://docs.aws.amazon.com/msk/latest/developerguide/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonMSKFullAccess).

## Verwenden Sie den Dual-Stack-Netzwerktyp für einen Cluster
<a name="update-msks-network-type"></a>

Sie können den Netzwerktyp für einen MSK-Serverless-Cluster mithilfe des SDK AWS-Managementkonsole AWS CLI, oder aktualisieren. AWS 

------
#### [ Using AWS-Managementkonsole ]

1. Die Amazon MSK-Konsole zu [https://console.aws.amazon.com/msk/Hause öffnen? region=us-east-1\$1/home/](https://console.aws.amazon.com/msk/home?region=us-east-1#/home/).

1. Wählen Sie den MSK Serverless-Cluster aus, für den Sie den Dual-Stack-Netzwerktyp konfigurieren möchten.

1. **Wählen Sie auf der Seite mit den Cluster-Details die Option Eigenschaften aus.**

1. Wählen Sie **unter Netzwerkeinstellungen** die Option **Netzwerktyp bearbeiten** aus.

1. Wählen Sie als **Netzwerktyp** die Option **Dual Stack** aus.

1. Wählen Sie **Änderungen speichern ** aus.

------
#### [ Using AWS CLI ]

Sie können die [Update-Connectivity-API](https://docs.aws.amazon.com/cli/latest/reference/kafka/update-connectivity.html) verwenden, um den Netzwerktyp Ihres vorhandenen MSK Serverless-Clusters auf Dual-Stack zu aktualisieren. Im folgenden Beispiel wird der ` update-connectivity` Befehl verwendet, um den Netzwerktyp des Clusters auf Dual-Stack festzulegen.

Ersetzen Sie im folgenden Beispiel den Beispiel-Cluster-ARN, arn:aws:kafka: *us-east-1* :cluster//* 123456789012*, durch Ihren tatsächlichen MSK-Cluster-ARN. *myCluster* *12345678-1234-1234-1234-123456789012 -1* [Verwenden Sie den Befehl describe-cluster, um die aktuelle Cluster-Version abzurufen.](https://docs.aws.amazon.com/cli/latest/reference/kafka/describe-cluster.html)

```
aws kafka update-connectivity \
    --cluster-arn "arn:aws:kafka:us-east-1:123456789012:cluster/myCluster/12345678-1234-1234-1234-123456789012-1" \
    --current-version "KTVPDKIKX0DER" \
    --connectivity-info '{
        "networkType": "DUAL"
    }
```

------
#### [ Using AWS SDK ]

Das folgende Beispiel verwendet die [UpdateConnectivity](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-connectivity.html#UpdateConnectivity)API, um den Netzwerktyp des Clusters auf Dual-Stack festzulegen.

Ersetzen Sie im folgenden Beispiel den Beispiel-Cluster-ARN, arn:aws:kafka: *us-east-1* :cluster//*123456789012*, durch Ihren tatsächlichen MSK-Cluster-ARN. *myCluster* *12345678-1234-1234-1234-123456789012-1* Verwenden Sie die API, um die aktuelle Cluster-Version abzurufen. [DescribeCluster](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn.html#DescribeCluster)

```
import boto3

client = boto3.client("kafka")

response = client.update_connectivity(
    ClusterArn="arn:aws:kafka:us-east-1:123456789012:cluster/myCluster/12345678-1234-1234-1234-123456789012-1",
    CurrentVersion="KTVPDKIKX0DER",
    ConnectivityInfo={
        "NetworkType": "DUAL"
    }
)
print("Connectivity update initiated:", response)
```

------

## Überlegungen zur Verwendung des Dual-Stack-Netzwerktyps
<a name="msks-dual-stack-considerations"></a>
+ IPv6 Unterstützung ist derzeit nur im Dual-Stack-Modus (IPv4 \$1 IPv6) verfügbar, nicht nur im Modus -only. IPv6
+ Der Dual-Stack-Netzwerktyp ist für private Multi-VPC-Konnektivität nicht verfügbar.
+ Sie können den Netzwerktyp für einen vorhandenen Cluster nur dann von IPv4 zu Dual-Stack ändern, wenn alle Subnetze den Dual-Stack-Netzwerktyp unterstützen.
+ Nach der Aktivierung von Dual-Stack können Sie nicht zum IPv4 Netzwerktyp zurückkehren. Um zurück zu wechseln, müssen Sie den Cluster löschen und neu erstellen.
+ Sie benötigen die folgenden IAM-Berechtigungen:
  + `ec2:DescribeSubnets` und ` ec2:ModifyVpcEndpoint`

# Überwachen Sie serverlose MSK-Cluster
<a name="serverless-monitoring"></a>

Amazon MSK ist in Amazon integriert, CloudWatch sodass Sie Metriken für Ihren MSK-Serverless-Cluster sammeln, anzeigen und analysieren können. Die in der folgenden Tabelle aufgeführten Metriken sind für alle Serverless-Cluster verfügbar. Da diese Metriken als einzelne Datenpunkte für jede Partition im Thema veröffentlicht werden, empfehlen wir, sie als SUM-Statistik zu betrachten, um eine Übersicht auf Themenebene zu erhalten.

Amazon MSK veröffentlicht `PerSec` Metriken mit einer CloudWatch Frequenz von einmal pro Minute. Das bedeutet, dass die SUM-Statistik für einen Zeitraum von einer Minute die Daten pro Sekunde für `PerSec`-Metriken genau wiedergibt. Verwenden Sie den folgenden CloudWatch mathematischen Ausdruck, um Daten pro Sekunde für einen Zeitraum von mehr als einer Minute zu sammeln:. `m1 * 60/PERIOD(m1)`


**Auf der DEFAULT-Überwachungsebene verfügbare Metriken**  

| Name | Wenn sichtbar | Dimensionen | Description | 
| --- | --- | --- | --- | 
| BytesInPerSec | Nachdem ein Produzent zu einem Thema geschrieben hat | Cluster-Name, Thema |  Die Anzahl der Bytes, die pro Sekunde von Clients empfangen werden. Diese Metrik ist für jedes Thema verfügbar.  | 
| BytesOutPerSec | Nachdem eine Verbrauchergruppe von einem Thema konsumiert hat | Cluster-Name, Thema |  Die Anzahl der Bytes, die pro Sekunde an Clients gesendet werden. Diese Metrik ist für jedes Thema verfügbar.  | 
| FetchMessageConversionsPerSec | Nachdem eine Verbrauchergruppe von einem Thema konsumiert hat | Cluster-Name, Thema |  Die Anzahl der Abrufnachrichten-Konvertierungen pro Sekunde für den Broker.  | 
| EstimatedMaxTimeLag | Nachdem eine Verbrauchergruppe von einem Thema konsumiert hat | Cluster-Name, Verbrauchergruppe, Thema  | Eine Zeitschätzung der MaxOffsetLag Metrik. | 
| MaxOffsetLag | Nachdem eine Verbrauchergruppe von einem Thema konsumiert hat | Cluster-Name, Verbrauchergruppe, Thema  | Die maximale Offset-Verzögerung für alle Partitionen in einem Thema. | 
| MessagesInPerSec | Nachdem ein Produzent zu einem Thema geschrieben hat | Cluster-Name, Thema | Die Anzahl der Nachrichten, die pro Sekunde für das Thema eingehen. | 
| ProduceMessageConversionsPerSec | Nachdem ein Produzent zu einem Thema geschrieben hat | Cluster-Name, Thema | Die Anzahl der Produzenten-Nachrichtenkonvertierungen pro Sekunde für den Broker. | 
| SumOffsetLag | Nachdem eine Verbrauchergruppe von einem Thema konsumiert hat | Cluster-Name, Verbrauchergruppe, Thema  | Die aggregierte Offset-Verzögerung für alle Partitionen in einem Thema. | 

**So zeigen Sie MSK.-Serverless-Metriken an**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Wählen Sie im Navigationsbereich unter **Metriken** **Alle Metriken** aus.

1. Suchen Sie in den Metriken nach dem Begriff **kafka**.

1. Wählen Sie **AWS/Kafka / Cluster-Name, Thema** oder **AWS/Kafka / Cluster-Name, Verbrauchergruppe, Thema**, um verschiedene Metriken anzuzeigen.