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. # Datensicherheit bei Amazon ElastiCache Um Ihre Daten zu schützen, EC2 bieten Amazon ElastiCache und Amazon Mechanismen zum Schutz vor unbefugtem Zugriff auf Ihre Daten auf dem Server. Amazon ElastiCache for Memcached bietet Verschlüsselungsfunktionen für Daten in Caches, auf denen Memcached-Versionen 1.6.12 oder höher ausgeführt werden. Amazon ElastiCache mit Valkey und Redis OSS bietet Verschlüsselungsfunktionen für Daten in Caches, auf denen Valkey 7.2 oder höher ausgeführt wird, und Redis OSS-Versionen 3.2.6 (für EOL geplant, siehe Zeitplan für das [Ende des Lebenszyklus der Redis OSS-Versionen](engine-versions.md#deprecated-engine-versions)), 4.0.10 oder höher. Amazon unterstützt ElastiCache auch die Authentifizierung von Benutzern mit IAM oder Valkey und Redis OSS AUTH sowie die Autorisierung von Benutzervorgängen mithilfe von Role-Based Access Control (RBAC). + 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 Cache und Ihrer Anwendung, verschlüsselt. + Bei der Verschlüsselung im Ruhezustand werden Ihre Daten auf dem Laufwerk bei Synchronisierungs- und Sicherungsoperationen verschlüsselt. ElastiCache unterstützt die Authentifizierung von Benutzern mithilfe von IAM und den Befehlen Valkey und Redis OSS AUTH sowie die Autorisierung von Benutzervorgängen mithilfe von Role-Based Access Control (RBAC). ![\[ElastiCache Bild: für Valkey und Redis OSS-Sicherheitsdiagramm\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/ElastiCache-Redis-Secure-Compliant.png) *ElastiCache für das OSS-Sicherheitsdiagramm von Valkey und Redis* **Topics** + [ElastiCache Verschlüsselung bei der Übertragung (TLS)](in-transit-encryption.md) + [Verschlüsselung im Ruhezustand in ElastiCache](at-rest-encryption.md) + [Authentifizierung und Autorisierung](auth-redis.md) # ElastiCache Verschlüsselung bei der Übertragung (TLS) Um Ihre Daten zu schützen, EC2 bieten Amazon ElastiCache und Amazon Mechanismen zum Schutz vor unbefugtem Zugriff auf Ihre Daten auf dem Server. Durch die Bereitstellung von Verschlüsselungsfunktionen während der Übertragung ElastiCache erhalten Sie ein Tool, mit dem Sie Ihre Daten schützen können, wenn sie von einem Ort zum anderen übertragen werden. In allen serverlosen Valkey- oder Redis OSS-Caches ist die Verschlüsselung bei der Übertragung aktiviert. Für knotenbasierte Cluster können Sie die Verschlüsselung während der Übertragung für eine Replikationsgruppe aktivieren, indem Sie den Parameter `TransitEncryptionEnabled` auf `true` (CLI:`--transit-encryption-enabled`) setzen, wenn Sie die Replikationsgruppe erstellen. Sie können dies unabhängig davon tun, ob Sie die Replikationsgruppe mithilfe der AWS-Managementkonsole, der oder der API AWS CLI erstellen. ElastiCache Für alle Serverless-Caches ist die Verschlüsselung während der Übertragung aktiviert. Für knotenbasierte Cluster können Sie die Verschlüsselung während der Übertragung auf einem Cluster aktivieren, indem Sie den Parameter `TransitEncryptionEnabled` auf `true` (CLI:`--transit-encryption-enabled`) setzen, wenn Sie den Cluster mit dem Vorgang `CreateCacheCluster` (CLI:`create-cache-cluster`) erstellen. **Topics** + [Übersicht über die Verschlüsselung während der Übertragung](#in-transit-encryption-overview) + [Verschlüsselungsbedingungen bei der Übertragung (Valkey und Redis OSS)](#in-transit-encryption-constraints) + [Verschlüsselungsbedingungen bei der Übertragung (Memcached)](#in-transit-encryption-constraints) + [Bewährte Methoden für die Verschlüsselung während der Übertragung](#in-transit-encryption-best-practices) + [Weitere OSS-Optionen von Valkey und Redis](#in-transit-encryption-see-also) + [Aktivierung der Verschlüsselung bei der Übertragung für Memcached](#in-transit-encryption-enable-existing-mc) + [Aktivieren von Verschlüsselung während der Übertragung](in-transit-encryption-enable.md) + [Verbindung zu ElastiCache (Valkey) oder Amazon ElastiCache for Redis OSS mit Verschlüsselung während der Übertragung mithilfe von Valkey-CLI herstellen](connect-tls.md) + [Aktivierung der Verschlüsselung während der Übertragung auf einem knotenbasierten Redis-OSS-Cluster mithilfe von Python](in-transit-encryption-enable-python.md) + [Bewährte Methoden für die Aktivierung der Verschlüsselung während der Übertragung](enable-python-best-practices.md) + [Mit Openssl (Memcached) wird eine Verbindung zu Knoten hergestellt, für die Verschlüsselung während der Übertragung aktiviert ist](#in-transit-encryption-connect-mc) + [Erstellen eines TLS-Memcached-Clients mit Java](#in-transit-encryption-connect-java) + [Erstellen eines TLS-Memcached-Clients mit PHP](#in-transit-encryption-connect-php-mc) ## Übersicht über die Verschlüsselung während der Übertragung Die ElastiCache Amazon-Verschlüsselung bei der Übertragung ist eine Funktion, mit der Sie die Sicherheit Ihrer Daten an den anfälligsten Stellen erhöhen können — wenn sie von einem Ort zum anderen übertragen werden. Da für die Verschlüsselung und Entschlüsselung der Daten an den Endpunkten eine gewisse Verarbeitung erforderlich ist, kann die Aktivierung der Verschlüsselung während der Übertragung einige Performance-Einbußen zufolge haben. Sie sollten Benchmark-Tests Ihrer Daten mit und ohne Verschlüsselung während der Übertragung durchführen, um die Performance-Einbußen bei Ihren Anwendungsfällen zu bestimmen. ElastiCache Die Verschlüsselung bei der Übertragung implementiert die folgenden Funktionen: + **Verschlüsselte Client-Verbindungen** – Client-Verbindungen mit Cache-Knoten sind TLS-verschlüsselt. + **Verschlüsselte Serververbindungen** – Daten, die zwischen Knoten in einem Cluster übertragen werden, sind verschlüsselt. + **Serverauthentifizierung** – Clients können die Verbindung zum richtigen Server authentifizieren. + **Client-Authentifizierung** — Mithilfe der Funktionen Valkey und Redis OSS AUTH kann der Server die Clients authentifizieren. ## Verschlüsselungsbedingungen bei der Übertragung (Valkey und Redis OSS) Bei der Planung Ihrer knotenbasierten ElastiCache Cluster-Implementierung sollten Sie die folgenden Einschränkungen der In-Transit-Verschlüsselung von Amazon berücksichtigen: + Die Verschlüsselung während der Übertragung wird für Replikationsgruppen unterstützt, auf denen Valkey 7.2 und höher sowie die Redis OSS-Versionen 3.2.6, 4.0.10 und höher ausgeführt werden. + Das Ändern der Verschlüsselungseinstellung bei der Übertragung für einen vorhandenen Cluster wird für Replikationsgruppen unterstützt, auf denen Valkey 7.2 und höher sowie Redis OSS Version 7 und höher ausgeführt wird. + Die Verschlüsselung während der Übertragung wird nur für Replikationsgruppen unterstützt, die in einer Amazon VPC ausgeführt werden. + Die Verschlüsselung während der Übertragung wird für Replikationsgruppen, auf denen die folgenden Knotentypen ausgeführt werden, nicht unterstützt: M1, M2. Weitere Informationen finden Sie unter [Unterstützte Knotentypen](CacheNodes.SupportedTypes.md). + Verschlüsselung während der Übertragung wird durch die Festlegung des `TransitEncryptionEnabled`-Parameters auf `true` ausdrücklich aktiviert. + Stellen Sie sicher, dass Ihr Caching-Client TLS-Konnektivität unterstützt und dass Sie diese in der Client-Konfiguration aktiviert haben. + Ab dem 26. Januar 2026 AWS wird die unterstützte Mindestversion von TLS ElastiCache für Valkey Version 7.2 und höher sowie ElastiCache für Redis OSS Version 6 und höher auf 1.2 aktualisiert. Kunden müssen ihre Client-Software vor diesem Datum aktualisieren. Dieses Update hilft Ihnen dabei, Sicherheits-, Compliance- und behördliche Anforderungen zu erfüllen. ## Verschlüsselungsbedingungen bei der Übertragung (Memcached) Bei der Planung Ihrer knotenbasierten ElastiCache Cluster-Implementierung sollten Sie die folgenden Einschränkungen der In-Transit-Verschlüsselung von Amazon berücksichtigen: + Verschlüsselung während der Übertragung wird auf Clustern mit der Memcached-Version 1.6.12 und höher unterstützt. + Verschlüsselung während der Übertragung unterstützt die Transport-Layer-Security(TLS)-Versionen 1.2 und 1.3. + Die Verschlüsselung während der Übertragung wird nur für Cluster unterstützt, die in einer Amazon VPC ausgeführt werden. + Die Verschlüsselung während der Übertragung wird für Replikationsgruppen, auf denen die folgenden Knotentypen ausgeführt werden, nicht unterstützt: M1, M2, M3, R3, T2. Weitere Informationen finden Sie unter [Unterstützte Knotentypen](CacheNodes.SupportedTypes.md). + Verschlüsselung während der Übertragung wird durch die Festlegung des `TransitEncryptionEnabled`-Parameters auf `true` ausdrücklich aktiviert. + Sie können die Verschlüsselung während der Übertragung nur für einen Cluster aktivieren, wenn Sie den Cluster erstellen. Sie können die Verschlüsselung während der Übertragung nicht aktivieren und deaktivieren, indem Sie einen Cluster ändern. + Stellen Sie sicher, dass Ihr Caching-Client TLS-Konnektivität unterstützt und dass Sie diese in der Client-Konfiguration aktiviert haben. ## Bewährte Methoden für die Verschlüsselung während der Übertragung + Aufgrund der für die Verschlüsselung und Entschlüsselung der Daten an den Endpunkten erforderliche Verarbeitung, kann die Implementierung der Verschlüsselung während der Übertragung eine Verringerung der Performance zufolge haben. Führen Sie einen Benchmark-Test der Verschlüsselung während der Übertragung im Vergleich zu keiner Verschlüsselung Ihrer eigenen Daten durch, um deren Auswirkungen auf die Performance Ihrer Implementierung zu ermitteln. + Da der Aufbau neuer Verbindungen kostspielig sein kann, können Sie die Auswirkungen der Verschlüsselung während der Übertragung auf die Leistung verringern, indem Sie Ihre TLS-Verbindungen aufrechterhalten. ## Weitere OSS-Optionen von Valkey und Redis Weitere Informationen zu den für Valkey und Redis OSS verfügbaren Optionen finden Sie unter den folgenden Links. + [Verschlüsselung im Ruhezustand in ElastiCache](at-rest-encryption.md) + [Authentifizierung mit dem Befehl Valkey und Redis OSS AUTH](auth.md) + [Rollenbasierte Zugriffskontrolle (RBAC)](Clusters.RBAC.md) + [Amazon VPCs und ElastiCache Sicherheit](VPCs.md) + [Identity and Access Management für Amazon ElastiCache](IAM.md) ## Aktivierung der Verschlüsselung bei der Übertragung für Memcached Treffen Sie zum Aktivieren der Verschlüsselung während der Übertragung beim Erstellen eines Memcached-Clusters mit der AWS-Managementkonsole die folgende Auswahl: + Wählen Sie Memcached als Ihre Engine. + Wählen Sie die Engine-Version 1.6.12 und höher. + Wählen Sie unter **Encryption in transit** (Verschlüsselung während der Übertragung) **Enable** (Aktivieren) aus. Informationen zum step-by-step Vorgang finden Sie unter. [Einen Cluster für Valkey oder Redis OSS erstellen](Clusters.Create.md) # Aktivieren von Verschlüsselung während der Übertragung Für alle Serverless-Caches ist die Verschlüsselung während der Übertragung aktiviert. In einem knotenbasierten Cluster können Sie die Verschlüsselung während der Übertragung mithilfe der AWS-ManagementkonsoleAWS CLI oder der API aktivieren. ElastiCache ## Aktivieren der Verschlüsselung bei der Übertragung mithilfe der AWS-Managementkonsole ### Aktivieren der Verschlüsselung bei der Übertragung für einen neuen knotenbasierten Cluster mithilfe der AWS-Managementkonsole Wenn Sie einen eigenen Cluster entwerfen, ist bei den Konfigurationen „Dev/Test“ und „Production“ mit der Methode „Easy Create“ die Verschlüsselung während der Übertragung aktiviert. Legen Sie die folgenden Einstellungen fest, wenn Sie die Konfiguration selbst auswählen: + Wählen Sie die Engine-Version 3.2.6, 4.0.10 und höher. + Aktivieren Sie für die Option **Verschlüsselung während der Übertragung** das Kontrollkästchen neben **Aktivieren**. Informationen zum step-by-step Prozess finden Sie im Folgenden: + [Erstellen eines Valkey-Clusters (Cluster-Modus deaktiviert) (Konsole)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs) + [Erstellen eines Valkey- oder Redis OSS-Clusters (Cluster-Modus aktiviert) (Konsole)](Clusters.Create.md#Clusters.Create.CON.RedisCluster) ### Aktivieren der Verschlüsselung bei der Übertragung für einen vorhandenen knotenbasierten Cluster mithilfe der AWS-Managementkonsole Die Aktivierung der Verschlüsselung während der Übertragung ist ein zweistufiger Vorgang. Sie müssen zuerst den Modus der Übertragungsverschlüsselung auf `preferred` festlegen. In diesem Modus können Ihre Valkey- oder Redis OSS-Clients eine Verbindung sowohl über verschlüsselte als auch über unverschlüsselte Verbindungen herstellen. Nachdem Sie alle Ihre Valkey- oder Redis OSS-Clients auf verschlüsselte Verbindungen migriert haben, können Sie Ihre Clusterkonfiguration ändern, um den Übertragungsverschlüsselungsmodus auf einzustellen. `required` Wenn Sie den Modus der Verschlüsselung während der Übertragung auf `required` festlegen, werden alle unverschlüsselten Verbindungen gelöscht und nur verschlüsselte Verbindungen werden zugelassen. ****Stellen Sie Ihren **Transit-Verschlüsselungsmodus** auf Bevorzugt ein**** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Amazon-Konsole unter [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. Wählen Sie **Valkey-Caches** oder **Redis OSS-Caches** aus den ElastiCache **Ressourcen**, die im Navigationsbereich auf der linken Seite angezeigt werden. 1. Wählen Sie den Cache aus, den Sie aktualisieren möchten. 1. Wählen Sie das Dropdown-Menü **Actions** (Aktionen) und dann **Modify** (Ändern) aus. 1. Wählen Sie im Bereich **Sicherheit** unter **Verschlüsselung während der Übertragung** die Option **Aktivieren** aus. 1. Wählen Sie **Preferred** (Bevorzugt) als den **Transit encryption mode** (Modus der Verschlüsselung während der Übertragung) aus. 1. Wählen Sie **Preview changes** (Änderungsvorschau anzeigen) aus und speichern Sie die Änderungen. Nachdem Sie alle Ihre Valkey- oder Redis OSS-Clients migriert haben, um verschlüsselte Verbindungen zu verwenden: ****Stellen Sie Ihren **Transit-Verschlüsselungsmodus** auf Erforderlich**** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Amazon-Konsole unter [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. Wählen Sie **Valkey-Caches** oder **Redis OSS-Caches** aus den ElastiCache **Ressourcen**, die im Navigationsbereich auf der linken Seite angezeigt werden. 1. Wählen Sie den Cache aus, den Sie aktualisieren möchten. 1. Wählen Sie das Dropdown-Menü **Actions** (Aktionen) und dann **Modify** (Ändern) aus. 1. Wählen Sie im Bereich **Security** (Sicherheit) die Option **Required** (Erforderlich) als **Transit encryption mode** (Modus der Verschlüsselung während der Übertragung) aus. 1. Wählen Sie **Preview changes** (Änderungsvorschau anzeigen) aus und speichern Sie die Änderungen. ## Aktivieren Sie die Verschlüsselung bei der Übertragung mit dem AWS CLI Verwenden Sie den Parameter, um die Verschlüsselung während der Übertragung zu aktivieren, wenn Sie eine Valkey- oder Redis OSS-Replikationsgruppe mithilfe von erstellen.AWS CLI`transit-encryption-enabled` ### Aktivierung der Verschlüsselung während der Übertragung auf einem neuen knotenbasierten Cluster für Valkey oder Redis OSS (Clustermodus deaktiviert) (CLI) Verwenden Sie den AWS CLI Vorgang `create-replication-group` und die folgenden Parameter, um eine Valkey- oder Redis OSS-Replikationsgruppe mit Replikaten zu erstellen, für die die Verschlüsselung bei der Übertragung aktiviert ist: **Hauptparameter:** + **--engine**— Muss oder sein. `valkey` `redis` + **--engine-version**—Wenn es sich bei der Engine um Redis OSS handelt, muss es sich um 3.2.6, 4.0.10 oder höher handeln. + **--transit-encryption-enabled**—Erforderlich. Wenn Sie die Verschlüsselung während der Übertragung aktivieren, müssen Sie zudem einen Wert für den `--cache-subnet-group`-Parameter angeben. + **--num-cache-clusters**—Muss mindestens 1 sein. Der Höchstwert für diesen Parameter ist 6. Weitere Informationen finden Sie hier: + [Eine Valkey- oder Redis OSS-Replikationsgruppe (Clustermodus deaktiviert) von Grund auf neu erstellen ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Classic.md#Replication.CreatingReplGroup.NoExistingCluster.Classic.CLI) + [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html) ### Aktivierung der Verschlüsselung während der Übertragung auf einem neuen knotenbasierten Cluster für Valkey oder Redis OSS (Cluster Mode Enabled) (CLI) Verwenden Sie den AWS CLI Vorgang `create-replication-group` und die folgenden Parameter, um eine Valkey- oder Redis OSS-Replikationsgruppe (Clustermodus aktiviert) zu erstellen, für die die Verschlüsselung bei der Übertragung aktiviert ist: **Hauptparameter:** + **--engine**— Muss oder sein. `valkey` `redis` + **--engine-version**—Wenn es sich bei der Engine um Redis OSS handelt, muss es sich um 3.2.6, 4.0.10 oder höher handeln. + **--transit-encryption-enabled**—Erforderlich. Wenn Sie die Verschlüsselung während der Übertragung aktivieren, müssen Sie zudem einen Wert für den `--cache-subnet-group`-Parameter angeben. + Verwenden Sie einen der folgenden Parametersätze, um die Konfiguration der Knotengruppen der Replikationsgruppe anzugeben. + **--num-node-groups**—Zur Angabe der Anzahl der Shards (Knoten-Gruppen) in dieser Replikationsgruppe. Der Höchstwert für diesen Parameter ist 500. **--replicas-per-node-group**—Definiert die Anzahl der Replikat-Knoten in jeder Knotengruppe. Der hier angegebene Wert wird auf allen Shards in dieser Replikationsgruppe angewendet. Der Höchstwert für diesen Parameter ist 5. + **--node-group-configuration**—Spezifiziert die Konfiguration jedes Shards unabhängig. Weitere Informationen finden Sie hier: + [Eine Valkey- oder Redis OSS-Replikationsgruppe (Cluster Mode Enabled) von Grund auf neu erstellen ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI) + [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html) ### Aktivieren der Verschlüsselung während der Übertragung für einen vorhandenen Cluster mithilfe der AWS CLI Die Aktivierung der Verschlüsselung während der Übertragung ist ein zweistufiger Vorgang. Sie müssen zuerst den Modus der Übertragungsverschlüsselung auf `preferred` festlegen. In diesem Modus können Ihre Valkey- oder Redis OSS-Clients Verbindungen sowohl über verschlüsselte als auch über unverschlüsselte Verbindungen herstellen. Nachdem Sie alle Ihre Valkey- oder Redis OSS-Clients auf verschlüsselte Verbindungen migriert haben, können Sie Ihre Clusterkonfiguration ändern, um den Übertragungsverschlüsselungsmodus auf einzustellen. `required` Wenn Sie den Modus der Verschlüsselung während der Übertragung auf `required` festlegen, werden alle unverschlüsselten Verbindungen gelöscht und nur verschlüsselte Verbindungen werden zugelassen. Verwenden Sie den AWS CLI Vorgang `modify-replication-group` und die folgenden Parameter, um eine Valkey- oder Redis OSS-Replikationsgruppe (Clustermodus aktiviert) zu aktualisieren, für die die Verschlüsselung während der Übertragung deaktiviert ist. **So aktivieren Sie die Verschlüsselung während der Übertragung** 1. Stellen Sie unter Verwendung transit-encryption-mode der `preferred` folgenden Parameter auf ein + **--transit-encryption-enabled**—Erforderlich. + **--transit-encryption-mode** – muss auf `preferred` festgelegt sein. 1. Stellen transit-encryption-mode Sie `required` unter Verwendung der folgenden Parameter auf ein: + **--transit-encryption-enabled**—Erforderlich. + **--transit-encryption-mode** – muss auf `required` festgelegt sein. # Verbindung zu ElastiCache (Valkey) oder Amazon ElastiCache for Redis OSS mit Verschlüsselung während der Übertragung mithilfe von Valkey-CLI herstellen Um auf Daten von Redis OSS-Caches zuzugreifen, ElastiCache für die Verschlüsselung während der Übertragung aktiviert ist, verwenden Sie Clients, die mit Secure Socket Layer (SSL) arbeiten. Sie können valkey-cli auch unter Amazon Linux und TLS/SSL Amazon Linux 2 verwenden. Wenn Ihr Client TLS nicht unterstützt, können Sie den `stunnel` Befehl auf Ihrem Client-Host verwenden, um einen SSL-Tunnel zu den Redis-OSS-Knoten zu erstellen. ## Verschlüsselte Verbindung mit Linux Gehen Sie wie folgt vor, um mit Valkey-CLI eine Verbindung zu einem Valkey- oder Redis-OSS-Cluster herzustellen, für den die Verschlüsselung während der Übertragung auf Amazon Linux 2 oder Amazon Linux aktiviert ist. 1. Laden Sie das Valkey-Cli-Hilfsprogramm herunter und kompilieren Sie es. Dieses Hilfsprogramm ist in der Valkey-Softwaredistribution enthalten. 1. Geben Sie an der Befehlszeile Ihrer EC2 Instanz die entsprechenden Befehle für die von Ihnen verwendete Linux-Version ein. **Amazon Linux 2** Wenn Sie Amazon Linux 2 verwenden, geben Sie Folgendes ein: ``` sudo yum -y install openssl-devel gcc wget https://github.com/valkey-io/valkey/archive/refs/tags/7.2.6.tar.gz tar xvzf valkey-7.2.6.tar.gz cd valkey-7.2.6 make distclean make valkey-cli BUILD_TLS=yes sudo install -m 755 src/valkey-cli /usr/local/bin/ ``` **Amazon Linux** Wenn Sie Amazon Linux verwenden, geben Sie Folgendes ein: ``` sudo yum install gcc jemalloc-devel openssl-devel tcl tcl-devel clang wget wget https://github.com/valkey-io/valkey/archive/refs/tags/8.0.0.tar.gz tar xvzf valkey-8.0.0.tar.gz cd valkey-8.0.0 make valkey-cli CC=clang BUILD_TLS=yes sudo install -m 755 src/valkey-cli /usr/local/bin/ ``` Unter Amazon Linux müssen Sie möglicherweise auch die folgenden zusätzlichen Schritte ausführen: ``` sudo yum install clang CC=clang make sudo make install ``` 1. Nachdem Sie das valkey-cli Utility heruntergeladen und installiert haben, wird empfohlen, den optionalen Befehl auszuführen. `make-test` 1. Um eine Verbindung zu einem Cluster mit aktivierter Verschlüsselung und Authentifizierung herzustellen, geben Sie diesen Befehl ein: ``` valkey-cli -h Primary or Configuration Endpoint --tls -a 'your-password' -p 6379 ``` **Anmerkung** Wenn Sie redis6 auf Amazon Linux 2023 installieren, können Sie jetzt den folgenden Befehl verwenden`redis6-cli`: `valkey-cli` ``` redis6-cli -h Primary or Configuration Endpoint --tls -p 6379 ``` ## Verschlüsselte Verbindung mit Stunnel Gehen Sie wie folgt vor, um mit Valkey-CLI eine Verbindung zu einem Redis-OSS-Cluster herzustellen, für den die Verschlüsselung während der Übertragung mithilfe von Stunnel aktiviert ist. 1. Verwenden Sie SSH, um eine Verbindung mit Ihrem Client herzustellen und installieren Sie `stunnel`. ``` sudo yum install stunnel ``` 1. Führen Sie den folgenden Befehl aus, um eine Datei `'/etc/stunnel/valkey-cli.conf'` gleichzeitig zu erstellen und zu bearbeiten, um einem oder mehreren Verbindungsparametern einen Endpunkt ElastiCache für den Redis OSS-Cluster hinzuzufügen. Verwenden Sie dabei die unten angegebene Ausgabe als Vorlage. ``` vi /etc/stunnel/valkey-cli.conf fips = no setuid = root setgid = root pid = /var/run/stunnel.pid debug = 7 delay = yes options = NO_SSLv2 options = NO_SSLv3 [valkey-cli] client = yes accept = 127.0.0.1:6379 connect = primary.ssltest.wif01h.use1.cache.amazonaws.com:6379 [valkey-cli-replica] client = yes accept = 127.0.0.1:6380 connect = ssltest-02.ssltest.wif01h.use1.cache.amazonaws.com:6379 ``` In diesem Beispiel hat die Konfigurationsdatei zwei Verbindungen: `valkey-cli` und `valkey-cli-replica`. Dabei werden die Parameter folgendermaßen eingestellt: + Für **client** wird "yes" eingestellt, um anzugeben, dass diese stunnel-Instance ein Client ist. + **accept** wird die Client-IP zugewiesen. In diesem Beispiel ist der primäre Wert auf den Redis OSS-Standard 127.0.0.1 auf Port 6379 gesetzt. Das Replikat muss einen anderen Port aufrufen und auf „6380” festgelegt sein. Sie können die temporären Ports 1024-65535 verwenden. Weitere Informationen finden Sie unter [Temporäre Ports](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_ACLs.html#VPC_ACLs_Ephemeral_Ports) im *Benutzerhandbuch zu Amazon VPC*. + **connect** ist auf den Redis OSS-Serverendpunkt eingestellt. Weitere Informationen finden Sie unter [Verbindungsendpunkte finden in ElastiCache](Endpoints.md). 1. Starten `stunnel`. ``` sudo stunnel /etc/stunnel/valkey-cli.conf ``` Verwenden Sie den Befehl `netstat`, um zu bestätigen, dass der Tunnel gestartet wurde. ``` sudo netstat -tulnp | grep -i stunnel tcp 0 0 127.0.0.1:6379 0.0.0.0:* LISTEN 3189/stunnel tcp 0 0 127.0.0.1:6380 0.0.0.0:* LISTEN 3189/stunnel ``` 1. Stellen Sie über den lokalen Endpunkt des Tunnels eine Verbindung zum verschlüsselten Redis OSS-Knoten her. + Wenn bei ElastiCache der Erstellung des Redis OSS-Clusters kein AUTH-Passwort verwendet wurde, verwendet dieses Beispiel die Valkey-CLI, um eine Verbindung zum ElastiCache for Redis OSS-Server unter Verwendung des vollständigen Pfads für Valkey-CLI unter Amazon Linux herzustellen: ``` /home/ec2-user/redis-7.2.5/src/valkey-cli -h localhost -p 6379 ``` Wenn das AUTH-Passwort bei der Erstellung des Redis OSS-Clusters verwendet wurde, verwendet dieses Beispiel valkey-cli, um eine Verbindung zum Redis OSS-Server herzustellen, wobei der vollständige Pfad für valkey-cli auf Amazon Linux verwendet wird: ``` /home/ec2-user/redis-7.2.5/src/valkey-cli -h localhost -p 6379 -a my-secret-password ``` ODER + Ändern Sie das Verzeichnis auf redis-7.2.5 und gehen Sie wie folgt vor: Wenn bei ElastiCache der Erstellung des Redis OSS-Clusters kein AUTH-Passwort verwendet wurde, verwendet dieses Beispiel die Valkey-CLI, um eine Verbindung zum ElastiCache for Redis OSS-Server unter Verwendung des vollständigen Pfads für Valkey-CLI unter Amazon Linux herzustellen: ``` src/valkey-cli -h localhost -p 6379 ``` Wenn das AUTH-Passwort bei der Erstellung des Redis OSS-Clusters verwendet wurde, verwendet dieses Beispiel valkey-cli, um eine Verbindung zum Valkey- oder Redis OSS-Server herzustellen, wobei der vollständige Pfad für valkey-cli auf Amazon Linux verwendet wird: ``` src/valkey-cli -h localhost -p 6379 -a my-secret-password ``` In diesem Beispiel wird Telnet verwendet, um eine Verbindung zum Valkey Redis OSS-Server herzustellen. ``` telnet localhost 6379 Trying 127.0.0.1... Connected to localhost. Escape character is '^]'. auth MySecretPassword +OK get foo $3 bar ``` 1. Um SSL-Tunnel zu stoppen und zu schließen, verwenden Sie `pkill` für den stunnel-Prozess. ``` sudo pkill stunnel ``` # Aktivierung der Verschlüsselung während der Übertragung auf einem knotenbasierten Redis-OSS-Cluster mithilfe von Python Die folgende Anleitung zeigt, wie die Verschlüsselung bei der Übertragung auf einem Redis OSS 7.0-Cluster aktiviert wird, der ursprünglich mit deaktivierter Verschlüsselung während der Übertragung erstellt wurde. TCP- und TLS-Clients kommunizieren während dieses Vorgangs ohne Ausfallzeiten weiter mit dem Cluster. Boto3 ruft die benötigten Anmeldeinformationen (`aws_access_key_id`, `aws_secret_access_key`, und `aws_session_token`) aus den Umgebungsvariablen ab. Diese Anmeldeinformationen werden vorab in dasselbe Bash-Terminal eingefügt, in dem wir `python3` ausführen, um den in diesem Handbuch gezeigten Python-Code zu verarbeiten. Der Code im folgenden Beispiel wurde von einer EC2 Instance verarbeitet, die in derselben VPC gestartet wurde, mit der der ElastiCache Redis OSS-Cluster darin erstellt wird. **Anmerkung** In den folgenden Beispielen werden das boto3-SDK für ElastiCache Verwaltungsvorgänge (Cluster- oder Benutzererstellung) und redis-py-cluster redis-py/ für die Datenverarbeitung verwendet. Sie müssen mindestens boto3-Version (=\$1) 1.26.39 verwenden, um die Online-TLS-Migration mit der Cluster-Änderungs-API verwenden zu können. ElastiCache unterstützt die Online-TLS-Migration nur für Cluster mit Valkey Version 7.2 und höher oder Redis OSS Version 7.0 oder höher. Wenn Sie also einen Cluster haben, auf dem eine Redis OSS-Version vor 7.0 ausgeführt wird, müssen Sie die Redis OSS-Version Ihres Clusters aktualisieren. Weitere Informationen zu Versionsunterschieden finden Sie unter [Wesentliche Unterschiede zwischen dem Verhalten und der Kompatibilität der Engine-Versionen mit Redis OSS](VersionManagementConsiderations.md). **Topics** + [Definieren Sie die Zeichenkettenkonstanten, die den ElastiCache Valkey- oder Redis OSS-Cluster starten](#enable-python-define-constants) + [Definieren der Klassen für die Clusterkonfiguration](#enable-python-define-classes) + [Definieren einer Klasse, die den eigentlichen Cluster darstellt](#enable-python-define-classes-cluster) + [(Optional) Erstellen Sie eine Wrapper-Klasse, um die Client-Verbindung zum Valkey- oder Redis-OSS-Cluster zu demonstrieren](#enable-python-create-wrapper) + [Erstellen der Hauptfunktion, die den Änderungsprozess der Konfiguration der Verschlüsselung während der Übertragung demonstriert](#enable-python-main-function) ## Definieren Sie die Zeichenkettenkonstanten, die den ElastiCache Valkey- oder Redis OSS-Cluster starten Definieren wir zunächst einige einfache Python-String-Konstanten, die die Namen der AWS Entitäten enthalten, die zur Erstellung des ElastiCache Clusters erforderlich sind`security-group`, wie`Cache Subnet group`, und a. `default parameter group` All diese AWS Entitäten müssen im Voraus in Ihrem AWS Konto in der Region erstellt werden, die Sie verwenden möchten. ``` #Constants definitions SECURITY_GROUP = "sg-0492aa0a29c558427" CLUSTER_DESCRIPTION = "This cluster has been launched as part of the online TLS migration user guide" EC_SUBNET_GROUP = "client-testing" DEFAULT_PARAMETER_GROUP_REDIS_7_CLUSTER_MODE_ENABLED = "default.redis7.cluster.on" ``` ## Definieren der Klassen für die Clusterkonfiguration Lassen Sie uns nun einige einfache Python-Klassen definieren, die eine Konfiguration eines Clusters darstellen und Metadaten über den Cluster wie die Valkey- oder Redis-OSS-Version, den Instanztyp und ob die In-Transit-Verschlüsselung (TLS) aktiviert oder deaktiviert ist, enthalten. ``` #Class definitions class Config: def __init__( self, instance_type: str = "cache.t4g.small", version: str = "7.0", multi_az: bool = True, TLS: bool = True, name: str = None, ): self.instance_type = instance_type self.version = version self.multi_az = multi_az self.TLS = TLS self.name = name or f"tls-test" def create_base_launch_request(self): return { "ReplicationGroupId": self.name, "TransitEncryptionEnabled": self.TLS, "MultiAZEnabled": self.multi_az, "CacheNodeType": self.instance_type, "Engine": "redis", "EngineVersion": self.version, "CacheSubnetGroupName": EC_SUBNET_GROUP , "CacheParameterGroupName": DEFAULT_PARAMETER_GROUP_REDIS_7_CLUSTER_MODE_ENABLED , "ReplicationGroupDescription": CLUSTER_DESCRIPTION, "SecurityGroupIds": [SECURITY_GROUP], } class ConfigCME(Config): def __init__( self, instance_type: str = "cache.t4g.small", version: str = "7.0", multi_az: bool = True, TLS: bool = True, name: str = None, num_shards: int = 2, num_replicas_per_shard: int = 1, ): super().__init__(instance_type, version, multi_az, TLS, name) self.num_shards = num_shards self.num_replicas_per_shard = num_replicas_per_shard def create_launch_request(self) -> dict: launch_request = self.create_base_launch_request() launch_request["NumNodeGroups"] = self.num_shards launch_request["ReplicasPerNodeGroup"] = self.num_replicas_per_shard return launch_request ``` ## Definieren einer Klasse, die den eigentlichen Cluster darstellt Lassen Sie uns nun einige einfache Python-Klassen definieren, die den ElastiCache Valkey- oder Redis-OSS-Cluster selbst darstellen. Diese Klasse wird über ein Client-Feld verfügen, das einen Boto3-Client für ElastiCache Verwaltungsvorgänge wie das Erstellen des Clusters und das Abfragen der API enthält. ElastiCache ``` import botocore.config import boto3 # Create boto3 client def init_client(region: str = "us-east-1"): config = botocore.config.Config(retries={"max_attempts": 10, "mode": "standard"}) init_request = dict() init_request["config"] = config init_request["service_name"] = "elasticache" init_request["region_name"] = region return boto3.client(**init_request) class ElastiCacheClusterBase: def __init__(self, name: str): self.name = name self.elasticache_client = init_client() def get_first_replication_group(self): return self.elasticache_client.describe_replication_groups( ReplicationGroupId=self.name )["ReplicationGroups"][0] def get_status(self) -> str: return self.get_first_replication_group()["Status"] def get_transit_encryption_enabled(self) -> bool: return self.get_first_replication_group()["TransitEncryptionEnabled"] def is_available(self) -> bool: return self.get_status() == "available" def is_modifying(self) -> bool: return self.get_status() == "modifying" def wait_for_available(self): while True: if self.is_available(): break else: time.sleep(5) def wait_for_modifying(self): while True: if self.is_modifying(): break else: time.sleep(5) def delete_cluster(self) -> bool: self.elasticache_client.delete_replication_group( ReplicationGroupId=self.name, RetainPrimaryCluster=False ) def modify_transit_encryption_mode(self, new_transit_encryption_mode: str): # generate api call to migrate the cluster to TLS preffered or to TLS required self.elasticache_client.modify_replication_group( ReplicationGroupId=self.name, TransitEncryptionMode=new_transit_encryption_mode, TransitEncryptionEnabled=True, ApplyImmediately=True, ) self.wait_for_modifying() class ElastiCacheClusterCME(ElastiCacheClusterBase): def __init__(self, name: str): super().__init__(name) @classmethod def launch(cls, config: ConfigCME = None) -> ElastiCacheClusterCME: config = config or ConfigCME() print(config) new_cluster = ElastiCacheClusterCME(config.name) launch_request = config.create_launch_request() new_cluster.elasticache_client.create_replication_group(**launch_request) new_cluster.wait_for_available() return new_cluster def get_configuration_endpoint(self) -> str: return self.get_first_replication_group()["ConfigurationEndpoint"]["Address"] #Since the code can throw exceptions, we define this class to make the code more readable and #so we won't forget to delete the cluster class ElastiCacheCMEManager: def __init__(self, config: ConfigCME = None): self.config = config or ConfigCME() def __enter__(self) -> ElastiCacheClusterCME: self.cluster = ElastiCacheClusterCME.launch(self.config) return self.cluster def __exit__(self, exc_type, exc_val, exc_tb): self.cluster.delete_cluster() ``` ## (Optional) Erstellen Sie eine Wrapper-Klasse, um die Client-Verbindung zum Valkey- oder Redis-OSS-Cluster zu demonstrieren Jetzt erstellen wir eine Wrapper-Klasse für den `redis-py-cluster`-Client. Diese Wrapper-Klasse unterstützt das Vorbefüllen des Clusters mit einigen Schlüsseln und das anschließende Ausführen zufälliger wiederholter `get`-Befehle. **Anmerkung** Dies ist ein optionaler Schritt, der jedoch den Code der Hauptfunktion vereinfacht, die in einem späteren Schritt erstellt wird. ``` import redis improt random from time import perf_counter_ns, time class DowntimeTestClient: def __init__(self, client): self.client = client # num of keys prefilled self.prefilled = 0 # percent of get above prefilled self.percent_get_above_prefilled = 10 # nil result expected when get hit above prefilled # total downtime in nano seconds self.downtime_ns = 0 # num of success and fail operations self.success_ops = 0 self.fail_ops = 0 self.connection_errors = 0 self.timeout_errors = 0 def replace_client(self, client): self.client = client def prefill_data(self, timelimit_sec=60): end_time = time() + timelimit_sec while time() < end_time: self.client.set(self.prefilled, self.prefilled) self.prefilled += 1 # unsuccesful operations throw exceptions def _exec(self, func): try: start_ns = perf_counter_ns() func() self.success_ops += 1 elapsed_ms = (perf_counter_ns() - start_ns) // 10 ** 6 # upon succesful execution of func # reset random_key to None so that the next command # will use a new random key self.random_key = None except Exception as e: elapsed_ns = perf_counter_ns() - start_ns self.downtime_ns += elapsed_ns # in case of failure- increment the relevant counters so that we will keep track # of how many connection issues we had while trying to communicate with # the cluster. self.fail_ops += 1 if e.__class__ is redis.exceptions.ConnectionError: self.connection_errors += 1 if e.__class__ is redis.exceptions.TimeoutError: self.timeout_errors += 1 def _repeat_exec(self, func, seconds): end_time = time() + seconds while time() < end_time: self._exec(func) def _new_random_key_if_needed(self, percent_above_prefilled): if self.random_key is None: max = int((self.prefilled * (100 + percent_above_prefilled)) / 100) return random.randint(0, max) return self.random_key def _random_get(self): key = self._new_random_key_if_needed(self.percent_get_above_prefilled) result = self.client.get(key) # we know the key was set for sure only in the case key < self.prefilled if key < self.prefilled: assert result.decode("UTF-8") == str(key) def repeat_get(self, seconds=60): self._repeat_exec(self._random_get, seconds) def get_downtime_ms(self) -> int: return self.downtime_ns // 10 ** 6 def do_get_until(self, cond_check): while not cond_check(): self.repeat_get() # do one more get cycle once condition is met self.repeat_get() ``` ## Erstellen der Hauptfunktion, die den Änderungsprozess der Konfiguration der Verschlüsselung während der Übertragung demonstriert Definieren wir nun die Hauptfunktion wie folgt: 1. Erstellen Sie den Cluster mit dem Boto3-Client. ElastiCache 1. Initialisieren Sie den `redis-py-cluster`-Client, der eine Verbindung mit dem Cluster mit einer guten TCP-Verbindung ohne TLS herstellt. 1. Der `redis-py-cluster`-Client füllt den Cluster vorab mit einigen Daten. 1. Der boto3-Client löst die TLS-Migration von „no-TLS“ zu „TLS Preferred“ aus. 1. Während der Cluster zu TLS `Preferred` migriert wird, sendet der `redis-py-cluster`-TCP-Client wiederholte `get`-Operationen an den Cluster, bis die Migration abgeschlossen ist. 1. Nachdem die Migration zu TLS `Preferred` abgeschlossen ist, überprüfen wir, dass der Cluster die Verschlüsselung während der Übertragung unterstützt. Anschließend erstellen wir einen `redis-py-cluster`-Client, der mit TLS eine Verbindung mit dem Cluster herstellt. 1. Wir senden einige `get`-Befehle mit dem neuen TLS-Client und dem alten TCP-Client. 1. Der boto3-Client löst die TLS-Migration von „TLS `Preferred`“ zu „TLS required“ aus. 1. Während der Migration des Clusters auf TLS erforderlich, sendet der redis-py-cluster TLS-Client wiederholte `get` Operationen an den Cluster, bis die Migration abgeschlossen ist. ``` import redis def init_cluster_client( cluster: ElastiCacheClusterCME, prefill_data: bool, TLS: bool = True) -> DowntimeTestClient: # we must use for the host name the cluster configuration endpoint. redis_client = redis.RedisCluster( host=cluster.get_configuration_endpoint(), ssl=TLS, socket_timeout=0.25, socket_connect_timeout=0.1 ) test_client = DowntimeTestClient(redis_client) if prefill_data: test_client.prefill_data() return test_client if __name__ == '__main__': config = ConfigCME(TLS=False, instance_type="cache.m5.large") with ElastiCacheCMEManager(config) as cluster: # create a client that will connect to the cluster with clear tcp connection test_client_tcp = init_cluster_client(cluster, prefill_data=True, TLS=False) # migrate the cluster to TLS Preferred cluster.modify_transit_encryption_mode(new_transit_encryption_mode="preferred") # do repeated get commands until the cluster finishes the migration to TLS Preferred test_client_tcp.do_get_until(cluster.is_available) # verify that in transit encryption is enabled so that clients will be able to connect to the cluster with TLS assert cluster.get_transit_encryption_enabled() == True # create a client that will connect to the cluster with TLS connection. # we must first make sure that the cluster indeed supports TLS test_client_tls = init_cluster_client(cluster, prefill_data=True, TLS=True) # by doing get commands with the tcp client for 60 more seconds # we can verify that the existing tcp connection to the cluster still works test_client_tcp.repeat_get(seconds=60) # do get commands with the new TLS client for 60 more seconds test_client_tcp.repeat_get(seconds=60) # migrate the cluster to TLS required cluster.modify_transit_encryption_mode(new_transit_encryption_mode="required") # from this point the tcp clients will be disconnected and we must not use them anymore. # do get commands with the TLS client until the cluster finishes migartion to TLS required mode. test_client_tls.do_get_until(cluster.is_available) ``` # Bewährte Methoden für die Aktivierung der Verschlüsselung während der Übertragung ## Vor dem Aktivieren der Verschlüsselung während der Übertragung: sicherstellen, dass die DNS-Einträge ordnungsgemäß verarbeitet werden **Anmerkung** Während dieses Prozesses ändern und löschen wir alte Endpunkte. Eine falsche Verwendung der Endpunkte kann dazu führen, dass der Valkey- oder Redis-OSS-Client alte und gelöschte Endpunkte verwendet, sodass er keine Verbindung zum Cluster herstellen kann. Während der Migration des Clusters von ohne TLS auf TLS Preferred wird der alte DNS-Eintrag für den Endpunkt der Clusterkonfiguration beibehalten, und die neuen DNS-Einträge für den Clusterkonfigurationsendpunkt werden in einem anderen Format generiert. TLS-fähige Cluster verwenden ein anderes Format von DNS-Einträgen als TLS-deaktivierte Cluster. ElastiCache behält beide DNS-Einträge bei, wenn ein Cluster konfiguriert ist, `encryption mode: Preferred` sodass Anwendungen und andere Valkey- oder Redis OSS-Clients zwischen ihnen wechseln können. Die folgenden Änderungen in den DNS-Einträgen finden während des TLS-Migrationsprozesses statt: ### Beschreibung der Änderungen an den DNS-Einträgen, die bei der Aktivierung der Verschlüsselung während der Übertragung vorgenommen werden **Für CME-Cluster** Wenn ein Cluster auf „Übertragungs-Verschlüsselungsmodus: bevorzugt“ eingestellt ist: + Der ursprüngliche Endpunkt der Clusterkonfiguration für einen No-TLS-Cluster bleibt aktiv. Es wird keine Ausfallzeit geben, wenn der Cluster vom TLS-Verschlüsselungsmodus „none“ auf „preferred“ umkonfiguriert wird. + Neue TLS Valkey- oder Redis OSS-Endpunkte werden generiert, wenn der Cluster auf den TLS-Preferred-Modus gesetzt wird. Diese neuen Endpunkte werden genauso aufgelöst IPs wie die alten Endpunkte (ohne TLS). + Der neue TLS Valkey- oder Redis OSS-Konfigurationsendpunkt wird in der ElastiCache Konsole und in der Antwort auf die API verfügbar gemacht. `describe-replication-group` Wenn ein Cluster auf „Übertragungs-Verschlüsselungsmodus: erforderlich“ eingestellt ist: + Alte Endpunkte, die nicht TLS-fähig sind, werden gelöscht. Es wird keine Ausfallzeiten der TLS-Cluster-Endpunkte geben. + Sie können einen neuen `cluster-configuration-endpoint` von der ElastiCache Konsole oder von der `describe-replication-group` API abrufen. **Für CMD-Cluster mit aktiviertem automatischem Failover oder deaktiviertem automatischen Failover** Wenn die Replikationsgruppe auf „Übertragungs-Verschlüsselungsmodus: bevorzugt“ eingestellt ist: + Der ursprüngliche primäre Endpunkt und der Reader-Endpunkt für nicht TLS-fähige Cluster bleiben aktiv. + Neue primäre und Reader-Endpunkte mit TLS werden generiert, wenn der Cluster auf den Modus „TLS `Preferred`“ eingestellt ist. Diese neuen Endpunkte werden auf dieselben IPs wie die alten (ohne TLS) aufgelöst. + Der neue primäre Endpunkt und der Reader-Endpunkt werden in der ElastiCache Konsole und in der Antwort auf die `describe-replication-group` API angezeigt. Wenn die Replikationsgruppe auf „Übertragungs-Verschlüsselungsmodus: erforderlich“ eingestellt ist: + Alte primäre und Reader-Endpunkte ohne TLS werden gelöscht. Es wird keine Ausfallzeiten der TLS-Cluster-Endpunkte geben. + Sie können neue primäre Endpunkte und Leser-Endpunkte von der ElastiCache Konsole oder von der `describe-replication-group` API abrufen. ### Die empfohlene Verwendung der DNS-Einträge **Für CME-Cluster** + Verwenden Sie den Endpunkt der Clusterkonfiguration anstelle von DNS-Einträgen pro Knoten in Ihrem Anwendungscode. Die direkte Verwendung von DNS-Namen pro Knoten wird nicht empfohlen, da sie sich während der Migration ändern und der Anwendungscode die Verbindung zum Cluster unterbricht. + Codieren Sie einen Cluster-Konfigurationsendpunkt in Ihrer Anwendung nicht fest, da er sich während dieses Vorgangs ändern wird. + Es ist eine schlechte Praxis, den Cluster-Konfigurationsendpunkt in Ihrer Anwendung fest zu codieren, da er während dieses Vorgangs geändert werden kann. Nachdem die Verschlüsselung während der Übertragung abgeschlossen ist, fragen Sie den Endpunkt der Cluster-Konfiguration mit der `describe-replication-group` API ab (wie oben dargestellt (fett gedruckt)) und verwenden Sie ab diesem Zeitpunkt den DNS, den Sie als Antwort erhalten. **Für CMD-Cluster mit aktiviertem automatischen Failover** + Verwenden Sie in Ihrem Anwendungscode den primären Endpunkt und den Reader-Endpunkt anstelle der DNS-Namen pro Knoten, da die alten DNS-Namen pro Knoten gelöscht und neue generiert werden, wenn der Cluster von „no-TLS“ zu „TLS Preferred“ migriert wird. Es wird nicht empfohlen, DNS-Namen pro Knoten direkt zu verwenden, da Sie Ihrem Cluster später möglicherweise Replikate hinzufügen. Wenn Automatic Failover aktiviert ist, werden außerdem die Rollen des primären Clusters und der Replikate automatisch vom ElastiCache Dienst geändert. Es wird empfohlen, den primären Endpunkt und den Leser-Endpunkt zu verwenden, damit Sie diese Änderungen verfolgen können. Schließlich hilft Ihnen die Verwendung des Reader-Endpunkts dabei, Ihre Lesevorgänge aus den Replikaten gleichmäßig auf die Replikate im Cluster zu verteilen. + Es wird nicht empfohlen, den primären Endpunkt und den Reader-Endpunkt in Ihrer Anwendung fest zu kodieren, da diese während des TLS-Migrationsprozesses geändert werden können. Nachdem die Umstellung auf TLS-Preferred abgeschlossen ist, fragen Sie den primären Endpunkt und den Endpunkt des Lesegeräts mit der describe-replication-group API ab und verwenden Sie ab diesem Zeitpunkt den DNS, den Sie als Antwort erhalten. Auf diese Weise können Sie Änderungen an Endpunkten dynamisch verfolgen. **Für CMD-Cluster mit deaktiviertem automatischen Failover** + Verwenden Sie den primären Endpunkt und den Reader-Endpunkt anstelle der DNS-Namen pro Knoten in Ihrem Anwendungscode. Wenn Automatic Failover deaktiviert ist, werden Skalierung, Patching, Failover und andere Verfahren, die automatisch vom ElastiCache Dienst verwaltet werden, wenn Automatic Failover aktiviert ist, stattdessen von Ihnen durchgeführt. Das erleichtert es Ihnen, den Überblick über die verschiedenen Endpunkte zu behalten. Da bei der Migration des Clusters von „no-TLS“ zu „TLS Preferred“ die alten DNS-Namen pro Knoten gelöscht und neue generiert werden, sollten Sie die DNS-Namen pro Knoten nicht direkt verwenden. Dies ist erforderlich, damit sich die Clients während der TLS-Migration mit dem Cluster verbinden können. Außerdem profitieren Sie von einer gleichmäßigen Verteilung der Lesevorgänge zwischen den Replikaten, wenn Sie den Reader-Endpunkt verwenden, und behalten den Überblick über die DNS-Einträge, wenn Sie dem Cluster Replikate hinzufügen oder löschen. + Eine feste Kodierung des Endpunkts der Clusterkonfiguration in Ihrer Anwendung wird nicht empfohlen, da er während der TLS-Migration geändert werden kann. ## Bei der Verschlüsselung während der Übertragung: darauf achten, wann der Migrationsprozess abgeschlossen ist Die Änderung des Verschlüsselungsmodus während der Übertragung erfolgt nicht sofort und kann einige Zeit in Anspruch nehmen. Dies gilt insbesondere für große Cluster. Erst wenn der Cluster die Migration zu „TLS Preferred“ abgeschlossen hat, kann er sowohl TCP- als auch TLS-Verbindungen akzeptieren und bereitstellen. Daher sollten Sie keine Clients erstellen, die versuchen, TLS-Verbindungen mit dem Cluster herzustellen, bis die Verschlüsselung während der Übertragung abgeschlossen ist. Es gibt mehrere Möglichkeiten, sich benachrichtigen zu lassen, wenn die Verschlüsselung während der Übertragung erfolgreich abgeschlossen wurde oder fehlschlägt (im obigen Codebeispiel nicht dargestellt): + Verwenden des SNS-Services, um benachrichtigt zu werden, wenn die Verschlüsselung abgeschlossen ist + Verwenden der `describe-events`-API, die ein Ereignis ausgibt, wenn die Verschlüsselung abgeschlossen ist + In der ElastiCache Konsole wird eine Meldung angezeigt, dass die Verschlüsselung abgeschlossen ist Sie können in Ihrer Anwendung auch Logik implementieren, um festzustellen, ob die Verschlüsselung abgeschlossen ist. Im obigen Beispiel haben wir mehrere Möglichkeiten kennengelernt, wie wir sicherstellen können, dass der Cluster die Migration abschließt: + Warten, bis der Migrationsprozess beginnt (der Clusterstatus wechselt zu „Wird geändert“) und warten, bis die Änderung abgeschlossen ist (der Clusterstatus wechselt wieder zu „Verfügbar“) + Bestätigen Sie, dass für den Cluster `transit_encryption_enabled` auf „Wahr“ festgelegt ist, indem Sie die `describe-replication-group`-API abfragen. ### Nach dem Aktivieren der Verschlüsselung während der Übertragung: sicherstellen, dass die von Ihnen verwendeten Clients ordnungsgemäß konfiguriert sind Während sich der Cluster im Modus „TLS Preferred“ befindet, sollte Ihre Anwendung TLS-Verbindungen mit dem Cluster herstellen und nur diese Verbindungen verwenden. Auf diese Weise kommt es bei Ihrer Anwendung nicht zu Ausfallzeiten, wenn die Verschlüsselung während der Übertragung aktiviert wird. Mit dem Befehl info im Abschnitt SSL können Sie sicherstellen, dass keine klareren TCP-Verbindungen zur Valkey- oder Redis-OSS-Engine bestehen. ``` # SSL ssl_enabled:yes ssl_current_certificate_not_before_date:Mar 20 23:27:07 2017 GMT ssl_current_certificate_not_after_date:Feb 24 23:27:07 2117 GMT ssl_current_certificate_serial:D8C7DEA91E684163 tls_mode_connected_tcp_clients:0 (should be zero) tls_mode_connected_tls_clients:100 ``` ## Mit Openssl (Memcached) wird eine Verbindung zu Knoten hergestellt, für die Verschlüsselung während der Übertragung aktiviert ist Um auf Daten von Memcached-Knoten zuzugreifen, ElastiCache für die Verschlüsselung bei der Übertragung aktiviert ist, müssen Sie Clients verwenden, die mit Secure Socket Layer (SSL) arbeiten. Sie können Openssl s\$1client auch auf Amazon Linux und Amazon Linux 2 verwenden. Verwenden Sie Openssl s\$1client, um sich mit einem Memcached-Cluster zu verbinden, der mit Verschlüsselung während der Übertragung auf Amazon Linux 2 oder Amazon Linux aktiviert ist, wie folgt: ``` /usr/bin/openssl s_client -connect memcached-node-endpoint:memcached-port ``` ## Erstellen eines TLS-Memcached-Clients mit Java Um einen Client im TLS-Modus zu erstellen, gehen Sie wie folgt vor, um den Client mit dem entsprechenden zu initialisieren: SSLContext ``` import java.security.KeyStore; import javax.net.ssl.SSLContext; import javax.net.ssl.TrustManagerFactory; import net.spy.memcached.AddrUtil; import net.spy.memcached.ConnectionFactoryBuilder; import net.spy.memcached.MemcachedClient; public class TLSDemo { public static void main(String[] args) throws Exception { ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder(); // Build SSLContext TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); tmf.init((KeyStore) null); SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, tmf.getTrustManagers(), null); // Create the client in TLS mode connectionFactoryBuilder.setSSLContext(sslContext); MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster.fnjyzo.cfg.use1.cache.amazonaws.com:11211")); // Store a data item for an hour. client.set("theKey", 3600, "This is the data value"); } } ``` ## Erstellen eines TLS-Memcached-Clients mit PHP Gehen Sie wie folgt vor, um einen Client im TLS-Modus zu erstellen, um den Client mit dem entsprechenden zu initialisieren: SSLContext ``` setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE); /* Add the memcached's cluster server/s */ $tls_client->addServer($server_endpoint, $server_port); /* Configure the client to use TLS */ if(!$tls_client->setOption(Memcached::OPT_USE_TLS, 1)) { echo $tls_client->getLastErrorMessage(), "\n"; exit(1); } /* Set your TLS context configurations values. * See MemcachedTLSContextConfig in memcached-api.php for all configurations */ $tls_config = new MemcachedTLSContextConfig(); $tls_config->hostname = '*.mycluster.fnjyzo.use1.cache.amazonaws.com'; $tls_config->skip_cert_verify = false; $tls_config->skip_hostname_verify = false; /* Use the created TLS context configuration object to create OpenSSL's SSL_CTX and set it to your client. * Note: These TLS context configurations will be applied to all the servers connected to this client. */ $tls_client->createAndSetTLSContext((array)$tls_config); /* test the TLS connection with set-get scenario: */ /* store the data for 60 seconds in the cluster. * The client will decide which cache host will store this item. */ if($tls_client->set('key', 'value', 60)) { print "Successfully stored key\n"; } else { echo "Failed to set key: ", $tls_client->getLastErrorMessage(), "\n"; exit(1); } /* retrieve the key */ if ($tls_client->get('key') === 'value') { print "Successfully retrieved key\n"; } else { echo "Failed to get key: ", $tls_client->getLastErrorMessage(), "\n"; exit(1); } ``` Weitere Informationen zur Verwendung des PHP-Client finden Sie unter [Installation des ElastiCache Cluster-Clients für PHP](Appendix.PHPAutoDiscoverySetup.md). # Verschlüsselung im Ruhezustand in ElastiCache Um Ihre Daten zu schützen, bieten Amazon ElastiCache und Amazon S3 verschiedene Möglichkeiten, den Zugriff auf Daten in Ihrem Cache einzuschränken. Weitere Informationen erhalten Sie unter [Amazon VPCs und ElastiCache Sicherheit](VPCs.md) und [Identity and Access Management für Amazon ElastiCache](IAM.md). ElastiCache Die Verschlüsselung im Ruhezustand ist eine Funktion zur Erhöhung der Datensicherheit durch Verschlüsselung von Daten auf der Festplatte. In einem Serverless-Cache ist sie immer aktiviert. Wenn die Funktion aktiviert ist, werden folgenden Aspekte verschlüsselt: + Festplatte bei Synchronisierung, Backup und Austausch + In Amazon S3 gespeicherte Backups Daten, die auf SSDs (Solid-State-Laufwerken) in Clustern mit aktivierter Datenklassifizierung gespeichert sind, sind immer verschlüsselt. ElastiCache bietet standardmäßige (vom Service verwaltete) Verschlüsselung im Ruhezustand sowie die Möglichkeit, Ihre eigenen symmetrischen, vom Kunden verwalteten AWS KMS-Schlüssel im [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) (KMS) zu verwenden. Wählen Sie bei der Sicherung des Caches unter Verschlüsselungsoptionen aus, ob Sie den Standardverschlüsselungsschlüssel oder einen vom Kunden verwalteten Schlüssel verwenden möchten. Weitere Informationen finden Sie unter [Aktivieren der Verschlüsselung im Ruhezustand](#at-rest-encryption-enable). **Wichtig** Die Aktivierung der At-Rest-Verschlüsselung auf einem vorhandenen knotenbasierten Valkey- oder Redis-OSS-Cluster beinhaltet das Löschen Ihrer vorhandenen Replikationsgruppe, **nachdem die Sicherung und Wiederherstellung für die Replikationsgruppe ausgeführt wurde**. Die Verschlüsselung im Ruhezustand kann nur für einen Cache aktiviert werden, wenn dieser erstellt wird. Da zum Verschlüsseln und Entschlüsseln der Daten ein gewisses Maß an Verarbeitung erforderlich ist, kann die Aktivierung der Verschlüsselung der Daten im Ruhezustand bei diesen Vorgängen zu Leistungseinbußen führen. Sie sollten Ihre Daten mit und ohne Verschlüsselung im Ruhezustand vergleichen, um die Auswirkungen auf die Leistung für Ihre Anwendungsfälle zu ermitteln. **Topics** + [Bedingungen für die Verschlüsselung im Ruhezustand](#at-rest-encryption-constraints) + [Verwendung von vom Kunden verwalteten Schlüsseln von KMS AWS](#using-customer-managed-keys-for-elasticache-security) + [Aktivieren der Verschlüsselung im Ruhezustand](#at-rest-encryption-enable) + [Weitere Informationen finden Sie unter:](#at-rest-encryption-see-also) ## Bedingungen für die Verschlüsselung im Ruhezustand Bei der Planung der Implementierung ElastiCache der Verschlüsselung im Ruhezustand sollten Sie die folgenden Einschränkungen bei der ElastiCache Verschlüsselung im Ruhezustand berücksichtigen: + Die Verschlüsselung im Ruhezustand wird für Replikationsgruppen unterstützt, auf denen Valkey 7.2 und höher ausgeführt wird, sowie auf Redis OSS-Versionen (3.2.6 ist für EOL geplant, siehe Zeitplan für das [Ende des Lebenszyklus der Redis OSS-Versionen](engine-versions.md#deprecated-engine-versions)), 4.0.10 oder höher. + Die Verschlüsselung der Daten im Ruhezustand wird nur für Replikationsgruppen unterstützt, die in einer Amazon VPC. ausgeführt werden. + Die Verschlüsselung im Ruhezustand wird nur für Replikationsgruppen unterstützt, die die folgenden Knotentypen ausführen. + R7g, R6gd, R6g, R5, R4, R3 + M7 g, M6 g, M5, M4, M3 + T4g, T3, T2 + C7gn Weitere Informationen finden Sie unter [Unterstützte Knotentypen](CacheNodes.SupportedTypes.md). + Die Verschlüsselung im Ruhezustand wird durch die explizite Festlegung des `AtRestEncryptionEnabled`-Parameters auf `true` aktiviert. + Sie können die Verschlüsselung im Ruhezustand nur für eine Replikationsgruppe aktivieren, wenn Sie die Replikationsgruppe erstellen. Sie können die Verschlüsselung während der Übertragung nicht aktivieren und deaktivieren, indem Sie eine Replikationsgruppe ändern. Informationen zur Implementierung der Verschlüsselung im Ruhezustand bei vorhandenen Replikationsgruppen finden Sie unter [Aktivieren der Verschlüsselung im Ruhezustand](#at-rest-encryption-enable). + Wenn ein Cluster einen Knotentyp aus der R6gd-Familie verwendet, werden auf SSDs gespeicherte Daten unabhängig davon verschlüsselt, ob die Verschlüsselung im Ruhezustand aktiviert ist oder nicht. + Die Option, vom Kunden verwaltete Schlüssel für die Verschlüsselung im Ruhezustand zu verwenden, ist in den Regionen AWS GovCloud (us-gov-east-1 und -1) nicht verfügbar. us-gov-west + Wenn ein Cluster einen Knotentyp aus der R6GD-Familie verwendet, werden die auf der SSD gespeicherten Daten mit dem ausgewählten, vom Kunden verwalteten AWS KMS-Schlüssel (oder der vom Service verwalteten Verschlüsselung in AWS GovCloud Regionen) verschlüsselt. + Mit Memcached wird die Verschlüsselung im Ruhezustand nur in serverlosen Caches unterstützt. + Bei Verwendung von Memcached ist die Option, vom Kunden verwaltete Schlüssel für die Verschlüsselung im Ruhezustand zu verwenden, in AWS GovCloud den Regionen (-1 und -1) nicht verfügbar. us-gov-east us-gov-west Durch die Implementierung der Verschlüsselung der Daten im Ruhezustand kann die Leistung während der Sicherungs- und Knoten-Synchronisierungsvorgänge reduziert sein. Vergleichen Sie die Verschlüsselung der Daten im Ruhezustand mit Ihren eigenen unverschlüsselten Daten, um die Auswirkungen auf die Leistung Ihrer Implementierung zu ermitteln. ## Verwendung von vom Kunden verwalteten Schlüsseln von KMS AWS ElastiCache unterstützt symmetrische, vom Kunden verwaltete AWS KMS-Schlüssel (KMS-Schlüssel) für die Verschlüsselung im Ruhezustand. Kundenverwaltete KMS-Schlüssel sind Verschlüsselungsschlüssel, die Sie in Ihrem AWS Konto erstellen, besitzen und verwalten. Weitere Informationen finden Sie unter [AWS-KMS-Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#root_keys) im *Entwicklerhandbuch zum AWS-Schlüsselverwaltungsdienst*. Die Schlüssel müssen in AWS KMS erstellt werden, bevor sie mit ElastiCache verwendet werden können. Informationen zum Erstellen von AWS KMS-Stammschlüsseln finden Sie unter [Creating Keys](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) im *AWS Key Management Service Developer Guide*. ElastiCache 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 ElastiCache Amazon-Integration mit AWS KMS zu aktivieren. Der `kms:ViaService` Bedingungsschlüssel beschränkt die Verwendung eines AWS KMS-Schlüssels (KMS-Schlüssel) auf Anfragen von bestimmten AWS Diensten. Um `kms:ViaService` mit zu verwenden ElastiCache, schließen Sie beide ViaService Namen in den Wert des Bedingungsschlüssels ein: `elasticache.AWS_region.amazonaws.com` und`dax.AWS_region.amazonaws.com`. Weitere Informationen finden Sie unter [kms: ViaService](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-via-service). Sie können [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html)damit die Anfragen verfolgen, an die Amazon in AWS Key Management Service Ihrem Namen ElastiCache sendet. Alle API-Aufrufe, die sich auf vom Kunden verwaltete Schlüssel AWS Key Management Service beziehen, haben entsprechende CloudTrail Protokolle. Sie können sich auch die Zuschüsse ansehen, die ElastiCache generiert werden, wenn Sie den [ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html)KMS-API-Aufruf aufrufen. Ist eine Replikationsgruppe mit einem vom Kunden verwalteten Schlüssel verschlüsselt, werden alle Backups für die Replikationsgruppe wie folgt verschlüsselt: + Tägliche automatische Backups werden mit dem vom Kunden verwalteten Schlüssel verschlüsselt, der dem Cluster zugeordnet ist. + Die letzte Sicherung, die beim Löschen der Replikationsgruppe erstellt wird, wird ebenfalls mit dem kundenverwalteten Schlüssel verschlüsselt, der der Replikationsgruppe zugeordnet ist. + Standardmäßig werden manuell erstellte Sicherungen mit dem der Replikationsgruppe zugeordneten KMS-Schlüssel verschlüsselt. Mit einem anderen kundenverwalteten Schlüssel können Sie dies außer Kraft setzen. + Als Standardeinstellung wird beim Kopieren einer Sicherung ein vom Kunden verwalteter Schlüssel verwendet, der mit der Quellsicherung verknüpft ist. Mit einem anderen kundenverwalteten Schlüssel können Sie dies außer Kraft setzen. **Anmerkung** Kundenverwaltete Schlüssel können beim Exportieren von Sicherungen in den von Ihnen ausgewählten Amazon S3-Bucket nicht verwendet werden. Alle in Amazon S3 exportierten Sicherungen werden jedoch mit [serverseitiger Verschlüsselung](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html) verschlüsselt. Sie können wahlweise die Sicherungsdatei 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 unter Verwendung eines KMS-Schlüssels eingerichtet ist, oder eine Verschlüsselungsoption in der Datei selbst ändern. Außerdem können Sie vom Kunden verwaltete Schlüssel verwenden, um manuell erstellte Backups für Replikationsgruppen zu verschlüsseln, die keine vom Kunden verwalteten Schlüssel für die Verschlüsselung verwenden. Durch diese Option wird die in Amazon S3 gespeicherte Sicherungsdatei mit einem KMS-Schlüssel verschlüsselt, auch wenn die Daten in der ursprünglichen Replikationsgruppe nicht verschlüsselt sind. Bei der Wiederherstellung von einer Sicherung können Sie aus verschiedenen Verschlüsselungsoptionen wählen, ähnlich den verfügbaren Verschlüsselungsoptionen beim Erstellen einer neuen Replikationsgruppe. + Wenn Sie den Schlüssel löschen oder [deaktivieren](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) und für den Schlüssel, den Sie zur Verschlüsselung eines Caches verwendet haben, [Genehmigungen zurückziehen](https://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html), kann der Cache nicht wiederhergestellt werden. Mit anderen Worten, es 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. Nach dem Löschen des Schlüssels können Sie einen anderen vom Kunden verwalteten Schlüssel verwenden, um eine Sicherungskopie 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 Daten zuzugreifen. ElastiCache Verschlüsselte ElastiCache Amazon-Caches unterstützen keine manuelle Schlüsselrotation, bei der ein neuer Root-Schlüssel erstellt und alle Verweise auf den alten Schlüssel aktualisiert werden. Weitere Informationen finden Sie unter [Rotation von AWS KMS-Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) im *AWS Key Management Service Developer Guide*. + Für die Verschlüsselung eines ElastiCache Caches mithilfe eines KMS-Schlüssels ist ein Grant pro Cache erforderlich. Diese Genehmigung gilt für die Lebensdauer des Caches. Zusätzlich wird eine Genehmigung pro Backup bei der Backup-Erstellung verwendet. Diese Genehmigung wird zurückgezogen, sobald das Backup erstellt wurde. + Weitere Informationen zu AWS KMS-Zuschüssen und -Limits finden Sie unter [Limits](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html) im *AWS Key Management Service Developer Guide*. ## Aktivieren der Verschlüsselung im Ruhezustand Für alle Serverless-Caches ist die Verschlüsselung im Ruhezustand aktiviert. Wenn Sie einen knotenbasierten Cluster erstellen, können Sie die Verschlüsselung im Ruhezustand aktivieren, indem Sie den Parameter auf setzen. `AtRestEncryptionEnabled` `true` Sie können die Verschlüsselung der Daten im Ruhezustand für vorhandene Replikationsgruppen nicht aktivieren. Sie können die Verschlüsselung im Ruhezustand aktivieren, wenn Sie einen Cache erstellen. ElastiCache Sie können dies mit der AWS-ManagementkonsoleAWS CLI, oder der ElastiCache API tun. Beim Erstellen eines Caches können Sie eine der folgenden Optionen auswählen: + **Standard** – Diese Option verwendet serviceverwaltete Verschlüsselung im Ruhezustand. + Vom **Kunden verwalteter Schlüssel** — Mit dieser Option können Sie den Schlüssel ID/ARN von AWS KMS für die Verschlüsselung im Ruhezustand bereitstellen. Informationen zum Erstellen von AWS KMS-Root-Schlüsseln finden Sie unter [Create Keys](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) im *AWS Key Management Service Developer Guide* **Contents** + [Aktivierung der Verschlüsselung im Ruhezustand mithilfe der AWS-Managementkonsole](#at-rest-encryption-enable-con) + [Aktivierung der Verschlüsselung im Ruhezustand mithilfe der AWS CLI](#at-rest-encryption-enable-cli) ### Aktivierung der At-Rest-Verschlüsselung auf einem vorhandenen knotenbasierten Valkey- oder Redis OSS-Cluster Sie können die Verschlüsselung im Ruhezustand nur aktivieren, wenn Sie eine Valkey- oder Redis OSS-Replikationsgruppe erstellen. Gehen Sie folgendermaßen vor, wenn Sie über eine vorhandene Replikationsgruppe verfügen, für die Sie die Verschlüsselung der Daten im Ruhezustand aktivieren möchten. **Aktivieren der Verschlüsselung der Daten im Ruhezustand für eine vorhandene Replikationsgruppe** 1. Erstellen Sie eine manuelle Sicherung Ihrer vorhandenen Replikationsgruppe. Weitere Informationen finden Sie unter [Erstellen manueller Backups](backups-manual.md). 1. Erstellen Sie eine neue Replikationsgruppe, indem Sie sie aus der Sicherung wiederherstellen. Aktivieren Sie in der neuen Replikationsgruppe die Verschlüsselung der Daten im Ruhezustand. Weitere Informationen finden Sie unter [Wiederherstellen aus einem Backup in einen neuen Cache](backups-restoring.md). 1. Aktualisieren Sie die Endpunkte in Ihrer Anwendung so, dass sie auf die neue Replikationsgruppe verweisen. 1. Löschen Sie die alte Replikationsgruppe. Für weitere Informationen siehe [Löschen eines Clusters in ElastiCache](Clusters.Delete.md) oder [Löschen einer Replikationsgruppe](Replication.DeletingRepGroup.md). ### Aktivierung der Verschlüsselung im Ruhezustand mithilfe der AWS-Managementkonsole #### Aktivieren der Verschlüsselung im Ruhezustand für einen Serverless-Cache (Konsole) Für alle Serverless-Caches ist die Verschlüsselung im Ruhezustand aktiviert. Standardmäßig wird ein KMS-Schlüssel, der AWS-Eigentümer ist, zum Verschlüsseln von Daten verwendet. Um Ihren eigenen AWS KMS Schlüssel auszuwählen, treffen Sie die folgenden Auswahlen: + Erweitern Sie den Abschnitt **Standardeinstellungen**. + Wählen Sie im Abschnitt **Standardeinstellungen** die Option **Standardeinstellungen anpassen** aus. + Wählen Sie im Abschnitt **Sicherheit** die Option **Sicherheitseinstellungen anpassen** aus. + Wählen Sie unter der Einstellung **Verschlüsselungsschlüssels** die Option **Kundenverwalteter CMK** aus. + Wählen Sie unter der Einstellung **AWS KMS-Schlüssel** einen Schlüssel aus. #### Aktivierung der Verschlüsselung im Ruhezustand auf einem knotenbasierten Cluster (Konsole) Wenn Sie einen eigenen Cache entwerfen, ist bei den Konfigurationen „Dev/Test“ und „Production“ mit der Methode „Easy Create“ die Verschlüsselung im Ruhezustand mithilfe des Schlüssels **Standard** aktiviert. Legen Sie die folgenden Einstellungen fest, wenn Sie die Konfiguration selbst auswählen: + Wählen Sie Version 3.2.6, 4.0.10 oder höher als Ihre Engine-Version. + Aktivieren Sie für die Option **Verschlüsselung im Ruhezustand** das Kontrollkästchen neben **Aktivieren**. + Wählen Sie entweder die Option **Standardschlüssel** oder **Kundenverwalteter CMK**. Das step-by-step Verfahren finden Sie im Folgenden: + [Erstellen eines Valkey-Clusters (Cluster-Modus deaktiviert) (Konsole)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs) + [Erstellen eines Valkey- oder Redis OSS-Clusters (Cluster-Modus aktiviert) (Konsole)](Clusters.Create.md#Clusters.Create.CON.RedisCluster) ### Aktivierung der Verschlüsselung im Ruhezustand mithilfe der AWS CLI Um die Verschlüsselung im Ruhezustand zu aktivieren, wenn Sie einen Valkey- oder Redis-OSS-Cluster mithilfe von erstellen AWS CLI, verwenden Sie beim Erstellen einer Replikationsgruppe den at-rest-encryption-enabled Parameter *--*. #### Aktivierung der At-Rest-Verschlüsselung auf einem Valkey- oder Redis OSS-Cluster (Cluster-Modus deaktiviert) (CLI) Der folgende Vorgang erstellt die Valkey- oder Redis OSS-Replikationsgruppe (Clustermodus deaktiviert) `my-classic-rg` mit drei Knoten (*-- num-cache-clusters*), einem primären und zwei Read Replicas. *Die Verschlüsselung im Ruhezustand ist für diese Replikationsgruppe aktiviert (--). at-rest-encryption-enabled* Die folgenden Parameter und ihre Werte sind erforderlich, um die Verschlüsselung für diese Replikationsgruppe zu aktivieren: **Hauptparameter** + **--engine**— Muss oder sein. `valkey` `redis` + **--engine-version**—Wenn es sich bei der Engine um Redis OSS handelt, muss es sich um 3.2.6, 4.0.10 oder höher handeln. + **--at-rest-encryption-enabled**—Erforderlich, um die Verschlüsselung von Daten im Ruheszustand zu aktivieren. **Example 1: Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) mit Replikaten** Für Linux, macOS oder Unix: ``` aws elasticache create-replication-group \ --replication-group-id my-classic-rg \ --replication-group-description "3 node replication group" \ --cache-node-type cache.m4.large \ --engine redis \ --at-rest-encryption-enabled \ --num-cache-clusters 3 ``` Für Windows: ``` aws elasticache create-replication-group ^ --replication-group-id my-classic-rg ^ --replication-group-description "3 node replication group" ^ --cache-node-type cache.m4.large ^ --engine redis ^ --at-rest-encryption-enabled ^ --num-cache-clusters 3 ^ ``` Weitere Informationen finden Sie unter: + [Eine Valkey- oder Redis OSS-Replikationsgruppe (Clustermodus deaktiviert) von Grund auf neu erstellen ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Classic.md#Replication.CreatingReplGroup.NoExistingCluster.Classic.CLI) + [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)   #### Aktivierung der At-Rest-Verschlüsselung auf einem Cluster für Valkey oder Redis OSS (Cluster-Modus aktiviert) (CLI) *Der folgende Vorgang erstellt die Valkey- oder Redis OSS-Replikationsgruppe (Clustermodus aktiviert) `my-clustered-rg` mit drei Knotengruppen oder Shards (--). num-node-groups* *Jeder hat drei Knoten, einen primären und zwei Read Replicas (--). replicas-per-node-group* Die Verschlüsselung im Ruhezustand ist für diese Replikationsgruppe aktiviert (*-- at-rest-encryption-enabled*). Die folgenden Parameter und ihre Werte sind erforderlich, um die Verschlüsselung für diese Replikationsgruppe zu aktivieren: **Hauptparameter** + **--engine**— Muss oder sein. `valkey` `redis` + **--engine-version**—Wenn es sich bei der Engine um Redis OSS handelt, muss es sich um 4.0.10 oder höher handeln. + **--at-rest-encryption-enabled**—Erforderlich, um die Verschlüsselung von Daten im Ruheszustand zu aktivieren. + **--cache-parameter-group**—Muss `default-redis4.0.cluster.on` oder eine davon abgeleitete sein, um diese zu einer Cluster-Modus-fähigen Replikationsgruppe zu machen. **Example 2: Ein Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert)** Für Linux, macOS oder Unix: ``` aws elasticache create-replication-group \ --replication-group-id my-clustered-rg \ --replication-group-description "redis clustered cluster" \ --cache-node-type cache.m3.large \ --num-node-groups 3 \ --replicas-per-node-group 2 \ --engine redis \ --engine-version 6.2 \ --at-rest-encryption-enabled \ --cache-parameter-group default.redis6.x.cluster.on ``` Für Windows: ``` aws elasticache create-replication-group ^ --replication-group-id my-clustered-rg ^ --replication-group-description "redis clustered cluster" ^ --cache-node-type cache.m3.large ^ --num-node-groups 3 ^ --replicas-per-node-group 2 ^ --engine redis ^ --engine-version 6.2 ^ --at-rest-encryption-enabled ^ --cache-parameter-group default.redis6.x.cluster.on ``` Weitere Informationen finden Sie unter: + [Eine Valkey- oder Redis OSS-Replikationsgruppe (Cluster Mode Enabled) von Grund auf neu erstellen ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI) + [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html) ## Weitere Informationen finden Sie unter: + [Amazon VPCs und ElastiCache Sicherheit](VPCs.md) + [Identity and Access Management für Amazon ElastiCache](IAM.md) # Authentifizierung und Autorisierung AWS Identity and Access Management (IAM) ist ein Webservice, mit dem Sie den Zugriff auf AWS Ressourcen sicher kontrollieren können. ElastiCache unterstützt die Authentifizierung von Benutzern mithilfe von IAM und den Befehlen Valkey und Redis OSS AUTH sowie die Autorisierung von Benutzervorgängen mithilfe von Role-Based Access Control (RBAC). **Topics** + [Rollenbasierte Zugriffskontrolle (RBAC)](Clusters.RBAC.md) + [Authentifizierung mit dem Befehl Valkey und Redis OSS AUTH](auth.md) + [Deaktivieren der Zugriffskontrolle auf einem ElastiCache Valkey- oder Redis-OSS-Cache](in-transit-encryption-disable.md) # Rollenbasierte Zugriffskontrolle (RBAC) Mit den Befehlen Valkey und Redis OSS AUTH, wie unter beschrieben, [Authentifizierung mit dem Befehl Valkey und Redis OSS AUTH](auth.md) können Sie Role-Based Access Control (RBAC) verwenden. RBAC ist auch die einzige Möglichkeit, den Zugriff auf Serverless-Caches zu kontrollieren. Dies ist für Valkey 7.2 und höher sowie für Redis OSS 6.0 bis 7.2 verfügbar. RBAC ermöglicht Ihnen: + Steuern Sie den Cache-Zugriff über Benutzergruppen. Diese Benutzergruppen dienen dazu, den Zugriff auf Caches zu organisieren. + Verwenden Sie bei *AuthN* Passwörter pro Benutzer und nicht pro Cluster-Authentifizierungstoken. + Mit *AuthZ verfügen Sie über fein abgestufte* Benutzerberechtigungen. + Basieren Sie Ihren Clusterzugriff auf. ACLs Im Gegensatz zu Valkey und Redis OSS AUTH, bei denen alle authentifizierten Clients vollen Cache-Zugriff haben, wenn ihr Token authentifiziert ist, können Sie mit RBAC Benutzer Gruppen zuweisen, die von den gewünschten Rollen der Benutzer abhängen. Diese Sets dienen dazu, den Zugriff auf Caches zu organisieren. Mithilfe von RBAC erstellen Sie Benutzer und weisen ihnen bestimmte Berechtigungen zu, indem Sie eine Zugriffszeichenfolge verwenden, wie im Folgenden beschrieben. Sie weisen den Benutzern Gruppen zu, die auf eine bestimmte Rolle zugeschnitten sind (Administratoren, Personalabteilung), die dann in einem oder mehreren ElastiCache Caches bereitgestellt werden. Auf diese Weise können Sie Sicherheitsgrenzen zwischen Clients einrichten, die denselben Valkey- oder Redis-OSS-Cache oder dieselben Caches verwenden, und verhindern, dass Clients gegenseitig auf die Daten zugreifen. RBAC wurde entwickelt, um die Einführung von [ACL](https://valkey.io/topics/acl/) in Redis OSS 6 zu unterstützen. Wenn Sie RBAC mit Ihrem ElastiCache Valkey- oder Redis OSS-Cache verwenden, gibt es einige Einschränkungen: + Eine für die „VALKEY“ -Engine konfigurierte Benutzergruppe kann nur Benutzer enthalten, die einen Authentifizierungsmechanismus (entweder Passwort oder IAM) verwenden. Das bedeutet, dass alle Benutzer mit der Engine „VALKEY“ und alle anderen Benutzer mit der Engine „Redis“, deren Setup für die Authentifizierung mit Passwort oder IAM konfiguriert ist, zu dieser Benutzergruppe gehören können. + Bei der Verwendung von RBAC mit Valkey-Clustern können sowohl Benutzergruppen mit der Engine „VALKEY“ als auch mit der Engine „REDIS“ verwendet werden. + Bei der Verwendung von RBAC mit Redis OSS-Clustern können nur Benutzergruppen mit der Engine „REDIS“ verwendet werden. + Sie können keine Passwörter in einer Zugriffsfolge angeben. Sie legen Passwörter mit oder Anrufen fest. [CreateUser[ModifyUser](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyUser.html)](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateUser.html) + Bei Benutzerrechten aktivieren oder deaktivieren Sie Benutzer mit dem `on` und `off` als Teil der Zugriffszeichenfolge. Wenn in der Zugriffszeichenfolge keine angegeben ist, wird dem Benutzer `off` zugewiesen und er hat keine Zugriffsrechte für den Cache. + Sie können keine verbotenen und umbenannten Befehle als Teil der Zugriffszeichenfolge verwenden. Gibt man einen verbotenen oder einen umbenannten Befehl an, wird eine Ausnahme ausgelöst. Wenn Sie Zugriffskontrolllisten (ACLs) für einen umbenannten Befehl verwenden möchten, geben Sie den ursprünglichen Namen des Befehls an, d. h. den Namen des Befehls vor der Umbenennung. + Sie können den `reset`-Befehl als Teil einer Zugriffszeichenfolge nicht benutzen. Sie geben Passwörter mit API-Parametern an, und ElastiCache für Valkey und Redis verwaltet OSS 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 von Benutzern zusammen mit den für jeden Benutzer geltenden ACL-Regeln zurück. ElastiCache unterstützt den `ACL LIST` Befehl, bietet jedoch keine Unterstützung für Passwort-Hashes wie Redis OSS. Mit können Sie den [DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html)Vorgang verwenden ElastiCache, um ähnliche Informationen abzurufen, einschließlich der in der Zugriffszeichenfolge enthaltenen Regeln. Ruft jedoch [DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html)kein Benutzerkennwort ab. + [Andere schreibgeschützte Befehle, die von ElastiCache for Valkey und Redis OSS unterstützt werden, umfassen [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) ElastiCache für Valkey und Redis unterstützt OSS keine anderen schreibbasierten ACL-Befehle. + Es gelten die folgenden Limits: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/Clusters.RBAC.html) **RBAC mit Valkey** Bei der Verwendung von Role Based Access Control mit Valkey werden Benutzer und Benutzergruppen mit dem Engine-Typ „VALKEY“ erstellt. Dies wird empfohlen, da Valkey mit RBAC standardmäßig eine höhere Sicherheit im Vergleich zu Redis OSS bietet. Sowohl bereitgestellte als auch serverlose Valkey-Cluster unterstützen VALKEY-Benutzer- und Benutzergruppenzuordnungen. Zu den wichtigsten Funktionen von Valkey Access Control gehören: + Valkey-Benutzer sind nur auf Valkey-Benutzergruppenzuordnungen beschränkt. + Valkey-Benutzergruppen können Valkey-Benutzer und Redis OSS-Benutzer enthalten, die entweder kennwortgeschützt oder IAM-Authentifizierung aktiviert sind. + Valkey-Benutzer müssen entweder einen Kennwortschutz oder eine IAM-Authentifizierung verwenden. + VALKEY-Benutzergruppen können nur VALKEY-Clustern zugeordnet werden + Es gibt keine Standardbenutzeranforderung. Wenn die Valkey-Benutzergruppe Clustern zugeordnet ist, wird die Standardbenutzeranforderung automatisch deaktiviert. Kunden werden sehen, dass der Standardbenutzer ausgeschaltet ist, wenn sie den Befehl ACL LIST verwenden. Weitere Informationen zur Verwendung von RBAC mit ElastiCache für Valkey und Redis OSS folgen. **Topics** + [Spezifizieren von Berechtigungen mithilfe einer Zugriffszeichenfolge](#Access-string) + [Anwenden von RBAC auf einen Cache ElastiCache für Valkey oder Redis OSS](#rbac-using) + [Migration von AUTH zu RBAC](#Migrate-From-RBAC-to-Auth) + [Migration von RBAC zu AUTH](#Migrate-From-RBAC-to-AUTH-1) + [Automatisches Rotieren von Passwörtern für Benutzer](User-Secrets-Manager.md) + [Authentifizieren mit IAM](auth-iam.md) ## Spezifizieren von Berechtigungen mithilfe einer Zugriffszeichenfolge Um Berechtigungen für einen ElastiCache Valkey- oder Redis OSS-Cache anzugeben, erstellen Sie eine Zugriffszeichenfolge und weisen sie einem Benutzer entweder über oder zu.AWS CLIAWS-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 von links nach rechts kumulativ angewendet und anstelle der angegebenen Zeichenfolge kann eine einfachere Zeichenfolge verwendet werden, wenn Redundanzen in der angegebenen Zeichenfolge vorhanden sind. 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. + `+@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 [Erstellen von Benutzern und Benutzergruppen mit der Konsole und dem CLI](#Users-management). Wenn Sie einen vorhandenen Workload zu migrieren ElastiCache, können Sie die Zugriffszeichenfolge durch einen Aufruf abrufen`ACL LIST`, wobei der Benutzer und alle Kennwort-Hashes ausgenommen sind. Für Redis OSS Version 6.2 und höher wird auch die folgende Syntax für die Zugriffszeichenfolge unterstützt: + `&*` – Zugriff auf alle verfügbaren Kanäle ist erlaubt. Für Redis OSS Version 7.0 und höher wird auch die folgende Syntax für Zugriffszeichenfolgen unterstützt: + `|` – kann zum Blockieren von Unterbefehlen verwendet werden (z. B. „-config\$1set“). + `%R~` – fügt das angegebene Leseschlüsselmuster hinzu. Dies verhält sich ähnlich wie das reguläre Schlüsselmuster, gewährt jedoch nur die Erlaubnis, aus Schlüsseln zu lesen, die dem angegebenen Muster entsprechen. Weitere Informationen finden Sie unter [Wichtigen Berechtigungen](https://valkey.io/topics/acl/). + `%W~` – fügt das angegebene Schreibschlüsselmuster hinzu. Dies verhält sich ähnlich wie das reguläre Schlüsselmuster, gewährt jedoch nur die Erlaubnis, in Schlüssel zu schreiben, die dem angegebenen Muster entsprechen. Weitere Informationen finden Sie unter [ACL-Schlüsselberechtigungen](https://valkey.io/topics/acl/). + `%RW~` – Alia für `~`. + `()` – erstellt einen neuen Selektor, mit dem die Regeln verglichen werden sollen. Selektoren werden nach den Benutzerberechtigungen und in der Reihenfolge bewertet, in der sie definiert sind. Wenn ein Befehl entweder den Benutzerberechtigungen oder einem beliebigen Selektor entspricht, ist er zulässig. Weitere Informationen finden Sie unter [ACL-Selektoren](https://valkey.io/topics/acl/). + `clearselectors` – löscht alle an den Benutzer angehängten Selektoren. ## Anwenden von RBAC auf einen Cache ElastiCache für Valkey oder Redis OSS Um RBAC ElastiCache für Valkey oder Redis OSS zu verwenden, gehen Sie wie folgt vor: 1. Erstellung eines oder mehrerer Benutzer. 1. Erstellen Sie eine Benutzergruppe und fügen Sie der Gruppe Benutzer hinzu. 1. Weisen Sie die Benutzergruppe einen Cache zu, bei dem die Verschlüsselung während der Übertragung aktiviert ist. Diese Schritte werden im Folgenden detailliert beschrieben. **Topics** + [Erstellen von Benutzern und Benutzergruppen mit der Konsole und dem CLI](#Users-management) + [Verwalten von Benutzergruppen mit der Konsole und dem CLI](#User-Groups) + [Zuweisen von Benutzergruppen zu Serverless-Caches](#Users-groups-to-serverless-caches) + [Zuweisung von Benutzergruppen zu Replikationsgruppen](#Users-groups-to-RGs) ### Erstellen von Benutzern und Benutzergruppen mit der Konsole und dem CLI Die Benutzerinformationen für RBAC-Benutzer sind eine Benutzer-ID, ein Benutzername, sowie optional ein Kennwort und eine Zugriffszeichenfolge. Die Zugriffszeichenfolge stellt die Berechtigungsstufe für Schlüssel und Befehle bereit. Die Benutzer-ID ist eindeutig für den Benutzer und der Benutzername wird an die Engine übergeben. Vergewissern Sie sich, dass die von Ihnen bereitgestellten Benutzerberechtigungen für den beabsichtigten Zweck der Benutzergruppe sinnvoll sind. Wenn Sie beispielsweise eine Benutzergruppe mit dem Namen `Administrators` erstellen, sollte jeder Benutzer, den Sie dieser Gruppe hinzufügen, seine Zugriffszeichenfolge auf vollen Zugriff auf Schlüssel und Befehle gesetzt haben. Für Benutzer in einer `e-commerce`-Benutzergruppe können Sie die Zugriffszeichenfolge auf Nur-Lese-Zugriff setzen. ElastiCache konfiguriert automatisch einen Standardbenutzer mit Benutzer-ID und Benutzername `"default"` und fügt ihn allen Benutzergruppen hinzu. Sie können diesen Benutzer nicht löschen oder ändern. Dieser Benutzer ist aus Kompatibilitätsgründen 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. Wenn Sie einem Cache eine angemessene Zugriffskontrolle hinzufügen möchten, ersetzen Sie diesen Standardbenutzer durch einen neuen, der nicht aktiviert ist oder ein sicheres Passwort verwendet. Um den Standardbenutzer zu ändern, erstellen Sie einen neuen Benutzer, dessen Benutzername auf`default` gesetzt ist. Sie können ihn dann mit dem ursprünglichen Standardbenutzer austauschen. Führen Sie die folgenden Schritte aus, wie Sie den ursprünglichen `default`-Benutzer mit einem anderen `default`-Benutzer mit einer geänderten Zugriffszeichenfolge getauscht haben. **Ändern Sie den Standardbenutzer in der Konsole wie folgt:** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Amazon-Konsole unter [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. Wählen Sie aus dem Navigationsbereich **Benutzergruppenverwaltung** aus. 1. Wählen Sie für **Benutzergruppen-ID** die ID aus, die Sie ändern möchten. Stellen Sie sicher, dass Sie den Link und nicht das Kontrollkästchen ausgewählt haben. 1. Wählen Sie **Ändern** aus. 1. Wählen **Sie im Fenster Ändern** die Option **Verwalten** aus. Wählen Sie unter „Wählen Sie den gewünschten Benutzer aus“ den Benutzer mit dem **Standardbenutzernamen** aus. 1. Wählen Sie **Choose (Auswählen)** aus. 1. Wählen Sie **Ändern** aus. Wenn Sie dies tun, werden alle vorhandenen Verbindungen mit einem Cache, die der ursprüngliche Standardbenutzer hatte, beendet. **Um den Standardbenutzer mit dem zu ändern AWS CLI** 1. Erstellen Sie einen neuen Benutzer mit dem Benutzernamen `default` unter Verwendung der folgenden Befehle. Für Linux, macOS oder Unix: ``` aws elasticache create-user \ --user-id "new-default-user" \ --user-name "default" \ --engine "VALKEY" \ --passwords "a-str0ng-pa))word" \ --access-string "off +get ~keys*" ``` Für Windows: ``` aws elasticache create-user ^ --user-id "new-default-user" ^ --user-name "default" ^ --engine "VALKEY" ^ --passwords "a-str0ng-pa))word" ^ --access-string "off +get ~keys*" ``` 1. Erstellen Sie eine Benutzergruppe und fügen Sie den von Ihnen zuvor erstellten Benutzer hinzu. Für Linux, macOS oder Unix: ``` aws elasticache create-user-group \ --user-group-id "new-group-2" \ --engine "VALKEY" \ --user-ids "new-default-user" ``` Für Windows: ``` aws elasticache create-user-group ^ --user-group-id "new-group-2" ^ --engine "VALKEY" ^ --user-ids "new-default-user" ``` Beim Erstellen eines Benutzers können Sie bis zu zwei Passwörter einrichten. Wenn Sie ein Passwort ändern, werden alle vorhandenen Verbindungen mit Caches beibehalten. Beachten Sie insbesondere die folgenden Einschränkungen bei Benutzerkennwörtern, wenn Sie RBAC for ElastiCache für Valkey und Redis OSS verwenden: + 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 Gehen Sie wie unten beschrieben vor, um die Benutzer in der Konsole zu verwalten. **Verwalten von Benutzern in der Konsole** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Amazon-Konsole unter [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. Wählen Sie im ElastiCache Amazon-Dashboard **Benutzerverwaltung** aus. Die folgenden Optionen sind verfügbar: + **Benutzer erstellen** – Beim Erstellen eines Benutzers geben Sie eine Benutzer-ID, einen Benutzernamen, einen Authentifizierungsmodus und eine Zugriffszeichenfolge ein. Die Zugriffszeichenfolge legt die Berechtigungsstufe fest, welche Schlüssel und Befehle für den Benutzer erlaubt sind. Beim Erstellen eines Benutzers können Sie bis zu zwei Passwörter einrichten. Wenn Sie ein Passwort ändern, werden alle vorhandenen Verbindungen mit Caches beibehalten. + **Benutzer ändern** – Ermöglicht Ihnen, die Authentifizierungseinstellungen eines Benutzers zu aktualisieren oder dessen Zugriffszeichenfolge zu ändern. + **Benutzer löschen** –Das Konto wird aus allen Benutzergruppen entfernt, zu denen es gehört. Gehen Sie wie unten beschrieben vor, um die Benutzer im AWS CLI zu verwalten. **So ändern Sie einen Benutzer mit dem CLI** + Verwenden des `modify-user`-Befehls, um das Passwort oder die Passwörter eines Benutzers zu aktualisieren oder die Zugriffsberechtigungen eines Benutzers zu ändern. Wenn ein Benutzer geändert wird, werden die Benutzergruppen, die dem Benutzer zugeordnet sind, gemeinsam mit allen Caches aktualisiert, die der Benutzergruppe zugeordnet sind. Alle vorhandenen Verbindungen werden gewartet. Im Folgenden sind einige Beispiele aufgeführt. Für Linux, macOS oder Unix: ``` aws elasticache modify-user \ --user-id user-id-1 \ --access-string "~objects:* ~items:* ~public:*" \ --authentication-mode Type=iam ``` Für Windows: ``` aws elasticache modify-user ^ --user-id user-id-1 ^ --access-string "~objects:* ~items:* ~public:*" ^ --authentication-mode Type=iam ``` **Anmerkung** Wir raten davon ab, die `nopass`-Option zu nutzen. Wenn Sie dies tun, empfehlen wir, die Berechtigungen des Benutzers auf Nur-Lese-Zugriff und auf einen begrenzten Satz von Schlüsseln festzulegen. **So löschen Sie einen Benutzer mit dem CLI** + Verwenden Sie den Befehl `delete-user`, um einen Benutzer zu löschen. Das Konto wird gelöscht und aus allen zugehörigen Benutzergruppen entfernt. Im Folgenden wird ein -Beispiel gezeigt. Für Linux, macOS oder Unix: ``` aws elasticache delete-user \ --user-id user-id-2 ``` Für Windows: ``` aws elasticache delete-user ^ --user-id user-id-2 ``` Um eine Liste der Benutzer anzuzeigen, rufen Sie die [describe-user](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-users.html)-Operation auf. ``` aws elasticache describe-users ``` ### Verwalten von Benutzergruppen mit der Konsole und dem CLI Sie können Benutzergruppen erstellen, um den Zugriff von Benutzern auf einen oder mehrere Caches zu organisieren und zu steuern, wie im Folgenden dargestellt. Gehen Sie wie unten beschrieben vor, um die Benutzergruppen in der Konsole zu verwalten. **So verwalten Sie Benutzergruppen mithilfe der Konsole** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Amazon-Konsole unter [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/). 1. Wählen Sie im ElastiCache Amazon-Dashboard die Option **Benutzergruppenverwaltung** aus. Die folgenden Operationen sind verfügbar, um neue Benutzergruppen zu erstellen: + **Erstellen** – Wenn Sie eine Benutzergruppe erstellen, fügen Sie Benutzer hinzu und ordnen die Benutzergruppen dann Caches zu. So können Sie beispielsweise eine `Admin`-Benutzergruppe für Benutzer erstellen, die über Administratorrollen in einem Cache verfügen. **Wichtig** Wenn Sie keine Valkey- oder Redis OSS-Benutzergruppe verwenden, müssen Sie beim Erstellen einer Benutzergruppe einen Standardbenutzer angeben. + **Benutzer hinzufügen** – Fügen Sie der Benutzergruppe Benutzer hinzu. + **Entfernen von Benutzern** – Entfernt Benutzer aus der Benutzergruppe. Wenn Benutzer aus einer Benutzergruppe entfernt werden, werden alle vorhandenen Verbindungen, die diese mit einem Cache haben, beendet. + **Löschen** – Verwenden Sie diese Option, um eine Benutzergruppe zu löschen. Beachten Sie, dass nur die Benutzergruppe selbst und nicht die Benutzer, die zu dieser Gruppe gehören, gelöscht wird. Für bestehende Benutzergruppen können Sie die folgenden Aktionen ausführen: + **Benutzer hinzufügen** – Fügen Sie der Benutzergruppe bereits vorhandene Benutzer hinzu. + **Benutzer löschen** – Entfernt vorhandene Benutzer aus der Benutzergruppe. **Anmerkung** Benutzer werden von der Benutzergruppe entfernt, aber nicht aus dem System gelöscht. Gehen Sie wie unten beschrieben vor, um die Benutzergruppen im CLI zu verwalten. **So erstellen Sie eine neue Benutzergruppe und fügen einen Benutzer mittels der CLI hinzu** + Geben Sie wie nachfolgend gezeigt den `create-user-group`-Befehl ein. Für Linux, macOS oder Unix: ``` aws elasticache create-user-group \ --user-group-id "new-group-1" \ --engine "VALKEY" \ --user-ids user-id-1, user-id-2 ``` Für Windows: ``` aws elasticache create-user-group ^ --user-group-id "new-group-1" ^ --engine "VALKEY" ^ --user-ids user-id-1, user-id-2 ``` **So ändern Sie eine Benutzergruppe durch Hinzufügen neuer Benutzer oder Entfernen aktueller Mitglieder mit der CLI** + Geben Sie wie nachfolgend gezeigt den `modify-user-group`-Befehl ein. Für Linux, macOS oder Unix: ``` aws elasticache modify-user-group --user-group-id new-group-1 \ --user-ids-to-add user-id-3 \ --user-ids-to-remove user-id-2 ``` Für Windows: ``` aws elasticache modify-user-group --user-group-id new-group-1 ^ --user-ids-to-add user-id-3 ^ --user-ids-to-removere user-id-2 ``` **Anmerkung** Alle offenen Verbindungen, die zu einem Benutzer gehören, der aus einer Benutzergruppe entfernt wurde, werden mit diesem Befehl beendet. **So löschen Sie eine Benutzergruppe mit dem CLI** + Geben Sie wie nachfolgend gezeigt den `delete-user-group`-Befehl ein. Die Benutzergruppe selbst, nicht die zur Gruppe gehörenden Benutzer, wird gelöscht. Für Linux, macOS oder Unix: ``` aws elasticache delete-user-group / --user-group-id ``` Für Windows: ``` aws elasticache delete-user-group ^ --user-group-id ``` Um eine Liste der Benutzergruppen zu sehen, können Sie den [describe-user-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-user-groups.html)Vorgang aufrufen. ``` aws elasticache describe-user-groups \ --user-group-id test-group ``` ### Zuweisen von Benutzergruppen zu Serverless-Caches Nachdem Sie eine Benutzergruppe erstellt und Benutzer hinzugefügt haben, besteht der letzte Schritt bei der Implementierung von RBAC darin, diese Benutzergruppe einem Serverless-Cache zuzuweisen. #### Zuweisen von Benutzergruppen zu Serverless-Caches mithilfe der Konsole Gehen Sie wie folgt vor, um einem serverlosen Cache mithilfe von eine Benutzergruppe hinzuzufügen:AWS-Managementkonsole + Informationen zum deaktivierten Cluster-Modus finden Sie unter [Erstellen eines Valkey-Clusters (Cluster-Modus deaktiviert) (Konsole)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs) + Informationen zum aktivierten Cluster-Modus finden Sie unter [Erstellen eines Valkey- oder Redis OSS-Clusters (Cluster-Modus aktiviert) (Konsole)](Clusters.Create.md#Clusters.Create.CON.RedisCluster) #### Zuweisen von Benutzergruppen zu serverlosen Caches mithilfe von AWS CLI Der folgende AWS CLI Vorgang erstellt einen serverlosen Cache unter Verwendung des **user-group-id** Parameters mit dem Wert. `my-user-group-id` Ersetzen Sie die Subnetzgruppe `sng-test` durch eine vorhandene Subnetzgruppe. **Hauptparameter** + **--engine**— Muss `VALKEY` oder `REDIS` sein. + **--user-group-id** – Dieser Wert gibt die ID der Benutzergruppe an, die aus Benutzern mit bestimmten Zugriffsberechtigungen für den Cache besteht. Für Linux, macOS oder Unix: ``` aws elasticache create-serverless-cache \ --serverless-cache-name "new-serverless-cache" \ --description "new-serverless-cache" \ --engine "VALKEY" \ --user-group-id "new-group-1" ``` Für Windows: ``` aws elasticache create-serverless-cache ^ --serverless-cache-name "new-serverless-cache" ^ --description "new-serverless-cache" ^ --engine "VALKEY" ^ --user-group-id "new-group-1" ``` Die folgende AWS CLI Operation ändert einen serverlosen Cache mit dem **user-group-id** Parameter mit dem Wert. `my-user-group-id` Für Linux, macOS oder Unix: ``` aws elasticache modify-serverless-cache \ --serverless-cache-name serverless-cache-1 \ --user-group-id "new-group-2" ``` Für Windows: ``` aws elasticache modify-serverless-cache ^ --serverless-cache-name serverless-cache-1 ^ --user-group-id "new-group-2" ``` Beachten Sie, dass jegliche an einem Cache vorgenommenen Änderungen asynchron aktualisiert werden. Sie können den Fortschritt durch Ansicht der Ereignismeldungen überwachen. Weitere Informationen finden Sie unter [ElastiCache Ereignisse anzeigen](ECEvents.Viewing.md). ### Zuweisung von Benutzergruppen zu Replikationsgruppen Nachdem Sie eine Benutzergruppe erstellt und Benutzer hinzugefügt haben, besteht der letzte Schritt bei der Implementierung von RBAC darin, diese Benutzergruppe einer Replikationsgruppe zuzuweisen. #### Zuweisen von Benutzergruppen zu Replikationsgruppen mit der Konsole Gehen Sie wie folgt vor, um einer Replikation mithilfe von eine Benutzergruppe hinzuzufügen:AWS-Managementkonsole + Informationen zum deaktivierten Cluster-Modus finden Sie unter [Erstellen eines Valkey-Clusters (Cluster-Modus deaktiviert) (Konsole)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs) + Informationen zum aktivierten Cluster-Modus finden Sie unter [Erstellen eines Valkey- oder Redis OSS-Clusters (Cluster-Modus aktiviert) (Konsole)](Clusters.Create.md#Clusters.Create.CON.RedisCluster) #### Zuweisen von Benutzergruppen zu Replikationsgruppen mithilfe von AWS CLI Der folgende AWS CLI Vorgang erstellt eine Replikationsgruppe mit aktivierter Verschlüsselung bei der Übertragung (TLS) und dem **user-group-ids** Parameter mit dem Wert`my-user-group-id`. Ersetzen Sie die Subnetzgruppe `sng-test` durch eine vorhandene Subnetzgruppe. **Hauptparameter** + **--engine**— Muss `valkey` oder sein`redis`. + **--engine-version** – Muss 6.0 oder höher sein. + **--transit-encryption-enabled** – Erforderlich für die Authentifizierung und zum Zuordnen einer Benutzergruppe. + **--user-group-ids** – Dieser Wert gibt die ID der Benutzergruppe an, die aus Benutzern mit bestimmten Zugriffsberechtigungen für den Cache besteht. + **--cache-subnet-group** – Erforderlich für die Zuordnung einer Benutzergruppe. Für Linux, macOS oder Unix: ``` aws elasticache create-replication-group \ --replication-group-id "new-replication-group" \ --replication-group-description "new-replication-group" \ --engine "VALKEY" \ --cache-node-type cache.m5.large \ --transit-encryption-enabled \ --user-group-ids "new-group-1" \ --cache-subnet-group "cache-subnet-group" ``` Für Windows: ``` aws elasticache create-replication-group ^ --replication-group-id "new-replication-group" ^ --replication-group-description "new-replication-group" ^ --engine "VALKEY" ^ --cache-node-type cache.m5.large ^ --transit-encryption-enabled ^ --user-group-ids "new-group-1" ^ --cache-subnet-group "cache-subnet-group" ``` Der folgende AWS CLI Vorgang ändert eine Replikationsgruppe mit aktivierter Verschlüsselung bei der Übertragung (TLS) und dem **user-group-ids** Parameter mit dem Wert`my-user-group-id`. Für Linux, macOS oder Unix: ``` aws elasticache modify-replication-group \ --replication-group-id replication-group-1 \ --user-group-ids-to-remove "new-group-1" \ --user-group-ids-to-add "new-group-2" ``` Für Windows: ``` aws elasticache modify-replication-group ^ --replication-group-id replication-group-1 ^ --user-group-ids-to-remove "new-group-1" ^ --user-group-ids-to-add "new-group-2" ``` Beachten Sie die `PendingChanges` in der Antwort. Jegliche an einem Cache vorgenommenen Änderungen werden asynchron aktualisiert. Sie können den Fortschritt durch Ansicht der Ereignismeldungen überwachen. Weitere Informationen finden Sie unter [ElastiCache Ereignisse anzeigen](ECEvents.Viewing.md). ## Migration von AUTH zu RBAC Wenn Sie AUTH wie unter beschrieben verwenden [Authentifizierung mit dem Befehl Valkey und Redis OSS AUTH](auth.md) und zu RBAC migrieren möchten, gehen Sie wie folgt vor. Gehen Sie wie folgt vor, um mithilfe der Konsole von AUTH zu RBAC zu migrieren. **Um mithilfe der Konsole von Valkey oder Redis OSS AUTH zu RBAC zu migrieren** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Konsole unter. ElastiCache [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) 1. Wählen Sie aus der Liste in der oberen rechten Ecke die AWS Region aus, in der sich der Cache befindet, den Sie ändern möchten. 1. Wählen Sie im Navigationsbereich die Engine aus, die auf dem Cache ausgeführt wird, den Sie ändern möchten. Es wird eine Liste der Caches der ausgewählten Engine angezeigt. 1. Wählen Sie in der Liste der Caches den Namen des Caches aus, den Sie ändern möchten. 1. Wählen Sie für **Actions (Aktionen)** die Option **Modify (Ändern)** aus. Das Fenster **Ändern** wird angezeigt. 1. Wählen Sie für **Zugriffskontroll** die Option **Zugriffskontrollliste für Benutzergruppen** aus. 1. Wählen Sie für **Zugriffskontrollliste für Benutzergruppen** eine Benutzergruppe aus. 1. Wählen Sie **Änderungen in der Vorschau anzeigen** und dann auf dem nächsten Bildschirm **Ändern** aus. Verwenden Sie das folgende Verfahren, um mithilfe der CLI von Valkey oder Redis OSS AUTH zu RBAC zu migrieren. **So migrieren Sie mit der CLI von AUTH zu RBAC** + Geben Sie wie nachfolgend gezeigt den `modify-replication-group`-Befehl ein. Für Linux, macOS oder Unix: ``` aws elasticache modify-replication-group --replication-group-id test \ --auth-token-update-strategy DELETE \ --user-group-ids-to-add user-group-1 ``` Für Windows: ``` aws elasticache modify-replication-group --replication-group-id test ^ --auth-token-update-strategy DELETE ^ --user-group-ids-to-add user-group-1 ``` ## Migration von RBAC zu AUTH Wenn Sie RBAC verwenden und zu Redis OSS AUTH migrieren möchten, finden Sie weitere Informationen unter. [Migration von RBAC zu AUTH](auth.md#Migrate-From-RBAC-to-AUTH) **Anmerkung** Wenn Sie die Zugriffskontrolle für einen ElastiCache Cache deaktivieren müssen, müssen Sie dies über den tun.AWS CLI Weitere Informationen finden Sie unter [Deaktivieren der Zugriffskontrolle auf einem ElastiCache Valkey- oder Redis-OSS-Cache](in-transit-encryption-disable.md). # Automatisches Rotieren von Passwörtern für Benutzer Mit AWS Secrets Manager können Sie hartcodierte Anmeldeinformationen in Ihrem Code (einschließlich Kennwörtern) durch einen API-Aufruf an Secrets Manager ersetzen, um das Geheimnis programmgesteuert abzurufen. Dadurch wird sichergestellt, dass das Secret nicht kompromittiert werden kann, wenn jemand Ihren Code durchsucht, da es sich gar nicht dort befindet. Außerdem können Sie Secrets Manager so konfigurieren, dass er das Secret automatisch nach einem von Ihnen festgelegten Zeitplan rotiert. So können Sie Secrets mit langer Einsatzdauer durch Secrets mit kurzer Einsatzdauer ersetzen und damit das Risiko einer Kompromittierung erheblich verringern. Mit Secrets Manager können Sie Ihre OSS-Passwörter (d. h. Secrets) ElastiCache für Redis mithilfe einer von Secrets Manager AWS Lambda bereitgestellten Funktion automatisch rotieren. Weitere Informationen zu finden Sie AWS Secrets Manager unter [Was ist AWS Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) ## Wie ElastiCache verwendet Secrets Valkey 7.2 und höher verfügen über einen gleichwertigen Funktionsumfang wie Redis OSS 7.0. In Redis OSS 6, ElastiCache eingeführt, [Rollenbasierte Zugriffskontrolle (RBAC)](Clusters.RBAC.md) um den Valkey- oder Redis OSS-Cluster zu sichern. Mit dieser Funktion können bestimmte Verbindungen bezüglich der ausführbaren Befehle und der Tasten, auf die zugegriffen werden kann, eingeschränkt werden. Bei RBAC erstellt der Kunde zwar einen Benutzer mit Passwörtern, die Passwortwerte müssen jedoch manuell im Klartext eingegeben werden und sind für den Bediener sichtbar. Mit Secrets Manager wird das Passwort von Anwendungen aus Secrets Manager abgerufen, anstatt es manuell einzugeben und in der Anwendungskonfiguration zu speichern. Weitere Informationen hierzu finden Sie unter [Wie werden ElastiCache Benutzer mit dem Geheimnis verknüpft](#How-User-Secrets-Manager-Associate). Für die Verwendung von Secrets fallen Kosten an. Preisinformationen finden Sie unter [AWS Secrets Manager – Preise](https://aws.amazon.com/secrets-manager/pricing/). ## Wie werden ElastiCache Benutzer mit dem Geheimnis verknüpft Secrets Manager speichert eine Referenz für den zugehörigen Benutzer im `SecretString`-Feld des Secrets. Von der ElastiCache Seite wird es keinen Hinweis auf das Geheimnis geben. ``` { "password": "strongpassword", "username": "user1", "user_arn": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1" //this is the bond between the secret and the user } ``` ## Lambda-Rotationsfunktion Zur Aktivierung der automatischen Passwortrotation von Secrets Manager erstellen Sie eine Lambda-Funktion, die mit der [modify-user](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-user.html)-API interagiert, um die Passwörter des Benutzers zu aktualisieren. Informationen zur Funktionsweise finden Sie unter [Funktionsweise der Drehung](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html#rotate-secrets_how). **Anmerkung** Für einige AWS Dienste AWS empfiehlt es sich, sowohl den Bedingungsschlüssel als auch den `aws:SourceAccount` globalen Bedingungsschlüssel zu verwenden, um das `aws:SourceArn` Szenario eines verwirrten Stellvertreters zu vermeiden. Wenn Sie jedoch die `aws:SourceArn`-Bedingung in Ihre Drehungsfunktions-Richtlinie einschließen, kann die Drehungsfunktion nur verwendet werden, um das von diesem ARN angegebene Secret zu rotieren. Es wird empfohlen, nur den Kontextschlüssel `aws:SourceAccount` anzugeben, damit Sie die Drehungsfunktion für mehrere Geheimnisse verwenden können. Informationen zu Problemen, auf die Sie möglicherweise stoßen, finden Sie unter [Fehlerbehebung bei der AWS Secrets Manager Manager-Rotation](https://docs.aws.amazon.com/secretsmanager/latest/userguide/troubleshoot_rotation.html). ## So erstellen Sie einen ElastiCache Benutzer und verknüpfen ihn mit Secrets Manager Die folgenden Schritte veranschaulichen, wie Sie einen Benutzer erstellen und ihn mit Secrets Manager verknüpfen: 1. **Einen inaktiven Benutzer erstellen** Für Linux, macOS oder Unix: ``` aws elasticache create-user \ --user-id user1 \ --user-name user1 \ --engine "REDIS" \ --no-password \ // no authentication is required --access-string "*off* +get ~keys*" // this disables the user ``` Für Windows: ``` aws elasticache create-user ^ --user-id user1 ^ --user-name user1 ^ --engine "REDIS" ^ --no-password ^ // no authentication is required --access-string "*off* +get ~keys*" // this disables the user ``` Es wird eine Antwort ähnlich dem folgenden Beispiel angezeigt: ``` { "UserId": "user1", "UserName": "user1", "Status": "active", "Engine": "redis", "AccessString": "off ~keys* -@all +get", "UserGroupIds": [], "Authentication": { "Type": "no_password" }, "ARN": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1" } ``` 1. Erstellen eines -Secrets Für Linux, macOS oder Unix: ``` aws secretsmanager create-secret \ --name production/ec/user1 \ --secret-string \ '{ "user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1", "username":"user1" }' ``` Für Windows: ``` aws secretsmanager create-secret ^ --name production/ec/user1 ^ --secret-string ^ '{ "user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1", "username":"user1" }' ``` Es wird eine Antwort ähnlich dem folgenden Beispiel angezeigt: ``` { "ARN": "arn:aws:secretsmanager:us-east-1:123456xxxx:secret:production/ec/user1-eaFois", "Name": "production/ec/user1", "VersionId": "aae5b963-1e6b-4250-91c6-ebd6c47d0d95" } ``` 1. **Eine Lambda-Funktion zur Rotation Ihres Passworts konfigurieren** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Lambda-Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/elasticache/) 1. Wählen Sie im Navigationsbereich **Functions** (Funktionen) und dann die erstellte Funktion aus. Wählen Sie den Funktionsnamen aus, nicht das Kontrollkästchen links davon. 1. Wählen Sie die Registerkarte **Konfiguration** aus. 1. Wählen Sie unter **General configuration** (Allgemeine Konfiguration) die Option **Edit** (Bearbeiten) aus und legen Sie die **Timeout** (Zeitüberschreitung) anschließend auf mindestens 12 Minuten fest. 1. Wählen Sie **Speichern**. 1. Wählen Sie **Environment variables** (Umgebungsvariablen) aus und legen Sie dann Folgendes fest: 1. SECRETS\$1MANAGER\$1ENDPOINT – https://secretsmanager.**REGION**.amazonaws.com 1. SERET\$1ARN – der Amazon-Ressourcenname (ARN) des Secrets, das Sie in Schritt 2 erstellt haben. 1. USER\$1NAME — Benutzername des Benutzers, ElastiCache 1. Wählen Sie **Speichern**. 1. Wählen Sie **Permissions** (Berechtigungen) aus. 1. Wählen Sie unter **Execution role** (Ausführungsrolle) den Namen der Lambda-Funktionsrolle aus, die auf der IAM-Konsole angezeigt werden soll. 1. Die Lambda-Funktion benötigt die folgende Berechtigung, um die Benutzer zu ändern und das Passwort festzulegen: ElastiCache ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "elasticache:DescribeUsers", "elasticache:ModifyUser" ], "Resource": "arn:aws:elasticache:us-east-1:123456789012:user:user1" } ] } ``` ------ Secrets Manager ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "secretsmanager:GetSecretValue", "secretsmanager:DescribeSecret", "secretsmanager:PutSecretValue", "secretsmanager:UpdateSecretVersionStage" ], "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:XXXX" }, { "Effect": "Allow", "Action": "secretsmanager:GetRandomPassword", "Resource": "*" } ] } ``` ------ 1. Die Secrets-Manager-Rotation einrichten 1. **Verwenden von AWS-Managementkonsole, siehe [Automatische Rotation für AWS Secrets Manager Manager-Geheimnisse mithilfe der Konsole einrichten](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_turn-on-for-other.html)** Weitere Informationen zum Einrichten eines Rotationszeitplans finden Sie unter [Zeitplanausdrücke in Secrets-Manager-Rotation](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_schedule.html). 1. **Verwenden von AWS CLI, siehe [Automatische Rotation einrichten für die AWS Secrets Manager Verwendung von AWS Command Line Interface](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets-cli.html)** # 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 Valkey oder Redis OSS mithilfe von AWS IAM-Identitäten authentifizieren, wenn Ihr Cache ElastiCache 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. Sie können die IAM-Authentifizierung auch verwenden, um eine detaillierte Zugriffskontrolle für jeden einzelnen Cache und Benutzer zu konfigurieren, wobei die Prinzipien der geringsten Zugriffsrechte eingehalten werden. ElastiCache ElastiCache Die IAM-Authentifizierung für ElastiCache funktioniert durch die Bereitstellung eines kurzlebigen IAM-Authentifizierungstoken anstelle eines langlebigen ElastiCache Benutzerkennworts im OSS oder Befehl Valkey oder Redis. `AUTH` `HELLO` Weitere Informationen zum IAM-Authentifizierungstoken finden Sie im AWS Allgemeinen Referenzhandbuch im [Signaturprozess für Signature Version 4](https://docs.aws.amazon.com//general/latest/gr/signature-version-4.html) und im 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 Valkey- oder Redis OSS-Caches gewähren. Um AWS IAM mit verwenden zu können ElastiCache, müssen Sie zunächst einen ElastiCache Benutzer erstellen, dessen Authentifizierungsmodus auf IAM eingestellt ist. Anschließend können Sie eine IAM-Identität erstellen oder wiederverwenden. Für die IAM-Identität ist eine zugehörige Richtlinie erforderlich, um dem ElastiCache Cache und ElastiCache dem `elasticache:Connect` Benutzer die Aktion 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 Cache herstellen. Ein Valkey- oder Redis OSS-Client mit Unterstützung für den Anbieter von Anmeldeinformationen kann die temporären Anmeldeinformationen für jede neue Verbindung automatisch generieren. ElastiCache führt die IAM-Authentifizierung für Verbindungsanfragen von IAM-fähigen ElastiCache 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 ElastiCache für Valkey 7.2 und höher oder Redis OSS Version 7.0 und höher verwendet wird. + Für IAM-fähige ElastiCache Benutzer müssen die Eigenschaften Benutzername und Benutzer-ID identisch sein. + Das IAM-Authentifizierungstoken ist für 15 Minuten gültig. Für langlebige Verbindungen empfehlen wir die Verwendung eines Valkey- oder Redis-OSS-Clients, der eine Schnittstelle zum Anbieter von Anmeldeinformationen unterstützt. + Eine IAM-authentifizierte Verbindung zu Valkey oder Redis OSS wird ElastiCache nach 12 Stunden automatisch unterbrochen. 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 die folgenden globalen Bedingungskontextschlüssel: + Bei Verwendung der IAM-Authentifizierung mit Serverless-Caches werden `aws:VpcSourceIp`, `aws:SourceVpc`, `aws:SourceVpce`, `aws:CurrentTime`, `aws:EpochTime` und `aws:ResourceTag/%s` (von zugehörigen Serverless-Caches und Benutzern) unterstützt. + Bei Verwendung der IAM-Authentifizierung mit Replikationsgruppen werden `aws:SourceIp` und `aws:ResourceTag/%s` (von zugehörigen Replikationsgruppen und Benutzern) unterstützt. 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 Caches ``` aws elasticache create-serverless-cache \ --serverless-cache-name cache-01 \ --description "ElastiCache IAM auth application" \ --engine redis ``` 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" : [ "elasticache:Connect" ], "Resource" : [ "arn:aws:elasticache:us-east-1:123456789012:serverlesscache:cache-01", "arn:aws:elasticache:us-east-1:123456789012:user:iam-user-01" ] } ] } ``` ------ 1. Erstellen Sie eine IAM-Rolle. ``` aws iam create-role \ --role-name "elasticache-iam-auth-app" \ --assume-role-policy-document file://trust-policy.json ``` 1. Erstellen Sie die IAM-Richtlinie. ``` aws iam create-policy \ --policy-name "elasticache-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 "elasticache-iam-auth-app" \ --policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all" ``` 1. Erstellen Sie einen neuen IAM-fähigen Benutzer. ``` aws elasticache create-user \ --user-name iam-user-01 \ --user-id iam-user-01 \ --authentication-mode Type=iam \ --engine redis \ --access-string "on ~* +@all" ``` 1. Erstellen Sie eine Benutzergruppe und fügen Sie einen Benutzer an. ``` aws elasticache create-user-group \ --user-group-id iam-user-group-01 \ --engine redis \ --user-ids default iam-user-01 aws elasticache modify-serverless-cache \ --serverless-cache-name cache-01 \ --user-group-id iam-user-group-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 Valkey- oder Redis-OSS-Cache herstellen, wie im folgenden Beispiel gezeigt. ``` String userId = "insert user id"; String cacheName = "insert cache name"; boolean isServerless = true; 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 ElastiCache with Redis OSS. IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless); String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials()); // Construct Redis OSS URL with IAM Auth credentials provider RedisURI redisURI = RedisURI.builder() .withHost(host) .withPort(port) .withSsl(ssl) .withAuthentication(userId, iamAuthToken) .build(); // Create a new Lettuce Redis OSS client RedisClient client = RedisClient.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 PARAM_RESOURCE_TYPE = "ResourceType"; private static final String RESOURCE_TYPE_SERVERLESS_CACHE = "ServerlessCache"; private static final String ACTION_NAME = "connect"; private static final String SERVICE_NAME = "elasticache"; private static final long TOKEN_EXPIRY_SECONDS = 900; private final String userId; private final String cacheName; private final String region; private final boolean isServerless; public IAMAuthTokenRequest(String userId, String cacheName, String region, boolean isServerless) { this.userId = userId; this.cacheName = cacheName; this.region = region; this.isServerless = isServerless; } 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(userId)); if (isServerless) { request.addParameters(PARAM_RESOURCE_TYPE, Collections.singletonList(RESOURCE_TYPE_SERVERLESS_CACHE)); } return request; } private URI getRequestUri() { return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, cacheName)); } 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 ElastiCache mithilfe des IAM-Anbieters für Anmeldeinformationen authentifizieren. ``` String userId = "insert user id"; String cacheName = "insert cache name"; boolean isServerless = true; 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 ElastiCache with Redis OSS. IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless); // Create a Redis OSS credentials provider using IAM credentials. RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider( userId, iamAuthTokenRequest, awsCredentialsProvider); // Construct Redis OSS URL with IAM Auth credentials provider RedisURI redisURI = RedisURI.builder() .withHost(host) .withPort(port) .withSsl(ssl) .withAuthentication(redisCredentialsProvider) .build(); // Create a new Lettuce Redis OSS client RedisClient client = RedisClient.create(redisURI); client.connect(); ``` Im Folgenden finden Sie ein Beispiel für einen Lettuce Redis OSS-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 userId; private final IAMAuthTokenRequest iamAuthTokenRequest; private final Supplier iamAuthTokenSupplier; public RedisIAMAuthCredentialsProvider(String userId, 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(userId, iamAuthTokenSupplier.get())); } private String getIamAuthToken() { return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials()); } } ``` # Authentifizierung mit dem Befehl Valkey und Redis OSS AUTH **Anmerkung** Der **AUTH** wurde ersetzt durch. [Rollenbasierte Zugriffskontrolle (RBAC)](Clusters.RBAC.md) Alle Serverless-Caches müssen RBAC für die Authentifizierung verwenden. Valkey und Redis OSS-Authentifizierungstoken oder Passwörter ermöglichen es Valkey und Redis OSS, ein Passwort anzufordern, bevor Clients Befehle ausführen können, wodurch die Datensicherheit verbessert wird. Das **AUTH** ist nur für knotenbasierte Cluster verfügbar. **Topics** + [Überblick über AUTH in ElastiCache für Valkey und Redis OSS](#auth-overview) + [Anwenden der Authentifizierung auf einen ElastiCache OSS-Cluster für Valkey und Redis](#auth-using) + [Ändern des AUTH-Tokens auf einem vorhandenen Cluster](#auth-modifyng-token) + [Migration von RBAC zu AUTH](#Migrate-From-RBAC-to-AUTH) ## Überblick über AUTH in ElastiCache für Valkey und Redis OSS Wenn Sie den **AUTH** mit Ihrem OSS-Cluster ElastiCache für Valkey und Redis verwenden, gibt es einige Verbesserungen. Beachten Sie bei der Verwendung von AUTH insbesondere die folgenden Einschränkungen für AUTH-Token oder -Passwörter: + Token oder Kennwörter müssen 16-128 druckbare Zeichen enthalten. + Nicht alphanumerische Zeichen sind auf (\$1, &, \$1, \$1, ^, <, >, -). + AUTH kann nur für Valkey- oder Redis OSS-Cluster aktiviert werden, für die Verschlüsselung während der Übertragung aktiviert ist. Um ein starkes Token einzurichten, wird empfohlen, eine strenge Passwortrichtlinie zu befolgen, z. B. die Folgende: + Token oder Passwörter müssen mindestens drei der folgenden Zeichentypen enthalten: + Uppercase characters + Lowercase characters + Ziffern + Nicht-alphanumerische Zeichen (`!`, `&`, `#`, `$`, `^`, `<`, `>`, `-`) + Token oder Passwörter dürfen kein Wörterbuchwort oder ein leicht modifiziertes Wörterbuchwort enthalten. + Tokens oder Passwörter dürfen nicht mit einem kürzlich verwendeten Token identisch oder diesem ähnlich sein. ## Anwenden der Authentifizierung auf einen ElastiCache OSS-Cluster für Valkey und Redis Sie können verlangen, dass Benutzer ein Token (Passwort) auf einem tokengeschützten Valkey- oder Redis OSS-Server eingeben. Geben Sie dazu beim Erstellen Ihrer Replikationsgruppe oder Ihres Clusters den Parameter `--auth-token` (API: `AuthToken`) mit dem richtigen Token an. Fügen Sie ihn auch in alle nachfolgenden Befehle an die Replikationsgruppe oder den Cluster ein. Der folgende AWS CLI Vorgang erstellt eine Replikationsgruppe mit aktivierter Verschlüsselung bei der Übertragung (TLS) und dem Token. **AUTH** `This-is-a-sample-token` Ersetzen Sie die Subnetzgruppe `sng-test` durch eine vorhandene Subnetzgruppe. **Hauptparameter** + **--engine**— Muss `valkey` oder sein`redis`. + **--engine-version**— Wenn die Engine Redis OSS ist, muss es 3.2.6, 4.0.10 oder höher sein. + **--transit-encryption-enabled** – Erforderlich für Authentifizierung und HIPAA-Berechtigung. + **--auth-token** – Für HIPAA-Konformität erforderlich. Dieser Wert muss das richtige Token für diesen tokengeschützten Valkey- oder Redis OSS-Server sein. + **--cache-subnet-group** – Für HIPAA-Konformität erforderlich. Für Linux, macOS oder Unix: ``` aws elasticache create-replication-group \ --replication-group-id authtestgroup \ --replication-group-description authtest \ --engine redis \ --cache-node-type cache.m4.large \ --num-node-groups 1 \ --replicas-per-node-group 2 \ --transit-encryption-enabled \ --auth-token This-is-a-sample-token \ --cache-subnet-group sng-test ``` Für Windows: ``` aws elasticache create-replication-group ^ --replication-group-id authtestgroup ^ --replication-group-description authtest ^ --engine redis ^ --cache-node-type cache.m4.large ^ --num-node-groups 1 ^ --replicas-per-node-group 2 ^ --transit-encryption-enabled ^ --auth-token This-is-a-sample-token ^ --cache-subnet-group sng-test ``` ## Ändern des AUTH-Tokens auf einem vorhandenen Cluster Um die Aktualisierung Ihrer Authentifizierung zu vereinfachen, können Sie das in einem Cluster verwendete **AUTH** Token ändern. Sie können diese Änderung vornehmen, wenn die Engine-Version Valkey 7.2 oder höher oder Redis 5.0.6 oder höher ist. ElastiCache muss außerdem die Verschlüsselung bei der Übertragung aktiviert sein. Das Ändern des Authentifizierungs-Token unterstützt zwei Strategien: ROTATE und SET. Die ROTATE-Strategie fügt dem Server ein zusätzliches AUTH-Token hinzu, wobei das vorherige Token beibehalten wird. Die SET-Strategie aktualisiert den Server so, dass er nur ein einziges AUTH-Token unterstützt. Führen Sie diese Änderungsaufrufe mit dem `--apply-immediately`-Parameter durch, um die Änderungen sofort anzuwenden. ### Rotation des AUTH-Tokens Um einen Valkey- oder Redis OSS-Server mit einem neuen **AUTH-Token** zu aktualisieren, rufen Sie die `ModifyReplicationGroup` API mit dem `--auth-token` Parameter als neuem **AUTH** Token und dem `--auth-token-update-strategy` Wert ROTATE auf. Nach Abschluss der ROTATE-Änderung unterstützt der Cluster zusätzlich zu dem im Parameter angegebenen auch das vorherige AUTH-Token. `auth-token` Wenn vor der AUTH-Token-Rotation kein AUTH-Token für die Replikationsgruppe konfiguriert wurde, unterstützt der Cluster das im `--auth-token` Parameter angegebene AUTH-Token zusätzlich zur Unterstützung von Verbindungen ohne Authentifizierung. Informationen [Setzen des AUTH-Tokens](#auth-modifying-set) zur Aktualisierung des erforderlichen AUTH-Tokens finden Sie unter Verwendung der Aktualisierungsstrategie SET. **Anmerkung** Wenn Sie das AUTH-Token vorher nicht konfigurieren, unterstützt der Cluster nach Abschluss der Änderung zusätzlich zu dem AUTH-Token, das im AUTH-Token-Parameter angegeben ist, kein weiteres AUTH-Token. Wenn diese Änderung auf einem Server durchgeführt wird, der bereits zwei AUTH-Token unterstützt, wird bei diesem Vorgang auch das älteste AUTH-Token entfernt. Auf diese Weise kann ein Server bis zu zwei aktuelle AUTH-Token gleichzeitig unterstützen. An dieser Stelle können Sie fortfahren, indem Sie den Client so aktualisieren, dass er das neueste AUTH-Token verwendet. Nachdem die Clients aktualisiert wurden, können Sie die SET-Strategie für die **AUTH**-Token-Rotation (im folgenden Abschnitt erläutert) verwenden, um ausschließlich den neuen Token zu verwenden. Mit dem folgenden AWS CLI Vorgang wird eine Replikationsgruppe so geändert, dass das Token rotiert wird**AUTH**. `This-is-the-rotated-token` Für Linux, macOS oder Unix: ``` aws elasticache modify-replication-group \ --replication-group-id authtestgroup \ --auth-token This-is-the-rotated-token \ --auth-token-update-strategy ROTATE \ --apply-immediately ``` Für Windows: ``` aws elasticache modify-replication-group ^ --replication-group-id authtestgroup ^ --auth-token This-is-the-rotated-token ^ --auth-token-update-strategy ROTATE ^ --apply-immediately ``` ### Setzen des AUTH-Tokens Um einen Valkey- oder Redis OSS-Server so zu aktualisieren, dass er ein einzelnes erforderliches **AUTH** Token unterstützt, rufen Sie den `ModifyReplicationGroup` API-Vorgang mit dem `--auth-token` Parameter auf, der denselben Wert wie das letzte AUTH-Token hat, und dem `--auth-token-update-strategy` Parameter mit dem Wert. `SET` Die SET-Strategie kann nur mit einem Cluster verwendet werden, der über 2 AUTH-Token oder 1 optionales AUTH-Token verfügt, wenn zuvor eine ROTATE-Strategie verwendet wurde. Nach Abschluss der Änderung unterstützt der Server nur das im Parameter auth-token angegebene AUTH-Token. Mit dem folgenden AWS CLI Vorgang wird eine Replikationsgruppe geändert, auf die das AUTH-Token festgelegt werden soll. `This-is-the-set-token` Für Linux, macOS oder Unix: ``` aws elasticache modify-replication-group \ --replication-group-id authtestgroup \ --auth-token This-is-the-set-token \ --auth-token-update-strategy SET \ --apply-immediately ``` Für Windows: ``` aws elasticache modify-replication-group ^ --replication-group-id authtestgroup ^ --auth-token This-is-the-set-token ^ --auth-token-update-strategy SET ^ --apply-immediately ``` ### Aktivierung der Authentifizierung auf einem vorhandenen Cluster Um die Authentifizierung auf einem vorhandenen Valkey- oder Redis OSS-Server zu aktivieren, rufen Sie den `ModifyReplicationGroup` API-Vorgang auf. Rufen Sie `ModifyReplicationGroup` mit dem `--auth-token`-Parameter als neuem Token und `--auth-token-update-strategy` mit dem Wert ROTATE auf. Nach Abschluss der ROTATE-Änderung unterstützt der Cluster das im `--auth-token` Parameter angegebene **AUTH** Token zusätzlich zur Unterstützung von Verbindungen ohne Authentifizierung. Sobald alle Client-Anwendungen aktualisiert wurden, um sich mit dem AUTH-Token bei Valkey oder Redis OSS zu authentifizieren, verwenden Sie die SET-Strategie, um das AUTH-Token als erforderlich zu markieren. Die Aktivierung der Authentifizierung wird nur auf Valkey- und Redis OSS-Servern unterstützt, auf denen Encryption in Transit (TLS) aktiviert ist. ## Migration von RBAC zu AUTH Wenn Sie Benutzer mit Valkey oder Redis OSS Role-Based Access Control (RBAC) authentifizieren, wie unter beschrieben[Rollenbasierte Zugriffskontrolle (RBAC)](Clusters.RBAC.md), und Sie zu AUTH migrieren möchten, verwenden Sie die folgenden Verfahren. Sie können entweder mit der Konsole oder mit dem CLI migrieren. **Um mithilfe der Konsole von RBAC zu AUTH zu migrieren** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Konsole unter. [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/) 1. Wählen Sie aus der Liste in der oberen rechten Ecke die AWS Region aus, in der sich der Cluster befindet, den Sie ändern möchten. 1. Wählen Sie im Navigationsbereich die Engine, die auf dem Cluster ausgeführt wird, den Sie modifizieren möchten. Es wird eine Liste der ausgewählten Engine-Cluster angezeigt. 1. Wählen Sie in der Liste der Cluster den Namen des Clusters aus, den Sie modifizieren möchten.. 1. Wählen Sie für **Actions (Aktionen)** die Option **Modify (Ändern)** aus. Das Fenster **Ändern** wird angezeigt. 1. Wählen Sie für **Access Control** **Valkey AUTH default user access oder **Redis OSS** AUTH default user access**. 1. Legen Sie unter **Valkey AUTH-Token** oder **Redis OSS AUTH-Token** ein neues Token fest. 1. Wählen Sie **Änderungen in der Vorschau anzeigen** und dann auf dem nächsten Bildschirm **Ändern** aus. **Um von RBAC zu AUTH zu migrieren, verwenden Sie den AWS CLI** Verwenden Sie einen der folgenden Befehle, um ein neues optionales **AUTH** Token für Ihre Valkey- oder Redis OSS-Replikationsgruppe zu konfigurieren. Beachten Sie, dass ein optionales Auth-Token einen nicht authentifizierten Zugriff auf die Replikationsgruppe ermöglicht, bis das Auth-Token als erforderlich gekennzeichnet ist. Verwenden Sie dabei die Aktualisierungsstrategie im folgenden Schritt. `SET` Für Linux, macOS oder Unix: ``` aws elasticache modify-replication-group \ --replication-group-id test \ --remove-user-groups \ --auth-token This-is-a-sample-token \ --auth-token-update-strategy ROTATE \ --apply-immediately ``` Für Windows: ``` aws elasticache modify-replication-group ^ --replication-group-id test ^ --remove-user-groups ^ --auth-token This-is-a-sample-token ^ --auth-token-update-strategy ROTATE ^ --apply-immediately ``` Nachdem Sie den obigen Befehl ausgeführt haben, können Sie Ihre Valkey- oder Redis OSS-Anwendungen aktualisieren, um sich mit dem neu konfigurierten optionalen AUTH-Token bei der ElastiCache Replikationsgruppe zu authentifizieren. Verwenden Sie die Aktualisierungsstrategie `SET` im nachfolgenden Befehl unten, um die Auth-Token-Rotation abzuschließen. Dadurch wird das optionale AUTH-Token als erforderlich markiert. Wenn die Aktualisierung des Auth-Tokens abgeschlossen ist, wird der Status der Replikationsgruppe als angezeigt `ACTIVE` und für alle Verbindungen zu dieser Replikationsgruppe ist eine Authentifizierung erforderlich. Für Linux, macOS oder Unix: ``` aws elasticache modify-replication-group \ --replication-group-id test \ --auth-token This-is-a-sample-token \ --auth-token-update-strategy SET \ --apply-immediately ``` Für Windows: ``` aws elasticache modify-replication-group ^ --replication-group-id test ^ --remove-user-groups ^ --auth-token This-is-a-sample-token ^ --auth-token-update-strategy SET ^ --apply-immediately ``` Weitere Informationen finden Sie unter [Authentifizierung mit dem Befehl Valkey und Redis OSS AUTH](#auth). **Anmerkung** Wenn Sie die Zugriffskontrolle auf einem ElastiCache Cluster deaktivieren müssen, finden Sie weitere Informationen unter[Deaktivieren der Zugriffskontrolle auf einem ElastiCache Valkey- oder Redis-OSS-Cache](in-transit-encryption-disable.md). # Deaktivieren der Zugriffskontrolle auf einem ElastiCache Valkey- oder Redis-OSS-Cache Folgen Sie den nachstehenden Anweisungen, um die Zugriffskontrolle für einen TLS-fähigen Valkey- oder Redis OSS-Cache zu deaktivieren. Ihr Cache wird eine von zwei verschiedenen Konfigurationstypen haben: AUTH-Standardbenutzerzugriff oder Benutzergruppen-Zugriffskontrollliste (RBAC). Wenn Ihr Cache mit der AUTH-Konfiguration erstellt wurde, müssen Sie ihn auf die RBAC-Konfiguration ändern, bevor Sie den Cache deaktivieren können, indem Sie die Benutzergruppen entfernen. Wenn Ihr Cache mit der RBAC-Konfiguration erstellt wurde, können Sie ihn direkt deaktivieren. **Um einen mit RBAC konfigurierten serverlosen Valkey- oder Redis OSS-Cache zu deaktivieren** 1. Entfernen Sie die Benutzergruppen, um die Zugriffskontrolle zu deaktivieren. ``` aws elasticache modify-serverless-cache --serverless-cache-name --remove-user-group ``` 1. (Optional) Stellen Sie sicher, dass dem Serverless-Cache keine Benutzergruppen zugeordnet sind. ``` aws elasticache describe-serverless-caches --serverless-cache-name { "..." "UserGroupId": "" "..." } ``` **Um einen Valkey- oder Redis OSS-Cache zu deaktivieren, der mit einem AUTH-Token konfiguriert ist** 1. Ändern Sie das AUTH-Token in RBAC und geben Sie eine Benutzergruppe an, die hinzugefügt werden soll. ``` aws elasticache modify-replication-group --replication-group-id --auth-token-update-strategy DELETE --user-group-ids-to-add ``` 1. Stellen Sie sicher, dass das AUTH-Token deaktiviert und eine Benutzergruppe hinzugefügt wurde. ``` aws elasticache describe-replication-groups --replication-group-id { "..." "AuthTokenEnabled": false, "UserGroupIds": [ "" ] "..." } ``` 1. Entfernen Sie die Benutzergruppen, um die Zugriffskontrolle zu deaktivieren. ``` aws elasticache modify-replication-group --replication-group-id --user-group-ids-to-remove { "..." "PendingModifiedValues": { "UserGroups": { "UserGroupIdsToAdd": [], "UserGroupIdsToRemove": [ "" ] } "..." } ``` 1. (Optional) Stellen Sie sicher, dass dem Cluster keine Benutzergruppen zugeordnet sind. Das Feld `AuthTokenEnabled` sollte auch „false“ lauten. ``` aws elasticache describe-replication-groups --replication-group-id "AuthTokenEnabled": false ``` **Um einen mit RBAC konfigurierten Valkey- oder Redis OSS-Cluster zu deaktivieren** 1. Entfernen Sie die Benutzergruppen, um die Zugriffskontrolle zu deaktivieren. ``` aws elasticache modify-replication-group --replication-group-id --user-group-ids-to-remove { "..." "PendingModifiedValues": { "UserGroups": { "UserGroupIdsToAdd": [], "UserGroupIdsToRemove": [ "" ] } "..." } ``` 1. (Optional) Stellen Sie sicher, dass dem Cluster keine Benutzergruppen zugeordnet sind. Das Feld `AuthTokenEnabled` sollte auch „false“ lauten. ``` aws elasticache describe-replication-groups --replication-group-id "AuthTokenEnabled": false ```