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.
# Sicherheit in Amazon MSK
Cloud-Sicherheit hat AWS höchste Priorität. Als AWS Kunde profitieren Sie von einer Rechenzentrums- und Netzwerkarchitektur, die darauf ausgelegt sind, die Anforderungen der sicherheitssensibelsten Unternehmen zu erfüllen.
Sicherheit ist eine gemeinsame Verantwortung von Ihnen AWS und Ihnen. Das [Modell der geteilten Verantwortung](https://aws.amazon.com/compliance/shared-responsibility-model/) beschreibt dies als Sicherheit *der* Cloud und Sicherheit *in* der Cloud:
+ **Sicherheit der Cloud** — AWS ist verantwortlich für den Schutz der Infrastruktur, die AWS Dienste in der AWS Cloud ausführt. AWS bietet Ihnen auch Dienste, die Sie sicher nutzen können. Externe Prüfer testen und verifizieren regelmäßig die Wirksamkeit unserer Sicherheitsmaßnahmen im Rahmen der [AWS](https://aws.amazon.com/compliance/programs/) . Informationen zu den Compliance-Programmen, die für Amazon Managed Streaming für Apache Kafka gelten, finden Sie unter [Im Rahmen des Compliance-Programms zugelassene Amazon-Web-Services](https://aws.amazon.com/compliance/services-in-scope/).
+ **Sicherheit in der Cloud** — Ihre Verantwortung richtet sich nach dem AWS Dienst, den Sie nutzen. Sie sind auch für andere Faktoren verantwortlich, einschließlich der Vertraulichkeit Ihrer Daten, für die Anforderungen Ihres Unternehmens und für die geltenden Gesetze und Vorschriften.
Diese Dokumentation zeigt Ihnen, wie Sie das Modell der geteilten Verantwortung bei der Verwendung von Amazon MSK einsetzen können. Die folgenden Themen zeigen Ihnen, wie Sie Amazon MKS konfigurieren, um Ihre Sicherheits- und Compliance-Ziele zu erreichen. Sie lernen auch, wie Sie andere Amazon Web Services verwenden, die Sie bei der Überwachung und Sicherung Ihrer Amazon-MSK-Ressourcen unterstützen.
**Topics**
+ [
# Datenschutz in Amazon Managed Streaming für Apache Kafka
](data-protection.md)
+ [
# Authentifizierung und Autorisierung für Amazon MSK APIs
](security-iam.md)
+ [
# Authentifizierung und Autorisierung für Apache Kafka APIs
](kafka_apis_iam.md)
+ [
# Ändern der Sicherheitsgruppe eines Amazon-MSK-Clusters
](change-security-group.md)
+ [
# Steuern Sie den Zugriff auf ZooKeeper Apache-Knoten in Ihrem Amazon MSK-Cluster
](zookeeper-security.md)
+ [
# Compliance-Validierung für Amazon Managed Streaming für Apache Kafka
](MSK-compliance.md)
+ [
# Ausfallsicherheit in Amazon Managed Streaming für Apache Kafka
](disaster-recovery-resiliency.md)
+ [
# Infrastruktursicherheit in Amazon Managed Streaming für Apache Kafka
](infrastructure-security.md)
# Datenschutz in Amazon Managed Streaming für Apache Kafka
Das [Modell der AWS gemeinsamen Verantwortung](https://aws.amazon.com/compliance/shared-responsibility-model/) gilt für den Datenschutz in Amazon Managed Streaming for Apache Kafka. Wie in diesem Modell beschrieben, AWS ist verantwortlich für den Schutz der globalen Infrastruktur, auf der AWS Cloud alle Systeme laufen. Sie sind dafür verantwortlich, die Kontrolle über Ihre in dieser Infrastruktur gehosteten Inhalte zu behalten. Sie sind auch für die Sicherheitskonfiguration und die Verwaltungsaufgaben für die von Ihnen verwendeten AWS-Services verantwortlich. Weitere Informationen zum Datenschutz finden Sie unter [Häufig gestellte Fragen zum Datenschutz](https://aws.amazon.com/compliance/data-privacy-faq/). Informationen zum Datenschutz in Europa finden Sie im Blog-Beitrag [AWS -Modell der geteilten Verantwortung und in der DSGVO](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) im *AWS -Sicherheitsblog*.
Aus Datenschutzgründen empfehlen wir, dass Sie AWS-Konto Anmeldeinformationen schützen und einzelne Benutzer mit AWS IAM Identity Center oder AWS Identity and Access Management (IAM) einrichten. So erhält jeder Benutzer nur die Berechtigungen, die zum Durchführen seiner Aufgaben erforderlich sind. Außerdem empfehlen wir, die Daten mit folgenden Methoden schützen:
+ Verwenden Sie für jedes Konto die Multi-Faktor-Authentifizierung (MFA).
+ Wird verwendet SSL/TLS , um mit AWS Ressourcen zu kommunizieren. Wir benötigen TLS 1.2 und empfehlen TLS 1.3.
+ Richten Sie die API und die Protokollierung von Benutzeraktivitäten mit ein AWS CloudTrail. Informationen zur Verwendung von CloudTrail Pfaden zur Erfassung von AWS Aktivitäten finden Sie unter [Arbeiten mit CloudTrail Pfaden](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) im *AWS CloudTrail Benutzerhandbuch*.
+ Verwenden Sie AWS Verschlüsselungslösungen zusammen mit allen darin enthaltenen Standardsicherheitskontrollen AWS-Services.
+ Verwenden Sie erweiterte verwaltete Sicherheitsservices wie Amazon Macie, die dabei helfen, in Amazon S3 gespeicherte persönliche Daten zu erkennen und zu schützen.
+ Wenn Sie für den Zugriff AWS über eine Befehlszeilenschnittstelle oder eine API FIPS 140-3-validierte kryptografische Module benötigen, verwenden Sie einen FIPS-Endpunkt. Weitere Informationen über verfügbare FIPS-Endpunkte finden Sie unter [Federal Information Processing Standard (FIPS) 140-3](https://aws.amazon.com/compliance/fips/).
Wir empfehlen dringend, in Freitextfeldern, z. B. im Feld **Name**, keine vertraulichen oder sensiblen Informationen wie die E-Mail-Adressen Ihrer Kunden einzugeben. Dies gilt auch, wenn Sie mit Amazon MSK oder anderen AWS-Services über die Konsole AWS CLI, API oder AWS SDKs arbeiten. Alle Daten, die Sie in Tags oder Freitextfelder eingeben, die für Namen verwendet werden, können für Abrechnungs- oder Diagnoseprotokolle verwendet werden. Wenn Sie eine URL für einen externen Server bereitstellen, empfehlen wir dringend, keine Anmeldeinformationen zur Validierung Ihrer Anforderung an den betreffenden Server in die URL einzuschließen.
**Topics**
+ [
# Amazon-MSK-Verschlüsselung
](msk-encryption.md)
+ [
# Erste Schritte mit der Amazon MSK-Verschlüsselung
](msk-working-with-encryption.md)
+ [
# Verwenden Sie Amazon MSK APIs mit Interface VPC-Endpunkten
](privatelink-vpc-endpoints.md)
# Amazon-MSK-Verschlüsselung
Amazon MSK bietet Datenverschlüsselungsoptionen, mit denen Sie strenge Anforderungen an die Datenverwaltung erfüllen können. Die Zertifikate, die Amazon MSK für die Verschlüsselung verwendet, müssen alle 13 Monate erneuert werden. Amazon MSK erneuert diese Zertifikate automatisch für alle Cluster. Express-Broker-Cluster bleiben in dem `ACTIVE` Zustand, in dem Amazon MSK den Vorgang zur Aktualisierung des Zertifikats startet. Für Standard-Broker-Cluster legt Amazon MSK den Status des Clusters auf den `MAINTENANCE` Zeitpunkt fest, zu dem der Vorgang zur Zertifikatsaktualisierung gestartet wird. MSK setzt den Wert auf den `ACTIVE` Zeitpunkt zurück, zu dem die Aktualisierung abgeschlossen ist. Während der Zertifikatsaktualisierung eines Clusters können Sie weiterhin Daten erzeugen und verwenden, aber Sie können keine Aktualisierungsvorgänge für den Cluster ausführen.
## Amazon MSK-Verschlüsselung im Ruhezustand
Amazon MSK wird in [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (KMS) integriert, um transparente serverseitige Verschlüsselung zu ermöglichen. Amazon MQ verschlüsselt stets Ihre Daten im Ruhezustand. Wenn Sie einen MSK-Cluster erstellen, können Sie den AWS KMS key angeben, den Amazon MSK zur Verschlüsselung Ihrer Daten im Ruhezustand verwenden soll. Wenn Sie keinen KMS-Schlüssel angeben, erstellt Amazon MSK einen [Von AWS verwalteter Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) für Sie und verwendet ihn in Ihrem Namen. Weitere Informationen über KMS-Schlüssel finden Sie unter [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#kms_keys) im *Entwicklerhandbuch zu AWS Key Management Service *.
## Amazon MSK-Verschlüsselung bei der Übertragung
Amazon MSK verwendet TLS 1.2. Daten werden standardmäßig während der Übertragung zwischen den Brokern Ihres MSK-Clusters verschlüsselt. Sie können diese Standardeinstellung beim Erstellen des Clusters außer Kraft setzen.
Für die Kommunikation zwischen Clients und Brokern müssen Sie eine der folgenden drei Einstellungen angeben:
+ Nur Daten mit TLS-Verschlüsselung zulassen. Dies ist die Standardeinstellung.
+ Sowohl Klartextdaten als auch Daten mit TLS-Verschlüsselung zulassen
+ Nur Klartextdaten zulassen
Amazon MSK-Broker verwenden öffentliche AWS Certificate Manager Zertifikate. Daher vertraut jeder Vertrauensspeicher, der Amazon Trust Services vertraut, auch den Zertifikaten von Amazon-MSK-Brokern.
Während wir dringend empfehlen, die Verschlüsselung während der Übertragung zu aktivieren, kann dies zusätzliche CPU-Kosten und einige Millisekunden Latenz verursachen. Die meisten Anwendungsfälle reagieren jedoch nicht empfindlich auf diese Unterschiede, und das Ausmaß der Auswirkungen hängt von der Konfiguration Ihres Clusters, Ihrer Clients und Ihres Nutzungsprofils ab.
# Erste Schritte mit der Amazon MSK-Verschlüsselung
Beim Erstellen eines MSK-Clusters können Sie Verschlüsselungseinstellungen im JSON-Format angeben. Im Folgenden wird ein -Beispiel gezeigt.
```
{
"EncryptionAtRest": {
"DataVolumeKMSKeyId": "arn:aws:kms:us-east-1:123456789012:key/abcdabcd-1234-abcd-1234-abcd123e8e8e"
},
"EncryptionInTransit": {
"InCluster": true,
"ClientBroker": "TLS"
}
}
```
Für `DataVolumeKMSKeyId` können Sie einen [vom Kunden verwalteten Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) oder den Von AWS verwalteter Schlüssel für MSK in Ihrem Konto angeben (`alias/aws/kafka`). Wenn Sie nichts angeben`EncryptionAtRest`, verschlüsselt Amazon MSK Ihre ruhenden Daten trotzdem unter dem. Von AWS verwalteter Schlüssel Um festzustellen, welchen Schlüssel Ihr Cluster verwendet, senden Sie eine `GET`-Anforderung oder rufen Sie den `DescribeCluster`-API-Vorgang auf.
Für `EncryptionInTransit` ist der Standardwert von `InCluster` auf Wahr festgelegt, aber Sie können ihn auf Falsch setzen, wenn Sie Ihre Daten bei der Übergabe zwischen Brokern nicht von Amazon MSK verschlüsseln lassen möchten.
Um den Verschlüsselungsmodus für die Übertragung von Daten zwischen Clients und Brokern anzugeben, legen Sie `ClientBroker` auf einen der drei Werte folgenden fest: `TLS`, `TLS_PLAINTEXT`, oder `PLAINTEXT`.
**Topics**
+ [
# Geben Sie die Verschlüsselungseinstellungen an, wenn Sie einen Amazon MSK-Cluster erstellen
](msk-working-with-encryption-cluster-create.md)
+ [
# Testen Sie die Amazon MSK TLS-Verschlüsselung
](msk-working-with-encryption-test-tls.md)
# Geben Sie die Verschlüsselungseinstellungen an, wenn Sie einen Amazon MSK-Cluster erstellen
In diesem Prozess wird beschrieben, wie Verschlüsselungseinstellungen bei der Erstellung eines Amazon MSK-Clusters angegeben werden.
**Geben Sie bei der Erstellung eines Clusters die Verschlüsselungseinstellungen an**
1. Speichern Sie den Inhalt des vorherigen Beispiels in einer Datei und geben Sie der Datei einen beliebigen Namen. Nennen Sie sie beispielsweise „`encryption-settings.json`“.
1. Führen Sie den `create-cluster`-Befehl aus, und weisen Sie mithilfe der `encryption-info`-Option auf die Datei, in der Sie Ihr Konfigurations-JSON gespeichert haben. Im Folgenden wird ein -Beispiel gezeigt. *\$1YOUR MSK VERSION\$1*Ersetzen Sie es durch eine Version, die der Apache Kafka-Client-Version entspricht. Weitere Informationen zum Auffinden der MSK-Cluster-Version finden Sie unter [Ermitteln Sie Ihre MSK-Cluster-Version](create-topic.md#find-msk-cluster-version). Beachten Sie, dass die Verwendung einer Apache-Kafka-Client-Version, die nicht mit Ihrer MSK-Cluster-Version identisch ist, zu Beschädigung, Verlust und Ausfallzeiten von Apache-Kafka-Daten führen kann.
```
aws kafka create-cluster --cluster-name "ExampleClusterName" --broker-node-group-info file://brokernodegroupinfo.json --encryption-info file://encryptioninfo.json --kafka-version "{YOUR MSK VERSION}" --number-of-broker-nodes 3
```
Im Folgenden finden Sie ein Beispiel für eine erfolgreiche Antwort nach der Ausführung dieses Befehls.
```
{
"ClusterArn": "arn:aws:kafka:us-east-1:123456789012:cluster/SecondTLSTest/abcdabcd-1234-abcd-1234-abcd123e8e8e",
"ClusterName": "ExampleClusterName",
"State": "CREATING"
}
```
# Testen Sie die Amazon MSK TLS-Verschlüsselung
In diesem Prozess wird beschrieben, wie die TLS-Verschlüsselung auf Amazon MSK getestet wird.
**So testen Sie die TLS-Verschlüsselung**
1. Erstellen Sie einen Client-Computer entsprechend der Anweisungen in [Schritt 3: Einen Client-Computer erstellen](create-client-machine.md).
1. Installieren Sie Apache Kafka auf dem Client-Computer.
1. In diesem Beispiel verwenden wir den JVM-Vertrauensspeicher, um mit dem MSK-Cluster zu kommunizieren. Erstellen Sie dazu zunächst einen Ordner mit dem Namen `/tmp` auf dem Client-Computer. Wechseln Sie dann zum Ordner „`bin`“ der Apache Kafka-Installation und führen Sie den folgenden Befehl aus. (Ihr JVM-Pfad kann sich unterscheiden.)
```
cp /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.201.b09-0.amzn2.x86_64/jre/lib/security/cacerts /tmp/kafka.client.truststore.jks
```
1. Wenn Sie sich noch im `bin`-Ordner der Apache Kafka-Installation auf dem Client-Computer befinden, erstellen Sie eine Textdatei `client.properties` mit dem folgenden Inhalt.
```
security.protocol=SSL
ssl.truststore.location=/tmp/kafka.client.truststore.jks
```
1. Führen Sie den folgenden Befehl auf einem Computer aus, auf dem der AWS CLI installiert ist, und *clusterARN* ersetzen Sie ihn durch den ARN Ihres Clusters.
```
aws kafka get-bootstrap-brokers --cluster-arn clusterARN
```
Ein erfolgreiches Ergebnis sieht wie folgt aus. Speichern Sie dieses Ergebnis, da Sie es für den nächsten Schritt benötigen.
```
{
"BootstrapBrokerStringTls": "a-1.example.g7oein.c2.kafka.us-east-1.amazonaws.com:0123,a-3.example.g7oein.c2.kafka.us-east-1.amazonaws.com:0123,a-2.example.g7oein.c2.kafka.us-east-1.amazonaws.com:0123"
}
```
1. Führen Sie den folgenden Befehl aus und *BootstrapBrokerStringTls* ersetzen Sie ihn durch einen der Broker-Endpunkte, die Sie im vorherigen Schritt erhalten haben.
```
/bin/kafka-console-producer.sh --broker-list BootstrapBrokerStringTls --producer.config client.properties --topic TLSTestTopic
```
1. Öffnen Sie ein neues Befehlsfenster und stellen Sie eine Verbindung zu demselben Client-Computer her. Führen Sie dann den folgenden Befehl aus, um einen Konsolenverbraucher zu erstellen.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBrokerStringTls --consumer.config client.properties --topic TLSTestTopic
```
1. Geben Sie im Produzent-Fenster eine Textnachricht gefolgt von einem Zeilenumbruch ein, und suchen Sie im Verbraucher-Fenster nach derselben Nachricht. Amazon MSK hat diese Nachricht während der Übertragung verschlüsselt.
Weitere Informationen zum Konfigurieren von Apache Kafka-Clients für die Arbeit mit verschlüsselten Daten finden Sie unter [Konfigurieren von Kafka-Clients](https://kafka.apache.org/documentation/#security_configclients).
# Verwenden Sie Amazon MSK APIs mit Interface VPC-Endpunkten
Sie können einen Interface VPC Endpoint, powered by, verwenden AWS PrivateLink, um zu verhindern, dass der Datenverkehr zwischen Ihrer Amazon VPC und Amazon MSK das APIs Amazon-Netzwerk verlässt. Interface VPC Endpoints benötigen kein Internet-Gateway, kein NAT-Gerät, keine VPN-Verbindung oder AWS Direct Connect-Verbindung. [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html)ist eine AWS Technologie, die private Kommunikation zwischen AWS Services über eine elastic network interface mit Private IPs in Ihrer Amazon VPC ermöglicht. Weitere Informationen finden Sie unter [Amazon Virtual Private Cloud](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) und [Interface VPC Endpoints ()AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint).
Ihre Anwendungen können über Amazon MSK Provisioned und MSK Connect eine Verbindung herstellen. APIs AWS PrivateLink Erstellen Sie zunächst einen Interface-VPC-Endpunkt für Ihre Amazon MSK-API, um den Datenverkehr von und zu Ihren Amazon VPC-Ressourcen über den Interface VPC-Endpunkt zu starten. VPC-Endpunkte mit FIPS-fähiger Schnittstelle sind für US-Regionen verfügbar. [Weitere Informationen finden Sie unter Erstellen eines Schnittstellenendpunkts.](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint)
Mithilfe dieser Funktion können Ihre Apache Kafka-Clients die Verbindungszeichenfolgen dynamisch abrufen, um eine Connect mit MSK Provisioned- oder MSK Connect-Ressourcen herzustellen, ohne das Internet zu durchqueren, um die Verbindungszeichenfolgen abzurufen.
Wählen Sie beim Erstellen eines Interface VPC-Endpoints einen der folgenden Dienstnamen-Endpunkte aus:
**Für MSK Provisioned:**
+ Die folgenden Dienstnamen-Endpunkte werden für neue Verbindungen nicht mehr unterstützt:
+ com.amazonaws.region.kafka
+ com.amazonaws.region.kafka-fips (FIPS-fähig)
+ Der Dual-Stack-Endpunktservice, der sowohl den Datenverkehr als auch den Datenverkehr unterstützt, ist: IPv4 IPv6
+ aws.api.region.kafka-api
+ aws.api.region. kafka-api-fips (FIPS-fähig)
[Um die Dual-Stack-Endpunkte einzurichten, müssen Sie die Richtlinien für Dual-Stack- und FIPS-Endgeräte befolgen.](https://docs.aws.amazon.com/sdkref/latest/guide/feature-endpoints.html)
Wobei Region der Name Ihrer Region ist. Wählen Sie diesen Dienstnamen, um mit MSK APIs Provisioned-Compatible zu arbeiten. *Weitere Informationen finden Sie unter [Operationen](https://docs.aws.amazon.com/msk/1.0/apireference/operations.html) in der Datei 1.0/apireference/. https://docs.aws.amazon.com/msk/*
**Für MSK Connect:**
+ com.amazonaws.region.kafkaconnect
Wobei Region der Name Ihrer Region ist. Wählen Sie diesen Dienstnamen, um mit MSK APIs Connect-Compatible zu arbeiten. Weitere Informationen finden Sie unter [Aktionen](https://docs.aws.amazon.com/MSKC/latest/mskc/API_Operations.html) in der *Amazon MSK Connect API-Referenz.*
Weitere Informationen, einschließlich step-by-step Anweisungen zum Erstellen eines Schnittstellen-VPC-Endpunkts, finden Sie im *AWS PrivateLink Handbuch* unter [Erstellen eines Schnittstellenendpunkts](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint).
## Steuern Sie den Zugriff auf VPC-Endpunkte für Amazon MSK Provisioned oder MSK Connect APIs
Mit VPC-Endpunktrichtlinien können Sie den Zugriff steuern, indem Sie entweder eine Richtlinie an einen VPC-Endpunkt anhängen oder indem Sie zusätzliche Felder in einer Richtlinie verwenden, die einem IAM-Benutzer, einer Gruppe oder einer Rolle zugeordnet ist, um den Zugriff auf den angegebenen VPC-Endpunkt zu beschränken. Verwenden Sie die entsprechende Beispielrichtlinie, um Zugriffsberechtigungen für den MSK Provisioned- oder den MSK Connect-Dienst zu definieren.
Wenn Sie einem Endpunkt beim Erstellen keine Richtlinie zuordnen, ordnet Amazon VPC ihm eine Standardrichtlinie mit Vollzugriff auf den Service zu. IAM-identitätsbasierte Richtlinien oder servicespezifische Richtlinien werden von einer Endpunktrichtlinie nicht überschrieben oder ersetzt. Endpunktrichtlinien steuern unabhängig vom Endpunkt den Zugriff auf den angegebenen Service.
*Weitere Informationen finden Sie im Handbuch unter [Steuern des Zugriffs auf Dienste mit VPC-Endpunkten](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html).AWS PrivateLink *
------
#### [ MSK Provisioned — VPC policy example ]
**Schreibgeschützter Zugriff**
Diese Beispielrichtlinie kann an einen VPC-Endpunkt angehängt werden. Weitere Informationen finden Sie unter Steuern des Zugriffs auf Amazon VPC-Ressourcen. Es beschränkt die Aktionen darauf, nur Operationen über den VPC-Endpunkt aufzulisten und zu beschreiben, an den sie angehängt sind.
```
{
"Statement": [
{
"Sid": "MSKReadOnly",
"Principal": "*",
"Action": [
"kafka:List*",
"kafka:Describe*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
**MSK Provisioned — Beispiel für eine VPC-Endpunktrichtlinie**
Beschränken Sie den Zugriff auf einen bestimmten MSK-Cluster
Diese Beispielrichtlinie kann an einen VPC-Endpunkt angehängt werden. Es schränkt den Zugriff auf einen bestimmten Kafka-Cluster über den VPC-Endpunkt ein, an den er angehängt ist.
```
{
"Statement": [
{
"Sid": "AccessToSpecificCluster",
"Principal": "*",
"Action": "kafka:*",
"Effect": "Allow",
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/MyCluster"
}
]
}
```
------
#### [ MSK Connect — VPC endpoint policy example ]
**Konnektoren auflisten und einen neuen Connector erstellen**
Das Folgende ist ein Beispiel für eine Endpunktrichtlinie für MSK Connect. Diese Richtlinie ermöglicht es der angegebenen Rolle, Connectors aufzulisten und einen neuen Connector zu erstellen.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "MSKConnectPermissions",
"Effect": "Allow",
"Action": [
"kafkaconnect:ListConnectors",
"kafkaconnect:CreateConnector"
],
"Resource": "*",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/MyMSKConnectExecutionRole"
]
}
}
]
}
```
**MSK Connect — Beispiel für eine VPC-Endpunktrichtlinie**
Erlaubt nur Anfragen von einer bestimmten IP-Adresse in der angegebenen VPC
Das folgende Beispiel zeigt eine Richtlinie, die nur erlaubt, dass Anfragen, die von einer bestimmten IP-Adresse in der angegebenen VPC kommen, erfolgreich sind. Anfragen von anderen IP-Adressen schlagen fehl.
```
{
"Statement": [
{
"Action": "kafkaconnect:*",
"Effect": "Allow",
"Principal": "*",
"Resource": "*",
"Condition": {
"IpAddress": {
"aws:VpcSourceIp": "192.0.2.123"
},
"StringEquals": {
"aws:SourceVpc": "vpc-555555555555"
}
}
}
]
}
```
------
# Authentifizierung und Autorisierung für Amazon MSK APIs
AWS Identity and Access Management (IAM) hilft einem Administrator AWS-Service , den Zugriff auf Ressourcen sicher zu kontrollieren. AWS IAM-Administratoren steuern, wer *authentifiziert* (angemeldet) und *autorisiert* (im Besitz von Berechtigungen) ist, Amazon-MSK-Ressourcen zu nutzen. IAM ist ein Programm AWS-Service , das Sie ohne zusätzliche Kosten nutzen können.
**Topics**
+ [
# Funktionsweise von Amazon MKS mit IAM
](security_iam_service-with-iam.md)
+ [
# Beispiele für identitätsbasierte Amazon-MSK-Richtlinien
](security_iam_id-based-policy-examples.md)
+ [
# Servicebezogene Rollen für Amazon MSK
](using-service-linked-roles.md)
+ [
# AWS verwaltete Richtlinien für Amazon MSK
](security-iam-awsmanpol.md)
+ [
# Problembehandlung bei Amazon MSK-Identität und -Zugriff
](security_iam_troubleshoot.md)
# Funktionsweise von Amazon MKS mit IAM
Bevor Sie mit IAM den Zugriff auf Amazon MSK verwalten können, sollten Sie sich darüber informieren, welche IAM-Funktionen Sie mit Amazon MSK verwenden können. Einen allgemeinen Überblick darüber, wie Amazon MSK und andere AWS Services mit IAM zusammenarbeiten, finden Sie unter [AWS Services That Work with IAM im *IAM-Benutzerhandbuch*](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
**Topics**
+ [
# Identitätsbasierte Amazon-MSK-Richtlinien
](security_iam_service-with-iam-id-based-policies.md)
+ [
# Ressourcenbasierte Amazon-MSK-Richtlinien
](security_iam_service-with-iam-resource-based-policies.md)
+ [
# Autorisierung basierend auf Amazon-MSK-Tags
](security_iam_service-with-iam-tags.md)
+ [
# Amazon-MSK-IAM-Rollen
](security_iam_service-with-iam-roles.md)
# Identitätsbasierte Amazon-MSK-Richtlinien
Mit identitätsbasierten IAM-Richtlinien können Sie angeben, welche Aktionen und Ressourcen zugelassen oder abgelehnt werden. Darüber hinaus können Sie die Bedingungen festlegen, unter denen Aktionen zugelassen oder abgelehnt werden. Amazon MSK unterstützt bestimmte Aktionen, Ressourcen und Bedingungsschlüssel. Informationen zu sämtlichen Elementen, die Sie in einer JSON-Richtlinie verwenden, finden Sie in der [IAM-Referenz für JSON-Richtlinienelemente](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) im *IAM-Benutzerhandbuch*.
## Aktionen für identitätsbasierte Amazon MSK-Richtlinien
Administratoren können AWS JSON-Richtlinien verwenden, um festzulegen, wer Zugriff auf was hat. Das heißt, welcher **Prinzipal** **Aktionen** für welche **Ressourcen** und unter welchen **Bedingungen** ausführen kann.
Das Element `Action` einer JSON-Richtlinie beschreibt die Aktionen, mit denen Sie den Zugriff in einer Richtlinie zulassen oder verweigern können. Nehmen Sie Aktionen in eine Richtlinie auf, um Berechtigungen zur Ausführung des zugehörigen Vorgangs zu erteilen.
Richtlinienaktionen in Amazon MSK verwenden das folgende Präfix vor der Aktion: `kafka:`. Wenn Sie beispielsweise einem Benutzer die Berechtigung erteilen möchten, einen MSK-Cluster mit dem Amazon-MSK-API-Vorgang `DescribeCluster` zu beschreiben, nehmen Sie die Aktion `kafka:DescribeCluster` in die Richtlinie auf. Richtlinienanweisungen müssen entweder ein – `Action`oder ein `NotAction`-Element enthalten. Amazon MSK definiert einen eigenen Satz von Aktionen, die Aufgaben beschreiben, die Sie mit diesem Service durchführen können.
Bitte beachten Sie, dass bei Richtlinienaktionen für das MSK-Thema das `kafka-cluster` Präfix vor der Aktion APIs verwendet wird. Weitere Informationen finden Sie unter. [Semantik der Aktionen und Ressourcen der IAM-Autorisierungsrichtlinie](kafka-actions.md)
Um mehrere Aktionen in einer einzigen Anweisung anzugeben, trennen Sie sie wie folgt durch Kommata:
```
"Action": ["kafka:action1", "kafka:action2"]
```
Sie können auch Platzhalter verwenden, um mehrere Aktionen anzugeben. Beispielsweise können Sie alle Aktionen festlegen, die mit dem Wort `Describe` beginnen, einschließlich der folgenden Aktion:
```
"Action": "kafka:Describe*"
```
Eine Liste der Amazon-MSK-Aktionen finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für Amazon Managed Streaming für Apache Kafka](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonmanagedstreamingforapachekafka.html) im *IAM-Benutzerhandbuch*.
## Ressourcen für identitätsbasierte Amazon MSK-Richtlinien
Administratoren können mithilfe von AWS JSON-Richtlinien angeben, wer Zugriff auf was hat. Das heißt, welcher **Prinzipal** **Aktionen** für welche **Ressourcen** und unter welchen **Bedingungen** ausführen kann.
Das JSON-Richtlinienelement `Resource` gibt die Objekte an, auf welche die Aktion angewendet wird. Als Best Practice geben Sie eine Ressource mit dem zugehörigen [Amazon-Ressourcennamen (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html) an. Verwenden Sie für Aktionen, die keine Berechtigungen auf Ressourcenebene unterstützen, einen Platzhalter (\$1), um anzugeben, dass die Anweisung für alle Ressourcen gilt.
```
"Resource": "*"
```
Die Amazon-MSK-Instance-Ressource hat den folgenden ARN:
```
arn:${Partition}:kafka:${Region}:${Account}:cluster/${ClusterName}/${UUID}
```
Weitere Informationen zum Format von ARNs finden Sie unter [Amazon Resource Names (ARNs) und AWS Service Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
Wenn Sie beispielsweise die `CustomerMessages`-Instance in Ihrer Anweisung angeben möchten, verwenden Sie den folgenden ARN:
```
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/CustomerMessages/abcd1234-abcd-dcba-4321-a1b2abcd9f9f-2"
```
Um alle Instances anzugeben, die zu einem bestimmten Konto gehören, verwenden Sie den Platzhalter (\$1):
```
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/*"
```
Einige Amazon-MKS-Aktionen, z. B. das Erstellen von Ressourcen, können für bestimmte Ressourcen nicht ausgeführt werden. In diesen Fällen müssen Sie den Platzhalter (\$1) verwenden.
```
"Resource": "*"
```
Um mehrere Ressourcen in einer einzigen Anweisung anzugeben, trennen Sie sie durch Kommas. ARNs
```
"Resource": ["resource1", "resource2"]
```
Eine Liste der Amazon MSK-Ressourcentypen und ihrer ARNs Eigenschaften finden Sie unter [Von Amazon Managed Streaming for Apache Kafka definierte Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-resources-for-iam-policies) im *IAM-Benutzerhandbuch*. Informationen zu den Aktionen, mit denen Sie den ARN einzelner Ressourcen angeben können, finden Sie unter [Von Amazon Managed Streaming für Apache Kafka definierte Aktionen](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-actions-as-permissions).
## Bedingungsschlüssel für identitätsbasierte Amazon MSK-Richtlinien
Administratoren können mithilfe von AWS JSON-Richtlinien angeben, wer Zugriff auf was hat. Das heißt, welcher **Prinzipal** **Aktionen** für welche **Ressourcen** und unter welchen **Bedingungen** ausführen kann.
Das Element `Condition` gibt an, wann Anweisungen auf der Grundlage definierter Kriterien ausgeführt werden. Sie können bedingte Ausdrücke erstellen, die [Bedingungsoperatoren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) verwenden, z. B. ist gleich oder kleiner als, damit die Bedingung in der Richtlinie mit Werten in der Anforderung übereinstimmt. Eine Übersicht aller AWS globalen Bedingungsschlüssel finden Sie unter [Kontextschlüssel für AWS globale Bedingungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) im *IAM-Benutzerhandbuch*.
Amazon MSK definiert seinen eigenen Satz von Bedingungsschlüsseln und unterstützt auch die Verwendung einiger globaler Bedingungsschlüssel. Eine Übersicht aller AWS globalen Bedingungsschlüssel finden Sie unter [AWS Globale Bedingungskontextschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) im *IAM-Benutzerhandbuch*.
Eine Liste der Amazon-MSK-Bedingungsschlüssel finden Sie unter [Bedingungsschlüssel für Amazon Managed Streaming für Apache Kafka](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-policy-keys) im *IAM-Benutzerhandbuch*. Informationen dazu, mit welchen Aktionen und Ressourcen Sie einen Bedingungsschlüssel verwenden können, finden Sie unter [Von Amazon Managed Streaming für Apache Kafka definierte Aktionen](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonmanagedstreamingforkafka.html#amazonmanagedstreamingforkafka-actions-as-permissions).
## Beispiele für identitätsbasierte Amazon MSK-Richtlinien
Beispiele für identitätsbasierte Amazon-MSK-Richtlinien finden Sie unter [Beispiele für identitätsbasierte Amazon-MSK-Richtlinien](security_iam_id-based-policy-examples.md).
# Ressourcenbasierte Amazon-MSK-Richtlinien
Amazon MSK unterstützt eine Cluster-Richtlinie (auch als ressourcenbasierte Richtlinie bezeichnet) zur Verwendung mit Amazon-MSK-Clustern. Sie können eine Cluster-Richtlinie verwenden, um zu definieren, welche IAM-Prinzipale über kontoübergreifende Berechtigungen zum Einrichten einer privaten Konnektivität mit Ihrem Amazon-MSK-Cluster verfügen. Bei Verwendung mit der IAM-Client-Authentifizierung können Sie die Cluster-Richtlinie auch verwenden, um die Kafka-Datenebenen-Berechtigungen für die verbindenden Clients detailliert zu definieren.
Die maximale Größe, die für eine Cluster-Richtlinie unterstützt wird, beträgt 20 KB.
Ein Beispiel für die Konfiguration einer Cluster-Richtlinie finden Sie unter [Schritt 2: Eine Cluster-Richtlinie an den MSK-Cluster anhängen](mvpc-cluster-owner-action-policy.md).
# Autorisierung basierend auf Amazon-MSK-Tags
Sie können Amazon-MSK-Clustern Tags anhängen. Um den Zugriff auf der Grundlage von Tags zu steuern, geben Sie im Bedingungselement einer[ Richtlinie Tag-Informationen ](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html)an, indem Sie die Schlüssel `kafka:ResourceTag/key-name`, `aws:RequestTag/key-name`, oder Bedingung `aws:TagKeys` verwenden. Informationen zum Taggen von Amazon MSK-Ressourcen finden Sie unter. [Kennzeichnen Sie einen Amazon MSK-Cluster](msk-tagging.md)
Sie können den Cluster-Zugriff nur mit Hilfe von Tags steuern. Um Themen und Nutzergruppen zu taggen, müssen Sie in Ihren Richtlinien eine separate Erklärung ohne Stichwörter hinzufügen.
Ein Beispiel für eine identitätsbasierte Richtlinie zur Beschränkung des Zugriffs auf einen Cluster anhand der Tags in diesem Cluster finden Sie unter. [Zugreifen auf Amazon-MSK-Cluster anhand von Tags](security_iam_id-based-policy-examples-view-widget-tags.md)
Sie können Bedingungen in Ihrer identitätsbasierten Richtlinie verwenden, um den Zugriff auf Amazon-MSK-Ressourcen anhand von Tags zu steuern. Das folgende Beispiel zeigt eine Richtlinie, die es einem Benutzer ermöglicht, den Cluster zu beschreiben, seine Bootstrap-Broker abzurufen, seine Brokerknoten aufzulisten, ihn zu aktualisieren und zu löschen. Diese Richtlinie gewährt jedoch nur dann Berechtigungen, wenn das Cluster-Tag den Wert des betreffenden Benutzers `Owner` `username` hat. Die zweite Aussage in der folgenden Richtlinie ermöglicht den Zugriff auf die Themen im Cluster. Die erste Aussage in dieser Richtlinie autorisiert keinen Zugriff auf Themen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessClusterIfOwner",
"Effect": "Allow",
"Action": [
"kafka:Describe*",
"kafka:Get*",
"kafka:List*",
"kafka:Update*",
"kafka:Delete*"
],
"Resource": "arn:aws:kafka:us-east-1:123456789012:cluster/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Owner": "${aws:username}"
}
}
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:*Topic*",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:topic/*"
]
}
]
}
```
------
# Amazon-MSK-IAM-Rollen
Eine [IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) ist eine Entität in Ihrem Amazon–Web-Services-Konto mit spezifischen Berechtigungen.
## Verwenden temporärer Anmeldeinformationen mit Amazon MSK
Sie können temporäre Anmeldeinformationen verwenden, um sich über einen Verbund anzumelden, eine IAM-Rolle anzunehmen oder eine kontenübergreifende Rolle anzunehmen. Sie erhalten temporäre Sicherheitsanmeldedaten, indem Sie AWS STS API-Operationen wie [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)oder [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html)aufrufen.
Amazon MSK unterstützt die Verwendung temporärer Anmeldeinformationen.
## Service-verknüpfte Rollen
[Serviceverknüpfte Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) erlauben Amazon Web Services den Zugriff auf Ressourcen in anderen Services, um eine Aktion in Ihrem Auftrag auszuführen. Serviceverknüpfte Rollen werden in Ihrem IAM-Konto angezeigt und gehören zum Service. Ein -Administrator kann die Berechtigungen für serviceverknüpfte Rollen anzeigen, aber nicht bearbeiten.
Amazon MSK unterstützt serviceverknüpfte Rollen. Weitere Informationen zum Erstellen oder Verwalten von serviceverknüpften Amazon-MSK-Rollen finden Sie unter [Servicebezogene Rollen für Amazon MSK](using-service-linked-roles.md).
# Beispiele für identitätsbasierte Amazon-MSK-Richtlinien
Standardmäßig haben IAM-Benutzer und -Rollen keine Berechtigung zum Ausführen von Amazon-MSK-API-Aktionen. Ein Administrator muss IAM-Richtlinien erstellen, die Benutzern und Rollen die Berechtigung zum Ausführen bestimmter API-Operationen für die angegebenen Ressourcen gewähren, die diese benötigen. Der Administrator muss diese Richtlinien anschließend den IAM-Benutzern oder -Gruppen anfügen, die diese Berechtigungen benötigen.
Informationen dazu, wie Sie unter Verwendung dieser beispielhaften JSON-Richtliniendokumente eine identitätsbasierte IAM-Richtlinie erstellen, finden Sie unter [Erstellen von Richtlinien auf der JSON-Registerkarte](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) im *IAM-Benutzerhandbuch*.
**Topics**
+ [
# Best Practices für Richtlinien
](security_iam_service-with-iam-policy-best-practices.md)
+ [
# Gewähren der Berechtigung zur Anzeige der eigenen Berechtigungen für Benutzer
](security_iam_id-based-policy-examples-view-own-permissions.md)
+ [
# Zugriff auf einen Amazon-MSK-Cluster
](security_iam_id-based-policy-examples-access-one-cluster.md)
+ [
# Zugreifen auf Amazon-MSK-Cluster anhand von Tags
](security_iam_id-based-policy-examples-view-widget-tags.md)
# Best Practices für Richtlinien
Identitätsbasierte Richtlinien können festlegen, ob jemand Amazon-MSK-Ressourcen in Ihrem Konto erstellen, darauf zugreifen oder löschen kann. Dies kann zusätzliche Kosten für Ihr verursachen AWS-Konto. Beachten Sie beim Erstellen oder Bearbeiten identitätsbasierter Richtlinien die folgenden Richtlinien und Empfehlungen:
+ **Erste Schritte mit AWS verwalteten Richtlinien und Umstellung auf Berechtigungen mit den geringsten Rechten** — Verwenden Sie die *AWS verwalteten Richtlinien*, die Berechtigungen für viele gängige Anwendungsfälle gewähren, um damit zu beginnen, Ihren Benutzern und Workloads Berechtigungen zu gewähren. Sie sind in Ihrem verfügbar. AWS-Konto Wir empfehlen Ihnen, die Berechtigungen weiter zu reduzieren, indem Sie vom AWS Kunden verwaltete Richtlinien definieren, die speziell auf Ihre Anwendungsfälle zugeschnitten sind. Weitere Informationen finden Sie unter [Von AWS verwaltete Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) oder [Von AWS verwaltete Richtlinien für Auftragsfunktionen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) im *IAM-Benutzerhandbuch*.
+ **Anwendung von Berechtigungen mit den geringsten Rechten** – Wenn Sie mit IAM-Richtlinien Berechtigungen festlegen, gewähren Sie nur die Berechtigungen, die für die Durchführung einer Aufgabe erforderlich sind. Sie tun dies, indem Sie die Aktionen definieren, die für bestimmte Ressourcen unter bestimmten Bedingungen durchgeführt werden können, auch bekannt als *die geringsten Berechtigungen*. Weitere Informationen zur Verwendung von IAM zum Anwenden von Berechtigungen finden Sie unter [ Richtlinien und Berechtigungen in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) im *IAM-Benutzerhandbuch*.
+ **Verwenden von Bedingungen in IAM-Richtlinien zur weiteren Einschränkung des Zugriffs** – Sie können Ihren Richtlinien eine Bedingung hinzufügen, um den Zugriff auf Aktionen und Ressourcen zu beschränken. Sie können beispielsweise eine Richtlinienbedingung schreiben, um festzulegen, dass alle Anforderungen mithilfe von SSL gesendet werden müssen. Sie können auch Bedingungen verwenden, um Zugriff auf Serviceaktionen zu gewähren, wenn diese für einen bestimmten Zweck verwendet werden AWS-Service, z. CloudFormation B. Weitere Informationen finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingung](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) im *IAM-Benutzerhandbuch*.
+ **Verwenden von IAM Access Analyzer zur Validierung Ihrer IAM-Richtlinien, um sichere und funktionale Berechtigungen zu gewährleisten** – IAM Access Analyzer validiert neue und vorhandene Richtlinien, damit die Richtlinien der IAM-Richtliniensprache (JSON) und den bewährten IAM-Methoden entsprechen. IAM Access Analyzer stellt mehr als 100 Richtlinienprüfungen und umsetzbare Empfehlungen zur Verfügung, damit Sie sichere und funktionale Richtlinien erstellen können. Weitere Informationen finden Sie unter [Richtlinienvalidierung mit IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) im *IAM-Benutzerhandbuch*.
+ **Multi-Faktor-Authentifizierung (MFA) erforderlich** — Wenn Sie ein Szenario haben, das IAM-Benutzer oder einen Root-Benutzer in Ihrem System erfordert AWS-Konto, aktivieren Sie MFA für zusätzliche Sicherheit. Um MFA beim Aufrufen von API-Vorgängen anzufordern, fügen Sie Ihren Richtlinien MFA-Bedingungen hinzu. Weitere Informationen finden Sie unter [Sicherer API-Zugriff mit MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) im *IAM-Benutzerhandbuch*.
Weitere Informationen zu bewährten Methoden in IAM finden Sie unter [Best Practices für die Sicherheit in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) im *IAM-Benutzerhandbuch*.
# Gewähren der Berechtigung zur Anzeige der eigenen Berechtigungen für Benutzer
In diesem Beispiel wird gezeigt, wie Sie eine Richtlinie erstellen, die IAM-Benutzern die Berechtigung zum Anzeigen der eingebundenen Richtlinien und verwalteten Richtlinien gewährt, die ihrer Benutzeridentität angefügt sind. Diese Richtlinie umfasst Berechtigungen zum Ausführen dieser Aktion auf der Konsole oder programmgesteuert mithilfe der API oder. AWS CLI AWS
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
```
# Zugriff auf einen Amazon-MSK-Cluster
In diesem Beispiel möchten Sie einem IAM-Benutzer in Ihrem Amazon-Web-Services-Konto den Zugriff auf einen Ihrer Cluster gewähren, `purchaseQueriesCluster`. Diese Richtlinie ermöglicht es dem Benutzer, den Cluster zu beschreiben, seine Bootstrap-Broker abrufen, seine Broker-Knoten auflisten und ihn zu aktualisieren.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"UpdateCluster",
"Effect":"Allow",
"Action":[
"kafka:Describe*",
"kafka:Get*",
"kafka:List*",
"kafka:Update*"
],
"Resource":"arn:aws:kafka:us-east-1:012345678012:cluster/purchaseQueriesCluster/abcdefab-1234-abcd-5678-cdef0123ab01-2"
}
]
}
```
------
# Zugreifen auf Amazon-MSK-Cluster anhand von Tags
Sie können Bedingungen in Ihrer identitätsbasierten Richtlinie verwenden, um den Zugriff auf Amazon-MSK-Ressourcen anhand von Tags zu steuern. In diesem Beispiel wird dargestellt, wie Sie eine Richtlinie erstellen können, mit der Benutzer den Cluster beschreiben, seine Bootstrap-Broker abrufen, seine Broker-Knoten auflisten, ihn aktualisieren und löschen können. Die Berechtigung wird jedoch nur gewährt, wenn der Wert des Cluster-Tags „`Owner`“ dem Benutzernamen entspricht.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessClusterIfOwner",
"Effect": "Allow",
"Action": [
"kafka:Describe*",
"kafka:Get*",
"kafka:List*",
"kafka:Update*",
"kafka:Delete*"
],
"Resource": "arn:aws:kafka:us-east-1:012345678012:cluster/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Owner": "${aws:username}"
}
}
}
]
}
```
------
Sie können diese Richtlinie den IAM-Benutzern in Ihrem Konto anfügen. Wenn ein Benutzer mit dem Namen `richard-roe` versucht, einen MSK-Cluster zu aktualisieren, muss der Cluster mit dem Tag `Owner=richard-roe` oder `owner=richard-roe` markiert sein. Andernfalls wird der Zugriff abgelehnt. Der Tag-Schlüssel `Owner` der Bedingung stimmt sowohl mit `Owner` als auch mit `owner` überein, da die Namen von Bedingungsschlüsseln nicht zwischen Groß- und Kleinschreibung unterscheiden. Weitere Informationen finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingung](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) im *IAM-Benutzerhandbuch*.
# Servicebezogene Rollen für Amazon MSK
Amazon MSK verwendet AWS Identity and Access Management (IAM) [serviceverknüpfte](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) Rollen. Eine serviceverknüpfte Rolle ist eine einzigartige Art von IAM-Rolle, die direkt mit Amazon MSK verknüpft ist. Servicebezogene Rollen sind von Amazon MSK vordefiniert und beinhalten alle Berechtigungen, die der Service benötigt, um andere AWS Services in Ihrem Namen aufzurufen.
Eine serviceverknüpfte Rolle macht die Einrichtung von Amazon MSK einfacher, da Sie die erforderlichen Berechtigungen nicht manuell hinzufügen müssen. Amazon MSK definiert die Berechtigungen seiner serviceverknüpften Rollen. Sofern nicht anders definiert, kann nur Amazon MSK seine Rollen übernehmen. Die definierten Berechtigungen umfassen die Vertrauens- und Berechtigungsrichtlinie. Diese Berechtigungsrichtlinie kann keinen anderen IAM-Entitäten zugewiesen werden.
Informationen zu anderen Services, die serviceverknüpfte Rollen unterstützen, finden Sie unter [Amazon Web Services, die mit IAM funktionieren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html). Suchen Sie nach den Services, für die **Ja** in der Spalte **Serviceverknüpfte Rolle** angegeben ist. Wählen Sie über einen Link **Ja** aus, um die Dokumentation zu einer serviceverknüpften Rolle für diesen Service anzuzeigen.
**Topics**
+ [Berechtigungen von serviceverknüpften Rollen](slr-permissions.md)
+ [Erstellen einer serviceverknüpften Rolle](create-slr.md)
+ [Bearbeiten einer serviceverknüpften Rolle](edit-slr.md)
+ [Unterstützte Regionen für serviceverknüpfte -Rollen](slr-regions.md)
# Serviceverknüpfte Rollenberechtigungen für Amazon MSK
Amazon MSK verwendet die serviceverknüpfte Rolle namens **AWSServiceRoleForKafka**. Amazon MSK verwendet diese Rolle für den Zugriff auf Ihre Ressourcen und für die Ausführung von Vorgängen wie:
+ `*NetworkInterface` – Netzwerkschnittstellen im Kundenkonto erstellen und verwalten, die Cluster-Broker für Clients in der Kunden-VPC zugänglich machen.
+ `*VpcEndpoints`— VPC-Endpunkte im Kundenkonto verwalten, die Cluster-Broker für Kunden in der Kunden-VPC zugänglich machen, die sie verwenden. AWS PrivateLink Amazon MSK verwendet Berechtigungen für `DescribeVpcEndpoints`, `ModifyVpcEndpoint` und `DeleteVpcEndpoints`.
+ `secretsmanager`— Kundenanmeldedaten verwalten mit. AWS Secrets Manager
+ `GetCertificateAuthorityCertificate` – Das Zertifikat für Ihre private Zertifizierungsstelle abrufen.
+ `*Ipv6Addresses`— Netzwerkschnittstellen im Kundenkonto IPv6 Adressen zuweisen und deren Zuweisung aufheben, um die IPv6 Konnektivität für MSK-Cluster zu aktivieren.
+ `ModifyNetworkInterfaceAttribute`— Ändern Sie die Netzwerkschnittstellenattribute im Kundenkonto, um die IPv6 Einstellungen für die MSK-Cluster-Konnektivität zu konfigurieren.
Diese verwaltete Richtlinie ist mit der folgenden serviceverknüpften Rolle verbunden: `KafkaServiceRolePolicy`. Aktualisierungen dieser Richtlinie finden Sie unter [KafkaServiceRolePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/KafkaServiceRolePolicy.html).
Die serviceverknüpfte Rolle AWSServiceRoleForKafka vertraut darauf, dass die folgenden Services die Rolle annehmen:
+ `kafka.amazonaws.com`
Die Rollenberechtigungsrichtlinie erlaubt es Amazon MSK, die folgenden Aktionen für Ressourcen durchzuführen.
Sie müssen Berechtigungen konfigurieren, damit eine juristische Stelle von IAM (z. B. Benutzer, Gruppe oder Rolle) eine serviceverknüpfte Rolle erstellen, bearbeiten oder löschen kann. Weitere Informationen finden Sie unter [serviceverknüpfte Rollenberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) im *IAM-Benutzerhandbuch*.
# Eine serviceverknüpfte Rolle für Amazon MSK erstellen
Sie müssen eine serviceverknüpfte Rolle nicht manuell erstellen. Wenn Sie einen Amazon MSK-Cluster in der AWS-Managementkonsole, der oder der AWS API erstellen AWS CLI, erstellt Amazon MSK die serviceverknüpfte Rolle für Sie.
Wenn Sie diese serviceverknüpfte Rolle löschen und sie dann erneut erstellen müssen, können Sie dasselbe Verfahren anwenden, um die Rolle in Ihrem Konto neu anzulegen. Wenn Sie einen Amazon-MSK-Cluster erstellen, erstellt Amazon MSK wieder die servicevereknüpfte Rolle für Sie.
# Eine serviceverknüpfte Rolle für Amazon MSK bearbeiten
Amazon MSK verhindert die Bearbeitung der serviceverknüpften Rolle AWSServiceRoleForKafka. Da möglicherweise verschiedene Entitäten auf die Rolle verweisen, kann der Rollenname nach dem Erstellen einer serviceverknüpften Rolle nicht mehr geändert werden. Sie können jedoch die Beschreibung der Rolle mit IAM bearbeiten. Weitere Informationen finden Sie unter [Bearbeiten einer serviceverknüpften Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) im *IAM-Benutzerhandbuch*.
# Unterstützte Regionen für Amazon MSK serviceverknüpfte Rollen
Amazon MSK unterstützt die Verwendung von serviceverknüpften Rollen in allen Regionen, in denen der Service verfügbar ist. Weitere Informationen finden Sie unter [AWS -Regionen und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html).
# AWS verwaltete Richtlinien für Amazon MSK
Eine AWS verwaltete Richtlinie ist eine eigenständige Richtlinie, die von erstellt und verwaltet AWS wird. AWS Verwaltete Richtlinien sind so konzipiert, dass sie Berechtigungen für viele gängige Anwendungsfälle bereitstellen, sodass Sie damit beginnen können, Benutzern, Gruppen und Rollen Berechtigungen zuzuweisen.
Beachten Sie, dass AWS verwaltete Richtlinien für Ihre speziellen Anwendungsfälle möglicherweise keine Berechtigungen mit den geringsten Rechten gewähren, da sie allen AWS Kunden zur Verfügung stehen. Wir empfehlen Ihnen, die Berechtigungen weiter zu reduzieren, indem Sie [vom Kunden verwaltete Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) definieren, die speziell auf Ihre Anwendungsfälle zugeschnitten sind.
Sie können die in AWS verwalteten Richtlinien definierten Berechtigungen nicht ändern. Wenn die in einer AWS verwalteten Richtlinie definierten Berechtigungen AWS aktualisiert werden, wirkt sich das Update auf alle Prinzidentitäten (Benutzer, Gruppen und Rollen) aus, denen die Richtlinie zugeordnet ist. AWS aktualisiert eine AWS verwaltete Richtlinie höchstwahrscheinlich, wenn eine neue Richtlinie eingeführt AWS-Service wird oder neue API-Operationen für bestehende Dienste verfügbar werden.
Weitere Informationen finden Sie unter [Von AWS verwaltete Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) im *IAM-Benutzerhandbuch*.
# AWS verwaltete Richtlinie: Amazon MSKFull Access
Diese Richtlinie gewährt Administratorberechtigungen, die einem Prinzipal vollen Zugriff auf alle Amazon-MSK-Aktionen erlauben. Die Berechtigungen in dieser Richtlinie sind wie folgt gruppiert:
+ Die Amazon-MSK-Berechtigungen erlauben alle Amazon-MSK-Aktionen.
+ **`Amazon EC2`Berechtigungen** — In dieser Richtlinie sind sie erforderlich, um die übergebenen Ressourcen in einer API-Anfrage zu validieren. Dadurch soll sichergestellt werden, dass Amazon MSK die Ressourcen erfolgreich mit einem Cluster nutzen kann. Die übrigen Amazon EC2 EC2-Berechtigungen in dieser Richtlinie ermöglichen es Amazon MSK, AWS Ressourcen zu erstellen, die erforderlich sind, damit Sie eine Verbindung zu Ihren Clustern herstellen können.
+ **`AWS KMS`Berechtigungen** — werden bei API-Aufrufen verwendet, um die übergebenen Ressourcen in einer Anfrage zu validieren. Sie sind erforderlich, damit Amazon MSK den übergebenen Schlüssel mit dem Amazon-MSK-Cluster verwenden kann.
+ **`CloudWatch Logs, Amazon S3, and Amazon Data Firehose`Berechtigungen** — sind erforderlich, damit Amazon MSK sicherstellen kann, dass die Protokollzustellungsziele erreichbar sind und dass sie für die Verwendung von Broker-Protokollen gültig sind.
+ **`IAM`Berechtigungen** — sind erforderlich, damit Amazon MSK eine serviceverknüpfte Rolle in Ihrem Konto erstellen und eine Rolle zur Ausführung von Dienstleistungen an Amazon MSK übergeben kann.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"kafka:*",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"ec2:DescribeSecurityGroups",
"ec2:DescribeRouteTables",
"ec2:DescribeVpcEndpoints",
"ec2:DescribeVpcAttribute",
"kms:DescribeKey",
"kms:CreateGrant",
"logs:CreateLogDelivery",
"logs:GetLogDelivery",
"logs:UpdateLogDelivery",
"logs:DeleteLogDelivery",
"logs:ListLogDeliveries",
"logs:PutResourcePolicy",
"logs:DescribeResourcePolicies",
"logs:DescribeLogGroups",
"S3:GetBucketPolicy",
"firehose:TagDeliveryStream"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateVpcEndpoint"
],
"Resource": [
"arn:*:ec2:*:*:vpc/*",
"arn:*:ec2:*:*:subnet/*",
"arn:*:ec2:*:*:security-group/*"
]
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateVpcEndpoint"
],
"Resource": [
"arn:*:ec2:*:*:vpc-endpoint/*"
],
"Condition": {
"StringEquals": {
"aws:RequestTag/AWSMSKManaged": "true"
},
"StringLike": {
"aws:RequestTag/ClusterArn": "*"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:*:ec2:*:*:vpc-endpoint/*",
"Condition": {
"StringEquals": {
"ec2:CreateAction": "CreateVpcEndpoint"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:DeleteVpcEndpoints"
],
"Resource": "arn:*:ec2:*:*:vpc-endpoint/*",
"Condition": {
"StringEquals": {
"ec2:ResourceTag/AWSMSKManaged": "true"
},
"StringLike": {
"ec2:ResourceTag/ClusterArn": "*"
}
}
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:PassedToService": "kafka.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/kafka.amazonaws.com/AWSServiceRoleForKafka*",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "kafka.amazonaws.com"
}
}
},
{
"Effect": "Allow",
"Action": [
"iam:AttachRolePolicy",
"iam:PutRolePolicy"
],
"Resource": "arn:aws:iam::*:role/aws-service-role/kafka.amazonaws.com/AWSServiceRoleForKafka*"
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/delivery.logs.amazonaws.com/AWSServiceRoleForLogDelivery*",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "delivery.logs.amazonaws.com"
}
}
}
]
}
```
------
# AWS verwaltete Richtlinie: Amazon MSKRead OnlyAccess
Diese Richtlinie gewährt schreibgeschützte Berechtigungen, die es Benutzern erlauben, Informationen in Amazon MSK anzuzeigen. Prinzipale, denen diese Richtlinie angefügt ist, können keine Aktualisierungen vornehmen oder bestehende Ressourcen löschen. Sie können auch keine neuen Amazon-MSK-Ressourcen erstellen. Prinzipale mit diesen Berechtigungen können beispielsweise die Liste der Cluster und Konfigurationen, die mit ihrem Konto verknüpft sind, einsehen, aber nicht die Konfiguration oder Einstellungen von Clustern ändern. Die Berechtigungen in dieser Richtlinie sind wie folgt gruppiert:
+ **`Amazon MSK`Berechtigungen** — ermöglichen es Ihnen, Amazon MSK-Ressourcen aufzulisten, zu beschreiben und Informationen über sie abzurufen.
+ **`Amazon EC2`Berechtigungen** — werden verwendet, um die Amazon VPC, Subnetze und Sicherheitsgruppen zu beschreiben, ENIs die einem Cluster zugeordnet sind.
+ **`AWS KMS`Permission** — wird verwendet, um den Schlüssel zu beschreiben, der dem Cluster zugeordnet ist.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"kafka:Describe*",
"kafka:List*",
"kafka:Get*",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs",
"kms:DescribeKey"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
# AWS verwaltete Richtlinie: KafkaServiceRolePolicy
Sie können keine Verbindungen KafkaServiceRolePolicy zu Ihren IAM-Entitäten herstellen. Diese Richtlinie ist mit einer servicegebundenen Rolle verknüpft, die es Amazon MSK ermöglicht, Aktionen wie die Verwaltung von VPC-Endpunkten (Konnektoren) auf MSK-Clustern, die Verwaltung von Netzwerkschnittstellen und die Verwaltung von Cluster-Anmeldeinformationen mit AWS Secrets Manager durchzuführen. Weitere Informationen finden Sie unter [Servicebezogene Rollen für Amazon MSK](using-service-linked-roles.md).
In der folgenden Tabelle werden die Aktualisierungen der KafkaServiceRolePolicy verwalteten Richtlinie seit Beginn der Nachverfolgung von Änderungen durch Amazon MSK beschrieben.
| Änderungen | Beschreibung | Date |
| --- | --- | --- |
| [IPv6 Konnektivitätsunterstützung hinzugefügt zu KafkaServiceRolePolicy](#security-iam-awsmanpol-KafkaServiceRolePolicy) — Aktualisierung einer bestehenden Richtlinie | Amazon MSK hat Berechtigungen hinzugefügt, KafkaServiceRolePolicy um IPv6 Konnektivität für MSK-Cluster zu aktivieren. Diese Berechtigungen ermöglichen Amazon MSK, Netzwerkschnittstellen IPv6 Adressen zuzuweisen und deren Zuweisung aufzuheben und Netzwerkschnittstellenattribute im Kundenkonto zu ändern. | 17. November 2025 |
| [KafkaServiceRolePolicy](#security-iam-awsmanpol-KafkaServiceRolePolicy) – Aktualisierung auf eine bestehende Richtlinie | Amazon MSK hat Berechtigungen zur Unterstützung privater Multi-VPC-Konnektivität hinzugefügt. | 08. März 2023 |
| Amazon MSK hat mit der Nachverfolgung von Änderungen begonnen | Amazon MSK hat damit begonnen, Änderungen an KafkaServiceRolePolicy verwalteten Richtlinien nachzuverfolgen. | 08. März 2023 |
# AWS verwaltete Richtlinie: AWSMSKReplicator ExecutionRole
Die `AWSMSKReplicatorExecutionRole` Richtlinie gewährt dem Amazon MSK-Replikator die Erlaubnis, Daten zwischen MSK-Clustern zu replizieren. Die Berechtigungen in dieser Richtlinie sind wie folgt gruppiert:
+ **`cluster`**— Erteilt dem Amazon MSK Replicator die Berechtigung, mithilfe der IAM-Authentifizierung eine Verbindung zum Cluster herzustellen. Erteilt außerdem Berechtigungen zur Beschreibung und Änderung des Clusters.
+ **`topic`**— Erteilt dem Amazon MSK Replicator Berechtigungen zum Beschreiben, Erstellen und Ändern eines Themas sowie zum Ändern der dynamischen Konfiguration des Themas.
+ **`consumer group`**— Erteilt dem Amazon MSK Replicator Berechtigungen zum Beschreiben und Ändern von Nutzergruppen, zum Lesen und Schreiben von Daten aus einem MSK-Cluster und zum Löschen interner Themen, die vom Replikator erstellt wurden.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ClusterPermissions",
"Effect": "Allow",
"Action": [
"kafka-cluster:Connect",
"kafka-cluster:DescribeCluster",
"kafka-cluster:AlterCluster",
"kafka-cluster:DescribeTopic",
"kafka-cluster:CreateTopic",
"kafka-cluster:AlterTopic",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData",
"kafka-cluster:AlterGroup",
"kafka-cluster:DescribeGroup",
"kafka-cluster:DescribeTopicDynamicConfiguration",
"kafka-cluster:AlterTopicDynamicConfiguration",
"kafka-cluster:WriteDataIdempotently"
],
"Resource": [
"arn:aws:kafka:*:*:cluster/*"
]
},
{
"Sid": "TopicPermissions",
"Effect": "Allow",
"Action": [
"kafka-cluster:DescribeTopic",
"kafka-cluster:CreateTopic",
"kafka-cluster:AlterTopic",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData",
"kafka-cluster:DescribeTopicDynamicConfiguration",
"kafka-cluster:AlterTopicDynamicConfiguration",
"kafka-cluster:AlterCluster"
],
"Resource": [
"arn:aws:kafka:*:*:topic/*/*"
]
},
{
"Sid": "GroupPermissions",
"Effect": "Allow",
"Action": [
"kafka-cluster:AlterGroup",
"kafka-cluster:DescribeGroup"
],
"Resource": [
"arn:aws:kafka:*:*:group/*/*"
]
}
]
}
```
------
# Amazon MSK aktualisiert AWS verwaltete Richtlinien
Sehen Sie sich Details zu Aktualisierungen der AWS verwalteten Richtlinien für Amazon MSK an, seit dieser Service begonnen hat, diese Änderungen zu verfolgen.
| Änderungen | Beschreibung | Date |
| --- | --- | --- |
| [WriteDataIdempotently Berechtigung hinzugefügt zu AWSMSKReplicator ExecutionRole](security-iam-awsmanpol-AWSMSKReplicatorExecutionRole.md) — Aktualisierung einer bestehenden Richtlinie | Amazon MSK hat der AWSMSKReplicator ExecutionRole Richtlinie die WriteDataIdempotently Erlaubnis zur Unterstützung der Datenreplikation zwischen MSK-Clustern hinzugefügt. | 12. März 2024 |
| [AWSMSKReplicatorExecutionRole](security-iam-awsmanpol-AWSMSKReplicatorExecutionRole.md) – Neue Richtlinie | Amazon MSK hat eine AWSMSKReplicator ExecutionRole Richtlinie zur Unterstützung von Amazon MSK Replicator hinzugefügt. | 4. Dezember 2023 |
| [Amazon MSKFull Access](security-iam-awsmanpol-AmazonMSKFullAccess.md) — Aktualisierung einer bestehenden Richtlinie | Amazon MSK hat Berechtigungen zur Unterstützung von Amazon MSK Replicator hinzugefügt. | 28. September 2023 |
| [KafkaServiceRolePolicy](security-iam-awsmanpol-KafkaServiceRolePolicy.md) – Aktualisierung auf eine bestehende Richtlinie | Amazon MSK hat Berechtigungen zur Unterstützung privater Multi-VPC-Konnektivität hinzugefügt. | 08. März 2023 |
| [Amazon MSKFull Access](security-iam-awsmanpol-AmazonMSKFullAccess.md) — Aktualisierung einer bestehenden Richtlinie | Amazon MSK hat neue Amazon-EC2-Berechtigungen hinzugefügt, um die Verbindung zu einem Cluster zu ermöglichen. | 30. November 2021 |
| [Amazon MSKFull Access](security-iam-awsmanpol-AmazonMSKFullAccess.md) — Aktualisierung einer bestehenden Richtlinie | Amazon MSK hat eine neue Berechtigung hinzugefügt, mit der Amazon-EC2-Routing-Tabellen beschrieben werden können. | 19. November 2021 |
| Amazon MSK hat mit der Nachverfolgung von Änderungen begonnen | Amazon MSK hat damit begonnen, Änderungen an seinen AWS verwalteten Richtlinien nachzuverfolgen. | 19. November 2021 |
# Problembehandlung bei Amazon MSK-Identität und -Zugriff
Diagnostizieren und beheben Sie mithilfe der folgenden Informationen gängige Probleme, die bei der Verwendung von Amazon MSK und IAM auftreten können.
**Topics**
+ [
## Ich bin nicht autorisiert, eine Aktion in Amazon MSK auszuführen
](#security_iam_troubleshoot-no-permissions)
## Ich bin nicht autorisiert, eine Aktion in Amazon MSK auszuführen
Wenn Ihnen AWS-Managementkonsole mitgeteilt wird, dass Sie nicht berechtigt sind, eine Aktion durchzuführen, müssen Sie sich an Ihren Administrator wenden, um Unterstützung zu erhalten. Ihr Administrator hat Ihnen Ihre Anmeldeinformationen zur Verfügung gestellt.
Der folgende Beispielfehler tritt auf, wenn der `mateojackson`-IAM-Benutzer versucht, die Konsole zum Löschen eines Clusters zu verwenden, jedoch nicht über `kafka:DeleteCluster`-Berechtigungen verfügt.
```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: kafka:DeleteCluster on resource: purchaseQueriesCluster
```
In diesem Fall bittet Mateo seinen Administrator um die Aktualisierung seiner Richtlinien, um unter Verwendung der Aktion `purchaseQueriesCluster` auf die Ressource `kafka:DeleteCluster` zugreifen zu können.
# Authentifizierung und Autorisierung für Apache Kafka APIs
Sie können IAM verwenden, um Clients zu authentifizieren und Apache-Kafka-Aktionen zu erlauben oder zu verweigern. Alternativ können Sie TLS oder SASL/SCRAM zur Authentifizierung von Clients und Apache Kafka verwenden, ACLs um Aktionen zuzulassen oder abzulehnen.
Informationen darüber, wie Sie steuern können, wer [Amazon-MSK-Vorgänge](https://docs.aws.amazon.com/msk/1.0/apireference/operations.html) auf Ihrem Cluster ausführen kann, finden Sie unter [Authentifizierung und Autorisierung für Amazon MSK APIs](security-iam.md).
**Topics**
+ [
# IAM-Zugriffssteuerung
](iam-access-control.md)
+ [
# Gegenseitige TLS-Client-Authentifizierung für Amazon MSK
](msk-authentication.md)
+ [
# Authentifizierung der Anmeldedaten mit AWS Secrets Manager
](msk-password.md)
+ [
# Apache Kafka ACLs
](msk-acls.md)
# IAM-Zugriffssteuerung
IAM-Zugriffssteuerung für Amazon MSK ermöglicht es Ihnen, sowohl die Authentifizierung als auch die Autorisierung für Ihren MSK-Cluster zu verwalten. Dies macht die Verwendung eines Mechanismus für die Authentifizierung und einen anderen für die Autorisierung überflüssig. Wenn ein Client beispielsweise versucht, in Ihren Cluster zu schreiben, prüft Amazon MSK mithilfe von IAM, ob es sich bei diesem Client um eine authentifizierte Identität handelt und ob er berechtigt ist, für Ihren Cluster zu produzieren.
Die IAM-Zugriffskontrolle funktioniert für Java- und Nicht-Java-Clients, einschließlich Kafka-Clients, die in Python JavaScript, Go und.NET geschrieben sind. Die IAM-Zugriffskontrolle für Nicht-Java-Clients ist für MSK-Cluster mit Kafka-Version 2.7.1 oder höher verfügbar.
Um die IAM-Zugriffssteuerung zu ermöglichen, nimmt Amazon MSK geringfügige Änderungen am Apache-Kafka-Quellcode vor. Diese Änderungen werden keinen spürbaren Unterschied in Ihrem Apache-Kafka-Erlebnis bewirken. Amazon MSK protokolliert Zugriffsereignisse, sodass Sie sie prüfen können.
Sie können Apache Kafka ACL APIs für einen MSK-Cluster aufrufen, der IAM-Zugriffskontrolle verwendet. Apache Kafka ACLs hat jedoch keine Auswirkung auf die Autorisierung für IAM-Identitäten. Sie müssen IAM-Richtlinien verwenden, um den Zugriff auf IAM-Identitäten zu kontrollieren.
**Wichtige Überlegungen**
Wenn Sie die IAM-Zugriffskontrolle mit Ihrem MSK-Cluster verwenden, sollten Sie die folgenden wichtigen Überlegungen berücksichtigen:
Die IAM-Zugriffskontrolle gilt nicht für Apache-Knoten. ZooKeeper Weitere Informationen zum Steuern des Zugriffs auf diese Knoten finden Sie unter [Steuern Sie den Zugriff auf ZooKeeper Apache-Knoten in Ihrem Amazon MSK-Cluster](zookeeper-security.md).
Die Apache-Kafka-Einstellung `allow.everyone.if.no.acl.found` hat keine Auswirkung, wenn Ihr Cluster die IAM-Zugriffssteuerung verwendet.
Sie können Apache Kafka ACL APIs für einen MSK-Cluster aufrufen, der IAM-Zugriffskontrolle verwendet. Apache Kafka ACLs hat jedoch keine Auswirkung auf die Autorisierung für IAM-Identitäten. Sie müssen IAM-Richtlinien verwenden, um den Zugriff auf IAM-Identitäten zu kontrollieren.
# So funktioniert die IAM-Zugriffssteuerung für Amazon MSK
Um die IAM-Zugriffskontrolle für Amazon MSK zu verwenden, führen Sie die folgenden Schritte aus, die in diesen Themen ausführlich beschrieben werden:
+ [Erstellen Sie einen Amazon MSK-Cluster, der IAM-Zugriffskontrolle verwendet](create-iam-access-control-cluster-in-console.md)
+ [Konfiguration von Clients für die IAM-Zugriffssteuerung](configure-clients-for-iam-access-control.md)
+ [Erstellen Sie Autorisierungsrichtlinien für die IAM-Rolle](create-iam-access-control-policies.md)
+ [Bootstrap-Broker für IAM-Zugriffssteuerung abrufen](get-bootstrap-brokers-for-iam.md)
# Erstellen Sie einen Amazon MSK-Cluster, der IAM-Zugriffskontrolle verwendet
In diesem Abschnitt wird erklärt, wie Sie die AWS-Managementkonsole, die API oder die verwenden können, AWS CLI um einen Amazon MSK-Cluster zu erstellen, der IAM-Zugriffskontrolle verwendet. Informationen zum Aktivieren der IAM-Zugriffssteuerung für einen vorhandenen Cluster finden Sie unter [Sicherheitseinstellungen eines Amazon MSK-Clusters aktualisieren](msk-update-security.md).
**Verwenden Sie den AWS-Managementkonsole , um einen Cluster zu erstellen, der die IAM-Zugriffskontrolle verwendet**
1. Öffnen Sie die Amazon-MSK-Konsole unter [https://console.aws.amazon.com/msk/](https://console.aws.amazon.com/msk/).
1. Wählen Sie **Cluster erstellen**.
1. Wählen Sie **Cluster mit benutzerdefinierten Einstellungen erstellen**.
1. Wählen Sie im Abschnitt **Authentifizierung** die Option **IAM-Zugriffssteuerung** aus.
1. Führen Sie den Rest des Workflows zum Erstellen eines Clusters aus.
**Verwenden Sie die API oder die AWS CLI , um einen Cluster zu erstellen, der die IAM-Zugriffskontrolle verwendet**
+ Um einen Cluster mit aktivierter IAM-Zugriffskontrolle zu erstellen, verwenden Sie die [CreateCluster](https://docs.aws.amazon.com/msk/1.0/apireference/clusters.html#CreateCluster)API oder den CLI-Befehl [create-cluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kafka/create-cluster.html) und übergeben Sie den folgenden JSON-Code für den `ClientAuthentication` Parameter:. `"ClientAuthentication": { "Sasl": { "Iam": { "Enabled": true } }`
# Konfiguration von Clients für die IAM-Zugriffssteuerung
Damit Clients mit einem MSK-Cluster kommunizieren können, der die IAM-Zugriffskontrolle verwendet, können Sie einen der folgenden Mechanismen verwenden:
+ Konfiguration eines Nicht-Java-Clients mithilfe eines Mechanismus SASL\$1OAUTHBEARER
+ Konfiguration des Java-Clients mithilfe eines SASL\$1OAUTHBEARER Mechanismus oder AWS\$1MSK\$1IAM Mechanismus
## Verwenden Sie den SASL\$1OAUTHBEARER Mechanismus, um IAM zu konfigurieren
1. Bearbeiten Sie Ihre client.properties-Konfigurationsdatei mit dem folgenden Python-Kafka-Client-Beispiel. Konfigurationsänderungen sind in anderen Sprachen ähnlich.
```
from kafka import KafkaProducer
from kafka.errors import KafkaError
from kafka.sasl.oauth import AbstractTokenProvider
import socket
import time
from aws_msk_iam_sasl_signer import MSKAuthTokenProvider
class MSKTokenProvider():
def token(self):
token, _ = MSKAuthTokenProvider.generate_auth_token('')
return token
tp = MSKTokenProvider()
producer = KafkaProducer(
bootstrap_servers='',
security_protocol='SASL_SSL',
sasl_mechanism='OAUTHBEARER',
sasl_oauth_token_provider=tp,
client_id=socket.gethostname(),
)
topic = ""
while True:
try:
inp=input(">")
producer.send(topic, inp.encode())
producer.flush()
print("Produced!")
except Exception:
print("Failed to send message:", e)
producer.close()
```
1. Laden Sie die Hilfsbibliothek für die von Ihnen gewählte Konfigurationssprache herunter und folgen Sie den Anweisungen im Abschnitt *Erste Schritte* auf der Homepage dieser Sprachbibliothek.
+ JavaScript: [https://github.com/aws/aws-msk-iam-sasl-signer-js](https://github.com/aws/aws-msk-iam-sasl-signer-js#getting-started) \$1getting -started
+ Python: [https://github.com/aws/aws-msk-iam-sasl-signer-python](https://github.com/aws/aws-msk-iam-sasl-signer-python#get-started) \$1get -gestartet
+ [Gehe zu: -signer-go \$1getting -gestartet https://github.com/aws/ aws-msk-iam-sasl](https://github.com/aws/aws-msk-iam-sasl-signer-go#getting-started)
+ [.NET: -signer-net \$1getting -gestartet https://github.com/aws/ aws-msk-iam-sasl](https://github.com/aws/aws-msk-iam-sasl-signer-net#getting-started)
+ JAVA: SASL\$1OAUTHBEARER Unterstützung für Java ist über die JAR-Datei verfügbar [https://github.com/aws/aws-msk-iam-auth/releases](https://github.com/aws/aws-msk-iam-auth/releases)
## Verwenden Sie den benutzerdefinierten AWS\$1MSK\$1IAM MSK-Mechanismus, um IAM zu konfigurieren
1. Fügen Sie der Datei `client.properties` Folgendes hinzu. **Ersetzen Sie ihn durch den vollqualifizierten Pfad zur Trust Store-Datei auf dem Client.
**Anmerkung**
Wenn Sie ein bestimmtes Zertifikat nicht verwenden möchten, können Sie `ssl.truststore.location=` aus Ihrer `client.properties`-Datei entfernen. Wenn Sie keinen Wert für `ssl.truststore.location` angeben, verwendet der Java-Prozess das Standardzertifikat.
```
ssl.truststore.location=
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
```
Um ein benanntes Profil zu verwenden, das Sie für AWS Anmeldeinformationen erstellt haben, nehmen Sie es `awsProfileName="your profile name";` in Ihre Client-Konfigurationsdatei auf. Informationen zu benannten Profilen finden Sie in der AWS CLI Dokumentation unter [Benannte Profile](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html).
1. Laden Sie die neueste stabile [aws-msk-iam-auth](https://github.com/aws/aws-msk-iam-auth/releases)JAR-Datei herunter und platzieren Sie sie im Klassenpfad. Wenn Sie Maven verwenden, fügen Sie die folgende Abhängigkeit hinzu und passen Sie die Versionsnummer nach Bedarf an:
```
software.amazon.msk
aws-msk-iam-auth
1.0.0
```
Das Amazon-MSK-Client-Plugin ist unter der Apache-2.0-Lizenz als Open-Source verfügbar.
# Erstellen Sie Autorisierungsrichtlinien für die IAM-Rolle
Fügen Sie eine Autorisierungsrichtlinie an die IAM-Rolle an, die dem Client entspricht. In einer Autorisierungsrichtlinie geben Sie an, welche Aktionen für die Rolle erlaubt oder verweigert werden sollen. Wenn sich Ihr Client auf einer Amazon-EC2-Instance befindet, ordnen Sie die Autorisierungsrichtlinie der IAM-Rolle für diese Amazon-EC2-Instance zu. Alternativ können Sie Ihren Client so konfigurieren, dass er ein benanntes Profil verwendet, und dann die Autorisierungsrichtlinie der Rolle für dieses benannte Profil zuordnen. [Konfiguration von Clients für die IAM-Zugriffssteuerung](configure-clients-for-iam-access-control.md) beschreibt, wie ein Client für die Verwendung eines benannten Profils konfiguriert wird.
Informationen zum Erstellen einer IAM-Richtlinie finden Sie unter [Erstellen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
Im Folgenden finden Sie ein Beispiel für eine Autorisierungsrichtlinie für einen Cluster mit dem Namen MyTestCluster. Informationen zur Semantik der `Action`- und `Resource`-Elemente finden Sie unter [Semantik der Aktionen und Ressourcen der IAM-Autorisierungsrichtlinie](kafka-actions.md).
**Wichtig**
Änderungen, die Sie an einer IAM-Richtlinie vornehmen, werden in der IAM APIs und in der sofort widergespiegelt. AWS CLI Es kann jedoch einige Zeit dauern, bis die Änderung der Richtlinie wirksam wird. In den meisten Fällen werden Richtlinien-Änderungen in weniger als einer Minute wirksam. Netzwerkbedingungen können die Verzögerung manchmal erhöhen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kafka-cluster:Connect",
"kafka-cluster:AlterCluster",
"kafka-cluster:DescribeCluster"
],
"Resource": [
"arn:aws:kafka:us-east-1:111122223333:cluster/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1"
]
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:*Topic*",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:topic/MyTestCluster/*"
]
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:AlterGroup",
"kafka-cluster:DescribeGroup"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:group/MyTestCluster/*"
]
}
]
}
```
------
Informationen zum Erstellen einer Richtlinie mit Aktionselementen, die gängigen Anwendungsfällen von Apache Kafka entsprechen, wie z. B. das Erzeugen und Verbrauchen von Daten, finden Sie unter [Häufige Anwendungsfälle für Client-Autorisierungsrichtlinien](iam-access-control-use-cases.md).
[Für Kafka-Versionen 2.8.0 und höher ist die **WriteDataIdempotently**Berechtigung veraltet (KIP-679).](https://cwiki.apache.org/confluence/display/KAFKA/KIP-679%3A+Producer+will+enable+the+strongest+delivery+guarantee+by+default) `enable.idempotence = true` ist standardmäßig festgelegt. Daher bietet IAM für die Kafka-Versionen 2.8.0 und höher nicht die gleiche Funktionalität wie Kafka. ACLs Es ist nicht möglich, zu einem Thema `WriteDataIdempotently` zu gelangen, indem man nur `WriteData` Zugriff auf dieses Thema gewährt. Dies hat keinen Einfluss auf den Fall, dass `WriteData` es für **ALLE** Themen bereitgestellt wird. In diesem Fall ist `WriteDataIdempotently` erlaubt. Dies ist auf Unterschiede in der Implementierung der IAM-Logik und der Implementierung von Kafka ACLs zurückzuführen. Darüber hinaus erfordert das Schreiben zu einem Thema unabhängig davon auch Zugriff auf. `transactional-ids`
Um dieses Problem zu umgehen, empfehlen wir, eine Richtlinie zu verwenden, die der folgenden Richtlinie ähnelt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kafka-cluster:Connect",
"kafka-cluster:AlterCluster",
"kafka-cluster:DescribeCluster",
"kafka-cluster:WriteDataIdempotently"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:cluster/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1"
]
},
{
"Effect": "Allow",
"Action": [
"kafka-cluster:*Topic*",
"kafka-cluster:WriteData",
"kafka-cluster:ReadData"
],
"Resource": [
"arn:aws:kafka:us-east-1:123456789012:topic/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/TestTopic",
"arn:aws:kafka:us-east-1:123456789012:transactional-id/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/*"
]
}
]
}
```
------
In diesem Fall erlaubt `WriteData` Schreibvorgänge in `TestTopic`, während `WriteDataIdempotently` idempotente Schreibvorgänge in den Cluster erlaubt. Diese Richtlinie ermöglicht auch den Zugriff auf die `transactional-id` Ressourcen, die benötigt werden.
Da `WriteDataIdempotently` es sich um eine Berechtigung auf Clusterebene handelt, können Sie sie nicht auf Themenebene verwenden. Wenn sie auf Themenebene beschränkt `WriteDataIdempotently` ist, funktioniert diese Richtlinie nicht.
# Bootstrap-Broker für IAM-Zugriffssteuerung abrufen
Siehe [Holen Sie sich die Bootstrap-Broker für einen Amazon MSK-Cluster](msk-get-bootstrap-brokers.md).
# Semantik der Aktionen und Ressourcen der IAM-Autorisierungsrichtlinie
**Anmerkung**
Für Cluster, auf denen Apache Kafka Version 3.8 oder höher ausgeführt wird, unterstützt die IAM-Zugriffskontrolle die WriteTxnMarkers API zum Beenden von Transaktionen. Für Cluster, auf denen Kafka-Versionen vor 3.8 ausgeführt werden, unterstützt die IAM-Zugriffskontrolle keine internen Clusteraktionen, einschließlich. WriteTxnMarkers Verwenden Sie für diese früheren Versionen zum Beenden von Transaktionen die SCRAM- oder mTLS-Authentifizierung mit entsprechender ACLs anstelle der IAM-Authentifizierung.
In diesem Abschnitt wird die Semantik der Aktions- und Ressourcenelemente erläutert, die Sie in einer IAM-Autorisierungsrichtlinie verwenden können. Eine Beispielrichtlinie finden Sie unter [Erstellen Sie Autorisierungsrichtlinien für die IAM-Rolle](create-iam-access-control-policies.md).
## Aktionen der Autorisierungsrichtlinie
In der folgenden Tabelle sind die Aktionen aufgeführt, die Sie in eine Autorisierungsrichtlinie aufnehmen können, wenn Sie IAM-Zugriffssteuerung für Amazon MSK verwenden. Wenn Sie in Ihre Autorisierungsrichtlinie eine Aktion aus der Spalte *Aktion* der Tabelle aufnehmen, müssen Sie auch die entsprechenden Aktionen aus der Spalte *Erforderliche Aktionen* angeben.
| Action | Description | Erforderliche Aktionen | Erforderliche -Ressourcen | Gilt für Serverless-Cluster |
| --- | --- | --- | --- | --- |
| kafka-cluster:Connect | Gewährt die Berechtigung, sich mit dem Cluster zu verbinden und zu authentifizieren. | Keine | Cluster | Ja |
| kafka-cluster:DescribeCluster | Gewährt die Berechtigung zum Beschreiben verschiedener Aspekte des Clusters, was der DESCRIBE CLUSTER ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` | Cluster | Ja |
| kafka-cluster:AlterCluster | Gewährt die Berechtigung zum Ändern verschiedener Aspekte des Clusters, was der ALTER CLUSTER ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` `kafka-cluster:DescribeCluster` | Cluster | Nein |
| kafka-cluster:DescribeClusterDynamicConfiguration | Gewährt die Berechtigung zum Beschreiben der dynamischen Konfiguration eines Clusters, was der DESCRIBE\$1CONFIGS CLUSTER ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` | Cluster | Nein |
| kafka-cluster:AlterClusterDynamicConfiguration | Gewährt die Berechtigung zum Ändern der dynamischen Konfiguration eines Clusters, was der ALTER\$1CONFIGS CLUSTER ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration` | Cluster | Nein |
| kafka-cluster:WriteDataIdempotently | Gewährt die Berechtigung zum idempotenten Schreiben von Daten auf einen Cluster, was der IDEMPOTENT\$1WRITE CLUSTER ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` `kafka-cluster:WriteData` | Cluster | Ja |
| kafka-cluster:CreateTopic | Erteilt die Berechtigung zum Erstellen von Themen in einem Cluster, was der CREATE CLUSTER/TOPIC ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` | Thema | Ja |
| kafka-cluster:DescribeTopic | Gewährt die Berechtigung zum Beschreiben von Themen auf einem Cluster, was der DESCRIBE TOPIC ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` | Thema | Ja |
| kafka-cluster:AlterTopic | Gewährt die Berechtigung zum Ändern von Themen auf einem Cluster, was der ALTER TOPIC ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` | Thema | Ja |
| kafka-cluster:DeleteTopic | Gewährt die Berechtigung zum Löschen von Themen auf einem Cluster, was der DELETE TOPIC ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` | Thema | Ja |
| kafka-cluster:DescribeTopicDynamicConfiguration | Gewährt die Berechtigung zum Beschreiben der dynamischen Konfiguration von Themen auf einem Cluster, was der DESCRIBE\$1CONFIGS TOPIC ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` | Thema | Ja |
| kafka-cluster:AlterTopicDynamicConfiguration | Gewährt die Berechtigung zum Ändern der dynamischen Konfiguration von Themen auf einem Cluster, was der ALTER\$1CONFIGS TOPIC ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration` | Thema | Ja |
| kafka-cluster:ReadData | Gewährt die Berechtigung zum Lesen von Daten aus Themen auf einem Cluster, was der READ TOPIC ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:AlterGroup` | Thema | Ja |
| kafka-cluster:WriteData | Gewährt die Berechtigung zum Schreiben von Daten zu Themen auf einem Cluster, was der WRITE-TOPIC-ACL von Apache Kafka entspricht | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` | Thema | Ja |
| kafka-cluster:DescribeGroup | Gewährt die Berechtigung zum Beschreiben von Gruppen auf einem Cluster, was der DESCRIBE GROUP ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` | Gruppe | Ja |
| kafka-cluster:AlterGroup | Gewährt die Berechtigung, Gruppen in einem Cluster beizutreten, was der READ GROUP ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` `kafka-cluster:DescribeGroup` | Gruppe | Ja |
| kafka-cluster:DeleteGroup | Gewährt die Berechtigung zum Löschen von Gruppen auf einem Cluster, was der DELETE GROUP ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` `kafka-cluster:DescribeGroup` | Gruppe | Ja |
| kafka-cluster:DescribeTransactionalId | Erteilt die Berechtigung zur Beschreibung von Transaktionen IDs auf einem Cluster, was der DESCRIBE TRANSACTIONAL\$1ID-ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` | transactional-id | Ja |
| kafka-cluster:AlterTransactionalId | Erteilt die Berechtigung, Transaktionen auf einem Cluster zu ändern, was der WRITE IDs TRANSACTIONAL\$1ID-ACL von Apache Kafka entspricht. | `kafka-cluster:Connect` `kafka-cluster:DescribeTransactionalId` `kafka-cluster:WriteData` | transactional-id | Ja |
Sie können das Sternchen (\$1) als Platzhalter in einer Aktion hinter dem Doppelpunkt beliebig oft verwenden. Im Folgenden sind einige Beispiele aufgeführt.
+ `kafka-cluster:*Topic` steht für `kafka-cluster:CreateTopic`, `kafka-cluster:DescribeTopic`, `kafka-cluster:AlterTopic` und `kafka-cluster:DeleteTopic`. Es beinhaltet nicht `kafka-cluster:DescribeTopicDynamicConfiguration` oder `kafka-cluster:AlterTopicDynamicConfiguration`.
+ `kafka-cluster:*` steht für alle Berechtigungen.
## Ressourcen für Autorisierungsrichtlinien
In der folgenden Tabelle sind die vier Arten von Ressourcen aufgeführt, die Sie in eine Autorisierungsrichtlinie aufnehmen können, wenn Sie IAM-Zugriffssteuerung für Amazon MSK verwenden. Sie können den Cluster-Amazon-Ressourcennamen (ARN) von AWS-Managementkonsole oder mithilfe der [DescribeCluster](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn.html#DescribeCluster)API oder des Befehls [describe-cluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kafka/describe-cluster.html) AWS CLI abrufen. Anschließend können Sie den Cluster-ARN verwenden, um Themen-, Gruppen- und Transaktions-IDs zu erstellen. ARNs Um eine Ressource in einer Autorisierungsrichtlinie anzugeben, verwenden Sie den ARN dieser Ressource.
| Ressource | ARN-Format |
| --- | --- |
| Cluster | arn:aws:kafka: ::cluster//regionaccount-idcluster-namecluster-uuid |
| Thema | arn:aws:kafka: region ::topic///account-idcluster-namecluster-uuidtopic-name |
| Group (Gruppieren) | arn:aws:kafka: region ::group///account-idcluster-namecluster-uuidgroup-name |
| Transkaktions-ID | arn:aws:kafka: region ::transactional-id//account-idcluster-namecluster-uuidtransactional-id |
Sie können das Sternchen (\$1) als Platzhalter beliebig oft an beliebiger Stelle in dem Teil des ARN verwenden, der nach `:cluster/`, `:topic/`, `:group/` und `:transactional-id/` folgt. Im Folgenden finden Sie einige Beispiele dafür, wie Sie das Sternchen (\$1) als Platzhalter verwenden können, um auf mehrere Ressourcen zu verweisen:
+ `arn:aws:kafka:us-east-1:0123456789012:topic/MyTestCluster/*`: alle Themen in einem beliebigen Cluster mit Namen, unabhängig von der UUID des Clusters. MyTestCluster
+ `arn:aws:kafka:us-east-1:0123456789012:topic/MyTestCluster/abcd1234-0123-abcd-5678-1234abcd-1/*_test`: alle Themen, deren Name mit „\$1test“ endet, in dem Cluster, dessen Name MyTestCluster und dessen UUID abcd1234-0123-abcd-5678-1234abcd-1 ist.
+ `arn:aws:kafka:us-east-1:0123456789012:transactional-id/MyTestCluster/*/5555abcd-1111-abcd-1234-abcd1234-1`: alle Transaktionen, deren Transaktions-ID 5555abcd-1111-abcd-1234-abcd1234-1 lautet, in allen Inkarnationen eines Clusters, der in Ihrem Konto benannt ist. MyTestCluster Das heißt, wenn Sie einen Cluster mit dem Namen erstellen MyTestCluster, ihn dann löschen und dann einen weiteren Cluster mit demselben Namen erstellen, können Sie diesen Ressourcen-ARN verwenden, um dieselbe Transaktions-ID auf beiden Clustern darzustellen. Auf den gelöschten Cluster kann jedoch nicht zugegriffen werden.
# Häufige Anwendungsfälle für Client-Autorisierungsrichtlinien
Die erste Spalte der folgenden Tabelle zeigt einige gängige Anwendungsfälle. Um einen Client zur Ausführung eines bestimmten Anwendungsfalls zu autorisieren, nehmen Sie die für diesen Anwendungsfall erforderlichen Aktionen in die Autorisierungsrichtlinie des Clients auf und stellen Sie `Effect` auf `Allow` ein.
Informationen zu allen Aktionen, die Teil der IAM-Zugriffssteuerung für Amazon MSK sind, finden Sie unter [Semantik der Aktionen und Ressourcen der IAM-Autorisierungsrichtlinie](kafka-actions.md).
**Anmerkung**
Aktionen werden standardmäßig verweigert. Sie müssen jede Aktion, zu deren Ausführung Sie den Client autorisieren möchten, ausdrücklich erlauben.
****
| Anwendungsfall | Erforderliche Aktionen |
| --- | --- |
| Admin. | `kafka-cluster:*` |
| Erstellen Sie ein Thema | `kafka-cluster:Connect` `kafka-cluster:CreateTopic` |
| Daten produzieren | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` |
| Daten verbrauchen | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:DescribeGroup` `kafka-cluster:AlterGroup` `kafka-cluster:ReadData` |
| Daten idempotent produzieren | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` `kafka-cluster:WriteDataIdempotently` |
| Daten transaktionell produzieren | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:WriteData` `kafka-cluster:DescribeTransactionalId` `kafka-cluster:AlterTransactionalId` |
| Die Konfiguration eines Clusters beschreiben | `kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration` |
| Die Konfiguration eines Clusters aktualisieren | `kafka-cluster:Connect` `kafka-cluster:DescribeClusterDynamicConfiguration` `kafka-cluster:AlterClusterDynamicConfiguration` |
| Die Konfiguration eines Themas beschreiben | `kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration` |
| Die Konfiguration eines Themas aktualisieren | `kafka-cluster:Connect` `kafka-cluster:DescribeTopicDynamicConfiguration` `kafka-cluster:AlterTopicDynamicConfiguration` |
| Ein Thema ändern | `kafka-cluster:Connect` `kafka-cluster:DescribeTopic` `kafka-cluster:AlterTopic` |
# Gegenseitige TLS-Client-Authentifizierung für Amazon MSK
Sie können die Client-Authentifizierung mit TLS für Verbindungen von Ihren Anwendungen zu Ihren Amazon MSK-Brokern aktivieren. Damit Sie die Client-Authentifizierung verwenden können, benötigen Sie eine AWS Private CA. AWS Private CA Sie können sich entweder in demselben AWS-Konto Cluster oder in einem anderen Konto befinden. Informationen zu AWS Private CA s finden Sie unter [Erstellen und Verwalten von AWS Private CA](https://docs.aws.amazon.com/acm-pca/latest/userguide/create-CA.html).
Amazon MSK unterstützt keine Zertifikatssperrlisten (CRLs). Verwenden Sie Apache Kafka ACLs und Sicherheitsgruppen, um den Zugriff auf Ihre Cluster-Themen zu kontrollieren oder kompromittierte Zertifikate zu blockieren. AWS Hinweise zur Verwendung von Apache Kafka ACLs finden Sie unter. [Apache Kafka ACLs](msk-acls.md)
**Topics**
+ [
# Erstellen Sie einen Amazon MSK-Cluster, der die Client-Authentifizierung unterstützt
](msk-authentication-cluster.md)
+ [
# Richten Sie einen Client für die Verwendung der Authentifizierung ein
](msk-authentication-client.md)
+ [
# Erstellen und konsumieren Sie Nachrichten mithilfe von Authentifizierung
](msk-authentication-messages.md)
# Erstellen Sie einen Amazon MSK-Cluster, der die Client-Authentifizierung unterstützt
Dieses Verfahren zeigt Ihnen, wie Sie die Client-Authentifizierung mithilfe von aktivieren. AWS Private CA
**Anmerkung**
Wir empfehlen dringend, unabhängig AWS Private CA für jeden MSK-Cluster zu verwenden, wenn Sie Mutual TLS zur Zugriffskontrolle verwenden. Dadurch wird sichergestellt, dass TLS-Zertifikate, die von signiert wurden, PCAs nur bei einem einzigen MSK-Cluster authentifiziert werden.
1. Erstellen Sie eine Datei mit dem Namen `clientauthinfo.json` und dem folgenden Inhalt. *Private-CA-ARN*Ersetzen Sie es durch den ARN Ihres PCA.
```
{
"Tls": {
"CertificateAuthorityArnList": ["Private-CA-ARN"]
}
}
```
1. Erstellen Sie eine Datei mit dem Namen `brokernodegroupinfo.json`, wie unter [Erstellen Sie einen bereitgestellten Amazon MSK-Cluster mit dem AWS CLI](create-cluster-cli.md) beschrieben.
1. Für die Client-Authentifizierung müssen Sie auch die Verschlüsselung während der Übertragung zwischen Clients und Brokern aktivieren. Erstellen Sie eine Datei mit dem Namen `encryptioninfo.json` und dem folgenden Inhalt. *KMS-Key-ARN*Ersetzen Sie es durch den ARN Ihres KMS-Schlüssels. Für `ClientBroker` können Sie `TLS` oder `TLS_PLAINTEXT` festlegen.
```
{
"EncryptionAtRest": {
"DataVolumeKMSKeyId": "KMS-Key-ARN"
},
"EncryptionInTransit": {
"InCluster": true,
"ClientBroker": "TLS"
}
}
```
Weitere Informationen zur Verschlüsselung finden Sie unter [Amazon-MSK-Verschlüsselung](msk-encryption.md).
1. Führen Sie auf einem Computer, auf dem Sie das AWS CLI installiert haben, den folgenden Befehl aus, um einen Cluster mit aktivierter Authentifizierung und Verschlüsselung bei der Übertragung zu erstellen. Speichern Sie den in der Antwort angegebenen Cluster-ARN.
```
aws kafka create-cluster --cluster-name "AuthenticationTest" --broker-node-group-info file://brokernodegroupinfo.json --encryption-info file://encryptioninfo.json --client-authentication file://clientauthinfo.json --kafka-version "{YOUR KAFKA VERSION}" --number-of-broker-nodes 3
```
# Richten Sie einen Client für die Verwendung der Authentifizierung ein
Dieser Prozess beschreibt, wie Sie eine Amazon EC2 EC2-Instance einrichten, die als Client für die Authentifizierung verwendet wird.
Dieser Prozess beschreibt, wie Nachrichten mithilfe der Authentifizierung erzeugt und verarbeitet werden, indem ein Client-Computer erstellt, ein Thema erstellt und die erforderlichen Sicherheitseinstellungen konfiguriert werden.
1. Erstellen Sie eine Amazon-EC2-Instance, die als Client-Computer verwendet werden soll. Erstellen Sie diese Instance der Einfachheit halber in derselben VPC, die Sie für den Cluster verwendet haben. Unter [Schritt 3: Einen Client-Computer erstellen](create-client-machine.md) finden Sie ein Beispiel dafür, wie Sie solch einen Client-Computer erstellen können.
1. Erstellen eines Themas. Ein Beispiel finden Sie in den Anweisungen unter [Schritt 4: Erstellen Sie ein Thema im Amazon MSK-Cluster](create-topic.md).
1. Führen Sie auf einem Computer, auf dem Sie das AWS CLI installiert haben, den folgenden Befehl aus, um die Bootstrap-Broker des Clusters abzurufen. *Cluster-ARN*Ersetzen Sie es durch den ARN Ihres Clusters.
```
aws kafka get-bootstrap-brokers --cluster-arn Cluster-ARN
```
Speichern Sie die Zeichenfolge, die `BootstrapBrokerStringTls` in der Antwort zugeordnet ist.
1. Führen Sie auf Ihrem Client-Computer den folgenden Befehl aus, um mithilfe des JVM-Vertrauensspeichers Ihren Client-Vertrauensspeicher zu erstellen. Wenn Ihr JVM-Pfad anders ist, passen Sie den Befehl entsprechend an.
```
cp /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.201.b09-0.amzn2.x86_64/jre/lib/security/cacerts kafka.client.truststore.jks
```
1. Führen Sie auf Ihrem Client-Computer den folgenden Befehl aus, um einen privaten Schlüssel für Ihren Client zu erstellen. Ersetzen Sie *Distinguished-Name**Example-Alias*,*Your-Store-Pass*, und *Your-Key-Pass* durch Zeichenketten Ihrer Wahl.
```
keytool -genkey -keystore kafka.client.keystore.jks -validity 300 -storepass Your-Store-Pass -keypass Your-Key-Pass -dname "CN=Distinguished-Name" -alias Example-Alias -storetype pkcs12 -keyalg rsa
```
1. Führen Sie auf Ihrem Client-Computer den folgenden Befehl aus, um eine Zertifikatsanforderung mit dem privaten Schlüssel zu erstellen, den Sie im vorherigen Schritt erstellt haben.
```
keytool -keystore kafka.client.keystore.jks -certreq -file client-cert-sign-request -alias Example-Alias -storepass Your-Store-Pass -keypass Your-Key-Pass
```
1. Öffnen Sie die Datei `client-cert-sign-request`, und stellen Sie sicher, dass sie mit `-----BEGIN CERTIFICATE REQUEST-----` beginnt und mit `-----END CERTIFICATE REQUEST-----` endet. Wenn sie mit `-----BEGIN NEW CERTIFICATE REQUEST-----` beginnt , löschen Sie das Wort `NEW` (und das einzelne Leerzeichen, das darauf folgt) vom Anfang und vom Ende der Datei.
1. Führen Sie auf einem Computer, auf dem Sie das AWS CLI installiert haben, den folgenden Befehl aus, um Ihre Zertifikatsanforderung zu signieren. *Private-CA-ARN*Ersetzen Sie es durch den ARN Ihres PCA. Sie können den Gültigkeitswert ändern, wenn Sie möchten. Hier verwenden wir 300 als Beispiel.
```
aws acm-pca issue-certificate --certificate-authority-arn Private-CA-ARN --csr fileb://client-cert-sign-request --signing-algorithm "SHA256WITHRSA" --validity Value=300,Type="DAYS"
```
Speichern Sie den in der Antwort angegebenen Zertifikat-ARN.
**Anmerkung**
Um Ihr Client-Zertifikat abzurufen, verwenden Sie den Befehl `acm-pca get-certificate` und geben Sie Ihren Zertifikat-ARN an. Weitere Informationen finden Sie unter [get-certificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/acm-pca/get-certificate.html) in der *AWS CLI -Befehlsreferenz*.
1. Führen Sie den folgenden Befehl aus, um das Zertifikat abzurufen, das für Sie AWS Private CA signiert wurde. *Certificate-ARN*Ersetzen Sie durch den ARN, den Sie aus der Antwort auf den vorherigen Befehl erhalten haben.
```
aws acm-pca get-certificate --certificate-authority-arn Private-CA-ARN --certificate-arn Certificate-ARN
```
1. Kopieren Sie aus dem JSON-Ergebnis der Ausführung des vorherigen Befehls die Zeichenfolgen, die `Certificate` und `CertificateChain` zugeordnet sind. Fügen Sie diese beiden Zeichenketten in eine neue Datei mit dem Namen ein signed-certificate-from-acm. Fügen Sie die Zeichenfolge, die `Certificate` zugeordnet ist, zuerst ein, gefolgt von der Zeichenfolge, die `CertificateChain` zugeordnet ist. Ersetzen Sie die Zeichen `\n` durch neue Zeilen. Im Folgenden finden Sie die Struktur der Datei, nachdem Sie das Zertifikat und die Zertifikatkette eingefügt haben.
```
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
```
1. Führen Sie den folgenden Befehl auf dem Client-Computer aus, um dieses Zertifikat zu Ihrem Schlüsselspeicher hinzuzufügen, damit Sie es bei der Kommunikation mit den MSK-Brokern bereitstellen können.
```
keytool -keystore kafka.client.keystore.jks -import -file signed-certificate-from-acm -alias Example-Alias -storepass Your-Store-Pass -keypass Your-Key-Pass
```
1. Erstellen Sie eine Datei mit dem Namen `client.properties` und dem folgenden Inhalt. Passen Sie die Speicherorte des Vertrauensspeichers und des Schlüsselspeichers an die Pfade an, in denen Sie `kafka.client.truststore.jks` gespeichert haben. Ersetzen Sie die *\$1YOUR KAFKA VERSION\$1* Platzhalter durch Ihre Kafka-Client-Version.
```
security.protocol=SSL
ssl.truststore.location=/tmp/kafka_2.12-{YOUR KAFKA VERSION}/kafka.client.truststore.jks
ssl.keystore.location=/tmp/kafka_2.12-{YOUR KAFKA VERSION}/kafka.client.keystore.jks
ssl.keystore.password=Your-Store-Pass
ssl.key.password=Your-Key-Pass
```
# Erstellen und konsumieren Sie Nachrichten mithilfe von Authentifizierung
In diesem Prozess wird beschrieben, wie Nachrichten mithilfe von Authentifizierung erstellt und verarbeitet werden.
1. Führen Sie den folgenden Befehl aus, um ein Thema zu erstellen. Die Datei namens `client.properties` ist die Datei, die Sie im vorherigen Verfahren erstellt haben.
```
/bin/kafka-topics.sh --create --bootstrap-server BootstrapBroker-String --replication-factor 3 --partitions 1 --topic ExampleTopic --command-config client.properties
```
1. Führen Sie den folgenden Befehl aus, um einen Konsolenproduzenten zu starten. Die Datei namens `client.properties` ist die Datei, die Sie im vorherigen Verfahren erstellt haben.
```
/bin/kafka-console-producer.sh --bootstrap-server BootstrapBroker-String --topic ExampleTopic --producer.config client.properties
```
1. Führen Sie auf Ihrem Client-Computer in einem neuen Befehlsfenster den folgenden Befehl aus, um einen Konsolenverbraucher zu starten.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBroker-String --topic ExampleTopic --consumer.config client.properties
```
1. Geben Sie Nachrichten in das Produzentenfenster ein und beobachten Sie, wie sie im Verbraucherfenster angezeigt werden.
# Authentifizierung der Anmeldedaten mit AWS Secrets Manager
Sie können den Zugriff auf Ihre Amazon MSK-Cluster mithilfe von Anmeldeinformationen steuern, die mit AWS Secrets Manager gespeichert und gesichert werden. Das Speichern von Benutzeranmeldeinformationen in Secrets Manager reduziert den Aufwand für die Cluster-Authentifizierung, wie z. B. die Prüfung, Aktualisierung und Rotation von Anmeldeinformationen. Mit Secrets Manager können Sie auch Benutzeranmeldeinformationen clusterübergreifend freigeben.
Nachdem Sie einem MSK-Cluster ein Geheimnis zugeordnet haben, synchronisiert MSK die Anmeldedaten regelmäßig.
**Topics**
+ [
# So funktioniert die Authentifizierung mit den Anmeldedaten
](msk-password-howitworks.md)
+ [
# SASL/SCRAM Authentifizierung für einen Amazon MSK-Cluster einrichten
](msk-password-tutorial.md)
+ [
# Working with users
](msk-password-users.md)
+ [
# Einschränkungen bei der Verwendung von SCRAM-Geheimnissen
](msk-password-limitations.md)
# So funktioniert die Authentifizierung mit den Anmeldedaten
Die Authentifizierung der Anmeldedaten für Amazon MSK verwendet die Authentifizierung SASL/SCRAM (Simple Authentication and Security Layer/Salted Challenge Response Mechanism). Um die Authentifizierung über Anmeldeinformationen für einen Cluster einzurichten, erstellen Sie eine Secret-Ressource in [AWS Secrets Manager](https://docs.aws.amazon.com//secretsmanager/?id=docs_gateway) und ordnen diesem Secret Anmeldeinformationen zu.
SASL/SCRAM ist in [RFC 5802](https://tools.ietf.org/html/rfc5802) definiert. SCRAM verwendet gesicherte Hashing-Algorithmen und überträgt keine Klartext-Anmeldeinformationen zwischen dem Client und dem Server.
**Anmerkung**
Wenn Sie die SASL/SCRAM Authentifizierung für Ihren Cluster einrichten, aktiviert Amazon MSK die TLS-Verschlüsselung für den gesamten Datenverkehr zwischen Clients und Brokern.
# SASL/SCRAM Authentifizierung für einen Amazon MSK-Cluster einrichten
Um ein Geheimnis in AWS Secrets Manager einzurichten, folgen Sie dem Tutorial [Creating and Retrieving a Secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/tutorials_basic.html) im [AWS Secrets Manager Manager-Benutzerhandbuch](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html).
Beachten Sie die folgenden Anforderungen, wenn Sie ein Secret für einen Amazon-MSK-Cluster erstellen:
+ Wählen Sie für Secret-Typ die Option **Anderer Secret-Typ (z. B. API-Schlüssel)**.
+ Ihr Secret-Nname muss mit dem Präfix **AmazonMSK\$1** beginnen.
+ Sie müssen entweder einen vorhandenen benutzerdefinierten AWS KMS Schlüssel verwenden oder einen neuen benutzerdefinierten AWS KMS Schlüssel für Ihr Geheimnis erstellen. Secrets Manager verwendet standardmäßig den AWS KMS Standardschlüssel für ein Geheimnis.
**Wichtig**
Ein mit dem AWS KMS Standardschlüssel erstelltes Geheimnis kann nicht mit einem Amazon MSK-Cluster verwendet werden.
+ Ihre Anmeldeinformationen müssen das folgende Format haben, um Schlüssel-Wert-Paare mit der **Klartext**-Option eingeben zu können.
```
{
"username": "alice",
"password": "alice-secret"
}
```
+ Notieren Sie sich den ARN (Amazon-Ressourcenname) für Ihr Secret.
+
**Wichtig**
Sie können einem Cluster, der die unter [Passen Sie die Größe Ihres Clusters an: Anzahl der Partitionen pro Standard-Broker](bestpractices.md#partitions-per-broker) beschriebenen Grenzwerte überschreitet, kein Secrets-Manager-Secret zuordnen.
+ Wenn Sie den AWS CLI zum Erstellen des Geheimnisses verwenden, geben Sie eine Schlüssel-ID oder einen ARN für den `kms-key-id` Parameter an. Geben Sie keinen Alias an.
+ Um das Geheimnis Ihrem Cluster zuzuordnen, verwenden Sie entweder die Amazon MSK-Konsole oder den [ BatchAssociateScramSecret](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-scram-secrets.html#BatchAssociateScramSecret)Vorgang.
**Wichtig**
Wenn Sie einem Cluster ein Secret zuordnen, fügt Amazon MSK dem Secret eine Ressourcenrichtlinie hinzu, die es Ihrem Cluster ermöglicht, auf die von Ihnen definierten geheimen Werte zuzugreifen und diese zu lesen. Sie sollten diese Ressourcenrichtlinie nicht ändern. Andernfalls kann Ihr Cluster daran gehindert werden, auf Ihr Secret zuzugreifen. Wenn Sie Änderungen an der Secrets-Ressourcenrichtlinie und/oder dem für die geheime Verschlüsselung verwendeten KMS-Schlüssel vornehmen, stellen Sie sicher, dass Sie die Secrets erneut Ihrem MSK-Cluster zuordnen. Dadurch wird sichergestellt, dass Ihr Cluster weiterhin auf Ihr Geheimnis zugreifen kann.
Die folgende Beispiel-JSON-Eingabe für den Vorgang `BatchAssociateScramSecret` ordnet ein Secret einem Cluster zu:
```
{
"clusterArn" : "arn:aws:kafka:us-west-2:0123456789019:cluster/SalesCluster/abcd1234-abcd-cafe-abab-9876543210ab-4",
"secretArnList": [
"arn:aws:secretsmanager:us-west-2:0123456789019:secret:AmazonMSK_MyClusterSecret"
]
}
```
# Herstellen einer Verbindung zu Ihrem Cluster mit Anmeldeinformationen
Nachdem Sie ein Secret erstellt und es Ihrem Cluster zugeordnet haben, können Sie Ihren Client mit dem Cluster verbinden. Das folgende Verfahren zeigt, wie Sie einen Client mit einem Cluster verbinden, der SASL/SCRAM Authentifizierung verwendet. Außerdem wird anhand eines Beispielthemas gezeigt, wie das Produzieren und das Konsumieren anhand eines Beispielthemas erfolgt.
**Topics**
+ [
## Einen Client mithilfe der SASL/SCRAM Authentifizierung mit dem Cluster verbinden
](#w2aab9c13c29c17c13c11b9b7)
+ [
## Fehlerbehebung bei Verbindungsproblemen
](#msk-password-tutorial-connect-troubleshooting)
## Einen Client mithilfe der SASL/SCRAM Authentifizierung mit dem Cluster verbinden
1. Führen Sie den folgenden Befehl auf einem Computer aus, der AWS CLI installiert wurde. *clusterARN*Ersetzen Sie es durch den ARN Ihres Clusters.
```
aws kafka get-bootstrap-brokers --cluster-arn clusterARN
```
Speichern Sie aus dem JSON-Ergebnis dieses Befehls den Wert, der der genannten Zeichenfolge zugeordnet ist`BootstrapBrokerStringSaslScram`. Sie werden diesen Wert in späteren Schritten verwenden.
1. Erstellen Sie auf Ihrem Client-Computer eine JAAS-Konfigurationsdatei, die die in Ihrem Secret gespeicherten Benutzeranmeldeinformationen enthält. Erstellen Sie beispielsweise für den Benutzer **alice** eine Datei namens `users_jaas.conf` mit dem folgenden Inhalt.
```
KafkaClient {
org.apache.kafka.common.security.scram.ScramLoginModule required
username="alice"
password="alice-secret";
};
```
1. Verwenden Sie den folgenden Befehl, um Ihre JAAS-Konfigurationsdatei als `KAFKA_OPTS`-Umgebungsparameter zu exportieren.
```
export KAFKA_OPTS=-Djava.security.auth.login.config=/users_jaas.conf
```
1. Erstellen Sie in einem `/tmp`-Verzeichnis eine Datei namens `kafka.client.truststore.jks`.
1. (Optional) Verwenden Sie den folgenden Befehl, um die JDK-Schlüsselspeicherdatei aus Ihrem `cacerts` JVM-Ordner in die `kafka.client.truststore.jks` Datei zu kopieren, die Sie im vorherigen Schritt erstellt haben. *JDKFolder*Ersetzen Sie ihn durch den Namen des JDK-Ordners auf Ihrer Instanz. Beispielsweise könnte Ihr JDK-Ordner `java-1.8.0-openjdk-1.8.0.201.b09-0.amzn2.x86_64` benannt sein.
```
cp /usr/lib/jvm/JDKFolder/lib/security/cacerts /tmp/kafka.client.truststore.jks
```
1. Erstellen Sie im `bin`-Verzeichnis Ihrer Apache-Kafka-Installation eine Client-Eigenschaftendatei namens `client_sasl.properties` mit dem folgenden Inhalt. Diese Datei definiert den SASL-Mechanismus und das SASL-Protokoll.
```
security.protocol=SASL_SSL
sasl.mechanism=SCRAM-SHA-512
```
1. Führen Sie den folgenden Befehl aus, um ein Beispielthema zu erstellen. *BootstrapBrokerStringSaslScram*Ersetzen Sie es durch die Bootstrap-Broker-Zeichenfolge, die Sie in Schritt 1 dieses Themas abgerufen haben.
```
/bin/kafka-topics.sh --create --bootstrap-server BootstrapBrokerStringSaslScram --command-config /client_sasl.properties --replication-factor 3 --partitions 1 --topic ExampleTopicName
```
1. Führen Sie den folgenden Befehl auf Ihrem Client-Computer aus, um in dem von Ihnen erstellten Beispielthema zu produzieren. *BootstrapBrokerStringSaslScram*Ersetzen Sie sie durch die Bootstrap-Broker-Zeichenfolge, die Sie in Schritt 1 dieses Themas abgerufen haben.
```
/bin/kafka-console-producer.sh --broker-list BootstrapBrokerStringSaslScram --topic ExampleTopicName --producer.config client_sasl.properties
```
1. Führen Sie den folgenden Befehl auf Ihrem Client-Computer aus, um aus dem von Ihnen erstellten Thema zu verbrauchen. *BootstrapBrokerStringSaslScram*Ersetzen Sie sie durch die Bootstrap-Broker-Zeichenfolge, die Sie in Schritt 1 dieses Themas abgerufen haben.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBrokerStringSaslScram --topic ExampleTopicName --from-beginning --consumer.config client_sasl.properties
```
## Fehlerbehebung bei Verbindungsproblemen
Beim Ausführen von Kafka-Client-Befehlen können Java-Heap-Speicherfehler auftreten, insbesondere bei der Arbeit mit großen Themen oder Datensätzen. Diese Fehler treten auf, weil Kafka-Tools als Java-Anwendungen mit Standardspeichereinstellungen ausgeführt werden, die für Ihre Arbeitslast möglicherweise nicht ausreichen.
Um `Out of Memory Java Heap` Fehler zu beheben, können Sie die Größe des Java-Heaps erhöhen, indem Sie die `KAFKA_OPTS` Umgebungsvariable so ändern, dass sie Speichereinstellungen enthält.
Im folgenden Beispiel wird die maximale Heap-Größe auf 1 GB () festgelegt. `-Xmx1G` Sie können diesen Wert an Ihren verfügbaren Systemspeicher und Ihre Anforderungen anpassen.
```
export KAFKA_OPTS="-Djava.security.auth.login.config=/users_jaas.conf -Xmx1G"
```
Bei umfangreichen Themen sollten Sie die Verwendung von zeit- oder offsetbasierten Parametern in Betracht ziehen, anstatt die Speicherbelegung `--from-beginning` zu begrenzen:
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBrokerStringSaslScram --topic ExampleTopicName --max-messages 1000 --consumer.config client_sasl.properties
```
# Working with users
**Benutzer erstellen:** Sie erstellen Benutzer in Ihrem Secret als Schlüssel-Wert-Paare. Wenn Sie die **Klartext**-Option in der Secrets-Manager-Konsole verwenden, sollten Sie die Anmeldeinformationen im folgenden Format angeben.
```
{
"username": "alice",
"password": "alice-secret"
}
```
**Benutzerzugriff widerrufen:** Um die Anmeldeinformationen eines Benutzers für den Zugriff auf einen Cluster zu widerrufen, empfehlen wir, zuerst eine ACL für den Cluster zu entfernen oder zu erzwingen und dann die Zuordnung des Secrets aufzuheben. Dies ist auf Folgendes zurückzuführen:
+ Durch das Entfernen eines Benutzers werden bestehende Verbindungen nicht geschlossen.
+ Es dauert bis zu 10 Minuten, bis Änderungen an Ihrem Secret verbreitet sind.
Weitere Informationen zur Verwendung einer ACL mit Amazon MSK finden Sie unter [Apache Kafka ACLs](msk-acls.md).
Für Cluster, die ZooKeeper den Modus verwenden, empfehlen wir, den Zugriff auf Ihre ZooKeeper Knoten einzuschränken, um zu verhindern, dass Benutzer Änderungen vornehmen. ACLs Weitere Informationen finden Sie unter [Steuern Sie den Zugriff auf ZooKeeper Apache-Knoten in Ihrem Amazon MSK-Cluster](zookeeper-security.md).
# Einschränkungen bei der Verwendung von SCRAM-Geheimnissen
Beachten Sie die folgenden Einschränkungen bei der Verwendung von SCRAM-Secrets:
+ Amazon MSK unterstützt nur SCRAM-SHA-512-Authentifizierung.
+ Ein Amazon-MSK-Cluster kann bis zu 1 000 Benutzer haben.
+ Sie müssen eine AWS KMS key mit Ihrem Secret verwenden. Sie können kein Secret verwenden, das den standardmäßigen Secrets-Manager-Verschlüsselungsschlüssel mit Amazon MSK verwendet. Weitere Informationen zum Erstellen eines KMS-Schlüssels finden Sie unter [Erstellen von symmetrichen KMS-Verschlüsselungsschlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk).
+ Sie können keinen asymmetrischen KMS-Schlüssel mit Secrets Manager verwenden.
+ Mithilfe dieser [ BatchAssociateScramSecret](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-scram-secrets.html#BatchAssociateScramSecret)Operation können Sie einem Cluster bis zu 10 Geheimnisse gleichzeitig zuordnen.
+ Der Name von Secrets, die einem Amazon-MSK-Cluster zugeordnet sind, muss das Präfix **AmazonMSK\$1** haben.
+ Mit einem Amazon MSK-Cluster verknüpfte Geheimnisse müssen sich im selben Amazon Web Services Services-Konto und derselben AWS Region wie der Cluster befinden.
# Apache Kafka ACLs
Apache Kafka hat einen austauschbaren Authorizer und wird mit einer Authorizer-Implementierung geliefert. out-of-box Amazon MSK aktiviert diesen Autorisierer in der Datei `server.properties` auf den Brokern.
Apache Kafka ACLs haben das Format „Principal P ist [erlaubt/verweigert] Operation O von Host H auf einer beliebigen Ressource R, die RP entspricht“. ResourcePattern Wenn RP nicht mit einer bestimmten Ressource R übereinstimmt, hat R keine zugehörige Ressource ACLs, und daher darf niemand außer Superusern auf R zugreifen. Um dieses Verhalten von Apache Kafka zu ändern, setzen Sie die Eigenschaft `allow.everyone.if.no.acl.found` auf true. Amazon MSK setzt es standardmäßig auf true. Das bedeutet, dass bei Amazon MSK-Clustern alle Principals ACLs auf diese Ressource zugreifen können, wenn Sie nicht explizit eine Ressource festlegen. Wenn Sie eine Ressource ACLs aktivieren, können nur autorisierte Prinzipale darauf zugreifen. Wenn Sie den Zugriff auf ein Thema einschränken und einen Client mithilfe der gegenseitigen TLS-Authentifizierung autorisieren möchten, fügen Sie dies ACLs mithilfe der Apache Kafka-Autorisierungs-CLI hinzu. Weitere Informationen zum Hinzufügen, Entfernen und Auflisten ACLs finden Sie unter [Kafka Authorization](https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Authorization+Command+Line+Interface) Command Line Interface.
Da Amazon MSK Makler als Superuser konfiguriert, können sie auf alle Themen zugreifen. Dies hilft den Brokern, Nachrichten von der primären Partition zu replizieren, unabhängig davon, ob die `allow.everyone.if.no.acl.found` Eigenschaft für die Clusterkonfiguration definiert ist oder nicht.
**Hinzufügen oder Entfernen von Lese- und Schreibzugriff für ein Thema**
1. Fügen Sie Ihre Broker zur ACL-Tabelle hinzu, damit sie aus allen vorhandenen Themen lesen können. ACLs Um Ihren Brokern Lesezugriff auf ein Thema zu gewähren, führen Sie den folgenden Befehl auf einem Client-Computer aus, der mit dem MSK-Cluster kommunizieren kann.
*Distinguished-Name*Ersetzen Sie es durch den DNS eines der Bootstrap-Broker Ihres Clusters und ersetzen Sie dann die Zeichenfolge vor dem ersten Punkt in diesem eindeutigen Namen durch ein Sternchen ()`*`. Wenn beispielsweise einer der Bootstrap-Broker Ihres Clusters über den DNS verfügt`b-6.mytestcluster.67281x.c4.kafka.us-east-1.amazonaws.com`, ersetzen Sie ihn *Distinguished-Name* im folgenden Befehl durch. `*.mytestcluster.67281x.c4.kafka.us-east-1.amazonaws.com` Informationen zum Abrufen der Bootstrap-Broker finden Sie unter [Holen Sie sich die Bootstrap-Broker für einen Amazon MSK-Cluster](msk-get-bootstrap-brokers.md).
```
/bin/kafka-acls.sh --bootstrap-server BootstrapServerString --add --allow-principal "User:CN=Distinguished-Name" --operation Read --group=* --topic Topic-Name
```
1. Um einer Client-Anwendung Lesezugriff auf ein Thema zu gewähren, führen Sie den folgenden Befehl auf Ihrem Client-Computer aus. Wenn Sie die gegenseitige TLS-Authentifizierung verwenden, verwenden *Distinguished-Name* Sie dasselbe, das Sie bei der Erstellung des privaten Schlüssels verwendet haben.
```
/bin/kafka-acls.sh --bootstrap-server BootstrapServerString --add --allow-principal "User:CN=Distinguished-Name" --operation Read --group=* --topic Topic-Name
```
Zum Entfernen des Lesezugriffs können Sie denselben Befehl ausführen und `--add` durch `--remove` ersetzen.
1. Zum Gewähren von Schreibzugriff auf ein Thema führen Sie den folgenden Befehl auf Ihrem Client-Computer aus. Wenn Sie die gegenseitige TLS-Authentifizierung verwenden, verwenden *Distinguished-Name* Sie dieselbe, die Sie bei der Erstellung des privaten Schlüssels verwendet haben.
```
/bin/kafka-acls.sh --bootstrap-server BootstrapServerString --add --allow-principal "User:CN=Distinguished-Name" --operation Write --topic Topic-Name
```
Zum Entfernen des Schreibzugriffs können Sie denselben Befehl ausführen und `--add` durch `--remove` ersetzen.
# Ändern der Sicherheitsgruppe eines Amazon-MSK-Clusters
Auf dieser Seite wird erklärt, wie Sie die Sicherheitsgruppe eines vorhandenen MSK-Clusters ändern. Möglicherweise müssen Sie die Sicherheitsgruppe eines Clusters ändern, um einer bestimmten Gruppe von Benutzern Zugriff zu gewähren oder den Zugriff auf den Cluster einzuschränken. Weitere Informationen zu Sicherheitsgruppen finden Sie unter [Sicherheitsgruppen für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) im Amazon-VPC-Benutzerhandbuch.
1. Verwenden Sie die [ListNodes](https://docs.amazonaws.cn/en_us/msk/1.0/apireference/clusters-clusterarn-nodes.html#ListNodes)API oder den Befehl [list-nodes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kafka/list-nodes.html) in AWS CLI , um eine Liste der Broker in Ihrem Cluster abzurufen. Zu den Ergebnissen dieses Vorgangs gehören die IDs Elastic Network-Schnittstellen (ENIs), die den Brokern zugeordnet sind.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Dropdown-Menü in der oberen rechten Ecke des Bildschirms die Region aus, in der der Cluster bereitgestellt wird.
1. Wählen Sie im linken Bereich unter **Netzwerk und Sicherheit** die Option **Netzwerkschnittstellen**.
1. Wählen Sie die erste ENI aus, die Sie im ersten Schritt erhalten haben. Wählen Sie oben auf dem Bildschirm das Menü **Aktionen** und anschließend **Sicherheitsgruppen ändern**. Weisen Sie dieser ENI die neue Sicherheitsgruppe zu. Wiederholen Sie diesen Schritt für jedes Element ENIs , das Sie im ersten Schritt erhalten haben.
**Anmerkung**
Änderungen, die Sie mit der Amazon-EC2-Konsole an der Sicherheitsgruppe eines Clusters vornehmen, werden nicht in der MSK-Konsole unter **Netzwerkeinstellungen** wiedergegeben.
1. Konfigurieren Sie die Regeln der neuen Sicherheitsgruppe, um sicherzustellen, dass Ihre Clients Zugriff auf die Broker haben. Weitere Informationen zum Einrichten von Regeln für Sicherheitsgruppen finden Sie unter [Hinzufügen, Entfernen und Aktualisieren von Regeln](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html?shortFooter=true#AddRemoveRules) im Amazon-VPC-Benutzerhandbuch.
**Wichtig**
Wenn Sie die Sicherheitsgruppe ändern, die den Brokern eines Clusters zugeordnet ist, und diesem Cluster dann neue Broker hinzufügen, ordnet Amazon MSK die neuen Broker der ursprünglichen Sicherheitsgruppe zu, die dem Cluster zugeordnet war, als der Cluster erstellt wurde. Damit ein Cluster jedoch ordnungsgemäß funktioniert, müssen alle seine Broker derselben Sicherheitsgruppe zugeordnet sein. Wenn Sie also nach dem Ändern der Sicherheitsgruppe neue Broker hinzufügen, müssen Sie das vorherige Verfahren erneut ausführen und ENIs die neuen Broker aktualisieren.
# Steuern Sie den Zugriff auf ZooKeeper Apache-Knoten in Ihrem Amazon MSK-Cluster
Aus Sicherheitsgründen können Sie den Zugriff auf die ZooKeeper Apache-Knoten einschränken, die Teil Ihres Amazon MSK-Clusters sind. Zum Beschränken des Zugriffs auf die Knoten können Sie ihnen eine separate Sicherheitsgruppe zuweisen. Anschließend können Sie entscheiden, wer Zugriff auf diese Sicherheitsgruppe erhält.
**Wichtig**
Dieser Abschnitt gilt nicht für Cluster, die im KRaft Modus ausgeführt werden. Siehe [KRaft Modus](metadata-management.md#kraft-intro).
**Topics**
+ [
# Um Ihre ZooKeeper Apache-Knoten einer separaten Sicherheitsgruppe zuzuordnen
](zookeeper-security-group.md)
+ [
# Verwendung der TLS-Sicherheit mit Apache ZooKeeper
](zookeeper-security-tls.md)
# Um Ihre ZooKeeper Apache-Knoten einer separaten Sicherheitsgruppe zuzuordnen
Um den Zugriff auf ZooKeeper Apache-Knoten zu beschränken, können Sie ihnen eine separate Sicherheitsgruppe zuweisen. Sie können auswählen, wer Zugriff auf diese neue Sicherheitsgruppe hat, indem Sie Sicherheitsgruppenregeln festlegen.
1. Rufen Sie die ZooKeeper Apache-Verbindungszeichenfolge für Ihren Cluster ab. Um zu erfahren wie dies geht, vgl. [ZooKeeper Modus](metadata-management.md#msk-get-connection-string). Die Verbindungszeichenfolge enthält die DNS-Namen Ihrer ZooKeeper Apache-Knoten.
1. Verwenden Sie ein Tool wie `host` oder `ping`, um die DNS-Namen, die Sie im vorherigen Schritt erhalten haben, in IP-Adressen zu konvertieren. Speichern Sie diese IP-Adressen, da Sie sie später in diesem Verfahren benötigen.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Klicken Sie im linken Bereich unter **NETWORK & SECURITY (NETZWERK UND SICHERHEIT)** auf **Network Interfaces (Netzwerkschnittstellen)**.
1. Geben Sie im Suchfeld über der Tabelle der Netzwerkschnittstellen den Namen des Clusters ein, und geben Sie dann „return“ ein. Dadurch wird die Anzahl der Netzwerkschnittstellen, die in der Tabelle angezeigt werden, auf die Schnittstellen beschränkt, die dem Cluster zugeordnet sind.
1. Aktivieren Sie das Kontrollkästchen am Anfang der Zeile, die der ersten Netzwerkschnittstelle in der Liste entspricht.
1. Suchen Sie im Detailbereich unten auf der Seite nach der **primären privaten IPv4 IP**. Wenn diese IP-Adresse mit einer der IP-Adressen übereinstimmt, die Sie im ersten Schritt dieses Verfahrens erhalten haben, bedeutet dies, dass diese Netzwerkschnittstelle einem ZooKeeper Apache-Knoten zugewiesen ist, der Teil Ihres Clusters ist. Andernfalls deaktivieren Sie das Kontrollkästchen neben dieser Netzwerkschnittstelle, und wählen Sie die nächste Netzwerkschnittstelle in der Liste aus. Die Reihenfolge, in der Sie die Netzwerkschnittstellen auswählen, spielt keine Rolle. In den nächsten Schritten führen Sie nacheinander dieselben Operationen an allen Netzwerkschnittstellen durch, die ZooKeeper Apache-Knoten zugewiesen sind.
1. Wenn Sie eine Netzwerkschnittstelle auswählen, die einem ZooKeeper Apache-Knoten entspricht, wählen Sie oben auf der Seite das Menü **Aktionen** und dann **Sicherheitsgruppen ändern**. Weisen Sie dieser Netzwerkschnittstelle eine neue Sicherheitsgruppe zu. Weitere Informationen zum Erstellen von Sicherheitsgruppen finden Sie unter [Erstellen einer Sicherheitsgruppe](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html?shortFooter=true#CreatingSecurityGroups) in der Amazon-VPC-Dokumentation.
1. Wiederholen Sie den vorherigen Schritt, um allen Netzwerkschnittstellen, die den ZooKeeper Apache-Knoten Ihres Clusters zugeordnet sind, dieselbe neue Sicherheitsgruppe zuzuweisen.
1. Nun können Sie auswählen, wer Zugriff auf diese neue Sicherheitsgruppe hat. Weitere Informationen zum Einrichten von Regeln für Sicherheitsgruppen finden Sie unter [Hinzufügen, Entfernen und Aktualisieren von Regeln](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html?shortFooter=true#AddRemoveRules) in der Amazon-VPC-Dokumentation.
# Verwendung der TLS-Sicherheit mit Apache ZooKeeper
Sie können die TLS-Sicherheit für die Verschlüsselung bei der Übertragung zwischen Ihren Clients und Ihren ZooKeeper Apache-Knoten verwenden. Gehen Sie wie folgt vor, um die TLS-Sicherheit mit Ihren ZooKeeper Apache-Knoten zu implementieren:
+ Cluster müssen Apache Kafka Version 2.5.1 oder höher verwenden, um TLS-Sicherheit mit Apache verwenden zu können. ZooKeeper
+ Aktivieren Sie die TLS-Sicherheit, wenn Sie Ihren Cluster erstellen oder konfigurieren. Cluster, die mit Apache Kafka Version 2.5.1 oder höher und aktiviertem TLS erstellt wurden, verwenden automatisch TLS-Sicherheit mit Apache-Endpunkten. ZooKeeper Weitere Informationen zur Einrichtung von TLS-Sicherheit finden Sie unter [Erste Schritte mit der Amazon MSK-Verschlüsselung](msk-working-with-encryption.md).
+ Rufen Sie die TLS-Apache ZooKeeper Endpoints mithilfe des Vorgangs ab. [DescribeCluster ](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn.html#DescribeCluster)
+ Erstellen Sie eine ZooKeeper Apache-Konfigurationsdatei zur Verwendung mit den [https://kafka.apache.org/documentation/#security_authz_cli](https://kafka.apache.org/documentation/#security_authz_cli)Tools `kafka-configs.sh` und oder mit der ZooKeeper Shell. Bei jedem Tool verwenden Sie den `--zk-tls-config-file` Parameter, um Ihre ZooKeeper Apache-Konfiguration anzugeben.
Das folgende Beispiel zeigt eine typische ZooKeeper Apache-Konfigurationsdatei:
```
zookeeper.ssl.client.enable=true
zookeeper.clientCnxnSocket=org.apache.zookeeper.ClientCnxnSocketNetty
zookeeper.ssl.keystore.location=kafka.jks
zookeeper.ssl.keystore.password=test1234
zookeeper.ssl.truststore.location=truststore.jks
zookeeper.ssl.truststore.password=test1234
```
+ Für andere Befehle (z. B.`kafka-topics`) müssen Sie die `KAFKA_OPTS` Umgebungsvariable verwenden, um ZooKeeper Apache-Parameter zu konfigurieren. Das folgende Beispiel zeigt, wie die `KAFKA_OPTS` Umgebungsvariable so konfiguriert wird, dass ZooKeeper Apache-Parameter an andere Befehle übergeben werden:
```
export KAFKA_OPTS="
-Dzookeeper.clientCnxnSocket=org.apache.zookeeper.ClientCnxnSocketNetty
-Dzookeeper.client.secure=true
-Dzookeeper.ssl.trustStore.location=/home/ec2-user/kafka.client.truststore.jks
-Dzookeeper.ssl.trustStore.password=changeit"
```
Nachdem Sie die `KAFKA_OPTS`-Umgebungsvariable konfiguriert haben, können Sie CLI-Befehle normal verwenden. Im folgenden Beispiel wird mithilfe der ZooKeeper Apache-Konfiguration aus der `KAFKA_OPTS` Umgebungsvariablen ein Apache Kafka-Thema erstellt:
```
/bin/kafka-topics.sh --create --zookeeper ZooKeeperTLSConnectString --replication-factor 3 --partitions 1 --topic AWSKafkaTutorialTopic
```
**Anmerkung**
Die Namen der Parameter, die Sie in Ihrer ZooKeeper Apache-Konfigurationsdatei verwenden, und der Parameter, die Sie in Ihrer `KAFKA_OPTS` Umgebungsvariablen verwenden, sind nicht konsistent. Achten Sie darauf, welche Namen Sie mit welchen Parametern in Ihrer Konfigurationsdatei und `KAFKA_OPTS`-Umgebungsvariablen verwenden.
Weitere Informationen zum Zugriff auf Ihre ZooKeeper Apache-Knoten mit TLS finden Sie unter [KIP-515: Aktivieren Sie den ZK-Client, um die neue TLS-unterstützte Authentifizierung zu verwenden](https://cwiki.apache.org/confluence/display/KAFKA/KIP-515%3A+Enable+ZK+client+to+use+the+new+TLS+supported+authentication).
# Compliance-Validierung für Amazon Managed Streaming für Apache Kafka
Externe Prüfer bewerten im Rahmen verschiedener AWS -Compliance-Programme die Sicherheit und Compliance von Amazon Managed Streaming für Apache Kafka. Dazu gehören PCI und HIPAA BAA.
Eine Liste der AWS Services im Rahmen bestimmter Compliance-Programme finden Sie unter [Amazon Services in Umfang nach Compliance-Programm](https://aws.amazon.com/compliance/services-in-scope/) . Allgemeine Informationen finden Sie unter [AWS Compliance-Programme AWS](https://aws.amazon.com/compliance/programs/) .
Sie können Prüfberichte von Drittanbietern unter herunterladen AWS Artifact. Weitere Informationen finden Sie unter [Berichte herunterladen unter ](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html).
Ihre Compliance-Verantwortung bei der Nutzung von Amazon MSK hängt von der Sensibilität Ihrer Daten, den Compliance-Zielen Ihres Unternehmens und den geltenden Gesetzen und Vorschriften ab. AWS bietet die folgenden Ressourcen zur Unterstützung bei der Einhaltung von Vorschriften:
+ [Schnellstartanleitungen für Sicherheit und Compliance](https://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance) – In diesen Bereitstellungsleitfäden werden architektonische Überlegungen erörtert und Schritte für die Bereitstellung von sicherheits- und konformitätsorientierten Basisumgebungen auf AWS angegeben.
+ Whitepaper „[Architecting for HIPAA Security and Compliance“ — In diesem Whitepaper](https://docs.aws.amazon.com/whitepapers/latest/architecting-hipaa-security-and-compliance-on-aws/architecting-hipaa-security-and-compliance-on-aws.html) wird beschrieben, wie Unternehmen HIPAA-konforme Anwendungen erstellen können AWS .
+ [AWS Compliance-Ressourcen ](https://aws.amazon.com/compliance/resources/) — Diese Sammlung von Arbeitsmappen und Leitfäden kann auf Ihre Branche und Ihren Standort zutreffen.
+ [Bewertung von Ressourcen anhand von Regeln](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html) im *AWS Config Entwicklerhandbuch* — Der AWS Config Service bewertet, wie gut Ihre Ressourcenkonfigurationen den internen Praktiken, Branchenrichtlinien und Vorschriften entsprechen.
+ [AWS Security Hub CSPM](https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html)— Dieser AWS Service bietet einen umfassenden Überblick über Ihren Sicherheitsstatus, sodass Sie überprüfen können AWS , ob Sie die Sicherheitsstandards und Best Practices der Branche einhalten.
# Ausfallsicherheit in Amazon Managed Streaming für Apache Kafka
Die AWS globale Infrastruktur basiert auf AWS Regionen und Availability Zones. AWS Regionen bieten mehrere physisch getrennte und isolierte Availability Zones, die über Netzwerke mit niedriger Latenz, hohem Durchsatz und hoher Redundanz miteinander verbunden sind. Mithilfe von Availability Zones können Sie Anwendungen und Datenbanken erstellen und ausführen, die automatisch Failover zwischen Zonen ausführen, ohne dass es zu Unterbrechungen kommt. Availability Zones sind besser verfügbar, fehlertoleranter und skalierbarer als herkömmliche Infrastrukturen mit einem oder mehreren Rechenzentren.
Weitere Informationen zu AWS Regionen und Availability Zones finden Sie unter [AWS Globale](https://aws.amazon.com/about-aws/global-infrastructure/) Infrastruktur.
# Infrastruktursicherheit in Amazon Managed Streaming für Apache Kafka
Als verwalteter Service ist Amazon Managed Streaming for Apache Kafka durch die AWS globalen Netzwerksicherheitsverfahren geschützt, die im Whitepaper [Amazon Web Services: Sicherheitsprozesse im Überblick](https://d0.awsstatic.com/whitepapers/Security/AWS_Security_Whitepaper.pdf) beschrieben werden.
Sie verwenden AWS veröffentlichte API-Aufrufe, um über das Netzwerk auf Amazon MSK zuzugreifen. Kunden müssen Transport Layer Security (TLS) 1.0 oder neuer unterstützen. Wir empfehlen TLS 1.2 oder höher. Clients müssen außerdem Verschlüsselungssammlungen mit PFS (Perfect Forward Secrecy) wie DHE (Ephemeral Diffie-Hellman) oder ECDHE (Elliptic Curve Ephemeral Diffie-Hellman) unterstützen. Die meisten modernen Systemen wie Java 7 und höher unterstützen diese Modi.
Außerdem müssen Anforderungen mit einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel signiert sein, der einem IAM-Prinzipal zugeordnet ist. Alternativ können Sie mit [AWS -Security-Token-Service](https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html) (AWS STS) temporäre Sicherheitsanmeldeinformationen erstellen, um die Anforderungen zu signieren.