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.
# Datenschutz in MemoryDB
Das [Modell der AWS gemeinsamen Verantwortung](https://aws.amazon.com/compliance/shared-responsibility-model/) gilt für den Datenschutz in. Wie in diesem Modell beschrieben, AWS ist verantwortlich für den Schutz der globalen Infrastruktur, auf der alle Systeme laufen AWS Cloud. 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 der Konsole, der API oder auf andere AWS-Services Weise arbeiten oder diese verwenden. AWS CLI AWS SDKs 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.
# Datensicherheit in MemoryDB
Um Ihre Daten zu schützen, bieten MemoryDB und Amazon EC2 Mechanismen zum Schutz vor unbefugtem Zugriff auf Ihre Daten auf dem Server.
MemoryDB bietet auch Verschlüsselungsfunktionen für Daten auf Clustern:
+ Bei der Verschlüsselung während der Übertragung werden Ihre Daten bei der Verschiebung von einem Ort an den anderen, z. B. zwischen Knoten in Ihrem Cluster oder zwischen einem Cluster und Ihrer Anwendung, verschlüsselt.
+ Bei der Verschlüsselung im Ruhezustand werden das Transaktionsprotokoll und Ihre Daten auf der Festplatte bei Snapshot-Vorgängen verschlüsselt.
Sie können sie auch verwenden[Benutzer mit Zugriffskontrolllisten authentifizieren () ACLs](clusters.acls.md), um den Benutzerzugriff auf Ihre Cluster zu kontrollieren.
**Topics**
+ [
# Datensicherheit in MemoryDB
](encryption.md)
+ [
# Verschlüsselung im Ruhezustand in MemoryDB
](at-rest-encryption.md)
+ [
# Verschlüsselung während der Übertragung (TLS) in MemoryDB
](in-transit-encryption.md)
+ [
# Benutzer mit Zugriffskontrolllisten authentifizieren () ACLs
](clusters.acls.md)
+ [
# Authentifizieren mit IAM
](auth-iam.md)
# Verschlüsselung im Ruhezustand in MemoryDB
Um Ihre Daten zu schützen, bieten MemoryDB und Amazon S3 verschiedene Möglichkeiten, den Zugriff auf Daten in Ihren Clustern einzuschränken. Weitere Informationen erhalten Sie unter [MemoryDB und Amazon VPC](vpcs.md) und [Identitäts- und Zugriffsmanagement in MemoryDB](iam.md).
Die Verschlüsselung im Ruhezustand von MemoryDB ist immer aktiviert, um die Datensicherheit durch Verschlüsselung persistenter Daten zu erhöhen. Sie verschlüsselt die folgenden Aspekte:
+ Daten im Transaktionslog
+ Festplatte bei Synchronisierungs-, Snapshot- und Swap-Vorgängen
+ In Amazon S3 gespeicherte Schnappschüsse
MemoryDB bietet standardmäßige (vom Service verwaltete) Verschlüsselung im Ruhezustand sowie die Möglichkeit, Ihre eigenen symmetrischen, vom Kunden verwalteten Stammschlüssel im [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) (KMS) zu verwenden.
Daten, die auf SSDs (Solid-State-Laufwerken) in Clustern mit aktivierter Datenklassifizierung gespeichert sind, werden standardmäßig immer verschlüsselt.
Weitere Informationen über Verschlüsselung während der Übertragung finden Sie unter [Verschlüsselung während der Übertragung (TLS) in MemoryDB](in-transit-encryption.md).
**Topics**
+ [
## Verwenden von vom Kunden verwalteten Schlüsseln von KMS AWS
](#using-customer-managed-keys-for-memorydb-security)
+ [
## Weitere Informationen finden Sie unter:
](#at-rest-encryption-see-also)
## Verwenden von vom Kunden verwalteten Schlüsseln von KMS AWS
MemoryDB unterstützt symmetrische, vom Kunden verwaltete Stammschlüssel (KMS-Schlüssel) für die Verschlüsselung im Ruhezustand. Kundenverwaltete KMS-Schlüssel sind Verschlüsselungsschlüssel, die Sie in Ihrem Konto erstellen, besitzen und verwalten. AWS Weitere Informationen finden Sie unter [Stammschlüssel für Kunden](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#root_keys) im *AWS Key Management Service Developer Guide*. Die Schlüssel müssen in AWS KMS erstellt werden, bevor sie mit MemoryDB verwendet werden können.
Informationen zum Erstellen von AWS KMS-Root-Schlüsseln finden Sie unter [Creating Keys](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) im *AWS Key Management Service Developer Guide*.
MemoryDB ermöglicht Ihnen die Integration mit AWS KMS. Weitere Informationen finden Sie unter [Verwendung von Berechtigungen](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) im *Entwicklerhandbuch zum AWS -Schlüsselverwaltungsdienst*. Es sind keine Kundenaktionen erforderlich, um die MemoryDB-Integration mit KMS zu aktivieren. AWS
Der `kms:ViaService` Bedingungsschlüssel beschränkt die Verwendung eines AWS KMS-Schlüssels auf Anfragen von bestimmten AWS Diensten. Zur Verwendung `kms:ViaService` mit MemoryDB schließen Sie beide ViaService Namen in den Wert des Bedingungsschlüssels ein:. `memorydb.amazon_region.amazonaws.com` Weitere Informationen finden Sie unter [kms](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-via-service):. ViaService
Sie können [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html)damit die Anfragen verfolgen, an die MemoryDB in AWS Key Management Service Ihrem Namen sendet. Alle API-Aufrufe, die sich auf AWS Key Management Service vom Kunden verwaltete Schlüssel beziehen, haben entsprechende CloudTrail Protokolle. Sie können auch die Grants sehen, die MemoryDB erstellt, indem Sie den [ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html)KMS-API-Aufruf aufrufen.
Sobald ein Cluster mit einem vom Kunden verwalteten Schlüssel verschlüsselt wurde, werden alle Snapshots für den Cluster wie folgt verschlüsselt:
+ Automatische tägliche Snapshots werden mit dem vom Kunden verwalteten Schlüssel verschlüsselt, der dem Cluster zugeordnet ist.
+ Der endgültige Snapshot, der beim Löschen des Clusters erstellt wird, wird ebenfalls mit dem vom Kunden verwalteten Schlüssel verschlüsselt, der dem Cluster zugeordnet ist.
+ Manuell erstellte Snapshots werden standardmäßig so verschlüsselt, dass sie den KMS-Schlüssel verwenden, der dem Cluster zugeordnet ist. Mit einem anderen kundenverwalteten Schlüssel können Sie dies außer Kraft setzen.
+ Beim Kopieren eines Snapshots wird standardmäßig der vom Kunden verwaltete Schlüssel verwendet, der dem Quell-Snapshot zugeordnet ist. Mit einem anderen kundenverwalteten Schlüssel können Sie dies außer Kraft setzen.
**Anmerkung**
Vom Kunden verwaltete Schlüssel können nicht verwendet werden, wenn Snapshots in den ausgewählten Amazon S3 S3-Bucket exportiert werden. Alle nach Amazon S3 exportierten Snapshots werden jedoch mit [serverseitiger Verschlüsselung](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) verschlüsselt. Sie können die Snapshot-Datei in ein neues S3-Objekt kopieren und mit einem vom Kunden verwalteten KMS-Schlüssel verschlüsseln, die Datei in einen anderen S3-Bucket kopieren, der mit Standardverschlüsselung mit einem KMS-Schlüssel eingerichtet ist, oder eine Verschlüsselungsoption in der Datei selbst ändern.
Sie können auch vom Kunden verwaltete Schlüssel verwenden, um manuell erstellte Snapshots zu verschlüsseln, die keine vom Kunden verwalteten Schlüssel für die Verschlüsselung verwenden. Mit dieser Option wird die in Amazon S3 gespeicherte Snapshot-Datei mit einem KMS-Schlüssel verschlüsselt, obwohl die Daten auf dem ursprünglichen Cluster nicht verschlüsselt sind.
Bei der Wiederherstellung aus einem Snapshot können Sie aus verfügbaren Verschlüsselungsoptionen wählen, ähnlich den Verschlüsselungsoptionen, die bei der Erstellung eines neuen Clusters verfügbar sind.
+ Wenn Sie den Schlüssel löschen oder den Schlüssel [deaktivieren](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) und Berechtigungen für den Schlüssel, den Sie zur Verschlüsselung eines Clusters verwendet haben, [widerrufen](https://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html), kann der Cluster nicht mehr wiederhergestellt werden. Mit anderen Worten, er kann nach einem Hardwarefehler nicht geändert oder wiederhergestellt werden. AWS KMS löscht Root-Schlüssel erst nach einer Wartezeit von mindestens sieben Tagen. Nachdem der Schlüssel gelöscht wurde, können Sie einen anderen vom Kunden verwalteten Schlüssel verwenden, um einen Snapshot für Archivierungszwecke zu erstellen.
+ Bei der automatischen Schlüsselrotation bleiben die Eigenschaften Ihrer AWS KMS-Root-Schlüssel erhalten, sodass die Rotation keine Auswirkungen auf Ihre Fähigkeit hat, auf Ihre MemoryDB-Daten zuzugreifen. Verschlüsselte MemoryDB-Cluster unterstützen keine manuelle Schlüsselrotation, bei der ein neuer Stammschlüssel erstellt und alle Verweise auf den alten Schlüssel aktualisiert werden müssen. Weitere Informationen finden Sie unter [Rotation der Stammschlüssel von Kunden](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) im *AWS Key Management Service Developer Guide*.
+ Für die Verschlüsselung eines MemoryDB-Clusters mithilfe eines KMS-Schlüssels ist ein Grant pro Cluster erforderlich. Dieser Zuschuss wird während der gesamten Lebensdauer des Clusters verwendet. Darüber hinaus wird bei der Snapshot-Erstellung ein Grant pro Snapshot verwendet. Dieser Zuschuss wird zurückgezogen, sobald der Snapshot erstellt wurde.
+ Weitere Informationen zu AWS KMS-Zuschüssen und -Limits finden Sie unter [Kontingente](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html) im *AWS Key Management Service Developer Guide*.
## Weitere Informationen finden Sie unter:
+ [Verschlüsselung während der Übertragung (TLS) in MemoryDB](in-transit-encryption.md)
+ [MemoryDB und Amazon VPC](vpcs.md)
+ [Identitäts- und Zugriffsmanagement in MemoryDB](iam.md)
# Verschlüsselung während der Übertragung (TLS) in MemoryDB
Um Ihre Daten zu schützen, EC2 bieten MemoryDB und Amazon Mechanismen zum Schutz vor unbefugtem Zugriff auf Ihre Daten auf dem Server. Durch die Bereitstellung von Verschlüsselungsfunktionen während der Übertragung bietet Ihnen MemoryDB ein Tool, mit dem Sie Ihre Daten schützen können, wenn sie von einem Ort zum anderen übertragen werden. Sie können beispielsweise Daten von einem primären Knoten auf einen Read Replica-Knoten innerhalb eines Clusters oder zwischen Ihrem Cluster und Ihrer Anwendung verschieben.
**Topics**
+ [
## Übersicht über die Verschlüsselung während der Übertragung
](#in-transit-encryption-overview)
+ [
## Weitere Informationen finden Sie auch unter
](#in-transit-encryption-see-also)
## Übersicht über die Verschlüsselung während der Übertragung
Die MemoryDB-Verschlüsselung bei der Übertragung ist eine Funktion, die die Sicherheit Ihrer Daten an den anfälligsten Stellen erhöht, d. h. wenn sie von einem Ort zum anderen übertragen werden.
Die MemoryDB-Verschlüsselung bei der Übertragung implementiert die folgenden Funktionen:
+ **Verschlüsselte Verbindungen** — Sowohl die Server- als auch die Client-Verbindungen sind mit Transport Layer Security (TLS) verschlüsselt.
+ **Verschlüsselte Replikation** – Daten, die zwischen einem Primärknoten und Replikationsknoten übertragen werden, sind verschlüsselt.
+ **Serverauthentifizierung** – Clients können die Verbindung zum richtigen Server authentifizieren.
Ab dem 20.07.2023 ist TLS 1.2 die unterstützte Mindestversion für neue und bestehende Cluster. Verwenden Sie diesen [Link](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/), um mehr über TLS 1.2 zu erfahren unter. AWS
Weitere Informationen zum Herstellen einer Verbindung zu MemoryDB-Clustern finden Sie unter. [Mit Redis-Cli eine Verbindung zu MemoryDB-Knoten herstellen](getting-started.md#connect-tls)
## Weitere Informationen finden Sie auch unter
+ [Verschlüsselung im Ruhezustand in MemoryDB](at-rest-encryption.md)
+ [Benutzer mit Zugriffskontrolllisten authentifizieren () ACLs](https://docs.aws.amazon.com/memorydb/latest/devguide/clusters.acls.html)
+ [MemoryDB und Amazon VPC](vpcs.md)
+ [Identitäts- und Zugriffsmanagement in MemoryDB](iam.md)
# Benutzer mit Zugriffskontrolllisten authentifizieren () ACLs
Sie können Benutzer mit Zugriffskontrolllisten () authentifizieren. ACLs
ACLs ermöglichen es Ihnen, den Clusterzugriff zu kontrollieren, indem Sie Benutzer gruppieren. Diese Zugriffskontrolllisten dienen dazu, den Zugriff auf Cluster zu organisieren.
Mit ACLs erstellen Sie Benutzer und weisen ihnen mithilfe einer Zugriffszeichenfolge bestimmte Berechtigungen zu, wie im nächsten Abschnitt beschrieben. Sie weisen die Benutzer Zugriffskontrolllisten zu, die einer bestimmten Rolle (Administratoren, Personalabteilung) zugeordnet sind, die dann in einem oder mehreren MemoryDB-Clustern bereitgestellt werden. Auf diese Weise können Sie Sicherheitsgrenzen zwischen Clients einrichten, die denselben MemoryDB-Cluster oder dieselben MemoryDB-Cluster verwenden, und verhindern, dass Clients gegenseitig auf die Daten zugreifen.
ACLs wurden entwickelt, um die Einführung von [ACL](https://valkey.io/docs/topics/acl/) in Redis OSS 6 zu unterstützen. Bei der Verwendung ACLs mit Ihrem MemoryDB-Cluster gibt es einige Einschränkungen:
+ Sie können keine Passwörter in einer Zugriffsfolge angeben. Sie legen Passwörter mit [CreateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateUser.html)oder [UpdateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateUser.html)Anrufen fest.
+ Für Benutzerrechte übergeben Sie `on` und `off` als Teil der Zugriffszeichenfolge. Wenn nichts in der Zugriffszeichenfolge angegeben ist, wird dem Benutzer zugewiesen `off` und er hat keine Zugriffsrechte für den Cluster.
+ Sie können keine verbotenen Befehle verwenden. Wenn Sie einen verbotenen Befehl angeben, wird eine Ausnahme ausgelöst. Eine Liste dieser Befehle finden Sie unter[Eingeschränkte Befehle](restrictedcommands.md).
+ Sie können den `reset`-Befehl als Teil einer Zugriffszeichenfolge nicht benutzen. Sie geben Passwörter mit API-Parametern an, und MemoryDB verwaltet Passwörter. Daher können Sie `reset` nicht nutzen, da es alle Kennwörter für einen Benutzer entfernen würde.
+ Redis OSS 6 führt den Befehl [ACL](https://valkey.io/commands/acl-list) LIST ein. Dieser Befehl gibt eine Liste der Benutzer zusammen mit den ACL-Regeln zurück, die auf jeden Benutzer angewendet wurden. MemoryDB unterstützt den `ACL LIST` Befehl, bietet jedoch keine Unterstützung für Passwort-Hashes wie Redis OSS. Mit MemoryDB können Sie den [DescribeUsers](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeUsers.html)Vorgang verwenden, um ähnliche Informationen abzurufen, einschließlich der in der Zugriffszeichenfolge enthaltenen Regeln. Ruft jedoch [DescribeUsers](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeUsers.html)kein Benutzerkennwort ab.
[Andere schreibgeschützte Befehle, die von MemoryDB unterstützt werden, sind [ACL WHOAMI, ACL USERS](https://valkey.io/commands/acl-whoami) und [ACL CAT](https://valkey.io/commands/acl-users).](https://valkey.io/commands/acl-cat) MemoryDB unterstützt keine anderen schreibbasierten ACL-Befehle.
Die Verwendung ACLs mit MemoryDB wird im Folgenden ausführlicher beschrieben.
**Topics**
+ [
## Spezifizieren von Berechtigungen mithilfe einer Zugriffszeichenfolge
](#access-string)
+ [
## Funktionen für die Vektorsuche
](#access-vss)
+ [
## ACLs MemoryDB auf einen Cluster bewerben
](#rbac-using)
## Spezifizieren von Berechtigungen mithilfe einer Zugriffszeichenfolge
Um Berechtigungen für einen MemoryDB-Cluster anzugeben, erstellen Sie eine Zugriffszeichenfolge und weisen sie einem Benutzer zu, indem Sie entweder das oder verwenden. AWS CLI AWS-Managementkonsole
Zugriffszeichenfolgen werden als eine Liste von durch Leerzeichen getrennten Regeln definiert, die für den Benutzer angewendet werden. Sie definieren, welche Befehle ein Benutzer ausführen kann und welche Schlüssel ein Benutzer benutzen kann. Um einen Befehl auszuführen, muss ein Benutzer Zugriff auf den ausgeführten Befehl und alle Schlüssel haben, auf die mit dem Befehl zugegriffen wird. Regeln werden kumulativ von links nach rechts angewendet, und eine einfachere Zeichenfolge kann anstelle der angegebenen verwendet werden, wenn die angegebene Zeichenfolge Redundanzen enthält.
Weitere Informationen zur Syntax der ACL-Regeln finden Sie unter [ACL](https://valkey.io/topics/acl).
Im folgenden Beispiel wird durch die Zugriffszeichenfolge ein aktiver Benutzer dargestellt, der Zugriff auf alle verfügbaren Schlüssel und Befehle hat.
`on ~* &* +@all`
Die Syntax der Zugriffszeichenfolge wird wie folgt verteilt:
+ `on` – Der Benutzer ist ein aktiver Benutzer.
+ `~*` – Zugriff auf alle verfügbaren Schlüssel ist erlaubt.
+ `&*`— Zugriff wird auf alle Pubsub-Kanäle gewährt.
+ `+@all` – Zugriff auf alle verfügbaren Befehle ist erlaubt.
Die vorgenannten Einstellungen sind am wenigsten restriktiv. Sie können diese Einstellungen ändern und sie sicherer zu machen.
Das folgende Beispiel zeigt einen Benutzer, der nur Lesezugriff auf Schlüssel hat, die mit dem Schlüsselbereich "app::" beginnen
`on ~app::* -@all +@read`
Sie können diese Berechtigungen weiter verfeinern, indem Sie die Befehle auflisten, auf die der Benutzer zugreifen kann:
`+command1` – Der Zugriff des Benutzers auf Befehle ist auf *`command1`* beschränkt.
`+@category` – Der Zugriff des Benutzers auf Befehle ist auf eine Kategorie von Befehlen beschränkt.
Informationen zum Zuweisen einer Zugriffszeichenfolge zu einem Benutzer finden Sie unter [Benutzer und Zugriffskontrolllisten mit der Konsole und CLI erstellen](#users-management).
Wenn Sie einen vorhandenen Workload zu MemoryDB migrieren, können Sie die Zugriffszeichenfolge durch einen Aufruf abrufen`ACL LIST`, ohne den Benutzer und alle Passwort-Hashes.
## Funktionen für die Vektorsuche
Denn [Vektor-Suche](vector-search.md) alle Suchbefehle gehören zur `@search` Kategorie und zu den vorhandenen Kategorien `@fast` und wurden aktualisiert `@read``@write`, `@slow` sodass sie Suchbefehle enthalten. Wenn ein Benutzer keinen Zugriff auf eine Kategorie hat, hat er auch keinen Zugriff auf Befehle innerhalb der Kategorie. Wenn der Benutzer beispielsweise keinen Zugriff auf hat`@search`, kann er keine suchbezogenen Befehle ausführen.
Die folgende Tabelle zeigt die Zuordnung von Suchbefehlen zu den entsprechenden Kategorien.
| VSS-Befehle | @read | @write | @fast | @slow |
| --- | --- | --- | --- | --- |
| FT.CREATE | | Y | Y | |
| FT.DROPINDEX | | Y | Y | |
| FT.LIST | Y | | | Y |
| FT.INFO | Y | | Y | |
| FT.SEARCH | Y | | | Y |
| FT.AGGREGATE | Y | | | Y |
| FT.PROFILE | Y | | | Y |
| FT.ALIASADD | | Y | Y | |
| FT.ALIASDEL | | Y | Y | |
| FT.ALIASUPDATE | | Y | Y | |
| FT.\$1ALIASLIST | Y | | | Y |
| FT.EXPLAIN | Y | | Y | |
| FT.EXPLAINCLI | Y | | Y | |
| FT.CONFIG | Y | | Y | |
## ACLs MemoryDB auf einen Cluster bewerben
Um MemoryDB zu verwenden ACLs, gehen Sie wie folgt vor:
1. Erstellung eines oder mehrerer Benutzer.
1. Erstellen Sie eine ACL und fügen Sie Benutzer zur Liste hinzu.
1. Weisen Sie die ACL einem Cluster zu.
Diese Schritte werden im Folgenden detailliert beschrieben.
**Topics**
+ [
### Benutzer und Zugriffskontrolllisten mit der Konsole und CLI erstellen
](#users-management)
+ [
### Verwaltung von Zugriffskontrolllisten mit der Konsole und CLI
](#user-groups)
+ [
### Zuweisung von Zugriffskontrolllisten zu Clustern
](#users-groups-to-clusterss)
### Benutzer und Zugriffskontrolllisten mit der Konsole und CLI erstellen
Bei den Benutzerinformationen für ACLs Benutzer handelt es sich um einen Benutzernamen und optional um ein Passwort und eine Zugriffszeichenfolge. Die Zugriffszeichenfolge stellt die Berechtigungsstufe für Schlüssel und Befehle bereit. Der Name ist für den Benutzer eindeutig und wird an die Engine weitergegeben.
Stellen Sie sicher, dass die von Ihnen bereitgestellten Benutzerberechtigungen dem Zweck der ACL entsprechen. Wenn Sie beispielsweise eine ACL mit dem Namen erstellen`Administrators`, sollte für jeden Benutzer, den Sie zu dieser Gruppe hinzufügen, die Zugriffszeichenfolge auf vollen Zugriff auf Tasten und Befehle gesetzt sein. Für Benutzer in einer `e-commerce` ACL können Sie ihre Zugriffszeichenfolgen auf schreibgeschützten Zugriff festlegen.
MemoryDB konfiguriert automatisch einen Standardbenutzer pro Konto mit einem Benutzernamen. `"default"` Es wird keinem Cluster zugeordnet, es sei denn, es wird ausdrücklich zu einer ACL hinzugefügt. Sie können diesen Benutzer nicht löschen oder ändern. Dieser Benutzer ist aus Gründen der Kompatibilität mit dem Standardverhalten früherer Redis OSS-Versionen vorgesehen und verfügt über eine Zugriffszeichenfolge, die es ihm ermöglicht, alle Befehle aufzurufen und auf alle Schlüssel zuzugreifen.
Für jedes Konto, das den Standardbenutzer enthält, wird eine unveränderliche „Open-Access“ -ACL erstellt. Dies ist die einzige ACL, bei der der Standardbenutzer Mitglied sein kann. Wenn Sie einen Cluster erstellen, müssen Sie eine ACL auswählen, die dem Cluster zugeordnet werden soll. Sie haben zwar die Möglichkeit, die „Open-Access“ -ACL für den Standardbenutzer anzuwenden, wir empfehlen jedoch dringend, eine ACL für Benutzer zu erstellen, deren Berechtigungen auf ihre Geschäftsanforderungen beschränkt sind.
Cluster, für die TLS nicht aktiviert ist, müssen die „Open-Access“ -ACL verwenden, um eine offene Authentifizierung zu ermöglichen.
ACLs kann ohne Benutzer erstellt werden. Eine leere ACL hätte keinen Zugriff auf einen Cluster und kann nur TLS-fähigen Clustern zugeordnet werden.
Beim Erstellen eines Benutzers können Sie bis zu zwei Passwörter einrichten. Wenn Sie ein Passwort ändern, werden alle bestehenden Verbindungen zu Clustern beibehalten.
Beachten Sie bei der Verwendung von MemoryDB insbesondere die folgenden Einschränkungen ACLs für Benutzerkennwörter:
+ Passwörter müssen 16-128 druckbare Zeichen enthalten.
+ Folgende nicht-alphanumerische Zeichen sind nicht zulässig: `,` `""` `/` `@`.
#### Verwalten von Benutzern mit der Konsole und dem CLI
##### Einen Benutzer erstellen (Konsole)
**Um Benutzer auf der Konsole zu erstellen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. **Wählen Sie im linken Navigationsbereich Benutzer aus.**
1. Wählen Sie **Benutzer erstellen** aus.
1. Geben Sie auf der Seite **Benutzer erstellen** einen **Namen** ein.
Für die Benennung von Clustern gelten die folgenden Einschränkungen:
+ Er muss 1-40 alphanumerische Zeichen oder Bindestriche enthalten.
+ Er muss mit einem Buchstaben beginnen.
+ Er darf keine zwei aufeinanderfolgenden Bindestriche enthalten.
+ Er darf nicht mit einem Bindestrich enden.
1. Unter **Passwörter** können Sie bis zu zwei Passwörter eingeben.
1. Geben Sie unter **Zugriffszeichenfolge** eine Zugriffszeichenfolge ein. Die Zugriffszeichenfolge legt die Berechtigungsstufe fest, welche Schlüssel und Befehle für den Benutzer erlaubt sind.
1. Für **Tags** können Sie optional Tags anwenden, um Ihre Benutzer zu suchen und zu filtern oder Ihre AWS Kosten nachzuverfolgen.
1. Wählen Sie **Erstellen** aus.
##### Einen Benutzer mit dem erstellen AWS CLI
**So erstellen Sie einen Benutzer mit der CLI**
+ Verwenden Sie den Befehl [create-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-user.html), um einen Benutzer zu erstellen.
Für Linux, macOS oder Unix:
```
aws memorydb create-user \
--user-name user-name-1 \
--access-string "~objects:* ~items:* ~public:*" \
--authentication-mode \
Passwords="abc",Type=password
```
Für Windows:
```
aws memorydb create-user ^
--user-name user-name-1 ^
--access-string "~objects:* ~items:* ~public:*" ^
--authentication-mode \
Passwords="abc",Type=password
```
##### Einen Benutzer ändern (Konsole)
**Um Benutzer auf der Konsole zu ändern**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. **Wählen Sie im linken Navigationsbereich Benutzer aus.**
1. Wählen Sie das Optionsfeld neben dem Benutzer, den Sie ändern möchten, und wählen Sie dann **Aktionen** -> **Ändern**
1. Wenn Sie ein Passwort ändern möchten, wählen Sie das Optionsfeld **Passwörter ändern**. Beachten Sie, dass Sie, wenn Sie zwei Passwörter haben, beide eingeben müssen, wenn Sie eines davon ändern.
1. Wenn Sie die Zugriffszeichenfolge aktualisieren, geben Sie die neue ein.
1. Wählen Sie **Ändern** aus.
##### Einen Benutzer ändern mit AWS CLI
**So ändern Sie einen Benutzer mit dem CLI**
1. Verwenden Sie den Befehl [update-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-user.html), um einen Benutzer zu ändern.
1. Wenn ein Benutzer geändert wird, werden die mit dem Benutzer verknüpften Zugriffskontrolllisten zusammen mit allen Clustern, die der ACL zugeordnet sind, aktualisiert. Alle vorhandenen Verbindungen werden gewartet. Im Folgenden sind einige Beispiele aufgeführt.
Für Linux, macOS oder Unix:
```
aws memorydb update-user \
--user-name user-name-1 \
--access-string "~objects:* ~items:* ~public:*"
```
Für Windows:
```
aws memorydb update-user ^
--user-name user-name-1 ^
--access-string "~objects:* ~items:* ~public:*"
```
##### Benutzerdetails anzeigen (Konsole)
**Um Benutzerdetails auf der Konsole anzuzeigen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. **Wählen Sie im linken Navigationsbereich Benutzer aus.**
1. Wählen Sie den Benutzer unter **Benutzername** aus, oder verwenden Sie das Suchfeld, um den Benutzer zu finden.
1. Unter **Benutzereinstellungen** können Sie die Zugriffszeichenfolge, die Anzahl der Passwörter, den Status und den Amazon-Ressourcennamen (ARN) des Benutzers überprüfen.
1. Unter **Zugriffskontrolllisten (ACL)** können Sie überprüfen, zu welcher ACL der Benutzer gehört.
1. Unter **Tags** können Sie alle mit dem Benutzer verknüpften Tags überprüfen.
##### Benutzerdetails anzeigen mit dem AWS CLI
Verwenden Sie den Befehl [describe-users](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-users.html), um Details eines Benutzers anzuzeigen.
```
aws memorydb describe-users \
--user-name my-user-name
```
##### Einen Benutzer löschen (Konsole)
**Um Benutzer auf der Konsole zu löschen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. **Wählen Sie im linken Navigationsbereich Benutzer aus.**
1. Wählen Sie das Optionsfeld neben dem Benutzer, den Sie ändern möchten, und wählen Sie dann **Aktionen** -> **Löschen**
1. Geben Sie zur Bestätigung den Text `delete` in das Bestätigungstextfeld ein und wählen Sie dann **Löschen**.
1. Wenn Sie den Vorgang abbrechen möchten, klicken Sie auf **Cancel (Abbrechen)**.
##### Löschen eines Benutzers mit dem AWS CLI
**So löschen Sie einen Benutzer mit dem CLI**
+ Verwenden Sie den Befehl [delete-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-user.html), um einen Benutzer zu löschen.
Das Konto wird gelöscht und aus allen Zugriffskontrolllisten entfernt, zu denen es gehört. Im Folgenden wird ein -Beispiel gezeigt.
Für Linux, macOS oder Unix:
```
aws memorydb delete-user \
--user-name user-name-2
```
Für Windows:
```
aws memorydb delete-user ^
--user-name user-name-2
```
### Verwaltung von Zugriffskontrolllisten mit der Konsole und CLI
Sie können Zugriffskontrolllisten erstellen, um den Zugriff von Benutzern auf einen oder mehrere Cluster zu organisieren und zu kontrollieren, wie im Folgenden gezeigt.
Gehen Sie wie folgt vor, um Zugriffskontrolllisten mithilfe der Konsole zu verwalten.
#### Erstellen einer Zugriffskontrollliste (ACL) (Konsole)
**Um eine Zugriffskontrollliste mit der Konsole zu erstellen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Wählen Sie im linken Navigationsbereich **Access Control Lists (ACL)** aus.
1. Wählen Sie **Create ACL** aus.
1. Geben Sie auf der Seite „**Zugriffskontrollliste (ACL) erstellen**“ einen ACL-Namen ein.
Für die Benennung von Clustern gelten die folgenden Einschränkungen:
+ Er muss 1-40 alphanumerische Zeichen oder Bindestriche enthalten.
+ Er muss mit einem Buchstaben beginnen.
+ Er darf keine zwei aufeinanderfolgenden Bindestriche enthalten.
+ Er darf nicht mit einem Bindestrich enden.
1. Führen Sie unter **Ausgewählte Benutzer** einen der folgenden Schritte aus:
1. Erstellen Sie einen neuen Benutzer, indem Sie **Benutzer erstellen** wählen
1. Fügen Sie Benutzer hinzu, indem Sie **Verwalten** und dann Benutzer im Dialogfeld **Benutzer verwalten** auswählen und dann Auswählen **auswählen**.
1. Bei **Stichwörtern** können Sie optional Stichwörter verwenden, um nach Ihren Daten zu suchen und zu filtern ACLs oder Ihre AWS Kosten nachzuverfolgen.
1. Wählen Sie **Erstellen** aus.
#### Erstellen einer Zugriffskontrollliste (ACL) mit dem AWS CLI
Verwenden Sie die folgenden Verfahren, um mit der CLI eine Zugriffskontrollliste zu erstellen.
**So erstellen Sie eine neue ACL und fügen einen Benutzer mit der CLI hinzu**
+ Verwenden Sie den Befehl [create-acl](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-acl.html), um eine ACL zu erstellen.
Für Linux, macOS oder Unix:
```
aws memorydb create-acl \
--acl-name "new-acl-1" \
--user-names "user-name-1" "user-name-2"
```
Für Windows:
```
aws memorydb create-acl ^
--acl-name "new-acl-1" ^
--user-names "user-name-1" "user-name-2"
```
#### Ändern einer Zugriffskontrollliste (ACL) (Konsole)
**Um eine Zugriffskontrollliste mit der Konsole zu ändern**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Wählen Sie im linken Navigationsbereich **Access Control Lists (ACL)** aus.
1. Wählen Sie die ACL aus, die Sie ändern möchten, und klicken Sie dann auf **Ändern**
1. Führen Sie auf der Seite **Ändern** unter **Ausgewählte Benutzer** einen der folgenden Schritte aus:
1. Erstellen Sie einen neuen Benutzer, indem **Sie Benutzer erstellen** wählen, der der ACL hinzugefügt werden soll.
1. Fügen Sie Benutzer hinzu oder entfernen Sie sie, indem Sie „**Verwalten**“ wählen und dann im Dialogfeld „Benutzer **verwalten“ Benutzer auswählen oder deren Auswahl aufheben** und dann „Auswählen“ **wählen**.
1. Geben Sie auf der Seite **Zugriffskontrollliste (ACL) erstellen** einen ACL-Namen ein.
Für die Benennung von Clustern gelten die folgenden Einschränkungen:
+ Er muss 1-40 alphanumerische Zeichen oder Bindestriche enthalten.
+ Er muss mit einem Buchstaben beginnen.
+ Er darf keine zwei aufeinanderfolgenden Bindestriche enthalten.
+ Er darf nicht mit einem Bindestrich enden.
1. Führen Sie unter **Ausgewählte Benutzer** einen der folgenden Schritte aus:
1. Erstellen Sie einen neuen Benutzer, indem Sie **Benutzer erstellen** wählen
1. Fügen Sie Benutzer hinzu, indem Sie **Verwalten** und dann Benutzer im Dialogfeld **Benutzer verwalten** auswählen und dann Auswählen **auswählen**.
1. Wählen Sie **Ändern**, um Ihre Änderungen zu speichern, oder **Abbrechen**, um sie zu verwerfen.
#### Ändern einer Zugriffskontrollliste (ACL) mithilfe der AWS CLI
**So ändern Sie eine ACL, indem Sie neue Benutzer hinzufügen oder aktuelle Mitglieder mit der CLI entfernen**
+ Verwenden Sie den Befehl [update-acl](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-acl.html), um eine ACL zu ändern.
Für Linux, macOS oder Unix:
```
aws memorydb update-acl --acl-name new-acl-1 \
--user-names-to-add user-name-3 \
--user-names-to-remove user-name-2
```
Für Windows:
```
aws memorydb update-acl --acl-name new-acl-1 ^
--user-names-to-add user-name-3 ^
--user-names-to-remove user-name-2
```
**Anmerkung**
Alle offenen Verbindungen eines Benutzers, der aus einer ACL entfernt wurde, werden mit diesem Befehl beendet.
#### Details zur Zugriffskontrollliste (ACL) anzeigen (Konsole)
**Um ACL-Details auf der Konsole anzuzeigen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Wählen Sie im linken Navigationsbereich **Access Control Lists (ACL)** aus.
1. Wählen Sie die ACL unter **ACL-Name** aus oder verwenden Sie das Suchfeld, um die ACL zu finden.
1. Unter **Benutzer** können Sie die Liste der Benutzer überprüfen, die der ACL zugeordnet sind.
1. Unter **Assoziierte Cluster** können Sie überprüfen, zu welchem Cluster die ACL gehört.
1. Unter **Tags** können Sie alle mit der ACL verknüpften Tags überprüfen.
#### Zugriffskontrolllisten (ACL) anzeigen mit dem AWS CLI
Verwenden Sie den Befehl [describe-acls](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-acls.html), um Details einer ACL anzuzeigen.
```
aws memorydb describe-acls \
--acl-name test-group
```
#### Löschen einer Zugriffskontrollliste (ACL) (Konsole)
**Um Zugriffskontrolllisten mit der Konsole zu löschen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Wählen Sie im linken Navigationsbereich **Access Control Lists (ACL)** aus.
1. Wählen Sie die ACL aus, die Sie ändern möchten, und klicken Sie dann auf **Löschen**
1. Geben `delete` Sie auf der Seite **Löschen** das Bestätigungsfeld ein und wählen Sie **Löschen** oder **Abbrechen**, um das Löschen der ACL zu verhindern.
Die ACL selbst, nicht die Benutzer, die zu der Gruppe gehören, wird gelöscht.
#### Löschen einer Zugriffskontrollliste (ACL) mit dem AWS CLI
**So löschen Sie eine ACL mit der CLI**
+ Verwenden Sie den Befehl [delete-acl](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-acl.html), um eine ACL zu löschen.
Für Linux, macOS oder Unix:
```
aws memorydb delete-acl /
--acl-name
```
Für Windows:
```
aws memorydb delete-acl ^
--acl-name
```
Die vorhergehenden Beispiele geben die folgende Antwort zurück.
```
aws memorydb delete-acl --acl-name "new-acl-1"
{
"ACLName": "new-acl-1",
"Status": "deleting",
"EngineVersion": "6.2",
"UserNames": [
"user-name-1",
"user-name-3"
],
"clusters": [],
"ARN":"arn:aws:memorydb:us-east-1:493071037918:acl/new-acl-1"
}
```
### Zuweisung von Zugriffskontrolllisten zu Clustern
Nachdem Sie eine ACL erstellt und Benutzer hinzugefügt haben, besteht der letzte Schritt bei der Implementierung ACLs darin, die ACL einem Cluster zuzuweisen.
#### Zuweisung von Zugriffskontrolllisten zu Clustern mithilfe der Konsole
Informationen zum Hinzufügen einer ACL zu einem Cluster mithilfe der finden Sie AWS-Managementkonsole unter[Einen MemoryDB-Cluster erstellen](getting-started.md#clusters.create).
#### Zuweisen von Zugriffskontrolllisten zu Clustern mithilfe der AWS CLI
Der folgende AWS CLI Vorgang erstellt einen Cluster mit aktivierter Verschlüsselung bei der Übertragung (TLS) und dem **acl-name** Parameter mit dem Wert`my-acl-name`. Ersetzen Sie die Subnetzgruppe `subnet-group` durch eine vorhandene Subnetzgruppe.
**Hauptparameter**
+ **--engine-version**— Muss 6.2 sein.
+ **--tls-enabled**— Wird für die Authentifizierung und für die Zuordnung einer ACL verwendet.
+ **--acl-name**— Dieser Wert stellt Zugriffskontrolllisten bereit, die sich aus Benutzern mit bestimmten Zugriffsberechtigungen für den Cluster zusammensetzen.
Für Linux, macOS oder Unix:
```
aws memorydb create-cluster \
--cluster-name "new-cluster" \
--description "new-cluster" \
--engine-version "6.2" \
--node-type db.r6g.large \
--tls-enabled \
--acl-name "new-acl-1" \
--subnet-group-name "subnet-group"
```
Für Windows:
```
aws memorydb create-cluster ^
--cluster-name "new-cluster" ^
--cluster-description "new-cluster" ^
--engine-version "6.2" ^
--node-type db.r6g.large ^
--tls-enabled ^
--acl-name "new-acl-1" ^
--subnet-group-name "subnet-group"
```
Der folgende AWS CLI Vorgang ändert einen Cluster mit aktivierter Verschlüsselung bei der Übertragung (TLS) und dem **acl-name** Parameter mit dem Wert`new-acl-2`.
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name cluster-1 \
--acl-name "new-acl-2"
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name cluster-1 ^
--acl-name "new-acl-2"
```
# Authentifizieren mit IAM
**Topics**
+ [
## -Übersicht
](#auth-iam-overview)
+ [
## Einschränkungen
](#auth-iam-limits)
+ [
## Einrichtung
](#auth-iam-setup)
+ [
## Herstellen von Verbindungen
](#auth-iam-Connecting)
## -Übersicht
Mit der IAM-Authentifizierung können Sie eine Verbindung zu MemoryDB mithilfe von AWS IAM-Identitäten authentifizieren, wenn Ihr Cluster für die Verwendung von Valkey oder Redis OSS Version 7 oder höher konfiguriert ist. Auf diese Weise können Sie Ihr Sicherheitsmodell stärken und viele administrative Sicherheitsaufgaben vereinfachen. Mit der IAM-Authentifizierung können Sie eine differenzierte Zugriffskontrolle für jeden einzelnen MemoryDB-Cluster und jeden einzelnen MemoryDB-Benutzer konfigurieren und dabei die Prinzipien der geringsten Zugriffsrechte befolgen. Die IAM-Authentifizierung für MemoryDB funktioniert so, dass im Befehl oder ein kurzlebiges IAM-Authentifizierungstoken anstelle eines langlebigen MemoryDB-Benutzerkennworts bereitgestellt wird. `AUTH` `HELLO` Weitere Informationen zum IAM-Authentifizierungstoken finden Sie im Allgemeinen Referenzhandbuch im [Signaturprozess für Signature Version 4](https://docs.aws.amazon.com//general/latest/gr/signature-version-4.html) und im AWS folgenden Codebeispiel.
Sie können IAM-Identitäten und die zugehörigen Richtlinien verwenden, um den Zugriff auf Valkey oder Redis OSS weiter einzuschränken. Sie können Benutzern von ihren Federated Identity-Anbietern auch direkten Zugriff auf MemoryDB-Cluster gewähren.
Um AWS IAM mit MemoryDB zu verwenden, müssen Sie zunächst einen MemoryDB-Benutzer erstellen, dessen Authentifizierungsmodus auf IAM eingestellt ist. Anschließend können Sie eine IAM-Identität erstellen oder wiederverwenden. Die IAM-Identität benötigt eine zugehörige Richtlinie, um die `memorydb:Connect` Aktion dem MemoryDB-Cluster und dem MemoryDB-Benutzer zu gewähren. Nach der Konfiguration können Sie ein IAM-Authentifizierungstoken mit den AWS Anmeldeinformationen des IAM-Benutzers oder der IAM-Rolle erstellen. Schließlich müssen Sie das kurzlebige IAM-Authentifizierungstoken als Passwort in Ihrem Valkey- oder Redis-OSS-Client angeben, wenn Sie eine Verbindung zu Ihrem MemoryDB-Clusterknoten herstellen. Ein Client mit Unterstützung für den Anbieter von Anmeldeinformationen kann die temporären Anmeldeinformationen für jede neue Verbindung automatisch generieren. MemoryDB führt die IAM-Authentifizierung für Verbindungsanfragen von IAM-fähigen MemoryDB-Benutzern durch und validiert die Verbindungsanfragen mit IAM.
## Einschränkungen
Bei der Verwendung der IAM-Authentifizierung gelten die folgenden Einschränkungen:
+ Die IAM-Authentifizierung ist verfügbar, wenn Sie Valkey oder Redis OSS Engine Version 7.0 oder höher verwenden.
+ Das IAM-Authentifizierungstoken ist für 15 Minuten gültig. Für langlebige Verbindungen empfehlen wir die Verwendung eines Redis OSS-Clients, der eine Schnittstelle zum Anbieter von Anmeldeinformationen unterstützt.
+ Eine IAM-authentifizierte Verbindung zu MemoryDB wird nach 12 Stunden automatisch getrennt. Die Verbindung kann um 12 Stunden verlängert werden, indem ein `AUTH`- oder `HELLO`-Befehl mit einem neuen IAM-Authentifizierungstoken gesendet wird.
+ Die IAM-Authentifizierung wird in `MULTI EXEC`-Befehlen nicht unterstützt.
+ Derzeit unterstützt die IAM-Authentifizierung nicht alle globalen Bedingungskontextschlüssel. Weitere Informationen über globale Bedingungskontextschlüssel finden Sie unter [Globale AWS -Bedingungskontextschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) im IAM-Benutzerhandbuch.
## Einrichtung
So richten Sie die IAM-Authentifizierung ein:
1. Erstellen eines Clusters
```
aws memorydb create-cluster \
--cluster-name cluster-01 \
--description "MemoryDB IAM auth application"
--node-type db.r6g.large \
--engine-version 7.0 \
--acl-name open-access
```
1. Erstellen Sie, wie unten dargestellt, ein Dokument mit den IAM-Vertrauensrichtlinien für Ihre Rolle, sodass Ihr Konto die neue Rolle übernehmen kann. Speichern Sie die Richtlinie in einer Datei namens *trust-policy.json*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::123456789012:root" },
"Action": "sts:AssumeRole"
}
}
```
------
1. Erstellen Sie ein IAM-Richtliniendokument wie im Folgenden dargestellt. Speichern Sie die Richtlinie in einer Datei namens *policy.json*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect" : "Allow",
"Action" : [
"memorydb:connect"
],
"Resource" : [
"arn:aws:memorydb:us-east-1:123456789012:cluster/cluster-01",
"arn:aws:memorydb:us-east-1:123456789012:user/iam-user-01"
]
}
]
}
```
------
1. Erstellen Sie eine IAM-Rolle.
```
aws iam create-role \
--role-name "memorydb-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. Erstellen Sie die IAM-Richtlinie.
```
aws iam create-policy \
--policy-name "memorydb-allow-all" \
--policy-document file://policy.json
```
1. Fügen Sie die IAM-Richtlinie an die Rolle an.
```
aws iam attach-role-policy \
--role-name "memorydb-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/memorydb-allow-all"
```
1. Erstellen Sie einen neuen IAM-fähigen Benutzer.
```
aws memorydb create-user \
--user-name iam-user-01 \
--authentication-mode Type=iam \
--access-string "on ~* +@all"
```
1. Erstellen Sie eine ACL und fügen Sie den Benutzer hinzu.
```
aws memorydb create-acl \
--acl-name iam-acl-01 \
--user-names iam-user-01
aws memorydb update-cluster \
--cluster-name cluster-01 \
--acl-name iam-acl-01
```
## Herstellen von Verbindungen
**Verbinden mit Token als Passwort**
Sie müssen zuerst das kurzlebige IAM-Authentifizierungstoken mithilfe einer [vorab signierten AWS -SigV4-Anfrage](https://docs.aws.amazon.com//general/latest/gr/sigv4-signed-request-examples.html) generieren. Danach geben Sie das IAM-Authentifizierungstoken als Passwort an, wenn Sie eine Verbindung zu einem MemoryDB-Cluster herstellen, wie im folgenden Beispiel gezeigt.
```
String userName = "insert user name"
String clusterName = "insert cluster name"
String region = "insert region"
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request and signed it using the AWS credentials.
// The pre-signed request URL is used as an IAM authentication token for MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
// Construct URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(userName, iamAuthToken)
.build();
// Create a new Lettuce client
RedisClusterClient client = RedisClusterClient.create(redisURI);
client.connect();
```
Im Folgenden finden Sie die Definition für `IAMAuthTokenRequest`.
```
public class IAMAuthTokenRequest {
private static final HttpMethodName REQUEST_METHOD = HttpMethodName.GET;
private static final String REQUEST_PROTOCOL = "http://";
private static final String PARAM_ACTION = "Action";
private static final String PARAM_USER = "User";
private static final String ACTION_NAME = "connect";
private static final String SERVICE_NAME = "memorydb";
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final String userName;
private final String clusterName;
private final String region;
public IAMAuthTokenRequest(String userName, String clusterName, String region) {
this.userName = userName;
this.clusterName = clusterName;
this.region = region;
}
public String toSignedRequestUri(AWSCredentials credentials) throws URISyntaxException {
Request request = getSignableRequest();
sign(request, credentials);
return new URIBuilder(request.getEndpoint())
.addParameters(toNamedValuePair(request.getParameters()))
.build()
.toString()
.replace(REQUEST_PROTOCOL, "");
}
private Request getSignableRequest() {
Request request = new DefaultRequest<>(SERVICE_NAME);
request.setHttpMethod(REQUEST_METHOD);
request.setEndpoint(getRequestUri());
request.addParameters(PARAM_ACTION, Collections.singletonList(ACTION_NAME));
request.addParameters(PARAM_USER, Collections.singletonList(userName));
return request;
}
private URI getRequestUri() {
return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, clusterName));
}
private void sign(SignableRequest request, AWSCredentials credentials) {
AWS4Signer signer = new AWS4Signer();
signer.setRegionName(region);
signer.setServiceName(SERVICE_NAME);
DateTime dateTime = DateTime.now();
dateTime = dateTime.plus(Duration.standardSeconds(TOKEN_EXPIRY_SECONDS));
signer.presignRequest(request, credentials, dateTime.toDate());
}
private static List toNamedValuePair(Map> in) {
return in.entrySet().stream()
.map(e -> new BasicNameValuePair(e.getKey(), e.getValue().get(0)))
.collect(Collectors.toList());
}
}
```
**Verbinden mit Anbieter von Anmeldeinformationen**
Der folgende Code zeigt, wie Sie sich mit MemoryDB mithilfe des IAM-Anbieters für Anmeldeinformationen für die Authentifizierung bei MemoryDB authentifizieren.
```
String userName = "insert user name"
String clusterName = "insert cluster name"
String region = "insert region"
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request. Once this request is signed it can be used as an
// IAM authentication token for MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
// Create a credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
userName, iamAuthTokenRequest, awsCredentialsProvider);
// Construct URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(redisCredentialsProvider)
.build();
// Create a new Lettuce cluster client
RedisClusterClient client = RedisClusterClient.create(redisURI);
client.connect();
```
Im Folgenden finden Sie ein Beispiel für einen Lettuce-Cluster-Client, der den IAMAuth TokenRequest in einen Anmeldeinformationsanbieter einbindet, um bei Bedarf automatisch temporäre Anmeldeinformationen zu generieren.
```
public class RedisIAMAuthCredentialsProvider implements RedisCredentialsProvider {
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final AWSCredentialsProvider awsCredentialsProvider;
private final String userName;
private final IAMAuthTokenRequest iamAuthTokenRequest;
private final Supplier iamAuthTokenSupplier;
public RedisIAMAuthCredentialsProvider(String userName,
IAMAuthTokenRequest iamAuthTokenRequest,
AWSCredentialsProvider awsCredentialsProvider) {
this.userName = userName;
this.awsCredentialsProvider = awsCredentialsProvider;
this.iamAuthTokenRequest = iamAuthTokenRequest;
this.iamAuthTokenSupplier = Suppliers.memoizeWithExpiration(this::getIamAuthToken, TOKEN_EXPIRY_SECONDS, TimeUnit.SECONDS);
}
@Override
public Mono resolveCredentials() {
return Mono.just(RedisCredentials.just(userName, iamAuthTokenSupplier.get()));
}
private String getIamAuthToken() {
return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
}
```