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 MemoryDB
Cloud-Sicherheit hat höchste AWS 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 übergreifenden Verantwortlichkeit](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/) . Weitere Informationen zu den Compliance-Programmen, die für MemoryDB gelten, finden Sie unter [AWS Services im Umfang nach Compliance-Programm AWS](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, etwa für die Vertraulichkeit Ihrer Daten, für die Anforderungen Ihres Unternehmens und für die geltenden Gesetze und Vorschriften.
Diese Dokumentation hilft Ihnen zu verstehen, wie Sie das Modell der gemeinsamen Verantwortung bei der Verwendung von MemoryDB anwenden können. Es zeigt Ihnen, wie Sie MemoryDB konfigurieren, um Ihre Sicherheits- und Compliance-Ziele zu erreichen. Sie erfahren auch, wie Sie andere AWS Dienste nutzen können, die Ihnen bei der Überwachung und Sicherung Ihrer MemoryDB-Ressourcen helfen.
**Topics**
+ [Datenschutz](data-protection.md)
+ [Identity and Access Management](iam.md)
+ [Protokollierung und Überwachung](monitoring-overview.md)
+ [Compliance-Validierung](memorydb-compliance.md)
+ [Sicherheit der Infrastruktur](infrastructure-security.md)
+ [
# Richtlinie für den Datenverkehr zwischen Netzwerken
](Security.traffic.md)
+ [Service-Updates](service-updates.md)
# 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());
}
```
# Identitäts- und Zugriffsmanagement in MemoryDB
AWS Identity and Access Management (IAM) hilft einem Administrator AWS-Service , den Zugriff auf Ressourcen sicher zu kontrollieren. AWS IAM-Administratoren kontrollieren, wer *authentifiziert* (angemeldet) und *autorisiert* werden kann (über Berechtigungen verfügt), um MemoryDB-Ressourcen zu verwenden. IAM ist ein Programm AWS-Service , das Sie ohne zusätzliche Kosten nutzen können.
**Topics**
+ [
## Zielgruppe
](#security_iam_audience)
+ [
## Authentifizierung mit Identitäten
](#security_iam_authentication)
+ [
## Verwalten des Zugriffs mit Richtlinien
](#security_iam_access-manage)
+ [
# Wie funktioniert MemoryDB mit IAM
](security_iam_service-with-iam.md)
+ [
# Beispiele für identitätsbasierte Richtlinien für MemoryDB
](security_iam_id-based-policy-examples.md)
+ [
# Problembehandlung bei Identität und Zugriff auf MemoryDB
](security_iam_troubleshoot.md)
+ [
## Zugriffskontrolle
](#iam.accesscontrol)
+ [
# Überblick über die Verwaltung von Zugriffsberechtigungen für Ihre MemoryDB-Ressourcen
](iam.overview.md)
## Zielgruppe
Wie Sie AWS Identity and Access Management (IAM) verwenden, hängt von Ihrer Rolle ab:
+ **Servicebenutzer** – Fordern Sie von Ihrem Administrator Berechtigungen an, wenn Sie nicht auf Features zugreifen können (siehe [Problembehandlung bei Identität und Zugriff auf MemoryDB](security_iam_troubleshoot.md)).
+ **Serviceadministrator** – Bestimmen Sie den Benutzerzugriff und stellen Sie Berechtigungsanfragen (siehe [Wie funktioniert MemoryDB mit IAM](security_iam_service-with-iam.md)).
+ **IAM-Administrator** – Schreiben Sie Richtlinien zur Zugriffsverwaltung (siehe [Beispiele für identitätsbasierte Richtlinien für MemoryDB](security_iam_id-based-policy-examples.md)).
## Authentifizierung mit Identitäten
Authentifizierung ist die Art und Weise, wie Sie sich AWS mit Ihren Identitätsdaten anmelden. Sie müssen sich als IAM-Benutzer authentifizieren oder eine IAM-Rolle annehmen. Root-Benutzer des AWS-Kontos
Sie können sich als föderierte Identität anmelden, indem Sie Anmeldeinformationen aus einer Identitätsquelle wie AWS IAM Identity Center (IAM Identity Center), Single Sign-On-Authentifizierung oder Anmeldeinformationen verwenden. Google/Facebook Weitere Informationen zum Anmelden finden Sie unter [So melden Sie sich bei Ihrem AWS-Konto an](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) im *Benutzerhandbuch für AWS-Anmeldung *.
AWS Bietet für den programmatischen Zugriff ein SDK und eine CLI zum kryptografischen Signieren von Anfragen. Weitere Informationen finden Sie unter [AWS Signature Version 4 for API requests](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) im *IAM-Benutzerhandbuch*.
### AWS-Konto Root-Benutzer
Wenn Sie einen erstellen AWS-Konto, beginnen Sie mit einer Anmeldeidentität, dem sogenannten AWS-Konto *Root-Benutzer*, der vollständigen Zugriff auf alle AWS-Services Ressourcen hat. Wir raten ausdrücklich davon ab, den Root-Benutzer für Alltagsaufgaben zu verwenden. Eine Liste der Aufgaben, für die Sie sich als Root-Benutzer anmelden müssen, finden Sie unter [Tasks that require root user credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) im *IAM-Benutzerhandbuch*.
### Verbundidentität
Als bewährte Methode sollten menschliche Benutzer für den Zugriff AWS-Services mithilfe temporärer Anmeldeinformationen einen Verbund mit einem Identitätsanbieter verwenden.
Eine *föderierte Identität* ist ein Benutzer aus Ihrem Unternehmensverzeichnis, Ihrem Directory Service Web-Identitätsanbieter oder der AWS-Services mithilfe von Anmeldeinformationen aus einer Identitätsquelle zugreift. Verbundene Identitäten übernehmen Rollen, die temporäre Anmeldeinformationen bereitstellen.
Für die zentrale Zugriffsverwaltung empfehlen wir AWS IAM Identity Center. Weitere Informationen finden Sie unter [Was ist IAM Identity Center?](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
### IAM-Benutzer und -Gruppen
Ein *[IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* ist eine Identität mit bestimmten Berechtigungen für eine einzelne Person oder Anwendung. Wir empfehlen die Verwendung temporärer Anmeldeinformationen anstelle von IAM-Benutzern mit langfristigen Anmeldeinformationen. Weitere Informationen finden Sie im *IAM-Benutzerhandbuch* unter [Erfordern, dass menschliche Benutzer den Verbund mit einem Identitätsanbieter verwenden müssen, um AWS mithilfe temporärer Anmeldeinformationen darauf zugreifen zu](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) können.
Eine [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) spezifiziert eine Sammlung von IAM-Benutzern und erleichtert die Verwaltung von Berechtigungen für große Gruppen von Benutzern. Weitere Informationen finden Sie unter [Anwendungsfälle für IAM-Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) im *IAM-Benutzerhandbuch*.
### IAM-Rollen
Eine *[IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* ist eine Identität mit spezifischen Berechtigungen, die temporäre Anmeldeinformationen bereitstellt. Sie können eine Rolle übernehmen, indem Sie [von einer Benutzer- zu einer IAM-Rolle (Konsole) wechseln](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) AWS CLI oder einen AWS API-Vorgang aufrufen. Weitere Informationen finden Sie unter [Methoden, um eine Rolle zu übernehmen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) im *IAM-Benutzerhandbuch*.
IAM-Rollen sind nützlich für den Verbundbenutzer-Zugriff, temporäre IAM-Benutzerberechtigungen, kontoübergreifenden Zugriff, serviceübergreifenden Zugriff und Anwendungen, die auf Amazon EC2 laufen. Weitere Informationen finden Sie unter [Kontoübergreifender Ressourcenzugriff in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) im *IAM-Benutzerhandbuch*.
## Verwalten des Zugriffs mit Richtlinien
Sie kontrollieren den Zugriff, AWS indem Sie Richtlinien erstellen und diese an AWS Identitäten oder Ressourcen anhängen. Eine Richtlinie definiert Berechtigungen, wenn sie mit einer Identität oder Ressource verknüpft sind. AWS bewertet diese Richtlinien, wenn ein Principal eine Anfrage stellt. Die meisten Richtlinien werden AWS als JSON-Dokumente gespeichert. Weitere Informationen zu JSON-Richtliniendokumenten finden Sie unter [Übersicht über JSON-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) im *IAM-Benutzerhandbuch*.
Mit Hilfe von Richtlinien legen Administratoren fest, wer Zugriff auf was hat, indem sie definieren, welches **Prinzipal** welche **Aktionen** auf welchen **Ressourcen**und unter welchen **Bedingungen**durchführen darf.
Standardmäßig haben Benutzer, Gruppen und Rollen keine Berechtigungen. Ein IAM-Administrator erstellt IAM-Richtlinien und fügt sie zu Rollen hinzu, die die Benutzer dann übernehmen können. IAM-Richtlinien definieren Berechtigungen unabhängig von der Methode, die zur Ausführung der Operation verwendet wird.
### Identitätsbasierte Richtlinien
Identitätsbasierte Richtlinien sind JSON-Berechtigungsrichtliniendokumente, die Sie einer Identität (Benutzer, Gruppe oder Rolle) anfügen können. Diese Richtlinien steuern, welche Aktionen Identitäten für welche Ressourcen und unter welchen Bedingungen ausführen können. Informationen zum Erstellen identitätsbasierter Richtlinien finden Sie unter [Definieren benutzerdefinierter IAM-Berechtigungen mit vom Kunden verwalteten Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) im *IAM-Benutzerhandbuch*.
Identitätsbasierte Richtlinien können *Inline-Richtlinien* (direkt in eine einzelne Identität eingebettet) oder *verwaltete Richtlinien* (eigenständige Richtlinien, die mit mehreren Identitäten verbunden sind) sein. Informationen dazu, wie Sie zwischen verwalteten und Inline-Richtlinien wählen, finden Sie unter [Choose between managed policies and inline policies](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-choosing-managed-or-inline.html) im *IAM-Benutzerhandbuch*.
### Ressourcenbasierte Richtlinien
Ressourcenbasierte Richtlinien sind JSON-Richtliniendokumente, die Sie an eine Ressource anfügen. Beispiele hierfür sind *Vertrauensrichtlinien für IAM-Rollen* und Amazon S3*-Bucket-Richtlinien*. In Services, die ressourcenbasierte Richtlinien unterstützen, können Service-Administratoren sie verwenden, um den Zugriff auf eine bestimmte Ressource zu steuern. Sie müssen in einer ressourcenbasierten Richtlinie [einen Prinzipal angeben](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html).
Ressourcenbasierte Richtlinien sind Richtlinien innerhalb dieses Diensts. Sie können AWS verwaltete Richtlinien von IAM nicht in einer ressourcenbasierten Richtlinie verwenden.
### Weitere Richtlinientypen
AWS unterstützt zusätzliche Richtlinientypen, mit denen die maximalen Berechtigungen festgelegt werden können, die durch gängigere Richtlinientypen gewährt werden:
+ **Berechtigungsgrenzen** – Eine Berechtigungsgrenze legt die maximalen Berechtigungen fest, die eine identitätsbasierte Richtlinie einer IAM-Entität erteilen kann. Weitere Informationen finden Sie unter [Berechtigungsgrenzen für IAM-Entitäten](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) im *-IAM-Benutzerhandbuch*.
+ **Richtlinien zur Dienstkontrolle (SCPs)** — Geben Sie die maximalen Berechtigungen für eine Organisation oder Organisationseinheit in an AWS Organizations. Weitere Informationen finden Sie unter [Service-Kontrollrichtlinien](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) im *AWS Organizations -Benutzerhandbuch*.
+ **Richtlinien zur Ressourcenkontrolle (RCPs)** — Legen Sie die maximal verfügbaren Berechtigungen für Ressourcen in Ihren Konten fest. Weitere Informationen finden Sie im *AWS Organizations Benutzerhandbuch* unter [Richtlinien zur Ressourcenkontrolle (RCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html).
+ **Sitzungsrichtlinien** – Sitzungsrichtlinien sind erweiterte Richtlinien, die als Parameter übergeben werden, wenn Sie eine temporäre Sitzung für eine Rolle oder einen Verbundbenutzer erstellen. Weitere Informationen finden Sie unter [Sitzungsrichtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session) im *IAM-Benutzerhandbuch*.
### Mehrere Richtlinientypen
Wenn für eine Anfrage mehrere Arten von Richtlinien gelten, sind die sich daraus ergebenden Berechtigungen schwieriger zu verstehen. Informationen darüber, wie AWS bestimmt wird, ob eine Anfrage zulässig ist, wenn mehrere Richtlinientypen betroffen sind, finden Sie unter [Bewertungslogik für Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html) im *IAM-Benutzerhandbuch*.
# Wie funktioniert MemoryDB mit IAM
Bevor Sie IAM zur Verwaltung des Zugriffs auf MemoryDB verwenden, sollten Sie sich darüber informieren, welche IAM-Funktionen für MemoryDB verfügbar sind.
**IAM-Funktionen, die Sie mit MemoryDB verwenden können**
| IAM-Feature | MemoryDB-Unterstützung |
| --- | --- |
| [Identitätsbasierte Richtlinien](#security_iam_service-with-iam-id-based-policies) | Ja |
| [Ressourcenbasierte Richtlinien](#security_iam_service-with-iam-resource-based-policies) | Nein |
| [Richtlinienaktionen](#security_iam_service-with-iam-id-based-policies-actions) | Ja |
| [Richtlinienressourcen](#security_iam_service-with-iam-id-based-policies-resources) | Ja |
| [Bedingungsschlüssel für die Richtlinie](#security_iam_service-with-iam-id-based-policies-conditionkeys) | Ja |
| [ACLs](#security_iam_service-with-iam-acls) | Ja |
| [ABAC (Tags in Richtlinien)](#security_iam_service-with-iam-tags) | Ja |
| [Temporäre Anmeldeinformationen](#security_iam_service-with-iam-roles-tempcreds) | Ja |
| [Prinzipalberechtigungen](#security_iam_service-with-iam-principal-permissions) | Ja |
| [Servicerollen](#security_iam_service-with-iam-roles-service) | Ja |
| [Service-verknüpfte Rollen](#security_iam_service-with-iam-roles-service-linked) | Ja |
*Einen allgemeinen Überblick darüber, wie MemoryDB und andere AWS Dienste mit den meisten IAM-Funktionen funktionieren, finden Sie im IAM-Benutzerhandbuch unter [AWS Dienste, die mit IAM funktionieren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).*
## Identitätsbasierte Richtlinien für MemoryDB
**Unterstützt Richtlinien auf Identitätsbasis:** Ja
Identitätsbasierte Richtlinien sind JSON-Berechtigungsrichtliniendokumente, die Sie einer Identität anfügen können, wie z. B. IAM-Benutzern, -Benutzergruppen oder -Rollen. Diese Richtlinien steuern, welche Aktionen die Benutzer und Rollen für welche Ressourcen und unter welchen Bedingungen ausführen können. Informationen zum Erstellen identitätsbasierter Richtlinien finden Sie unter [Definieren benutzerdefinierter IAM-Berechtigungen mit vom Kunden verwalteten Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) im *IAM-Benutzerhandbuch*.
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. 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*.
### Beispiele für identitätsbasierte Richtlinien für MemoryDB
Beispiele für identitätsbasierte MemoryDB-Richtlinien finden Sie unter. [Beispiele für identitätsbasierte Richtlinien für MemoryDB](security_iam_id-based-policy-examples.md)
## Ressourcenbasierte Richtlinien in MemoryDB
**Unterstützt ressourcenbasierte Richtlinien:** Nein
Ressourcenbasierte Richtlinien sind JSON-Richtliniendokumente, die Sie an eine Ressource anfügen. Beispiele für ressourcenbasierte Richtlinien sind IAM-*Rollen-Vertrauensrichtlinien* und Amazon-S3-*Bucket-Richtlinien*. In Services, die ressourcenbasierte Richtlinien unterstützen, können Service-Administratoren sie verwenden, um den Zugriff auf eine bestimmte Ressource zu steuern. Für die Ressource, an welche die Richtlinie angehängt ist, legt die Richtlinie fest, welche Aktionen ein bestimmter Prinzipal unter welchen Bedingungen für diese Ressource ausführen kann. Sie müssen in einer ressourcenbasierten Richtlinie [einen Prinzipal angeben](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html). Zu den Prinzipalen können Konten, Benutzer, Rollen, Verbundbenutzer oder gehören. AWS-Services
Um kontoübergreifenden Zugriff zu ermöglichen, können Sie ein gesamtes Konto oder IAM-Entitäten in einem anderen Konto als Prinzipal in einer ressourcenbasierten Richtlinie angeben. Weitere Informationen finden Sie unter [Kontoübergreifender Ressourcenzugriff in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) im *IAM-Benutzerhandbuch*.
## Richtlinienaktionen für MemoryDB
**Unterstützt Richtlinienaktionen:** Ja
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 `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.
*Eine Liste der MemoryDB-Aktionen finden Sie unter [Von MemoryDB definierte Aktionen in der Serviceautorisierungsreferenz](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awskeymanagementservice.html#awskeymanagementservice-actions-as-permissions).*
Richtlinienaktionen in MemoryDB verwenden vor der Aktion das folgende Präfix:
```
MemoryDB
```
Um mehrere Aktionen in einer einzigen Anweisung anzugeben, trennen Sie sie mit Kommata:
```
"Action": [
"MemoryDB:action1",
"MemoryDB: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": "MemoryDB:Describe*"
```
Beispiele für identitätsbasierte MemoryDB-Richtlinien finden Sie unter. [Beispiele für identitätsbasierte Richtlinien für MemoryDB](security_iam_id-based-policy-examples.md)
## Richtlinienressourcen für MemoryDB
**Unterstützt Richtlinienressourcen:** Ja
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": "*"
```
*Eine Liste der MemoryDB-Ressourcentypen und ihrer ARNs Eigenschaften finden Sie unter [Von MemoryDB definierte Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awskeymanagementservice.html#awskeymanagementservice-resources-for-iam-policies) in der Service Authorization Reference.* Informationen darüber, mit welchen Aktionen Sie den ARN jeder Ressource angeben können, finden Sie unter [Von MemoryDB definierte Aktionen](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awskeymanagementservice.html#awskeymanagementservice-actions-as-permissions).
Beispiele für identitätsbasierte MemoryDB-Richtlinien finden Sie unter. [Beispiele für identitätsbasierte Richtlinien für MemoryDB](security_iam_id-based-policy-examples.md)
## Bedingungsschlüssel für Richtlinien für MemoryDB
**Unterstützt servicespezifische Richtlinienbedingungsschlüssel:** Ja
Administratoren können mithilfe von AWS JSON-Richtlinien angeben, wer auf was Zugriff 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*.
Beispiele für identitätsbasierte MemoryDB-Richtlinien finden Sie unter. [Beispiele für identitätsbasierte Richtlinien für MemoryDB](security_iam_id-based-policy-examples.md)
### Verwenden von Bedingungsschlüssel
Sie können Bedingungen angeben, die bestimmen, wie eine IAM-Richtlinie wirksam wird. In MemoryDB können Sie das `Condition` Element einer JSON-Richtlinie verwenden, um Schlüssel im Anforderungskontext mit Schlüsselwerten zu vergleichen, die Sie in Ihrer Richtlinie angeben. Weitere Informationen finden Sie unter [IAM-JSON-Richtlinienelemente: Bedingung](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).
*Eine Liste der MemoryDB-Bedingungsschlüssel finden Sie unter [Bedingungsschlüssel für MemoryDB](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awskeymanagementservice.html#awskeymanagementservice-policy-keys) in der Service Authorization Reference.*
Eine Liste der globalen Bedingungsschlüssel finden Sie unter [AWS Globale Bedingungskontextschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html).
#### Festlegung von Bedingungen: Verwenden von Bedingungsschlüsseln
Um eine differenzierte Steuerung zu implementieren, können Sie eine IAM-Berechtigungsrichtlinie schreiben, die Bedingungen für die Steuerung einzelner Parameter bei bestimmten Anfragen festlegt. Anschließend können Sie die Richtlinie auf IAM-Benutzer, -Gruppen oder -Rollen anwenden, die Sie mit der IAM-Konsole erstellen.
Um eine Bedingung anzuwenden, fügen Sie die Bedingungsinformationen der IAM-Richtlinienanweisung hinzu. Um beispielsweise die Erstellung eines MemoryDB-Clusters mit deaktiviertem TLS zu verbieten, können Sie in Ihrer Richtlinienerklärung die folgende Bedingung angeben.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"memorydb:CreateCluster"
],
"Resource": [
"*"
],
"Condition": {
"Bool": {
"memorydb:TLSEnabled": "false"
}
}
}
]
}
```
------
Weitere Informationen zum Tagging finden Sie unter. [Kennzeichnen Ihrer MemoryDB-Ressourcen](tagging-resources.md)
Weitere Informationen zur Verwendung von Richtlinienbedingungsoperatoren finden Sie unter [MemoryDB-API-Berechtigungen: Referenz zu Aktionen, Ressourcen und Bedingungen](iam.APIReference.md).
#### Beispielrichtlinien: Verwenden von Bedingungen für die differenzierte Parameterkontrolle
In diesem Abschnitt werden Beispielrichtlinien für die Implementierung einer detaillierten Zugriffskontrolle für die zuvor aufgeführten MemoryDB-Parameter beschrieben.
1. **memorydb: TLSEnabled** — Geben Sie an, dass Cluster nur mit aktiviertem TLS erstellt werden.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"memorydb:CreateCluster"
],
"Resource": [
"arn:aws:memorydb:*:*:parametergroup/*",
"arn:aws:memorydb:*:*:subnetgroup/*",
"arn:aws:memorydb:*:*:acl/*"
]
},
{
"Effect": "Allow",
"Action": [
"memorydb:CreateCluster"
],
"Resource": [
"*"
],
"Condition": {
"Bool": {
"memorydb:TLSEnabled": "true"
}
}
}
]
}
```
------
1. **memorydb:UserAuthenticationMode:** — Geben Sie an, dass die Benutzer mit einem bestimmten Authentifizierungsmodus (z. B. IAM) erstellt werden können.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"memorydb:Createuser"
],
"Resource": [
"arn:aws:memorydb:*:*:user/*"
],
"Condition": {
"StringEquals": {
"memorydb:UserAuthenticationMode": "iam"
}
}
}
]
}
```
------
In Fällen, in denen Sie auf „Verweigern“ basierende Richtlinien festlegen, wird empfohlen, den [StringEqualsIgnoreCase](https://docs.aws.amazon.com//IAM/latest/UserGuide/reference_policies_elements_condition_operators.html#Conditions_String)Operator zu verwenden, um unabhängig vom jeweiligen Fall alle Anrufe mit einem bestimmten Benutzerauthentifizierungsmodus zu vermeiden.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"memorydb:CreateUser"
],
"Resource": "*",
"Condition": {
"StringEqualsIgnoreCase": {
"memorydb:UserAuthenticationMode": "password"
}
}
}
]
}
```
------
## Zugriffskontrolllisten (ACLs) in MemoryDB
**Unterstützt ACLs**: Ja
Zugriffskontrolllisten (ACLs) steuern, welche Principals (Kontomitglieder, Benutzer oder Rollen) über Zugriffsberechtigungen für eine Ressource verfügen. ACLs ähneln ressourcenbasierten Richtlinien, verwenden jedoch nicht das JSON-Richtliniendokumentformat.
## Attributbasierte Zugriffskontrolle (ABAC) mit MemoryDB
**Unterstützt ABAC (Tags in Richtlinien):** Ja
Die attributbasierte Zugriffskontrolle (ABAC) ist eine Autorisierungsstrategie, bei der Berechtigungen basierend auf Attributen, auch als Tags bezeichnet, definiert werden. Sie können Tags an IAM-Entitäten und AWS -Ressourcen anhängen und dann ABAC-Richtlinien entwerfen, um Operationen zu ermöglichen, wenn das Tag des Prinzipals mit dem Tag auf der Ressource übereinstimmt.
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 `aws:ResourceTag/key-name`, `aws:RequestTag/key-name`, oder Bedingung `aws:TagKeys` verwenden.
Wenn ein Service alle drei Bedingungsschlüssel für jeden Ressourcentyp unterstützt, lautet der Wert für den Service **Ja**. Wenn ein Service alle drei Bedingungsschlüssel für nur einige Ressourcentypen unterstützt, lautet der Wert **Teilweise**.
*Weitere Informationen zu ABAC finden Sie unter [Definieren von Berechtigungen mit ABAC-Autorisierung](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) im IAM-Benutzerhandbuch*. Um ein Tutorial mit Schritten zur Einstellung von ABAC anzuzeigen, siehe [Attributbasierte Zugriffskontrolle (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_attribute-based-access-control.html) verwenden im *IAM-Benutzerhandbuch*.
## Temporäre Anmeldeinformationen mit MemoryDB verwenden
**Unterstützt temporäre Anmeldeinformationen:** Ja
Temporäre Anmeldeinformationen ermöglichen kurzfristigen Zugriff auf AWS Ressourcen und werden automatisch erstellt, wenn Sie einen Verbund verwenden oder die Rollen wechseln. AWS empfiehlt, temporäre Anmeldeinformationen dynamisch zu generieren, anstatt langfristige Zugriffsschlüssel zu verwenden. Weitere Informationen finden Sie unter [Temporäre Anmeldeinformationen in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) und [AWS-Services , die mit IAM funktionieren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) im *IAM-Benutzerhandbuch*.
## Serviceübergreifende Prinzipalberechtigungen für MemoryDB
**Unterstützt Forward Access Sessions (FAS):** Ja
Forward Access Sessions (FAS) verwenden die Berechtigungen des Prinzipals, der einen aufruft, in Kombination mit der Anforderung AWS-Service, Anfragen an AWS-Service nachgeschaltete Dienste zu stellen. Einzelheiten zu den Richtlinien für FAS-Anforderungen finden Sie unter [Zugriffssitzungen weiterleiten](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html).
## Servicerollen für MemoryDB
**Unterstützt Servicerollen:** Ja
Eine Servicerolle ist eine [IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html), die ein Service annimmt, um Aktionen in Ihrem Namen auszuführen. Ein IAM-Administrator kann eine Servicerolle innerhalb von IAM erstellen, ändern und löschen. Weitere Informationen finden Sie unter [Erstellen einer Rolle zum Delegieren von Berechtigungen an einen AWS-Service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) im *IAM-Benutzerhandbuch*.
**Warnung**
Durch das Ändern der Berechtigungen für eine Servicerolle kann die MemoryDB-Funktionalität beeinträchtigt werden. Bearbeiten Sie Servicerollen nur, wenn MemoryDB Sie dazu anleitet.
## Dienstbezogene Rollen für MemoryDB
**Unterstützt serviceverknüpfte Rollen:** Ja
Eine dienstverknüpfte Rolle ist eine Art von Servicerolle, die mit einer verknüpft ist. AWS-Service Der Service kann die Rolle übernehmen, um eine Aktion in Ihrem Namen auszuführen. Dienstbezogene Rollen werden in Ihrem Dienst angezeigt AWS-Konto und gehören dem Dienst. Ein IAM-Administrator kann die Berechtigungen für Service-verknüpfte Rollen anzeigen, aber nicht bearbeiten.
Details zum Erstellen oder Verwalten von serviceverknüpften Rollen finden Sie unter [AWS -Services, die mit IAM funktionieren](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html). Suchen Sie in der Tabelle nach einem Service mit einem `Yes` in der Spalte **Service-linked role** (Serviceverknüpfte Rolle). Wählen Sie den Link **Yes** (Ja) aus, um die Dokumentation für die serviceverknüpfte Rolle für diesen Service anzuzeigen.
# Beispiele für identitätsbasierte Richtlinien für MemoryDB
Standardmäßig sind Benutzer und Rollen nicht berechtigt, MemoryDB-Ressourcen zu erstellen oder zu ändern. Ein IAM-Administrator muss IAM-Richtlinien erstellen, die Benutzern die Berechtigung erteilen, Aktionen für die Ressourcen auszuführen, die sie benötigen.
Informationen dazu, wie Sie unter Verwendung dieser beispielhaften JSON-Richtliniendokumente eine identitätsbasierte IAM-Richtlinie erstellen, finden Sie unter [Erstellen von IAM-Richtlinien (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) im *IAM-Benutzerhandbuch*.
*Einzelheiten zu den von MemoryDB definierten Aktionen und Ressourcentypen, einschließlich des Formats ARNs für die einzelnen Ressourcentypen, finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für MemoryDB](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awskeymanagementservice.html) in der Service Authorization Reference.*
**Topics**
+ [
## Best Practices für Richtlinien
](#security_iam_service-with-iam-policy-best-practices)
+ [
## Verwenden der MemoryDB-Konsole
](#security_iam_id-based-policy-examples-console)
+ [
## Gewähren der Berechtigung zur Anzeige der eigenen Berechtigungen für Benutzer
](#security_iam_id-based-policy-examples-view-own-permissions)
## Best Practices für Richtlinien
Identitätsbasierte Richtlinien legen fest, ob jemand MemoryDB-Ressourcen in Ihrem Konto erstellen, darauf zugreifen oder sie 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*.
## Verwenden der MemoryDB-Konsole
Um auf die MemoryDB-Konsole zugreifen zu können, benötigen Sie ein Mindestmaß an Berechtigungen. Diese Berechtigungen müssen es Ihnen ermöglichen, Details zu den MemoryDB-Ressourcen in Ihrem aufzulisten und anzuzeigen. AWS-Konto Wenn Sie eine identitätsbasierte Richtlinie erstellen, die strenger ist als die mindestens erforderlichen Berechtigungen, funktioniert die Konsole nicht wie vorgesehen für Entitäten (Benutzer oder Rollen) mit dieser Richtlinie.
Sie müssen Benutzern, die nur die API AWS CLI oder die API aufrufen, keine Mindestberechtigungen für die Konsole gewähren. AWS Stattdessen sollten Sie nur Zugriff auf die Aktionen zulassen, die der API-Operation entsprechen, die die Benutzer ausführen möchten.
Um sicherzustellen, dass Benutzer und Rollen die MemoryDB-Konsole weiterhin verwenden können, fügen Sie den Entitäten auch die MemoryDB `ConsoleAccess` - oder `ReadOnly` AWS verwaltete Richtlinie hinzu. Weitere Informationen finden Sie unter [Hinzufügen von Berechtigungen zu einem Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) 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 OR-API. 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": "*"
}
]
}
```
# Problembehandlung bei Identität und Zugriff auf MemoryDB
Verwenden Sie die folgenden Informationen, um häufig auftretende Probleme zu diagnostizieren und zu beheben, die bei der Arbeit mit MemoryDB und IAM auftreten können.
**Topics**
+ [
## Ich bin nicht berechtigt, eine Aktion in MemoryDB auszuführen
](#security_iam_troubleshoot-no-permissions)
+ [
## Ich bin nicht berechtigt, iam durchzuführen: PassRole
](#security_iam_troubleshoot-passrole)
+ [
## Ich möchte Personen außerhalb meines AWS Kontos den Zugriff auf meine MemoryDB-Ressourcen ermöglichen
](#security_iam_troubleshoot-cross-account-access)
## Ich bin nicht berechtigt, eine Aktion in MemoryDB auszuführen
Wenn Ihnen AWS-Managementkonsole mitgeteilt wird, dass Sie nicht berechtigt sind, eine Aktion auszuführen, müssen Sie sich an Ihren Administrator wenden, um Unterstützung zu erhalten. Ihr Administrator ist die Person, die Ihnen Ihren Benutzernamen und Ihr Passwort zur Verfügung gestellt hat.
Der folgende Beispielfehler tritt auf, wenn der `mateojackson`-Benutzer versucht, die Konsole zum Anzeigen von Details zu einer fiktiven `my-example-widget`-Ressource zu verwenden, jedoch nicht über `MemoryDB:GetWidget`-Berechtigungen verfügt.
```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: MemoryDB:GetWidget on resource: my-example-widget
```
In diesem Fall bittet Mateo seinen Administrator um die Aktualisierung seiner Richtlinien, um unter Verwendung der Aktion `my-example-widget` auf die Ressource `MemoryDB:GetWidget` zugreifen zu können.
## Ich bin nicht berechtigt, iam durchzuführen: PassRole
Wenn Sie die Fehlermeldung erhalten, dass Sie nicht autorisiert sind, die `iam:PassRole` Aktion auszuführen, müssen Ihre Richtlinien aktualisiert werden, damit Sie eine Rolle an MemoryDB übergeben können.
Einige AWS-Services ermöglichen es Ihnen, eine bestehende Rolle an diesen Dienst zu übergeben, anstatt eine neue Servicerolle oder eine dienstverknüpfte Rolle zu erstellen. Hierzu benötigen Sie Berechtigungen für die Übergabe der Rolle an den Dienst.
Der folgende Beispielfehler tritt auf, wenn ein IAM-Benutzer mit dem Namen `marymajor` versucht, die Konsole zu verwenden, um eine Aktion in MemoryDB auszuführen. Die Aktion erfordert jedoch, dass der Service über Berechtigungen verfügt, die durch eine Servicerolle gewährt werden. Mary besitzt keine Berechtigungen für die Übergabe der Rolle an den Dienst.
```
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
```
In diesem Fall müssen die Richtlinien von Mary aktualisiert werden, um die Aktion `iam:PassRole` ausführen zu können.
Wenn Sie Hilfe benötigen, wenden Sie sich an Ihren Administrator. AWS Ihr Administrator hat Ihnen Ihre Anmeldeinformationen zur Verfügung gestellt.
## Ich möchte Personen außerhalb meines AWS Kontos den Zugriff auf meine MemoryDB-Ressourcen ermöglichen
Sie können eine Rolle erstellen, mit der Benutzer in anderen Konten oder Personen außerhalb Ihrer Organisation auf Ihre Ressourcen zugreifen können. Sie können festlegen, wem die Übernahme der Rolle anvertraut wird. Für Dienste, die ressourcenbasierte Richtlinien oder Zugriffskontrolllisten (ACLs) unterstützen, können Sie diese Richtlinien verwenden, um Personen Zugriff auf Ihre Ressourcen zu gewähren.
Weitere Informationen dazu finden Sie hier:
+ Informationen darüber, ob MemoryDB diese Funktionen unterstützt, finden Sie unter. [Wie funktioniert MemoryDB mit IAM](security_iam_service-with-iam.md)
+ *Informationen dazu, wie Sie Zugriff auf Ihre Ressourcen gewähren können, AWS-Konten die Ihnen gehören, finden Sie im IAM-Benutzerhandbuch unter [Gewähren des Zugriffs auf einen IAM-Benutzer in einem anderen AWS-Konto , den Sie besitzen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).*
+ Informationen dazu, wie Sie Dritten Zugriff auf Ihre Ressourcen gewähren können AWS-Konten, finden Sie [AWS-Konten im *IAM-Benutzerhandbuch* unter Gewähren des Zugriffs für Dritte](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html).
+ Informationen dazu, wie Sie über einen Identitätsverbund Zugriff gewähren, finden Sie unter [Gewähren von Zugriff für extern authentifizierte Benutzer (Identitätsverbund)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html) im *IAM-Benutzerhandbuch*.
+ Informationen zum Unterschied zwischen der Verwendung von Rollen und ressourcenbasierten Richtlinien für den kontoübergreifenden Zugriff finden Sie unter [Kontoübergreifender Ressourcenzugriff in IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) im *IAM-Benutzerhandbuch*.
## Zugriffskontrolle
Sie können über gültige Anmeldeinformationen verfügen, um Ihre Anfragen zu authentifizieren, aber ohne die entsprechenden Berechtigungen können Sie keine MemoryDB-Ressourcen erstellen oder darauf zugreifen. Sie benötigen beispielsweise die erforderlichen Berechtigungen, um einen MemoryDB-Cluster zu erstellen.
In den folgenden Abschnitten wird beschrieben, wie Sie Berechtigungen für MemoryDB verwalten. Wir empfehlen Ihnen, zunächst die Übersicht zu lesen.
+ [Überblick über die Verwaltung von Zugriffsberechtigungen für Ihre MemoryDB-Ressourcen](iam.overview.md)
+ [Verwenden von identitätsbasierten Richtlinien (IAM-Richtlinien) für MemoryDB](iam.identitybasedpolicies.md)
# Überblick über die Verwaltung von Zugriffsberechtigungen für Ihre MemoryDB-Ressourcen
Jede AWS Ressource gehört einem AWS Konto, und die Berechtigungen zum Erstellen oder Zugreifen auf eine Ressource werden durch Berechtigungsrichtlinien geregelt. Ein Kontoadministrator kann Berechtigungsrichtlinien an IAM-Identitäten (Benutzer, Gruppen und Rollen) anfügen. Darüber hinaus unterstützt MemoryDB auch das Anhängen von Berechtigungsrichtlinien an Ressourcen.
**Anmerkung**
Ein *Kontoadministrator* (oder Administratorbenutzer) ist ein Benutzer mit Administratorrechten. Weitere Informationen finden Sie unter [Bewährte Methoden für IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) im *IAM-Benutzerhandbuch*.
Um Zugriff zu gewähren, fügen Sie Ihren Benutzern, Gruppen oder Rollen Berechtigungen hinzu:
+ Benutzer und Gruppen in: AWS IAM Identity Center
Erstellen Sie einen Berechtigungssatz. Befolgen Sie die Anweisungen unter [Erstellen eines Berechtigungssatzes](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
+ Benutzer, die in IAM über einen Identitätsanbieter verwaltet werden:
Erstellen Sie eine Rolle für den Identitätsverbund. Befolgen Sie die Anleitung unter [Eine Rolle für einen externen Identitätsanbieter (Verbund) erstellen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) im *IAM-Benutzerhandbuch*.
+ IAM-Benutzer:
+ Erstellen Sie eine Rolle, die Ihr Benutzer annehmen kann. Befolgen Sie die Anleitung unter [Eine Rolle für einen IAM-Benutzer erstellen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) im *IAM-Benutzerhandbuch*.
+ (Nicht empfohlen) Weisen Sie einem Benutzer eine Richtlinie direkt zu oder fügen Sie einen Benutzer zu einer Benutzergruppe hinzu. Befolgen Sie die Anweisungen unter [Hinzufügen von Berechtigungen zu einem Benutzer (Konsole)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) im *IAM-Benutzerhandbuch*.
**Topics**
+ [
## MemoryDB-Ressourcen und -Operationen
](#iam.overview.resourcesandoperations)
+ [
## Grundlegendes zum Eigentum an Ressourcen
](#access-control-resource-ownership)
+ [
## Verwaltung des Zugriffs auf -Ressourcen
](#iam.overview.managingaccess)
+ [
# Verwenden von identitätsbasierten Richtlinien (IAM-Richtlinien) für MemoryDB
](iam.identitybasedpolicies.md)
+ [
# Berechtigungen auf Ressourcenebene
](iam.resourcelevelpermissions.md)
+ [
# Verwenden von dienstverknüpften Rollen für MemoryDB
](using-service-linked-roles.md)
+ [
# AWS verwaltete Richtlinien für MemoryDB
](security-iam-awsmanpol.md)
+ [
# MemoryDB-API-Berechtigungen: Referenz zu Aktionen, Ressourcen und Bedingungen
](iam.APIReference.md)
## MemoryDB-Ressourcen und -Operationen
*In MemoryDB ist die primäre Ressource ein Cluster.*
Diesen Ressourcen sind eindeutige Amazon-Ressourcennamen (ARNs) zugeordnet, wie im Folgenden dargestellt.
**Anmerkung**
Damit Berechtigungen auf Ressourcenebene wirksam sind, sollte der Ressourcenname in der ARN-Zeichenfolge in Kleinbuchstaben geschrieben werden.
****
| Ressourcentyp | ARN-Format |
| --- | --- |
| Benutzer | arn:aws:memorydb ::user/user1 *us-east-1:123456789012* |
| Zugriffskontrollliste (ACL) | arn:aws:memorydb ::acl/myacl *us-east-1:123456789012* |
| Cluster | arn:aws:memorydb ::cluster/mein-Cluster *us-east-1:123456789012* |
| Schnappschuss | arn:aws:memorydb ::snapshot/mein-snapshot *us-east-1:123456789012* |
| Parametergruppe | arn:aws:memorydb ::parametergruppe/ *us-east-1:123456789012* my-parameter-group |
| Subnetzgruppe | arn:aws:memorydb::subnetgroup/ *us-east-1:123456789012* my-subnet-group |
MemoryDB bietet eine Reihe von Operationen für die Arbeit mit MemoryDB-Ressourcen. [Eine Liste der verfügbaren Operationen finden Sie unter MemoryDB-Aktionen.](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_Operations.html)
## Grundlegendes zum Eigentum an Ressourcen
Ein *Ressourcenbesitzer* ist das AWS Konto, das die Ressource erstellt hat. Das heißt, der Ressourcenbesitzer ist das AWS Konto der Prinzipalentität, die die Anforderung authentifiziert, mit der die Ressource erstellt wird. Eine *Prinzipalentität* kann das Root-Konto, ein IAM-Benutzer oder eine IAM-Rolle sein. Die Funktionsweise wird anhand der folgenden Beispiele deutlich:
+ Angenommen, Sie verwenden die Root-Kontoanmeldeinformationen Ihres AWS Kontos, um einen Cluster zu erstellen. In diesem Fall ist Ihr AWS Konto der Eigentümer der Ressource. In MemoryDB ist die Ressource der Cluster.
+ Angenommen, Sie erstellen in Ihrem AWS Konto einen IAM-Benutzer und gewähren diesem Benutzer die Erlaubnis, einen Cluster zu erstellen. In diesem Fall kann der Benutzer einen Cluster erstellen. Ihr AWS Konto, zu dem der Benutzer gehört, besitzt jedoch die Clusterressource.
+ Angenommen, Sie erstellen in Ihrem AWS Konto eine IAM-Rolle mit Berechtigungen zum Erstellen eines Clusters. In diesem Fall kann jeder, der die Rolle übernehmen kann, einen Cluster erstellen. Ihr AWS Konto, zu dem die Rolle gehört, besitzt die Clusterressource.
## Verwaltung des Zugriffs auf -Ressourcen
Eine *Berechtigungsrichtlinie* beschreibt, wer Zugriff auf welche Objekte hat. Im folgenden Abschnitt werden die verfügbaren Optionen zum Erstellen von Berechtigungsrichtlinien erläutert.
**Anmerkung**
In diesem Abschnitt wird die Verwendung von IAM im Kontext von MemoryDB beschrieben. Er enthält keine detaillierten Informationen über den IAM-Service. Eine umfassende IAM-Dokumentation finden Sie unter [Was ist IAM?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) im *IAM-Benutzerhandbuch*. Für Informationen über die Syntax und Beschreibungen von [AWS -IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) lesen Sie die *IAM-Richtlinienreferenz im IAM-Benutzerhandbuch*.
An eine IAM-Identität angefügte Richtlinien werden als *identitätsbasierte* Richtlinien (oder IAM-Richtlinien) bezeichnet. An Ressourcen angehängte Richtlinien werden als *ressourcenbasierte Richtlinien* bezeichnet.
**Topics**
+ [
### Identitätsbasierte Richtlinien (IAM-Richtlinien)
](#iam.overview.managingaccess.identitybasedpolicies)
+ [
### Angeben der Richtlinienelemente: Aktionen, Effekte, Ressourcen und Prinzipale
](#iam.overview.policyelements)
+ [
### Angeben von Bedingungen in einer Richtlinie
](#iam.specifyconditions)
### Identitätsbasierte Richtlinien (IAM-Richtlinien)
Richtlinien können IAM-Identitäten angefügt werden. Sie können z. B. Folgendes tun:
+ **Anfügen einer Berechtigungsrichtlinie zu einem Benutzer oder einer Gruppe in Ihrem Konto** – Ein Kontoadministrator kann eine Berechtigungsrichtlinie verwenden, die einem bestimmten Benutzer zugeordnet ist, um Berechtigungen zu erteilen. In diesem Fall sind die Berechtigungen für diesen Benutzer vorgesehen, um eine MemoryDB-Ressource zu erstellen, z. B. einen Cluster, eine Parametergruppe oder eine Sicherheitsgruppe.
+ **Einer Rolle eine Berechtigungsrichtlinie zuweisen (kontoübergreifende Berechtigungen gewähren)** – Sie können einer IAM-Rolle eine identitätsbasierte Berechtigungsrichtlinie zuweisen, um kontoübergreifende Berechtigungen zu erteilen. Der Administrator in Konto A kann beispielsweise wie folgt eine Rolle erstellen, um einem anderen Konto (z. B. AWS Konto B) oder einem AWS Dienst kontoübergreifende Berechtigungen zu gewähren:
1. Der Administrator von Konto A erstellt eine IAM-Rolle und fügt ihr eine Berechtigungsrichtlinie an, die Berechtigungen für Ressourcen in Konto A erteilt.
1. Der Administrator von Konto A weist der Rolle eine Vertrauensrichtlinie zu, die Konto B als den Prinzipal identifiziert, der die Rolle übernehmen kann.
1. Der Administrator von Konto B kann dann die Berechtigungen zur Übernahme der Rolle an alle Benutzer in Konto B delegieren. Auf diese Weise können Benutzer in Konto B Ressourcen in Konto A erstellen oder darauf zugreifen. In einigen Fällen möchten Sie einem AWS Dienst möglicherweise Berechtigungen zur Übernahme der Rolle erteilen. Zum Support dieses Ansatzes kann es sich beim Prinzipal in der Vertrauensrichtlinie auch um einen AWS -Service-Prinzipal handeln.
Weitere Informationen zum Delegieren von Berechtigungen mithilfe von IAM finden Sie unter [Zugriffsverwaltung](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) im *IAM-Benutzerhandbuch*.
Im Folgenden finden Sie ein Beispiel für eine Richtlinie, die es einem Benutzer ermöglicht, die `DescribeClusters` Aktion für Ihr AWS Konto durchzuführen. MemoryDB unterstützt auch die Identifizierung bestimmter Ressourcen, die die Ressource ARNs für API-Aktionen verwenden. (Dieser Ansatz heißt auch Ressourcenebenen-Berechtigungen.)
Weitere Informationen zur Verwendung identitätsbasierter Richtlinien mit MemoryDB finden Sie unter. [Verwenden von identitätsbasierten Richtlinien (IAM-Richtlinien) für MemoryDB](iam.identitybasedpolicies.md) Weitere Informationen zu Benutzern, Gruppen, Rollen und Berechtigungen finden Sie unter [Identitäten (Benutzer, Gruppen und Rollen)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) im *IAM-Benutzerhandbuch*.
### Angeben der Richtlinienelemente: Aktionen, Effekte, Ressourcen und Prinzipale
[Für jede MemoryDB-Ressource (siehe[MemoryDB-Ressourcen und -Operationen](#iam.overview.resourcesandoperations)) definiert der Dienst eine Reihe von API-Vorgängen (siehe Aktionen).](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_Operations.html) Um Berechtigungen für diese API-Operationen zu gewähren, definiert MemoryDB eine Reihe von Aktionen, die Sie in einer Richtlinie angeben können. Für die MemoryDB-Clusterressource sind beispielsweise die folgenden Aktionen definiert:`CreateCluster`, und. `DeleteCluster` `DescribeClusters` Für das Durchführen einer API-Operation können Berechtigungen für mehrere Aktionen erforderlich sein.
Grundlegende Richtlinienelemente:
+ **Ressource** – In einer Richtlinie wird der Amazon-Ressourcenname (ARN) zur Identifizierung der Ressource verwendet, für die die Richtlinie gilt. Weitere Informationen finden Sie unter [MemoryDB-Ressourcen und -Operationen](#iam.overview.resourcesandoperations).
+ **Aktion** – Mit Aktionsschlüsselwörtern geben Sie die Ressourcenoperationen an, die Sie zulassen oder verweigern möchten. Je nach Angabe gewährt oder verweigert die `memorydb:CreateCluster` Berechtigung dem Benutzer beispielsweise die Berechtigung`Effect`, den MemoryDB-Vorgang auszuführen. `CreateCluster`
+ **Auswirkung** – Die von Ihnen festgelegte Auswirkung, wenn der Benutzer die jeweilige Aktion anfordert – entweder „allow“ (Zugriffserlaubnis) oder „deny“ (Zugriffsverweigerung). Wenn Sie den Zugriff auf eine Ressource nicht ausdrücklich gestatten ("Allow"), wird er automatisch verweigert. Sie können den Zugriff auf eine Ressource auch explizit verweigern. So können Sie zum Beispiel sicherstellen, dass ein Benutzer nicht auf die Ressource zugreifen kann, auch wenn der Zugriff durch eine andere Richtlinie gestattet wird.
+ **Prinzipal** – In identitätsbasierten Richtlinien (IAM-Richtlinien) ist der Benutzer, dem die Richtlinie zugewiesen ist, automatisch der Prinzipal. In ressourcenbasierten Richtlinien müssen Sie den Benutzer, das Konto, den Service oder die sonstige Entität angeben, die die Berechtigungen erhalten soll (gilt nur für ressourcenbasierte Richtlinien).
Weitere Informationen zur Syntax und zu Beschreibungen von IAM-Richtlinien finden Sie in der [AWS -IAM-Richtlinienreferenz](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) im *IAM-Benutzerhandbuch*.
Eine Tabelle mit allen MemoryDB-API-Aktionen finden Sie unter. [MemoryDB-API-Berechtigungen: Referenz zu Aktionen, Ressourcen und Bedingungen](iam.APIReference.md)
### Angeben von Bedingungen in einer Richtlinie
Beim Erteilen von Berechtigungen können Sie mithilfe der IAM-Richtliniensyntax die Bedingungen angeben, unter denen die Richtlinie wirksam werden soll. Beispielsweise kann festgelegt werden, dass eine Richtlinie erst ab einem bestimmten Datum gilt. Weitere Informationen zum Angeben von Bedingungen in einer Richtliniensyntax finden Sie im Thema [Bedingung](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition) im *IAM Benutzerhandbuch*.
# Verwenden von identitätsbasierten Richtlinien (IAM-Richtlinien) für MemoryDB
In diesem Thema finden Sie Beispiele für identitätsbasierte Richtlinien, in denen ein Kontoadministrator den IAM-Identitäten (Benutzer, Gruppen und Rollen) Berechtigungsrichtlinien anfügen kann.
**Wichtig**
Wir empfehlen Ihnen, zunächst die Themen zu lesen, in denen die grundlegenden Konzepte und Optionen zur Verwaltung des Zugriffs auf MemoryDB-Ressourcen erläutert werden. Weitere Informationen finden Sie unter [Überblick über die Verwaltung von Zugriffsberechtigungen für Ihre MemoryDB-Ressourcen](iam.overview.md).
Dieses Thema besteht aus folgenden Abschnitten:
+ [Für die Verwendung der MemoryDB-Konsole sind Berechtigungen erforderlich](#iam.identitybasedpolicies.minconpolicies)
+ [AWS-verwaltete (vordefinierte) Richtlinien für MemoryDB](security-iam-awsmanpol.md#iam.identitybasedpolicies.predefinedpolicies)
+ [Beispiele für vom Kunden verwaltete Richtlinien](#iam.identitybasedpolicies.customermanagedpolicies)
Dies ist ein Beispiel für eine Berechtigungsrichtlinie.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "AllowClusterPermissions",
"Effect": "Allow",
"Action": [
"memorydb:CreateCluster",
"memorydb:DescribeClusters",
"memorydb:UpdateCluster"],
"Resource": "*"
},
{
"Sid": "AllowUserToPassRole",
"Effect": "Allow",
"Action": [ "iam:PassRole" ],
"Resource": "arn:aws:iam::123456789012:role/EC2-roles-for-cluster"
}
]
}
```
------
Die Richtlinie enthält zwei Anweisungen:
+ Die erste Anweisung gewährt Berechtigungen für die MemoryDB-Aktionen (`memorydb:CreateCluster`, und`memorydb:UpdateCluster`) auf jedem Cluster`memorydb:DescribeClusters`, der dem Konto gehört.
+ Die zweite Anweisung erteilt Berechtigungen für die IAM-Aktion (`iam:PassRole`) für den IAM-Rollennamen am Ende des `Resource`-Wertes.
Das Element `Principal` ist in der Richtlinie nicht angegeben, da in identitätsbasierten Richtlinien die Angabe des Prinzipals als Empfänger der Berechtigung nicht erforderlich ist. Wenn Sie einem Benutzer eine Richtlinie zuweisen, ist der Benutzer automatisch der Prinzipal. Wird die Berechtigungsrichtlinie einer IAM-Rolle angefügt, erhält der in der Vertrauensrichtlinie der Rolle angegebene Prinzipal die Berechtigungen.
Eine Tabelle mit allen MemoryDB-API-Aktionen und den Ressourcen, für die sie gelten, finden Sie unter. [MemoryDB-API-Berechtigungen: Referenz zu Aktionen, Ressourcen und Bedingungen](iam.APIReference.md)
## Für die Verwendung der MemoryDB-Konsole sind Berechtigungen erforderlich
In der Referenztabelle für Berechtigungen sind die MemoryDB-API-Operationen aufgeführt und die erforderlichen Berechtigungen für jeden Vorgang aufgeführt. Weitere Hinweise zu MemoryDB-API-Vorgängen finden Sie unter. [MemoryDB-API-Berechtigungen: Referenz zu Aktionen, Ressourcen und Bedingungen](iam.APIReference.md)
Um die MemoryDB-Konsole zu verwenden, gewähren Sie zunächst Berechtigungen für zusätzliche Aktionen, wie in der folgenden Berechtigungsrichtlinie beschrieben.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "MinPermsForMemDBConsole",
"Effect": "Allow",
"Action": [
"memorydb:Describe*",
"memorydb:List*",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeVpcs",
"ec2:DescribeAccountAttributes",
"ec2:DescribeSecurityGroups",
"cloudwatch:GetMetricStatistics",
"cloudwatch:DescribeAlarms",
"s3:ListAllMyBuckets",
"sns:ListTopics",
"sns:ListSubscriptions" ],
"Resource": "*"
}
]
}
```
------
Die MemoryDB-Konsole benötigt diese zusätzlichen Berechtigungen aus den folgenden Gründen:
+ Berechtigungen für die MemoryDB-Aktionen ermöglichen es der Konsole, MemoryDB-Ressourcen im Konto anzuzeigen.
+ Die Konsole benötigt Berechtigungen für die `ec2` Aktionen zur Abfrage von Amazon EC2, damit Availability Zones VPCs, Sicherheitsgruppen und Kontoattribute angezeigt werden können.
+ Die Berechtigungen für `cloudwatch` Aktionen ermöglichen es der Konsole, CloudWatch Amazon-Metriken und -Alarme abzurufen und sie in der Konsole anzuzeigen.
+ Die Berechtigungen für `sns`-Aktionen ermöglichen es der Konsole, Themen und Abonnements von Amazon Simple Notification Service (Amazon SNS) abzurufen und in der Konsole anzuzeigen.
## Beispiele für vom Kunden verwaltete Richtlinien
Wenn Sie keine Standardrichtlinie verwenden und eine benutzerdefinierte verwaltete Richtlinie verwenden möchten, stellen Sie eines sicher. Sie sollten entweder die Genehmigung zum Aufrufen von `iam:createServiceLinkedRole` haben (weitere Informationen finden Sie unter [Beispiel 4: Erlauben Sie einem Benutzer, die IAM-API aufzurufen CreateServiceLinkedRole](#create-service-linked-role-policy)). Oder Sie hätten eine mit dem Service verknüpfte MemoryDB-Rolle erstellen sollen.
In Kombination mit den Mindestberechtigungen, die für die Verwendung der MemoryDB-Konsole erforderlich sind, gewähren die Beispielrichtlinien in diesem Abschnitt zusätzliche Berechtigungen. Die Beispiele sind auch relevant für die AWS SDKs und die. AWS CLI Weitere Informationen darüber, welche Berechtigungen für die Verwendung der MemoryDB-Konsole erforderlich sind, finden Sie unter. [Für die Verwendung der MemoryDB-Konsole sind Berechtigungen erforderlich](#iam.identitybasedpolicies.minconpolicies)
Anweisungen zum Einrichten von IAM-Benutzern und -Gruppen finden Sie unter [Erstellen Ihrer ersten IAM-Benutzer- und -Administratorengruppe](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) im *IAM-Benutzerhandbuch*.
**Wichtig**
Testen Sie Ihre IAM-Richtlinien immer gründlich, bevor Sie sie in der Produktion verwenden. Einige MemoryDB-Aktionen, die einfach erscheinen, können andere Aktionen erfordern, um sie zu unterstützen, wenn Sie die MemoryDB-Konsole verwenden. `memorydb:CreateCluster`Gewährt beispielsweise Berechtigungen zum Erstellen von MemoryDB-Clustern. Um diesen Vorgang auszuführen, verwendet die MemoryDB-Konsole jedoch eine Reihe von `List` AND-Aktionen, um `Describe` Konsolenlisten aufzufüllen.
**Topics**
+ [
### Beispiel 1: Erlauben Sie einem Benutzer nur Lesezugriff auf MemoryDB-Ressourcen
](#example-allow-list-current-memorydb-resources)
+ [
### Beispiel 2: Erlauben Sie einem Benutzer, allgemeine MemoryDB-Systemadministratoraufgaben auszuführen
](#example-allow-specific-memorydb-actions)
+ [
### Beispiel 3: Erlauben Sie einem Benutzer den Zugriff auf alle MemoryDB-API-Aktionen
](#allow-unrestricted-access)
+ [
### Beispiel 4: Erlauben Sie einem Benutzer, die IAM-API aufzurufen CreateServiceLinkedRole
](#create-service-linked-role-policy)
### Beispiel 1: Erlauben Sie einem Benutzer nur Lesezugriff auf MemoryDB-Ressourcen
Die folgende Richtlinie gewährt Berechtigungen für MemoryDB-Aktionen, die es einem Benutzer ermöglichen, Ressourcen aufzulisten. Gewöhnlich ordnen Sie diese Art von Berechtigungsrichtlinie einer Gruppe von Managern zu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[{
"Sid": "MemDBUnrestricted",
"Effect":"Allow",
"Action": [
"memorydb:Describe*",
"memorydb:List*"],
"Resource":"*"
}
]
}
```
------
### Beispiel 2: Erlauben Sie einem Benutzer, allgemeine MemoryDB-Systemadministratoraufgaben auszuführen
Zu den allgemeinen Systemadministratoraufgaben gehört das Ändern von Clustern, Parametern und Parametergruppen. Ein Systemadministrator möchte möglicherweise auch Informationen über die MemoryDB-Ereignisse abrufen. Die folgende Richtlinie gewährt einem Benutzer Berechtigungen zur Ausführung von MemoryDB-Aktionen für diese allgemeinen Systemadministratoraufgaben. Normalerweise ordnen Sie diese Art Berechtigungsrichtlinie der Systemadministratorengrupe zu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "MDBAllowSpecific",
"Effect": "Allow",
"Action": [
"memorydb:UpdateCluster",
"memorydb:DescribeClusters",
"memorydb:DescribeEvents",
"memorydb:UpdateParameterGroup",
"memorydb:DescribeParameterGroups",
"memorydb:DescribeParameters",
"memorydb:ResetParameterGroup"
],
"Resource": "*"
}
]
}
```
------
### Beispiel 3: Erlauben Sie einem Benutzer den Zugriff auf alle MemoryDB-API-Aktionen
Die folgende Richtlinie ermöglicht einem Benutzer den Zugriff auf alle MemoryDB-Aktionen. Es wird empfohlen, diese Art von Berechtigungsrichtlinie nur einem Administratorbenutzer zu gewähren.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[{
"Sid": "MDBAllowAll",
"Effect":"Allow",
"Action":[
"memorydb:*" ],
"Resource":"*"
}
]
}
```
------
### Beispiel 4: Erlauben Sie einem Benutzer, die IAM-API aufzurufen CreateServiceLinkedRole
Die folgende Richtlinie ermöglicht dem Benutzer den Aufruf der IAM-`CreateServiceLinkedRole`-API. Wir empfehlen, dass Sie dem Benutzer, der mutative MemoryDB-Operationen aufruft, diese Art von Berechtigungsrichtlinie gewähren.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"CreateSLRAllows",
"Effect":"Allow",
"Action":[
"iam:CreateServiceLinkedRole"
],
"Resource":"*",
"Condition":{
"StringLike":{
"iam:AWS ServiceName":"memorydb.amazonaws.com"
}
}
}
]
}
```
------
# Berechtigungen auf Ressourcenebene
Sie können den Umfang der Berechtigungen einschränken, indem Sie Ressourcen in einer IAM-Richtlinie festlegen. Viele AWS CLI API-Aktionen unterstützen einen Ressourcentyp, der je nach Verhalten der Aktion variiert. Jede IAM-Richtlinienanweisung erteilt die Berechtigung für eine Aktion, die auf eine Ressource ausgeführt wird. Wenn die Aktion nicht auf eine benannte Ressource wirkt oder wenn Sie die Erlaubnis erteilen, die Aktion auf allen Ressourcen durchzuführen, ist der Wert der Ressource in der Richtlinie ein Platzhalter (\$1). Für viele API-Aktionen können Sie die Ressourcen einschränken, die ein Benutzer ändern kann. Hierzu geben Sie den Amazon-Ressourcennamen (ARN) einer Ressource oder ein ARN-Muster an, das mehreren Ressourcen entspricht. Zum Einschränken von Berechtigungen nach Ressource bestimmen Sie die Ressource unter Angabe des ARN.
**ARN-Format für MemoryDB-Ressourcen**
**Anmerkung**
Damit Berechtigungen auf Ressourcenebene wirksam sind, sollte der Ressourcenname in der ARN-Zeichenfolge in Kleinbuchstaben geschrieben werden.
+ Benutzer — arn:aws:memorydb ::user/user1 *us-east-1:123456789012*
+ ACL — arn:aws:memorydb ::acl/my-acl *us-east-1:123456789012*
+ Cluster — arn:aws:memorydb ::cluster/mein-cluster *us-east-1:123456789012*
+ Schnappschuss — arn:aws:memorydb ::snapshot/mein-snapshot *us-east-1:123456789012*
+ Parametergruppe — arn:aws:memorydb ::parametergroup/ *us-east-1:123456789012* my-parameter-group
+ Subnetzgruppe — arn:aws:memorydb *us-east-1:123456789012* ::subnetgroup/ my-subnet-group
**Topics**
+ [
## Beispiel 1: Erlauben Sie einem Benutzer vollen Zugriff auf bestimmte MemoryDB-Ressourcentypen
](#example-allow-list-current-memorydb-resources-resource)
+ [
## Beispiel 2: Verweigern Sie einem Benutzer den Zugriff auf einen Cluster.
](#example-allow-specific-memorydb-actions-resource)
## Beispiel 1: Erlauben Sie einem Benutzer vollen Zugriff auf bestimmte MemoryDB-Ressourcentypen
Die folgende Richtlinie erlaubt ausdrücklich den angegebenen `account-id` Vollzugriff auf alle Ressourcen vom Typ Subnetzgruppe, Sicherheitsgruppe und Cluster.
```
{
"Sid": "Example1",
"Effect": "Allow",
"Action": "memorydb:*",
"Resource": [
"arn:aws:memorydb:us-east-1:account-id:subnetgroup/*",
"arn:aws:memorydb:us-east-1:account-id:securitygroup/*",
"arn:aws:memorydb:us-east-1:account-id:cluster/*"
]
}
```
## Beispiel 2: Verweigern Sie einem Benutzer den Zugriff auf einen Cluster.
Im folgenden Beispiel wird der angegebene `account-id` Zugriff auf einen bestimmten Cluster explizit verweigert.
```
{
"Sid": "Example2",
"Effect": "Deny",
"Action": "memorydb:*",
"Resource": [
"arn:aws:memorydb:us-east-1:account-id:cluster/name"
]
}
```
# Verwenden von dienstverknüpften Rollen für MemoryDB
[MemoryDB verwendet dienstgebundene Rollen AWS Identity and Access Management (IAM).](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) Eine dienstgebundene Rolle ist ein einzigartiger Typ von IAM-Rolle, die direkt mit einem AWS Dienst verknüpft ist, z. B. MemoryDB. Serviceverknüpfte MemoryDB-Rollen sind von MemoryDB vordefiniert. Sie enthalten alle Berechtigungen, die der Dienst benötigt, um AWS -Dienste im Namen Ihrer Cluster aufzurufen.
Eine dienstverknüpfte Rolle erleichtert die Einrichtung von MemoryDB, da Sie die erforderlichen Berechtigungen nicht manuell hinzufügen müssen. Die Rollen existieren bereits in Ihrem AWS Konto, sind jedoch mit MemoryDB-Anwendungsfällen verknüpft und verfügen über vordefinierte Berechtigungen. Nur MemoryDB kann diese Rollen übernehmen, und nur diese Rollen können die vordefinierte Berechtigungsrichtlinie verwenden. Sie können die Rollen nur nach dem Löschen der zugehörigen Ressourcen löschen. Dadurch werden Ihre MemoryDB-Ressourcen geschützt, da Sie die für den Zugriff auf die Ressourcen erforderlichen Berechtigungen nicht versehentlich entfernen können.
Informationen zu anderen Services, die serviceverknüpften Rollen unterstützen, finden Sie unter [AWS -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.
**Contents**
+ [Berechtigungen von serviceverknüpften Rollen](#service-linked-role-permissions)
+ [
## Erstellen einer serviceverknüpften Rolle (IAM)
](#create-service-linked-role-iam)
+ [Verwenden der IAM-Konsole](#create-service-linked-role-iam-console)
+ [Verwenden der IAM-CLI](#create-service-linked-role-iam-cli)
+ [Verwenden der IAM-API](#create-service-linked-role-iam-api)
+ [Bearbeiten der Beschreibung einer serviceverknüpften Rolle](#edit-service-linked-role)
+ [Verwenden der IAM-Konsole](#edit-service-linked-role-iam-console)
+ [Verwenden der IAM-CLI](#edit-service-linked-role-iam-cli)
+ [Verwenden der IAM-API](#edit-service-linked-role-iam-api)
+ [
## Löschen einer dienstverknüpften Rolle für MemoryDB
](#delete-service-linked-role)
+ [
### Bereinigen einer serviceverknüpften Rolle
](#service-linked-role-review-before-delete)
+ [
### Löschen einer serviceverknüpften Rolle (IAM-Konsole)
](#delete-service-linked-role-iam-console)
+ [
### Löschen einer serviceverknüpften Rolle (IAM-CLI)
](#delete-service-linked-role-iam-cli)
+ [
### Löschen einer serviceverknüpften Rolle (IAM-API)
](#delete-service-linked-role-iam-api)
## Dienstbezogene Rollenberechtigungen für MemoryDB
MemoryDB verwendet die dienstgebundene Rolle DB. Diese Richtlinie ermöglicht es **AWSServiceRoleForMemoryMemoryDB**, AWS Ressourcen in Ihrem Namen zu verwalten, sofern dies für die Verwaltung Ihrer Cluster erforderlich ist.
Die AWSService RoleForMemory Berechtigungsrichtlinie für datenbankbezogene Rollen ermöglicht es MemoryDB, die folgenden Aktionen für die angegebenen Ressourcen durchzuführen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:aws-cn:ec2:*:*:network-interface/*",
"Condition": {
"StringEquals": {
"ec2:CreateAction": "CreateNetworkInterface"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": [
"AmazonMemoryDBManaged"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface"
],
"Resource": [
"arn:aws-cn:ec2:*:*:network-interface/*",
"arn:aws-cn:ec2:*:*:subnet/*",
"arn:aws-cn:ec2:*:*:security-group/*"
]
},
{
"Effect": "Allow",
"Action": [
"ec2:DeleteNetworkInterface",
"ec2:ModifyNetworkInterfaceAttribute"
],
"Resource": "arn:aws-cn:ec2:*:*:network-interface/*",
"Condition": {
"StringEquals": {
"ec2:ResourceTag/AmazonMemoryDBManaged": "true"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:DeleteNetworkInterface",
"ec2:ModifyNetworkInterfaceAttribute"
],
"Resource": "arn:aws-cn:ec2:*:*:security-group/*"
},
{
"Effect": "Allow",
"Action": [
"ec2:DescribeSecurityGroups",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"cloudwatch:namespace": "AWS/MemoryDB"
}
}
}
]
}
```
------
Weitere Informationen finden Sie unter [AWS verwaltete Richtlinie: Arbeitsspeicher DBService RolePolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-memorydbServiceRolePolicy).
**Um einer IAM-Entität zu ermöglichen, dienstverknüpfte DB-Rollen zu erstellen AWSService RoleForMemory**
Die folgende Berechtigungsanweisung zu den Berechtigungen für diese IAM-Entität hinzufügen:
```
{
"Effect": "Allow",
"Action": [
"iam:CreateServiceLinkedRole",
"iam:PutRolePolicy"
],
"Resource": "arn:aws:iam::*:role/aws-service-role/memorydb.amazonaws.com/AWSServiceRoleForMemoryDB*",
"Condition": {"StringLike": {"iam:AWS ServiceName": "memorydb.amazonaws.com"}}
}
```
**Um einer IAM-Entität zu ermöglichen, dienstverknüpfte DB-Rollen zu löschen AWSService RoleForMemory**
Die folgende Berechtigungsanweisung zu den Berechtigungen für diese IAM-Entität hinzufügen:
```
{
"Effect": "Allow",
"Action": [
"iam:DeleteServiceLinkedRole",
"iam:GetServiceLinkedRoleDeletionStatus"
],
"Resource": "arn:aws:iam::*:role/aws-service-role/memorydb.amazonaws.com/AWSServiceRoleForMemoryDB*",
"Condition": {"StringLike": {"iam:AWS ServiceName": "memorydb.amazonaws.com"}}
}
```
Alternativ können Sie eine AWS verwaltete Richtlinie verwenden, um vollen Zugriff auf MemoryDB zu gewähren.
## Erstellen einer serviceverknüpften Rolle (IAM)
Sie können eine serviceverknüpfte Rolle mithilfe der IAM-Konsole, der CLI oder API erstellen.
### Erstellen einer serviceverknüpften Rolle (IAM-Konsole)
Sie können die IAM-Konsole für das Erstellen einer serviceverknüpften Rolle verwenden.
**So erstellen Sie eine serviceverknüpfte Rolle (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. **Wählen Sie im linken Navigationsbereich der IAM-Konsole Rollen aus.** Klicken Sie auf **Create New Role (Neue Rolle erstellen)**.
1. Wählen Sie unter **Select type of trusted entity (Typ der vertrauenswürdigen Entität auswählen)** die Option **AWS -Service** aus.
1. Wählen Sie unter **Oder wählen Sie einen Dienst aus, um seine Anwendungsfälle anzuzeigen**, die Option **MemoryDB** aus.
1. Wählen Sie **Weiter: Berechtigungen** aus.
1. Beachten Sie unter **Richtlinienname**, dass `MemoryDBServiceRolePolicy` für diese Rolle erforderlich ist. Wählen Sie **Weiter: Tags** aus.
1. Beachten Sie, dass Tags für serviceverknüpfte Rollen nicht unterstützt werden. Klicken Sie auf **Next:Review** (Weiter: Prüfen).
1. (Optional:) Bearbeiten Sie in **Role description** die Beschreibung für die neue serviceverknüpfte Rolle.
1. Prüfen Sie die Rolle und klicken Sie dann auf **Rolle erstellen**.
### Erstellen einer serviceverknüpften Rolle (IAM-CLI)
Sie können IAM-Operationen von verwenden, um eine dienstverknüpfte AWS Command Line Interface Rolle zu erstellen. Diese Rolle kann die Vertrauensrichtlinie, sowie die enthaltenen Richtlinien enthalten, die der Service für die Zuweisung der Rolle benötigt.
**So erstellen Sie eine serviceverknüpfte Rolle (CLI)**
Führen Sie die folgenden Operationen aus:
```
$ aws iam [create-service-linked-role](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceLinkedRole.html) --aws-service-name memorydb.amazonaws.com
```
### Erstellen einer serviceverknüpften Rolle (IAM-API)
Sie können die IAM-API für das Erstellen einer serviceverknüpften Rolle verwenden. Diese Rolle kann die Vertrauensrichtlinie, sowie die enthaltenen Richtlinien enthalten, die der Service für die Zuweisung der Rolle benötigt.
**So erstellen Sie eine serviceverknüpfte Rolle (API)**
Verwenden Sie den [CreateServiceLinkedRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateServiceLinkedRole.html)-API-Aufruf. Geben Sie in der Anforderung einen Servicenamen im Format `memorydb.amazonaws.com` an.
## Die Beschreibung einer serviceverknüpften Rolle für MemoryDB bearbeiten
MemoryDB erlaubt es Ihnen nicht, die dienstverknüpfte DB-Rolle zu bearbeiten. AWSService RoleForMemory 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.
### Bearbeiten der Beschreibung einer serviceverknüpften Rolle (IAM-Konsole)
Sie können die IAM-Konsole für das Bearbeiten der Beschreibung einer serviceverknüpften Rolle verwenden.
**So bearbeiten Sie die Beschreibung einer serviceverknüpften Rolle (Konsole)**
1. **Wählen Sie im linken Navigationsbereich der IAM-Konsole die Option Rollen aus.**
1. Wählen Sie den Namen der zu ändernden Rolle.
1. Wählen Sie neben **Role description** ganz rechts **Edit**.
1. Geben Sie eine neue Beschreibung im Dialogfeld ein und klicken Sie auf **Save (Speichern)**.
### Bearbeiten der Beschreibung einer serviceverknüpften Rolle (IAM-CLI)
Sie können IAM-Operationen von aus verwenden, AWS Command Line Interface um eine mit einem Dienst verknüpfte Rollenbeschreibung zu bearbeiten.
**So ändern Sie die Beschreibung einer serviceverknüpften Rolle (CLI)**
1. (Optional) Verwenden Sie den Vorgang for IAM, um die aktuelle Beschreibung AWS CLI für eine Rolle anzuzeigen. `[get-role](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)`
**Example**
```
$ aws iam [get-role](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) --role-name AWSServiceRoleForMemoryDB
```
Verwenden Sie den Rollennamen, nicht den ARN, um sich auf Rollen mit den CLI-Operationen zu beziehen. Wenn eine Rolle zum Beispiel folgenden ARN hat: `arn:aws:iam::123456789012:role/myrole`, verweisen Sie auf die Rolle als **myrole**.
1. Verwenden Sie den Vorgang AWS CLI for IAM, um die Beschreibung einer serviceverknüpften Rolle zu aktualisieren. `[update-role-description](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRoleDescription.html)`
Für Linux, macOS oder Unix:
```
$ aws iam [update-role-description](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRoleDescription.html) \
--role-name AWSServiceRoleForMemoryDB \
--description "new description"
```
Für Windows:
```
$ aws iam [update-role-description](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRoleDescription.html) ^
--role-name AWSServiceRoleForMemoryDB ^
--description "new description"
```
### Bearbeiten der Beschreibung einer serviceverknüpften Rolle (IAM-API)
Sie können die IAM-API für das Bearbeiten der Beschreibung einer serviceverknüpften Rolle verwenden.
**So ändern Sie die Beschreibung einer serviceverknüpften Rolle (API)**
1. (Optional) Um die aktuelle Beschreibung einer Rolle anzuzeigen, verwenden Sie die IAM-API-Operation [GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html).
**Example**
```
https://iam.amazonaws.com/
?Action=[GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)
&RoleName=AWSServiceRoleForMemoryDB
&Version=2010-05-08
&AUTHPARAMS
```
1. Um die Beschreibung einer Rolle zu aktualisieren, verwenden Sie die IAM-API-Operation [UpdateRoleDescription](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRoleDescription.html).
**Example**
```
https://iam.amazonaws.com/
?Action=[UpdateRoleDescription](https://docs.aws.amazon.com/IAM/latest/APIReference/API_UpdateRoleDescription.html)
&RoleName=AWSServiceRoleForMemoryDB
&Version=2010-05-08
&Description="New description"
```
## Löschen einer dienstverknüpften Rolle für MemoryDB
Wenn Sie ein Feature oder einen Dienst, die bzw. der eine serviceverknüpften Rolle erfordert, nicht mehr benötigen, sollten Sie diese Rolle löschen. Auf diese Weise haben Sie keine ungenutzte juristische Stelle, die nicht aktiv überwacht oder verwaltet wird. Sie müssen jedoch Ihre serviceverknüpfte Rolle zunächst bereinigen, bevor Sie sie löschen können.
MemoryDB löscht die dienstverknüpfte Rolle nicht für Sie.
### Bereinigen einer serviceverknüpften Rolle
Bevor Sie IAM verwenden können, um eine dienstverknüpfte Rolle zu löschen, stellen Sie zunächst sicher, dass der Rolle keine Ressourcen (Cluster) zugeordnet sind.
**So überprüfen Sie in der IAM-Konsole, ob die serviceverknüpfte Rolle über eine aktive Sitzung verfügt**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. **Wählen Sie im linken Navigationsbereich der IAM-Konsole Rollen aus.** Wählen Sie dann den Namen (nicht das Kontrollkästchen) der AWSService RoleForMemory DB-Rolle aus.
1. Wählen Sie auf der Seite **Summary** für die ausgewählte Rolle die Registerkarte **Access Advisor**.
1. Überprüfen Sie auf der Registerkarte **Access Advisor** die jüngsten Aktivitäten für die serviceverknüpfte Rolle.
**Um MemoryDB-Ressourcen zu löschen, die AWSService RoleForMemory DB (Konsole) benötigen**
+ Informationen zum Löschen eines Clusters finden Sie unter:
+ [Mit dem AWS-Managementkonsole](getting-started.md#clusters.deleteclusters.viewdetails)
+ [Verwenden Sie den AWS CLI](getting-started.md#clusters.delete.cli)
+ [Verwenden der MemoryDB-API](getting-started.md#clusters.delete.api)
### Löschen einer serviceverknüpften Rolle (IAM-Konsole)
Sie können die IAM-Konsole für das Löschen einer serviceverknüpften Rolle verwenden.
**So löschen Sie eine serviceverknüpfte Rolle (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. **Wählen Sie im linken Navigationsbereich der IAM-Konsole Rollen aus.** Aktivieren Sie dann das Kontrollkästchen neben dem Rollennamen, den Sie löschen möchten, nicht den Namen oder die Zeile selbst.
1. Wählen Sie für **Role actions** oben auf der Seite **Delete role** aus.
1. Überprüfen Sie auf der Bestätigungsseite die Daten, auf die der Dienst zuletzt zugegriffen hat. Aus diesen Daten geht hervor, wann jede der ausgewählten Rollen zuletzt auf einen AWS Dienst zugegriffen hat. Auf diese Weise können Sie leichter bestätigen, ob die Rolle derzeit aktiv ist. Wenn Sie fortfahren möchten, wählen Sie **Yes, Delete** aus, um die serviceverknüpfte Rolle zur Löschung zu übermitteln.
1. Sehen Sie sich die Benachrichtigungen in der IAM-Konsole an, um den Fortschritt der Löschung der serviceverknüpften Rolle zu überwachen. Da die Löschung der serviceverknüpften IAM-Rolle asynchron erfolgt, kann die Löschung nach dem Übermitteln der Rolle für die Löschung erfolgreich sein oder fehlschlagen. Wenn der Vorgang fehlschlägt, können Sie in den Benachrichtigungen **View details** oder **View Resources** auswählen, um zu erfahren, warum die Löschung fehlgeschlagen ist.
### Löschen einer serviceverknüpften Rolle (IAM-CLI)
Sie können IAM-Operationen von verwenden, AWS Command Line Interface um eine dienstverknüpfte Rolle zu löschen.
**So löschen Sie eine serviceverknüpfte Rolle (CLI)**
1. Wenn Sie den Namen der serviceverknüpften Rolle, die Sie löschen möchten, nicht kennen, geben Sie den folgenden Befehl ein. Dieser Befehl listet die Rollen und ihre Amazon-Ressourcennamen (ARNs) in Ihrem Konto auf.
```
$ aws iam [get-role](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html) --role-name role-name
```
Verwenden Sie den Rollennamen, nicht den ARN, um sich auf Rollen mit den CLI-Operationen zu beziehen. Wenn eine Rolle zum Beispiel den ARN `arn:aws:iam::123456789012:role/myrole` hat, verweisen Sie auf die Rolle als **myrole**.
1. Da eine serviceverknüpfte Rolle nicht gelöscht werden kann, wenn sie verwendet wird oder ihr Ressourcen zugeordnet sind, müssen Sie eine Löschungsanforderung übermitteln. Diese Anforderung kann verweigert werden, wenn diese Bedingungen nicht erfüllt sind. Sie benötigen die `deletion-task-id` aus der Antwort, um den Status der Löschaufgabe zu überprüfen. Geben Sie Folgendes ein, um eine Anforderung zum Löschen einer serviceverknüpften Rolle abzusenden.
```
$ aws iam [delete-service-linked-role](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServiceLinkedRole.html) --role-name role-name
```
1. Geben Sie Folgendes ein, um den Status der Löschaufgabe zu überprüfen.
```
$ aws iam [get-service-linked-role-deletion-status](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetServiceLinkedRoleDeletionStatus.html) --deletion-task-id deletion-task-id
```
Der Status der Löschaufgabe kann `NOT_STARTED`, `IN_PROGRESS`, `SUCCEEDED` oder `FAILED` lauten. Wenn die Löschung fehlschlägt, gibt der Aufruf den Grund zurück, sodass Sie das Problem beheben können.
### Löschen einer serviceverknüpften Rolle (IAM-API)
Sie können die IAM-API zum Löschen einer serviceverknüpften Rolle verwenden.
**So löschen Sie eine serviceverknüpfte Rolle (API)**
1. Um eine Löschanfrage für eine serviceverknüpfte Rolle zu übermitteln, rufen Sie [DeleteServiceLinkedRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServiceLinkedRole.html) auf. Geben Sie in der Anforderung einen Rollennamen an.
Da eine serviceverknüpfte Rolle nicht gelöscht werden kann, wenn sie verwendet wird oder ihr Ressourcen zugeordnet sind, müssen Sie eine Löschungsanforderung übermitteln. Diese Anforderung kann verweigert werden, wenn diese Bedingungen nicht erfüllt sind. Sie benötigen die `DeletionTaskId` aus der Antwort, um den Status der Löschaufgabe zu überprüfen.
1. Um den Status der Löschung zu überprüfen, rufen Sie [GetServiceLinkedRoleDeletionStatus](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetServiceLinkedRoleDeletionStatus.html) auf. Geben Sie in der Anforderung die `DeletionTaskId` an.
Der Status der Löschaufgabe kann `NOT_STARTED`, `IN_PROGRESS`, `SUCCEEDED` oder `FAILED` lauten. Wenn die Löschung fehlschlägt, gibt der Aufruf den Grund zurück, sodass Sie das Problem beheben können.
# AWS verwaltete Richtlinien für MemoryDB
Um Benutzern, Gruppen und Rollen Berechtigungen hinzuzufügen, ist es einfacher, AWS verwaltete Richtlinien zu verwenden, als Richtlinien selbst zu schreiben. Es erfordert Zeit und Fachwissen, um [von Kunden verwaltete IAM-Richtlinien zu erstellen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html), die Ihrem Team nur die benötigten Berechtigungen bieten. Um schnell loszulegen, können Sie unsere AWS verwalteten Richtlinien verwenden. Diese Richtlinien decken allgemeine Anwendungsfälle ab und sind in Ihrem AWS Konto verfügbar. Weitere Informationen zu AWS verwalteten Richtlinien finden Sie unter [AWS Verwaltete Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) im *IAM-Benutzerhandbuch*.
AWS Dienste verwalten und aktualisieren AWS verwaltete Richtlinien. Sie können die Berechtigungen in AWS verwalteten Richtlinien nicht ändern. Services fügen einer von AWS verwalteten Richtlinien gelegentlich zusätzliche Berechtigungen hinzu, um neue Features zu unterstützen. Diese Art von Update betrifft alle Identitäten (Benutzer, Gruppen und Rollen), an welche die Richtlinie angehängt ist. Services aktualisieren eine von AWS verwaltete Richtlinie am ehesten, ein neues Feature gestartet wird oder neue Vorgänge verfügbar werden. Dienste entfernen keine Berechtigungen aus einer AWS verwalteten Richtlinie, sodass durch Richtlinienaktualisierungen Ihre bestehenden Berechtigungen nicht beeinträchtigt werden.
AWS Unterstützt außerdem verwaltete Richtlinien für Jobfunktionen, die sich über mehrere Dienste erstrecken. Die **ReadOnlyAccess** AWS verwaltete Richtlinie bietet beispielsweise schreibgeschützten Zugriff auf alle AWS Dienste und Ressourcen. Wenn ein Dienst eine neue Funktion startet, werden nur Leseberechtigungen für neue Operationen und Ressourcen AWS hinzugefügt. Eine Liste und Beschreibungen der Richtlinien für Auftragsfunktionen finden Sie in [Verwaltete AWS -Richtlinien für Auftragsfunktionen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) im *IAM-Leitfaden*.
## AWS verwaltete Richtlinie: Arbeitsspeicher DBService RolePolicy
Sie können die Richtlinie für den DBService RolePolicy AWS verwalteten Speicher nicht mit Identitäten in Ihrem Konto verknüpfen. Diese Richtlinie ist Teil der serviceverknüpften AWS MemoryDB-Rolle. Diese Rolle ermöglicht es dem Dienst, Netzwerkschnittstellen und Sicherheitsgruppen in Ihrem Konto zu verwalten.
MemoryDB verwendet die Berechtigungen in dieser Richtlinie, um EC2-Sicherheitsgruppen und Netzwerkschnittstellen zu verwalten. Dies ist für die Verwaltung von MemoryDB-Clustern erforderlich.
**Details zu Berechtigungen**
Diese Richtlinie umfasst die folgenden Berechtigungen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateTags"
],
"Resource": "arn:aws-cn:ec2:*:*:network-interface/*",
"Condition": {
"StringEquals": {
"ec2:CreateAction": "CreateNetworkInterface"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": [
"AmazonMemoryDBManaged"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface"
],
"Resource": [
"arn:aws-cn:ec2:*:*:network-interface/*",
"arn:aws-cn:ec2:*:*:subnet/*",
"arn:aws-cn:ec2:*:*:security-group/*"
]
},
{
"Effect": "Allow",
"Action": [
"ec2:DeleteNetworkInterface",
"ec2:ModifyNetworkInterfaceAttribute"
],
"Resource": "arn:aws-cn:ec2:*:*:network-interface/*",
"Condition": {
"StringEquals": {
"ec2:ResourceTag/AmazonMemoryDBManaged": "true"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:DeleteNetworkInterface",
"ec2:ModifyNetworkInterfaceAttribute"
],
"Resource": "arn:aws-cn:ec2:*:*:security-group/*"
},
{
"Effect": "Allow",
"Action": [
"ec2:DescribeSecurityGroups",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeAvailabilityZones",
"ec2:DescribeSubnets",
"ec2:DescribeVpcs"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"cloudwatch:namespace": "AWS/MemoryDB"
}
}
}
]
}
```
------
## AWS-verwaltete (vordefinierte) Richtlinien für MemoryDB
AWS adressiert viele gängige Anwendungsfälle durch die Bereitstellung eigenständiger IAM-Richtlinien, die von erstellt und verwaltet werden. AWS Die verwalteten Richtlinien erteilen die erforderlichen Berechtigungen für viele häufige Anwendungsfälle, sodass Sie nicht mühsam ermitteln müssen, welche Berechtigungen erforderlich sind. Weitere Informationen finden Sie unter [AWS -verwaltete Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) im *IAM-Benutzerhandbuch*.
Die folgenden AWS verwalteten Richtlinien, die Sie Benutzern in Ihrem Konto zuordnen können, gelten nur für MemoryDB:
### AmazonMemoryDBReadOnlyAccess
Sie können die `AmazonMemoryDBReadOnlyAccess`-Richtlinie an Ihre IAM-Identitäten anfügen. Diese Richtlinie gewährt Administratorberechtigungen, die nur Lesezugriff auf alle MemoryDB-Ressourcen ermöglichen.
**AmazonMemoryDBReadOnlyAccess**- Gewährt schreibgeschützten Zugriff auf MemoryDB-Ressourcen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"memorydb:Describe*",
"memorydb:List*"
],
"Resource": "*"
}]
}
```
------
### AmazonMemoryDBFullZugriff
Sie können die `AmazonMemoryDBFullAccess`-Richtlinie an Ihre IAM-Identitäten anfügen. Diese Richtlinie gewährt Administratorberechtigungen, die vollen Zugriff auf alle MemoryDB-Ressourcen ermöglichen.
**AmazonMemoryDBFullZugriff** — Gewährt vollen Zugriff auf MemoryDB-Ressourcen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "memorydb:*",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/memorydb.amazonaws.com/AWSServiceRoleForMemoryDB",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "memorydb.amazonaws.com"
}
}
}
]
}
```
------
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "memorydb:*",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws-cn:iam::*:role/aws-service-role/memorydb.amazonaws.com/AWSServiceRoleForMemoryDB",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "memorydb.amazonaws.com"
}
}
}
]
}
```
------
Sie können auch Ihre eigenen benutzerdefinierten IAM-Richtlinien erstellen, um Berechtigungen für MemoryDB-API-Aktionen zu gewähren. Die benutzerdefinierten Richtlinien können Sie dann den IAM-Benutzern oder -Gruppen zuweisen, die diese Berechtigungen benötigen.
## MemoryDB-Updates für verwaltete Richtlinien AWS
Sehen Sie sich Details zu Aktualisierungen der AWS verwalteten Richtlinien für MemoryDB an, seit dieser Dienst begonnen hat, diese Änderungen zu verfolgen. Abonnieren Sie den RSS-Feed auf der Seite MemoryDB-Dokumentenverlauf, um automatische Benachrichtigungen über Änderungen an dieser Seite zu erhalten.
| Änderungen | Beschreibung | Date |
| --- | --- | --- |
| [AWS verwaltete Richtlinie: Arbeitsspeicher DBService RolePolicy](#security-iam-awsmanpol-memorydbServiceRolePolicy)— Richtlinie wird hinzugefügt | Memory DBService RolePolicy hat die Berechtigung für memorydb hinzugefügt:. ReplicateMultiRegionClusterData Diese Berechtigung ermöglicht es der serviceverknüpften Rolle, Daten für MemoryDB-Cluster mit mehreren Regionen zu replizieren. | 01.12.2024 |
| [AmazonMemoryDBFullZugriff](#iam.identitybasedpolicies.predefinedpolicies-fullaccess)— Richtlinie wird hinzugefügt | MemoryDB hat neue Berechtigungen hinzugefügt, um unterstützte Ressourcen zu beschreiben und aufzulisten. Diese Berechtigungen sind erforderlich, damit MemoryDB alle unterstützten Ressourcen in einem Konto abfragen kann. | 10.07.2021 |
| [AmazonMemoryDBReadOnlyAccess](#iam.identitybasedpolicies.predefinedpolicies-readonly)— Richtlinie hinzufügen | MemoryDB hat neue Berechtigungen hinzugefügt, um unterstützte Ressourcen zu beschreiben und aufzulisten. Diese Berechtigungen sind erforderlich, damit MemoryDB kontobasierte Anwendungen erstellen kann, indem alle unterstützten Ressourcen in einem Konto abgefragt werden. | 10.07.2021 |
| MemoryDB hat begonnen, Änderungen zu verfolgen | Servicestart | 19.8.2021 |
# MemoryDB-API-Berechtigungen: Referenz zu Aktionen, Ressourcen und Bedingungen
Wenn Sie [Zugriffskontroll](iam.md#iam.accesscontrol) - und Schreibberechtigungsrichtlinien einrichten, um sie an eine IAM-Richtlinie anzuhängen (entweder identitäts- oder ressourcenbasiert), verwenden Sie die folgende Tabelle als Referenz. In der Tabelle sind alle MemoryDB-API-Operationen und die entsprechenden Aktionen aufgeführt, für die Sie Berechtigungen zur Ausführung der Aktion erteilen können. Sie geben die Aktionen im Feld `Action` der Richtlinie und einen Ressourcenwert im Feld `Resource` der Richtlinie an. Sofern nicht anders angegeben, ist die Ressource erforderlich. Einige Felder enthalten sowohl eine erforderliche Ressource als auch optionale Ressourcen. Wenn kein Ressourcen-ARN vorhanden ist, ist die Ressource in der Richtlinie als Platzhalter (\$1) dargestellt.
**Anmerkung**
Um eine Aktion anzugeben, verwenden Sie das Präfix `memorydb:` gefolgt vom Namen der API-Operation (z. B. `memorydb:DescribeClusters`).
Mit den Bildlaufleisten können Sie den Rest der Tabelle sehen.
**MemoryDB-API und erforderliche Berechtigungen für Aktionen**
| MemoryDB-API-Operationen | Erforderliche Berechtigungen (API-Aktionen) | Ressourcen |
| --- | --- | --- |
| [BatchUpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_BatchUpdateCluster.html) | `memorydb:BatchUpdateCluster` | Cluster |
| [CopySnapshot](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CopySnapshot.html) | `memorydb:CopySnapshot` `memorydb:TagResource` `s3:GetBucketLocation` `s3:ListAllMyBuckets` | Snapshot (Quelle, Ziel) \$1 \$1 |
| [CreateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateCluster.html) | `memorydb:CreateCluster` `memorydb:TagResource` `s3:GetObject` Wenn Sie den Parameter `SnapshotArns` verwenden, benötigt jedes Mitglied der `SnapshotArns`-Liste seine eigene `s3:GetObject`-Berechtigung mit dem `s3`-ARN als Ressource. | Parametergruppe. (Optional) Cluster, Snapshot, Sicherheitsgruppen-IDs und Subnetzgruppe `arn:aws:s3:::my_bucket/snapshot1.rdb` Wobei*my\$1bucket*/für einen S3-Bucket und einen Snapshot *snapshot1* steht, aus dem Sie den Cluster erstellen möchten. |
| [CreateParameterGroup](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateParameterGroup.html) | `memorydb:CreateParameterGroup` `memorydb:TagResource` | Parametergruppe |
| [CreateSubnetGroup](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateSubnetGroup.html) | `memorydb:CreateSubnetGroup` `memorydb:TagResource` | Subnetzgruppe | \$1 |
| [CreateSnapshot](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateSnapshot.html) | `memorydb:CreateSnapshot` `memorydb:TagResource` | Schnappschuss, Cluster |
| [CreateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateUser.html) | `memorydb:CreateUser` `memorydb:TagResource` | Benutzer |
| [ACL erstellen](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateACL.html) | `memorydb:CreateACL` `memorydb:TagResource` | Zugriffskontrollliste (ACL) |
| [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html) | `memorydb:UpdateCluster` | Cluster |
| [DeleteCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DeleteCluster.html) | `memorydb:DeleteCluster` | Cluster. (Optional) Snapshot |
| [DeleteParameterGroup](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DeleteParameterGroup.html) | `memorydb:DeleteParameterGroup` | Parametergruppe |
| [DeleteSubnetGroup](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DeleteSubnetGroup.html) | `memorydb:DeleteSubnetGroup` | Subnetzgruppe |
| [DeleteSnapshot](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DeleteSnapshot.html) | `memorydb:DeleteSnapshot` | Schnappschuss |
| [DeleteUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DeleteUser.html) | `memorydb:DeleteUser` | Benutzer |
| [ACL löschen](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DeleteACL.html) | `memorydb:DeleteACL` | ACL |
| [DescribeClusters](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html) | `memorydb:DescribeClusters` | Cluster |
| [DescribeEngineVersions](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeEngineVersions.html) | `memorydb:DescribeEngineVersions` | Keine Ressourcen-ARN: \$1 |
| [DescribeParameterGroups](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeParameterGroups.html) | `memorydb:DescribeParameterGroups` | Parametergruppe |
| [DescribeParameters](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeParameters.html) | `memorydb:DescribeParameters` | Parametergruppe |
| [DescribeSubnetGroups](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeSubnetGroups.html) | `memorydb:DescribeSubnetGroups` | Subnetzgruppe | \$1 |
| [DescribeEvents](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeEvents.html) | `memorydb:DescribeEvents` | Keine Ressourcen-ARN: \$1 |
| [DescribeClusters](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html) | `memorydb:DescribeClusters` | Cluster |
| [DescribeServiceUpdates](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeServiceUpdates.html) | `memorydb:DescribeServiceUpdates` | Keine Ressourcen-ARN: \$1 |
| [DescribeSnapshots](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeSnapshots.html) | `memorydb:DescribeSnapshots` | Schnappschuss |
| [DescribeUsers](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeUsers.html) | `memorydb:DescribeUsers` | Benutzer |
| [Beschreiben ACLs](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeACLs.html) | `memorydb:DescribeACLs` | ACLs |
| [ListAllowedNodeTypeUpdates](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_ListAllowedNodeTypeUpdates.html) | `memorydb:ListAllowedNodeTypeUpdates` | Cluster |
| [ListTags](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_ListTags.html) | `memorydb:ListTags` | (Optional) Cluster, Snapshot |
| [UpdateParameterGroup](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateParameterGroup.html) | `memorydb:UpdateParameterGroup` | Parametergruppe |
| [UpdateSubnetGroup](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateSubnetGroup.html) | `memorydb:UpdateSubnetGroup` | Subnetzgruppe |
| [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html) | `memorydb:UpdateCluster` | Cluster. (Optional) Parametergruppe, Sicherheitsgruppe |
| [UpdateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateUser.html) | `memorydb:UpdateUser` | Benutzer |
| [ACL aktualisieren](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateACL.html) | `memorydb:UpdateACL` | ACL |
| [UntagResource](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UntagResource.html) | `memorydb:UntagResource` | (Optional) Cluster, Snapshot |
| [ResetParameterGroup](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_ResetParameterGroup.html) | `memorydb:ResetParameterGroup` | Parametergruppe |
| [FailoverShard](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_FailoverShard.html) | `memorydb:FailoverShard` | Cluster, Shard |
# Protokollierung und Überwachung
Die Überwachung ist ein wichtiger Bestandteil der Aufrechterhaltung der Zuverlässigkeit, Verfügbarkeit und Leistung von MemoryDB und Ihren anderen AWS Lösungen. AWS bietet die folgenden Überwachungstools, um MemoryDB zu überwachen, zu melden, wenn etwas nicht stimmt, und gegebenenfalls automatische Maßnahmen zu ergreifen:
+ *Amazon CloudWatch* überwacht Ihre AWS Ressourcen und die Anwendungen, auf denen Sie laufen, AWS in Echtzeit. Sie können Kennzahlen erfassen und verfolgen, benutzerdefinierte Dashboards erstellen und Alarme festlegen, die Sie benachrichtigen oder Maßnahmen ergreifen, wenn eine bestimmte Metrik einen von Ihnen festgelegten Schwellenwert erreicht. Sie können beispielsweise die CPU-Auslastung oder andere Kennzahlen Ihrer EC2 Amazon-Instances CloudWatch verfolgen und bei Bedarf automatisch neue Instances starten. Weitere Informationen finden Sie im [ CloudWatch Amazon-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
+ Mit *Amazon CloudWatch Logs* können Sie Ihre Protokolldateien von EC2 Amazon-Instances und anderen Quellen überwachen CloudTrail, speichern und darauf zugreifen. CloudWatch Logs kann Informationen in den Protokolldateien überwachen und Sie benachrichtigen, wenn bestimmte Schwellenwerte erreicht werden. Sie können Ihre Protokolldaten auch in einem sehr robusten Speicher archivieren. Weitere Informationen finden Sie im [Amazon CloudWatch Logs-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/).
+ *AWS CloudTrail*erfasst API-Aufrufe und zugehörige Ereignisse, die von oder im Namen Ihres AWS Kontos getätigt wurden, und übermittelt die Protokolldateien an einen von Ihnen angegebenen Amazon S3 S3-Bucket. Sie können feststellen, welche Benutzer und Konten angerufen wurden AWS, von welcher Quell-IP-Adresse aus die Anrufe getätigt wurden und wann die Aufrufe erfolgten. Weitere Informationen finden Sie im [AWS CloudTrail -Benutzerhandbuch](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
# MemoryDB mit Amazon überwachen CloudWatch
Sie können MemoryDB mithilfe von CloudWatch MemoryDB überwachen. Dabei werden Rohdaten gesammelt und zu lesbaren Metriken verarbeitet, die nahezu in Echtzeit verfügbar sind. Diese Statistiken werden 15 Monate gespeichert, damit Sie auf Verlaufsinformationen zugreifen können und einen besseren Überblick darüber erhalten, wie Ihre Webanwendung oder der Service ausgeführt werden. Sie können auch Alarme einrichten, die auf bestimmte Grenzwerte achten und Benachrichtigungen senden oder Aktivitäten auslösen, wenn diese Grenzwerte erreicht werden. Weitere Informationen finden Sie im [ CloudWatch Amazon-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
In den folgenden Abschnitten sind die Metriken und Dimensionen für MemoryDB aufgeführt.
**Topics**
+ [
# Metriken auf Host-Ebene
](metrics.HostLevel.md)
+ [
# Metriken für MemoryDB
](metrics.memorydb.md)
+ [
# Welche Metriken sollte ich überwachen?
](metrics.whichshouldimonitor.md)
+ [
# Auswählen von Metrikstatistiken und -zeiträumen
](metrics.ChoosingStatisticsAndPeriods.md)
+ [
# CloudWatch Metriken überwachen
](cloudwatchmetrics.md)
# Metriken auf Host-Ebene
Der `AWS/MemoryDB` Namespace umfasst die folgenden Metriken auf Host-Ebene für einzelne Knoten.
**Weitere Informationen finden Sie auch unter:**
+ [Metriken für MemoryDB](metrics.memorydb.md)
| Metrik | Beschreibung | Einheit |
| --- | --- | --- |
| CPUUtilization | Der Prozentsatz der CPU-Nutzung für den gesamten Host. Da Valkey und Redis OSS Single-Threading verwenden, empfehlen wir Ihnen, die EngineCPUUtilization Metrik für Knoten mit 4 oder mehr v zu überwachen. CPUs | Prozent |
| FreeableMemory | Größe des freien Arbeitsspeichers auf dem Host. Diese Zahl wird aus dem Arbeitsspeicher und den Puffern abgeleitet, die das Betriebssystem als frei verfügbar meldet. | Bytes |
| NetworkBytesIn | Anzahl der Byte, die der Host aus dem Netzwerk gelesen hat. | Bytes |
| NetworkBytesOut | Anzahl der von der Instance auf allen Netzwerkschnittstellen gesendeten Byte. | Bytes |
| NetworkPacketsIn | Anzahl der von der Instance auf allen Netzwerkschnittstellen empfangenen Pakete. Diese Metrik gibt das an eine einzelne Instance eingehende Netzwerkdatenvolumen an, ausgedrückt in Anzahl an Paketen. | Anzahl |
| NetworkPacketsOut | Anzahl der von der Instance auf allen Netzwerkschnittstellen gesendeten Pakete. Diese Metrik gibt das von einer einzelnen Instance ausgehende Netzwerkdatenvolumen an, ausgedrückt in Anzahl an Paketen. | Anzahl |
| NetworkBandwidthInAllowanceExceeded | Die Anzahl der Pakete wurde geformt, weil die eingehende aggregierte Bandbreite das Maximum für die Instance überschritten hat. | Anzahl |
| NetworkConntrackAllowanceExceeded | Die Anzahl der Pakete wurde geformt, weil die Verbindungsverfolgung das Maximum für die Instance überschritten hat und keine neuen Verbindungen hergestellt werden konnten. Dies kann zu einem Paketverlust für den Datenverkehr zur oder von der Instance führen. | Anzahl |
| NetworkBandwidthOutAllowanceExceeded | Die Anzahl der Pakete wurde geformt, weil die ausgehende aggregierte Bandbreite das Maximum für die Instance überschritten hat. | Anzahl |
| NetworkPacketsPerSecondAllowanceExceeded | Die Anzahl der Pakete, die geformt wurden, weil Anzahl der bidirektionalen Pakete pro Sekunde das Maximum für die Instance überschritten hat. | Anzahl |
| NetworkMaxBytesIn | Die maximale Anzahl an empfangenen Byte pro Sekunde pro Sekunde pro Minute. | Bytes |
| NetworkMaxBytesOut | Die maximale Anzahl an übertragenen Byte pro Sekunde pro Sekunde pro Minute. | Bytes |
| NetworkMaxPacketsIn | Die maximale Anzahl an empfangenen Paketen pro Sekunde pro Sekunde pro Minute. | Anzahl |
| NetworkMaxPacketsOut | Die maximale Anzahl an übertragenen Paketen pro Sekunde pro Sekunde pro Minute. | Anzahl |
| SwapUsage | Größe des belegten Auslagerungsspeichers auf dem Host. | Bytes |
# Metriken für MemoryDB
Der `AWS/MemoryDB`-Namespace enthält die folgenden Metriken.
Mit Ausnahme von`ReplicationLag`, `EngineCPUUtilization` `SuccessfulWriteRequestLatency``SuccessfulReadRequestLatency`, und werden diese Metriken aus den OSS-Befehlen Valkey und Redis abgeleitet. **info** Jede Metrik wird auf Knotenebene berechnet.
Eine vollständige Dokumentation des **INFO** Befehls finden Sie unter [INFO](http://valkey.io/commands/info).
**Weitere Informationen finden Sie auch unter:**
+ [Metriken auf Host-Ebene](metrics.HostLevel.md)
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/memorydb/latest/devguide/metrics.memorydb.html)
Im Folgenden finden Sie Zusammenfassungen bestimmter Befehle, die von **info commandstats** abgeleitet sind. Der Abschnitt commandstats enthält Statistiken, die auf dem Befehlstyp basieren, einschließlich der Anzahl der Aufrufe.
Eine vollständige Liste der verfügbaren Befehle finden Sie unter [Befehle](https://valkey.io/commands).
| Metrik | Beschreibung | Einheit |
| --- | --- | --- |
| EvalBasedCmds | Die Gesamtzahl der Befehle für EVAL-basierte Befehle. Dies wird aus der commandstats Statistik durch Summierung eval und abgeleitet. evalsha | Anzahl |
| GeoSpatialBasedCmds | Die Gesamtzahl der Befehle für raumbezogene Befehle. Dies wird aus der commandstats Statistik abgeleitet. Es wird abgeleitet, indem alle Befehle des Geo-Typs summiert werden:geoadd, geodist, geohash, geopos, georadius und georadiusbymember. | Anzahl |
| GetTypeCmds | Gesamtanzahl der auf read-only basierenden Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle read-only Typbefehle (get,, hget scardlrange, usw.) summiert werden. | Anzahl |
| HashBasedCmds | Gesamtanzahl der Hash-basierten Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehle summiert werden, die auf einen oder mehrere Hashes (hget,, hkeys hvalshdel, usw.) einwirken. | Anzahl |
| HyperLogLogBasedCmds | Gesamtanzahl der auf HyperLogLog basierenden Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehlstypen (pfadd, pfcountpfmerge, usw.) summiert werden. pf | Anzahl |
| JsonBasedCmds | Die Gesamtanzahl der JSON-basierten Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehle summiert werden, die sich auf ein oder mehrere JSON-Dokumentobjekte auswirken. | Anzahl |
| KeyBasedCmds | Gesamtanzahl der schlüsselbasierten Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehle summiert werden, die sich auf einen oder mehrere Schlüssel in mehreren Datenstrukturen auswirken (del, expirerename, usw.). | Anzahl |
| ListBasedCmds | Gesamtanzahl der listenbasierten Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehle summiert werden, die sich auf eine oder mehrere Listen auswirken (lindex,, lrange lpushltrim, usw.). | Anzahl |
| PubSubBasedCmds | Die Gesamtzahl der Befehle für pub/sub die Funktionalität. Dies wird aus den commandstats Statistiken abgeleitet, indem alle für die pub/sub Funktionalität verwendeten Befehle summiert werden:psubscribe,publish,pubsub, punsubscribesubscribe, undunsubscribe. | Anzahl |
| SearchBasedCmds | Die Gesamtzahl der sekundären Index- und Suchbefehle, einschließlich Lese- und Schreibbefehlen. Dies wird aus der commandstats Statistik abgeleitet, indem alle Suchbefehle summiert werden, die sich auf sekundäre Indizes auswirken. | Anzahl |
| SearchBasedGetCmds | Gesamtzahl der Befehle für den sekundären Index und die schreibgeschützte Suche. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehle für sekundäre Indizes und Suchabfragen summiert werden. | Anzahl |
| SearchBasedSetCmds | Gesamtzahl der sekundären Index- und Suchbefehle zum Schreiben. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehle für den sekundären Index und die Suchgruppe summiert werden. | Anzahl |
| SearchNumberOfIndexes | Gesamtzahl der Indizes. | Anzahl |
| SearchNumberOfIndexedKeys | Gesamtzahl der indizierten Schlüssel | Anzahl |
| SearchTotalIndexSize | Speicher (Byte), der von allen Indizes verwendet wird. | Bytes |
| SetBasedCmds | Gesamtanzahl der Set-basierten Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehle summiert werden, die auf einen oder mehrere Sätze (scard,, sdiff saddsunion, usw.) einwirken. | Anzahl |
| SetTypeCmds | Gesamtanzahl der auf write basierenden Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle mutative Befehlstypen summiert werden, die mit Daten arbeiten (set,hset, saddlpop, usw.) | Anzahl |
| SortedSetBasedCmds | Gesamtanzahl der Sorted Set-basierten Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehle summiert werden, die sich auf eine oder mehrere sortierte Sätze (zcount,, zrange zrankzadd, usw.) auswirken. | Anzahl |
| StringBasedCmds | Gesamtanzahl der Zeichenfolge-basierten Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehle summiert werden, die sich auf eine oder mehrere Zeichenketten (strlen, setexsetrange, usw.) auswirken. | Anzahl |
| StreamBasedCmds | Die Gesamtanzahl Stream-basierter Befehle. Dies wird aus der commandstats Statistik abgeleitet, indem alle Befehle summiert werden, die sich auf einen oder mehrere Stream-Datentypen (xrange,, xlen xaddxdel, usw.) auswirken. | Anzahl |
# Welche Metriken sollte ich überwachen?
Die folgenden CloudWatch Metriken bieten einen guten Einblick in die Leistung von MemoryDB. In den meisten Fällen empfehlen wir, CloudWatch Alarme für diese Metriken einzurichten, damit Sie Korrekturmaßnahmen ergreifen können, bevor Leistungsprobleme auftreten.
**Topics**
+ [
## CPUUtilization
](#metrics-cpu-utilization)
+ [
## Motor CPUUtilization
](#metrics-engine-cpu-utilization)
+ [
## SwapUsage
](#metrics-swap-usage)
+ [
## Evictions
](#metrics-evictions)
+ [
## CurrConnections
](#metrics-curr-connections)
+ [
## Arbeitsspeicher
](#metrics-memory)
+ [
## Netzwerk
](#metrics-network)
+ [
## Latency
](#metrics-latency)
+ [
## Replikation
](#metrics-replication)
## CPUUtilization
Diese Metrik auf Hostebene wird in Prozent angegeben. Weitere Informationen finden Sie unter [Metriken auf Host-Ebene](metrics.HostLevel.md).
Verwenden Sie bei kleineren Knotentypen mit 2 V CPUs oder weniger die `CPUUtilization ` Metrik, um Ihre Arbeitslast zu überwachen.
Generell empfehlen wir, den Schwellenwert auf 90 % der verfügbaren CPU-Kapazität festzulegen. Da Valkey und Redis OSS Single-Threading verwenden, sollte der tatsächliche Schwellenwert als Bruchteil der Gesamtkapazität des Knotens berechnet werden. Angenommen, Sie verwenden einen Knotentyp mit zwei Kernen. In diesem Fall CPUUtilization wäre der Schwellenwert für 90/2 oder 45%. Informationen zur Anzahl der Kerne (vCPUs) Ihres Knotentyps finden Sie unter [MemoryDB-Preise](https://aws.amazon.com/memorydb/pricing/?p=ps).
Sie müssen Ihren eigenen Schwellenwert festlegen, der auf der Anzahl der Kerne in dem Knoten basiert, den Sie verwenden. Wenn Sie diesen Schwellenwert überschreiten und Ihre Hauptlast aus Leseanfragen besteht, skalieren Sie Ihren Cluster, indem Sie Read Replicas hinzufügen. Wenn die Hauptlast aus Schreibanforderungen besteht, empfehlen wir Ihnen, mehr Shards hinzuzufügen, um die Schreiblast auf mehr Primärknoten zu verteilen.
**Tipp**
Anstatt die Metrik auf Host-Ebene zu verwenden`CPUUtilization`, können Sie möglicherweise die Metrik verwenden`EngineCPUUtilization`, die den Prozentsatz der Nutzung auf dem Valkey- oder Redis-OSS-Engine-Kern meldet. [Um zu sehen, ob diese Metrik auf Ihren Knoten verfügbar ist, und weitere Informationen finden Sie unter Metriken für MemoryDB.](https://docs.aws.amazon.com/memorydb/latest/devguide/metrics.memorydb.html)
Für größere Knotentypen mit 4 V CPUs oder mehr können Sie die `EngineCPUUtilization` Metrik verwenden, die den Prozentsatz der Nutzung auf dem Valkey- oder Redis OSS-Engine-Kern angibt. Um zu sehen, ob diese Metrik auf Ihren Knoten verfügbar ist, und weitere Informationen finden Sie unter [Metriken](https://docs.aws.amazon.com/memorydb/latest/devguide/metrics.memorydb.html) für MemoryDB.
## Motor CPUUtilization
Für größere Knotentypen mit 4 V CPUs oder mehr können Sie die `EngineCPUUtilization` Metrik verwenden, die den Prozentsatz der Nutzung auf dem Valkey- oder Redis OSS-Engine-Kern angibt. Um zu sehen, ob diese Metrik auf Ihren Knoten verfügbar ist, und weitere Informationen finden Sie unter [Metriken](https://docs.aws.amazon.com/memorydb/latest/devguide/metrics.memorydb.html) für MemoryDB.
## SwapUsage
Diese Metrik auf Hostebene wird in Bytes angegeben. Weitere Informationen finden Sie unter [Metriken auf Host-Ebene](metrics.HostLevel.md).
Wenn entweder die `FreeableMemory` CloudWatch Metrik nahe 0 ist (d. h. unter 100 MB) oder die `SwapUsage` Metrik größer als die `FreeableMemory` Metrik ist, dann könnte ein Knoten unter Speicherdruck stehen.
## Evictions
Dies ist eine Motormetrik. Wir empfehlen Ihnen, einen eigenen Grenzwert für diese Metrik basierend auf den Anforderungen Ihrer Anwendung zu bestimmen.
## CurrConnections
Dies ist eine Motormetrik. Wir empfehlen Ihnen, einen eigenen Grenzwert für diese Metrik basierend auf den Anforderungen Ihrer Anwendung zu bestimmen.
Eine zunehmende Anzahl von *CurrConnections*kann auf ein Problem mit Ihrer Anwendung hinweisen. Um dieses Problem zu beheben, müssen Sie das Verhalten der Anwendung untersuchen.
## Arbeitsspeicher
Speicher ist ein Kernaspekt von Valkey und von Redis OSS. Es ist notwendig, die Speicherauslastung Ihres Clusters zu verstehen, um Datenverluste zu vermeiden und das zukünftige Wachstum Ihres Datasets berücksichtigen zu können. Statistiken über die Speicherauslastung eines Knotens sind im Speicherbereich des [INFO-Befehls](https://valkey.io/commands/info) verfügbar.
## Netzwerk
Einer der entscheidenden Faktoren für die Kapazität der Netzwerkbandbreite Ihres Clusters ist der von Ihnen ausgewählte Knotentyp. Weitere Informationen zur Netzwerkkapazität Ihres Nodes finden Sie unter [Amazon MemoryDB-Preise](https://aws.amazon.com/memorydb/pricing/).
## Latency
Die Latenzmetriken `SuccessfulWriteRequestLatency` und `SuccessfulReadRequestLatency` messen die Gesamtzeit, die MemoryDB für die Valkey-Engine benötigt, um auf eine Anfrage zu antworten.
**Anmerkung**
Überhöhte Werte für `SuccessfulWriteRequestLatency` und `SuccessfulReadRequestLatency` Metriken können auftreten, wenn Valkey-Pipelining verwendet wird und CLIENT REPLY auf dem Valkey-Client aktiviert ist. Valkey-Pipelining ist eine Technik zur Leistungssteigerung, indem mehrere Befehle gleichzeitig ausgegeben werden, ohne auf die Antwort auf jeden einzelnen Befehl warten zu müssen. [Um überhöhte Werte zu vermeiden, empfehlen wir, Ihren Redis-Client so zu konfigurieren, dass er Befehle weiterleitet, wenn CLIENT REPLY OFF ist.](https://valkey.io/commands/client-reply/)
## Replikation
Das Datenvolumen, das repliziert wird, ist über die `ReplicationBytes`-Metrik ersehbar. Sie können den Durchsatz der Replikationskapazität `MaxReplicationThroughput` anhand der Replikationskapazität überwachen. Es wird empfohlen, weitere Shards hinzuzufügen, wenn der maximale Durchsatz für die Replikationskapazität erreicht ist.
`ReplicationDelayedWriteCommands`kann auch angeben, ob die Arbeitslast den maximalen Durchsatz der Replikationskapazität überschreitet. Weitere Informationen zur Replikation in MemoryDB finden Sie unter [Grundlegendes](https://docs.aws.amazon.com/memorydb/latest/devguide/replication.html) zur MemoryDB-Replikation
# Auswählen von Metrikstatistiken und -zeiträumen
Es ermöglicht CloudWatch Ihnen zwar, für jede Metrik eine beliebige Statistik und einen beliebigen Zeitraum auszuwählen, aber nicht alle Kombinationen sind sinnvoll. Beispielsweise CPUUtilization sind die Statistiken Durchschnitt, Minimum und Maximum für nützlich, die Summenstatistik jedoch nicht.
Alle MemoryDB-Samples werden für einen Zeitraum von 60 Sekunden für jeden einzelnen Knoten veröffentlicht. Für jeden Zeitraum von 60 Sekunden enthält eine Knotenmetrik nur eine einzige Stichprobe.
# CloudWatch Metriken überwachen
MemoryDB und CloudWatch sind integriert, sodass Sie eine Vielzahl von Metriken sammeln können. Sie können diese Metriken überwachen mit. CloudWatch
**Anmerkung**
Für die folgenden Beispiele sind die CloudWatch Befehlszeilentools erforderlich. Weitere Informationen zu den Entwicklertools CloudWatch und zum Herunterladen finden Sie auf der [ CloudWatch Produktseite](https://aws.amazon.com/cloudwatch).
Die folgenden Verfahren zeigen Ihnen, wie Sie Speicherplatzstatistiken für einen Cluster für die letzte Stunde sammeln können. CloudWatch
**Anmerkung**
Die in den folgenden Beispielen angegebenen `EndTime` Werte `StartTime` und dienen der Veranschaulichung. Stellen Sie sicher, dass Sie Ihre Knoten durch geeignete Start- und Endzeitwerte ersetzen.
Informationen zu MemoryDB-Grenzwerten finden Sie unter [AWS Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_memorydb) for MemoryDB.
## Metriken überwachen CloudWatch (Konsole)
**Um Statistiken zur CPU-Auslastung für einen Cluster zu sammeln**
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 die Knoten aus, für die Sie Metriken anzeigen möchten.
**Anmerkung**
Bei der Auswahl von mehr als 20 Knoten wird die Ansicht von Metriken auf der Konsole deaktiviert.
1. Klicken Sie auf der Seite **Cluster** der AWS Management Console auf den Namen eines oder mehrerer Cluster.
Die Detailseite für den Cluster wird angezeigt.
1. Klicken Sie oben im Fenster auf die Registerkarte **Nodes**.
1. Wählen Sie auf der Registerkarte **Knoten** des Detailfensters die Knoten aus, für die Sie Metriken anzeigen möchten.
Eine Liste der verfügbaren CloudWatch Metriken wird unten im Konsolenfenster angezeigt.
1. Klicken Sie auf die Metrik **CPU Utilization**.
Die CloudWatch Konsole wird geöffnet und zeigt Ihre ausgewählten Metriken an. Sie können die Dropdown-Listenfelder **Statistic** und **Period** und die Registerkarte **Time Range** verwenden, um die angezeigten Metriken zu ändern.
## CloudWatch Metriken mit der CloudWatch CLI überwachen
**Um Statistiken zur CPU-Auslastung für einen Cluster zu sammeln**
+ Verwenden Sie den CloudWatch Befehl **aws cloudwatch get-metric-statistics** mit den folgenden Parametern (beachten Sie, dass die Start- und Endzeiten nur als Beispiele angezeigt werden; Sie müssen Ihre eigenen entsprechenden Start- und Endzeiten ersetzen):
Für Linux, macOS oder Unix:
```
1. aws cloudwatch get-metric-statistics CPUUtilization \
2. --dimensions=ClusterName=mycluster,NodeId=0002" \
3. --statistics=Average \
4. --namespace="AWS/MemoryDB" \
5. --start-time 2013-07-05T00:00:00 \
6. --end-time 2013-07-06T00:00:00 \
7. --period=60
```
Für Windows:
```
1. mon-get-stats CPUUtilization ^
2. --dimensions=ClusterName=mycluster,NodeId=0002" ^
3. --statistics=Average ^
4. --namespace="AWS/MemoryDB" ^
5. --start-time 2013-07-05T00:00:00 ^
6. --end-time 2013-07-06T00:00:00 ^
7. --period=60
```
## Überwachung von CloudWatch Metriken mithilfe der CloudWatch API
**Um Statistiken zur CPU-Auslastung für einen Cluster zu sammeln**
+ Rufen Sie die CloudWatch API `GetMetricStatistics` mit den folgenden Parametern auf (beachten Sie, dass die Start- und Endzeiten nur als Beispiele angezeigt werden; Sie müssen Ihre eigenen entsprechenden Start- und Endzeiten ersetzen):
+ `Statistics.member.1``=Average`
+ `Namespace``=AWS/MemoryDB`
+ `StartTime``=2013-07-05T00:00:00`
+ `EndTime``=2013-07-06T00:00:00`
+ `Period``=60`
+ `MeasureName``=CPUUtilization`
+ `Dimensions``=ClusterName=mycluster,NodeId=0002`
**Example**
```
1. http://monitoring.amazonaws.com/
2. ?SignatureVersion=4
3. &Action=GetMetricStatistics
4. &Version=2014-12-01
5. &StartTime=2013-07-16T00:00:00
6. &EndTime=2013-07-16T00:02:00
7. &Period=60
8. &Statistics.member.1=Average
9. &Dimensions.member.1="ClusterName=mycluster"
10. &Dimensions.member.2="NodeId=0002"
11. &Namespace=Amazon/memorydb
12. &MeasureName=CPUUtilization
13. &Timestamp=2013-07-07T17%3A48%3A21.746Z
14. &AWS;AccessKeyId=<&AWS; Access Key ID>
15. &Signature=
```
# Überwachung von MemoryDB-Ereignissen
Wenn für einen Cluster wichtige Ereignisse eintreten, sendet MemoryDB eine Benachrichtigung an ein bestimmtes Amazon SNS SNS-Thema. Zu den wichtigen Ereignissen zählen beispielsweise das fehlgeschlagene Hinzufügen eines Knotens, das erfolgreiche Hinzufügen eines Knotens und die Änderung einer Sicherheitsgruppe. Durch die Überwachung wichtiger Schlüsselereignisse können Sie den aktuellen Status Ihrer Cluster erfahren und, je nach Ereignis, Korrekturen vornehmen.
**Topics**
+ [
# MemoryDB Amazon SNS SNS-Benachrichtigungen verwalten
](mdbevents.sns.md)
+ [
# MemoryDB-Ereignisse anzeigen
](mdbevents.viewing.md)
+ [
# Ereignisbenachrichtigungen und Amazon SNS
](memorydbsns.md)
# MemoryDB Amazon SNS SNS-Benachrichtigungen verwalten
Mit Amazon Simple Notification Service (Amazon SNS) können Sie MemoryDB so konfigurieren, dass Benachrichtigungen für wichtige Cluster-Ereignisse gesendet werden. In diesen Beispielen konfigurieren Sie einen Cluster mit dem Amazon-Ressourcenname (ARN) eines Amazon-SNS-Themas, um Benachrichtigungen zu erhalten.
**Anmerkung**
In diesem Thema wird davon ausgegangen, dass Sie sich bei Amazon SNS angemeldet und ein Amazon-SNS-Thema eingerichtet und abonniert haben. Informationen dazu finden Sie im [Entwicklerhandbuch zu Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/).
## Hinzufügen eines Amazon-SNS-Themas
In den folgenden Abschnitten erfahren Sie, wie Sie mithilfe der AWS Konsole, der oder der MemoryDB-API ein Amazon SNS SNS-Thema hinzufügen. AWS CLI
### Hinzufügen eines Amazon-SNS-Themas (Konsole)
Das folgende Verfahren zeigt Ihnen, wie Sie ein Amazon-SNS-Thema für einen Cluster hinzufügen.
**Anmerkung**
Diese Vorgehensweise kann auch zum Ändern des Amazon-SNS-Themas verwendet werden.
**So fügen Sie ein Amazon-SNS-Thema für einen Cluster hinzu oder ändern es (Konsole)**
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 unter **Cluster** den Cluster aus, für den Sie einen Amazon-SNS-Thema-ARN hinzufügen oder ändern möchten.
1. Wählen Sie **Ändern** aus.
1. Wählen Sie im Feld **Modify Cluster (Cluster ändern)** unter **Topic for SNS Notification** (Thema für SNS-Benachrichtigung)** das SNS-Thema aus, das Sie hinzufügen möchten, oder wählen Sie **Manual ARN input (Manuelle ARN-Eingabe) aus und geben Sie den ARN des Amazon-SNS-Themas ein.
1. Wählen Sie **Ändern** aus.
### Hinzufügen eines Amazon SNS SNS-Themas (AWS CLI)
Verwenden Sie den AWS CLI Befehl`update-cluster`, um ein Amazon SNS SNS-Thema für einen Cluster hinzuzufügen oder zu ändern.
Das folgende Codebeispiel fügt einen Amazon-SNS-Themen-ARN zu *my-cluster* hinzu.
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--sns-topic-arn arn:aws:sns:us-east-1:565419523791:memorydbNotifications
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--sns-topic-arn arn:aws:sns:us-east-1:565419523791:memorydbNotifications
```
Weitere Informationen finden Sie unter [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
### Hinzufügen eines Amazon SNS SNS-Themas (MemoryDB-API)
Um ein Amazon SNS SNS-Thema für einen Cluster hinzuzufügen oder zu aktualisieren, rufen Sie die `UpdateCluster` Aktion mit den folgenden Parametern auf:
+ `ClusterName``=my-cluster`
+ `SnsTopicArn``=arn%3Aaws%3Asns%3Aus-east-1%3A565419523791%3AmemorydbNotifications`
Um ein Amazon SNS SNS-Thema für einen Cluster hinzuzufügen oder zu aktualisieren, rufen Sie die `UpdateCluster` Aktion auf.
Weitere Informationen finden Sie unter [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
## Aktivieren und Deaktivieren von Amazon-SNS-Benachrichtigungen
Sie können Benachrichtigungen für einen Cluster aktivieren oder deaktivieren. Das folgende Verfahren zeigt, wie Sie Amazon-SNS-Benachrichtigungen deaktivieren.
### Aktivieren und Deaktivieren von Amazon-SNS-Benachrichtigungen (Konsole)
**Um Amazon SNS SNS-Benachrichtigungen zu deaktivieren, verwenden Sie den AWS-Managementkonsole**
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 das Optionsfeld links neben dem Cluster aus, für den Sie die Benachrichtigung ändern möchten.
1. Wählen Sie **Ändern** aus.
1. Wählen Sie im Feld **Modify Cluster** unter **Topic for SNS Notification** die Option *Disable Notifications* aus.
1. Wählen Sie **Ändern** aus.
### Amazon SNS SNS-Benachrichtigungen (AWS CLI) aktivieren und deaktivieren
Verwenden Sie zum Deaktivieren von Amazon-SNS-Benachrichtigungen den Befehl `update-cluster` mit folgenden Parametern:
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--sns-topic-status inactive
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--sns-topic-status inactive
```
### Amazon SNS SNS-Benachrichtigungen aktivieren und deaktivieren (MemoryDB-API)
Rufen Sie zum Deaktivieren von Amazon-SNS-Benachrichtigungen die `UpdateCluster`-Aktion mit folgenden Parametern auf:
+ `ClusterName``=my-cluster`
+ `SnsTopicStatus``=inactive`
Diese Aktion führt zu folgender oder einer ähnlichen Ausgabe:
**Example**
```
1. https://memory-db.us-east-1.amazonaws.com/
2. ?Action=UpdateCluster
3. &ClusterName=my-cluster
4. &SnsTopicStatus=inactive
5. &Version=2021-01-01
6. &SignatureVersion=4
7. &SignatureMethod=HmacSHA256
8. &Timestamp=20210801T220302Z
9. &X-Amz-Algorithm=Amazon4-HMAC-SHA256
10. &X-Amz-Date=20210801T220302Z
11. &X-Amz-SignedHeaders=Host
12. &X-Amz-Expires=20210801T220302Z
13. &X-Amz-Credential=
14. &X-Amz-Signature=
```
# MemoryDB-Ereignisse anzeigen
MemoryDB protokolliert Ereignisse, die sich auf Ihre Cluster, Sicherheitsgruppen und Parametergruppen beziehen. Diese Informationen beinhalten Datum und Zeit eines Ereignisses, den Quellnamen und Quelltyp sowie eine Beschreibung des Ereignisses. Sie können Ereignisse einfach mit der MemoryDB-Konsole, dem AWS CLI `describe-events` Befehl oder der MemoryDB-API-Aktion aus dem Protokoll abrufen. `DescribeEvents`
Die folgenden Verfahren zeigen Ihnen, wie Sie alle MemoryDB-Ereignisse der letzten 24 Stunden (1440 Minuten) anzeigen können.
## MemoryDB-Ereignisse anzeigen (Konsole)
Das folgende Verfahren zeigt Ereignisse mithilfe der MemoryDB-Konsole an.
**Um Ereignisse mit der MemoryDB-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 Ereignisse aus.**
Der Bildschirm „*Ereignisse*“ wird angezeigt und listet alle verfügbaren Ereignisse auf. Jede Zeile der Liste steht für ein Ereignis und zeigt die Ereignisquelle, den Ereignistyp (wie Cluster, Parametergruppe, ACL, Sicherheitsgruppe oder Subnetzgruppe), die GMT-Zeit des Ereignisses und die Beschreibung des Ereignisses an.
Mit der Option **Filter** können Sie angeben, ob alle Ereignisse oder nur Ereignisse eines bestimmten Typs in der Ereignisliste enthalten sein sollen.
## MemoryDB-Ereignisse anzeigen (CLI)AWS
Verwenden Sie den Befehl, um mit dem eine Liste von MemoryDB-Ereignissen zu generieren. AWS CLI`describe-events` Mit optionalen Parametern können Sie u. a. den Typ und den Zeitrahmen der aufgelisteten Ereignisse sowie die maximale Anzahl der aufzulistenden Ereignisse steuern.
Der folgende Code listet bis zu 40 Cluster-Ereignisse auf.
```
aws memorydb describe-events --source-type cluster --max-results 40
```
Mit dem folgenden Code werden alle Ereignisse der letzten 24 Stunden (1 440 Minuten) aufgelistet.
```
aws memorydb describe-events --duration 1440
```
Die Ausgabe des Befehls `describe-events` sieht in etwa wie folgt aus:
```
{
"Events": [
{
"Date": "2021-03-29T22:17:37.781Z",
"Message": "Added node 0001 in Availability Zone us-east-1a",
"SourceName": "memorydb01",
"SourceType": "cluster"
},
{
"Date": "2021-03-29T22:17:37.769Z",
"Message": "cluster created",
"SourceName": "memorydb01",
"SourceType": "cluster"
}
]
}
```
Weitere Informationen z. B. zu den verfügbaren Parametern und den zulässigen Parameterwerten finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-events.html](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-events.html).
## MemoryDB-Ereignisse anzeigen (MemoryDB-API)
Verwenden Sie die Aktion, um mithilfe der MemoryDB-API eine Liste von MemoryDB-Ereignissen zu generieren. `DescribeEvents` Mit optionalen Parametern können Sie u. a. den Typ und den Zeitrahmen der aufgelisteten Ereignisse sowie die maximale Anzahl der aufzulistenden Ereignisse steuern.
Der folgende Code listet die 40 neuesten -Cluster-Ereignisse auf.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeEvents
&MaxResults=40
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&SourceType=cluster
&Timestamp=20210802T192317Z
&Version=2021-01-01
&X-Amz-Credential=
```
Der folgende Code listet die Cluster-Ereignisse der letzten 24 Stunden (1440 Minuten) auf.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeEvents
&Duration=1440
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&SourceType=cluster
&Timestamp=20210802T192317Z
&Version=2021-01-01
&X-Amz-Credential=
```
Die Ausgabe der oben angegebenen Aktionen sollte in etwa wie folgt aussehen:
```
cluster created
cluster
2021-08-02T18:22:18.202Z
my-memorydb-primary
(...output omitted...)
e21c81b4-b9cd-11e3-8a16-7978bb24ffdf
```
Weitere Informationen z. B. zu den verfügbaren Parametern und den zulässigen Parameterwerten finden Sie unter [https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeEvents.html](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeEvents.html).
# Ereignisbenachrichtigungen und Amazon SNS
MemoryDB kann Nachrichten mithilfe von Amazon Simple Notification Service (SNS) veröffentlichen, wenn wichtige Ereignisse in einem Cluster auftreten. Diese Funktion kann verwendet werden, um die Serverlisten auf Client-Computern zu aktualisieren, die mit einzelnen Knotenendpunkten eines Clusters verbunden sind.
**Anmerkung**
Weitere Informationen zum Amazon Simple Notification Service (SNS) sowie Informationen zu Preisen und Links zur Amazon-SNS-Dokumentation finden Sie auf der [Produktseite zu Amazon SNS](https://aws.amazon.com/sns).
Benachrichtigungen werden in einem bestimmten Amazon-SNS*-Thema* veröffentlicht. Für Benachrichtigungen müssen folgende Voraussetzungen erfüllt sein:
+ Für MemoryDB-Benachrichtigungen kann nur ein Thema konfiguriert werden.
+ Das AWS Konto, dem das Amazon SNS SNS-Thema gehört, muss dasselbe Konto sein, das den Cluster besitzt, auf dem Benachrichtigungen aktiviert sind.
## MemoryDB-Ereignisse
Die folgenden MemoryDB-Ereignisse lösen Amazon SNS SNS-Benachrichtigungen aus:
| Ereignisname | Fehlermeldung | Beschreibung |
| --- | --- | --- |
| MemoryDB: AddNodeComplete | "Modified number of nodes from %d to %d" | Ein Knoten wurde dem Cluster hinzugefügt und ist einsatzbereit. |
| MemoryDB: AddNodeFailed aufgrund unzureichender freier IP-Adressen | "Failed to modify number of nodes from %d to %d due to insufficient free IP addresses" | Ein Knoten konnte nicht hinzugefügt werden, da nicht genügend IP-Adressen verfügbar sind. |
| Speicher-DB: ClusterParametersChanged | "Updated parameter group for the cluster" Beim Erstellen wird auch `"Updated to use a ParameterGroup %s"` gesendet. | Ein oder mehrere Cluster-Parameter wurden geändert. |
| MemoryDB: ClusterProvisioningComplete | "Cluster created." | Die Bereitstellung eines Clusters ist abgeschlossen und die Knoten im Cluster sind einsatzbereit. |
| MemoryDB: ClusterProvisioningFailed aufgrund eines inkompatiblen Netzwerkstatus | "Failed to create cluster due to incompatible network state. %s" | Es wurde versucht, einen neuen Cluster in einer nicht existierenden Virtual Private Cloud (VPC) zu starten. |
| Speicher-DB: ClusterRestoreFailed | "Restore from %s failed for node %s. %s" | MemoryDB konnte den Cluster nicht mit Snapshot-Daten füllen. Dies könnte an einer nicht vorhandenen Snapshot-Datei in Amazon S3 oder an falschen Berechtigungen für diese Datei liegen. Wenn Sie den Cluster beschreiben, lautet der Status. `restore-failed` Sie müssen den Cluster löschen und von vorne beginnen. Weitere Informationen finden Sie unter [Einen neuen Cluster mit einem extern erstellten Snapshot erstellen](snapshots-seeding-redis.md). |
| Speicher-DB: ClusterScalingComplete | `"Succeeded applying modification to node type to %s."` | Die Skalierung für den Cluster wurde erfolgreich abgeschlossen. |
| Speicher-DB: ClusterScalingFailed | `"Failed applying modification to node type to %s."` | Der Scale-Up-Vorgang auf dem Cluster ist fehlgeschlagen. |
| Speicher-DB: NodeReplaceStarted | "Recovering node %s" | MemoryDB hat festgestellt, dass der Host, auf dem ein Knoten läuft, heruntergefahren oder nicht erreichbar ist, und hat begonnen, den Knoten zu ersetzen. Der DNS-Eintrag für den ersetzten Knoten wurde nicht geändert. In den meisten Fällen müssen Sie die Serverliste für die Clients nicht aktualisieren, wenn dieses Ereignis auftritt. Einige Clientbibliotheken verwenden den Knoten möglicherweise auch dann nicht mehr, wenn MemoryDB den Knoten ersetzt hat. In diesem Fall sollte die Anwendung die Serverliste aktualisieren, wenn dieses Ereignis eintritt. |
| MemoryDB: NodeReplaceComplete | "Finished recovery for node %s" | MemoryDB hat festgestellt, dass der Host, auf dem ein Knoten ausgeführt wird, heruntergefahren oder nicht erreichbar ist, und hat den Austausch des Knotens abgeschlossen. Der DNS-Eintrag für den ersetzten Knoten wurde nicht geändert. In den meisten Fällen müssen Sie die Serverliste für die Clients nicht aktualisieren, wenn dieses Ereignis auftritt. Einige Clientbibliotheken verwenden den Knoten möglicherweise auch dann nicht mehr, wenn MemoryDB den Knoten ersetzt hat. In diesem Fall sollte die Anwendung die Serverliste aktualisieren, wenn dieses Ereignis eintritt. |
| MemoryDB: CreateClusterComplete | "Cluster created" | Der Cluster wurde erfolgreich erstellt. |
| Memory-DB: CreateClusterFailed | "Failed to create cluster due to unsuccessful creation of its node(s)." und "Deleting all nodes belonging to this cluster." | Der Cluster wurde nicht erstellt. |
| Speicher-DB: DeleteClusterComplete | "Cluster deleted." | Das Löschen eines Clusters und aller zugehörigen Knoten ist abgeschlossen. |
| MemoryDB: FailoverComplete | `"Failover to replica node %s completed"` | Failover zu einem Replikationsknoten wurde erfolgreich abgeschlossen. |
| Speicher-DB: NodeReplacementCanceled | "The replacement of node %s which was scheduled during the maintenance window from start time: %s, end time: %s has been canceled" | Ein Knoten in Ihrem Cluster, der ersetzt werden sollte, soll nicht länger ersetzt werden. |
| Speicher-DB: NodeReplacementRescheduled | "The replacement in maintenance window for node %s has been re-scheduled from previous start time: %s, previous end time: %s to new start time: %s, new end time: %s" | Für einen zu ersetzenden Knoten in Ihrem Cluster wurde eine spätere Ersetzung im neuen Fenster geplant, das in der Benachrichtigung angegeben wurde. Weitere Informationen zu den möglichen Aktionen erhalten Sie unter [Ersetzen von Knoten](nodes.nodereplacement.md). |
| Speicher-DB: NodeReplacementScheduled | "The node %s is scheduled for replacement during the maintenance window from start time: %s to end time: %s" | Ein Knoten in Ihrem Cluster soll während des in der Benachrichtigung beschriebenen Fensters ersetzt werden. Weitere Informationen zu den möglichen Aktionen erhalten Sie unter [Ersetzen von Knoten](nodes.nodereplacement.md). |
| Speicher-DB: RemoveNodeComplete | "Removed node %s" | Ein Knoten wurde aus dem Cluster entfernt. |
| Speicher-DB: SnapshotComplete | "Snapshot %s succeeded for node %s" | Ein Snapshot wurde erfolgreich abgeschlossen. |
| Memory-DB: SnapshotFailed | "Snapshot %s failed for node %s" | Ein Snapshot ist fehlgeschlagen. Eine detailliertere Ursache finden Sie in den Ereignissen des Clusters. Wenn Sie den Snapshot beschreiben (siehe [DescribeSnapshots](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeSnapshots.html)), ist dessen Status `failed`. |
# MemoryDB-API-Aufrufe protokollieren mit AWS CloudTrail
MemoryDB ist in einen Dienst integriert AWS CloudTrail, der eine Aufzeichnung der Aktionen bereitstellt, die von einem Benutzer, einer Rolle oder einem AWS Dienst in MemoryDB ausgeführt wurden. CloudTrail erfasst alle API-Aufrufe für MemoryDB als Ereignisse, einschließlich Aufrufe von der MemoryDB-Konsole und von Codeaufrufen an die MemoryDB-API-Operationen. Wenn Sie einen Trail erstellen, können Sie die kontinuierliche Bereitstellung von CloudTrail Ereignissen an einen Amazon S3 S3-Bucket aktivieren, einschließlich Ereignissen für MemoryDB. Wenn Sie keinen Trail konfigurieren, können Sie die neuesten Ereignisse trotzdem in der CloudTrail Konsole im **Ereignisverlauf** anzeigen. Anhand der von CloudTrail gesammelten Informationen können Sie die Anfrage an MemoryDB, die IP-Adresse, von der aus die Anfrage gestellt wurde, wer die Anfrage gestellt hat, wann sie gestellt wurde, und weitere Details ermitteln.
Weitere Informationen CloudTrail dazu finden Sie im [AWS CloudTrail Benutzerhandbuch](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
## MemoryDB-Informationen in CloudTrail
CloudTrail ist in Ihrem AWS Konto aktiviert, wenn Sie das Konto erstellen. Wenn eine Aktivität in MemoryDB auftritt, wird diese Aktivität zusammen mit anderen AWS Dienstereignissen im CloudTrail Ereignisverlauf in einem **Ereignis** aufgezeichnet. Sie können aktuelle Ereignisse in Ihrem AWS Konto anzeigen, suchen und herunterladen. Weitere Informationen finden Sie unter [Ereignisse mit CloudTrail Ereignisverlauf anzeigen](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).
Für eine fortlaufende Aufzeichnung der Ereignisse in Ihrem AWS Konto, einschließlich Ereignissen für MemoryDB, erstellen Sie einen Trail. Ein Trail ermöglicht CloudTrail die Übermittlung von Protokolldateien an einen Amazon S3 S3-Bucket. Wenn Sie einen Trail in der Konsole anlegen, gilt dieser standardmäßig für alle Regionen. Der Trail protokolliert Ereignisse aus allen Regionen der AWS Partition und übermittelt die Protokolldateien an den von Ihnen angegebenen Amazon S3 S3-Bucket. Darüber hinaus können Sie andere AWS Dienste konfigurieren, um die in den CloudTrail Protokollen gesammelten Ereignisdaten weiter zu analysieren und darauf zu reagieren. Weitere Informationen finden Sie hier:
+ [Übersicht zum Erstellen eines Trails](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail Unterstützte Dienste und Integrationen](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Konfiguration von Amazon SNS SNS-Benachrichtigungen für CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Empfangen von CloudTrail Protokolldateien aus mehreren Regionen](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) und [Empfangen von CloudTrail Protokolldateien von mehreren Konten](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
Alle MemoryDB-Aktionen werden von protokolliert. CloudTrail Beispielsweise generieren Aufrufe von `DescribeClusters` und `UpdateCluster` Aktionen Einträge in den CloudTrail Protokolldateien. `CreateCluster`
Jeder Ereignis- oder Protokolleintrag enthält Informationen zu dem Benutzer, der die Anforderung generiert hat. Die Identitätsinformationen unterstützen Sie bei der Ermittlung der folgenden Punkte:
+ Gibt an, ob die Anforderung mit Root- oder IAM-Benutzer-Anmeldeinformationen ausgeführt wurde.
+ Gibt an, ob die Anforderung mit temporären Sicherheitsanmeldeinformationen für eine Rolle oder einen Verbundbenutzer gesendet wurde.
+ Ob die Anfrage von einem anderen AWS Dienst gestellt wurde.
Weitere Informationen finden Sie unter [CloudTrail userIdentity-Element](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
## Grundlegendes zu MemoryDB-Protokolldateieinträgen
Ein Trail ist eine Konfiguration, die die Übertragung von Ereignissen als Protokolldateien an einen von Ihnen angegebenen Amazon S3 S3-Bucket ermöglicht. CloudTrail Protokolldateien enthalten einen oder mehrere Protokolleinträge. Ein Ereignis stellt eine einzelne Anforderung aus einer beliebigen Quelle dar und enthält Informationen über die angeforderte Aktion, Datum und Uhrzeit der Aktion, Anforderungsparameter usw. CloudTrail Protokolldateien sind kein geordneter Stack-Trace der öffentlichen API-Aufrufe, sodass sie nicht in einer bestimmten Reihenfolge angezeigt werden.
Das folgende Beispiel zeigt einen CloudTrail Protokolleintrag, der die `CreateCluster` Aktion demonstriert.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "IAMUser",
"principalId": "EKIAUAXQT3SWDEXAMPLE",
"arn": "arn:aws:iam::123456789012:user/john",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "john"
},
"eventTime": "2021-07-10T17:56:46Z",
"eventSource": "memorydb.amazonaws.com",
"eventName": "CreateCluster",
"awsRegion": "us-east-1",
"sourceIPAddress": "192.0.2.01",
"userAgent": "aws-cli/2.2.29 Python/3.9.6 Darwin/19.6.0 source/x86_64 prompt/off command/memorydb.create-cluster",
"requestParameters": {
"clusterName": "memorydb-cluster",
"nodeType": "db.r6g.large",
"subnetGroupName": "memorydb-subnet-group",
"aCLName": "open-access"
},
"responseElements": {
"cluster": {
"name": "memorydb-cluster",
"status": "creating",
"numberOfShards": 1,
"availabilityMode": "MultiAZ",
"clusterEndpoint": {
"port": 6379
},
"nodeType": "db.r6g.large",
"engineVersion": "6.2",
"enginePatchVersion": "6.2.6",
"parameterGroupName": "default.memorydb-redis6",
"parameterGroupStatus": "in-sync",
"subnetGroupName": "memorydb-subnet-group",
"tLSEnabled": true,
"aRN": "arn:aws:memorydb:us-east-1:123456789012:cluster/memorydb-cluster",
"snapshotRetentionLimit": 0,
"maintenanceWindow": "tue:06:30-tue:07:30",
"snapshotWindow": "09:00-10:00",
"aCLName": "open-access",
"dataTiering": "false",
"autoMinorVersionUpgrade": true
}
},
"requestID": "506fc951-9ae2-42bb-872c-98028dc8ed11",
"eventID": "2ecf3dc3-c931-4df0-a2b3-be90b596697e",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management"
}
```
Das folgende Beispiel zeigt einen CloudTrail Protokolleintrag, der die `DescribeClusters` Aktion demonstriert. Beachten Sie, dass bei allen MemoryDB-Aufrufen Describe und List (`Describe*`und`List*`) der `responseElements` Abschnitt entfernt wird und als angezeigt wird. `null`
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "IAMUser",
"principalId": "EKIAUAXQT3SWDEXAMPLE",
"arn": "arn:aws:iam::123456789012:user/john",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "john"
},
"eventTime": "2021-07-10T18:39:51Z",
"eventSource": "memorydb.amazonaws.com",
"eventName": "DescribeClusters",
"awsRegion": "us-east-1",
"sourceIPAddress": "192.0.2.01",
"userAgent": "aws-cli/2.2.29 Python/3.9.6 Darwin/19.6.0 source/x86_64 prompt/off command/memorydb.describe-clusters",
"requestParameters": {
"maxResults": 50,
"showShardDetails": true
},
"responseElements": null,
"requestID": "5e831993-52bb-494d-9bba-338a117c2389",
"eventID": "32a3dc0a-31c8-4218-b889-1a6310b7dd50",
"readOnly": true,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management"
}
```
Das folgende Beispiel zeigt einen CloudTrail Protokolleintrag, der eine `UpdateCluster` Aktion aufzeichnet.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "IAMUser",
"principalId": "EKIAUAXQT3SWDEXAMPLE",
"arn": "arn:aws:iam::123456789012:user/john",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "john"
},
"eventTime": "2021-07-10T19:23:20Z",
"eventSource": "memorydb.amazonaws.com",
"eventName": "UpdateCluster",
"awsRegion": "us-east-1",
"sourceIPAddress": "192.0.2.01",
"userAgent": "aws-cli/2.2.29 Python/3.9.6 Darwin/19.6.0 source/x86_64 prompt/off command/memorydb.update-cluster",
"requestParameters": {
"clusterName": "memorydb-cluster",
"snapshotWindow": "04:00-05:00",
"shardConfiguration": {
"shardCount": 2
}
},
"responseElements": {
"cluster": {
"name": "memorydb-cluster",
"status": "updating",
"numberOfShards": 2,
"availabilityMode": "MultiAZ",
"clusterEndpoint": {
"address": "clustercfg.memorydb-cluster.cde8da.memorydb.us-east-1.amazonaws.com",
"port": 6379
},
"nodeType": "db.r6g.large",
"engineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"parameterGroupName": "default.memorydb-redis6",
"parameterGroupStatus": "in-sync",
"subnetGroupName": "memorydb-subnet-group",
"tLSEnabled": true,
"aRN": "arn:aws:memorydb:us-east-1:123456789012:cluster/memorydb-cluster",
"snapshotRetentionLimit": 0,
"maintenanceWindow": "tue:06:30-tue:07:30",
"snapshotWindow": "04:00-05:00",
"autoMinorVersionUpgrade": true,
"DataTiering": "false"
}
},
"requestID": "dad021ce-d161-4365-8085-574133afab54",
"eventID": "e0120f85-ab7e-4ad4-ae78-43ba15dee3d8",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management"
}
```
Das folgende Beispiel zeigt einen CloudTrail Protokolleintrag, der die `CreateUser` Aktion demonstriert. Beachten Sie, dass bei MemoryDB-Aufrufen, die vertrauliche Daten enthalten, diese Daten beim entsprechenden CloudTrail Ereignis unkenntlich gemacht werden, wie im `requestParameters` folgenden Abschnitt dargestellt.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "IAMUser",
"principalId": "EKIAUAXQT3SWDEXAMPLE",
"arn": "arn:aws:iam::123456789012:user/john",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "john"
},
"eventTime": "2021-07-10T19:56:13Z",
"eventSource": "memorydb.amazonaws.com",
"eventName": "CreateUser",
"awsRegion": "us-east-1",
"sourceIPAddress": "192.0.2.01",
"userAgent": "aws-cli/2.2.29 Python/3.9.6 Darwin/19.6.0 source/x86_64 prompt/off command/memorydb.create-user",
"requestParameters": {
"userName": "memorydb-user",
"authenticationMode": {
"type": "password",
"passwords": [
"HIDDEN_DUE_TO_SECURITY_REASONS"
]
},
"accessString": "~* &* -@all +@read"
},
"responseElements": {
"user": {
"name": "memorydb-user",
"status": "active",
"accessString": "off ~* &* -@all +@read",
"aCLNames": [],
"minimumEngineVersion": "6.2",
"authentication": {
"type": "password",
"passwordCount": 1
},
"aRN": "arn:aws:memorydb:us-east-1:123456789012:user/memorydb-user"
}
},
"requestID": "ae288b5e-80ab-4ff8-989a-5ee5c67cd193",
"eventID": "ed096e3e-16f1-4a23-866c-0baa6ec769f6",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management"
}
```
# Konformitätsprüfung für MemoryDB
Externe Prüfer bewerten die Sicherheit und Konformität von MemoryDB im Rahmen mehrerer AWS Compliance-Programme. Dies umfasst:
+ Payment Card Industry Data Security Standard (PCI DSS). Weitere Informationen finden Sie unter [PCI DSS](https://aws.amazon.com/compliance/pci-dss-level-1-faqs/).
+ Health Insurance Portability and Accountability Act Business Associate Agreement (HIPAA BAA). Weitere Informationen finden Sie unter [HIPAA-Compliance](https://aws.amazon.com/compliance/hipaa-compliance).
+ System and Organization Controls (SOC) 1, 2 und 3. Weitere Informationen finden Sie unter [SOC](https://aws.amazon.com/compliance/soc-faqs).
+ Moderat des Federal Risk and Authorization Management Program (FedRAMP). Weitere Informationen finden Sie unter [FedRAMP](https://aws.amazon.com/compliance/services-in-scope/FedRAMP/).
+ ISO/IEC 27001:2013, 27017:2015, 27018:2019 und 9001:2015. ISO/IEC [Weitere Informationen finden Sie unter ISO- und CSA STAR-Zertifizierungen und -Services.AWS](https://aws.amazon.com/compliance/iso-certified/)
Eine Liste der AWS Services im Rahmen bestimmter Compliance-Programme finden Sie unter [AWS Services im Umfang nach Compliance-Programmen](https://aws.amazon.com/compliance/services-in-scope/).
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 Verantwortung für die Einhaltung von Vorschriften bei der Verwendung von MemoryDB hängt von der Vertraulichkeit 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.
+ [AWS Ressourcen zur AWS](https://aws.amazon.com/compliance/resources/) von Vorschriften — Diese Sammlung von Arbeitsmappen und Leitfäden kann auf Ihre Branche und Ihren Standort zutreffen.
+ [Evaluieren von Ressourcen mit Regeln](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html) im *AWS Config -Entwicklerhandbuch* – AWS Config bewertet, wie gut Ihre Ressourcenkonfigurationen mit internen Praktiken, Branchenrichtlinien und Vorschriften übereinstimmen.
+ [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 und hilft Ihnen AWS , die Einhaltung der Sicherheitsstandards und bewährten Verfahren der Branche zu überprüfen.
+ [AWS Audit Manager](https://docs.aws.amazon.com/audit-manager/latest/userguide/what-is.html) — Mit diesem AWS Service können Sie Ihre AWS Nutzung kontinuierlich überprüfen, um Ihr Risikomanagement und die Einhaltung von Vorschriften und Industriestandards zu vereinfachen.
# Infrastruktursicherheit in MemoryDB
Als verwalteter Service ist MemoryDB 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 sind.
Sie verwenden AWS veröffentlichte API-Aufrufe, um über das Netzwerk auf MemoryDB zuzugreifen. Clients müssen Transport Layer Security (TLS) 1.2 oder höher unterstützen. Wir empfehlen TLS 1.3 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.
# Richtlinie für den Datenverkehr zwischen Netzwerken
MemoryDB verwendet die folgenden Techniken, um Ihre Daten zu sichern und vor unbefugtem Zugriff zu schützen:
+ **[MemoryDB und Amazon VPC](vpcs.md)**erklärt den Typ der Sicherheitsgruppe, die Sie für Ihre Installation benötigen.
+ **[MemoryDB-API und VPC-Schnittstellen-Endpunkte ()AWS PrivateLink](memorydb-privatelink.md)**ermöglicht es Ihnen, eine private Verbindung zwischen Ihren VPC- und MemoryDB-API-Endpunkten herzustellen.
+ **[Identitäts- und Zugriffsmanagement in MemoryDB](iam.md)**Verwenden Sie zum Erteilen und Beschränken von Aktionen von Benutzern, Gruppen und Rollen.
# MemoryDB und Amazon VPC
Der Amazon Virtual Private Cloud (Amazon VPC)-Service definiert ein virtuelles Netzwerk, das einem herkömmlichen Rechenzentrum sehr ähnlich ist. Wenn Sie eine Virtual Private Cloud (VPC) mit Amazon VPC konfigurieren, können Sie ihren IP-Adressbereich auswählen, Subnetze erstellen und Routentabellen, Netzwerk-Gateways und Sicherheitseinstellungen konfigurieren. Sie können dem virtuellen Netzwerk auch einen Cluster hinzufügen und den Zugriff auf den Cluster mithilfe von Amazon VPC-Sicherheitsgruppen kontrollieren.
In diesem Abschnitt wird erklärt, wie Sie einen MemoryDB-Cluster in einer VPC manuell konfigurieren. Diese Informationen richten sich an Benutzer, die ein tieferes Verständnis der Zusammenarbeit von MemoryDB und Amazon VPC wünschen.
**Topics**
+ [
# MemoryDB verstehen und VPCs
](vpcs.mdb.md)
+ [
# Zugriffsmuster für den Zugriff auf einen MemoryDB-Cluster in einer Amazon VPC
](memorydb-vpc-accessing.md)
+ [
# Erstellen einer Virtual Private Cloud (VPC)
](VPCs.creatingVPC.md)
# MemoryDB verstehen und VPCs
MemoryDB ist vollständig in Amazon VPC integriert. Für MemoryDB-Benutzer bedeutet dies Folgendes:
+ MemoryDB startet Ihren Cluster immer in einer VPC.
+ Wenn Sie noch nicht damit vertraut sind AWS, wird automatisch eine Standard-VPC für Sie erstellt.
+ Wenn Sie eine Standard-VPC haben und beim Starten eines Clusters kein Subnetz angeben, wird der Cluster in Ihrer Standard-Amazon-VPC gestartet.
Weitere Informationen finden Sie unter [Detecting Your Supported Platforms and Whether You Have a Default VPC](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html#detecting-platform).
Mit Amazon VPC können Sie ein virtuelles Netzwerk in der AWS Cloud erstellen, das einem herkömmlichen Rechenzentrum sehr ähnlich ist. Sie können Ihre VPC konfigurieren, einschließlich der Auswahl ihres IP-Adressbereichs, der Erstellung von Subnetzen und der Konfiguration von Routentabellen, Netzwerk-Gateways und Sicherheitseinstellungen.
MemoryDB verwaltet Software-Upgrades, Patches, Fehlererkennung und Wiederherstellung.
## Überblick über MemoryDB in einer VPC
+ Eine VPC ist ein isolierter Teil der AWS Cloud, dem ein eigener Block von IP-Adressen zugewiesen wird.
+ Ein Internet-Gateway verbindet Ihre VPC direkt mit dem Internet und bietet Zugriff auf andere AWS Ressourcen wie Amazon Simple Storage Service (Amazon S3), die außerhalb Ihrer VPC laufen.
+ Ein Amazon VPC-Subnetz ist ein Segment des IP-Adressbereichs einer VPC, in dem Sie AWS Ressourcen entsprechend Ihren Sicherheits- und Betriebsanforderungen isolieren können.
+ Eine Amazon VPC-Sicherheitsgruppe kontrolliert den ein- und ausgehenden Datenverkehr für Ihre MemoryDB-Cluster und Amazon-Instances. EC2
+ Sie können einen MemoryDB-Cluster im Subnetz starten. Die Knoten haben private IP-Adressen aus dem Adressbereich des Subnetzes.
+ Sie können EC2 Amazon-Instances auch im Subnetz starten. Jede EC2 Amazon-Instance hat eine private IP-Adresse aus dem Adressbereich des Subnetzes. Die EC2 Amazon-Instance kann eine Verbindung zu jedem Knoten im selben Subnetz herstellen.
+ Damit eine EC2 Amazon-Instance in Ihrer VPC vom Internet aus erreichbar ist, müssen Sie der Instance eine statische, öffentliche Adresse zuweisen, die als Elastic IP-Adresse bezeichnet wird.
## Voraussetzungen
Um einen MemoryDB-Cluster innerhalb einer VPC zu erstellen, muss Ihre VPC die folgenden Anforderungen erfüllen:
+ Ihre VPC muss nicht dedizierte EC2 Amazon-Instances zulassen. Sie können MemoryDB nicht in einer VPC verwenden, die für Dedicated Instance Tenancy konfiguriert ist.
+ Für Ihre VPC muss eine Subnetzgruppe definiert werden. MemoryDB verwendet diese Subnetzgruppe, um ein Subnetz und IP-Adressen innerhalb dieses Subnetzes auszuwählen, die Ihren Knoten zugeordnet werden sollen.
+ Für Ihre VPC muss eine Sicherheitsgruppe definiert werden, oder Sie können den bereitgestellten Standard verwenden.
+ Die CIDR-Blöcke für jedes Subnetz müssen groß genug sein, um Reserve-IP-Adressen bereitzustellen, die MemoryDB bei Wartungsaktivitäten verwenden kann.
## Weiterleitung und Sicherheit
Sie können das Routing in Ihrer VPC so konfigurieren, dass gesteuert wird, wohin der Datenverkehr fließt (z. B. zum Internet-Gateway oder Virtual Private Gateway). Mit einem Internet-Gateway hat Ihre VPC direkten Zugriff auf andere AWS Ressourcen, die nicht in Ihrer VPC laufen. Wenn Sie sich dafür entscheiden, nur ein virtuelles privates Gateway mit einer Verbindung zum lokalen Netzwerk Ihrer Organisation zu verwenden, können Sie Ihren internetgebundenen Datenverkehr über das VPN weiterleiten und lokale Sicherheitsrichtlinien und Firewalls verwenden, um den ausgehenden Datenverkehr zu kontrollieren. In diesem Fall fallen zusätzliche Bandbreitengebühren an, wenn Sie über das Internet auf AWS Ressourcen zugreifen.
Sie können Amazon VPC-Sicherheitsgruppen verwenden, um die MemoryDB-Cluster und EC2 Amazon-Instances in Ihrer Amazon VPC zu sichern. Sicherheitsgruppen wirken wie eine Firewall auf der Instance-Ebene, nicht auf der Subnetzebene.
**Anmerkung**
Wir empfehlen dringend, DNS-Namen zu verwenden, um eine Verbindung zu Ihren Knoten herzustellen, da sich die zugrunde liegende IP-Adresse im Laufe der Zeit ändern kann.
## Amazon VPC-Dokumentation
Amazon VPC hat eine eigene Dokumentation, in der das Erstellen und Nutzen Ihrer erklärt wird. Die folgende Tabelle zeigt, wo Sie Informationen in den Amazon VPC-Handbüchern finden.
| Beschreibung | Dokumentation |
| --- | --- |
| Erste Schritte bei der Verwendung von Amazon VPC | [Erste Schritte mit Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-getting-started.html) |
| So verwenden Sie Amazon VPC über AWS-Managementkonsole | [Amazon VPC User Guide](https://docs.aws.amazon.com/vpc/latest/userguide/) |
| Vollständige Beschreibungen aller Amazon-VPC-Befehle | [ EC2 Amazon-Befehlszeilenreferenz](https://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/) (die Amazon VPC-Befehle finden Sie in der EC2 Amazon-Referenz) |
| Vollständige Beschreibungen der Amazon-VPC-API-Aktionen, -Datentypen und -Fehler | [ EC2 Amazon-API-Referenz](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/) (die Amazon VPC-API-Operationen finden Sie in der EC2 Amazon-Referenz) |
| Informationen für den Netzwerkadministrator, der das Gateway an Ihrem Ende einer optionalen IPsec VPN-Verbindung konfigurieren muss | [Was ist AWS Site-to-Site VPN?](https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html) |
Weitere Informationen zur Amazon Virtual Private Cloud finden Sie unter [Amazon Virtual Private Cloud](https://aws.amazon.com/vpc/).
# Zugriffsmuster für den Zugriff auf einen MemoryDB-Cluster in einer Amazon VPC
MemoryDB unterstützt die folgenden Szenarien für den Zugriff auf einen Cluster in einer Amazon VPC:
**Contents**
+ [
## Zugreifen auf einen MemoryDB-Cluster, wenn sich dieser und die EC2 Amazon-Instance in derselben Amazon VPC befinden
](#memorydb-vpc-accessing-same-vpc)
+ [
## Zugreifen auf einen MemoryDB-Cluster, wenn sich dieser und die EC2 Amazon-Instance in einem anderen Amazon befinden VPCs
](#memorydb-vpc-accessing-different-vpc)
+ [In verschiedenen VPCs Amazonasgebieten in derselben Region](#memorydb-vpc-accessing-different-vpc-same-region)
+ [Verwenden von Transit Gateway](#memorydb-vpc-accessing-using-transit-gateway)
+ [In verschiedenen Amazonasgebieten VPCs in verschiedenen Regionen](#memorydb-vpc-accessing-different-vpc-different-region)
+ [Verwenden von Transit VPC](#memorydb-vpc-accessing-different-vpc-different-region-using-transit-vpc)
+ [
## Zugreifen auf einen MemoryDB-Cluster von einer Anwendung aus, die im Rechenzentrum eines Kunden läuft
](#memorydb-vpc-accessing-data-center)
+ [Verwenden von VPN-Konnektivität](#memorydb-vpc-accessing-data-center-vpn)
+ [Verwenden von Direct Connect](#memorydb-vpc-accessing-data-center-direct-connect)
## Zugreifen auf einen MemoryDB-Cluster, wenn sich dieser und die EC2 Amazon-Instance in derselben Amazon VPC befinden
Der häufigste Anwendungsfall ist, wenn eine auf einer EC2 Instance bereitgestellte Anwendung eine Verbindung zu einem Cluster in derselben VPC herstellen muss.
Der einfachste Weg, den Zugriff zwischen EC2 Instances und Clustern in derselben VPC zu verwalten, ist wie folgt:
1. Erstellen Sie eine VPC-Sicherheitsgruppe für Ihren Cluster. Diese Sicherheitsgruppe kann verwendet werden, um den Zugriff auf die Cluster einzuschränken. Sie können für diese Sicherheitsgruppe beispielsweise eine benutzerdefinierte Regel erstellen, die TCP-Zugriff über den Port, den Sie dem Cluster bei seiner Erstellung zugeordnet haben, und eine IP-Adresse gewährt, mit der Sie auf den Cluster zugreifen.
Der Standardport für MemoryDB-Cluster ist. `6379`
1. Erstellen Sie eine VPC-Sicherheitsgruppe für Ihre EC2 Instances (Web- und Anwendungsserver). Diese Sicherheitsgruppe kann bei Bedarf den Zugriff auf die EC2 Instance aus dem Internet über die Routingtabelle der VPC ermöglichen. Sie können beispielsweise Regeln für diese Sicherheitsgruppe festlegen, um den TCP-Zugriff auf die EC2 Instance über Port 22 zu ermöglichen.
1. Erstellen Sie in der Sicherheitsgruppe für Ihren Cluster benutzerdefinierte Regeln, die Verbindungen von der Sicherheitsgruppe aus zulassen, die Sie für Ihre EC2 Instances erstellt haben. Damit wird jedem Mitglied der Sicherheitsgruppe der Zugriff auf die DB-Instances gestattet.
**So erstellen Sie eine Regel in einer VPC-Sicherheitsgruppe, die Verbindungen über eine andere Sicherheitsgruppe zulässt**
1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon VPC-Konsole unter [https://console.aws.amazon.com/vpc](https://console.aws.amazon.com/vpc).
1. Klicken Sie im linken Navigationsbereich auf **Security Groups**.
1. Wählen oder erstellen Sie eine Sicherheitsgruppe, die Sie für Ihre Cluster verwenden werden. Wählen Sie unter **Inbound Rules (Eingangsregeln)** die Option **Edit Inbound Rules (Eingangsregeln bearbeiten)** und dann **Add Rule (Regeln hinzufügen)**. Diese Sicherheitsgruppe gewährt Mitgliedern einer anderen Sicherheitsgruppe Zugriff.
1. Wählen Sie für **Type** die Option **Custom TCP Rule** aus.
1. Geben Sie für **Port Range** den Port an, den Sie beim Erstellen des Clusters verwendet haben.
Der Standardport für MemoryDB-Cluster ist. `6379`
1. Geben Sie in das Feld **Source** die ersten Zeichen der ID der Sicherheitsgruppe ein. Wählen Sie aus der Liste die Sicherheitsgruppe aus, die Sie für Ihre EC2 Amazon-Instances verwenden möchten.
1. Wählen Sie **Save**, wenn Sie fertig sind.
## Zugreifen auf einen MemoryDB-Cluster, wenn sich dieser und die EC2 Amazon-Instance in einem anderen Amazon befinden VPCs
Wenn sich Ihr Cluster in einer anderen VPC befindet als die EC2 Instance, die Sie für den Zugriff verwenden, gibt es mehrere Möglichkeiten, auf den Cluster zuzugreifen. Wenn sich der Cluster und die EC2 Instance in verschiedenen, VPCs aber in derselben Region befinden, können Sie VPC-Peering verwenden. Wenn sich der Cluster und die EC2 Instance in unterschiedlichen Regionen befinden, können Sie VPN-Konnektivität zwischen Regionen herstellen.
**Topics**
+ [In verschiedenen VPCs Amazonasgebieten in derselben Region](#memorydb-vpc-accessing-different-vpc-same-region)
+ [In verschiedenen Amazonasgebieten VPCs in verschiedenen Regionen](#memorydb-vpc-accessing-different-vpc-different-region)
### Zugreifen auf einen MemoryDB-Cluster, wenn sich dieser und die EC2 Amazon-Instance in einem anderen Amazon VPCs in derselben Region befinden
*Cluster, auf den von einer EC2 Amazon-Instance in einer anderen Amazon VPC innerhalb derselben Region zugegriffen wird — VPC Peering Connection*
Eine VPC-Peering-Verbindung ist eine Netzwerkverbindung zwischen zwei VPCs , mit der Sie den Verkehr zwischen ihnen mithilfe privater IP-Adressen weiterleiten können. Instances in jeder der VPCs können so miteinander kommunizieren, als befänden sie sich im selben Netzwerk. Sie können eine VPC-Peering-Verbindung zwischen Ihrem eigenen Amazon VPCs oder mit einer Amazon-VPC in einem anderen AWS Konto innerhalb einer einzelnen Region herstellen. Weitere Informationen zum Amazon-VPC-Peering finden Sie in der [VPC-Dokumentation](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/vpc-peering.html)
**So greifen Sie auf einen Cluster in einer anderen Amazon VPC über Peering zu**
1. Stellen Sie sicher, dass die beiden VPCs keinen sich überschneidenden IP-Bereich haben, da Sie sie sonst nicht miteinander verbinden können.
1. Schauen Sie sich die beiden VPCs an. Weitere Informationen finden Sie unter [Erstellen und Akzeptieren einer Amazon-VPC-Peering-Verbindung](https://docs.aws.amazon.com/AmazonVPC/latest/PeeringGuide/create-vpc-peering-connection.html).
1. Aktualisieren Sie Ihre Routing-Tabelle. Weitere Informationen finden Sie unter [Aktualisieren der Routing-Tabellen für eine VPC-Peering-Verbindung](https://docs.aws.amazon.com/AmazonVPC/latest/PeeringGuide/vpc-peering-routing.html).
1. Ändern Sie die Sicherheitsgruppe Ihres MemoryDB-Clusters, um eingehende Verbindungen von der Anwendungssicherheitsgruppe in der Peering-VPC zuzulassen. Weitere Informationen finden Sie unter [Verweisen auf Peer-VPC-Sicherheitsgruppen](https://docs.aws.amazon.com/AmazonVPC/latest/PeeringGuide/vpc-peering-security-groups.html).
Beim Zugriff auf einen Cluster über eine Peering-Verbindung fallen zusätzliche Datenübertragungskosten an.
#### Verwenden von Transit Gateway
Ein Transit-Gateway ermöglicht es Ihnen, Verbindungen VPCs und VPN-Verbindungen in derselben AWS Region herzustellen und den Verkehr zwischen ihnen weiterzuleiten. Ein Transit-Gateway funktioniert AWS kontenübergreifend, und Sie können AWS Resource Access Manager verwenden, um Ihr Transit-Gateway mit anderen Konten zu teilen. Nachdem Sie ein Transit-Gateway mit einem anderen AWS Konto gemeinsam genutzt haben VPCs , kann der Kontoinhaber dieses Konto mit Ihrem Transit-Gateway verknüpfen. Benutzer in einem der Konten können die Anhang jederzeit löschen.
Sie können Multicast auf einem Transit Gateway aktivieren und dann eine Transit Gateway-Multicast-Domain erstellen, mit der Multicast-Datenverkehr von der Multicast-Quelle über VPC-Anhängen, die Sie der Domain zuordnen, an Multicast-Gruppenmitglieder gesendet werden kann.
Sie können auch einen Peering-Verbindungsanhang zwischen Transit-Gateways in verschiedenen AWS Regionen erstellen. Auf diese Weise können Sie den Datenverkehr zwischen den Anhängen der Transit Gateways über verschiedene Regionen hinweg leiten.
Weitere Informationen finden Sie unter [Transit Gateways](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-transit-gateways.html).
### Zugreifen auf einen MemoryDB-Cluster, wenn sich dieser und die EC2 Amazon-Instance in unterschiedlichen Amazon-Regionen VPCs befinden
#### Verwenden von Transit VPC
Eine Alternative zur Verwendung von VPC-Peering, eine weitere gängige Strategie für die Verbindung mehrerer, geografisch verteilter VPCs und entfernter Netzwerke, ist die Einrichtung einer Transit-VPC, die als globales Netzwerk-Transitzentrum dient. Eine Transit-VPC vereinfacht die Netzwerkverwaltung und minimiert die Anzahl der Verbindungen, die für die Verbindung mehrerer VPCs und entfernter Netzwerke erforderlich sind. Dieses Design kann Zeit und Aufwand verringern und auch Kosten reduzieren, da es virtuell ohne die herkömmlichen Ausgaben implementiert wird, die beim Einrichten einer physischen Präsenz in einem Co-Location-Transit-Hub oder beim Bereitstellen physischer Netzwerkausstattung anfallen.
*Verbindungen zwischen verschiedenen Regionen VPCs herstellen*
Sobald die Transit Amazon VPC eingerichtet ist, kann eine Anwendung, die in einer „Spoke“ VPC in einer Region bereitgestellt wird, eine Verbindung zu einem MemoryDB-Cluster in einer „Spoke“ VPC in einer anderen Region herstellen.
**So greifen Sie auf einen Cluster in einer anderen VPC in einer anderen AWS Region zu**
1. Stellen Sie eine Transit-VPC-Lösung bereit. Weitere Informationen finden Sie unter [AWS-Transit-Gateway](https://aws.amazon.com/transit-gateway/).
1. Aktualisieren Sie die VPC-Routing-Tabellen in der App und leiten VPCs Sie den Datenverkehr über das VGW (Virtual Private Gateway) und die VPN-Appliance weiter. Im Falle des dynamischen Routing mit Border Gateway Protocol (BGP) werden Ihre Routen möglicherweise automatisch gefüllt.
1. Ändern Sie die Sicherheitsgruppe Ihres MemoryDB-Clusters, um eingehende Verbindungen aus dem IP-Bereich der Anwendungsinstanzen zuzulassen. Beachten Sie, dass Sie in diesem Szenario nicht auf die Sicherheitsgruppe des Anwendungsservers verwiesen können.
Beim regionsübergreifenden Zugriff auf einen Cluster entstehen Netzwerklatenzen und fallen zusätzliche, regionsübergreifende Datenübertragungskosten an.
## Zugreifen auf einen MemoryDB-Cluster von einer Anwendung aus, die im Rechenzentrum eines Kunden läuft
Ein anderes mögliches Szenario ist eine Hybridarchitektur, bei der Clients oder Anwendungen im Rechenzentrum des Kunden möglicherweise auf einen MemoryDB-Cluster in der VPC zugreifen müssen. Dieses Szenario wird auch unterstützt, vorausgesetzt, dass entweder über VPN oder Direct Connect Konnektivität zwischen der VPC des Kunden und dem Rechenzentrum besteht.
**Topics**
+ [Verwenden von VPN-Konnektivität](#memorydb-vpc-accessing-data-center-vpn)
+ [Verwenden von Direct Connect](#memorydb-vpc-accessing-data-center-direct-connect)
### Zugriff auf einen MemoryDB-Cluster von einer Anwendung aus, die im Rechenzentrum eines Kunden mithilfe von VPN-Konnektivität ausgeführt wird
*Über ein VPN von Ihrem Rechenzentrum aus eine Verbindung zu MemoryDB herstellen*
**So greifen Sie auf einen Cluster in einer VPC von einer Anwendung vor Ort über eine VPN-Verbindung zu**
1. Richten Sie VPN-Konnektivität ein, indem Sie ein Hardware Virtual Private Gateway zu Ihrer VPC hinzufügen. Weitere Informationen finden Sie unter [Hinzufügen eines Hardware Virtual Private Gateway zu Ihrer VPC](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html).
1. Aktualisieren Sie die VPC-Routingtabelle für das Subnetz, in dem Ihr MemoryDB-Cluster bereitgestellt wird, um Datenverkehr von Ihrem lokalen Anwendungsserver zuzulassen. Im Falle des dynamischen Routing mit BGP werden Ihre Routen möglicherweise automatisch gefüllt.
1. Ändern Sie die Sicherheitsgruppe Ihres MemoryDB-Clusters, um eingehende Verbindungen von den lokalen Anwendungsservern zuzulassen.
Beim Zugriff auf einen Cluster über eine VPN-Verbindung entstehen Netzwerklatenzen und fallen zusätzliche Datenübertragungskosten an.
### Zugreifen auf einen MemoryDB-Cluster von einer Anwendung aus, die im Rechenzentrum eines Kunden mit Direct Connect ausgeführt wird
*Über Direct Connect von Ihrem Rechenzentrum aus eine Verbindung zu MemoryDB herstellen*
**So greifen Sie über Direct Connect von einer in Ihrem Netzwerk ausgeführten Anwendung auf einen MemoryDB-Cluster zu**
1. Richten Sie Direct Connect-Konnektivität ein. Weitere Informationen finden Sie unter [Erste Schritte mit AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/getting_started.html).
1. Ändern Sie die Sicherheitsgruppe Ihres MemoryDB-Clusters, um eingehende Verbindungen von den lokalen Anwendungsservern zuzulassen.
Beim Zugriff auf einen Cluster über eine DX-Verbindung können Netzwerklatenzen entstehen und zusätzliche Datenübertragungskosten anfallen.
# Erstellen einer Virtual Private Cloud (VPC)
In diesem Beispiel erstellen Sie eine virtuelle private Cloud (VPC), die auf dem Amazon VPC-Service basiert, mit einem privaten Subnetz für jede Availability Zone.
## Eine VPC (Konsole) erstellen
**So erstellen Sie einen MemoryDB-Cluster in einer Amazon Virtual Private Cloud**
1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Wählen Sie auf dem VPC-Dashboard **Create VPC** (VPC erstellen) aus.
1. Wählen Sie unter **Resources to create** (Zu erstellende Ressourcen) die Option **VPC and more** (VPC und mehr) aus.
1. Wählen Sie unter **Anzahl der Availability Zones (AZs)** die Anzahl der Availability Zones aus, in denen Sie Ihre Subnetze starten möchten.
1. Wählen Sie unter **Number of public subnets** (Anzahl der öffentlichen Subnetze) die Anzahl der öffentlichen Subnetze aus, die Sie zu Ihrer VPC hinzufügen möchten.
1. Wählen Sie unter **Number of private subnets** (Anzahl der privaten Subnetze) die Anzahl der privaten Subnetze aus, die Sie zu Ihrer VPC hinzufügen möchten.
**Tipp**
Notieren Sie sich Ihre Subnetz-IDs und welches öffentlich und welches privat ist. Sie benötigen diese Informationen später, wenn Sie Ihre Cluster starten und Ihrer Amazon VPC eine EC2 Amazon-Instance hinzufügen.
1. Erstellen Sie eine Amazon-VPC-Sicherheitsgruppe. Sie werden diese Gruppe für Ihren Cluster und Ihre EC2 Amazon-Instance verwenden.
1. Wählen Sie im linken Navigationsbereich von die AWS-Managementkonsole Option **Sicherheitsgruppen** aus.
1. Wählen Sie **Sicherheitsgruppen erstellen** aus.
1. Geben Sie einen Namen und eine Beschreibung für Ihre Sicherheitsgruppe in die entsprechenden Felder ein. Wählen Sie für **VPC** den Bezeichner für Ihre VPC aus.
1. Wenn Sie die gewünschten Einstellungen vorgenommen haben, wählen Sie **Ja, erstellen** aus.
1. Definieren Sie eine Netzwerkeingangsregel für Ihre Sicherheitsgruppe. Diese Regel ermöglicht es Ihnen, über Secure Shell (SSH) eine Verbindung zu Ihrer EC2 Amazon-Instance herzustellen.
1. Klicken Sie im linken Navigationsbereich auf **Security Groups**.
1. Suchen Sie Ihre Sicherheitsgruppe in der Liste und wählen Sie sie aus.
1. Wählen Sie unter **Security Group** die Registerkarte **Inbound** aus. Wählen Sie im Feld **Create a new rule** die Option **SSH** und anschließend **Add Rule** aus.
Stellen Sie die folgenden Werte für Ihre neue eingehende Regel ein, um HTTP-Zugriff zuzulassen:
+ Typ: HTTP
+ Quelle: 0.0.0.0/0
1. Stellen Sie die folgenden Werte für Ihre neue eingehende Regel ein, um HTTP-Zugriff zuzulassen:
+ Typ: HTTP
+ Quelle: 0.0.0.0/0
Wählen Sie **Apply Rule Changes** aus.
Jetzt sind Sie bereit, eine [Subnetzgruppe](https://docs.aws.amazon.com/memorydb/latest/devguide/subnetgroups.html) und [einen Cluster in Ihrer VPC zu erstellen](https://docs.aws.amazon.com/memorydb/latest/devguide/getting-started.createcluster.html).
# Subnetze und Subnetzgruppen
Eine *Subnetzgruppe* ist eine Sammlung von Subnetzen (in der Regel private Subnetze), die Sie für Ihre, in einer Amazon Virtual Private Cloud (VPC)-Umgebung ausgeführten, Cluster festlegen können.
Wenn Sie einen Cluster in einer Amazon VPC erstellen, können Sie eine Subnetzgruppe angeben oder die bereitgestellte Standardgruppe verwenden. MemoryDB verwendet diese Subnetzgruppe, um ein Subnetz und IP-Adressen innerhalb dieses Subnetzes auszuwählen, die Ihren Knoten zugeordnet werden sollen.
In diesem Abschnitt wird beschrieben, wie Sie Subnetze und Subnetzgruppen erstellen und nutzen, um den Zugriff auf Ihre MemoryDB-Ressourcen zu verwalten.
Weitere Informationen zur Verwendung von Subnetzgruppen in einer Amazon-VPC-Umgebung finden Sie unter [Schritt 3: Zugriff auf den Cluster autorisieren](getting-started.md#getting-started.authorizeaccess).
**Unterstützte MemoryDB AZ IDs**
| Regionsname/Region | Unterstützt AZ IDs |
| --- | --- |
| Region USA Ost (Ohio) `us-east-2` | `use2-az1, use2-az2, use2-az3` |
| Region USA Ost (Nord-Virginia) `us-east-1` | `use1-az1, use1-az2, use1-az4, use1-az5, use1-az6` |
| Region USA West (Nordkalifornien) `us-west-1` | `usw1-az1, usw1-az2, usw1-az3` |
| Region USA West (Oregon) `us-west-2` | `usw2-az1, usw2-az2, usw2-az3, usw2-az4` |
| Region Kanada (Zentral) `ca-central-1` | `cac1-az1, cac1-az2, cac1-az4` |
| Region Asien-Pazifik (Hongkong) `ap-east-1` | `ape1-az1, ape1-az2, ape1-az3` |
| Region Asien-Pazifik (Mumbai) `ap-south-1` | `aps1-az1, aps1-az2, aps1-az3` |
| Region Asien-Pazifik (Tokio) `ap-northeast-1` | `apne1-az1, apne1-az2, apne1-az4` |
| Asia Pacific (Seoul) Region `ap-northeast-2` | `apne2-az1, apne2-az2, apne2-az3` |
| Region Asien-Pazifik (Singapur) `ap-southeast-1` | `apse1-az1, apse1-az2, apse1-az3` |
| Region Asien-Pazifik (Sydney) `ap-southeast-2` | apse2-az1, apse2-az2, apse2-az3 |
| Region Europa (Frankfurt) `eu-central-1` | `euc1-az1, euc1-az2, euc1-az3` |
| Region Europa (Irland) `eu-west-1` | `euw1-az1, euw1-az2, euw1-az3` |
| Region Europa (London) `eu-west-2` | `euw2-az1, euw2-az2, euw2-az3` |
| Region Europa (Paris) `eu-west-3` | `euw3-az1, euw3-az2, euw3-az3` |
| Region Europa (Stockholm) `eu-north-1` | `eun1-az1, eun1-az2, eun1-az3 ` |
| Region Europa (Mailand) `eu-south-1` | `eus1-az1, eus1-az2, eus1-az3 ` |
| Region Südamerika (São Paulo) `sa-east-1` | `sae1-az1, sae1-az2, sae1-az3` |
| Region China (Peking) `cn-north-1` | `cnn1-az1, cnn1-az2` |
| Region China (Ningxia) `cn-northwest-1` | `cnw1-az1, cnw1-az2, cnw1-az3` |
| `us-gov-east-1` | `usge1-az1, usge1-az2, usge1-az3` |
| `us-gov-west-1` | `usgw1-az1, usgw1-az2, usgw1-az3` |
| Region Europa (Spanien) `eu-south-2` | `eus2-az1, eus2-az2, eus2-az3` |
**Topics**
+ [
# MemoryDB und IPV6
](subnetgroups.ipv6.md)
+ [
# Erstellen einer Subnetzgruppe
](subnetgroups.creating.md)
+ [
# Aktualisierung einer Subnetzgruppe
](subnetgroups.modifying.md)
+ [
# Details zur Subnetzgruppe anzeigen
](subnetgroups.Viewing.md)
+ [
# Löschen einer Subnetzgruppe
](subnetgroups.deleting.md)
# MemoryDB und IPV6
Sie können neue Dual-Stack- und reine IPv6-Cluster mit Valkey- und Redis OSS-Engines erstellen, indem Sie Subnetzgruppen mit Dual-Stack- und reinen IPv6-Subnetzen bereitstellen. Sie können den Netzwerktyp für einen vorhandenen Cluster nicht ändern.
Mit dieser Funktion können Sie:
+ Erstellen Sie reine IPv4-Cluster und Dual-Stack-Cluster in Dual-Stack-Subnetzen.
+ Erstellen Sie reine IPv6-Cluster in reinen IPv6-Subnetzen.
+ Erstellen Sie neue Subnetzgruppen, um reine IPv4-, Dual-Stack- und reine IPv6-Subnetze zu unterstützen.
+ Ändern Sie bestehende Subnetzgruppen, um zusätzliche Subnetze aus der zugrunde liegenden VPC einzubeziehen.
+ Ändern Sie bestehende Subnetze in Subnetzgruppen
+ Fügen Sie IPv6 nur Subnetze zu Subnetzgruppen hinzu, für die konfiguriert sind IPv6
+ Fügen Sie Subnetzgruppen, für die konfiguriert sind, Subnetze hinzu IPv4 oder verwenden Sie Dual-Stack-Unterstützung IPv4
+ Ermitteln Sie alle Knoten im Cluster mit IPv4- ODER IPv6-Adressen mithilfe von Engine-Discovery-Befehlen für Dual-Stack- und IPv6-Cluster. Zu diesen Discovery-Befehlen gehören `redis_info``redis_cluster`, und ähnliche.
+ Ermitteln Sie die IPv4- und IPv6-Adressen aller Knoten im Cluster mithilfe von DNS-Erkennungsbefehlen für Dual-Stack- und IPv6-Cluster.
# Erstellen einer Subnetzgruppe
Wenn Sie eine neue Subnetzgruppe erstellen, notieren Sie sich die Anzahl der verfügbaren IP-Adressen. Wenn das Subnetz nur über wenige freie IP-Adressen verfügt, beschränkt dies auch die Anzahl der neuen Knoten, die Sie zu dem Cluster hinzufügen können. Um dieses Problem zu lösen, können Sie einer Subnetzgruppe weitere Subnetze zuweisen, um ausreichend IP-Adressen in der Availability Zone Ihres Clusters bereitzustellen. Danach können Sie dem Cluster weitere Knoten hinzufügen.
Die folgenden Verfahren zeigen Ihnen, wie Sie eine Subnetzgruppe mit den Namen `mysubnetgroup` (Konsole) AWS CLI, die und die MemoryDB-API erstellen.
## Erstellen einer Subnetzgruppe (Konsole)
Im folgenden Verfahren wird das Erstellen einer Subnetzgruppe (Konsole) erläutert.
**Erstellen einer DB-Sicherheitsgruppe (Konsole)**
1. Melden Sie sich bei der AWS Management Console an 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 **Subnet** Groups aus.
1. Klicken Sie auf **Create Subnet Group (Subnetzgruppe ändern)**.
1. Gehen Sie auf der Seite **„Subnetzgruppe erstellen**“ wie folgt vor:
1. Geben Sie im Feld **Name** einen Namen für Ihre Subnetzgruppe 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. Geben Sie im Feld **Description** eine Beschreibung für Ihre Subnetzgruppe ein.
1. Wählen Sie im Feld **VPC ID** die erstellte Amazon VPC aus. Wenn Sie noch keine erstellt haben, klicken Sie auf die Schaltfläche **VPC erstellen** und folgen Sie den Schritten, um eine zu erstellen.
1. **Wählen Sie **unter Ausgewählte Subnetze** die Availability Zone und die ID Ihres privaten Subnetzes aus und klicken Sie dann auf Auswählen.**
1. Für **Tags** können Sie optional Tags anwenden, um Ihre Subnetze zu durchsuchen und zu filtern oder Ihre Kosten zu verfolgen. AWS
1. Wenn Sie die gewünschten Einstellungen vorgenommen haben, wählen Sie **Erstellen** aus.
1. Klicken Sie in der angezeigten Bestätigungsmeldung auf **Close**.
Ihre neue Subnetzgruppe wird in der Liste der **Subnetzgruppen** der MemoryDB-Konsole angezeigt. Unten im Fenster können Sie die Subnetzgruppe auswählen, um Details wie die der Gruppe zugeordneten Subnetze anzuzeigen.
## Erstellen einer Subnetzgruppe (AWS CLI)
Geben Sie in einem Befehlszeilenfenster den Befehl `create-subnet-group` ein, um eine Subnetzgruppe zu erstellen.
Für Linux, macOS oder Unix:
```
aws memorydb create-subnet-group \
--subnet-group-name mysubnetgroup \
--description "Testing" \
--subnet-ids subnet-53df9c3a
```
Für Windows:
```
aws memorydb create-subnet-group ^
--subnet-group-name mysubnetgroup ^
--description "Testing" ^
--subnet-ids subnet-53df9c3a
```
Die Ausgabe dieses Befehls sieht ähnlich wie folgt aus:
```
{
"SubnetGroup": {
"Subnets": [
{
"Identifier": "subnet-53df9c3a",
"AvailabilityZone": {
"Name": "us-east-1a"
}
}
],
"VpcId": "vpc-3cfaef47",
"Name": "mysubnetgroup",
"ARN": "arn:aws:memorydb:us-east-1:012345678912:subnetgroup/mysubnetgroup",
"Description": "Testing"
}
}
```
Weitere Informationen finden Sie im AWS CLI Thema[create-subnet-group](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-subnet-group.html).
## Eine Subnetzgruppe erstellen (MemoryDB-API)
Rufen `CreateSubnetGroup` Sie mithilfe der MemoryDB-API mit den folgenden Parametern auf:
+ `SubnetGroupName=``mysubnetgroup`
+ `Description=``Testing`
+ `SubnetIds.member.1=``subnet-53df9c3a`
# Aktualisierung einer Subnetzgruppe
Sie können die Beschreibung einer Subnetzgruppe aktualisieren oder die Liste der Subnetze ändern, die der Subnetzgruppe IDs zugeordnet sind. Es ist nicht möglich, Subnetz-IDs aus einer Subnetzgruppe zu löschen, wenn das Subnetz derzeit von einem Cluster verwendet wird.
Die folgenden Verfahren zeigen Ihnen, wie Sie eine Subnetzgruppe aktualisieren.
## Aktualisierung von Subnetzgruppen (Konsole)
**Um eine Subnetzgruppe zu aktualisieren**
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 **Subnet** Groups aus.
1. Wählen Sie in der Liste der Subnetzgruppen die gewünschte Subnetzgruppe aus.
1. Die Felder **Name **VPCId****und **Beschreibung** können nicht geändert werden.
1. Klicken Sie im Abschnitt **Ausgewählte Subnetze** auf **Verwalten**, um alle Änderungen an den Availability Zones vorzunehmen, die Sie für die Subnetze benötigen. Klicken Sie auf **Save (Speichern)**, um die Änderungen zu speichern.
## Aktualisierung von Subnetzgruppen (AWS CLI)
Verwenden Sie in einer Befehlszeile den Befehl, `update-subnet-group` um eine Subnetzgruppe zu aktualisieren.
Für Linux, macOS oder Unix:
```
aws memorydb update-subnet-group \
--subnet-group-name mysubnetgroup \
--description "New description" \
--subnet-ids "subnet-42df9c3a" "subnet-48fc21a9"
```
Für Windows:
```
aws memorydb update-subnet-group ^
--subnet-group-name mysubnetgroup ^
--description "New description" ^
--subnet-ids "subnet-42df9c3a" "subnet-48fc21a9"
```
Die Ausgabe dieses Befehls sieht ähnlich wie folgt aus:
```
{
"SubnetGroup": {
"VpcId": "vpc-73cd3c17",
"Description": "New description",
"Subnets": [
{
"Identifier": "subnet-42dcf93a",
"AvailabilityZone": {
"Name": "us-east-1a"
}
},
{
"Identifier": "subnet-48fc12a9",
"AvailabilityZone": {
"Name": "us-east-1a"
}
}
],
"Name": "mysubnetgroup",
"ARN": "arn:aws:memorydb:us-east-1:012345678912:subnetgroup/mysubnetgroup",
}
}
```
Weitere Informationen finden Sie im AWS CLI Thema [update-subnet-group](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-subnet-group.html).
## Aktualisierung von Subnetzgruppen (MemoryDB-API)
Rufen `UpdateSubnetGroup` Sie mithilfe der MemoryDB-API mit den folgenden Parametern auf:
+ `SubnetGroupName=``mysubnetgroup`
+ Alle anderen Parameter, deren Werte Sie ändern möchten. In diesem Beispiel wird `Description=``New%20description` verwendet, um die Beschreibung der Subnetzgruppe zu ändern.
**Example**
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateSubnetGroup
&Description=New%20description
&SubnetGroupName=mysubnetgroup
&SubnetIds.member.1=subnet-42df9c3a
&SubnetIds.member.2=subnet-48fc21a9
&SignatureMethod=HmacSHA256
&SignatureVersion=4
&Timestamp=20141201T220302Z
&Version=2014-12-01
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20141201T220302Z
&X-Amz-Expires=20141201T220302Z
&X-Amz-Signature=
&X-Amz-SignedHeaders=Host
```
**Anmerkung**
Wenn Sie eine neue Subnetzgruppe erstellen, notieren Sie sich die Anzahl der verfügbaren IP-Adressen. Wenn das Subnetz nur über wenige freie IP-Adressen verfügt, beschränkt dies auch die Anzahl der neuen Knoten, die Sie zu dem Cluster hinzufügen können. Um dieses Problem zu lösen, können Sie einer Subnetzgruppe weitere Subnetze zuweisen, um ausreichend IP-Adressen in der Availability Zone Ihres Clusters bereitzustellen. Danach können Sie dem Cluster weitere Knoten hinzufügen.
# Details zur Subnetzgruppe anzeigen
Die folgenden Verfahren zeigen Ihnen, wie Sie Details zu einer Subnetzgruppe anzeigen.
## Details von Subnetzgruppen anzeigen (Konsole)
**Um Details einer Subnetzgruppe anzuzeigen (Konsole)**
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 **Subnet** Groups aus.
1. Wählen Sie auf der Seite **Subnetzgruppen** die Subnetzgruppe unter **Name aus, oder geben Sie den Namen** der Subnetzgruppe in die Suchleiste ein.
1. Wählen Sie auf der Seite **Subnetzgruppen** die Subnetzgruppe unter **Name aus, oder geben Sie den Namen** der Subnetzgruppe in die Suchleiste ein.
1. Unter **Subnetzgruppeneinstellungen** können Sie den Namen, die Beschreibung, die VPC-ID und den Amazon-Ressourcennamen (ARN) der Subnetzgruppe einsehen.
1. Unter **Subnetze** können Sie die Availability Zones, Subnet IDs - und CIDR-Blöcke der Subnetzgruppe einsehen
1. Unter **Tags** können Sie alle Tags anzeigen, die der Subnetzgruppe zugeordnet sind.
## Details zu Subnetzgruppen anzeigen (AWS CLI)
Verwenden Sie in einer Befehlszeile den Befehl, `describe-subnet-groups` um die Details einer bestimmten Subnetzgruppe anzuzeigen.
Für Linux, macOS oder Unix:
```
aws memorydb describe-subnet-groups \
--subnet-group-name mysubnetgroup
```
Für Windows:
```
aws memorydb describe-subnet-groups ^
--subnet-group-name mysubnetgroup
```
Die Ausgabe dieses Befehls sieht ähnlich wie folgt aus:
```
{
"subnetgroups": [
{
"Subnets": [
{
"Identifier": "subnet-060cae3464095de6e",
"AvailabilityZone": {
"Name": "us-east-1a"
}
},
{
"Identifier": "subnet-049d11d4aa78700c3",
"AvailabilityZone": {
"Name": "us-east-1c"
}
},
{
"Identifier": "subnet-0389d4c4157c1edb4",
"AvailabilityZone": {
"Name": "us-east-1d"
}
}
],
"VpcId": "vpc-036a8150d4300bcf2",
"Name": "mysubnetgroup",
"ARN": "arn:aws:memorydb:us-east-1:53791xzzz7620:subnetgroup/mysubnetgroup",
"Description": "test"
}
]
}
```
Um Details zu allen Subnetzgruppen anzuzeigen, verwenden Sie denselben Befehl, jedoch ohne Angabe eines Subnetzgruppennamens.
```
aws memorydb describe-subnet-groups
```
Weitere Informationen finden Sie im AWS CLI Thema. [describe-subnet-groups](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-subnet-group.html)
## Subnetzgruppen anzeigen (MemoryDB-API)
Rufen `DescribeSubnetGroups` Sie mithilfe der MemoryDB-API mit den folgenden Parametern auf:
`SubnetGroupName=``mysubnetgroup`
**Example**
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateSubnetGroup
&Description=New%20description
&SubnetGroupName=mysubnetgroup
&SubnetIds.member.1=subnet-42df9c3a
&SubnetIds.member.2=subnet-48fc21a9
&SignatureMethod=HmacSHA256
&SignatureVersion=4
&Timestamp=20211801T220302Z
&Version=2021-01-01
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20210801T220302Z
&X-Amz-Expires=20210801T220302Z
&X-Amz-Signature=
&X-Amz-SignedHeaders=Host
```
# Löschen einer Subnetzgruppe
Wenn Sie eine Subnetzgruppe nicht mehr benötigen, können Sie sie löschen. Sie können eine Subnetzgruppe, die derzeit von einem Cluster verwendet wird, nicht löschen. Sie können auch eine Subnetzgruppe in einem Cluster mit aktiviertem Multi-AZ nicht löschen, wenn dieser Cluster mit weniger als zwei Subnetzen belässt. Sie müssen zuerst **Multi-AZ** deaktivieren und dann das Subnetz löschen.
Das folgende Verfahren zeigt, wie Sie eine Subnetzgruppe löschen.
## Löschen einer Subnetzgruppe (Konsole)
**So löschen Sie eine Subnetzgruppe**
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 **Subnet** Groups aus.
1. **Wählen Sie in der Liste der Subnetzgruppen die aus, die Sie löschen möchten, klicken Sie auf **Aktionen** und dann auf Löschen.**
**Anmerkung**
Sie können keine Standard-Subnetzgruppe oder eine, die mit Clustern verknüpft ist, löschen.
1. Der Bestätigungsbildschirm **„Subnetzgruppen löschen**“ wird angezeigt.
1. Um die Subnetzgruppe zu löschen, geben Sie `delete` in das Bestätigungstextfeld ein. Wählen Sie **Cancel (Abbrechen)**, um die Subnetzgruppe zu erhalten.
## Löschen einer Subnetzgruppe (AWS CLI)
Rufen Sie mit dem AWS CLI den Befehl **delete-subnet-group** mit dem folgenden Parameter auf:
+ `--subnet-group-name` *mysubnetgroup*
Für Linux, macOS oder Unix:
```
aws memorydb delete-subnet-group \
--subnet-group-name mysubnetgroup
```
Für Windows:
```
aws memorydb delete-subnet-group ^
--subnet-group-name mysubnetgroup
```
Weitere Informationen finden Sie im AWS CLI Thema [delete-subnet-group](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-subnet-group.html).
## Löschen einer Subnetzgruppe (MemoryDB-API)
Rufen `DeleteSubnetGroup` Sie mithilfe der MemoryDB-API mit dem folgenden Parameter auf:
+ `SubnetGroupName=mysubnetgroup`
**Example**
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DeleteSubnetGroup
&SubnetGroupName=mysubnetgroup
&SignatureMethod=HmacSHA256
&SignatureVersion=4
&Timestamp=20210801T220302Z
&Version=2021-01-01
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20210801T220302Z
&X-Amz-Expires=20210801T220302Z
&X-Amz-Signature=
&X-Amz-SignedHeaders=Host
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
Weitere Informationen finden Sie im Thema MemoryDB-API. [DeleteSubnetGroup](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DeleteSubnetGroup.html)
# MemoryDB-API und VPC-Schnittstellen-Endpunkte ()AWS PrivateLink
*Sie können eine private Verbindung zwischen Ihrer VPC und den Amazon MemoryDB-API-Endpunkten herstellen, indem Sie einen VPC-Schnittstellen-Endpunkt erstellen.* Schnittstellen-Endpunkte werden betrieben von. [AWS PrivateLink](https://aws.amazon.com/privatelink) AWS PrivateLink ermöglicht Ihnen den privaten Zugriff auf MemoryDB-API-Operationen ohne Internet-Gateway, NAT-Gerät, VPN-Verbindung oder AWS Direct Connect-Verbindung.
Instances in Ihrer VPC benötigen keine öffentlichen IP-Adressen, um mit MemoryDB-API-Endpunkten zu kommunizieren. Ihre Instances benötigen auch keine öffentlichen IP-Adressen, um die verfügbaren MemoryDB-API-Operationen nutzen zu können. Der Verkehr zwischen Ihrer VPC und MemoryDB verlässt das Amazon-Netzwerk nicht. Jeder Schnittstellenendpunkt wird durch eine oder mehrere Elastic Network-Schnittstellen in Ihren Subnetzen dargestellt. Weitere Informationen zu Elastic Network-Schnittstellen finden Sie unter [Elastic Network-Schnittstellen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) im *Amazon EC2 Benutzerhandbuch.*
+ Weitere Informationen zu VPC-Endpunkten finden Sie unter [Interface VPC Endpoints (AWS PrivateLink)](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) im *Amazon* VPC-Benutzerhandbuch.
+ [Weitere Informationen zu MemoryDB-API-Vorgängen finden Sie unter MemoryDB-API-Operationen.](https://docs.aws.amazon.com/memorydb/latest/APIReference/Welcome.html)
Wenn Sie nach dem Erstellen eines VPC-Schnittstellen-Endpunkts [private DNS-Hostnamen](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#vpce-private-dns) für den Endpunkt aktivieren, wird dies der Standard-MemoryDB-Endpunkt sein (https://memorydb. *Region*.amazonaws.com) wird zu Ihrem VPC-Endpunkt aufgelöst. Wenn Sie keine privaten DNS-Hostnamen aktiviert haben, stellt Amazon VPC einen DNS-Endpunktnamen bereit, den Sie im folgenden Format verwenden können:
```
VPC_Endpoint_ID.memorydb.Region.vpce.amazonaws.com
```
Weitere Informationen finden Sie unter [Schnittstellen-VPC-Endpunkte (AWS PrivateLink)](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) im *Amazon-VPC-Benutzerhandbuch*. MemoryDB unterstützt Aufrufe aller [API-Aktionen in Ihrer VPC](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_Operations.html).
**Anmerkung**
Private DNS-Hostnamen können nur für einen VPC-Endpunkt in der VPC aktiviert werden. Wenn Sie einen zusätzlichen VPC-Endpunkt erstellen möchten, sollte der private DNS-Hostname dafür deaktiviert werden.
## Überlegungen zu VPC-Endpunkten
Bevor Sie einen Schnittstellen-VPC-Endpunkt für MemoryDB-API-Endpunkte einrichten, stellen Sie sicher, dass Sie die [Eigenschaften und Einschränkungen der Schnittstellenendpunkte](https://docs.aws.amazon.com/vpc/latest/privatelink/endpoint-services-overview.html) im *Amazon* VPC-Benutzerhandbuch lesen. Alle MemoryDB-API-Operationen, die für die Verwaltung von MemoryDB-Ressourcen relevant sind, sind über Ihre VPC verfügbar unter. AWS PrivateLink VPC-Endpunktrichtlinien werden für MemoryDB-API-Endpunkte unterstützt. Standardmäßig ist der vollständige Zugriff auf MemoryDB-API-Operationen über den Endpunkt zulässig. Weitere Informationen finden Sie unter [Steuerung des Zugriffs auf Services mit VPC-Endpunkten](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html) im *Amazon-VPC-Benutzerhandbuch*.
### Erstellen eines VPC-Schnittstellen-Endpunkts für die MemoryDB-API
Sie können einen VPC-Endpunkt für die MemoryDB-API entweder mit der Amazon VPC-Konsole oder mit dem erstellen. AWS CLI Weitere Informationen finden Sie unter [Erstellung eines Schnittstellenendpunkts](https://docs.aws.amazon.com/vpc/latest/privatelink/create-endpoint-service.html) im *Benutzerhandbuch für Amazon VPC*.
Nachdem Sie einen Schnittstellen-VPC-Endpunkt erstellt haben, können Sie private DNS-Hostnamen für den Endpunkt aktivieren. Wenn Sie dies tun, der Standard-MemoryDB-Endpunkt (https://memorydb. *Region*.amazonaws.com) wird zu Ihrem VPC-Endpunkt aufgelöst. Weitere Informationen finden Sie unter [Zugriff auf einen Service über einen Schnittstellenendpunkt](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#access-service-though-endpoint) im *Benutzerhandbuch für Amazon VPC*.
### Erstellen einer VPC-Endpunktrichtlinie für die Amazon MemoryDB-API
Sie können Ihrem VPC-Endpunkt eine Endpunktrichtlinie hinzufügen, die den Zugriff auf die MemoryDB-API steuert. Die Richtlinie legt Folgendes fest:
+ Prinzipal, der die Aktionen ausführen kann.
+ Aktionen, die ausgeführt werden können
+ Die Ressourcen, für die Aktionen ausgeführt werden können.
Weitere Informationen finden Sie unter [Steuerung des Zugriffs auf Services mit VPC-Endpunkten](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html) im *Amazon-VPC-Benutzerhandbuch*.
**Example VPC-Endpunktrichtlinie für MemoryDB-API-Aktionen**
Im Folgenden finden Sie ein Beispiel für eine Endpunktrichtlinie für die MemoryDB-API. Wenn diese Richtlinie an einen Endpunkt angehängt ist, gewährt sie allen Prinzipalen auf allen Ressourcen Zugriff auf die aufgelisteten MemoryDB-API-Aktionen.
```
{
"Statement": [{
"Principal": "*",
"Effect": "Allow",
"Action": [
"memorydb:CreateCluster",
"memorydb:UpdateCluster",
"memorydb:CreateSnapshot"
],
"Resource": "*"
}]
}
```
**Example VPC-Endpunktrichtlinie, die jeglichen Zugriff von einem bestimmten Konto aus verweigert AWS**
Die folgende VPC-Endpunktrichtlinie verweigert dem AWS Konto *123456789012* jeglichen Zugriff auf Ressourcen, die den Endpunkt verwenden. Die Richtlinie erlaubt alle Aktionen von anderen Konten.
```
{
"Statement": [{
"Action": "*",
"Effect": "Allow",
"Resource": "*",
"Principal": "*"
},
{
"Action": "*",
"Effect": "Deny",
"Resource": "*",
"Principal": {
"AWS": [
"123456789012"
]
}
}
]
}
```
# Common Vulnerabilities and Exposures (CVE): Sicherheitslücken, die in MemoryDB behoben wurden
Common Vulnerabilities and Exposures (CVE) ist eine Liste von Einträgen für öffentlich bekannte Cybersicherheitsschwachstellen. Jeder Eintrag ist ein Link, der eine Identifikationsnummer, eine Beschreibung und mindestens eine öffentliche Referenz enthält. Auf dieser Seite finden Sie eine Liste von Sicherheitslücken, die in MemoryDB behoben wurden.
Wir empfehlen, immer auf die neuesten MemoryDB-Versionen zu aktualisieren, um vor bekannten Sicherheitslücken geschützt zu sein. MemoryDB macht die PATCH-Komponente verfügbar. PATCH-Versionen sind für abwärtskompatible Bugfixes, Sicherheitskorrekturen und nicht funktionale Änderungen vorgesehen.
Anhand der folgenden Tabelle können Sie überprüfen, ob eine bestimmte Version von MemoryDB einen Fix für eine bestimmte Sicherheitslücke enthält. Wenn Ihr MemoryDB-Cache auf ein Service-Update wartet, ist er möglicherweise anfällig für eine der unten aufgeführten Sicherheitslücken. Wir empfehlen Ihnen, das Service-Update zu installieren. Weitere Informationen zu den unterstützten Versionen der MemoryDB-Engine und zur Durchführung eines Upgrades finden Sie unter. [Engine-Versionen](engine-versions.md)
**Anmerkung**
Wenn ein CVE in einer MemoryDB-Version adressiert wird, bedeutet dies, dass es auch in den neueren Versionen adressiert wird.
Ein Sternchen (\$1) in der folgenden Tabelle gibt an, dass Sie das neueste Service-Update für den MemoryDB-Cluster installiert haben müssen, auf dem die angegebene Version ausgeführt wird, um die Sicherheitslücke zu schließen. Weitere Informationen darüber, wie Sie überprüfen können, ob Sie das neueste Dienstupdate für die MemoryDB-Version installiert haben, auf der Ihr Cluster ausgeführt wird, finden Sie unter. [Verwalten der Service-Updates](managing-updates.md)
| MemoryDB-Version | CVEs Adressiert |
| --- | --- |
| Valkey 7.3 und alle früheren Versionen von Valkey Redis OSS 7.1 und alle früheren Versionen von Redis OSS | [CVE-2025-49844 \$1, CVE-2025-46817 \$1, CVE-2025-46818](https://www.cve.org/CVERecord?id=CVE-2025-49844) [https://www.cve.org/CVERecord?id=CVE-2025-46817](https://www.cve.org/CVERecord?id=CVE-2025-46817) |
| Valkey 7.2 und 7.3 | [CVE-2025-21607 \$1, CVE-2025-21605 \$1, CVE-2024-31449](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2025-21607) [\$1, CVE-2024-31227 \$1, CVE-2024-31228](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2025-21605) [https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-31449](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-31449) |
| Tal 7.2.7 | [CVE-2024-51741](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-51741) |
| Redis OSS 7.1 und 6.2 | [CVE-2025-21605 \$1, CVE-2024-31449](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2025-21605) [https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-31227](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-31227) |
| Redis OS 7.0.7 | [CVE-2023-41056 \$1](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-41056) |
| Redis OS 6.2.7 | [CVE-2024-46981](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-46981) |
| Redis OS 6.2.6 | [CVE-2023-24834 \$1, CVE-2022-35977 \$1, CVE-2023-36021](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-24834) [https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-35977](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-35977) [CVE-2023-45145](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-45145): Beachten Sie, dass dieser CVE in Redis OSS 6.2 und 7.0 behoben wurde, aber nicht in Redis OSS 7.1. |
| Redis OSS 6.0.5 | [https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-24735](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-24735) |
# Dienstupdates in MemoryDB
MemoryDB überwacht automatisch Ihre Flotte von Clustern und Knoten, um Service-Updates zu installieren, sobald diese verfügbar sind. In der Regel richten Sie ein vordefiniertes Wartungsfenster ein, damit MemoryDB diese Updates anwenden kann. In einigen Fällen könnte dieser Ansatz jedoch zu starr sein und möglicherweise Ihre Geschäftsabläufe einschränken.
Mit steuern Sie[Dienstupdates in MemoryDB](#service-updates), wann und welche Updates angewendet werden. Sie können den Fortschritt dieser Updates für Ihren ausgewählten MemoryDB-Cluster auch in Echtzeit überwachen.
# Verwalten der Service-Updates
MemoryDB-Dienstupdates werden regelmäßig veröffentlicht. Wenn Sie über einen oder mehrere qualifizierende Cluster für diese Service-Updates verfügen, erhalten Sie Benachrichtigungen per E-Mail, SNS, Personal Health Dashboard (PHD) und über CloudWatch Amazon-Events, wenn die Updates veröffentlicht werden. Die Updates werden auch auf der Seite **Service Updates** in der MemoryDB-Konsole angezeigt. Mithilfe dieses Dashboards können Sie alle Service-Updates und deren Status für Ihre MemoryDB-Flotte einsehen.
Sie legen fest, wann ein Update angewendet wird, bevor ein automatisches Update gestartet wird. Wir empfehlen dringend, dass Sie alle Updates des Typs **Sicherheitsupdate** so schnell wie möglich installieren, um sicherzustellen, dass Ihre MemoryDB immer über aktuelle Sicherheitspatches verfügt. up-to-date
In den folgenden Abschnitten werden diese Optionen ausführlich erörtert.
**Topics**
+ [
## Überblick über verwaltete Wartungs- und Service-Updates von Amazon MemoryDB
](#managing-updates-maintenance)
## Überblick über verwaltete Wartungs- und Service-Updates von Amazon MemoryDB
Wir aktualisieren unsere MemoryDB-Flotte regelmäßig, wobei Patches und Upgrades nahtlos auf die Instanzen angewendet werden. Wir tun dies auf eine der beiden Arten:
1. Kontinuierliche verwaltete Wartung.
1. Aktualisierungen der Dienste.
Diese Wartungs- und Serviceupdates sind erforderlich, um Upgrades durchzuführen, die die Sicherheit, Zuverlässigkeit und Betriebsleistung verbessern.
Kontinuierliche verwaltete Wartung erfolgt von Zeit zu Zeit und direkt in Ihren Wartungsfenstern, ohne dass Sie Maßnahmen ergreifen müssen. Es ist wichtig zu beachten, dass Wartungsfenster für alle Kunden verpflichtend sind und dass Sie nicht die Möglichkeit haben, sich abzumelden. Wir empfehlen dringend, kritische oder wichtige Aktivitäten während dieser festgelegten Wartungsfenster zu vermeiden. Bitte beachten Sie außerdem, dass wichtige Updates nicht übersprungen werden können, um die Sicherheit und optimale Leistung des Systems zu gewährleisten.
Service-Updates bieten Ihnen die Flexibilität, sie selbst anzuwenden. Sie sind zeitlich begrenzt und können in das Wartungsfenster verschoben werden, damit wir sie nach Ablauf ihres Fälligkeitsdatums anwenden können.
Sie können Updates verwalten, indem Sie sie so schnell wie möglich installieren oder indem Sie Knoten austauschen, da Updates automatisch angewendet werden, wenn sie ausgetauscht werden. Während der eingehenden Wartungsfenster findet keine Aktualisierungsaktivität statt, wenn die Updates auf allen Knoten vor ihnen installiert wurden.
### Service-Updates
[Dienstupdates in MemoryDB](service-updates.md)ermöglichen es Ihnen, bestimmte Service-Updates nach eigenem Ermessen anzuwenden. Bei diesen Updates kann es sich um folgende Typen handeln: Sicherheitspatches oder kleinere Softwareupdates. Diese Updates tragen dazu bei, die Sicherheit, Zuverlässigkeit und Betriebsleistung Ihrer Cluster zu verbessern.
Der Vorteil dieser Service-Updates besteht darin, dass Sie kontrollieren können, wann das Update installiert werden soll (z. B. können Sie die Installation von Service-Updates verzögern, wenn es ein wichtiges Geschäftsereignis gibt, das die Verfügbarkeit von MemoryDB-Clustern rund um die Uhr erfordert).
Wenn Sie über einen oder mehrere qualifizierende Cluster für diese Service-Updates verfügen, erhalten Sie Benachrichtigungen per E-Mail, [Amazon SNS](mdbevents.sns.md), [AWS Health Dashboard](https://docs.aws.amazon.com/health/latest/ug/getting-started-health-dashboard.html) und [Amazon CloudWatch Events-Events](monitoring-cloudwatch.md), wenn die Updates veröffentlicht werden. Die Updates werden auch auf der Seite **Service Updates** in der MemoryDB-Konsole angezeigt. Mithilfe dieses Dashboards können Sie alle Service-Updates und deren Status für Ihre MemoryDB-Flotte einsehen.
Sie legen fest, wann ein Update angewendet wird, bevor ein automatisches Update gestartet wird. Wir empfehlen dringend, dass Sie alle Updates des Typs Sicherheitsupdate so schnell wie möglich installieren, um sicherzustellen, dass Ihre MemoryDB immer über aktuelle Sicherheitspatches verfügt. up-to-date
Ihr Cluster kann Teil verschiedener Service-Updates sein. Bei den meisten Updates müssen Sie sie nicht separat anwenden. Wenn Sie ein Update auf Ihren Cluster anwenden, werden die anderen Updates, sofern zutreffend, als abgeschlossen markiert. Möglicherweise müssen Sie mehrere Updates separat auf denselben Cluster anwenden, wenn der Status nicht automatisch auf „abgeschlossen“ wechselt.
#### Auswirkungen und Ausfallzeiten von Service-Updates
Wenn Sie oder Amazon MemoryDB ein Service-Update auf einen oder mehrere MemoryDB-Cluster anwenden, wird das Update auf nicht mehr als einen Knoten gleichzeitig innerhalb jedes Shards angewendet, bis alle ausgewählten Cluster aktualisiert sind. Bei den Knoten, die aktualisiert werden, kommt es zu Ausfallzeiten von einigen Sekunden, während der Rest des Clusters weiterhin den Datenverkehr bedient.
+ An der Clusterkonfiguration wird sich nichts ändern.
+ Sie werden eine Verzögerung bei Ihren CloudWatch Kennzahlen feststellen, die so schnell wie möglich aufholen.
**Wie wirkt sich ein Knotenaustausch auf meine Anwendung aus?** - Bei MemoryDB-Knoten ist der Austauschprozess darauf ausgelegt, Haltbarkeit und Verfügbarkeit zu gewährleisten. Bei MemoryDB-Clustern mit einem Knoten erstellt MemoryDB dynamisch ein Replikat, stellt Daten aus unseren Durability-Komponenten wieder her und führt dann ein Failover darauf durch. Bei Replikationsgruppen, die aus mehreren Knoten bestehen, ersetzt MemoryDB die vorhandenen Replikate und synchronisiert Daten aus unseren Durability-Komponenten mit den neuen Replikaten. MemoryDB ist nur dann Multi-AZ verfügbar, wenn es mehr als einen Knoten gibt. In diesem Szenario löst der Austausch des Primärknotens also einen Failover auf eine Read Replica aus. Die geplanten Knotenersetzungen werden abgeschlossen, während der Cluster eingehende Schreibanforderungen bearbeitet. Wenn es nur einen Knoten gibt, ersetzt MemoryDB den primären und synchronisiert dann die Daten aus unseren Durability-Komponenten. Der primäre Knoten ist während dieser Zeit nicht verfügbar, was zu längeren Schreibunterbrechungen führt.
**Welche bewährten Methoden sollte ich befolgen, um einen reibungslosen Austausch zu gewährleisten und den Datenverlust zu minimieren?** - In MemoryDB sind Daten äußerst robust, und Datenverlust ist selbst bei Implementierungen mit einem Knoten nicht zu erwarten. Es wird jedoch empfohlen, Multi-AZ- und Backup-Strategien zu implementieren, um das Risiko eines Verlusts im unwahrscheinlichen Fall eines Ausfalls zu minimieren. Für einen reibungslosen Austausch versuchen wir, jeweils nur so viele Knoten aus demselben Cluster zu ersetzen, dass der Cluster stabil bleibt. Sie können Primär- und Lesereplikate in verschiedenen Availability Zones bereitstellen, indem Sie Multi-AZ aktivieren. In diesem Fall erfolgt beim Austausch eines Knotens ein Failover der primären Rolle auf ein Replikat im Shard. Dieser Shard wird nun für den Datenverkehr verwendet, und die Daten werden aus ihren Bestandteilen für die Haltbarkeit wiederhergestellt. Wenn Ihre Konfiguration nur ein primäres und ein einzelnes Replikat pro Shard umfasst, empfehlen wir, vor dem Patchen weitere Replikate hinzuzufügen. Dadurch wird eine verringerte Verfügbarkeit während des Patchvorgangs verhindert. Wir empfehlen, den Austausch für einen Zeitraum mit geringem eingehenden Schreibverkehr zu planen.
**Welche Best Practices für die Client-Konfiguration sollte ich befolgen, um Anwendungsunterbrechungen während der Wartung so gering wie möglich zu halten?** - In MemoryDB ist die Konfiguration im Clustermodus immer aktiviert, wodurch die beste Verfügbarkeit bei verwalteten oder nicht verwalteten Vorgängen gewährleistet wird. Die einzelnen Knotenendpunkte der Replikatknoten können für alle Lesevorgänge verwendet werden. In MemoryDB ist Auto-Failover im Cluster immer aktiviert, was bedeutet, dass sich der primäre Knoten ändern kann. Daher sollte die Anwendung die Rolle des Knotens bestätigen und alle Lese-Endpunkte aktualisieren, um sicherzustellen, dass Sie den primären Knoten nicht zu stark belasten. Vermeiden Sie außerdem, die Replikate während der Wartungsfenster mit Leseanforderungen zu überlasten. Eine Möglichkeit, dies zu erreichen, besteht darin, sicherzustellen, dass Sie über mindestens zwei Read Replicas verfügen, um Unterbrechungen beim Lesen während der Wartung zu vermeiden.
Es ist wichtig, Client-Anwendungen zu testen, um sicherzustellen, dass sie dem Redis/Valkey Cluster-Protokoll entsprechen, damit Anfragen ordnungsgemäß zwischen den Knoten umgeleitet werden können. Es ist ratsam, Back-off- und Wiederholungsstrategien zu implementieren, um eine Überlastung der MemoryDB-Knoten bei Wartungs- und Austauschaktivitäten zu vermeiden.
**Neuplanung** [— Sie können das Service-Update verschieben, indem Sie das Wartungsfenster ändern.](maintenance-window.md) Das geplante Update wird nur dann auf den Cluster angewendet, wenn das geplante Datum mit dem Wartungsfenster des Clusters übereinstimmt. Sobald Sie das Wartungsfenster geändert haben und das geplante Datum verstrichen ist, wird das Service-Update in den folgenden Wochen auf das neu festgelegte Fenster verschoben. Sie erhalten eine Woche vor Erreichen des neuen Datums eine neue Benachrichtigung.
Sicherheit bei AWS ist eine gemeinsame Verantwortung. Wir empfehlen dringend, dass Sie das Update frühestens installieren.
**Abmeldung von Service-Updates** — Sie können feststellen, ob Sie sich von einem Service-Update abmelden können, indem Sie den Wert des Attributs „Startdatum der automatischen Aktualisierung“ überprüfen. Wenn der Wert des Attributs „Startdatum der automatischen Aktualisierung“ eines Service-Updates festgelegt ist, plant MemoryDB das Service-Update für alle verbleibenden Cluster für das bevorstehende Wartungsfenster. Eine Abmeldung ist nicht möglich. Wenn Sie das Service-Update jedoch vor dem Wartungsfenster auf die verbleibenden Cluster anwenden, wird MemoryDB das Service-Update während des Wartungsfensters nicht erneut anwenden. Weitere Informationen finden Sie unter [Anwenden der Service-Updates](applying-updates.md).
**Warum können die Service-Updates während der Wartungsfenster nicht direkt von MemoryDB installiert werden?** - Bitte beachten Sie, dass der Zweck von Service-Updates darin besteht, Ihnen die Flexibilität zu geben, wann sie installiert werden sollen. Cluster, die nicht an den von MemoryDB unterstützten [Compliance-Programmen](memorydb-compliance.md) teilnehmen, können sich dafür entscheiden, diese Updates nicht oder nur in reduzierter Häufigkeit im Laufe des Jahres anzuwenden. Es wird jedoch empfohlen, die Updates zu installieren, um die Einhaltung der Vorschriften zu gewährleisten. Dies gilt nur, wenn der Wert des Attributs „Startdatum der automatischen Aktualisierung“ eines Dienstupdates nicht vorhanden ist. Weitere Informationen finden Sie unter [Konformitätsprüfung für MemoryDB](memorydb-compliance.md).
**Inwiefern unterscheiden sich Updates, die im Wartungsfenster angewendet werden, von den Service-Updates?** - Updates, die im Rahmen der kontinuierlichen verwalteten Wartung vorgenommen werden, werden direkt in Ihren Wartungsfenstern geplant, ohne dass Sie etwas unternehmen müssen. Service-Updates werden zeitlich festgelegt und geben Ihnen die Kontrolle darüber, wann Sie sie bis zum „Startdatum für automatische Updates“ beantragen möchten. Wenn sie bis dahin immer noch nicht installiert sind, kann MemoryDB diese Updates in Ihrem Wartungsfenster einplanen.
### Kontinuierliche verwaltete Wartungsupdates
Diese Updates sind verpflichtend und werden direkt in Ihren Wartungsfenstern angewendet, ohne dass Sie etwas unternehmen müssen. Diese Updates unterscheiden sich von denen, die durch Service-Updates angeboten werden.
#### Kontinuierliche Auswirkungen auf Wartungsarbeiten und Ausfallzeiten
**Wie lange dauert der Austausch eines Knotens?** - Ein Austausch ist in der Regel innerhalb von 30 Minuten abgeschlossen. Der Austausch kann bei bestimmten Instanzkonfigurationen und Datenverkehrsmustern länger dauern.
**Wie wirkt sich ein Knotenaustausch auf meine Anwendung aus?** - Kontinuierliche verwaltete Wartungsupdates werden auf die gleiche Weise wie „Service-Updates“ angewendet, indem Knoten ausgetauscht werden. Einzelheiten finden Sie oben im Abschnitt Auswirkungen von Service-Updates und Ausfallzeiten.
**Wie verwalte ich den Austausch von Knoten selbst?** — Sie haben die Möglichkeit, diese Austauschvorgänge jederzeit vor Ablauf des geplanten Zeitfensters für den Knotenaustausch selbst zu verwalten. Wenn Sie sich dafür entscheiden, den Austausch selbst zu verwalten, können Sie je nach Anwendungsfall verschiedene Maßnahmen ergreifen.
+ [Ersetzen Sie einen Knoten im Cluster durch einen oder mehrere Shards](nodes.nodereplacement.md)[: Sie können entweder [Backup und Wiederherstellung](snapshots-restoring.md) oder Scale-Out verwenden, gefolgt von einem Scale-In, um die Knoten zu ersetzen.](cluster-resharding-online.md)
+ [Ändern Sie Ihr Wartungsfenster](maintenance-window.md): Sie können auch das Wartungsfenster Ihres Clusters ändern. Um Ihr Wartungsfenster später auf einen günstigeren Zeitpunkt zu ändern, können Sie die [UpdateCluster API](clusters.modify.md) oder die [Update-Cluster-CLI](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) verwenden oder in der MemoryDB Management [Console auf Modify](clusters.modify.md) klicken. Sobald Sie Ihr Wartungsfenster geändert haben, plant MemoryDB die Wartung Ihres Knotens für das neu festgelegte Fenster ein.
Um zu sehen, wie das in der Praxis funktioniert, nehmen wir an, es ist derzeit Donnerstag, der 11.09., um 15:00 Uhr und das nächste Wartungsfenster ist Freitag, der 10. November, um 17:00 Uhr. Hier sind 3 Szenarien:
+ Sie ändern Ihr Wartungsfenster auf Freitag um 16:00 Uhr (nach dem aktuellen Datum und vor dem nächsten geplanten Wartungsfenster). Der Knoten wird am Freitag den 10. November um 16:00 Uhr ersetzt.
+ Sie ändern Ihr Wartungsfenster auf Samstag um 16:00 Uhr (nach dem aktuellen Datum und nach dem nächsten geplanten Wartungsfenster). Der Knoten wird am Samstag den 11. November um 16:00 Uhr ersetzt.
+ Sie ändern Ihr Wartungsfenster auf Mittwoch um 16:00 Uhr (früher in der Woche als die aktuelle Uhrzeit). Der Knoten wird am Mittwoch den 15. November um 16:00 Uhr ersetzt.
Weitere Informationen finden Sie unter [Verwaltung der Wartung](maintenance-window.md).
Bitte beachten Sie, dass die Knoten in verschiedenen Clustern aus verschiedenen Regionen gleichzeitig ausgetauscht werden können, sofern Ihr Wartungsfenster für diese Cluster so konfiguriert ist, dass es dasselbe ist.
**Wie erfahre ich von bevorstehenden geplanten Ersatzlieferungen?** - Sie sollten eine Gesundheitsbenachrichtigung auf dem AWS Gesundheits-Dashboard erhalten. Außerdem können Sie den Status verschiedener Service-Upgrades mit der DescribeServiceUpdates API abrufen. Bitte beachten Sie, dass wir alle Anstrengungen unternehmen, um Kunden proaktiv über absehbare Ersatzlieferungen zu informieren. In Ausnahmefällen wie unvorhersehbaren Ausfällen kann es jedoch zu unangekündigten Ersatzlieferungen kommen.
**Kann ich die geplante Wartung zu einem geeigneteren Zeitpunkt ändern?** - Ja, Sie können die geplante Wartung auf einen geeigneteren Zeitpunkt verschieben, indem Sie das [Wartungsfenster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeServiceUpdates.html) ändern.
**Warum führen Sie diese Knotenersetzungen durch?** - Diese Ersetzungen sind erforderlich, um obligatorische Softwareupdates auf Ihrem zugrunde liegenden Host anzuwenden. Die Updates tragen dazu bei, unsere Sicherheit, Zuverlässigkeit und Betriebsleistung zu verbessern.
**Wirken sich diese Ersetzungen gleichzeitig auf meine Knoten in mehreren Availability Zones und Clustern aus verschiedenen Regionen aus?** - Ersatzprodukte können in mehreren Availability Zones oder Regionen parallel ausgeführt werden, abhängig vom Wartungsfenster für Cluster.
# Anwenden der Service-Updates
Sie können die Service-Updates auf Ihre Flotte anwenden, sobald diese Updates den Status **available** (Verfügbar) haben. Service-Updates sind kumulativ. Das bedeutet, dass bisher nicht angewendete Updates im neuesten Update enthalten sind.
Wenn für ein Service-Update die automatische Aktualisierung aktiviert ist, können Sie festlegen, dass keine Maßnahmen ergriffen werden, wenn es verfügbar ist. **MemoryDB plant, das Update während des Wartungsfensters Ihrer Cluster nach dem Startdatum der automatischen Aktualisierung anzuwenden.** Sie erhalten entsprechende Benachrichtigungen für jede Stufe des Updates.
**Anmerkung**
Sie können nur die Service-Updates anwenden, die über den Status **verfügbar** oder **geplant** verfügen.
Weitere Informationen zur Überprüfung und Installation von dienstspezifischen Updates auf entsprechende MemoryDB-Cluster finden Sie unter. [Anwenden der Service-Updates mithilfe der Konsole](#applying-updates-console-APIReferenceconsole)
Wenn ein neues Service-Update für einen oder mehrere Ihrer MemoryDB-Cluster verfügbar ist, können Sie die MemoryDB-Konsole, die API oder verwenden, um das Update anzuwenden. AWS CLI Die folgenden Abschnitte beschreiben die Optionen, die zum Anwenden von Updates genutzt werden können.
## Anwenden der Service-Updates mithilfe der Konsole
Um die Liste der Service-Updates und weitere Informationen anzuzeigen, gehen Sie zur Seite **Service-Updates** in der Konsole.
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. Klicken Sie im Navigationsbereich auf **Service-Updates**.
Unter **Details zum Service-Update** können Sie Folgendes einsehen:
+ **Name des Service-Updates**: Der eindeutige Name des Service-Updates
+ **Beschreibung des Updates**: Detaillierte Informationen zum Service-Update
+ **Startdatum für automatische Aktualisierung**: Wenn dieses Attribut gesetzt ist, beginnt MemoryDB damit, Ihre Cluster so zu planen, dass sie nach diesem Datum in den entsprechenden Wartungsfenstern automatisch aktualisiert werden. **Sie erhalten im Voraus Benachrichtigungen über das genaue geplante Wartungsfenster, das möglicherweise nicht unmittelbar nach dem Startdatum der automatischen Aktualisierung liegt.** Sie können das Update trotzdem jederzeit auf Ihre Cluster anwenden. Wenn das Attribut nicht gesetzt ist, ist das Service-Update nicht automatisch aktualisiert und MemoryDB aktualisiert Ihre Cluster nicht automatisch.
Im Abschnitt **Cluster update status** (Cluster-Aktualisierungsstatus) können Sie eine Liste von Clustern anzeigen, auf denen das Service-Update nicht oder erst kürzlich angewendet wurde. Für jeden Cluster können Sie Folgendes anzeigen:
+ **Cluster-Name** – Der Name des Clusters
+ **Nodes Updated (Aktualisierte Knoten)**: Verhältnis der individuellen Knoten in einem bestimmten Cluster, die aktualisiert wurden bzw. weiterhin für das betreffende Service-Update verfügbar sind.
+ **Aktualisierungs-Typ**: Typ des Service-Updates, also einer der folgenden Werte: **security-update** oder **engine-update**
+ **Status**: Status des Service-Updates auf dem Cluster, also einer der folgenden Werte:
+ *verfügbar*: Das Update ist für die relevanten Cluster verfügbar.
+ *in Bearbeitung*: Das Update wird gerade auf diesen Cluster angewendet.
+ *scheduled (geplant)*: Das Aktualisierungsdatum wurde geplant.
+ *complete (abgeschlossen)*: Das Update wurde erfolgreich angewendet. Cluster mit dem Status „Abgeschlossen“ werden nach Abschluss 7 Tage lang angezeigt.
Wenn Sie einen oder alle Cluster mit dem Status **verfügbar** oder **geplant** auswählen und dann auf **Apply now** (Jetzt anwenden) klicken, wird das Update auf diesen Clustern angewendet.
## Anwenden der Dienstupdates mit dem AWS CLI
Nachdem Sie benachrichtigt wurden, dass Service-Updates verfügbar sind, können Sie sie mit der AWS CLI inspizieren und anwenden:
+ Führen Sie den folgenden Befehl aus, um eine Beschreibung der verfügbaren Serviceaktualisierungen abzurufen:
`aws memorydb describe-service-updates --status available`
Weitere Informationen finden Sie unter [describe-service-updates](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-service-updates.html).
+ Führen Sie den folgenden Befehl aus, um ein Service-Update auf eine Liste von Clustern anzuwenden:
`aws memorydb batch-update-cluster --service-update ServiceUpdateNameToApply=sample-service-update --cluster-names cluster-1 cluster2`
Weitere Informationen finden Sie unter [batch-update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/batch-update-cluster.html).