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.
# Erste Schritte mit Amazon ElastiCache
Verwenden Sie das praktische Tutorial in diesem Abschnitt, um Ihnen den Einstieg zu erleichtern und mehr über die Verwendung ElastiCache zu erfahren.
**Topics**
+ [Einrichten ElastiCache](set-up.md)
+ [Erstellen Sie einen serverlosen Valkey-Cache](GettingStarted.serverless-valkey.step1.md)
+ [Erstellen Sie einen serverlosen Redis OSS-Cache](GettingStarted.serverless-redis.step1.md)
+ [Erstellen Sie einen serverlosen Memcached-Cache](create-serverless-cache-mem.md)
+ [Tutorials: Erste Schritte mit Python und ElastiCache](ElastiCache-Getting-Started-Tutorials.md)
+ [Tutorial: Lambda für den Zugriff ElastiCache in einer VPC konfigurieren](LambdaRedis.md)
# Einrichten ElastiCache
Gehen Sie wie folgt vor, um den ElastiCache Webservice zu verwenden.
**Topics**
+ [Melden Sie sich an für ein AWS-Konto](#sign-up-for-aws)
+ [Erstellen eines Benutzers mit Administratorzugriff](#create-an-admin)
+ [Erteilen programmgesteuerten Zugriffs](#elasticache-set-up-access-key)
+ [Berechtigungen einrichten](#elasticache-set-up-permissions)
+ [Richten Sie ein EC2](#elasticache-install-configure-ec2)
+ [Gewähren des Netzwerkzugriffs](#elasticache-install-grant-access-VPN)
+ [Richten Sie den Befehlszeilenzugriff ein](#Download-and-install-cli)
## Melden Sie sich an für ein AWS-Konto
Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.
**Um sich für eine anzumelden AWS-Konto**
1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)
1. Folgen Sie den Online-Anweisungen.
Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.
Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Du kannst jederzeit deine aktuellen Kontoaktivitäten einsehen und dein Konto verwalten, indem du zu [https://aws.amazon.com/](https://aws.amazon.com/)gehst und **Mein Konto** auswählst.
## Erstellen eines Benutzers mit Administratorzugriff
Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-KontosAWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.
**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**
1. Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.
Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung Benutzerhandbuch* zu.
1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.
Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.
**Erstellen eines Benutzers mit Administratorzugriff**
1. Aktivieren Sie das IAM Identity Center.
Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center Benutzerhandbuch*.
1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.
*Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center*
**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.
Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).
**Weiteren Benutzern Zugriff zuweisen**
1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.
Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center Benutzerhandbuch*.
1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.
Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center Benutzerhandbuch*.
## Erteilen programmgesteuerten Zugriffs
Benutzer benötigen programmatischen Zugriff, wenn sie mit AWS außerhalb des interagieren möchten.AWS-Managementkonsole Die Art und Weise, wie programmatischer Zugriff gewährt wird, hängt vom Benutzertyp ab, der zugreift.AWS
Um Benutzern programmgesteuerten Zugriff zu gewähren, wählen Sie eine der folgenden Optionen.
****
| Welcher Benutzer benötigt programmgesteuerten Zugriff? | Bis | Von |
| --- | --- | --- |
| IAM | (Empfohlen) Verwenden Sie Konsolenanmeldeinformationen als temporäre Anmeldeinformationen, um programmatische Anfragen an AWS CLIAWS SDKs, oder zu signieren.AWS APIs | Befolgen Sie die Anweisungen für die Schnittstelle, die Sie verwenden möchten. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/set-up.html) |
| Mitarbeiteridentität (Benutzer, die in IAM Identity Center verwaltet werden) | Verwenden Sie temporäre Anmeldeinformationen, um programmatische Anfragen an das AWS CLIAWS SDKs, oder AWS APIs zu signieren. | Befolgen Sie die Anweisungen für die Schnittstelle, die Sie verwenden möchten. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/set-up.html) |
| IAM | Verwenden Sie temporäre Anmeldeinformationen, um programmatische Anfragen an das AWS CLIAWS SDKs, oder zu signieren.AWS APIs | Folgen Sie den Anweisungen unter [Verwenden temporärer Anmeldeinformationen mit AWS Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) im IAM-Benutzerhandbuch. |
| IAM | (Nicht empfohlen)Verwenden Sie langfristige Anmeldeinformationen, um programmatische Anfragen an das AWS CLIAWS SDKs, oder zu signieren.AWS APIs | Befolgen Sie die Anweisungen für die Schnittstelle, die Sie verwenden möchten. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/set-up.html) |
**Verwandte Themen:**
+ [Was ist IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) im *IAM-Benutzerhandbuch*.
+ AWS*AWS Allgemeine Referenz* zu [Sicherheitsanmeldedaten](https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html).
## Richten Sie Ihre Berechtigungen ein (nur ElastiCache für neue Benutzer)
Um Zugriff zu gewähren, fügen Sie Ihren Benutzern, Gruppen oder Rollen Berechtigungen hinzu:
+ Benutzer und Gruppen in AWS IAM Identity Center:
Erstellen Sie einen Berechtigungssatz. Befolgen Sie die Anweisungen unter [Erstellen eines Berechtigungssatzes](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) im *AWS IAM Identity Center-Benutzerhandbuch*.
+ Benutzer, die in IAM über einen Identitätsanbieter verwaltet werden:
Erstellen Sie eine Rolle für den Identitätsverbund. Befolgen Sie die Anleitung unter [Eine Rolle für einen externen Identitätsanbieter (Verbund) erstellen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) im *IAM-Benutzerhandbuch*.
+ IAM-Benutzer:
+ Erstellen Sie eine Rolle, die Ihr Benutzer annehmen kann. Befolgen Sie die Anleitung unter [Eine Rolle für einen IAM-Benutzer erstellen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) im *IAM-Benutzerhandbuch*.
+ (Nicht empfohlen) Weisen Sie einem Benutzer eine Richtlinie direkt zu oder fügen Sie einen Benutzer zu einer Benutzergruppe hinzu. Befolgen Sie die Anweisungen unter [Hinzufügen von Berechtigungen zu einem Benutzer (Konsole)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) im *IAM-Benutzerhandbuch*.
Amazon ElastiCache erstellt und verwendet servicebezogene Rollen, um in Ihrem Namen Ressourcen bereitzustellen und auf andere AWS Ressourcen und Services zuzugreifen. ElastiCache Um eine servicebezogene Rolle für Sie zu erstellen, verwenden Sie die AWS verwaltete Richtlinie mit dem Namen. `AmazonElastiCacheFullAccess` Diese Rolle besitzt die vordefinierte Berechtigung, die der Service benötigt, um eine Service-verknüpfte Rolle für Sie zu erstellen.
Sie können sich entscheiden, anstelle der Standardrichtlinie eine benutzerseitig verwaltete Richtlinie zu verwenden. Stellen Sie in diesem Fall sicher, dass Sie entweder über die Berechtigung zum Aufrufen von `iam:createServiceLinkedRole` verfügen oder die serviceverknüpfte ElastiCache-Rolle bereits erstellt wurde.
Weitere Informationen finden Sie hier:
+ [Erstellen einer neuen Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html)(IAM)
+ [AWS verwaltete Richtlinien für Amazon ElastiCache](IAM.IdentityBasedPolicies.PredefinedPolicies.md)
+ [Verwenden von serviceverknüpften Rollen für Amazon ElastiCache](using-service-linked-roles.md)
## Richten Sie ein EC2
Sie müssen eine EC2 Instanz einrichten, von der aus Sie eine Verbindung zu Ihrem Cache herstellen.
+ Wenn Sie noch keine EC2 Instance haben, erfahren Sie hier, wie Sie eine EC2 Instance einrichten: [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
+ Ihre EC2 Instance muss sich in derselben VPC befinden und dieselben Sicherheitsgruppeneinstellungen wie Ihr Cache haben. Standardmäßig ElastiCache erstellt Amazon einen Cache in Ihrer Standard-VPC und verwendet die Standardsicherheitsgruppe. Um diesem Tutorial zu folgen, stellen Sie sicher, dass sich Ihre EC2 Instance in der Standard-VPC befindet und über die Standardsicherheitsgruppe verfügt.
## Gewähren des Netzwerkzugriffs aus einer Amazon-VPC-Sicherheitsgruppe für den Cache
ElastiCache knotenbasierte Cluster verwenden Port 6379 für Valkey- und Redis OSS-Befehle, und ElastiCache Serverless verwendet sowohl Port 6379 als auch Port 6380. Um erfolgreich eine Verbindung herzustellen und Valkey- oder Redis OSS-Befehle von Ihrer EC2 Instance aus auszuführen, muss Ihre Sicherheitsgruppe bei Bedarf Zugriff auf diese Ports gewähren.
ElastiCache for Memcached verwendet die Ports 11211 und 11212, um Memcached-Befehle zu akzeptieren. Um erfolgreich eine Verbindung herzustellen und Memcached-Befehle von Ihrer EC2 Instance aus auszuführen, muss Ihre Sicherheitsgruppe den Zugriff auf diese Ports zulassen.
1. Melden Sie sich bei der an AWS Command Line Interface und öffnen Sie die [ EC2 Amazon-Konsole](https://console.aws.amazon.com/ec2/).
1. Wählen Sie in der Navigationsleiste unter **Network &Security** die Option **Security Groups** aus.
1. Wählen Sie aus der Liste der Sicherheitsgruppen die Sicherheitsgruppe Ihrer Amazon VPC aus. Sofern Sie keine Sicherheitsgruppe zur ElastiCache Verwendung erstellt haben, wird diese Sicherheitsgruppe als *Standard* bezeichnet.
1. Klicken Sie auf die Registerkarte „Eingehend“ und führen Sie anschließend folgende Schritte aus.
1. Wählen Sie **Bearbeiten** aus.
1. Wählen Sie **Regel hinzufügen** aus.
1. Wählen Sie in der Spalte „Typ“ die Option **Benutzerdefinierte TCP-Regel** aus.
1. Wenn Sie Valkey oder Redis OSS verwenden, geben Sie in das Feld **Portbereich** den Text ein. `6379`
Wenn Sie Memcached verwenden, geben Sie in das Feld **Portbereich den Text** ein. `11211`
1. Wählen Sie im Feld **Quelle** die Option **Anywhere** mit dem Portbereich (0.0.0.0/0) aus, sodass jede EC2 Amazon-Instance, die Sie in Ihrer Amazon VPC starten, eine Verbindung zu Ihrem Cache herstellen kann.
1. **Wenn Sie ElastiCache Serverless verwenden, fügen Sie eine weitere Regel hinzu, indem Sie Regel hinzufügen wählen.**
1. Wählen Sie in der Spalte **Typ** die Option **Benutzerdefinierte TCP-Regel** aus.
1. Wenn Sie es ElastiCache für Redis OSS verwenden, geben Sie in das Feld **Portbereich** den Text ein. `6380`
Wenn Sie ElastiCache für Memcached verwenden, geben Sie in das Feld **Portbereich** den Text ein. `11212`
1. Wählen Sie im Feld **Quelle** die Option **Anywhere** mit dem Portbereich (0.0.0.0/0) aus, sodass jede EC2 Amazon-Instance, die Sie in Ihrer Amazon VPC starten, eine Verbindung zu Ihrem Cache herstellen kann.
1. Wählen Sie **Speichern** aus.
## Laden Sie den Befehlszeilenzugriff herunter und richten Sie ihn ein
***Laden Sie das Valkey-Cli-Hilfsprogramm herunter und installieren Sie es.***
Wenn Sie ElastiCache für Valkey verwenden, finden Sie das Valkey-Cli-Hilfsprogramm möglicherweise nützlich. Wenn Sie ElastiCache für Redis OSS mit redis-cli verwenden, sollten Sie erwägen, zu valkey-cli zu wechseln, da es auch für Redis OSS funktioniert.
1. Connect Sie mithilfe des Verbindungsdienstprogramms Ihrer Wahl eine Verbindung zu Ihrer EC2 Amazon-Instance her. Anweisungen zum Herstellen einer Verbindung mit einer EC2 Amazon-Instance finden Sie im [Amazon-Handbuch „ EC2 Erste Schritte](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html)“.
1. Laden Sie das valkey-cli Utility herunter und installieren Sie es, indem Sie den entsprechenden Befehl für Ihr Setup ausführen.
**Amazon Linux 2**
```
sudo amazon-linux-extras install epel -y
sudo yum install gcc jemalloc-devel openssl-devel tcl tcl-devel -y
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 BUILD_TLS=yes
```
**Anmerkung**
Beim Installieren des redis6-Pakets wird redis6-cli mit standardmäßiger Verschlüsselungsunterstützung installiert.
Bei der Installation von valkey-cli oder redis-cli ist es wichtig, Build-Unterstützung für TLS zu haben. ElastiCache Serverless ist nur zugänglich, wenn TLS aktiviert ist.
Wenn der Cluster, mit dem Sie eine Verbindung herstellen, nicht verschlüsselt ist, benötigen Sie die Option `Build_TLS=yes` nicht.
# Erstellen Sie einen serverlosen Valkey-Cache
In diesem Schritt erstellen Sie einen neuen Cache in Amazon ElastiCache.
**AWS-Managementkonsole**
So erstellen Sie mit der ElastiCache Konsole einen neuen Cache:
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Wählen Sie im Navigationsbereich auf der linken Seite der Konsole **Valkey-Caches** aus.
1. Wählen Sie auf der rechten Seite der Konsole die Option Valkey-Cache **erstellen**
1. Geben Sie in den **Cache-Einstellungen** einen **Namen** ein. Sie können optional eine **Beschreibung** für den Cache eingeben.
1. Lassen Sie die Standardeinstellungen ausgewählt.
1. Klicken Sie auf **Erstellen**, um den Cache zu erstellen.
1. Sobald sich der Cache im Status „AKTIV“ befindet, können Sie mit dem Schreiben und Lesen von Daten in den Cache beginnen.
**AWS CLI**
Das folgende AWS CLI Beispiel erstellt einen neuen Cache mit create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine valkey
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine valkey
```
Beachten Sie, dass für das Feld „Status“ der Wert `CREATING` festgelegt ist.
Verwenden Sie den `describe-serverless-caches` Befehl, ElastiCache um zu überprüfen, ob die Erstellung des Caches abgeschlossen ist.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Fahren Sie nach dem Erstellen des neuen Caches mit [Daten in den Cache lesen und in den Cache schreiben](GettingStarted.serverless-valkey.step2.md) fort.
# Daten in den Cache lesen und in den Cache schreiben
In diesem Abschnitt wird davon ausgegangen, dass Sie eine EC2 Amazon-Instance erstellt haben und eine Verbindung zu ihr herstellen können. Eine Anleitung dazu finden Sie im [Amazon EC2 Getting Started Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html).
In diesem Abschnitt wird auch davon ausgegangen, dass Sie VPC-Zugriffs- und Sicherheitsgruppeneinstellungen für die EC2 Instance eingerichtet haben, von der aus Sie eine Verbindung zu Ihrem Cache herstellen, und Valkey-CLI auf Ihrer Instance eingerichtet haben. EC2 Weitere Informationen zu diesem Schritt finden Sie unter [Einrichten ElastiCache](set-up.md).
Wenn Sie über eine große oder globale Anwendung verfügen, können Sie zusätzlich zu den unten aufgeführten Schritten die Leseleistung erheblich steigern, indem Sie Replikate erstellen und aus ihnen lesen. Weitere Informationen zu diesem fortgeschritteneren Schritt finden Sie unter[Bewährte Methoden für die Verwendung von Read Replicas](ReadReplicas.md).
**Finden Ihres Cache-Endpunkts**
**AWS-Managementkonsole**
So finden Sie den Endpunkt Ihres Caches mithilfe der ElastiCache 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 Navigationsbereich auf der linken Seite der Konsole **Valkey-Caches** aus.
1. Klicken Sie auf der rechten Seite der Konsole auf den Namen des Caches, den Sie gerade erstellt haben.
1. Suchen Sie in den **Cache-Details** den Cache-Endpunkt und kopieren Sie ihn.
**AWS CLI**
Das folgende AWS CLI Beispiel zeigt, wie Sie mit dem Befehl den Endpunkt für Ihren neuen Cache finden. describe-serverless-caches Nachdem Sie den Befehl ausgeführt haben, suchen Sie nach dem Feld „Endpunkt“.
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Connect zu Ihrem Valkey Cache her (Linux)
Jetzt, da Sie den benötigten Endpunkt haben, können Sie sich bei Ihrer EC2 Instance anmelden und eine Verbindung zum Cache herstellen. Im folgenden Beispiel verwenden Sie das Hilfsprogramm *valkey-cli*, um eine Verbindung zu einem Cluster herzustellen. Der folgende Befehl stellt eine Verbindung mit einem Cache her. (Hinweis: Ersetzen Sie cache-endpoint durch den Endpunkt, den Sie im vorherigen Schritt abgerufen haben.)
```
src/valkey-cli -h cache-endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
## Connect zu Ihrem Valkey Cache her (Windows)
Jetzt, da Sie den benötigten Endpunkt haben, können Sie sich bei Ihrer EC2 Instance anmelden und eine Verbindung zum Cache herstellen. Im folgenden Beispiel verwenden Sie das Hilfsprogramm *valkey-cli*, um eine Verbindung zu einem Cluster herzustellen. Mit dem folgenden Befehl stellen Sie eine Verbindung mit einem Cache her. Öffnen Sie die Befehlszeile, wechseln Sie zum Valkey- oder Redis-OSS-Verzeichnis und führen Sie den Befehl aus (Hinweis: Ersetzen Sie Cache\$1Endpoint durch den Endpunkt, den Sie im vorherigen Schritt abgerufen haben).
```
c:\Valkey>valkey-cli -h Valkey_Cluster_Endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
Sie können jetzt mit [(Optional) Bereinigen](GettingStarted.serverless-valkey.step3.md) fortfahren.
# (Optional) Bereinigen
Wenn Sie den von Ihnen erstellten ElastiCache Amazon-Cache nicht mehr benötigen, können Sie ihn löschen. Mit diesem Schritt wird sichergestellt, dass Ihnen keine Ressourcen in Rechnung gestellt werden, die Sie nicht nutzen. Sie können die ElastiCache Konsole, die oder die ElastiCache API verwenden AWS CLI, um Ihren Cache zu löschen.
**AWS-Managementkonsole**
So löschen Sie Ihren Cache 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 Navigationsbereich auf der linken Seite der Konsole **Valkey Caches** aus.
1. Wählen Sie das Optionsfeld neben dem Cache, dem Sie löschen möchten.
1. Wählen Sie oben rechts **Aktionen** und dann **Löschen** aus.
1. Sie können sich optional dafür entscheiden, einen abschließenden Snapshot zu erstellen, bevor Sie Ihren Cache löschen.
1. Geben Sie auf dem Bestätigungsbildschirm **Löschen** den Cache-Namen erneut ein und wählen Sie die Option **Löschen** aus, um den Cluster zu löschen, oder **Abbrechen**, um den Cluster beizubehalten.
Sobald Ihr Cache in den Status **DELETING** wechselt, fallen für ihn keine Gebühren mehr an.
**AWS CLI**
Im folgenden AWS CLI Beispiel wird ein Cache mithilfe des Befehls gelöscht. delete-serverless-cache
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
Beachten Sie, dass für das Feld **Status** der Wert **DELETING** festgelegt ist.
Sie können jetzt mit [Nächste Schritte](GettingStarted.serverless-valkey.next-steps.md) fortfahren.
# Nächste Schritte
Weitere Informationen dazu ElastiCache finden Sie auf den folgenden Seiten:
+ [Arbeiten mit ElastiCache](WorkingWithElastiCache.md)
+ [Skalierung ElastiCache](Scaling.md)
+ [Protokollierung und Überwachung in Amazon ElastiCache](MonitoringECMetrics.md)
+ [ElastiCache Best Practices und Caching-Strategien](BestPractices.md)
+ [Snapshot und Wiederherstellung](backups.md)
+ [Amazon SNS SNS-Überwachung von Ereignissen ElastiCache](ECEvents.md)
# Erstellen Sie einen serverlosen Redis OSS-Cache
In diesem Schritt erstellen Sie einen neuen Cache in Amazon ElastiCache.
**AWS-Managementkonsole**
So erstellen Sie mit der ElastiCache Konsole einen neuen Cache:
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 im Navigationsbereich auf der linken Seite der Konsole **Redis OSS-Caches** aus.
1. Wählen Sie auf der rechten Seite der Konsole die Option **Redis OSS-Cache erstellen**
1. Geben Sie in den **Cache-Einstellungen** einen **Namen** ein. Sie können optional eine **Beschreibung** für den Cache eingeben.
1. Lassen Sie die Standardeinstellungen ausgewählt.
1. Klicken Sie auf **Erstellen**, um den Cache zu erstellen.
1. Sobald sich der Cache im Status „AKTIV“ befindet, können Sie mit dem Schreiben und Lesen von Daten in den Cache beginnen.
**AWS CLI**
Das folgende AWS CLI Beispiel erstellt einen neuen Cache mit create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine redis
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine redis
```
Beachten Sie, dass für das Feld „Status“ der Wert `CREATING` festgelegt ist.
Verwenden Sie den `describe-serverless-caches` Befehl, ElastiCache um zu überprüfen, ob die Erstellung des Caches abgeschlossen ist.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Fahren Sie nach dem Erstellen des neuen Caches mit [Daten in den Cache lesen und in den Cache schreiben](GettingStarted.serverless-redis.step2.md) fort.
# Daten in den Cache lesen und in den Cache schreiben
In diesem Abschnitt wird davon ausgegangen, dass Sie eine EC2 Amazon-Instance erstellt haben und eine Verbindung zu ihr herstellen können. Eine Anleitung dazu finden Sie im [Amazon EC2 Getting Started Guide](https://aws.amazon.com/ec2/getting-started/).
In diesem Abschnitt wird auch davon ausgegangen, dass Sie VPC-Zugriffs- und Sicherheitsgruppeneinstellungen für die EC2 Instance eingerichtet haben, von der aus Sie eine Verbindung zu Ihrem Cache herstellen, und Valkey-CLI auf Ihrer Instance eingerichtet haben. EC2 Weitere Informationen zu diesem Schritt finden Sie unter [Einrichten ElastiCache](set-up.md).
**Finden Ihres Cache-Endpunkts**
**AWS-Managementkonsole**
So finden Sie den Endpunkt Ihres Caches mithilfe der Konsole: ElastiCache
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 Navigationsbereich auf der linken Seite der Konsole **Valkey caches **Redis** OSS caches** aus.
1. Klicken Sie auf der rechten Seite der Konsole auf den Namen des Caches, den Sie gerade erstellt haben.
1. Suchen Sie in den **Cache-Details** den Cache-Endpunkt und kopieren Sie ihn.
**AWS CLI**
Das folgende AWS CLI Beispiel zeigt, wie Sie mit dem Befehl den Endpunkt für Ihren neuen Cache finden. describe-serverless-caches Nachdem Sie den Befehl ausgeführt haben, suchen Sie nach dem Feld „Endpunkt“.
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Connect zu Ihrem Valkey- oder Redis OSS-Cache her (Linux)
Jetzt, da Sie den Endpunkt haben, den Sie benötigen, können Sie sich bei Ihrer EC2 Instance anmelden und eine Verbindung zum Cache herstellen. Im folgenden Beispiel verwenden Sie das Hilfsprogramm *valkey-cli*, um eine Verbindung zu einem Cluster herzustellen. Der folgende Befehl stellt eine Verbindung mit einem Cache her. (Hinweis: Ersetzen Sie cache-endpoint durch den Endpunkt, den Sie im vorherigen Schritt abgerufen haben.)
```
src/valkey-cli -h cache-endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
## Connect zu Ihrem Valkey- oder Redis OSS-Cache her (Windows)
Da Sie nun den benötigten Endpunkt haben, können Sie sich bei Ihrer EC2 Instance anmelden und eine Verbindung zum Cache herstellen. Im folgenden Beispiel verwenden Sie das Hilfsprogramm *valkey-cli*, um eine Verbindung zu einem Cluster herzustellen. Mit dem folgenden Befehl stellen Sie eine Verbindung mit einem Cache her. Öffnen Sie die Befehlszeile, wechseln Sie zum Valkey-Verzeichnis und führen Sie den Befehl aus (Hinweis: Ersetzen Sie Cache\$1Endpoint durch den Endpunkt, den Sie im vorherigen Schritt abgerufen haben).
```
c:\Redis>valkey-cli -h Redis_Cluster_Endpoint --tls -p 6379
set a "hello" // Set key "a" with a string value and no expiration
OK
get a // Get value for key "a"
"hello"
```
Sie können jetzt mit [(Optional) Bereinigen](GettingStarted.serverless-redis.step3.md) fortfahren.
# (Optional) Bereinigen
Wenn Sie den von Ihnen erstellten ElastiCache Amazon-Cache nicht mehr benötigen, können Sie ihn löschen. Mit diesem Schritt wird sichergestellt, dass Ihnen keine Ressourcen in Rechnung gestellt werden, die Sie nicht nutzen. Sie können die ElastiCache Konsole, die oder die ElastiCache API verwenden AWS CLI, um Ihren Cache zu löschen.
**AWS-Managementkonsole**
So löschen Sie Ihren Cache 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 Navigationsbereich auf der linken Seite der Konsole **Valkey oder Redis OSS** Caches aus.
1. Wählen Sie das Optionsfeld neben dem Cache, dem Sie löschen möchten.
1. Wählen Sie oben rechts **Aktionen** und dann **Löschen** aus.
1. Sie können sich optional dafür entscheiden, einen abschließenden Snapshot zu erstellen, bevor Sie Ihren Cache löschen.
1. Geben Sie auf dem Bestätigungsbildschirm **Löschen** den Cache-Namen erneut ein und wählen Sie die Option **Löschen** aus, um den Cluster zu löschen, oder **Abbrechen**, um den Cluster beizubehalten.
Sobald Ihr Cache in den Status **DELETING** wechselt, fallen für ihn keine Gebühren mehr an.
**AWS CLI**
Im folgenden AWS CLI Beispiel wird ein Cache mit dem Befehl gelöscht. delete-serverless-cache
**Linux**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name CacheName
```
Beachten Sie, dass für das Feld **Status** der Wert **DELETING** festgelegt ist.
Sie können jetzt mit [Nächste Schritte](GettingStarted.serverless-redis.next-steps.md) fortfahren.
# Nächste Schritte
Weitere Informationen dazu ElastiCache finden Sie auf den folgenden Seiten:
+ [Arbeiten mit ElastiCache](WorkingWithElastiCache.md)
+ [Skalierung ElastiCache](Scaling.md)
+ [Protokollierung und Überwachung in Amazon ElastiCache](MonitoringECMetrics.md)
+ [ElastiCache Best Practices und Caching-Strategien](BestPractices.md)
+ [Snapshot und Wiederherstellung](backups.md)
+ [Amazon SNS SNS-Überwachung von Ereignissen ElastiCache](ECEvents.md)
# Einen serverlosen Memcached-Cache erstellen
**AWS-Managementkonsole**
So erstellen Sie mit der Konsole einen neuen serverlosen Memcached-Cache: ElastiCache
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. Klicken Sie im Navigationsbereich auf der linken Seite der Konsole auf **Memcached-Caches**.
1. Wählen Sie auf der rechten Seite der Konsole **Memcached-Cache erstellen** aus.
1. Geben Sie in den **Cache-Einstellungen** einen **Namen** ein. Sie können optional eine **Beschreibung** für den Cache eingeben.
1. Lassen Sie die Standardeinstellungen ausgewählt.
1. Klicken Sie auf **Erstellen**, um den Cache zu erstellen.
1. Sobald sich der Cache im Status „AKTIV“ befindet, können Sie mit dem Schreiben und Lesen von Daten in den Cache beginnen.
Um einen neuen Cache mit dem zu erstellen AWS CLI
Das folgende AWS CLI Beispiel erstellt einen neuen Cache mit create-serverless-cache.
**Linux**
```
aws elasticache create-serverless-cache \
--serverless-cache-name CacheName \
--engine memcached
```
**Windows**
```
aws elasticache create-serverless-cache ^
--serverless-cache-name CacheName ^
--engine memcached
```
Beachten Sie, dass für das Feld „Status“ der Wert `CREATING` festgelegt ist.
Verwenden Sie den `describe-serverless-caches` Befehl, ElastiCache um zu überprüfen, ob die Erstellung des Caches abgeschlossen ist.
**Linux**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Fahren Sie nach dem Erstellen des neuen Caches mit [Daten in den Cache lesen und in den Cache schreiben](read-write-cache-mem.md) fort.
# Daten in den Cache lesen und in den Cache schreiben
In diesem Abschnitt wird davon ausgegangen, dass Sie eine EC2 Amazon-Instance erstellt haben und eine Verbindung zu ihr herstellen können. Eine Anleitung dazu finden Sie im [Amazon-Leitfaden „ EC2 Erste Schritte](https://aws.amazon.com/ec2/getting-started/)“.
ElastiCache Erstellt standardmäßig einen Cache in Ihrer Standard-VPC. Stellen Sie sicher, dass Ihre EC2 Instance auch in der Standard-VPC erstellt wurde, damit sie eine Verbindung zum Cache herstellen kann.
**Finden Ihres Cache-Endpunkts**
**AWS-Managementkonsole**
So finden Sie den Endpunkt Ihres Caches mithilfe der ElastiCache 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. Klicken Sie im Navigationsbereich auf der linken Seite der Konsole auf **Memcached-Caches**.
1. Klicken Sie auf der rechten Seite der Konsole auf den Namen des Caches, den Sie gerade erstellt haben.
1. Suchen Sie in den **Cache-Details** den Cache-Endpunkt und kopieren Sie ihn.
**AWS CLI**
Das folgende AWS CLI Beispiel zeigt, wie Sie mit dem describe-serverless-caches Befehl den Endpunkt für Ihren neuen Cache ermitteln können. Nachdem Sie den Befehl ausgeführt haben, suchen Sie nach dem Feld „Endpunkt“.
**Linux**
```
aws elasticache describe-serverless-caches \
--serverless-cache-name CacheName
```
**Windows**
```
aws elasticache describe-serverless-caches ^
--serverless-cache-name CacheName
```
## Herstellen einer Verbindung mithilfe von OpenSSL
Weitere Informationen zum Herstellen einer Verbindung mithilfe von OpenSSL finden Sie unter [ElastiCache Verschlüsselung bei der Übertragung (TLS)](in-transit-encryption.md).
## Herstellen einer Verbindung mithilfe des Memcached-Java-Clients
```
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.FailureMode;
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);
// Set Failure Mode to Retry
connectionFactoryBuilder.setFailureMode(FailureMode.Retry);
MemcachedClient client = new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses("mycluster-fnjyzo.serverless.use1.cache.amazonaws.com:11211"));
// Store a data item for an hour.
client.set("theKey", 3600, "This is the data value");
}
}
```
## Herstellen einer Verbindung mithilfe des Memcached-PHP-Clients
```
addServer($cluster_endpoint, $server_port);
if(!$tls_client->setOption(Memcached::OPT_USE_TLS, 1)) {
echo $tls_client->getLastErrorMessage(), "\n";
exit(1);
}
$tls_config = new MemcachedTLSContextConfig();
$tls_config->hostname = '*.serverless.use1.cache.amazonaws.com';
$tls_config->skip_cert_verify = false;
$tls_config->skip_hostname_verify = false;
$tls_client->createAndSetTLSContext((array)$tls_config);
/* store the data for 60 seconds in the cluster */
$tls_client->set('key', 'value', 60);
?>
```
## Herstellen einer Verbindung mithilfe des Memcached-Python-Clients (Pymemcache)
Siehe [https://pymemcache.readthedocs. io/en/latest/getting](https://pymemcache.readthedocs.io/en/latest/getting_started.html)\$1started.html
```
import ssl
from pymemcache.client.base import Client
context = ssl.create_default_context()
cluster_endpoint =
target_port = 11211
memcached_client = Client(("{cluster_endpoint}", target_port), tls_context=context)
memcached_client.set("key", "value", expire=500, noreply=False)
assert self.memcached_client.get("key").decode() == "value"
```
## Connect mit dem NodeJS/TS Memcached-Client her (Electrode-IO Memcache)
[https://github.com/electrode-io/Siehe](https://github.com/electrode-io/memcache) Memcache und [https://www.npmjs.com/package/Memcache-Client](https://www.npmjs.com/package/memcache-client)
Installieren über `npm i memcache-client`
Erstellen Sie in der Anwendung wie folgt einen Memcached-TLS-Client:
```
var memcache = require("memcache-client");
const client = new memcache.MemcacheClient({server: "{cluster_endpoint}:11211", tls: {}});
client.set("key", "value");
```
## Herstellen einer Verbindung mithilfe des Memcached-Rust-Clients (rust-memcache)
Weitere [Informationen finden Sie unter https://crates. io/crates/memcache](https://crates.io/crates/memcache)und [https://github.com/aisk/Rust-Memcache](https://github.com/aisk/rust-memcache).
```
// create connection with to memcached server node:
let client = memcache::connect("memcache+tls://:11211?verify_mode=none").unwrap();
// set a string value
client.set("foo", "bar", 0).unwrap();
```
## Herstellen einer Verbindung mithilfe des Memcached-Go-Clients (Gomemcache)
[https://github.com/bradfitz/Siehe Gomemcache](https://github.com/bradfitz/gomemcache)
```
c := New(net.JoinHostPort("{cluster_endpoint}", strconv.Itoa(port)))
c.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
var td tls.Dialer
td.Config = &tls.Config{}
return td.DialContext(ctx, network, addr)
}
foo := &Item{Key: "foo", Value: []byte("fooval"), Flags: 123}
err := c.Set(foo)
```
## Herstellen einer Verbindung mithilfe des Memcached-Ruby-Clients (Dalli)
[Siehst du Dalli https://github.com/petergoldstein/](https://github.com/petergoldstein/dalli)
```
require 'dalli'
ssl_context = OpenSSL::SSL::SSLContext.new
ssl_context.ssl_version = :SSLv23
ssl_context.verify_hostname = true
ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
client = Dalli::Client.new(":11211", :ssl_context => ssl_context);
client.get("abc")
```
## Connect mit Memcached.NET-Client herstellen () EnyimMemcachedCore
Siehe [https://github.com/cnblogs/EnyimMemcachedCore](https://github.com/cnblogs/EnyimMemcachedCore)
```
"MemcachedClient": {
"Servers": [
{
"Address": "{cluster_endpoint}",
"Port": 11211
}
],
"UseSslStream": true
}
```
Sie können jetzt mit [(Optional) Bereinigen](read-write-cleanup-mem.md) fortfahren.
# (Optional) Bereinigen
**Mit dem AWS-Managementkonsole**
Mit dem folgenden Verfahren wird ein einzelner Cache aus Ihrer Bereitstellung gelöscht. Wenn Sie mehrere Caches löschen möchten, wiederholen Sie das Verfahren für jeden Cache, den Sie löschen möchten. Sie brauchen nicht zu warten, bis ein Cache fertig gelöscht ist, bevor Sie den Vorgang zum Löschen eines anderen Caches starten.
**So löschen Sie einen Cache**
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 Konsolen-Dashboard die Engine aus, die auf dem Cache läuft, den Sie löschen möchten. Es wird eine Liste mit allen Caches, in denen diese Engine ausgeführt wird, angezeigt.
1. Wählen Sie den Namen des Caches aus der Liste der Caches aus, um den zu löschenden Cache anzugeben.
**Wichtig**
Sie können jeweils nur einen Cache aus der ElastiCache Konsole löschen. Werden mehrere Caches ausgewählt, wird der Löschvorgang deaktiviert.
1. Klicken Sie bei ** Actions** auf **Delete**.
1. Wählen Sie auf dem Bestätigungsbildschirm **Cache löschen** die Option **Löschen** aus, um den Cache zu löschen, oder **Abbrechen**, wenn Sie den Cache luster beibehalten möchten.
1. Wenn Sie **Löschen** auswählen, ändert sich der Status des Caches in *deleting*.
Sobald Ihr Cache in den Status **DELETING** wechselt, fallen für ihn keine Gebühren mehr an.
**Mit dem AWS CLI**
Der folgende Code löscht den Cache my-cache.
```
aws elasticache delete-serverless-cache --serverless-cache-name my-cache
```
Die delete-serverless-cache CLI-Aktion löscht nur einen serverlosen Cache. Um mehrere Caches zu löschen, rufen Sie delete-serverless-cache jeden serverlosen Cache auf, den Sie löschen möchten. Sie brauchen nicht zu warten, bis ein Serverless-Cache fertig gelöscht ist, bevor Sie einen anderen löschen.
**Für Linux, macOS oder Unix:**
```
aws elasticache delete-serverless-cache \
--serverless-cache-name my-cache
```
**Für Windows:**
```
aws elasticache delete-serverless-cache ^
--serverless-cache-name my-cache
```
Weitere Informationen finden Sie im AWS CLI For-Thema. ElastiCache delete-serverless-cache
Sie können jetzt mit [Nächste Schritte](next-steps-mem.md) fortfahren.
# Nächste Schritte
Weitere Informationen dazu finden ElastiCache Sie unter:
+ [Arbeiten mit ElastiCache](WorkingWithElastiCache.md)
+ [Skalierung ElastiCache](Scaling.md)
+ [Kontingente für ElastiCache](quota-limits.md)
+ [ElastiCache Best Practices und Caching-Strategien](BestPractices.md)
+ [ElastiCache Ereignisse anzeigen](ECEvents.Viewing.md)
# Tutorials: Erste Schritte mit Python und ElastiCache
Dieser Abschnitt enthält praktische Tutorials, die Ihnen helfen, mehr über Valkey und Redis OSS zu ElastiCache erfahren. Wir empfehlen Ihnen, eines der sprachspezifischen Tutorials durchzuarbeiten.
**Anmerkung**
AWS SDKs sind für eine Vielzahl von Sprachen verfügbar. Eine vollständige Liste finden Sie unter [Tools für Amazon Web Services](https://aws.amazon.com/tools/).
**Topics**
+ [Python und ElastiCache](ElastiCache-Getting-Started-Tutorials-Python.md)
# Python und ElastiCache
In diesem Tutorial verwenden Sie das AWS SDK for Python (Boto3), um einfache Programme für die folgenden ElastiCache Operationen zu schreiben:
+ ElastiCache Für Redis OSS-Cluster erstellen (Clustermodus aktiviert und Clustermodus deaktiviert)
+ Prüfen Sie, ob Benutzer oder Benutzergruppen existieren, andernfalls erstellen Sie sie. (Diese Funktion ist mit Valkey 7.2 und höher sowie mit Redis OSS 6.0 bis 7.1 verfügbar.)
+ Verbinden mit ElastiCache
+ Führe Operationen wie das Einstellen und Abrufen von Zeichenketten, das Lesen von und Schreiben in Streams sowie das Veröffentlichen und Abonnieren von Inhalten über den Kanal aus. Pub/Sub
Während Sie dieses Tutorial durcharbeiten, können Sie sich auf die Dokumentation zum AWS SDK für Python (Boto) beziehen. Der folgende Abschnitt ist spezifisch für ElastiCache: [ElastiCache Low-Level-Client](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elasticache.html)
## Tutorial-Voraussetzungen
+ Richten Sie einen AWS Zugriffsschlüssel ein, um den zu verwenden.AWS SDKs Weitere Informationen finden Sie unter [Einrichten ElastiCache](set-up.md).
+ Python 3.0 oder später installieren. Weitere Informationen finden Sie unter [https://www.python.org/downloads](https://www.python.org/downloads). Weiter Informationen finden Sie unter [Quickstart](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) in der Boto 3-Dokumentation.
**Topics**
+ [Tutorial-Voraussetzungen](#ElastiCache-Getting-Started-Tutorials-Prerquisites)
+ [Tutorial: ElastiCache Cluster und Benutzer erstellen](#ElastiCache-Getting-Started-Tutorials-Create-Cluster-and-Users)
+ [Tutorial: Verbindung herstellen mit ElastiCache](#ElastiCache-Getting-Started-Tutorials-Connecting)
+ [Verwendungsbeispiele](#ElastiCache-Getting-Started-Tutorials-Usage)
## Tutorial: ElastiCache Cluster und Benutzer erstellen
In den folgenden Beispielen werden das boto3 SDK ElastiCache für Redis OSS-Verwaltungsvorgänge (Cluster- oder Benutzererstellung) und redis-py-cluster redis-py/ für die Datenverarbeitung verwendet.
**Topics**
+ [Erstellen Sie einen Cluster mit deaktiviertem Cluster-Modus](#ElastiCache-Getting-Started-Tutorials-Create-Cluster)
+ [Erstellen eines Clusters mit deaktivierten Cluster-Modus mit TLS und RBAC](#ElastiCache-Getting-Started-Tutorials-RBAC)
+ [Erstellen Sie einen Cluster mit aktiviertem Cluster-Modus](#ElastiCache-Getting-Started-Tutorials-Cluster-Enabled)
+ [Erstellen Sie einen Cluster mit aktiviertem Cluster-Modus mit TLS und RBAC](#ElastiCache-Getting-Started-Tutorials-Cluster-RBAC)
+ [Prüfen Sie, ob sie users/usergroup existieren, andernfalls erstellen Sie sie](#ElastiCache-Getting-Started-Tutorials-Users)
### Erstellen Sie einen Cluster mit deaktiviertem Cluster-Modus
*Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen .py ein. CreateClusterModeDisabledCluster*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_disabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumCacheClusters=2,ReplicationGroupDescription='Sample cluster',ReplicationGroupId=None):
"""Creates an ElastiCache Cluster with cluster mode disabled
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumCacheClusters: Number of nodes in the cluster. Minimum 1 (just a primary node) and maximun 6 (1 primary and 5 replicas).
If not specified, cluster will be created with 1 primary and 1 replica.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
response = client.create_replication_group(
AutomaticFailoverEnabled=True,
CacheNodeType=CacheNodeType,
Engine='valkey',
EngineVersion=EngineVersion,
NumCacheClusters=NumCacheClusters,
ReplicationGroupDescription=ReplicationGroupDescription,
ReplicationGroupId=ReplicationGroupId,
SnapshotRetentionLimit=30,
)
return response
if __name__ == '__main__':
# Creates an ElastiCache Cluster mode disabled cluster, based on cache.m6g.large nodes, Valkey 8.0, one primary and two replicas
elasticacheResponse = create_cluster_mode_disabled(
#CacheNodeType='cache.m6g.large',
EngineVersion='8.0',
NumCacheClusters=3,
ReplicationGroupDescription='Valkey cluster mode disabled with replicas',
ReplicationGroupId='valkey202104053'
)
logging.info(elasticacheResponse)
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python CreateClusterModeDisabledCluster.py`
Weitere Informationen finden Sie unter [Verwaltung von Clustern in ElastiCache](Clusters.md).
### Erstellen eines Clusters mit deaktivierten Cluster-Modus mit TLS und RBAC
Um die Sicherheit zu gewährleisten, können Sie Transport Layer Security (TLS) und rollenbasierte Zugriffssteuerung (RBAC) beim Erstellen eines Clusters mit deaktiviertem Cluster-Modus verwenden. Im Gegensatz zu Valkey oder Redis OSS AUTH, bei denen alle authentifizierten Clients vollen Zugriff auf die Replikationsgruppe haben, wenn ihr Token authentifiziert ist, können Sie mit RBAC den Clusterzugriff über Benutzergruppen steuern. Diese Benutzergruppen dienen dazu, den Zugriff auf Replikationsgruppen zu organisieren. Weitere Informationen finden Sie unter [Rollenbasierte Zugriffskontrolle (RBAC)](Clusters.RBAC.md).
*Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen RBAC.py ein. ClusterModeDisabledWith*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_disabled_rbac(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumCacheClusters=2,ReplicationGroupDescription='Sample cluster',ReplicationGroupId=None, UserGroupIds=None, SecurityGroupIds=None,CacheSubnetGroupName=None):
"""Creates an ElastiCache Cluster with cluster mode disabled and RBAC
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumCacheClusters: Number of nodes in the cluster. Minimum 1 (just a primary node) and maximun 6 (1 primary and 5 replicas).
If not specified, cluster will be created with 1 primary and 1 replica.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Mandatory name for the cluster.
:param UserGroupIds: The ID of the user group to be assigned to the cluster.
:param SecurityGroupIds: List of security groups to be assigned. If not defined, default will be used
:param CacheSubnetGroupName: subnet group where the cluster will be placed. If not defined, default will be used.
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return {'Error': 'ReplicationGroupId parameter is required'}
elif not isinstance(UserGroupIds,(list)):
return {'Error': 'UserGroupIds parameter is required and must be a list'}
params={'AutomaticFailoverEnabled': True,
'CacheNodeType': CacheNodeType,
'Engine': 'valkey',
'EngineVersion': EngineVersion,
'NumCacheClusters': NumCacheClusters,
'ReplicationGroupDescription': ReplicationGroupDescription,
'ReplicationGroupId': ReplicationGroupId,
'SnapshotRetentionLimit': 30,
'TransitEncryptionEnabled': True,
'UserGroupIds':UserGroupIds
}
# defaults will be used if CacheSubnetGroupName or SecurityGroups are not explicit.
if isinstance(SecurityGroupIds,(list)):
params.update({'SecurityGroupIds':SecurityGroupIds})
if CacheSubnetGroupName:
params.update({'CacheSubnetGroupName':CacheSubnetGroupName})
response = client.create_replication_group(**params)
return response
if __name__ == '__main__':
# Creates an ElastiCache Cluster mode disabled cluster, based on cache.m6g.large nodes, Valkey 8.0, one primary and two replicas.
# Assigns the existent user group "mygroup" for RBAC authentication
response=create_cluster_mode_disabled_rbac(
CacheNodeType='cache.m6g.large',
EngineVersion='8.0',
NumCacheClusters=3,
ReplicationGroupDescription='Valkey cluster mode disabled with replicas',
ReplicationGroupId='valkey202104',
UserGroupIds=[
'mygroup'
],
SecurityGroupIds=[
'sg-7cc73803'
],
CacheSubnetGroupName='default'
)
logging.info(response)
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python ClusterModeDisabledWithRBAC.py`
Weitere Informationen finden Sie unter [Verwaltung von Clustern in ElastiCache](Clusters.md).
### Erstellen Sie einen Cluster mit aktiviertem Cluster-Modus
Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen *ClusterModeEnabled.py* ein.
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_enabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumNodeGroups=1,ReplicasPerNodeGroup=1, ReplicationGroupDescription='Sample cache with cluster mode enabled',ReplicationGroupId=None):
"""Creates an ElastiCache Cluster with cluster mode enabled
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumNodeGroups: Number of shards in the cluster. Minimum 1 and maximun 90.
If not specified, cluster will be created with 1 shard.
:param ReplicasPerNodeGroup: Number of replicas per shard. If not specified 1 replica per shard will be created.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
response = client.create_replication_group(
AutomaticFailoverEnabled=True,
CacheNodeType=CacheNodeType,
Engine='valkey',
EngineVersion=EngineVersion,
ReplicationGroupDescription=ReplicationGroupDescription,
ReplicationGroupId=ReplicationGroupId,
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary node (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=NumNodeGroups,
ReplicasPerNodeGroup=ReplicasPerNodeGroup,
CacheParameterGroupName='default.valkey7.2.cluster.on'
)
return response
# Creates a cluster mode enabled
response = create_cluster_mode_enabled(
CacheNodeType='cache.m6g.large',
EngineVersion='6.0',
ReplicationGroupDescription='Valkey cluster mode enabled with replicas',
ReplicationGroupId='valkey20210',
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=2,
ReplicasPerNodeGroup=1,
)
logging.info(response)
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python ClusterModeEnabled.py`
Weitere Informationen finden Sie unter [Verwaltung von Clustern in ElastiCache](Clusters.md).
### Erstellen Sie einen Cluster mit aktiviertem Cluster-Modus mit TLS und RBAC
Um die Sicherheit zu gewährleisten, können Sie Transport Layer Security (TLS) und rollenbasierte Zugriffssteuerung (RBAC) beim Erstellen eines Clusters mit aktiviertem Cluster-Modus verwenden. Im Gegensatz zu Valkey oder Redis OSS AUTH, bei denen alle authentifizierten Clients vollen Zugriff auf die Replikationsgruppe haben, wenn ihr Token authentifiziert ist, können Sie mit RBAC den Clusterzugriff über Benutzergruppen steuern. Diese Benutzergruppen dienen dazu, den Zugriff auf Replikationsgruppen zu organisieren. Weitere Informationen finden Sie unter [Rollenbasierte Zugriffskontrolle (RBAC)](Clusters.RBAC.md).
*Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen RBAC.py ein. ClusterModeEnabledWith*
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def create_cluster_mode_enabled(CacheNodeType='cache.t3.small',EngineVersion='6.0',NumNodeGroups=1,ReplicasPerNodeGroup=1, ReplicationGroupDescription='Sample cache with cluster mode enabled',ReplicationGroupId=None,UserGroupIds=None, SecurityGroupIds=None,CacheSubnetGroupName=None,CacheParameterGroupName='default.valkey7.2.cluster.on'):
"""Creates an ElastiCache Cluster with cluster mode enabled and RBAC
Returns a dictionary with the API response
:param CacheNodeType: Node type used on the cluster. If not specified, cache.t3.small will be used
Refer to https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/CacheNodes.SupportedTypes.html for supported node types
:param EngineVersion: Engine version to be used. If not specified, latest will be used.
:param NumNodeGroups: Number of shards in the cluster. Minimum 1 and maximun 90.
If not specified, cluster will be created with 1 shard.
:param ReplicasPerNodeGroup: Number of replicas per shard. If not specified 1 replica per shard will be created.
:param ReplicationGroupDescription: Description for the cluster.
:param ReplicationGroupId: Name for the cluster.
:param CacheParameterGroupName: Parameter group to be used. Must be compatible with the engine version and cluster mode enabled.
:return: dictionary with the API results
"""
if not ReplicationGroupId:
return 'ReplicationGroupId parameter is required'
elif not isinstance(UserGroupIds,(list)):
return {'Error': 'UserGroupIds parameter is required and must be a list'}
params={'AutomaticFailoverEnabled': True,
'CacheNodeType': CacheNodeType,
'Engine': 'valkey',
'EngineVersion': EngineVersion,
'ReplicationGroupDescription': ReplicationGroupDescription,
'ReplicationGroupId': ReplicationGroupId,
'SnapshotRetentionLimit': 30,
'TransitEncryptionEnabled': True,
'UserGroupIds':UserGroupIds,
'NumNodeGroups': NumNodeGroups,
'ReplicasPerNodeGroup': ReplicasPerNodeGroup,
'CacheParameterGroupName': CacheParameterGroupName
}
# defaults will be used if CacheSubnetGroupName or SecurityGroups are not explicit.
if isinstance(SecurityGroupIds,(list)):
params.update({'SecurityGroupIds':SecurityGroupIds})
if CacheSubnetGroupName:
params.update({'CacheSubnetGroupName':CacheSubnetGroupName})
response = client.create_replication_group(**params)
return response
if __name__ == '__main__':
# Creates a cluster mode enabled cluster
response = create_cluster_mode_enabled(
CacheNodeType='cache.m6g.large',
EngineVersion='7.2',
ReplicationGroupDescription='Valkey cluster mode enabled with replicas',
ReplicationGroupId='valkey2021',
# Creates a cluster mode enabled cluster with 1 shard(NumNodeGroups), 1 primary (implicit) and 2 replicas (replicasPerNodeGroup)
NumNodeGroups=2,
ReplicasPerNodeGroup=1,
UserGroupIds=[
'mygroup'
],
SecurityGroupIds=[
'sg-7cc73803'
],
CacheSubnetGroupName='default'
)
logging.info(response)
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python ClusterModeEnabledWithRBAC.py`
Weitere Informationen finden Sie unter [Verwaltung von Clustern in ElastiCache](Clusters.md).
### Prüfen Sie, ob sie users/usergroup existieren, andernfalls erstellen Sie sie
Mithilfe von RBAC erstellen Sie Benutzer und weisen ihnen spezifische Berechtigungen zu, indem Sie eine Zugriffszeichenfolge verwenden, wie im Folgenden beschrieben. Sie weisen die Benutzer Benutzergruppen zu, denen eine bestimmte Rolle zugewiesen ist (Administratoren, Personalabteilung), die dann einer oder mehreren ElastiCache Redis OSS-Replikationsgruppen zugewiesen werden. Auf diese Weise können Sie Sicherheitsgrenzen zwischen Clients einrichten, die dieselbe Valkey- oder Redis OSS-Replikationsgruppe (n) verwenden, und verhindern, dass Clients gegenseitig auf die Daten zugreifen. Weitere Informationen finden Sie unter [Rollenbasierte Zugriffskontrolle (RBAC)](Clusters.RBAC.md).
*Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen UserAndUserGroups .py ein.* Aktualisieren Sie den Mechanismus für die Bereitstellung von Anmeldeinformationen. In diesem Beispiel werden Anmeldeinformationen als ersetzbar angezeigt und ihnen wird ein nicht deklariertes Element zugewiesen. Vermeiden Sie die Hartkodierung von Anmeldeinformationen.
In diesem Beispiel wird eine Zugriffszeichenfolge mit den Berechtigungen für den Benutzer verwendet. Weitere Informationen zu Zugriffszeichenfolgen finden Sie unter[Spezifizieren von Berechtigungen mithilfe einer Zugriffszeichenfolge](Clusters.RBAC.md#Access-string).
```
import boto3
import logging
logging.basicConfig(level=logging.INFO)
client = boto3.client('elasticache')
def check_user_exists(UserId):
"""Checks if UserId exists
Returns True if UserId exists, otherwise False
:param UserId: ElastiCache User ID
:return: True|False
"""
try:
response = client.describe_users(
UserId=UserId,
)
if response['Users'][0]['UserId'].lower() == UserId.lower():
return True
except Exception as e:
if e.response['Error']['Code'] == 'UserNotFound':
logging.info(e.response['Error'])
return False
else:
raise
def check_group_exists(UserGroupId):
"""Checks if UserGroupID exists
Returns True if Group ID exists, otherwise False
:param UserGroupId: ElastiCache User ID
:return: True|False
"""
try:
response = client.describe_user_groups(
UserGroupId=UserGroupId
)
if response['UserGroups'][0]['UserGroupId'].lower() == UserGroupId.lower():
return True
except Exception as e:
if e.response['Error']['Code'] == 'UserGroupNotFound':
logging.info(e.response['Error'])
return False
else:
raise
def create_user(UserId=None,UserName=None,Password=None,AccessString=None):
"""Creates a new user
Returns the ARN for the newly created user or the error message
:param UserId: ElastiCache user ID. User IDs must be unique
:param UserName: ElastiCache user name. ElastiCache allows multiple users with the same name as long as the associated user ID is unique.
:param Password: Password for user. Must have at least 16 chars.
:param AccessString: Access string with the permissions for the user.
:return: user ARN
"""
try:
response = client.create_user(
UserId=UserId,
UserName=UserName,
Engine='Redis',
Passwords=[Password],
AccessString=AccessString,
NoPasswordRequired=False
)
return response['ARN']
except Exception as e:
logging.info(e.response['Error'])
return e.response['Error']
def create_group(UserGroupId=None, UserIds=None):
"""Creates a new group.
A default user is required (mandatory) and should be specified in the UserIds list
Return: Group ARN
:param UserIds: List with user IDs to be associated with the new group. A default user is required
:param UserGroupId: The ID (name) for the group
:return: Group ARN
"""
try:
response = client.create_user_group(
UserGroupId=UserGroupId,
Engine='Redis',
UserIds=UserIds
)
return response['ARN']
except Exception as e:
logging.info(e.response['Error'])
if __name__ == '__main__':
groupName='mygroup2'
userName = 'myuser2'
userId=groupName+'-'+userName
# Creates a new user if the user ID does not exist.
for tmpUserId,tmpUserName in [ (userId,userName), (groupName+'-default','default')]:
if not check_user_exists(tmpUserId):
response=create_user(UserId=tmpUserId, UserName=EXAMPLE,Password=EXAMPLE,AccessString='on ~* +@all')
logging.info(response)
# assigns the new user ID to the user group
if not check_group_exists(groupName):
UserIds = [ userId , groupName+'-default']
response=create_group(UserGroupId=groupName,UserIds=UserIds)
logging.info(response)
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python UserAndUserGroups.py`
## Tutorial: Verbindung herstellen mit ElastiCache
In den folgenden Beispielen wird der Valkey- oder Redis OSS-Client verwendet, um eine Verbindung herzustellen. ElastiCache
**Topics**
+ [Herstellen einer Verbindung zu einem Cluster mit deaktiviertem Cluster-Modus](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-disabled)
+ [Herstellen einer Verbindung zu einem Cluster mit aktiviertem Cluster-Modus](#ElastiCache-Getting-Started-Tutorials-Connecting-cluster-mode-enabled)
### Herstellen einer Verbindung zu einem Cluster mit deaktiviertem Cluster-Modus
Kopieren Sie das folgende Programm und fügen Sie es in eine Datei namens *ConnectClusterModeDisabled.py* ein. Aktualisieren Sie den Mechanismus für die Bereitstellung von Anmeldeinformationen. In diesem Beispiel werden Anmeldeinformationen als ersetzbar angezeigt und ihnen wird ein nicht deklariertes Element zugewiesen. Vermeiden Sie die Hartkodierung von Anmeldeinformationen.
```
from redis import Redis
import logging
logging.basicConfig(level=logging.INFO)
redis = Redis(host='primary.xxx.yyyyyy.zzz1.cache.amazonaws.com', port=6379, decode_responses=True, ssl=True, username=example, password=EXAMPLE)
if redis.ping():
logging.info("Connected to Redis")
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python ConnectClusterModeDisabled.py`
### Herstellen einer Verbindung zu einem Cluster mit aktiviertem Cluster-Modus
Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen *ConnectClusterModeEnabled.py* ein.
```
from rediscluster import RedisCluster
import logging
logging.basicConfig(level=logging.INFO)
redis = RedisCluster(startup_nodes=[{"host": "xxx.yyy.clustercfg.zzz1.cache.amazonaws.com","port": "6379"}], decode_responses=True,skip_full_coverage_check=True)
if redis.ping():
logging.info("Connected to Redis")
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python ConnectClusterModeEnabled.py`
## Verwendungsbeispiele
In den folgenden Beispielen wird das Boto3-SDK für die Arbeit mit ElastiCache ElastiCache Redis OSS verwendet.
**Topics**
+ [Zeichenfolgen festlegen und abrufen](#ElastiCache-Getting-Started-Tutorials-set-strings)
+ [Festlegen und Abrufen eines Hash mit mehreren Elementen](#ElastiCache-Getting-Started-Tutorials-set-hash)
+ [Von einem Kanal aus veröffentlichen (schreiben) und abonnieren (lesen) Pub/Sub](#ElastiCache-Getting-Started-Tutorials-pub-sub)
+ [Schreiben und Lesen aus einem Stream](#ElastiCache-Getting-Started-Tutorials-read-write-stream)
### Zeichenfolgen festlegen und abrufen
*Kopieren Sie das folgende Programm und fügen Sie es in eine Datei namens .py ein. SetAndGetStrings*
```
import time
import logging
logging.basicConfig(level=logging.INFO,format='%(asctime)s: %(message)s')
keyName='mykey'
currTime=time.ctime(time.time())
# Set the key 'mykey' with the current date and time as value.
# The Key will expire and removed from cache in 60 seconds.
redis.set(keyName, currTime, ex=60)
# Sleep just for better illustration of TTL (expiration) value
time.sleep(5)
# Retrieve the key value and current TTL
keyValue=redis.get(keyName)
keyTTL=redis.ttl(keyName)
logging.info("Key {} was set at {} and has {} seconds until expired".format(keyName, keyValue, keyTTL))
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python SetAndGetStrings.py`
### Festlegen und Abrufen eines Hash mit mehreren Elementen
Kopieren Sie das folgende Programm und fügen Sie es in eine Datei namens *SetAndGetHash.py* ein.
```
import logging
import time
logging.basicConfig(level=logging.INFO,format='%(asctime)s: %(message)s')
keyName='mykey'
keyValues={'datetime': time.ctime(time.time()), 'epochtime': time.time()}
# Set the hash 'mykey' with the current date and time in human readable format (datetime field) and epoch number (epochtime field).
redis.hset(keyName, mapping=keyValues)
# Set the key to expire and removed from cache in 60 seconds.
redis.expire(keyName, 60)
# Sleep just for better illustration of TTL (expiration) value
time.sleep(5)
# Retrieves all the fields and current TTL
keyValues=redis.hgetall(keyName)
keyTTL=redis.ttl(keyName)
logging.info("Key {} was set at {} and has {} seconds until expired".format(keyName, keyValues, keyTTL))
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python SetAndGetHash.py`
### Von einem Kanal aus veröffentlichen (schreiben) und abonnieren (lesen) Pub/Sub
Kopieren Sie das folgende Programm und fügen Sie es in eine Datei namens *PubAndSub.py* ein.
```
import logging
import time
def handlerFunction(message):
"""Prints message got from PubSub channel to the log output
Return None
:param message: message to log
"""
logging.info(message)
logging.basicConfig(level=logging.INFO)
redis = Redis(host="redis202104053.tihewd.ng.0001.use1.cache.amazonaws.com", port=6379, decode_responses=True)
# Creates the subscriber connection on "mychannel"
subscriber = redis.pubsub()
subscriber.subscribe(**{'mychannel': handlerFunction})
# Creates a new thread to watch for messages while the main process continues with its routines
thread = subscriber.run_in_thread(sleep_time=0.01)
# Creates publisher connection on "mychannel"
redis.publish('mychannel', 'My message')
# Publishes several messages. Subscriber thread will read and print on log.
while True:
redis.publish('mychannel',time.ctime(time.time()))
time.sleep(1)
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python PubAndSub.py`
### Schreiben und Lesen aus einem Stream
Kopieren Sie das folgende Programm und fügen Sie es in eine Datei namens *ReadWriteStream.py* ein.
```
from redis import Redis
import redis.exceptions as exceptions
import logging
import time
import threading
logging.basicConfig(level=logging.INFO)
def writeMessage(streamName):
"""Starts a loop writting the current time and thread name to 'streamName'
:param streamName: Stream (key) name to write messages.
"""
fieldsDict={'writerId':threading.currentThread().getName(),'myvalue':None}
while True:
fieldsDict['myvalue'] = time.ctime(time.time())
redis.xadd(streamName,fieldsDict)
time.sleep(1)
def readMessage(groupName=None,streamName=None):
"""Starts a loop reading from 'streamName'
Multiple threads will read from the same stream consumer group. Consumer group is used to coordinate data distribution.
Once a thread acknowleges the message, it won't be provided again. If message wasn't acknowledged, it can be served to another thread.
:param groupName: stream group were multiple threads will read.
:param streamName: Stream (key) name where messages will be read.
"""
readerID=threading.currentThread().getName()
while True:
try:
# Check if the stream has any message
if redis.xlen(streamName)>0:
# Check if if the messages are new (not acknowledged) or not (already processed)
streamData=redis.xreadgroup(groupName,readerID,{streamName:'>'},count=1)
if len(streamData) > 0:
msgId,message = streamData[0][1][0]
logging.info("{}: Got {} from ID {}".format(readerID,message,msgId))
#Do some processing here. If the message has been processed sucessfuly, acknowledge it and (optional) delete the message.
redis.xack(streamName,groupName,msgId)
logging.info("Stream message ID {} read and processed successfuly by {}".format(msgId,readerID))
redis.xdel(streamName,msgId)
else:
pass
except:
raise
time.sleep(0.5)
# Creates the stream 'mystream' and consumer group 'myworkergroup' where multiple threads will write/read.
try:
redis.xgroup_create('mystream','myworkergroup',mkstream=True)
except exceptions.ResponseError as e:
logging.info("Consumer group already exists. Will continue despite the error: {}".format(e))
except:
raise
# Starts 5 writer threads.
for writer_no in range(5):
writerThread = threading.Thread(target=writeMessage, name='writer-'+str(writer_no), args=('mystream',),daemon=True)
writerThread.start()
# Starts 10 reader threads
for reader_no in range(10):
readerThread = threading.Thread(target=readMessage, name='reader-'+str(reader_no), args=('myworkergroup','mystream',),daemon=True)
readerThread.daemon = True
readerThread.start()
# Keep the code running for 30 seconds
time.sleep(30)
```
Geben Sie den folgenden Befehl ein, um das Programm auszuführen:
`python ReadWriteStream.py`
# Tutorial: Lambda für den Zugriff ElastiCache in einer VPC konfigurieren
In diesem Tutorial erfahren Sie, wie Sie einen ElastiCache serverlosen Cache erstellen, eine Lambda-Funktion erstellen, dann die Lambda-Funktion testen und optional anschließend bereinigen.
**Topics**
+ [Schritt 1: Einen serverlosen Cache erstellen ElastiCache .](#LambdaRedis.step1)
+ [Schritt 2: Erstellen Sie eine Lambda-Funktion für ElastiCache](#LambdaRedis.step2)
+ [Schritt 3: Testen Sie die Lambda-Funktion mit ElastiCache](#LambdaRedis.step3)
+ [Schritt 4: Aufräumen (optional)](#LambdaRedis.step4)
## Schritt 1: Einen serverlosen Cache erstellen ElastiCache .
Gehen Sie folgendermaßen vor, um einen serverlosen Cache zu erstellen.
### Schritt 1.1: Erstellen Sie einen serverlosen Cache
In diesem Schritt erstellen Sie mithilfe der (CLI) einen serverlosen Cache in der Standard-Amazon-VPC in der Region us-east-1 in Ihrem Konto.AWS Command Line Interface Informationen zum Erstellen eines serverlosen Caches mithilfe der ElastiCache Konsole oder API finden Sie unter. [Erstellen Sie einen serverlosen Redis OSS-Cache](GettingStarted.serverless-redis.step1.md)
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine valkey
```
Beachten Sie, dass für das Feld „Status“ der Wert `CREATING` festgelegt ist. Es kann eine Minute dauern ElastiCache , bis der Cache fertig erstellt ist.
### Schritt 1.2: Serverlosen Cache-Endpunkt kopieren
Stellen Sie sicher, dass ElastiCache für Redis OSS die Erstellung des Caches mit dem `describe-serverless-caches` Befehl abgeschlossen ist.
```
aws elasticache describe-serverless-caches \
--serverless-cache-name cache-01
```
Kopieren Sie die in der Ausgabe angezeigte Endpunktadresse. Sie benötigen diese Adresse, wenn Sie das Bereitstellungspaket für Ihre Lambda-Funktion erstellen.
### Schritt 1.3: IAM-Rolle erstellen
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",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::*:role/*"
},
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::*:role/*"
}]
}
```
------
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"
```
### Schritt 1.4: Erstellen Sie einen Standardbenutzer
1. Erstellen Sie einen neuen Standardbenutzer.
```
aws elasticache create-user \
--user-name default \
--user-id default-user-disabled \
--engine redis \
--authentication-mode Type=no-password-required \
--access-string "off +get ~keys*"
```
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-user-disabled iam-user-01
aws elasticache modify-serverless-cache \
--serverless-cache-name cache-01 \
--user-group-id iam-user-group-01
```
## Schritt 2: Erstellen Sie eine Lambda-Funktion für ElastiCache
Gehen Sie wie folgt vor, um eine Lambda-Funktion für den Zugriff auf den ElastiCache Cache zu erstellen.
### Schritt 2.1: Erstellen Sie eine Lambda-Funktion
In diesem Tutorial stellen wir Beispielcode in Python für Ihre Lambda-Funktion bereit.
**Python**
Der folgende Python-Beispielcode liest und schreibt ein Element in Ihren ElastiCache Cache. Kopieren Sie den Code in eine Datei und speichern Sie diese mit dem Namen `app.py`. Achten Sie darauf, den `elasticache_endpoint` Wert im Code durch die Endpunktadresse zu ersetzen, die Sie im vorherigen Schritt kopiert haben.
```
from typing import Tuple, Union
from urllib.parse import ParseResult, urlencode, urlunparse
import botocore.session
import redis
from botocore.model import ServiceId
from botocore.signers import RequestSigner
from cachetools import TTLCache, cached
import uuid
class ElastiCacheIAMProvider(redis.CredentialProvider):
def __init__(self, user, cache_name, is_serverless=False, region="us-east-1"):
self.user = user
self.cache_name = cache_name
self.is_serverless = is_serverless
self.region = region
session = botocore.session.get_session()
self.request_signer = RequestSigner(
ServiceId("elasticache"),
self.region,
"elasticache",
"v4",
session.get_credentials(),
session.get_component("event_emitter"),
)
# Generated IAM tokens are valid for 15 minutes
@cached(cache=TTLCache(maxsize=128, ttl=900))
def get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]:
query_params = {"Action": "connect", "User": self.user}
if self.is_serverless:
query_params["ResourceType"] = "ServerlessCache"
url = urlunparse(
ParseResult(
scheme="https",
netloc=self.cache_name,
path="/",
query=urlencode(query_params),
params="",
fragment="",
)
)
signed_url = self.request_signer.generate_presigned_url(
{"method": "GET", "url": url, "body": {}, "headers": {}, "context": {}},
operation_name="connect",
expires_in=900,
region_name=self.region,
)
# RequestSigner only seems to work if the URL has a protocol, but
# Elasticache only accepts the URL without a protocol
# So strip it off the signed URL before returning
return (self.user, signed_url.removeprefix("https://"))
def lambda_handler(event, context):
username = "iam-user-01" # replace with your user id
cache_name = "cache-01" # replace with your cache name
elasticache_endpoint = "cache-01-xxxxx.serverless.use1.cache.amazonaws.com" # replace with your cache endpoint
creds_provider = ElastiCacheIAMProvider(user=username, cache_name=cache_name, is_serverless=True)
redis_client = redis.Redis(host=elasticache_endpoint, port=6379, credential_provider=creds_provider, ssl=True, ssl_cert_reqs="none")
key='uuid'
# create a random UUID - this will be the sample element we add to the cache
uuid_in = uuid.uuid4().hex
redis_client.set(key, uuid_in)
result = redis_client.get(key)
decoded_result = result.decode("utf-8")
# check the retrieved item matches the item added to the cache and print
# the results
if decoded_result == uuid_in:
print(f"Success: Inserted {uuid_in}. Fetched {decoded_result} from Valkey.")
else:
raise Exception(f"Bad value retrieved. Expected {uuid_in}, got {decoded_result}")
return "Fetched value from Valkey"
```
Dieser Code verwendet die Python-Bibliothek redis-py, um Elemente in Ihren Cache zu legen und abzurufen. Dieser Code verwendet Cachetools, um generierte IAM-Auth-Token 15 Minuten lang zwischenzuspeichern. Gehen Sie wie folgt vor, um ein Bereitstellungspaket zu erstellen, das redis-py und cachetools enthält.
Erstellen Sie in Ihrem Projektverzeichnis, das die Quellcodedatei app.py enthält, ein Ordnerpaket, in dem Sie die Bibliotheken redis-py und cachetools installieren können.
```
mkdir package
```
Installieren Sie redis-py, cachetools mit pip.
```
pip install --target ./package redis
pip install --target ./package cachetools
```
Erstellen Sie eine ZIP-Datei, die die Bibliotheken redis-py und cachetools enthält. Führen Sie unter Linux oder macOS den folgenden Befehl aus: Verwenden Sie in Windows Ihr bevorzugtes ZIP-Hilfsprogramm, um eine .zip-Datei mit den Bibliotheken redis-py und cachetools im Stammverzeichnis zu erstellen.
```
cd package
zip -r ../my_deployment_package.zip .
```
Fügen Sie den Funktionscode in die ZIP-Datei ein. Führen Sie unter Linux oder macOS den folgenden Befehl aus: Verwenden Sie in Windows Ihr bevorzugtes ZIP-Programm, um app.py zum Stammverzeichnis Ihrer ZIP-Datei hinzuzufügen.
```
cd ..
zip my_deployment_package.zip app.py
```
### Schritt 2.2: Eine IAM-Rolle erstellen (Ausführungsrolle)
Hängen Sie die AWS verwaltete Richtlinie mit dem Namen der Rolle `AWSLambdaVPCAccessExecutionRole` an.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
```
### Schritt 2.3: Aktualisieren des Bereitstellungspakets (Erstellen der Lambda-Funktion)
In diesem Schritt erstellen Sie die Lambda-Funktion (AccessValkey) mit dem Befehl AWS CLI create-function.
Führen Sie in dem Projektverzeichnis, das die ZIP-Datei Ihres Bereitstellungspakets enthält, den folgenden `create-function` Lambda-CLI-Befehl aus.
Verwenden Sie für die Rollenoption den ARN der Ausführungsrolle, die Sie im vorherigen Schritt erstellt haben. Geben Sie für die vpc-config durch Kommas getrennte Listen der Subnetze Ihrer Standard-VPC und die Sicherheitsgruppen-ID Ihrer Standard-VPC ein. Sie finden diese Werte in der Amazon-VPC-Konsole. Um die Subnetze Ihrer Standard-VPC zu finden, wählen Sie **Ihre VPCs** und dann die Standard-VPC Ihres AWS Kontos aus. Um die Sicherheitsgruppe für diese VPC zu finden, gehen Sie zu **Sicherheit** und wählen Sie **Sicherheitsgruppen** aus. Stellen Sie sicher, dass die Region us-east-1 ausgewählt ist.
```
aws lambda create-function \
--function-name AccessValkey \
--region us-east-1 \
--zip-file fileb://my_deployment_package.zip \
--role arn:aws:iam::123456789012:role/elasticache-iam-auth-app \
--handler app.lambda_handler \
--runtime python3.12 \
--timeout 30 \
--vpc-config SubnetIds=comma-separated-vpc-subnet-ids,SecurityGroupIds=default-security-group-id
```
## Schritt 3: Testen Sie die Lambda-Funktion mit ElastiCache
In diesem Schritt rufen Sie die Lambda-Funktion manuell mit dem Befehl invoke auf. Wenn die Lambda-Funktion ausgeführt wird, generiert sie eine UUID und schreibt sie in den ElastiCache Cache, den Sie in Ihrem Lambda-Code angegeben haben. Die Lambda-Funktion ruft das Element dann aus dem Cache ab.
1. Rufen Sie die Lambda-Funktion (AccessValkey) mit dem Befehl AWS Lambda invoke auf.
```
aws lambda invoke \
--function-name AccessValkey \
--region us-east-1 \
output.txt
```
1. Stellen Sie sicher, dass die Lambda-Funktion erfolgreich ausgeführt wurde:
+ Überprüfen Sie die Datei "output.txt".
+ Überprüfen Sie die Ergebnisse in CloudWatch Logs, indem Sie die CloudWatch Konsole öffnen und die Protokollgruppe für Ihre Funktion auswählen (/). aws/lambda/AccessValkey Die Ausgabe dieses Protokollstreams sollte ähnlich wie folgt aussehen:
```
Success: Inserted 826e70c5f4d2478c8c18027125a3e01e. Fetched 826e70c5f4d2478c8c18027125a3e01e from Valkey.
```
+ Überprüfen Sie die Ergebnisse in der AWS Lambda Konsole.
## Schritt 4: Aufräumen (optional)
Gehen Sie zum Aufräumen wie folgt vor.
### Schritt 4.1: Lambda-Funktion löschen
```
aws lambda delete-function \
--function-name AccessValkey
```
### Schritt 4.2: Löschen Sie den serverlosen Cache
Löschen Sie den Cache.
```
aws elasticache delete-serverless-cache \
--serverless-cache-name cache-01
```
Benutzer und Benutzergruppen entfernen.
```
aws elasticache delete-user \
--user-id default-user-disabled
aws elasticache delete-user \
--user-id iam-user-01
aws elasticache delete-user-group \
--user-group-id iam-user-group-01
```
### Schritt 4.3: Entfernen Sie die IAM-Rolle und -Richtlinien
```
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
aws iam delete-role \
--role-name "elasticache-iam-auth-app"
aws iam delete-policy \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```