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. # Migration von der kennwortbasierten Authentifizierung (AUTH) zur IAM-Authentifizierung In dieser Anleitung wird beschrieben, wie Sie Ihren ElastiCache knotenbasierten Cluster- oder Serverless-Cache von der kennwortbasierten Authentifizierung (AUTH) zur (IAM) -Authentifizierung migrieren, ohne dass der Dienst unterbrochen wird. AWS Identity and Access Management **Anmerkung** Wir empfehlen, diese Migration in einer Nicht-Produktionsumgebung zu testen, bevor Sie Änderungen an Ihrer Produktionsumgebung vornehmen. ## -Übersicht Die IAM-Authentifizierung bietet erhöhte Sicherheit, da langlebige Passwörter überflüssig werden. Stattdessen generieren Anwendungen mithilfe des [AWS Signature Version 4-Signaturprozesses kurzlebige Authentifizierungstoken (gültig bis zu 15 Minuten). ](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) ## Voraussetzungen Bevor Sie beginnen, prüfen Sie Folgendes: + In Ihrem Cache wird Redis OSS 7.0 oder höher oder Valkey ausgeführt. Die IAM-Authentifizierung wird in früheren Engine-Versionen nicht unterstützt. + In-transit Die Verschlüsselung (TLS) ist in Ihrem Cache aktiviert. Für die IAM-Authentifizierung ist TLS erforderlich. Weitere Informationen finden Sie unter [ElastiCache Verschlüsselung bei der Übertragung (TLS)](in-transit-encryption.md). + Sie verfügen über die erforderlichen IAM-Berechtigungen, um Benutzer zu erstellen und Benutzergruppen zu ändern. Weitere Informationen finden Sie unter [So ElastiCache arbeitet Amazon mit IAM](security_iam_service-with-iam.md). + Die IAM-Rolle oder der IAM-Benutzer, die Ihre Anwendung verwendet, verfügt über eine IAM-Richtlinie, die die `elasticache:Connect` Aktion für den Ziel-Cache und den IAM-Benutzer zulässt. Weitere Informationen finden Sie unter [Authentifizieren mit IAM](auth-iam.md). + Für Ihre Anwendung gelten keine zusätzlichen Einschränkungen bei der IAM-Authentifizierung. Die vollständige Liste der Einschränkungen finden Sie unter[Authentifizieren mit IAM](auth-iam.md). ## Migrationsprozess Der Migrationsprozess umfasst die Erstellung sowohl eines Kennworts als auch eines IAM-authenticated Benutzers, die Überprüfung der Konnektivität und die anschließende Umstellung Ihrer Anwendungen auf die IAM-Authentifizierung. ### Schritt 1: Benutzer erstellen Erstellen Sie zwei ElastiCache Benutzer, sodass Ihr Cache während der Migrationsphase sowohl die kennwortbasierte Authentifizierung als auch die IAM-Authentifizierung unterstützt. **Erstellen Sie einen Benutzer mit kennwortbasierter Authentifizierung ** **Anmerkung** Wenn Sie bereits einen kennwortbasierten Benutzer konfiguriert haben, können Sie die Erstellung eines neuen Benutzers überspringen und Ihren vorhandenen Benutzer verwenden. Verwenden Sie den folgenden AWS CLI Befehl, um einen kennwortbasierten Benutzer zu erstellen. Für Linux, macOS oder Unix: ``` aws elasticache create-user \ --user-id {{}} \ --user-name default \ --engine {{}} \ --passwords "{{}}" \ --access-string "on ~* +@all" ``` Für Windows: ``` aws elasticache create-user ^ --user-id {{}} ^ --user-name default ^ --engine {{}} ^ --passwords "{{}}" ^ --access-string "on ~* +@all" ``` Ersetzen Sie: + {{}}— Eine eindeutige ID für diesen Benutzer. + {{}}— Die Engine, die dein Cache verwendet: `valkey` oder`redis`. + {{}}— Das AUTH-Token, das derzeit in Ihrem Cache konfiguriert ist. **Erstellen Sie einen Benutzer IAM-authenticated ** Verwenden Sie den folgenden AWS CLI Befehl, um einen IAM-authenticated Benutzer zu erstellen. Für Linux, macOS oder Unix: ``` aws elasticache create-user \ --user-id {{}} \ --user-name {{}} \ --authentication-mode Type=iam \ --engine {{}} \ --access-string "on ~* +@all" ``` Für Windows: ``` aws elasticache create-user ^ --user-id {{}} ^ --user-name {{}} ^ --authentication-mode Type=iam ^ --engine {{}} ^ --access-string "on ~* +@all" ``` Ersetzen Sie: + {{}}— Eine eindeutige ID für den IAM-Benutzer. + {{}}— Der Benutzername für den IAM-Benutzer. + {{}}— Die Engine, die Ihr Cache verwendet: `valkey` oder`redis`. ### Schritt 2: Benutzergruppe erstellen und anhängen Wenn Sie bereits eine Benutzergruppe haben, die Ihren passwortbasierten Benutzer enthält, fügen Sie den IAM-authenticated Benutzer zu dieser vorhandenen Gruppe hinzu: Für Linux, macOS oder Unix: ``` aws elasticache modify-user-group \ --user-group-id {{}} \ --user-ids-to-add {{}} ``` Für Windows: ``` aws elasticache modify-user-group ^ --user-group-id {{}} ^ --user-ids-to-add {{}} ``` Ersetzen Sie: + {{}}— Die ID Ihrer bestehenden Benutzergruppe. + {{}}— Die Benutzer-ID des in Schritt 1 erstellten IAM-authenticated Benutzers. Fahren Sie anschließend fort mit der unter [Schritt 3: Überprüfen Sie beide Authentifizierungsmethoden](#auth-to-iam-verify-dual) beschriebenen Anleitung. Andernfalls erstellen Sie eine neue Benutzergruppe, fügen Sie beide Benutzer hinzu und hängen Sie die Gruppe an Ihren Cache an. Verwenden Sie die folgenden AWS CLI Befehle, um eine Benutzergruppe mit beiden Benutzern zu erstellen: Für Linux, macOS oder Unix: ``` aws elasticache create-user-group \ --user-group-id {{}} \ --engine {{}} \ --user-ids {{}} {{}} ``` Für Windows: ``` aws elasticache create-user-group ^ --user-group-id {{}} ^ --engine {{}} ^ --user-ids {{}} {{}} ``` Ersetzen Sie: + {{}}— Eine eindeutige ID für die Benutzergruppe. + {{}}— Die Engine, die dein Cache verwendet: `valkey` oder`redis`. + {{}}, {{}} — Die in Schritt 1 erstellten Benutzer-IDs. Ändern Sie dann Ihren Cache, um die neue Benutzergruppe zu verwenden. Für knotenbasierte Cluster: Für Linux, macOS oder Unix: ``` aws elasticache modify-replication-group \ --replication-group-id {{}} \ --auth-token-update-strategy DELETE \ --user-group-ids-to-add {{}} ``` Für Windows: ``` aws elasticache modify-replication-group ^ --replication-group-id {{}} ^ --auth-token-update-strategy DELETE ^ --user-group-ids-to-add {{}} ``` Ersetzen Sie: + {{}}— Die ID Ihrer Replikationsgruppe. + {{}}— Die Benutzergruppen-ID, die Sie oben erstellt haben. Für serverlose Caches: Für Linux, macOS oder Unix: ``` aws elasticache modify-serverless-cache \ --serverless-cache-name {{}} \ --user-group-id {{}} ``` Für Windows: ``` aws elasticache modify-serverless-cache ^ --serverless-cache-name {{}} ^ --user-group-id {{}} ``` Ersetzen Sie: + {{}}— Der Name Ihres serverlosen Caches. + {{}}— Die Benutzergruppen-ID, die Sie oben erstellt haben. ### Schritt 3: Überprüfen Sie beide Authentifizierungsmethoden Nach Abschluss von Schritt 2 unterstützt Ihr Cache beide Authentifizierungsmethoden. Stellen Sie sicher, dass Anwendungen mit beiden Methoden eine Verbindung herstellen können, bevor Sie fortfahren. + Anwendungen, die die kennwortbasierte Authentifizierung verwenden, können weiterhin eine Verbindung mit dem Passwort herstellen. + Anwendungen, die für die IAM-Authentifizierung konfiguriert sind, können mithilfe von IAM-Token eine Verbindung herstellen. ### Schritt 4: Stellen Sie eine Verbindung mit IAM her **Generieren Sie ein IAM-Authentifizierungstoken ** Generieren Sie ein kurzlebiges IAM-Authentifizierungstoken mithilfe einer vorsignierten [AWS SigV4-Anfrage. ](https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html) Das folgende Python-Beispiel veranschaulicht die Token-Generierung. ``` import boto3 from botocore.auth import SigV4QueryAuth from botocore.awsrequest import AWSRequest cache_name = "" user = "" region = "" expires = 900 session = boto3.Session() credentials = session.get_credentials().get_frozen_credentials() req = AWSRequest( method="GET", url=f"http://{cache_name}/", params={"Action": "connect", "User": user} ) SigV4QueryAuth(credentials, "elasticache", region, expires=expires).add_auth(req) token = req.url.replace("http://", "") print(token) ``` **Anmerkung** Das generierte Token ist ab der Erstellung bis zu 15 Minuten gültig. **Stellen Sie mithilfe von valkey-cli eine Verbindung her ** Stellen Sie mithilfe des generierten Tokens eine Verbindung zu Ihrem ElastiCache Cache her. Sie können entweder **valkey-cli** oder verwenden**redis-cli**, um eine Verbindung zu Valkey-Clustern herzustellen. Verwenden Sie für Redis OSS-Cluster. **redis-cli** ``` valkey-cli -h {{}} -p 6379 --tls ``` Fügen Sie für Cluster mit aktiviertem Clustermodus das `--cluster` Flag hinzu: ``` valkey-cli -h {{}} -p 6379 --tls --cluster ``` Authentifizieren Sie sich dann mit dem folgenden Befehl: ``` AUTH {{}} {{}} ``` Ersetzen Sie: + {{}}— Der Endpunkt Ihres Caches. + {{}}— Der Nutzername des IAM-authenticated Benutzers. + {{}}— Das von Ihnen generierte IAM-Authentifizierungstoken. Erwartete Ausgabe: ``` OK ``` Führen Sie den folgenden Befehl aus, um den Benutzernamen zu überprüfen: ``` ACL WHOAMI ``` ### Schritt 5: Anwendungsintegration Verwenden Sie für Java-Anwendungen die standardmäßige Anbieterkette für AWS Anmeldeinformationen, um temporäre Sicherheitsanmeldeinformationen zu generieren. Weitere Informationen finden Sie unter [Authentifizieren mit IAM](auth-iam.md). Generieren Sie für andere Sprachen das IAM-Authentifizierungstoken mithilfe des [AWS Signature Version 4-Signaturprozesses ](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) und übergeben Sie es als Passwort im `AUTH` Befehl Ihres Clients. ## Abschluss der Migration Nachdem Ihre Anwendungen mithilfe der IAM-Authentifizierung eine Verbindung herstellen können, führen Sie die folgenden Schritte aus, um die Migration abzuschließen. ### Schritt 1: Konfigurieren Sie die IAM-Authentifizierung mit Fallback Bevor Sie den kennwortbasierten Benutzer entfernen, aktualisieren Sie Ihren Anwendungscode, um die IAM-Authentifizierung als primäre Methode zu verwenden und den kennwortbasierten Benutzer als Fallback beizubehalten. In Ihrem Anwendungscode: + Konfigurieren Sie Ihren Client so, dass er sich mit IAM-generated Tokens als primärer Methode authentifiziert. + Fügen Sie einen Fallback-Mechanismus hinzu, sodass der Client erneut versucht, die passwortbasierten AUTH-Anmeldeinformationen zu verwenden, wenn die IAM-Authentifizierung fehlschlägt (z. B. aufgrund eines Ablaufs des Tokens oder eines Generierungsfehlers). + Protokollieren Sie alle Authentifizierungsversuche, einschließlich Fallbacks und Wiederholungsversuchen, sodass Sie überwachen können, ob Verbindungen auf die kennwortbasierte Authentifizierung zurückgreifen. ### Schritt 2: Überwachen und verifizieren Überprüfen Sie Ihre Anwendungsprotokolle `IamAuthenticationExpirations` und die `IamAuthenticationThrottling` CloudWatch Amazon-Metriken über einen Zeitraum von mindestens 24—48 Stunden, um sicherzustellen, dass alle Verbindungen über IAM hergestellt werden. Ein Wert ungleich Null für eine der beiden Metriken rechtfertigt eine Untersuchung: + `IamAuthenticationExpirations`— Eine IAM-authentifizierte Verbindung wird nach 12 Stunden automatisch getrennt. Die Verbindung kann verlängert werden, indem ein `AUTH` `HELLO` OR-Befehl mit einem neuen IAM-Authentifizierungstoken gesendet wird. + `IamAuthenticationThrottling`— Weist auf zu viele Authentifizierungsanfragen hin, was bedeuten kann, dass Ihre Anwendung Tokens zu aggressiv generiert oder Probleme mit dem Verbindungspooling hat. Bei knotenbasierten Clustern können Sie zusätzliche Prüfungen auf Engine-Ebene durchführen: + `ACL LOG`— Suchen Sie nach fehlgeschlagenen Authentifizierungsversuchen. Suchen Sie nach Einträgen mit`reason=auth`. + `CLIENT LIST`— Verifizieren Sie die verbundenen Benutzer. Markieren Sie das `user=` Feld, um zu bestätigen, dass die Kunden den IAM-Benutzer verwenden. `ACL LOG`und `CLIENT LIST` sind nur in knotenbasierten Clustern verfügbar. Verlassen Sie sich bei ElastiCache serverlosen Bereitstellungen auf anwendungsseitige Protokollierung und Amazon-Metriken. CloudWatch ### Schritt 3: Entfernen Sie den passwortbasierten Benutzer Sobald Sie bestätigt haben, dass alle Anwendungen die IAM-Authentifizierung verwenden, entfernen Sie den kennwortbasierten Benutzer aus der Benutzergruppe. **Valkey-Caches ** Den passwortbasierten Benutzer direkt entfernen: Für Linux, macOS oder Unix: ``` aws elasticache modify-user-group \ --user-group-id {{}} \ --user-ids-to-remove {{}} ``` Für Windows: ``` aws elasticache modify-user-group ^ --user-group-id {{}} ^ --user-ids-to-remove {{}} ``` **Redis OSS-Caches ** Bei Redis OSS-Caches muss die Benutzergruppe immer einen Benutzer mit dem Benutzernamen enthalten. `default` Wenn der kennwortbasierte Benutzer, den Sie in Schritt 1 erstellt haben, den Benutzernamen hat, müssen Sie einen deaktivierten Platzhalterbenutzer erstellen`default`, um ihn zu ersetzen, bevor Sie ihn entfernen: Für Linux, macOS oder Unix: ``` aws elasticache create-user \ --user-id {{}} \ --user-name default \ --engine redis \ --no-password-required \ --access-string "off ~* -@all" ``` Für Windows: ``` aws elasticache create-user ^ --user-id {{}} ^ --user-name default ^ --engine redis ^ --no-password-required ^ --access-string "off ~* -@all" ``` Fügen Sie dann den deaktivierten Benutzer zur Gruppe hinzu und entfernen Sie den kennwortbasierten Benutzer: Für Linux, macOS oder Unix: ``` aws elasticache modify-user-group \ --user-group-id {{}} \ --user-ids-to-add {{}} \ --user-ids-to-remove {{}} ``` Für Windows: ``` aws elasticache modify-user-group ^ --user-group-id {{}} ^ --user-ids-to-add {{}} ^ --user-ids-to-remove {{}} ``` Wenn der passwortbasierte Benutzer, den Sie in Schritt 1 erstellt haben, nicht über den Benutzernamen verfügt, können Sie ihn direkt entfernen`default`, indem Sie denselben Befehl verwenden, der oben für Valkey-Caches beschrieben wurde. Ersetzen Sie: + {{}}— Eine eindeutige ID für den deaktivierten Platzhalterbenutzer (nur Redis OSS). + {{}}— Die ID der Benutzergruppe, die Ihrem Cache zugeordnet ist. + {{}}— Die Benutzer-ID des passwortbasierten Benutzers, der entfernt werden soll. **Anmerkung** Löschen Sie den kennwortbasierten Benutzer nicht, nachdem Sie ihn aus der Benutzergruppe entfernt haben. Halten Sie ihn für den Fall bereit, dass Sie zur kennwortbasierten Authentifizierung zurückkehren müssen. ### Schritt 4: Bestätigen Sie nach dem Entfernen Nachdem Sie den passwortbasierten Benutzer aus der Benutzergruppe entfernt haben, überwachen Sie die Amazon-Statistik. `AuthenticationFailures` CloudWatch Ein anhaltender Wert Null bestätigt, dass keine Authentifizierungsfehler aufgetreten sind, einschließlich aller verbleibenden passwortbasierten Versuche. Stellen Sie für diese Metrik einen CloudWatch Alarm ein, um unerwartete Versuche zu erkennen. Bei knotenbasierten Clustern können Sie dies auch mit `ACL LOG` und überprüfen. `CLIENT LIST` Verlassen Sie sich bei serverlosen Caches auf anwendungsseitige Protokollierung und Metriken. CloudWatch ## Rollback-Verfahren Re-add Geben Sie den kennwortbasierten Benutzer in die Benutzergruppe ein und stellen Sie dann die kennwortbasierte Authentifizierung in Ihrer Anwendung wieder her, während Sie die Untersuchung durchführen. Für Valkey-Caches: Für Linux, macOS oder Unix: ``` aws elasticache modify-user-group \ --user-group-id {{}} \ --user-ids-to-add {{}} ``` Für Windows: ``` aws elasticache modify-user-group ^ --user-group-id {{}} ^ --user-ids-to-add {{}} ``` Verwenden Sie für Redis-OSS-Caches, bei denen der kennwortbasierte Benutzer den Benutzernamen `default` nicht hat, denselben Befehl wie oben beschrieben. Fügen Sie für Redis OSS-Caches, in denen Sie einen deaktivierten Platzhalterbenutzer erstellt haben[Schritt 3: Entfernen Sie den passwortbasierten Benutzer](#auth-to-iam-remove-user), den kennwortbasierten Benutzer hinzu und entfernen Sie den deaktivierten Platzhalterbenutzer in einem einzigen Vorgang: Für Linux, macOS oder Unix: ``` aws elasticache modify-user-group \ --user-group-id {{}} \ --user-ids-to-add {{}} \ --user-ids-to-remove {{}} ``` Für Windows: ``` aws elasticache modify-user-group ^ --user-group-id {{}} ^ --user-ids-to-add {{}} ^ --user-ids-to-remove {{}} ``` Ersetzen Sie: + {{}}— Die ID der Benutzergruppe, die Ihrem Cache zugeordnet ist. + {{}}— Die Benutzer-ID des kennwortbasierten Benutzers, der erneut hinzugefügt werden soll. + {{}}— Die Benutzer-ID des deaktivierten Platzhalterbenutzers (nur Redis OSS).