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.
# Verwaltung von Clustern in ElastiCache
Ein *Cluster* ist eine Sammlung von einem oder mehreren Cache-Knoten, auf denen alle eine Instanz der Valkey-, Memcached- und Redis OSS-Engine-Software ausführen. Wenn Sie einen Cluster erstellen, geben Sie die Engine und die Version an, die von allen Knoten verwendet werden soll.
**Valkey- und Redis OSS-Cluster**
Das folgende Diagramm zeigt einen typischen Valkey- oder Redis OSS-Cluster. Diese Cluster können einen einzelnen Knoten oder bis zu sechs Knoten innerhalb eines Shard (API/CLI: Node Group) enthalten. Ein Valkey- oder Redis OSS-Cluster (Cluster-Modus deaktiviert) mit einem Knoten hat keinen Shard und ein Valkey- oder Redis OSS-Cluster (Cluster-Modus deaktiviert) mit mehreren Knoten hat einen einzigen Shard. Valkey- oder Redis OSS-Cluster (Cluster-Modus aktiviert) können bis zu 500 Shards haben, wobei Ihre Daten auf die Shards verteilt sind. Das Knoten- oder Shard-Limit kann auf maximal 500 pro Cluster erhöht werden, wenn die Engine-Version Valkey 7.2 und höher oder Redis OSS 5.0.6 und höher ist. Sie können beispielsweise einen Cluster mit 500 Knoten konfigurieren, der zwischen 83 Shards (ein primärer Knoten und 5 Replikate pro Shard) und 500 Shards (ein primärer Knoten und keine Replikate) umfasst. Stellen Sie sicher, dass für die Erhöhung genügend IP-Adressen verfügbar sind. Häufige Fallstricke sind Subnetze in der Subnetzgruppe, die einen zu kleinen CIDR-Bereich haben, oder Subnetze, die gemeinsam genutzt und von anderen Clustern stark beansprucht werden. Weitere Informationen finden Sie unter [Erstellen einer Subnetzgruppe](SubnetGroups.Creating.md). Für Versionen unter 5.0.6 liegt das Limit bei 250 pro Cluster.
Um eine Erhöhung des Limits zu beantragen, [AWS siehe Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) und wählen Sie den Limittyp **Nodes per cluster per instance type**.
Wenn Sie mehrere Knoten in einem Valkey- oder Redis OSS-Shard haben, ist einer der Knoten ein primärer Knoten. read/write Alle anderen Knoten im Shard sind schreibgeschützte Replikate.
Typische Valkey- oder Redis OSS-Cluster sehen wie folgt aus.
![\[Bild: Typische Valkey- und Redis OSS-Cluster\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Redis.png)
**Memcached-Cluster**
Typische Memcached-Cluster sehen wie folgt aus. Memcached-Cluster enthalten 1 bis 60 Knoten, über die Sie Ihre Daten horizontal partitionieren.
![\[Abbildung: Typischer Memcached-Cluster\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
**Elasticache-Operationen für Valkey, Memcached und Redis OSS**
Die meisten ElastiCache Operationen werden auf Clusterebene ausgeführt. Sie können einen Cluster mit einer bestimmten Anzahl von Knoten und einer Parametergruppe einrichten, die die Eigenschaften für jeden Knoten steuert. Alle Knoten innerhalb eines Clusters gehören demselben Knotentyp an und verfügen über die gleichen Einstellungen für Parameter und Sicherheitsgruppen.
Jeder Cluster muss über eine Cluster-Kennung verfügen. Die Cluster-Kennung ist ein vom Kunden angegebener Name für den Cluster. Diese Kennung gibt bei der Interaktion mit der ElastiCache API und den AWS CLI Befehlen einen bestimmten Cluster an. Die Cluster-ID muss für diesen Kunden in einer AWS Region eindeutig sein.
ElastiCache unterstützt mehrere Engine-Versionen. Sofern es keine bestimmten Gründe dagegen gibt, raten wir dazu, die neueste Version zu verwenden.
ElastiCache Cluster sind für den Zugriff über eine EC2 Amazon-Instance konzipiert. Wenn Sie Ihren Cluster in einer Virtual Private Cloud (VPC) starten, die auf dem Amazon VPC-Service basiert, können Sie von außerhalb AWS auf ihn zugreifen. Weitere Informationen finden Sie unter [Zugriff auf ElastiCache Ressourcen von außen AWS](accessing-elasticache.md#access-from-outside-aws).
Eine Liste der unterstützten Versionen finden Sie unter [Unterstützte Engines und Versionen](VersionManagement.md#supported-engine-versions)[Unterstützte Redis OSS-Engine-Versionen](engine-versions.md#supported-engine-versions.redis), und[Wird ElastiCache für Memcached-Versionen unterstützt](engine-versions.md#supported-engine-versions-mc).
# Auswahl eines Netzwerktyps in ElastiCache
ElastiCache unterstützt die Internetprotokoll-Versionen 4 und 6 (IPv4 und IPv6), sodass Sie Ihren Cluster so konfigurieren können, dass er Folgendes akzeptiert:
+ nur IPv4 Verbindungen,
+ nur IPv6 Verbindungen,
+ IPv4 sowohl als auch IPv6 Verbindungen (Dual-Stack)
IPv6 [wird für Workloads unterstützt, die Valkey 7.2 und höher oder Redis OSS 6.2 und höher verwenden, auf allen Instanzen, die auf dem Nitro-System basieren.](https://aws.amazon.com/ec2/nitro/) Für den Zugriff über fallen keine zusätzlichen Gebühren an. ElastiCache IPv6
**Anmerkung**
Die Migration von Clustern, die vor der Verfügbarkeit von IPV6 /Dual-Stack erstellt wurden, wird nicht unterstützt. Das Umschalten zwischen Netzwerktypen in neu erstellten Clustern wird ebenfalls nicht unterstützt.
IPv6 [wird für Workloads unterstützt, die Memcached 1.6.6 oder höher auf allen auf dem Nitro-System basierenden Instanzen verwenden.](https://aws.amazon.com/ec2/nitro/) Für den Zugriff über fallen keine zusätzlichen Gebühren an. ElastiCache IPv6
## Konfigurieren von Subnetzen für den Netzwerktyp
Wenn Sie einen Cluster in einer Amazon VPC erstellen, müssen Sie eine Subnetzgruppe angeben. ElastiCache verwendet diese Subnetzgruppe, um ein Subnetz und IP-Adressen innerhalb dieses Subnetzes auszuwählen, die Ihren Knoten zugeordnet werden sollen. ElastiCache Cluster benötigen ein Dual-Stack-Subnetz mit beiden IPv4 und ihnen zugewiesenen IPv6 Adressen, um im Dual-Stack-Modus betrieben werden zu können, und ein Subnetz nur für den Betrieb als IPv6 -only. IPv6
## Verwenden von Dual-Stack
ElastiCache Bei Verwendung von Redis OSS im aktivierten Clustermodus unterscheidet sich die Verbindung mit allen Clusterknoten über den Konfigurationsendpunkt aus Sicht einer Anwendung nicht von der direkten Verbindung zu einem einzelnen Cache-Knoten. Um dies zu erreichen, muss ein clusterfähiger Client einen Cluster-Erkennungsprozess durchführen und die Konfigurationsinformationen für alle Knoten anfordern. Das Erkennungsprotokoll von Redis unterstützt nur eine IP pro Knoten.
Wenn Sie einen Cluster mit ElastiCache for Memcached erstellen und Dual-Stack als Netzwerktyp wählen, müssen Sie anschließend einen IP-Erkennungstyp festlegen — entweder oder. IPv4 IPv6 ElastiCache verwendet standardmäßig den Netzwerktyp und die IP-Erkennung IPv6, aber das kann geändert werden. Wenn Sie Auto Discovery verwenden, werden nur die IP-Adressen des von Ihnen gewählten IP-Typs an den Memcached-Client zurückgegeben. Weitere Informationen finden Sie unter [Identifizieren Sie automatisch Knoten in Ihrem Cluster (Memcached)](AutoDiscovery.md).
Um die Abwärtskompatibilität mit allen vorhandenen Clients aufrechtzuerhalten, wurde die IP-Erkennung eingeführt, sodass Sie den IP-Typ (d. h. IPv4 oder IPv6) auswählen können, der im Discovery-Protokoll angekündigt werden soll. Dadurch wird die auto Erkennung zwar auf nur einen IP-Typ beschränkt, aber Dual-Stack ist für Workloads mit aktiviertem Clustermodus dennoch von Vorteil, da es Migrationen (oder Rollbacks) von einem IPv4 zu einem IPv6 Discovery-IP-Typ ohne Ausfallzeiten ermöglicht.
## TLS-fähige Dual-Stack-Cluster ElastiCache
Wenn TLS für ElastiCache Cluster aktiviert ist, geben Cluster-Erkennungsfunktionen wie `cluster slots``cluster shards`, und `cluster nodes` mit Valkey oder Redis OSS und `config get cluster` mit Memcached Hostnamen statt. IPs Die Hostnamen werden dann verwendet, anstatt eine Verbindung IPs zum ElastiCache Cluster herzustellen und einen TLS-Handshake durchzuführen. Das bedeutet, dass Clients nicht vom IP-Discovery-Parameter betroffen sind. *Bei TLS-fähigen Clustern hat der IP Discovery-Parameter keine Auswirkung auf das bevorzugte IP-Protokoll.* Stattdessen wird das verwendete IP-Protokoll dadurch bestimmt, welches IP-Protokoll der Client bei der Auflösung von DNS-Hostnamen bevorzugt.
Beispiele zur Konfiguration einer IP-Protokollpräferenz bei der Auflösung von DNS-Hostnamen finden Sie unter [TLS-fähige ElastiCache Dual-Stack-Cluster](BestPractices.md#network-type-configuring-tls-enabled-dual-stack).
## Verwenden von AWS-Managementkonsole(Valkey und Redis OSS)
Wenn Sie einen Cluster mit dem erstellen AWS-Managementkonsole, wählen Sie unter **Konnektivität** entweder **IPv4**einen Netzwerktyp **IPv6**oder **Dual-Stack**. Wenn Sie einen Valkey- oder Redis OSS-Cluster (Cluster-Modus aktiviert) erstellen und Dual-Stack wählen, müssen Sie anschließend einen **Discovery-IP-Typ** auswählen, entweder oder IPv6 . IPv4
Für weitere Informationen siehe [Erstellen eines Valkey- oder Redis OSS-Clusters (Cluster-Modus aktiviert) (Konsole)](Clusters.Create.md#Clusters.Create.CON.RedisCluster) oder [Erstellen eines Valkey- oder Redis-OSS (Clustermodus deaktiviert) (Konsole)](Clusters.Create.md#Clusters.Create.CON.Redis).
Wählen Sie beim Erstellen einer Replikationsgruppe mit dem AWS-Managementkonsole einen Netzwerktyp **IPv4**, entweder **IPv6**oder **Dual-Stack**. Wenn Sie sich für Dual-Stack entscheiden, müssen Sie anschließend einen **Discovery-IP-Typ** auswählen, entweder IPv6 oder IPv4.
Für weitere Informationen siehe [Eine Valkey- oder Redis OSS-Replikationsgruppe (Cluster Mode Disabled) von Grund auf neu erstellen](Replication.CreatingReplGroup.NoExistingCluster.Classic.md) oder [Eine Replikationsgruppe in Valkey oder Redis OSS (Cluster Mode Enabled) von Grund auf neu erstellen](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md).
## Verwenden von AWS-Managementkonsole(Memcached)
Wenn Sie einen Cluster mit dem erstellen AWS-Managementkonsole, wählen Sie unter **Konnektivität** entweder **IPv4**einen Netzwerktyp **IPv6**oder **Dual-Stack**. Wenn Sie sich für Dual-Stack entscheiden, müssen Sie anschließend einen **Discovery-IP-Typ** auswählen, entweder IPv6 oder IPv4.
Weitere Informationen finden Sie unter [Erstellen eines Memcached-Clusters (Konsole)](Clusters.Create-mc.md#Clusters.Create.CON.Memcached).
## Verwenden der CLI mit Valkey, Memcached oder Redis OSS.
**Redis OSS**
Wenn Sie einen Cluster mit Valkey oder Redis OSS mithilfe der CLI erstellen, verwenden Sie den [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)Befehl und geben die `NetworkType` Parameter und an: `IPDiscovery`
Für Linux, macOS oder Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine redis \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
Für Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine redis ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
Wenn Sie mithilfe der CLI eine Replikationsgruppe mit deaktiviertem Clustermodus erstellen, verwenden Sie den [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)Befehl und geben die `IPDiscovery` Parameter `NetworkType` und an:
Für Linux, macOS oder Unix:
```
aws elasticache create-replication-group \
--replication-group-id sample-repl-group \
--replication-group-description "demo cluster with replicas" \
--num-cache-clusters 3 \
--primary-cluster-id redis01 \
--network-type dual_stack \
--ip-discovery ipv4
```
Für Windows:
```
aws elasticache create-replication-group ^
--replication-group-id sample-repl-group ^
--replication-group-description "demo cluster with replicas" ^
--num-cache-clusters 3 ^
--primary-cluster-id redis01 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
Wenn Sie eine Replikationsgruppe mit aktiviertem Clustermodus erstellen und IPv4 für die IP-Erkennung mithilfe der CLI verwenden, verwenden Sie den [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)Befehl und geben die `IPDiscovery` Parameter `NetworkType` und an:
Für Linux, macOS oder Unix:
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv4 \
--region us-east-1
```
Für Windows:
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv4 ^
--region us-east-1
```
Wenn Sie eine Replikationsgruppe mit aktiviertem Clustermodus erstellen und IPv6 für die IP-Erkennung mithilfe der CLI verwenden, verwenden Sie den [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)Befehl und geben die `IPDiscovery` Parameter `NetworkType` und an:
Für Linux, macOS oder Unix:
```
aws elasticache create-replication-group \
--replication-group-id demo-cluster \
--replication-group-description "demo cluster" \
--cache-node-type cache.m5.large \
--num-node-groups 2 \
--engine redis \
--cache-subnet-group-name xyz \
--network-type dual_stack \
--ip-discovery ipv6 \
--region us-east-1
```
Für Windows:
```
aws elasticache create-replication-group ^
--replication-group-id demo-cluster ^
--replication-group-description "demo cluster" ^
--cache-node-type cache.m5.large ^
--num-node-groups 2 ^
--engine redis ^
--cache-subnet-group-name xyz ^
--network-type dual_stack ^
--ip-discovery ipv6 ^
--region us-east-1
```
**Memcached**
Wenn Sie mithilfe der CLI einen Cluster mit Memcached erstellen, verwenden Sie den [create-cache-cluster](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-cache-cluster.html)Befehl und geben die `NetworkType` Parameter und an: `IPDiscovery`
Für Linux, macOS oder Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id "cluster-test" \
--engine memcached \
--cache-node-type cache.m5.large \
--num-cache-nodes 1 \
--network-type dual_stack \
--ip-discovery ipv4
```
Für Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id "cluster-test" ^
--engine memcached ^
--cache-node-type cache.m5.large ^
--num-cache-nodes 1 ^
--network-type dual_stack ^
--ip-discovery ipv4
```
# Identifizieren Sie automatisch Knoten in Ihrem Cluster (Memcached)
ElastiCache Unterstützt bei Clustern, auf denen die Memcached-Engine ausgeführt wird, *Auto Discovery* — die Fähigkeit von Client-Programmen, automatisch alle Knoten in einem Cluster zu identifizieren und Verbindungen zu all diesen Knoten zu initiieren und aufrechtzuerhalten.
**Anmerkung**
Auto Discovery wurde für Cluster hinzugefügt, die auf Amazon ElastiCache Memcached ausgeführt werden. Auto Discovery ist für Valkey- oder Redis OSS-Engines nicht verfügbar.
Mit Auto Discovery muss Ihre Anwendung keine manuelle Verbindung mit einzelnen Cache-Knoten herstellten. Stattdessen stellt sie eine Verbindung mit einem Memcached-Knoten her und ruft die Liste der Knoten ab. Anhand dieser Liste erhält Ihre Anwendung Informationen über die restlichen Knoten im Cluster und kann eine Verbindung mit einem beliebigen Knoten herstellen. Die einzelnen Endpunkte der Cache-Knoten in Ihrer Anwendung müssen nicht als vordefinierter Code aufgenommen werden.
Wenn Sie in Ihrem Cluster einen Dual-Stack-Netzwerktyp verwenden, gibt Auto Discovery nur IPv4 oder IPv6 Adressen zurück, je nachdem, welche Sie auswählen. Weitere Informationen finden Sie unter [Auswahl eines Netzwerktyps in ElastiCache](network-type.md).
Alle Cache-Knoten im Cluster führen eine Liste mit Metadaten über alle anderen Knoten. Diese Metadaten werden aktualisiert, sobald Knoten hinzugefügt oder aus dem Cluster entfernt werden.
**Topics**
+ [Vorteile von Auto Discovery mit Memcached](AutoDiscovery.Benefits.md)
+ [Funktionsweise von Auto Discovery](AutoDiscovery.HowAutoDiscoveryWorks.md)
+ [Verwenden von Auto Discovery](AutoDiscovery.Using.md)
+ [Manuelles Herstellen einer Verbindung zu Memcache-Cache-Knoten](AutoDiscovery.Manual.md)
+ [Hinzufügen von Auto Discovery zu Ihrer Memcached-Clientbibliothek](AutoDiscovery.AddingToYourClientLibrary.md)
+ [ElastiCache Kunden mit auto Erkennung](Clients.md)
# Vorteile von Auto Discovery mit Memcached
Bei der Verwendung von Memcached bietet Auto Discovery die folgenden Vorteile:
+ Wenn Sie die Anzahl der Knoten in einem Cluster erhöhen, registrieren sich die neuen Knoten selbst beim Konfigurationsendpunkt und bei allen anderen Knoten. Wenn Sie Knoten aus dem Cache-Cluster entfernen, heben die entsprechenden Cluster ihre Registrierung selbst auf. In beiden Fällen werden alle anderen Knoten im Cluster mit den neuen Cache-Knotenmetadaten aktualisiert.
+ Ausfälle von Cache-Knoten werden automatisch erkannt und ausgefallene Knoten automatisch ersetzt.
**Anmerkung**
Der Knoten fällt solange aus, bis er ersetzt wird.
+ Ein Client-Programm muss nur eine Verbindung mit dem Konfigurationsendpunkt herstellen. Anschließend stellt die Auto Discovery-Bibliothek eine Verbindung mit allen anderen Knoten im Cluster her.
+ Client-Programme fragen den Cluster einmal pro Minute ab (dieses Intervall kann bei Bedarf geändert werden). Wenn Änderungen an der Cluster-Konfiguration vorgenommen wurden, z. B. neue oder gelöschte Knoten, erhält der Client eine aktualisierte Liste mit Metadaten. Anschließend stellt der Client je nach Bedarf eine Verbindung mit diesen Knoten her bzw. trennt die Verbindung.
Auto Discovery ist auf allen ElastiCache Memcached-Clustern aktiviert. Sie müssen Ihre Cache-Knoten nicht neu starten, um diese Funktion zu verwenden.
# Funktionsweise von Auto Discovery
**Topics**
+ [Herstellen von Verbindungen mit Cache-Knoten](#AutoDiscovery.HowAutoDiscoveryWorks.Connecting)
+ [Normale Cluster-Operationen](#AutoDiscovery.HowAutoDiscoveryWorks.NormalOps)
+ [Weitere Operationen in](#AutoDiscovery.HowAutoDiscoveryWorks.OtherOps)
In diesem Abschnitt wird beschrieben, wie Clientanwendungen den ElastiCache Clusterclient verwenden, um Cache-Knotenverbindungen zu verwalten und mit Datenelementen im Cache zu interagieren.
## Herstellen von Verbindungen mit Cache-Knoten
Von der Anwendungsseite aus betrachtet, unterscheidet sich das Herstellen einer Verbindung mit dem Cluster-Konfigurationsendpunkt nicht vom Herstellen einer direkten Verbindung mit einem einzelnen Cache-Knoten. Das folgende Ablaufdiagramm zeigt den Prozess zum Herstellen der Verbindung mit Cache-Knoten.
![\[Herstellen von Verbindungen mit Cache-Knoten\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/autodiscovery_cluster_membership_refresh-diagram.png)
**Prozess zum Herstellen von Verbindungen mit Cache-Knoten**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/callouts/1.png) | Die Anwendung löst den DNS-Namen des Konfigurationsendpunkts auf. Da der Konfigurationsendpunkt CNAME-Einträge für alle Cache-Knoten verwaltet, wird der DNS-Name in einen der Knoten aufgelöst. Der Client kann dann eine Verbindung mit diesem Knoten herstellen. |
| ![\[2\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/callouts/2.png) | Der Client fordert die Konfigurationsinformationen für alle anderen Knoten an. Da jeder Knoten Konfigurationsinformationen für alle Knoten im Cluster verwaltet, kann jeder Knoten auf Anfrage Konfigurationsinformationen an den Client weitergeben. |
| ![\[3\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/callouts/3.png) | Der Client empfängt die aktuelle Liste mit den Hostnamen und IP-Adressen der Cache-Knoten. Anschließend kann er eine Verbindung mit allen anderen Knoten im Cluster herstellen. |
**Anmerkung**
Das Client-Programm aktualisiert seine Liste mit den Hostnamen und IP-Adressen der Cache-Knoten einmal pro Minute. Dieses Abfrageintervall kann bei Bedarf angepasst werden.
## Normale Cluster-Operationen
Wenn die Anwendung eine Verbindung zu allen Cache-Knoten hergestellt hat, bestimmt der ElastiCache Cluster-Client, auf welchen Knoten einzelne Datenelemente gespeichert werden sollen und welche Knoten später nach diesen Datenelementen abgefragt werden sollen. Das folgende Ablaufdiagramm zeigt den Prozess für normale Cluster-Operationen.
![\[Normale Cluster-Operationen\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/autodiscovery_normal_cache_usage-diagram.png)
**Prozess für normale Cluster-Operationen**
| | |
| --- |--- |
| ![\[1\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/callouts/1.png) | Die Anwendung erstellt eine get-Anforderung für ein bestimmtes Datenelement, das durch seinen Schlüssel identifiziert wird. |
| ![\[2\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/callouts/2.png) | Der Client verwendet einen Hashing-Algorithmus für den Schlüssel, um den Cache-Knoten zu ermitteln, der das Datenelement enthält. |
| ![\[3\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/callouts/3.png) | Das Datenelement wird vom entsprechenden Knoten angefordert. |
| ![\[4\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/callouts/4.png) | Das Datenelement wird an die Anwendung zurückgegeben. |
## Weitere Operationen in
In manchen Situationen kann es vorkommen, dass Sie eine Änderung an den Knoten eines Clusters vornehmen. So können Sie beispielsweise einen zusätzlichen Knoten hinzufügen, um zusätzlichen Bedarf zu decken, oder einen Knoten löschen, um in Zeiten geringerer Nachfrage Geld zu sparen. Oder Sie ersetzen einen Knoten, weil er auf die eine oder andere Weise ausgefallen ist.
Bei einer Änderung im Cluster, die eine Aktualisierung der Metadaten auf die Endpunkte des Clusters erfordert, wird diese Änderung auf allen Knoten gleichzeitig vorgenommen. So sind die Metadaten in einem bestimmten Knoten konsistent mit den Metadaten in allen anderen Knoten im Cluster.
In jedem Fall sind die Metadaten für alle Knoten jederzeit konsistent, da sie für alle Knoten im Cluster gleichzeitig aktualisiert werden. Verwenden Sie immer den Konfigurationsendpunkt, um die Endpunkte der verschiedenen Knoten im Cluster zu erhalten. Durch Verwenden des Konfigurationsendpunkts stellen Sie sicher, dass Sie keine Endpunktdaten von einem Knoten erhalten, der "verschwindet".
### Hinzufügen eines Knotens
Während der Zeit, in der der Knoten eingerichtet wird, ist sein Endpunkt nicht in den Metadaten enthalten. Sobald der Knoten verfügbar ist, wird er den jeweiligen Metadaten der Cluster-Knoten hinzugefügt. In diesem Szenario sind die Metadaten für alle Knoten konsistent und Sie können mit dem neuen Knoten erst interagieren, sobald er verfügbar ist. Vorher liegen Ihnen keine Informationen darüber vor und Sie interagieren mit den Knoten in Ihrem Cluster so, als ob der neue Knoten nicht vorhanden wäre.
### Löschen eines Knotens
Wenn ein Knoten entfernt wird, wird sein Endpunkt erst in den Metadaten gelöscht und anschließend wird der Knoten aus dem Cluster entfernt. In diesem Szenario sind die Metadaten in allen Knoten konsistent und zu keiner Zeit enthalten sie den Endpunkt für den Knoten, der entfernt werden soll, während der Knoten nicht verfügbar ist. Während des Zeitraums, in dem der Knoten entfernt wird, erfolgt keine Meldung in den Metadaten. Demzufolge interagiert Ihre Anwendung nur mit den verbleibenden n-1 Knoten, so als ob der Knoten nicht vorhanden wäre.
### Ersetzen eines Knotens
Wenn ein Knoten ausfällt, wird ElastiCache dieser Knoten heruntergefahren und ein Ersatzknoten installiert. Das Ersetzen dauert einige Minuten. Während dieser Zeit zeigen die Metadaten in allen Knoten den Endpunkt für den ausgefallenen Knoten noch an, doch jeder Versuch, mit dem Knoten zu interagieren, schlägt fehl. Daher sollte Ihre Logik immer Logik für Wiederholungsversuche umfassen.
# Verwenden von Auto Discovery
Gehen Sie wie folgt vor, um Auto Discovery ElastiCache für Memcached zu verwenden:
+ [Rufen Sie den Konfigurationsendpunkt ab](#AutoDiscovery.Using.ConfigEndpoint)
+ [Laden Sie den ElastiCache Cluster-Client herunter](#AutoDiscovery.Using.ClusterClient)
+ [Ändern Sie Ihr Anwendungsprogramm](#AutoDiscovery.Using.ModifyApp)
## Rufen Sie den Konfigurationsendpunkt ab
Zum Herstellen der Verbindung mit einem Cluster müssen die Client-Programme den Cluster-Konfigurationsendpunkt kennen. Weitere Informationen finden Sie im Thema [Die Endpunkte eines Clusters finden (Konsole) (Memcached)](Endpoints.md#Endpoints.Find.Memcached).
Sie können auch den Befehl `aws elasticache describe-cache-clusters` mit dem Parameter `--show-cache-node-info` verwenden:
Unabhängig von der Methode, mit der Sie die Endpunkte des Clusters suchen, enthält der Konfigurationsendpunkt in seiner Adresse immer **.cfg**.
**Example Finden von Endpunkten mit dem for AWS CLI ElastiCache**
Für Linux, macOS oder Unix:
```
aws elasticache describe-cache-clusters \
--cache-cluster-id mycluster \
--show-cache-node-info
```
Für Windows:
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id mycluster ^
--show-cache-node-info
```
Dieser Vorgang erzeugt eine Ausgabe ähnlich der folgenden (JSON-Format):
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.0001.use1.cache.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-10-12T21:39:28.001Z",
"CustomerAvailabilityZone": "us-east-1e"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.0002.use1.cache.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-10-12T21:39:28.001Z",
"CustomerAvailabilityZone": "us-east-1a"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "Multiple",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-10-12T21:39:28.001Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "sat:06:00-sat:07:00",
"CacheNodeType": "cache.r3.large"
}
]
}
```
## Laden Sie den ElastiCache Cluster-Client herunter
Um Auto Discovery nutzen zu können, müssen Client-Programme den *ElastiCache-Cluster-Client* verwenden. Der ElastiCache Cluster-Client ist für Java, PHP und .NET verfügbar und enthält die gesamte erforderliche Logik, um all Ihre Cache-Knoten zu erkennen und eine Verbindung zu ihnen herzustellen.
**Um den ElastiCache Cluster-Client herunterzuladen**
1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die ElastiCache Konsole unter [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Wählen Sie in der ElastiCache Konsole **ElastiCache Cluster Client** und dann **Herunterladen** aus.
Der Quellcode für den ElastiCache Cluster-Client für Java ist unter [https://github.com/amazonwebservices/aws-elasticache-cluster-client-](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java) verfügbarmemcached-for-java. Diese Bibliothek basiert auf dem häufig verwendeten Spymemcached-Client. Der ElastiCache Cluster-Client ist unter der Amazon-Softwarelizenz [https://aws.amazon.com/asl](https://aws.amazon.com/asl) veröffentlicht. Es steht Ihnen frei, den Quellcode nach eigenen Wünschen zu ändern. Sie können den Code sogar in andere Memcached-Open-Source-Bibliotheken oder in Ihren eigenen Client-Code integrieren.
**Anmerkung**
Um den ElastiCache Cluster Client für PHP verwenden zu können, müssen Sie ihn zunächst auf Ihrer EC2 Amazon-Instance installieren. Weitere Informationen finden Sie unter [Installation des ElastiCache Cluster-Clients für PHP](Appendix.PHPAutoDiscoverySetup.md).
Für einen von TLS unterstützten Client laden Sie die Binärdatei mit PHP-Version 7.4 oder höher herunter.
Um den ElastiCache Cluster Client für.NET verwenden zu können, müssen Sie ihn zunächst auf Ihrer EC2 Amazon-Instance installieren. Weitere Informationen finden Sie unter [Installation des ElastiCache Clusterclients für.NET](Appendix.DotNETAutoDiscoverySetup.md).
## Ändern Sie Ihr Anwendungsprogramm
Ändern Sie Ihr Anwendungsprogramm, sodass es Auto Discovery verwendet. In den folgenden Abschnitten wird gezeigt, wie Sie den ElastiCache Cluster-Client für Java, PHP und .NET verwenden.
**Wichtig**
Stellen Sie beim Angeben des Cluster-Konfigurationsendpunkts sicher, dass der Endpunkt in seiner Adresse ".cfg" enthält, wie hier dargestellt. Verwenden Sie keinen CNAME oder einen Endpunkt ohne ".cfg" in der Adresse.
```
"mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
```
Wenn Sie den Cluster-Konfigurationsendpunkt nicht explizit angeben, erfolgt die Konfiguration für einen spezifischen Knoten.
# Den ElastiCache Cluster-Client für Java verwenden
Das folgende Programm zeigt, wie Sie den ElastiCache Cluster-Client verwenden, um eine Verbindung zu einem Cluster-Konfigurationsendpunkt herzustellen und dem Cache ein Datenelement hinzuzufügen. Mithilfe von Auto Discovery stellt das Programm eine Verbindung mit allen Knoten im Cluster her, ohne dass ein Eingreifen erforderlich ist.
```
package com.amazon.elasticache;
import java.io.IOException;
import java.net.InetSocketAddress;
// Import the &AWS;-provided library with Auto Discovery support
import net.spy.memcached.MemcachedClient;
public class AutoDiscoveryDemo {
public static void main(String[] args) throws IOException {
String configEndpoint = "mycluster.fnjyzo.cfg.use1.cache.amazonaws.com";
Integer clusterPort = 11211;
MemcachedClient client = new MemcachedClient(
new InetSocketAddress(configEndpoint,
clusterPort));
// The client will connect to the other cache nodes automatically.
// Store a data item for an hour.
// The client will decide which cache host will store this item.
client.set("theKey", 3600, "This is the data value");
}
}
```
# Den ElastiCache Cluster-Client für PHP verwenden
Das folgende Programm zeigt, wie Sie den ElastiCache Cluster-Client verwenden, um eine Verbindung zu einem Cluster-Konfigurationsendpunkt herzustellen und dem Cache ein Datenelement hinzuzufügen. Mithilfe von Auto Discovery stellt das Programm eine Verbindung mit allen Knoten im Cluster her, ohne dass ein Eingreifen erforderlich ist.
Um den ElastiCache Cluster Client für PHP verwenden zu können, müssen Sie ihn zunächst auf Ihrer EC2 Amazon-Instance installieren. Weitere Informationen finden Sie unter [Installation des ElastiCache Cluster-Clients für PHP](Appendix.PHPAutoDiscoverySetup.md).
```
setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE);
$dynamic_client->addServer($server_endpoint, $server_port);
/**
* Store the data for 60 seconds in the cluster.
* The client will decide which cache host will store this item.
*/
$dynamic_client->set('key', 'value', 60);
/**
* Configuring the client with Static client mode disables the usage of Auto Discovery
* and the client operates as it did before the introduction of Auto Discovery.
* The user can then add a list of server endpoints.
*/
$static_client = new Memcached('persistent-id');
$static_client->setOption(Memcached::OPT_CLIENT_MODE, Memcached::STATIC_CLIENT_MODE);
$static_client->addServer($server_endpoint, $server_port);
/**
* Store the data without expiration.
* The client will decide which cache host will store this item.
*/
$static_client->set('key', 'value');
?>
```
Ein Beispiel zur Verwendung des ElastiCache Cluster-Clients mit aktiviertem TLS finden Sie unter [Verwenden von In-Transit-Verschlüsselung mit PHP und Memcached](in-transit-encryption.md#in-transit-encryption-connect-php-mc).
# Den ElastiCache Cluster-Client für.NET verwenden
**Anmerkung**
ElastiCache Der.NET-Clusterclient ist seit Mai 2022 veraltet.
.NET-Client für ElastiCache ist Open Source unter. [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net)
Die .NET-Anwendungen erhalten ihre Konfigurationen in der Regel von ihrer Config-Datei. Nachfolgend finden Sie ein Beispiel einer Anwendungs-Config-Datei.
```
```
Das unten stehende C\$1-Programm zeigt, wie Sie den ElastiCache Cluster-Client verwenden, um eine Verbindung zu einem Clusterkonfigurationsendpunkt herzustellen und dem Cache ein Datenelement hinzuzufügen. Mithilfe von Auto Discovery stellt das Programm eine Verbindung mit allen Knoten im Cluster her, ohne dass ein Eingreifen erforderlich ist.
```
// *****************
// Sample C# code to show how to integrate with the Amazon ElastiCcache Auto Discovery feature.
using System;
using Amazon.ElastiCacheCluster;
using Enyim.Caching;
using Enyim.Caching.Memcached;
public class DotNetAutoDiscoveryDemo {
public static void Main(String[] args) {
// instantiate a new client.
ElastiCacheClusterConfig config = new ElastiCacheClusterConfig();
MemcachedClient memClient = new MemcachedClient(config);
// Store the data for 3600 seconds (1hour) in the cluster.
// The client will decide which cache host will store this item.
memClient.Store(StoreMode.Set, 3600, "This is the data value.");
} // end Main
} // end class DotNetAutoDiscoverDemo
```
# Manuelles Herstellen einer Verbindung zu Memcache-Cache-Knoten
Wenn Ihr Client-Programm Auto Discovery nicht verwendet, kann es manuell eine Verbindung zu den einzelnen Memcache-Cache-Knoten herstellen. Dies ist das Standardverhalten für Memcached-Clients.
Eine Liste der Hostnamen und Portnummern der Cache-Knoten erhalten Sie über die [AWS Managementkonsole](https://aws.amazon.com/console/). Sie können den AWS CLI`aws elasticache describe-cache-clusters` Befehl auch mit dem `--show-cache-node-info` Parameter verwenden.
**Example**
Der folgende Java-Codeausschnitt zeigt, wie eine Verbindung zu allen Knoten in einem Cluster mit vier Knoten hergestellt wird:
```
...
ArrayList cacheNodes = new ArrayList(
Arrays.asList(
"mycachecluster.fnjyzo.0001.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0002.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0003.use1.cache.amazonaws.com:11211",
"mycachecluster.fnjyzo.0004.use1.cache.amazonaws.com:11211"));
MemcachedClient cache = new MemcachedClient(AddrUtil.getAddresses(cacheNodes));
...
```
**Wichtig**
Wenn Sie Ihren Cluster durch Hinzufügen oder Entfernen von Knoten nach oben oder unten skalieren, müssen Sie die Liste der Knoten im Client-Code aktualisieren.
# Hinzufügen von Auto Discovery zu Ihrer Memcached-Clientbibliothek
Die Konfigurationsinformationen für Auto Discovery werden redundant in jedem Memcached-Clusterknoten gespeichert. Client-Anwendungen können jeden Cache-Knoten abfragen und die Konfigurationsinformationen für alle Knoten im Cluster abrufen.
Die jeweilige Methode, die eine Anwendung dazu nutzt, hängt von der Cache-Engine-Version ab:
+ Wenn die Cache-Engine-Version **1.4.14 oder höher** ist, verwenden Sie den Befehl `config`.
+ Wenn die Cache-Engine-Version **älter als 1.4.14** ist, verwenden Sie den Befehl `get AmazonElastiCache:cluster`.
Die Ausgaben dieser beiden Befehle sind identisch und werden im Abschnitt [Ausgabeformat](#AutoDiscovery.AddingToYourClientLibrary.OutputFormat) beschrieben.
## Cache-Engine-Version 1.4.14 oder höher
Für die Cache-Engine-Version 1.4.14 oder höher verwenden Sie den Befehl `config`. Dieser Befehl wurde den Memcached ASCII- und Binärprotokollen von hinzugefügt und ist im Cluster ElastiCache Client implementiert. ElastiCache Wenn Sie Auto Discovery mit einer anderen Client-Bibliothek verwenden möchten, muss diese Bibliothek um den Support für den Befehl `config` erweitert werden.
**Anmerkung**
Die folgende Dokumentation bezieht sich zwar auf das ASCII-Protokoll, der Befehl `config` unterstützt jedoch sowohl das ASCII- als auch das Binärprotokoll. Wenn Sie Auto Discovery-Unterstützung mithilfe des Binärprotokolls hinzufügen möchten, lesen Sie im [Quellcode für den Cluster-Client](https://github.com/amazonwebservices/aws-elasticache-cluster-client-memcached-for-java/tree/master/src/main/java/net/spy/memcached/protocol/binary) nach. ElastiCache
**Syntax**
`config [sub-command] [key]`
### Optionen
| Name | Description | Erforderlich |
| --- | --- | --- |
| sub-command | Der Unterbefehl, der zum Interagieren mit einem Cache-Knoten verwendet wird. Für Auto Discovery lautet dieser Unterbefehl `get`. | Ja |
| key | Der Schlüssel, mit dem die Cluster-Konfiguration gespeichert ist. Für Auto Discovery lautet dieser Schlüssel `cluster`. | Ja |
Verwenden Sie zum Abrufen der Cluster-Konfigurationsinformationen den folgenden Befehl:
```
config get cluster
```
## Cache-Engine-Version 1.4.14 oder niedriger
Verwenden Sie zum Abrufen der Cluster-Konfigurationsinformationen den folgenden Befehl:
```
get AmazonElastiCache:cluster
```
**Anmerkung**
Verändern Sie nicht den Schlüssel „:clusterAmazonElastiCache“, da sich dort die Cluster-Konfigurationsinformationen befinden. Wenn Sie diesen Schlüssel überschreiben, ist der Client möglicherweise für einen kurzen Zeitraum (nicht länger als 15 Sekunden) falsch konfiguriert, bevor die Konfigurationsinformationen ElastiCache automatisch und korrekt aktualisiert werden.
## Ausgabeformat
Wenn Sie `config get cluster` oder `get AmazonElastiCache:cluster` verwenden, umfasst die Antwort zwei Zeilen:
+ Die Versionsnummer der Konfigurationsinformationen. Jedes Mal, wenn ein Knoten dem Cluster hinzugefügt oder daraus entfernt wird, erhöht sich die Versionsnummer um eins.
+ Eine Liste der Cache-Knoten. Jeder Knoten in der Liste wird durch eine *hostname\$1ip-address\$1port*-Gruppe repräsentiert und durch ein Leerzeichen getrennt.
Am Ende jeder Zeile erscheint ein Wagenrücklauf- und Zeilenvorschubzeichen (CR \$1 LF). Die Datenzeile enthält am Ende ein Zeilenvorschubzeichen (LF), dem die Zeichen CR \$1 LF hinzugefügt werden. Die Config-Versionszeile wird durch LF ohne CR beendet.
Ein Cluster mit drei Knoten würde wie folgt dargestellt:
```
configversion\n
hostname|ip-address|port hostname|ip-address|port hostname|ip-address|port\n\r\n
```
Jeder Knoten wird sowohl mit dem CNAME als auch der privaten IP-Adresse angezeigt. Der CNAME ist immer vorhanden. Wenn die private IP-Adresse nicht verfügbar ist, wird sie nicht angezeigt. Die Pipe-Zeichen "`|`" werden dennoch gedruckt.
**Example**
Das nachfolgende Beispiel zeigt die Nutzlast, die zurückgegeben wird, wenn Sie die Konfigurationsinformationen abfragen:
```
CONFIG cluster 0 136\r\n
12\n
myCluster.pc4ldq.0001.use1.cache.amazonaws.com|10.82.235.120|11211 myCluster.pc4ldq.0002.use1.cache.amazonaws.com|10.80.249.27|11211\n\r\n
END\r\n
```
**Anmerkung**
Die zweite Zeile gibt an, dass die Konfigurationsinformationen bisher zwölfmal geändert wurden.
In der dritten Zeile wird die Liste der Knoten in alphabetischer Reihenfolge nach Hostname angegeben. Diese Reihenfolge kann sich von der Sequenz unterscheiden, die Sie derzeit in Ihrer Client-Anwendung verwenden.
# ElastiCache Kunden mit auto Erkennung
Cluster-Client-Programme können automatisch alle Clusterknoten identifizieren und eine Verbindung zu ihnen herstellen, auf denen die Memcached-Engine ausgeführt wird.
In diesem Abschnitt wird die Installation und Konfiguration der ElastiCache PHP- und .NET-Clients für die Verwendung mit Auto Discovery beschrieben.
**Topics**
+ [Installieren und Kompilieren von Cluster-Clients](Appendix.InstallingClients.md)
+ [Konfiguration von ElastiCache Clients](ClientConfig.md)
# Installieren und Kompilieren von Cluster-Clients
Dieser Abschnitt behandelt die Installation, Konfiguration und Kompilierung der PHP- und .NET Amazon ElastiCache Auto Discovery-Cluster-Clients.
**Topics**
+ [Installation des ElastiCache Clusterclients für.NET](Appendix.DotNETAutoDiscoverySetup.md)
+ [Installation des ElastiCache Cluster-Clients für PHP](Appendix.PHPAutoDiscoverySetup.md)
+ [Den Quellcode für den ElastiCache Cluster-Client für PHP kompilieren](Appendix.PHPAutoDiscoveryCompile.md)
# Installation des ElastiCache Clusterclients für.NET
Den Code für den ElastiCache .NET Cluster Client als Open Source finden Sie unter [https://github.com/awslabs/elasticache-cluster-config-net](https://github.com/awslabs/elasticache-cluster-config-net).
In diesem Abschnitt wird beschrieben, wie Sie die .NET-Komponenten für den ElastiCache Cluster Client auf EC2 Amazon-Instances installieren, aktualisieren und entfernen. Weitere Informationen zu Auto Discovery finden Sie unter [Identifizieren Sie automatisch Knoten in Ihrem Cluster (Memcached)](AutoDiscovery.md). Beispiele für .NET-Code zur Verwendung des Clients finden Sie unter [Den ElastiCache Cluster-Client für.NET verwenden](AutoDiscovery.Using.ModifyApp.DotNET.md).
**Topics**
+ [Installieren von .NET](#Appendix.DotNETAutoDiscoverySetup.DotNET)
+ [Laden Sie den ElastiCache .NET-Clusterclient herunter für ElastiCache](#Appendix.DotNETAutoDiscoverySetup.Downloading)
+ [Installieren Sie Assemblys AWS mit NuGet](#Appendix.DotNETAutoDiscoverySetup.Installing)
## Installieren von .NET
Sie müssen.NET 3.5 oder höher installiert haben, um AWS das.NET-SDK für verwenden zu können ElastiCache. Wenn .NET 3.5 oder höher nicht installiert ist, können Sie die aktuelle Version unter [http://www.microsoft.com/net](http://www.microsoft.com/net) herunterladen, um sie zu installieren.
## Laden Sie den ElastiCache .NET-Clusterclient herunter für ElastiCache
**Um ElastiCache den.NET-Clusterclient herunterzuladen**
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 **ElastiCache Cluster Client**.
1. **Wählen Sie in der Liste ** ElastiCache Memcached Cluster Client herunterladen** die Option **.NET** aus, und klicken Sie dann auf Herunterladen.**
## Installieren Sie Assemblys AWS mit NuGet
NuGet ist ein Paketverwaltungssystem für die .NET-Plattform. NuGet kennt die Abhängigkeiten von Assemblys und installiert alle erforderlichen Dateien automatisch. NuGet installierte Assemblys werden zusammen mit Ihrer Lösung gespeichert und nicht etwa an einem zentralen Ort`Program Files`, sodass Sie anwendungsspezifische Versionen installieren können, ohne dass Kompatibilitätsprobleme auftreten.
### Wird installiert NuGet
NuGet kann über die Installationsgalerie auf MSDN installiert werden; siehe [https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c](https://visualstudiogallery.msdn.microsoft.com/27077b70-9dad-4c64-adcf-c7cf6bc9970c). Wenn Sie Visual Studio 2010 NuGet oder höher verwenden, wird es automatisch installiert.
Sie können entweder NuGet den **Solution Explorer** oder die **Package Manager Console** verwenden.
### NuGet Vom Solution Explorer aus verwenden
**Zur Verwendung NuGet aus dem Solution Explorer in Visual Studio 2010**
1. Wählen Sie im Menü **Extras** den **Bibliotheks-Paket-Manager** aus.
1. Klicken Sie auf **Paket-Manager-Konsole**.
**Zur Verwendung NuGet aus dem Solution Explorer in Visual Studio 2012 oder Visual Studio 2013**
1. Wählen Sie im Menü **Tools** die Option **NuGet Package Manager** aus.
1. Klicken Sie auf **Paket-Manager-Konsole**.
An der Befehlszeile können Sie die Komponenten mit `Install-Package` wie im Folgenden dargestellt installieren.
```
Install-Package Amazon.ElastiCacheCluster
```
Eine Seite für jedes Paket, das verfügbar ist NuGet, z. B. für die AWS SDK- und AWS.Extensions-Assemblys, finden Sie auf der NuGet Website unter [http://www.nuget.org](http://www.nuget.org). Die Seite für jedes Paket enthält eine Beispielbefehlszeile für die Installation des Pakets mithilfe der Konsole und eine Liste der früheren Versionen des Pakets, die über NuGet verfügbar sind.
Weitere Informationen zu den Befehlen der **Paket-Manager-Konsole** finden Sie unter [http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29](http://nuget.codeplex.com/wikipage?title=Package%20Manager%20Console%20Command%20Reference%20%28v1.3%29).
# Installation des ElastiCache Cluster-Clients für PHP
In diesem Abschnitt wird beschrieben, wie Sie die PHP-Komponenten für den ElastiCache Cluster-Client auf EC2 Amazon-Instances installieren, aktualisieren und entfernen. Weitere Informationen zu Auto Discovery finden Sie unter [Identifizieren Sie automatisch Knoten in Ihrem Cluster (Memcached)](AutoDiscovery.md). Beispiele für PHP-Code zur Verwendung des Clients finden Sie unter [Den ElastiCache Cluster-Client für PHP verwenden](AutoDiscovery.Using.ModifyApp.PHP.md).
**Topics**
+ [Herunterladen des Installationspakets](Appendix.PHPAutoDiscoverySetup.Downloading.md)
+ [Für Benutzer, die bereits die Erweiterung *php-memcached* installiert haben](#Appendix.PHPAutoDiscoverySetup.InstallingExisting)
+ [Installationsschritte für neue Benutzer](Appendix.PHPAutoDiscoverySetup.Installing.md)
+ [Entfernen des PHP-Cluster-Clients](Appendix.PHPAutoDiscoverySetup.Removing.md)
# Herunterladen des Installationspakets
Um sicherzustellen, dass Sie die richtige Version des ElastiCache Cluster Client für PHP verwenden, müssen Sie wissen, welche Version von PHP auf Ihrer EC2 Amazon-Instance installiert ist. Sie müssen auch wissen, ob auf Ihrer EC2 Amazon-Instance eine 64-Bit- oder 32-Bit-Version von Linux ausgeführt wird.
**So ermitteln Sie die auf Ihrer EC2 Amazon-Instance installierte PHP-Version**
+ Führen Sie in der Befehlszeile den folgenden Befehl aus:
```
php -v
```
Die PHP-Version wird wie in diesem Beispiel ausgegeben:
```
PHP 5.4.10 (cli) (built: Jan 11 2013 14:48:57)
Copyright (c) 1997-2012 The PHP Group
Zend Engine v2.4.0, Copyright (c) 1998-2012 Zend Technologies
```
**Anmerkung**
Wenn Ihre PHP- und Memcached-Versionen inkompatibel sind, wird in etwa folgende Fehlermeldung ausgegeben:
```
PHP Warning: PHP Startup: memcached: Unable to initialize module
Module compiled with module API=20100525
PHP compiled with module API=20131226
These options need to match
in Unknown on line 0
```
In diesem Fall müssen Sie das Modul aus dem Quellcode kompilieren. Weitere Informationen finden Sie unter [Den Quellcode für den ElastiCache Cluster-Client für PHP kompilieren](Appendix.PHPAutoDiscoveryCompile.md).
**So ermitteln Sie Ihre Amazon EC2 AMI-Architektur (64-Bit oder 32-Bit)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die EC2 Amazon-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Klicken Sie in der **Instance-Liste** auf Ihre EC2 Amazon-Instance.
1. Suchen Sie auf der Registerkarte **Description** nach dem Feld **AMI:**. Die Beschreibung einer 64-Bit-Instance enthält `x86_64`, bei einer 32-Bit-Instance enthält dieses Feld `i386` oder `i686`.
Sie sind jetzt bereit, den ElastiCache Cluster Client herunterzuladen.
**Um den ElastiCache Cluster-Client für PHP herunterzuladen**
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 in der ElastiCache Konsole **ElastiCache Cluster Client** aus.
1. Wählen Sie aus der Liste ** ElastiCache Memcached Cluster Client herunterladen** den ElastiCache Cluster-Client aus, der Ihrer PHP-Version und AMI-Architektur entspricht, und klicken Sie dann auf die Schaltfläche **Herunterladen**.
## Für Benutzer, die bereits die Erweiterung *php-memcached* installiert haben
**So aktualisieren Sie die `php-memcached`-Installation**
1. Entfernen Sie die bisherige Installation der Memcached-Erweiterung für PHP, wie im Thema [Entfernen des PHP-Cluster-Clients](Appendix.PHPAutoDiscoverySetup.Removing.md) beschrieben.
1. Installieren Sie die neue ElastiCache `php-memcached` Erweiterung wie zuvor unter beschrieben[Installationsschritte für neue Benutzer](Appendix.PHPAutoDiscoverySetup.Installing.md).
# Installationsschritte für neue Benutzer
**Topics**
+ [Installieren von PHP 7.x für neue Benutzer](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x)
+ [Installieren von PHP 5.x für neue Benutzer](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x)
## Installieren von PHP 7.x für neue Benutzer
**Topics**
+ [Um PHP 7 auf einem Ubuntu-Server 14.04 LTS AMI (64-Bit und 32-Bit) zu installieren](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.Ubuntu)
+ [So installieren Sie PHP 7 auf einem Amazon Linux 201609 AMI](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.AmznLinux)
+ [So installieren Sie PHP 7 auf einem SUSE Linux-AMI](#Appendix.PHPAutoDiscoverySetup.Installing.PHP7x.SuseLinux)
### Um PHP 7 auf einem Ubuntu-Server 14.04 LTS AMI (64-Bit und 32-Bit) zu installieren
1. Starten Sie eine neue Instance aus dem AMI.
1. Führen Sie die folgenden Befehle aus:
```
sudo apt-get update
sudo apt-get install gcc g++
```
1. Installieren Sie PHP 7.
```
sudo yum install php70
```
1. Laden Sie den Amazon ElastiCache Cluster Client herunter.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extrahieren Sie `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Kopieren Sie mit Root-Berechtigungen die extrahierte Artefaktdatei `amazon-elasticache-cluster-client.so` nach `/usr/lib/php/20151012`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib/php/20151012
```
1. Fügen Sie die Zeile `extension=amazon-elasticache-cluster-client.so` in die Datei `/etc/php/7.0/cli/php.ini` ein.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php/7.0/cli/php.ini
```
1. Starten Sie Ihren Apache-Server (neu).
```
sudo /etc/init.d/httpd start
```
### So installieren Sie PHP 7 auf einem Amazon Linux 201609 AMI
1. Starten Sie eine neue Instance aus dem AMI.
1. Führen Sie den folgenden Befehl aus:
```
sudo yum install gcc-c++
```
1. Installieren Sie PHP 7.
```
sudo yum install php70
```
1. Laden Sie den Amazon ElastiCache Cluster Client herunter.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extrahieren Sie `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Kopieren Sie mit Root-Berechtigungen die extrahierte Artefaktdatei `amazon-elasticache-cluster-client.so` nach `/usr/lib64/php/7.0/modules/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php/7.0/modules/
```
1. Erstellen Sie die Datei `50-memcached.ini`.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php-7.0.d/50-memcached.ini
```
1. Starten Sie Ihren Apache-Server (neu).
```
sudo /etc/init.d/httpd start
```
### So installieren Sie PHP 7 auf einem SUSE Linux-AMI
1. Starten Sie eine neue Instance aus dem AMI.
1. Führen Sie den folgenden Befehl aus:
```
sudo zypper install gcc
```
1. Installieren Sie PHP 7.
```
sudo yum install php70
```
1. Laden Sie den Amazon ElastiCache Cluster Client herunter.
```
wget https://elasticache-downloads.s3.amazonaws.com/ClusterClient/PHP-7.0/latest-64bit
```
1. Extrahieren Sie `latest-64bit`.
```
tar -zxvf latest-64bit
```
1. Kopieren Sie mit Root-Berechtigungen die extrahierte Artefaktdatei `amazon-elasticache-cluster-client.so` nach `/usr/lib64/php7/extensions/`.
```
sudo mv artifact/amazon-elasticache-cluster-client.so /usr/lib64/php7/extensions/
```
1. Fügen Sie die Zeile `extension=amazon-elasticache-cluster-client.so` in die Datei `/etc/php7/cli/php.ini` ein.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php7/cli/php.ini
```
1. Starten Sie Ihren Apache-Server (neu).
```
sudo /etc/init.d/httpd start
```
## Installieren von PHP 5.x für neue Benutzer
**Topics**
+ [So installieren Sie PHP 5 auf einem Amazon Linux 2014.03-AMI (64-Bit und 32-Bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.AmznLinux)
+ [So installieren Sie PHP 5 auf einem Red Hat Enterprise Linux 7.0-AMI (64-Bit und 32-Bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.RHEL)
+ [So installieren Sie PHP 5 auf einem Ubuntu-Server-14.04-LTS-AMI (64-Bit und 32-Bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Ubuntu)
+ [So installieren Sie PHP 5 für SUSE-Linux-Enterprise-Server-11-AMI (64-Bit oder 32-Bit)](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.SuseLinux)
+ [Andere Linux-Distributionen](#Appendix.PHPAutoDiscoverySetup.Installing.PHP5x.Other)
### So installieren Sie PHP 5 auf einem Amazon Linux 2014.03-AMI (64-Bit und 32-Bit)
1. Starten Sie eine Amazon Linux-Instance (64-Bit oder 32-Bit) und melden Sie sich an.
1. PHP-Abhängigkeiten installieren:
```
sudo yum install gcc-c++ php php-pear
```
1. Laden Sie das richtige `php-memcached` Paket für Ihre EC2 Amazon-Instance und PHP-Version herunter. Weitere Informationen finden Sie unter [Herunterladen des Installationspakets](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installieren `php-memcached`. Die URI ist der Download-Pfad für das Installationspaket:
```
sudo pecl install
```
Hier ist ein Beispielinstallationsbefehl für PHP 5.4, 64-Bit-Linux. Ersetzen Sie es in diesem Beispiel *X.Y.Z* durch die tatsächliche Versionsnummer:
```
sudo pecl install /home/AmazonElastiCacheClusterClient-X.Y.Z-PHP54-64bit.tgz
```
**Anmerkung**
Verwenden Sie immer die aktuelle Version des Installationsartefakts.
1. Fügen Sie mit entsprechender root/sudo Genehmigung eine neue Datei mit dem Namen `memcached.ini` im `/etc/php.d` Verzeichnis hinzu und fügen Sie „extension= amazon-elasticache-cluster-client .so“ in die Datei ein:
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Starten Sie Ihren Apache-Server (neu).
```
sudo /etc/init.d/httpd start
```
### So installieren Sie PHP 5 auf einem Red Hat Enterprise Linux 7.0-AMI (64-Bit und 32-Bit)
1. Starten Sie eine Red Hat Enterprise Linux-Instance (64-Bit oder 32-Bit) und melden Sie sich an.
1. PHP-Abhängigkeiten installieren:
```
sudo yum install gcc-c++ php php-pear
```
1. Laden Sie das richtige `php-memcached` Paket für Ihre EC2 Amazon-Instance und PHP-Version herunter. Weitere Informationen finden Sie unter [Herunterladen des Installationspakets](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installieren `php-memcached`. Die URI ist der Download-Pfad für das Installationspaket:
```
sudo pecl install
```
1. Fügen Sie mit entsprechender root/sudo Genehmigung eine neue Datei mit dem Namen `memcached.ini` im `/etc/php.d` Verzeichnis hinzu und fügen Sie sie `extension=amazon-elasticache-cluster-client.so` in die Datei ein.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php.d/memcached.ini
```
1. Starten Sie Ihren Apache-Server (neu).
```
sudo /etc/init.d/httpd start
```
### So installieren Sie PHP 5 auf einem Ubuntu-Server-14.04-LTS-AMI (64-Bit und 32-Bit)
1. Starten Sie eine Ubuntu Linux-Instance (64-Bit oder 32-Bit) und melden Sie sich an.
1. PHP-Abhängigkeiten installieren:
```
sudo apt-get update
sudo apt-get install gcc g++ php5 php-pear
```
1. Laden Sie das richtige `php-memcached` Paket für Ihre EC2 Amazon-Instance und PHP-Version herunter. Weitere Informationen finden Sie unter [Herunterladen des Installationspakets](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installieren `php-memcached`. Die URI ist der Download-Pfad für das Installationspaket.
```
sudo pecl install
```
**Anmerkung**
In diesem Installationsschritt wird das Build-Artefakt `amazon-elasticache-cluster-client.so` im Verzeichnis `/usr/lib/php5/20121212*` installiert. Überprüfen Sie den absoluten Pfad des Build-Artefakts, da er im nächsten Schritt benötigt wird.
Wenn der vorherige Befehl fehlschlägt, müssen Sie das PHP-Client-Artefakt `amazon-elasticache-cluster-client.so` manuell aus der heruntergeladenen Datei `*.tgz` extrahieren und in das Verzeichnis `/usr/lib/php5/20121212*` kopieren.
```
tar -xvf
cp amazon-elasticache-cluster-client.so /usr/lib/php5/20121212/
```
1. Fügen Sie mit entsprechender root/sudo Genehmigung eine neue Datei mit dem Namen `memcached.ini` im `/etc/php5/cli/conf.d` Verzeichnis hinzu und fügen Sie „extension=“ in die Datei ein.
```
echo "extension=" | sudo tee --append /etc/php5/cli/conf.d/memcached.ini
```
1. Starten Sie Ihren Apache-Server (neu).
```
sudo /etc/init.d/httpd start
```
### So installieren Sie PHP 5 für SUSE-Linux-Enterprise-Server-11-AMI (64-Bit oder 32-Bit)
1. Starten Sie eine SUSE-Linux-Instance (64-Bit oder 32-Bit) und melden Sie sich an.
1. PHP-Abhängigkeiten installieren:
```
sudo zypper install gcc php53-devel
```
1. Laden Sie das richtige `php-memcached` Paket für Ihre EC2 Amazon-Instance und PHP-Version herunter. Weitere Informationen finden Sie unter [Herunterladen des Installationspakets](Appendix.PHPAutoDiscoverySetup.Downloading.md).
1. Installieren `php-memcached`. Die URI ist der Download-Pfad für das Installationspaket.
```
sudo pecl install
```
1. Fügen Sie mit entsprechender root/sudo Genehmigung eine neue Datei mit dem Namen `memcached.ini` im `/etc/php5/conf.d` Verzeichnis hinzu und fügen Sie sie **extension=`amazon-elasticache-cluster-client.so`** in die Datei ein.
```
echo "extension=amazon-elasticache-cluster-client.so" | sudo tee --append /etc/php5/conf.d/memcached.ini
```
1. Starten Sie Ihren Apache-Server (neu).
```
sudo /etc/init.d/httpd start
```
**Anmerkung**
Sollte Schritt 5 für die vorherigen Plattformen nicht funktionieren, überprüfen Sie den Installationspfad für `amazon-elasticache-cluster-client.so`. Geben Sie auch den vollständigen Pfad der Binary in der Erweiterung an. Bei der verwendeten PHP-Version muss es sich um eine unterstützte Version handeln. Die Versionen 5.3 bis 5.5 werden unterstützt.
### Andere Linux-Distributionen
Auf einigen Systemen, insbesondere Cent OS7 und Red Hat Enterprise Linux (RHEL) 7.1, `libsasl2.so.3` wurde es ersetzt`libsasl2.so.2`. Wenn Sie auf diesen Systemen den ElastiCache Cluster-Client laden, versucht er, ihn zu finden und zu laden`libsasl2.so.2`, aber er schlägt fehl. Um dieses Problem zu beheben, erstellen Sie einen symbolischen Link auf `libsasl2.so.3`, damit der Client beim Laden von libsasl2.so.2 auf `libsasl2.so.3` weitergeleitet wird. Mit dem folgenden Code wird dieser symbolische Link erstellt.
```
cd /usr/lib64
sudo ln libsasl2.so.3 libsasl2.so.2
```
# Entfernen des PHP-Cluster-Clients
**Topics**
+ [Entfernen einer früheren Version von PHP 7](#Appendix.PHPAutoDiscoverySetup.Removing.PHP7x)
+ [Entfernen einer früheren Version von PHP 5](#Appendix.PHPAutoDiscoverySetup.Removing.PHP5x)
## Entfernen einer früheren Version von PHP 7
**So entfernen Sie eine frühere Version von PHP 7**
1. Entfernen Sie die Datei `amazon-elasticache-cluster-client.so` aus dem entsprechenden PHP-Bibliotheksverzeichnis, wie zuvor in den Installationsanleitungen erläutert. Weitere Informationen finden Sie in Installationsabschnitt unter [Für Benutzer, die bereits die Erweiterung *php-memcached* installiert haben](Appendix.PHPAutoDiscoverySetup.md#Appendix.PHPAutoDiscoverySetup.InstallingExisting).
1. Entfernen Sie die Zeile `extension=amazon-elasticache-cluster-client.so` aus der Datei `php.ini`.
1. Starten Sie Ihren Apache-Server (neu).
```
sudo /etc/init.d/httpd start
```
## Entfernen einer früheren Version von PHP 5
**So entfernen Sie eine frühere Version von PHP 5**
1. Entfernen Sie die Erweiterung `php-memcached`:
```
sudo pecl uninstall __uri/AmazonElastiCacheClusterClient
```
1. Entfernen Sie die Datei `memcached.ini` aus dem entsprechenden Verzeichnis, wie zuvor in den Installationsanleitungen erläutert.
# Den Quellcode für den ElastiCache Cluster-Client für PHP kompilieren
In diesem Abschnitt wird beschrieben, wie Sie den Quellcode für den ElastiCache Cluster-Client für PHP abrufen und kompilieren.
[Es gibt zwei Pakete, aus denen Sie Daten abrufen GitHub und kompilieren müssen: [aws-elasticache-cluster-client-libmemcached](https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached) und -. aws-elasticache-cluster-client memcached-for-php](https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php)
**Topics**
+ [Kompilieren der libmemcached-Bibliothek](#Appendix.PHPAutoDiscoveryCompile.Libmemcached)
+ [Den ElastiCache Memcached Auto Discovery Client für PHP kompilieren](#Appendix.PHPAutoDiscoveryCompile.Client)
## Kompilieren der libmemcached-Bibliothek
**Um die Bibliothek -libmemcached zu kompilieren aws-elasticache-cluster-client**
1. Starten Sie eine EC2 Amazon-Instance.
1. Installieren Sie die Abhängigkeiten der Bibliothek.
+ Auf dem Amazon Linux 201509 AMI
```
sudo yum install gcc gcc-c++ autoconf libevent-devel
```
+ Auf dem Ubuntu 14.04 AMI
```
sudo apt-get update
sudo apt-get install libevent-dev gcc g++ make autoconf libsasl2-dev
```
1. Führen Sie einen Pull des Repositorys aus und kompilieren Sie den Code.
```
Download and install [ https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz]( https://github.com/awslabs/aws-elasticache-cluster-client-libmemcached/archive/v1.0.18.tar.gz)
```
## Den ElastiCache Memcached Auto Discovery Client für PHP kompilieren
In den folgenden Abschnitten wird beschrieben, wie der ElastiCache Memcached Auto Discovery Client kompiliert wird
**Topics**
+ [Kompilieren des ElastiCache Memcached-Clients für PHP 7](#Appendix.PHPAudiscoveryCompile.Client.PHP7)
+ [Kompilieren des ElastiCache Memcached-Clients für PHP 5](#Appendix.PHPAudiscoveryCompile.PHP5)
### Kompilieren des ElastiCache Memcached-Clients für PHP 7
Führen Sie die folgenden Befehle im Code-Verzeichnis aus.
```
git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git
cd aws-elasticache-cluster-client-memcached-for-php
git checkout php7
sudo yum install php70-devel
phpize
./configure --with-libmemcached-dir= --disable-memcached-sasl
make
make install
```
**Anmerkung**
Sie können die libmemcached-Bibliothek mit der PHP-Binärdatei statisch verknüpfen, sodass sie über verschiedene Plattformen portiert werden kann. Führen Sie dazu den folgenden Befehl vor `make` aus:
```
sed -i "s#-lmemcached#/lib/libmemcached.a -lcrypt -lpthread -lm -lstdc++ -lsasl2#" Makefile
```
### Kompilieren des ElastiCache Memcached-Clients für PHP 5
Kompilieren Sie den `aws-elasticache-cluster-client-memcached-for-php`, indem Sie die folgenden Befehle im Ordner `aws-elasticache-cluster-client-memcached-for-php/` ausführen.
```
git clone https://github.com/awslabs/aws-elasticache-cluster-client-memcached-for-php.git
cd aws-elasticache-cluster-client-memcached-for-php
sudo yum install zlib-devel
phpize
./configure --with-libmemcached-dir=
make
make install
```
# Konfiguration von ElastiCache Clients
Ein ElastiCache Cluster ist protokollkonform mit Valkey, Memcached und Redis OSS. Der Code, die Anwendungen und die beliebtesten Tools, die Sie heute in Ihrer bestehenden Umgebung verwenden, funktionieren problemlos mit dem Service.
Dieser Abschnitt befasst sich mit den spezifischen Überlegungen für das Verbinden mit Cache-Knoten in ElastiCache.
**Topics**
+ [Eingeschränkte Befehle](ClientConfig.RestrictedCommands.md)
+ [Finden von Knotenendpunkten und Portnummern](ClientConfig.FindingEndpointsAndPorts.md)
+ [Verbinden für die Verwendung der automatischen Erkennung](ClientConfig.AutoDiscovery.md)
+ [Verbindung zu Knoten in einem Valkey- oder Redis OSS-Cluster herstellen](ClientConfig.ReplicationGroup.md)
+ [DNS-Namen und zugrunde liegende IP](ClientConfig.DNS.md)
# Eingeschränkte Befehle
ElastiCache Schränkt den Zugriff auf bestimmte Cache-Engine-spezifische Befehle ein, die erweiterte Rechte erfordern, um ein Managed Service-Erlebnis zu bieten. Für Cluster, auf denen Redis OSS ausgeführt wird, sind die folgenden Befehle nicht verfügbar:
+ `bgrewriteaof`
+ `bgsave`
+ `config`
+ `debug`
+ `migrate`
+ `replicaof`
+ `save`
+ `slaveof`
+ `shutdown`
+ `sync`
# Finden von Knotenendpunkten und Portnummern
Um eine Verbindung zu einem Cache-Knoten herzustellen, muss Ihre Anwendung den Endpunkt und die Portnummer für diesen Knoten kennen.
## Finden von Knotenendpunkten und Portnummern (Konsole)
**So bestimmen Sie Knotenendpunkte und Portnummern**
1. Melden Sie sich bei der [Amazon ElastiCache Management Console](https://aws.amazon.com/elasticache) an und wählen Sie die Engine aus, die auf Ihrem Cluster läuft.
Es wird eine Liste aller Cluster der ausgewählten Engine angezeigt.
1. Fahren Sie mit der Anleitung für die ausgewählte Engine und Konfiguration fort.
1. Wählen Sie den Namen des gewünschten Clusters aus.
1. Entnehmen Sie die benötigten Informationen für den gewünschten Knoten aus den Spalten **Port** und **Endpoint**.
## Finden von Cache-Knotenendpunkten und Portnummern (AWS CLI)
Verwenden Sie den Befehl `describe-cache-clusters` mit dem Parameter `--show-cache-node-info`, um die Endpunkte und Portnummern von Cache-Knoten zu bestimmen.
```
aws elasticache describe-cache-clusters --show-cache-node-info
```
Sie finden die vollständig qualifizierten DNS-Namen und Portnummern im Abschnitt Endpunkt in der Ausgabe.
## Suche nach Endpunkten und Portnummern von Cache-Knoten (ElastiCache API)
Verwenden Sie die Aktion `DescribeCacheClusters` mit dem Parameter `ShowCacheNodeInfo=true`, um die Endpunkte und Portnummern von Cache-Knoten zu bestimmen.
**Example**
```
1. https://elasticache.us-west-2.amazonaws.com /
2. ?Action=DescribeCacheClusters
3. &ShowCacheNodeInfo=true
4. &SignatureVersion=4
5. &SignatureMethod=HmacSHA256
6. &Timestamp=20140421T220302Z
7. &Version=2014-09-30
8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
9. &X-Amz-Credential=
10. &X-Amz-Date=20140421T220302Z
11. &X-Amz-Expires=20140421T220302Z
12. &X-Amz-Signature=
13. &X-Amz-SignedHeaders=Host
```
# Verbinden für die Verwendung der automatischen Erkennung
Wenn Sie in Ihren Anwendungen Auto Discovery verwenden, müssen Sie anstelle der einzelnen Endpunkte für jeden Cache-Knoten den Konfigurationsendpunkt für das Cluster kennen. Weitere Informationen finden Sie unter [Identifizieren Sie automatisch Knoten in Ihrem Cluster (Memcached)](AutoDiscovery.md).
**Anmerkung**
Derzeit ist Auto Discovery nur für Cluster verfügbar, auf denen Memcached ausgeführt wird.
# Verbindung zu Knoten in einem Valkey- oder Redis OSS-Cluster herstellen
**Anmerkung**
Derzeit werden Cluster (API/CLI: Replikationsgruppen), die Replikation und Read Replicas unterstützen, nur für Cluster unterstützt, auf denen Valkey oder Redis OSS ausgeführt wird.
ElastiCache Stellt für Cluster Konsolen-, CLI- und API-Schnittstellen bereit, um Verbindungsinformationen für einzelne Knoten abzurufen.
Für reine Lesezugriffe können Anwendungen eine Verbindung zu beliebigen Knoten im Cluster herstellen. Für Schreibaktivitäten empfehlen wir jedoch, dass Ihre Anwendungen eine Verbindung zum primären Endpunkt (Valkey oder Redis OSS (Clustermodus deaktiviert)) oder Konfigurationsendpunkt (Valkey oder Redis OSS (Clustermodus aktiviert)) für den Cluster herstellen, anstatt eine direkte Verbindung zu einem Knoten herzustellen. Dadurch wird sichergestellt, dass Ihre Anwendungen immer den korrekten Knoten finden, auch wenn Sie das Cluster neu konfigurieren und einem Lesereplikat die primäre Rolle zuweisen.
## Verbinden mit Clustern in einer Replikationsgruppe (Konsole)
**So bestimmen Sie Endpunkte und Portnummern**
+ Weitere Informationen finden Sie auch im Thema [Finden Sie die Endpunkte eines Valkey- oder Redis OSS-Clusters (Cluster-Modus deaktiviert) (Konsole)](Endpoints.md#Endpoints.Find.Redis).
## Verbinden mit Clustern in einer Replikationsgruppe (AWS CLI)
**So bestimmen Sie die Cache-Knoten-Endpunkte und Portnummern**
Verwenden Sie den Befehl `describe-replication-groups` mit dem Namen Ihrer Replikationsgruppe:
```
aws elasticache describe-replication-groups redis2x2
```
Die Ausgabe dieses Befehls sieht ähnlich wie folgt aus:
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "2 shards, 2 nodes (1 + 1 replica)",
"NodeGroups": [
{
"Status": "available",
"Slots": "0-8191",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "redis2x2-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "redis2x2.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "redis2x2",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"redis2x2-0001-001",
"redis2x2-0001-002",
"redis2x2-0002-001",
"redis2x2-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"PendingModifiedValues": {}
}
]
}
```
## Verbindung zu Clustern in einer Replikationsgruppe (API) herstellen ElastiCache
**So bestimmen Sie die Cache-Knoten-Endpunkte und Portnummern**
Rufen Sie `DescribeReplicationGroups` mit folgendem Parameter auf:
`ReplicationGroupId` = der Name Ihrer Replikationsgruppe
**Example**
```
1. https://elasticache.us-west-2.amazonaws.com /
2. ?Action=DescribeCacheClusters
3. &ReplicationGroupId=repgroup01
4. &Version=2014-09-30
5. &SignatureVersion=4
6. &SignatureMethod=HmacSHA256
7. &Timestamp=20140421T220302Z
8. &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
9. &X-Amz-Date=20140421T220302Z
10. &X-Amz-SignedHeaders=Host
11. &X-Amz-Expires=20140421T220302Z
12. &X-Amz-Credential=
13. &X-Amz-Signature=
```
# DNS-Namen und zugrunde liegende IP
Clients verfügen über eine Serverliste mit den Adressen und Ports der Server, auf denen Cache-Daten abgelegt werden. Bei der Verwendung ElastiCache gibt die DescribeCacheClusters API (oder das describe-cache-clusters Befehlszeilenprogramm) einen vollqualifizierten DNS-Eintrag und eine Portnummer zurück, die für die Serverliste verwendet werden können.
**Wichtig**
Es ist wichtig, dass Client-Anwendungen so konfiguriert werden, dass DNS-Namen von Cache-Knoten regelmäßig aufgelöst werden, wenn sie versuchen, eine Verbindung zu einem Cache-Knotenendpunkt herzustellen.
ElastiCache stellt sicher, dass der DNS-Name der Cache-Knoten derselbe bleibt, wenn Cache-Knoten im Falle eines Fehlers wiederhergestellt werden.
Persistente Cache-Knotenverbindungen werden von den meisten Client-Bibliotheken standardmäßig unterstützt. Wir empfehlen, beim Verwenden von ElastiCache persistente Cache-Knotenverbindungen zu nutzen. Clientseitige Zwischenspeicherung von DNS-Informationen kann an mehreren Orten erfolgen, darunter Client-Bibliotheken, der Sprache der Laufzeitumgebung oder dem Betriebssystem des Clients. Prüfen Sie die Konfiguration Ihrer Anwendung auf allen Ebenen, um sicherzustellen, dass IP-Adressen für Ihre Cache-Knoten regelmäßig aufgelöst werden.
# Datenzuweisung ElastiCache
ElastiCache Bei Valkey- oder Redis-OSS-Clustern, die eine Replikationsgruppe bilden und einen Knotentyp aus der R6GD-Familie verwenden, werden die Daten zwischen Arbeitsspeicher und lokalem SSD-Speicher (Solid State Drives) aufgeteilt. Data Tiering bietet eine neue Preis-Leistungs-Option für Valkey- oder Redis-OSS-Workloads, da neben der Speicherung von Daten im Arbeitsspeicher auch kostengünstigere Solid-State-Laufwerke (SSDs) in jedem Clusterknoten verwendet werden. Diese Option ist ideal für Workloads, die regelmäßig auf bis zu 20 Prozent ihres gesamten Datensatzes zugreifen, und für Anwendungen, die beim Zugriff auf Daten auf SSD zusätzliche Latenz tolerieren können.
ElastiCache Überwacht auf ElastiCache Clustern mit Daten-Tiering die letzte Zugriffszeit jedes gespeicherten Elements. Wenn der verfügbare Speicher (DRAM) vollständig verbraucht ist, ElastiCache verwendet es einen LRU-Algorithmus (Least-Recently Used), um Objekte, auf die selten zugegriffen wird, automatisch vom Arbeitsspeicher auf die SSD zu verschieben. Wenn anschließend auf Daten auf der SSD zugegriffen wird, werden sie ElastiCache automatisch und asynchron zurück in den Arbeitsspeicher verschoben, bevor die Anforderung verarbeitet wird. Wenn Sie eine Workload haben, die regelmäßig nur auf eine Teilmenge ihrer Daten zugreift, ist Daten-Tiering eine optimale Möglichkeit, Ihre Kapazität kostengünstig zu skalieren.
Beachten Sie, dass bei der Verwendung von Daten-Tiering die Schlüssel selbst immer im Speicher verbleiben, während die LRU die Platzierung von Werten in dem Speicher im Vergleich zur Festplatte regelt. Im Allgemeinen empfehlen wir, dass Ihre Schlüsselgrößen kleiner als Ihre Wertgrößen sind, wenn Sie Daten-Tiering verwenden.
Das Daten-Tiering ist so konzipiert, dass es minimale Auswirkungen auf die Leistung von Anwendungs-Workloads hat. Bei Annahme von 500-Byte-String-Werten können Sie beispielsweise durchschnittlich zusätzliche 300 Mikrosekunden Latenzzeit für Anforderungen an auf SSD gespeicherte Daten im Vergleich zu Anforderungen an Daten im Speicher erwarten.
Mit der größten Daten-Tiering-Knotengröße (cache.r6gd.16xlarge) können Sie bis zu 1 Petabyte Daten in einem einzigen Cluster mit 500 Knoten speichern (500 TB bei Verwendung von 1 Lesereplikat). Data Tiering ist mit allen Valkey- oder Redis-OSS-Befehlen und Datenstrukturen kompatibel, die in unterstützt werden. ElastiCache Um diese Funktion nutzen zu können, sind keine clientseitigen Änderungen erforderlich.
**Topics**
+ [Bewährte Methoden](#data-tiering-best-practices)
+ [Einschränkungen](#data-tiering-prerequisites)
+ [Preisgestaltung](#data-tiering-pricing)
+ [Überwachen](#data-tiering-monitoring)
+ [Verwenden von Daten-Tiering](#data-tiering-enabling)
+ [Wiederherstellen von Daten aus einem Backup in Cluster mit aktiviertem Daten-Tiering](#data-tiering-enabling-snapshots)
## Bewährte Methoden
Wir empfehlen Ihnen, die folgenden bewährten Methoden:
+ Daten-Tiering ist ideal für Workloads, die regelmäßig auf bis zu 20 Prozent ihres gesamten Datensatzes zugreifen, und für Anwendungen, die beim Zugriff auf Daten auf SSD zusätzliche Latenz tolerieren können.
+ Bei Verwendung von SSD-Kapazität, die auf Daten-Tiering-Knoten verfügbar ist, empfehlen wir, dass die Wertgröße größer als die Schlüsselgröße ist. Wenn Elemente zwischen DRAM und SSD verschoben werden, bleiben die Schlüssel immer im Speicher und nur die Werte werden in die SSD-Ebene verschoben.
## Einschränkungen
Für Daten-Tiering gelten die folgenden Beschränkungen:
+ Sie können Daten-Tiering nur für Cluster verwenden, die Teil einer Replikationsgruppe sind.
+ Der verwendete Knotentyp muss aus der r6gd-Familie stammen, die in den folgenden Regionen verfügbar ist: `us-east-2`, `us-east-1`, `us-west-2`, `us-west-1`, `eu-west-1`, `eu-central-1`, `eu-north-1`, `eu-west-3`, `ap-northeast-1`, `ap-southeast-1`, `ap-southeast-2`, `ap-south-1`, `ca-central-1` und `sa-east-1`.
+ Sie müssen eine Engine verwenden, die Valkey 7.2 oder höher ist, oder eine Redis OSS 6.2 oder höher.
+ Sie können ein Backup eines R6gd-Clusters nur dann in einem anderen Cluster wiederherstellen, wenn dieses ebenfalls R6gd verwendet.
+ Backups für Cluster mit Daten-Tiering können nicht nach Amazon S3 exportiert werden.
+ Die Online-Migration wird für Cluster mit R6gd-Knotentyp nicht unterstützt.
+ Die Skalierung von einem Cluster mit Daten-Tiering (z. B. ein Cluster, der einen R6gd-Knotentyp verwendet) zu einem Cluster ohne Daten-Tiering (z. B. ein Cluster, der einen R6g-Knotentyp verwendet) wird nicht unterstützt. Weitere Informationen finden Sie unter [Skalierung ElastiCache](Scaling.md).
+ Auto Scaling wird auf Clustern unterstützt, die Data Tiering für Valkey Version 7.2 und höher sowie Redis OSS Version 7.0.7 und höher verwenden. Weitere Informationen finden Sie unter [Auto Scaling Valkey- und Redis OSS-Cluster](AutoScaling.md).
+ Daten-Tiering unterstützt nur die maxmemory-Richtlinien `volatile-lru`, `allkeys-lru`, `volatile-lfu`, `allkeys-lfu` und `noeviction`.
+ Forkless Save wird für Valkey Version 7.2 und höher sowie Redis OSS Version 7.0.7 und höher unterstützt. Weitere Informationen finden Sie unter [So werden Synchronisation und Backup implementiert](Replication.Redis.Versions.md).
+ Elemente, die größer als 128 MiB sind, werden nicht auf SSD verschoben.
+ Ab Valley 8.1 und höher wird ein Element, dessen Schlüssel\$1Wertgröße weniger als 40 Byte beträgt, nicht auf die SSD verschoben.
## Preisgestaltung
R6gd-Knoten haben eine 4,8-mal höhere Gesamtkapazität (Speicher \$1 SSD). Bei maximaler Auslastung können Sie durch ihren Einsatz Einsparungen von über 60 Prozent im Vergleich zu R6g-Knoten (nur Speicher) erzielen. Weitere Informationen finden Sie unter [ElastiCache Preise](https://aws.amazon.com/elasticache/pricing/).
## Überwachen
ElastiCache bietet Metriken, die speziell für die Überwachung von Leistungsclustern entwickelt wurden, die Datenklassifizierung verwenden. Um das Verhältnis der Elemente in DRAM im Vergleich zu SSD zu überwachen, können Sie die `CurrItems` Metrik unter [Metrics for Valkey und](CacheMetrics.Redis.md) Redis OSS verwenden. Sie können den Prozentsatz wie folgt berechnen: *(CurrItems mit Dimension: Tier = Speicher \$1 100)/(ohne CurrItems Dimensionsfilter*).
Wenn die konfigurierte Löschrichtlinie dies zulässt, ElastiCache wird mit dem Löschen von Elementen begonnen, wenn der Prozentsatz der Elemente im Speicher unter 5 Prozent sinkt. Auf Knoten, für die die Noeviction-Richtlinie konfiguriert wurde, wird bei Schreibvorgängen der Fehler „Nicht genügend Arbeitsspeicher“ angezeigt.
Es wird dennoch empfohlen, die Skalierung für Cluster mit aktiviertem Clustermodus oder die Hochskalierung für Cluster mit deaktiviertem Clustermodus in Betracht zu ziehen, wenn der Prozentsatz der Elemente im Arbeitsspeicher unter 5 Prozent sinkt. Weitere Informationen zur Skalierung finden Sie unter[Skalierung von Valkey- oder Redis OSS-Clustern (Clustermodus aktiviert)](scaling-redis-cluster-mode-enabled.md). Weitere Informationen zu Metriken für Valkey- oder Redis OSS-Cluster, die Data Tiering verwenden, finden Sie unter. [Metriken für Valkey und Redis OSS](CacheMetrics.Redis.md)
## Verwenden von Daten-Tiering
### Verwenden von Data Tiering mit dem AWS-Managementkonsole
Wenn Sie einen Cluster als Teil einer Replikationsgruppe erstellen, verwenden Sie Daten-Tiering, indem Sie einen Knotentyp aus der R6gd-Familie auswählen, z. B. *cache.r6gd.xlarge*. Bei Auswahl dieses Knotentyps wird das Daten-Tiering automatisch aktiviert.
Weitere Informationen zum Erstellen von Clustern finden Sie unter [Einen Cluster für Valkey oder Redis OSS erstellen](Clusters.Create.md).
### Aktivieren von Data Tiering mit dem AWS CLI
Beim Erstellen einer Replikationsgruppe mithilfe von verwenden Sie Data Tiering AWS CLI, indem Sie einen Knotentyp aus der r6gd-Familie auswählen, z. B. *cache.r6gd.xlarge*, und den Parameter festlegen. `--data-tiering-enabled`
Sie können sich das Daten-Tiering nicht abwählen, wenn Sie einen Knotentyp aus der R6gd-Familie auswählen. Wenn Sie den Parameter `--no-data-tiering-enabled` festlegen, schlägt die Operation fehl.
Für Linux, macOS oder Unix:
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled
```
Für Windows:
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled
```
Nach dem Ausführen dieses Vorgangs sehen Sie eine Antwort ähnlich dem folgenden:
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
## Wiederherstellen von Daten aus einem Backup in Cluster mit aktiviertem Daten-Tiering
Sie können ein Backup auf einem neuen Cluster mit aktiviertem Data Tiering mithilfe der (Konsole), () oder (API) wiederherstellen.AWS CLI ElastiCache Wenn Sie einen Cluster mit Knotentypen in der R6gd-Familie erstellen, ist Daten-Tiering aktiviert.
### Wiederherstellen von Daten aus einem Backup in Cluster mit aktiviertem Daten-Tiering (Konsole)
**So stellen Sie ein Backup in einem neuen Cluster mit aktiviertem Daten-Tiering wieder her (Konsole)**
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 **Backups** aus.
1. Aktivieren Sie in der Liste der Sicherungen das Kontrollkästchen links neben dem Namen der Sicherung, aus der Sie wiederherstellen möchten.
1. Wählen Sie **Restore** (Wiederherstellen) aus.
1. Füllen Sie das Dialogfeld **Restore Cluster** aus. Füllen Sie unbedingt alle **Pflichtfelder** aus sowie alle anderen, deren Standardeinstellungen Sie ändern möchten.
1. **Cluster-ID** – Erforderlich. Der Name des neuen Clusters.
1. **Cluster-Modus aktiviert (Scale Out)** — Wählen Sie diese Option für einen Valkey- oder Redis OSS-Cluster (Cluster-Modus aktiviert).
1. **Node Type** (Knotentyp) – Geben Sie **cache.r6gd.xlarge** oder einen anderen Knotentyp aus der R6gd-Familie an.
1. **Anzahl der Shards** – Wählen Sie die Anzahl der Shards aus, die sich im neuen Cluster (API/CLI: Knotengruppen) befinden sollen.
1. **Replicas pro Shard** – Wählen Sie die Anzahl der Lesereplikat-Knoten aus, die sich in jedem Shard befinden sollen.
1. **Slots und Keyspaces** – Wählen Sie aus, wie die Schlüssel auf die Shards verteilt werden sollen. Wenn Sie die Schlüsselverteilungen angeben möchten, füllen Sie die Tabelle mit den Schlüsselbereichen für jeden Shard aus.
1. **Availability zone(s)** – Geben Sie an, wie die Availability Zones des Clusters ausgewählt werden sollen.
1. **Port** – Ändern Sie diese Einstellung nur, wenn der neue Cluster einen anderen Port verwenden soll.
1. **VPC auswählen** – Wählen Sie die VPC aus, in der dieser Cluster erstellt werden soll.
1. **Parametergruppe** — Wählen Sie eine Parametergruppe, die ausreichend Speicher für den Valkey- oder Redis-OSS-Overhead für den ausgewählten Knotentyp reserviert.
1. Wenn Sie die gewünschten Einstellungen vorgenommen haben, wählen Sie **Erstellen**.
Weitere Informationen zum Erstellen von Clustern finden Sie unter [Einen Cluster für Valkey oder Redis OSS erstellen](Clusters.Create.md).
### Wiederherstellen von Daten aus einem Backup in Cluster mit aktiviertem Daten-Tiering (AWS CLI)
Beim Erstellen einer Replikationsgruppe mithilfe von wird Data Tiering standardmäßig verwendet AWS CLI, indem ein Knotentyp aus der r6gd-Familie ausgewählt wird, z. B. *cache.r6gd.xlarge*, und der Parameter festgelegt wird. `--data-tiering-enabled`
Sie können sich das Daten-Tiering nicht abwählen, wenn Sie einen Knotentyp aus der R6gd-Familie auswählen. Wenn Sie den Parameter `--no-data-tiering-enabled` festlegen, schlägt die Operation fehl.
Für Linux, macOS oder Unix:
```
aws elasticache create-replication-group \
--replication-group-id redis-dt-cluster \
--replication-group-description "Redis OSS cluster with data tiering" \
--num-node-groups 1 \
--replicas-per-node-group 1 \
--cache-node-type cache.r6gd.xlarge \
--engine redis \
--cache-subnet-group-name default \
--automatic-failover-enabled \
--data-tiering-enabled \
--snapshot-name my-snapshot
```
Für Linux, macOS oder Unix:
```
aws elasticache create-replication-group ^
--replication-group-id redis-dt-cluster ^
--replication-group-description "Redis OSS cluster with data tiering" ^
--num-node-groups 1 ^
--replicas-per-node-group 1 ^
--cache-node-type cache.r6gd.xlarge ^
--engine redis ^
--cache-subnet-group-name default ^
--automatic-failover-enabled ^
--data-tiering-enabled ^
--snapshot-name my-snapshot
```
Nach dem Ausführen dieses Vorgangs sehen Sie eine Antwort ähnlich dem folgenden:
```
{
"ReplicationGroup": {
"ReplicationGroupId": "redis-dt-cluster",
"Description": "Redis OSS cluster with data tiering",
"Status": "creating",
"PendingModifiedValues": {},
"MemberClusters": [
"redis-dt-cluster"
],
"AutomaticFailover": "enabled",
"DataTiering": "enabled",
"SnapshotRetentionLimit": 0,
"SnapshotWindow": "06:00-07:00",
"ClusterEnabled": false,
"CacheNodeType": "cache.r6gd.xlarge",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false
}
}
```
# Einen Cluster vorbereiten in ElastiCache
Im Folgenden finden Sie Anweisungen zum Erstellen eines Clusters mithilfe der ElastiCache Konsole AWS CLI, der oder der ElastiCache API.
Sie können einen ElastiCache Cluster auch mithilfe von erstellen [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html). Weitere Informationen finden Sie unter [AWS:ElastiCache::: CacheCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-cache-cluster.html) im *AWS Cloud Formation-Benutzerhandbuch*, das Anleitungen zur Implementierung dieses Ansatzes enthält.
Wenn Sie einen Cluster oder eine Replikationsgruppe erstellen, ist es ratsam, einige Vorbereitungen zu treffen, damit Sie nicht sofort ein Upgrade durchführen oder Änderungen vornehmen müssen.
**Topics**
+ [Ermitteln Ihrer ElastiCache Cluster-Anforderungen](cluster-create-determine-requirements.md)
+ [Auswahl der Knotengröße](CacheNodes.SelectSize.md)
# Ermitteln Ihrer ElastiCache Cluster-Anforderungen
**Vorbereitung**
Wenn Sie die Antworten auf die folgenden Fragen kennen, kann die ElastiCache Clustererstellung reibungsloser vonstatten gehen:
+ Welchen Knoten-Instance-Typ benötigen Sie?
Eine Anleitung bei der Auswahl eines Knoten-Instance-Typs finden Sie unter [Auswahl der Knotengröße](CacheNodes.SelectSize.md).
+ Werden Sie Ihren Cluster in einer Virtual Private Cloud (VPC) auf der Basis von Amazon VPC starten?
**Wichtig**
Wenn Sie den Cluster in einer VPC starten, müssen Sie in derselben VPC eine Subnetzgruppe erstellen, bevor mit dem Erstellen eines Clusters beginnen. Weitere Informationen finden Sie unter [Subnetze und Subnetzgruppen](SubnetGroups.md).
ElastiCache ist so konzipiert, dass der Zugriff AWS über Amazon von innen möglich ist EC2. Wenn Sie jedoch in einer VPC starten, die auf Amazon VPC basiert, und Ihr Cluster sich in einer VPC befindet, können Sie den Zugriff von außerhalb AWS ermöglichen. Weitere Informationen finden Sie unter [Zugriff auf ElastiCache Ressourcen von außen AWS](accessing-elasticache.md#access-from-outside-aws).
+ Müssen Sie irgendwelche Parameterwerte anpassen?
Erstellen Sie in diesem Fall eine benutzerdefinierte Parametergruppe. Weitere Informationen finden Sie unter [Eine ElastiCache Parametergruppe erstellen](ParameterGroups.Creating.md).
Wenn Sie Valkey oder Redis OSS verwenden, sollten Sie die Einstellung `reserved-memory` von oder in Betracht ziehen. `reserved-memory-percent` Weitere Informationen finden Sie unter [Verwaltung von reserviertem Speicher für Valkey und Redis OSS](redis-memory-management.md).
+ Müssen Sie eine eigene *VPC-Sicherheitsgruppe* erstellen?
Weitere Informationen finden Sie unter [Sicherheit in Ihrer VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Security.html).
+ Haben Sie vor, Fehlertoleranz zu implementieren?
Weitere Informationen finden Sie unter [Minimieren von Ausfällen](disaster-recovery-resiliency.md#FaultTolerance).
**Topics**
+ [ElastiCache Speicher- und Prozessoranforderungen](#cluster-create-determine-requirements-memory)
+ [Konfiguration von Memcached-Cluster](#memcached-cluster-configuration)
+ [Valkey- und Redis OSS-Clusterkonfiguration](#redis-cluster-configuration)
+ [ElastiCache Skalierungsanforderungen](#cluster-create-determine-requirements-scaling)
+ [ElastiCache Zugriffsanforderungen](#cluster-create-determine-requirements-access)
+ [Anforderungen an Region, Availability Zone und Lokale Zone für ElastiCache](#cluster-create-determine-requirements-region)
## ElastiCache Speicher- und Prozessoranforderungen
Der Grundbaustein von Amazon ElastiCache ist der Node. Knoten werden zur Bildung von Clustern einzeln oder in Gruppierungen konfiguriert. Berücksichtigen Sie bei der Bestimmung des für den Cluster zu verwendenden Knotentyps die Knotenkonfiguration des Clusters und die zu speichernde Datenmenge.
Die Memcached-Engine arbeitet mit mehreren Threads. Daher wirkt sich die Anzahl der Kerne eines Knotens auf die für den Cluster verfügbare Rechenleistung aus.
## Konfiguration von Memcached-Cluster
ElastiCache für Memcached bestehen Cluster aus 1 bis 60 Knoten. Die Daten in einem Memcached-Cluster werden über Knoten im Cluster hinweg partitioniert. Ihre Anwendung stellt über eine als Endpunkt bezeichnete Netzwerkadresse eine Verbindung mit einem Memcached-Cluster her. Jeder Knoten in einem Memcached-Cluster verfügt über seinen eigenen Endpunkt. Dieser wird von der Anwendung zum Lesen aus oder Schreiben in einem bestimmten Knoten genutzt. Zusätzlich zu den Knotenendpunkten hat der Memcached-Cluster selbst einen Endpunkt, der als *Konfigurationsendpunkt* bezeichnet wird. Ihre Anwendung kann diesen Endpunkt verwenden, um aus dem Cluster zu lesen oder in den Cluster zu schreiben, wobei die Bestimmung des Knotens, aus dem gelesen oder in den geschrieben werden soll, Auto Discovery überlassen bleibt.
![\[Das Bild zeigt, wie ein Memcached-Cluster auf die Knoten im Cluster aufgeteilt ist.\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/ElastiCache-Cluster-Memcached.png)
Weitere Informationen finden Sie unter [Verwaltung von Clustern in ElastiCache](Clusters.md).
## Valkey- und Redis OSS-Clusterkonfiguration
ElastiCache für Valkey und Redis bestehen OSS-Cluster aus 0 bis 500 Shards (auch Knotengruppen genannt). Die Daten in einem Valkey- oder Redis OSS-Cluster sind auf die Shards im Cluster verteilt. Ihre Anwendung stellt über eine Netzwerkadresse, die als Endpunkt bezeichnet wird, eine Verbindung zu einem Valkey- oder Redis-OSS-Cluster her. Die Knoten in einem Valkey- oder Redis OSS-Shard erfüllen eine von zwei Rollen: eine read/write primäre und alle anderen Knoten sind schreibgeschützte Sekundärknoten (auch Read Replicas genannt). *Zusätzlich zu den Knotenendpunkten verfügt der Valkey- oder Redis-OSS-Cluster selbst über einen Endpunkt, den sogenannten Konfigurationsendpunkt.* Ihre Anwendung kann diesen Endpunkt verwenden, um aus dem Cluster zu lesen oder in ihn zu schreiben. Die Entscheidung, von welchem Knoten gelesen oder auf welchen geschrieben werden soll, bleibt Redis OSS ElastiCache überlassen.
![\[Bild, das einen Valkey- oder Redis-OSS-Cluster im deaktivierten Modus mit einem aktivierten Modus vergleicht.\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-Redis-ClustersRGs.png)
Weitere Informationen finden Sie unter [Verwaltung von Clustern in ElastiCache](Clusters.md).
## ElastiCache Skalierungsanforderungen
Alle Cluster können hochskaliert werden, indem ein neuer Cluster mit einem neuen, größeren Knotentyp erstellt wird. Wenn Sie einen Memcached-Cluster hochskalieren, ist der neue Cluster zunächst leer. Wenn Sie einen Valkey- oder Redis OSS-Cluster hochskalieren, können Sie ihn von einem Backup aus starten und so verhindern, dass der neue Cluster leer anfängt.
Amazon ElastiCache for Memcached-Cluster können horizontal oder horizontal skaliert werden. Ein Memcached-Cluster wird einfach durch Hinzufügen oder Entfernen von Knoten aus dem Cluster nach oben bzw. nach unten skaliert. Wenn Automatic Discovery aktiviert ist und die Anwendung mit dem Konfigurationsendpunkt des Clusters verbunden ist, sind zum Hinzufügen oder Entfernen von Knoten keine Änderungen an Ihrer Anwendung erforderlich.
Weitere Informationen finden Sie unter [Skalierung ElastiCache](Scaling.md) in diesem Handbuch.
## ElastiCache Zugriffsanforderungen
Standardmäßig wird auf ElastiCache Amazon-Cluster von EC2 Amazon-Instances aus zugegriffen. Der Netzwerkzugriff auf einen ElastiCache Cluster ist auf das Konto beschränkt, mit dem der Cluster erstellt wurde. Bevor Sie von einer EC2 Amazon-Instance aus auf einen Cluster zugreifen können, müssen Sie daher die EC2 Amazon-Instance autorisieren, auf den Cluster zuzugreifen. Die Schritte dazu variieren, je nachdem, ob Sie mit EC2 VPC oder EC2 -Classic gestartet sind.
Wenn Sie Ihren Cluster in EC2 VPC gestartet haben, müssen Sie dem Cluster Netzwerkzugang gewähren. Wenn Sie Ihren Cluster in EC2 -Classic gestartet haben, müssen Sie der Amazon Elastic Compute Cloud-Sicherheitsgruppe, die mit der Instance verknüpft ist, Zugriff auf Ihre ElastiCache Sicherheitsgruppe gewähren. Detaillierte Anweisungen finden Sie unter [Schritt 3. Autorisieren Sie den Zugriff auf den Cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) in diesem Handbuch.
## Anforderungen an Region, Availability Zone und Lokale Zone für ElastiCache
Amazon ElastiCache unterstützt alle AWS Regionen. Indem Sie Ihre ElastiCache Cluster in einer AWS Region in der Nähe Ihrer Anwendung platzieren, können Sie die Latenz reduzieren. Wenn Ihr Cluster aus mehreren Knoten besteht, können Sie die Auswirkungen von Ausfällen auf Ihren Cluster verringern, indem Sie Ihre Knoten in verschiedenen Availability Zones oder in Local Zones unterbringen.
Weitere Informationen finden Sie hier:
+ [Auswahl von Regionen und Verfügbarkeitszonen für ElastiCache](RegionsAndAZs.md)
+ [Verwenden von lokalen Zonen mit ElastiCache](Local_zones.md)
+ [Minimieren von Ausfällen](disaster-recovery-resiliency.md#FaultTolerance)
# Auswahl der Knotengröße
Die Knotengröße, die Sie für Ihren ElastiCache Cluster auswählen, wirkt sich auf Kosten, Leistung und Fehlertoleranz aus.
## Knotengröße (Valkey und Redis OSS)
Informationen zu den Vorteilen von Graviton-Prozessoren finden Sie unter [AWS -Graviton-Prozessor](https://aws.amazon.com/pm/ec2-graviton/).
Die Beantwortung der folgenden Fragen kann Ihnen helfen, den minimalen Knotentyp zu ermitteln, den Sie für Ihre Valkey- oder Redis OSS-Implementierung benötigen:
+ Erwarten Sie durchsatzgebundene Workloads mit mehreren Client-Verbindungen?
Wenn dies der Fall ist und Sie Redis OSS Version 5.0.6 oder höher verwenden, können Sie mit unserer erweiterten I/O Funktion, die, sofern verfügbarCPUs , für die Entlastung der Client-Verbindungen im Namen der Redis OSS-Engine verwendet wird, einen besseren Durchsatz und eine bessere Latenz erzielen. Wenn Sie Redis OSS Version 7.0.4 oder höher ausführen, lesen Threads jetzt zusätzlich zu den erweiterten I/O, you will get additional acceleration with enhanced I/O multiplexing, where each dedicated network IO thread pipelines commands from multiple clients into the Redis OSS engine, taking advantage of Redis OSS' ability to efficiently process commands in batches. In ElastiCache for Redis OSS v7.1 and above, we extended the enhanced I/O threads functionality to also handle the presentation layer logic. By presentation layer, what we mean is that Enhanced I/O Threads nicht nur die Client-Eingaben, sondern analysieren die Eingabe auch in das Redis OSS-Binärbefehlsformat, das dann zur Ausführung an den Haupt-Thread weitergeleitet wird, was zu einer Leistungssteigerung führt. Weitere Informationen finden Sie im [Blogbeitrag](https://aws.amazon.com/blogs/database/achieve-over-500-million-requests-per-second-per-cluster-with-amazon-elasticache-for-redis-7-1/) und auf der Seite mit den [unterstützten Versionen](VersionManagement.md#supported-engine-versions).
+ Haben Sie Workloads, die regelmäßig auf einen kleinen Prozentsatz ihrer Daten zugreifen?
Wenn dies der Fall ist und Sie die Redis OSS-Engine Version 6.2 oder höher verwenden, können Sie das Data-Tiering nutzen, indem Sie den Knotentyp r6gd wählen. Bei Verwendung von Daten-Tiering werden zuletzt verwendete Daten auf dem SSD gespeichert. Beim Abruf entsteht eine geringe Latenzzeit, die jedoch durch Kosteneinsparungen ausgeglichen wird. Weitere Informationen finden Sie unter [Datenzuweisung ElastiCache](data-tiering.md).
Weitere Informationen finden Sie unter [Unterstützte Knotentypen](CacheNodes.SupportedTypes.md).
+ Wie viel Gesamtspeicher benötigen Sie für Ihre Daten?
Um eine allgemeine Schätzung zu erhalten, nehmen Sie die Größe der Objekte, die Sie zwischenspeichern möchten. Multiplizieren Sie diese Größe mit der Anzahl der Objekte, die Sie gleichzeitig im Cache halten wollen. Um eine vernünftige Schätzung der Elementgröße zu erhalten, serialisieren Sie zunächst Ihre Cache-Elemente und zählen dann die Zeichen. Teilen Sie diese Zahl dann durch die Anzahl der Shards in Ihrem Cluster.
Weitere Informationen finden Sie unter [Unterstützte Knotentypen](CacheNodes.SupportedTypes.md).
+ Welche Version von Redis OSS verwenden Sie?
Bei Redis OSS-Versionen vor 2.8.22 müssen Sie mehr Speicher für Failover, Snapshots, Synchronisation und das Heraufstufen eines Replikats auf den primären Betrieb reservieren. Diese Anforderung besteht, weil ausreichend Speicher für alle Schreibvorgänge während des Prozesses zur Verfügung stehen muss.
Redis OSS Version 2.8.22 und höher verwenden einen forkless-Speicherprozess, der weniger verfügbaren Speicher benötigt als der vorherige Prozess.
Weitere Informationen finden Sie hier:
+ [So werden Synchronisation und Backup implementiert](Replication.Redis.Versions.md)
+ [Stellen Sie sicher, dass Sie über genügend Arbeitsspeicher verfügen, um einen Valkey- oder Redis OSS-Snapshot zu erstellen](BestPractices.BGSAVE.md)
+ Wie hoch ist der Anteil der Schreibvorgänge Ihrer Anwendung?
Anwendungen mit vielen Schreibvorgängen können deutlich mehr verfügbaren Speicher, d. h. Speicher, der nicht von Daten belegt wird, beim Erstellen von Snapshots oder beim Failover erfordern. Wenn der `BGSAVE`-Prozess ausgeführt wird, müssen Sie über genügend Speicher verfügen, der nicht durch Daten belegt ist, um alle Schreibvorgänge, die während des `BGSAVE`-Prozesses stattfinden, unterzubringen. Beispiele sind die Erstellung eines Snapshots, die Synchronisierung eines primären Clusters mit einem Replikat in einem Cluster und die Aktivierung der Append-Only-Datei-Funktion (AOF). Ein weiteres ist das Heraufstufen eines Replikats zum primären Knoten (wenn Sie Multi-AZ aktiviert haben). Im schlimmsten Fall werden alle Ihre Daten während des Prozesses neu geschrieben. In diesem Fall benötigen Sie eine Knoten-Instance-Größe mit doppelt so viel Speicher wie für die Daten allein benötigt wird.
Detailliertere Informationen erhalten Sie unter [Stellen Sie sicher, dass Sie über genügend Arbeitsspeicher verfügen, um einen Valkey- oder Redis OSS-Snapshot zu erstellen](BestPractices.BGSAVE.md).
+ Handelt es sich bei Ihrer Implementierung um einen eigenständigen Valkey- oder Redis OSS-Cluster (Cluster-Modus deaktiviert) oder um einen Valkey- oder Redis OSS-Cluster (Cluster-Modus aktiviert) mit mehreren Shards?
**Valkey- oder Redis OSS-Cluster (Cluster-Modus deaktiviert)**
Wenn Sie einen Valkey- oder Redis OSS-Cluster (Cluster-Modus deaktiviert) implementieren, muss Ihr Knotentyp in der Lage sein, all Ihre Daten zuzüglich des erforderlichen Overheads aufzunehmen, wie im vorherigen Punkt bullet.
Nehmen Sie zum Beispiel an, dass die Gesamtgröße aller Ihrer Objekte 12 GB beträgt. In diesem Fall können Sie einen `cache.m3.xlarge`-Knoten mit 13,3 GB Speicher oder einen `cache.r3.large`-Knoten mit 13,5 GB Speicher verwenden. Sie benötigen jedoch möglicherweise mehr Speicher für `BGSAVE`-Operationen. Wenn Ihre Anwendung sehr schreibintensiv ist, sollten Sie den Speicherbedarf auf mindestens 24 GB verdoppeln. Verwenden Sie also entweder eine `cache.m3.2xlarge` mit 27,9 GB Speicher oder eine `cache.r3.xlarge` mit 30,5 GB Speicher.
**Valkey oder Redis OSS (Clustermodus aktiviert) mit mehreren Shards**
Wenn Sie einen Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) mit mehreren Shards implementieren, muss der Knotentyp Datenbytes aufnehmen können. `bytes-for-data-and-overhead / number-of-shards`
Angenommen, Sie schätzen die Gesamtgröße aller Ihrer Objekte auf 12 GB und Sie haben zwei Shards. In diesem Fall können Sie einen `cache.m3.large`-Knoten mit 6,05 GB Speicher (12 GB / 2) verwenden. Sie benötigen jedoch möglicherweise mehr Speicher für `BGSAVE`-Operationen. Wenn Ihre Anwendung schreibintensiv ist, verdoppeln Sie die Speicheranforderungen auf mindestens 12 GB pro Shard. Verwenden Sie also entweder eine `cache.m3.xlarge` mit 13,3 GB Speicher oder eine `cache.r3.large` mit 13,5 GB Speicher.
+ Verwenden Sie Local Zones?
[Local Zones](Local_zones.md) ermöglichen es Ihnen, Ressourcen wie einen ElastiCache Cluster an mehreren Standorten in der Nähe Ihrer Benutzer zu platzieren. Bei der Auswahl der Knotengröße sollten Sie jedoch beachten, dass die verfügbaren Knotengrößen unabhängig von den Kapazitätsanforderungen derzeit auf die folgenden beschränkt sind:
+ Aktuelle Generation:
**M5-Knotentypen:** `cache.m5.large`, `cache.m5.xlarge`, `cache.m5.2xlarge`, `cache.m5.4xlarge`, `cache.m5.12xlarge`, `cache.m5.24xlarge`
**R5-Knotentypen:** `cache.r5.large`, `cache.r5.xlarge`, `cache.r5.2xlarge`, `cache.r5.4xlarge`, `cache.r5.12xlarge`, `cache.r5.24xlarge`
**T3-Knotentypen:** `cache.t3.micro`, `cache.t3.small`, `cache.t3.medium`
Während Ihr Cluster läuft, können Sie die Messwerte für Speicherverbrauch, Prozessorauslastung, Cache-Treffer und Cache-Fehlschläge überwachen, die veröffentlicht werden CloudWatch. Sie werden vielleicht feststellen, dass Ihr Cluster nicht die gewünschte Trefferquote hat oder dass die Schlüssel zu oft entfernt werden. Sie können in diesen Fällen eine andere Knotengröße mit größeren CPU- und Speicherspezifikationen wählen.
Denken Sie bei der Überwachung der CPU-Auslastung daran, dass Valkey und Redis OSS Single-Threading verwenden. Multiplizieren Sie also die gemeldete CPU-Nutzung mit der Anzahl der CPU-Kerne, um die tatsächliche Nutzung zu erhalten. Beispielsweise ist eine Vierkern-CPU, die eine Nutzungsrate von 20 Prozent meldet, tatsächlich die Einkern-CPU von Redis, die mit einer Auslastung von 80 Prozent läuft.
## Knotengröße (Memcached)
Memcached-Cluster enthalten gegebenenfalls mehrere Knoten mit über die Knoten partitionierten Cluster-Daten. Aus diesem Grund sind die Speicheranforderungen des Clusters und die eines Knotens zwar ähnlich, jedoch nicht identisch. Sie können Ihre erforderliche Cluster-Speicherkapazität mit wenigen großen Knoten oder mit vielen kleineren Knoten abdecken. Mit wechselnden Anforderungen können Sie Knoten zum Cluster hinzufügen oder aus diesem entfernen und zahlen so nur für die Knoten, die Sie tatsächlich brauchen.
Die Gesamtspeicherkapazität des Clusters wird durch Multiplizieren der Anzahl von Knoten im Cluster mit der RAM-Kapazität der einzelnen Knoten (nach Abzug der für die Systemverwaltung erforderlichen Kapazität) berechnet. Die Kapazität jedes Knotens basiert auf dem Knotentyp.
```
cluster_capacity = number_of_nodes * (node_capacity - system_overhead)
```
Die Anzahl von Knoten im Cluster ist ein Schlüsselfaktor für die Verfügbarkeit Ihres Clusters, der Memcached ausführt. Der Ausfall eines einzelnen Knotens kann Auswirkungen auf die Verfügbarkeit Ihrer Anwendung und die Belastung Ihrer Backend-Datenbank haben. Stellt in einem solchen Fall einen Ersatz ElastiCache für einen ausgefallenen Knoten bereit und dieser wird erneut aufgefüllt. Um diese Auswirkungen auf die Verfügbarkeit zu verringern, sollten Sie die Speicher- und Rechenkapazität auf mehrere Knoten mit geringerer Kapazität verteilen, anstatt weniger Knoten mit hoher Kapazität zu verwenden.
In einem Szenario, in dem Sie 35 GB Cache-Speicher haben möchten, können Sie eine der folgenden Konfigurationen einrichten:
+ 11 `cache.t2.medium`-Knoten mit 3,22 GB Speicher und jeweils 2 Threads = 35,42 GB und 22 Threads.
+ 6 `cache.m4.large`-Knoten mit 6,42 GB Speicher und jeweils 2 Threads = 38,52 GB und 12 Threads.
+ 3 `cache.r4.large`-Knoten mit 12,3 GB Speicher und jeweils 2 Threads = 36,90 GB und 6 Threads.
+ 3 `cache.m4.xlarge`-Knoten mit 14,28 GB Speicher und jeweils 4 Threads = 42,84 GB und 12 Threads.
**Vergleichen der Knotenoptionen**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/CacheNodes.SelectSize.html)
Diese Optionen bieten jeweils ähnliche Speicherkapazität bei unterschiedlicher Rechenkapazität und Kosten. Um die Kosten Ihrer spezifischen Optionen zu vergleichen, sehen Sie sich die [ ElastiCache Amazon-Preise](https://aws.amazon.com/elasticache/pricing/) an.
Für Cluster, die Memcached ausführen, wird ein Teil des verfügbaren Speichers auf jedem Knoten für den Verbindungs-Overhead verwendet. Weitere Informationen finden Sie unter [Overhead von Memcached-Verbindungen](ParameterGroups.Engine.md#ParameterGroups.Memcached.Overhead).
Bei der Verwendung mehrerer Knotenpunkte müssen die Schlüssel auf diese verteilt werden. Jeder Knoten besitzt einen eigenen Endpunkt. Für eine einfache Endpunktverwaltung können Sie ElastiCache die Auto Discovery-Funktion verwenden, mit der Client-Programme automatisch alle Knoten in einem Cluster identifizieren können. Weitere Informationen finden Sie unter [Identifizieren Sie automatisch Knoten in Ihrem Cluster (Memcached)](AutoDiscovery.md).
In manchen Fällen sind Sie vielleicht unsicher, wie viel Kapazität Sie benötigen. Wenn das so ist, empfehlen wir, zu Testzwecken mit einem `cache.m5.large`-Knoten zu beginnen. Überwachen Sie dann die Speicherauslastung, die CPU-Auslastung und die Cache-Trefferquote anhand der auf Amazon veröffentlichten ElastiCache Metriken CloudWatch. Weitere Informationen zu CloudWatch Metriken für ElastiCache finden Sie unter[Überwachung der Nutzung mit CloudWatch Metrics](CacheMetrics.md). Für die Produktion und größere Workloads bieten R5-Knoten die beste Leistung und einen optimalen RAM-Einstandswert.
Wenn Ihr Cluster nicht die gewünschte Trefferquote aufweist, können Sie einfach weitere Knoten hinzufügen, um den gesamten verfügbaren Speicher in Ihrem Cluster zu erhöhen.
Wenn Ihr Cluster durch die CPU begrenzt ist, aber eine ausreichende Trefferquote aufweist, richten Sie einen neuen Cluster mit einem Knotentyp ein, der mehr Rechenleistung bietet.
# Einen Cluster für Valkey oder Redis OSS erstellen
Die folgenden Beispiele zeigen, wie ein Valkey- oder Redis-OSS-Cluster mithilfe der AWS-Managementkonsole API, und erstellt wird.AWS CLI ElastiCache
## Erstellen eines Valkey- oder Redis-OSS (Clustermodus deaktiviert) (Konsole)
ElastiCache unterstützt die Replikation, wenn Sie die Valkey- oder Redis OSS-Engine verwenden. Um die Latenz zwischen dem Schreiben von Daten in einen read/write primären Valkey- oder Redis OSS-Cluster und der Weitergabe an einen schreibgeschützten sekundären Cluster zu überwachen, ElastiCache fügt dem Cluster einen speziellen Schlüssel hinzu,. `ElastiCacheMasterReplicationTimestamp` Dieser Schlüssel ist die aktuelle Weltzeit (UTC). Da ein Valkey- oder Redis OSS-Cluster möglicherweise zu einem späteren Zeitpunkt zu einer Replikationsgruppe hinzugefügt wird, ist dieser Schlüssel in allen Valkey- oder Redis OSS-Clustern enthalten, auch wenn sie zunächst nicht Mitglieder einer Replikationsgruppe sind. Weitere Informationen zu Replikationsgruppen finden Sie unter [Hohe Verfügbarkeit mit Replikationsgruppen](Replication.md).
Gehen Sie wie unter beschrieben vor, um einen Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) zu erstellen. [Erstellen eines Valkey-Clusters (Cluster-Modus deaktiviert) (Konsole)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
Sobald der Status Ihres Clusters *verfügbar* ist, können Sie Amazon EC2 Zugriff darauf gewähren, eine Verbindung herstellen und ihn verwenden. Weitere Informationen erhalten Sie unter [Schritt 3. Autorisieren Sie den Zugriff auf den Cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) und [Schritt 4. Connect zum Knoten des Clusters her](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Wichtig**
Sobald Ihr Cluster verfügbar ist, wird Ihnen jede ganze oder angebrochene Stunde in Rechnung gestellt, die der Cluster aktiv ist, auch wenn Sie ihn nicht aktiv nutzen. Damit Ihnen keine Kosten mehr für diesen Cluster entstehen, müssen Sie ihn löschen. Siehe [Löschen eines Clusters in ElastiCache](Clusters.Delete.md).
## Erstellen eines Valkey- oder Redis OSS-Clusters (Cluster-Modus aktiviert) (Konsole)
Wenn Sie Redis OSS 3.2.4 oder höher ausführen, können Sie einen Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) erstellen. Valkey- oder Redis OSS-Cluster (Cluster-Modus aktiviert) unterstützen die Partitionierung Ihrer Daten auf 1 bis 500 Shards (API/CLI: Knotengruppen), jedoch mit einigen Einschränkungen. Einen Vergleich von Valkey oder Redis OSS (Clustermodus deaktiviert) und Valkey oder Redis OSS (Clustermodus aktiviert) finden Sie unter. [Unterstützte Engines und Versionen](VersionManagement.md#supported-engine-versions)
**So erstellen Sie mit der Konsole einen Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) 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 aus der Liste in der oberen rechten Ecke die AWS Region aus, in der Sie diesen Cluster starten möchten.
1. Wählen Sie im Navigationsbereich **Get started** (Erste Schritte) aus.
1. Wählen Sie **Create VPC** (VPC erstellen) aus und befolgen Sie die Schritte unter [Erstellen einer Virtual Private Cloud (VPC)](VPCs.CreatingVPC.md).
1. Wählen Sie auf der ElastiCache Dashboard-Seite **Create Cluster und dann Create** **Valkey cluster oder **Create Redis** OSS cluster** aus.
1. Führen Sie unter **Cluster settings** (Cluster-Einstellungen) die folgenden Schritte aus:
1. Wählen Sie **Configure and create a new cluster** (Neuen Cluster konfigurieren und erstellen) aus.
1. Wählen Sie für **Cluster mode** (Cluster-Modus) **Enabled** (Aktiviert) aus.
1. Geben Sie für **Cluster info** (Cluster-Info) einen Wert für **Name** (Name) ein.
1. (Optional) Geben Sie einen Wert für **Description** (Beschreibung) ein.
1. Unter **Location** (Speicherort):
------
#### [ AWS Cloud ]
1. Wir empfehlen für **AWS Cloud** die Voreinstellungen für **Multi-AZ** und **Auto-failover** (Automatisches Failover) zu akzeptieren. Weitere Informationen finden Sie unter [Minimierung von Ausfallzeiten in ElastiCache für Redis](AutoFailover.md) OSS mit Multi-AZ.
1. Unter **Cluster settings** (Cluster-Einstellungen):
1. Wählen Sie unter **Engine version** (Engine-Version) eine verfügbare Version aus.
1. Verwenden Sie für **Port** den Standardport 6379. Wenn es einen Grund gibt, einen anderen Port zu verwenden, geben Sie die betreffende Portnummer ein.
1. Wählen Sie für die **Parameter group (Parametergruppe)** eine Parametergruppe aus oder erstellen Sie eine neue Parametergruppe. Parametergruppen steuern die Laufzeitparameter Ihres Clusters. Weitere Informationen zu Parametergruppen finden Sie unter [Valkey- und Redis OSS-Parameter](ParameterGroups.Engine.md#ParameterGroups.Redis) und [Eine ElastiCache Parametergruppe erstellen](ParameterGroups.Creating.md).
**Anmerkung**
Wenn Sie eine Parametergruppe zum Festlegen der Engine-Konfigurationswerte auswählen, wird diese Parametergruppe auf alle Cluster im globalen Datenspeicher angewendet. Auf der Seite **Parameter Groups (Parametergruppen)** gibt das Ja/nein-Attribut **Global** an, ob eine Parteigruppe Teil eines globalen Datenspeichers ist.
1. Klicken Sie für **Node type (Knotentyp)** auf den Abwärtspfeil (![\[Downward-pointing triangle icon, typically used to indicate a dropdown menu.\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/ElastiCache-DnArrow.png)). Wählen Sie im Dialogfeld **Change node type (Knotentyp ändern)** einen Wert für **Instance family (Instance-Familie)** für den gewünschten Knotentyp aus. Wählen Sie dann den Knotentyp aus, den Sie für diesen Cluster verwenden möchten, und wählen Sie dann **Save (Speichern)**.
Weitere Informationen finden Sie unter [Auswahl der Knotengröße](CacheNodes.SelectSize.md).
Wenn Sie einen r6gd-Knotentyp wählen, wird Daten-Tiering automatisch aktiviert. Weitere Informationen finden Sie unter [Datenzuweisung ElastiCache](data-tiering.md).
1. Wählen Sie unter **Anzahl der Shards** die Anzahl der Shards (Partitionen/Knotengruppen) aus, die Sie für diesen Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) benötigen.
Bei einigen Versionen von Valkey oder Redis OSS (Clustermodus aktiviert) können Sie die Anzahl der Shards in Ihrem Cluster dynamisch ändern:
+ **Redis OSS 3.2.10 und höher** — Wenn auf Ihrem Cluster Redis OSS 3.2.10 oder spätere Versionen ausgeführt werden, können Sie die Anzahl der Shards in Ihrem Cluster dynamisch ändern. Weitere Informationen finden Sie unter [Skalierung von Valkey- oder Redis OSS-Clustern (Clustermodus aktiviert)](scaling-redis-cluster-mode-enabled.md).
+ **Andere Redis OSS-Versionen** — Wenn auf Ihrem Cluster eine Version von Redis OSS vor Version 3.2.10 ausgeführt wird, gibt es einen anderen Ansatz. Um die Anzahl der Shards in Ihrem Cluster in diesem Fall zu ändern, erstellen Sie einen neuen Cluster mit der neuen Anzahl von Shards. Weitere Informationen finden Sie unter [Wiederherstellen aus einem Backup in einen neuen Cache](backups-restoring.md).
1. Wählen Sie für **Replicas per shard (Replikate pro Shard)** die Anzahl der Read Replica-Knoten aus, die sich in jedem Shard befinden sollen.
Die folgenden Einschränkungen gelten für Valkey oder Redis OSS (Clustermodus aktiviert).
+ Wenn Sie Multi-AZ aktiviert haben, stellen Sie sicher, dass mindestens ein Replikat pro Shard vorhanden ist.
+ Die Anzahl der Replikate ist für jeden Shard gleich, wenn der Cluster mithilfe der Konsole erstellt wird.
+ Die Anzahl der Lesereplikate pro Shard ist ein fester Wert, der nicht geändert werden kann. Wenn Sie feststellen, dass Sie mehr oder weniger Replikate pro Shard (API/CLI: Knotengruppe) benötigen, müssen Sie einen neuen Cluster mit der neuen Anzahl von Replikaten erstellen. Weitere Informationen finden Sie unter [Tutorial: Seeding eines neuen knotenbasierten Clusters mit einem extern erstellten Backup](backups-seeding-redis.md).
1. Unter **Connectivity** (Konnektivität)
1. Wählen Sie als **Network type** (Netzwerktyp) die IP-Version(en) aus, die dieser Cluster unterstützen soll.
1. Wählen Sie für **Subnetzgruppen** das Subnetz aus, das Sie auf diesen Cluster anwenden möchten. ElastiCache verwendet diese Subnetzgruppe, um ein Subnetz und IP-Adressen innerhalb dieses Subnetzes auszuwählen, die Ihren Knoten zugeordnet werden sollen. ElastiCache Cluster benötigen ein Dual-Stack-Subnetz mit beiden IPv4 und ihnen zugewiesenen IPv6 Adressen, um im Dual-Stack-Modus betrieben werden zu können, und ein Subnetz nur für den Betrieb als IPv6 -only. IPv6
Geben Sie beim Erstellen einer neuen Subnetzgruppe die **VPC ID** (VPC-ID) ein, zu der sie gehört.
Wählen Sie einen **Discovery IP type** (Erkennungs-IP-Typ) aus. Es werden nur die IP-Adressen des von Ihnen ausgewählten Protokolls zurückgegeben.
Weitere Informationen finden Sie unter:
+ [Auswahl eines Netzwerktyps in ElastiCache](network-type.md).
+ [Erstellen eines Subnetzes in der VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet)
Wenn Sie [Verwenden von lokalen Zonen mit ElastiCache](Local_zones.md) sind, müssen Sie ein Subnetz erstellen oder auswählen, das in der lokalen Zone liegt.
Weitere Informationen finden Sie unter [Subnetze und Subnetzgruppen](SubnetGroups.md).
1. Für **Availability zone placements** (Availability-Zone-Platzierungen) haben Sie zwei Optionen:
+ **Keine Präferenz** — wählt die Availability Zone. ElastiCache
+ **Availability Zones** angeben – Sie geben die Availability Zone für jeden Cluster an.
Wenn Sie die Availability Zones angeben, wählen Sie für jeden Cluster in jedem Shard die Availability Zone aus der Liste aus.
Weitere Informationen finden Sie unter [Auswahl von Regionen und Verfügbarkeitszonen für ElastiCache](RegionsAndAZs.md).
1. Wählen Sie **Next** (Weiter).
1. Unter **Erweiterte Valkey-Einstellungen** oder **Erweiterte Redis OSS-Einstellungen** oder
1. Für **Security** (Sicherheit):
1. Zur Verschlüsselung Ihrer Daten haben Sie die folgenden Optionen:
+ **Verschlüsselung im Ruhezustand** – Ermöglicht die Verschlüsselung von Daten, die auf der Festplatte gespeichert sind. Weitere Informationen finden Sie unter [Verschlüsselung im Ruhezustand](at-rest-encryption.md).
**Anmerkung**
Sie haben die Möglichkeit, einen anderen Verschlüsselungsschlüssel anzugeben, indem Sie **Customer Managed AWS KMS Key** und dann den Schlüssel auswählen. Weitere Informationen finden Sie unter [Verwendung von kundenverwalteten Schlüsseln aus AWS-KMS](at-rest-encryption.md#using-customer-managed-keys-for-elasticache-security).
+ **Verschlüsselung während der Übertragung** – Ermöglicht die Verschlüsselung von Daten während der Übertragung. Weitere Informationen finden Sie unter [Verschlüsselung während der Übertragung](in-transit-encryption.md). Wenn Sie für Valkey 7.2 und höher oder Redis OSS 6.0 und höher die Verschlüsselung während der Übertragung aktivieren, werden Sie aufgefordert, eine der folgenden **Zugriffskontrolloptionen** anzugeben:
+ **Keine Zugriffskontrolle** – Dies ist die Standardeinstellung. Dies bedeutet, dass es keine Einschränkungen für den Benutzerzugang zum Cluster gibt.
+ **Zugriffskontrollliste für Benutzergruppen** – Wählen Sie eine Benutzergruppe mit einer bestimmten Anzahl von Benutzern aus, die auf den Cluster zugreifen können. Weitere Informationen finden Sie unter [Verwalten von Benutzergruppen mit der Konsole und dem CLI](Clusters.RBAC.md#User-Groups).
+ **AUTH Default User** — Ein Authentifizierungsmechanismus für einen Valkey- oder Redis OSS-Server. [Weitere Informationen finden Sie unter AUTH.](auth.md)
+ **AUTH** — Ein Authentifizierungsmechanismus für den Valkey- oder Redis-OSS-Server. [Weitere Informationen finden Sie unter AUTH.](auth.md)
**Anmerkung**
Für Redis OSS-Versionen zwischen 3.2.6 und höher, mit Ausnahme von Version 3.2.10, ist AUTH die einzige Option.
1. Wählen Sie für **Security groups (Sicherheitsgruppen)** die gewünschten Sicherheitsgruppen für diesen Cluster aus. Eine *security group (Sicherheitsgruppe)* fungiert als Firewall, um den Netzwerkzugriff auf Ihren Cluster zu steuern. Sie können die Standardsicherheitsgruppe für Ihre VPC verwenden oder eine neue erstellen.
Weitere Informationen zu Sicherheitsgruppen finden Sie unter [Sicherheitsgruppen für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) im *Benutzerhandbuch zu Amazon VPC.*
1. Wenn Sie regelmäßig geplante automatische Sicherungen möchten, aktivieren Sie **Enable automatic backups** und geben Sie ein, wie viele Tage lang jede automatische Sicherung beibehalten werden soll, bevor sie automatisch gelöscht wird. Wenn Sie keine regelmäßig geplanten automatischen Sicherungen möchten, deaktivieren Sie das Kontrollkästchen **Enable automatic backups**. In beiden Fällen haben Sie jederzeit die Option, manuelle Sicherungen zu erstellen.
Weitere Informationen zu Sicherung und Wiederherstellung finden Sie unter[Snapshot und Wiederherstellung](backups.md).
1. (Optional) Geben Sie ein Wartungsfenster an. Das *Maintenance window (Wartungsfenster)* ist der (in der Regel eine Stunde lange) allwöchentliche Zeitraum, für den ElastiCache die Systemwartung Ihres Clusters plant. Sie können es ElastiCache überlassen, einen Tag und eine Uhrzeit für das Wartungsfenster auszuwählen (*No preference (Keine Präferenz)*) oder Sie können den Tag, die Uhrzeit und die Dauer selbst wählen (*Specify maintenance window (Wartungsfenster angeben)*). Treffen Sie bei Wahl von *Specify maintenance window* eine Auswahl in den Listen *Start day*, *Start time* und *Duration* (in Stunden) für Ihr Wartungsfenster. Alle Zeiten sind UCT-Zeiten.
Weitere Informationen finden Sie unter [Verwaltung der ElastiCache Cluster-Wartung](maintenance-window.md).
1. (Optional) Für **Protokolle**:
+ Unter **Protokollformat** wählen Sie entweder**Text** oder **JSON** aus.
+ Wählen Sie unter **Zieltyp** entweder **CloudWatch Logs** oder **Kinesis Firehose** aus.
+ Wählen Sie unter **Protokollziel** entweder **Neu erstellen** aus und geben Sie entweder Ihren CloudWatch Logs-Log-Gruppennamen oder Ihren Firehose-Stream-Namen ein, oder wählen **Sie Bestehende auswählen** und wählen Sie dann entweder Ihren CloudWatch Logs-Log-Gruppennamen oder Ihren Firehose-Streamnamen aus.
1. Um Ihnen bei der Verwaltung Ihrer Cluster und anderer ElastiCache Ressourcen unter **Tags** zu helfen, können Sie jeder Ressource Ihre eigenen Metadaten in Form von Tags zuweisen. Weitere Information finden Sie unter [Verschlagworten Sie Ihre Ressourcen ElastiCache](Tagging-Resources.md).
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie alle Ihre Einträge und ausgewählten Optionen und machen Sie dann evtl. erforderliche Korrekturen. Sobald Sie bereit sind, klicken Sie auf **Create** (Erstellen).
------
#### [ On premises ]
1. Für **On premises** (On-Premises) empfehlen wir Ihnen, **Auto-failover** (Automatisches Failover) aktiviert zu lassen. Weitere Informationen finden Sie unter [Minimierung von Ausfallzeiten in ElastiCache für Redis OSS](AutoFailover.md) mit Multi-AZ
1. Befolgen Sie die Schritte unter [Verwenden von Outposts](ElastiCache-Outposts.md).
------
Um das Äquivalent mithilfe der ElastiCache API oder AWS CLI anstelle der ElastiCache Konsole zu erstellen, gehen Sie wie folgt vor:
+ API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI: [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
Sobald der Status Ihres Clusters *verfügbar* ist, können Sie EC2 Zugriff darauf gewähren, eine Verbindung herstellen und ihn verwenden. Weitere Informationen erhalten Sie unter [Schritt 3. Autorisieren Sie den Zugriff auf den Cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) und [Schritt 4. Connect zum Knoten des Clusters her](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Wichtig**
Sobald Ihr Cluster verfügbar ist, wird Ihnen jede ganze oder angebrochene Stunde in Rechnung gestellt, die der Cluster aktiv ist, auch wenn Sie ihn nicht aktiv nutzen. Damit Ihnen keine Kosten mehr für diesen Cluster entstehen, müssen Sie ihn löschen. Siehe [Löschen eines Clusters in ElastiCache](Clusters.Delete.md).
## Erstellen eines Clusters (AWS CLI)
Verwenden Sie den `create-cache-cluster` Befehl AWS CLI, um einen Cluster mit dem zu erstellen.
**Wichtig**
Sobald Ihr Cluster verfügbar ist, wird Ihnen jede ganze oder angebrochene Stunde in Rechnung gestellt, die der Cluster aktiv ist, auch wenn Sie ihn nicht aktiv nutzen. Damit Ihnen keine Kosten mehr für diesen Cluster entstehen, müssen Sie ihn löschen. Siehe [Löschen eines Clusters in ElastiCache](Clusters.Delete.md).
### Erstellen eines Valkey- oder Redis OSS-Clusters (Clustermodus deaktiviert) (CLI)
**Example — Ein Valkey- oder Redis OSS-Cluster (Cluster-Modus deaktiviert) ohne Read Replicas**
Der folgende CLI-Code erstellt einen Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) ohne Replikate.
Wenn Sie einen Cluster mit einem Knotentyp aus der R6gd-Familie erstellen, müssen Sie den Parameter `data-tiering-enabled` übergeben.
Für Linux, macOS oder Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine redis \
--num-cache-nodes 1 \
--cache-parameter-group default.redis6.x \
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
Für Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine redis ^
--num-cache-nodes 1 ^
--cache-parameter-group default.redis6.x ^
--snapshot-arns arn:aws:s3:::amzn-s3-demo-bucket/snapshot.rdb
```
### Erstellen eines Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert) ()AWS CLI
Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) (API/CLI: Replikationsgruppen) können mit diesem Vorgang nicht erstellt werden. `create-cache-cluster` Informationen zum Erstellen eines Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert) (API/CLI: Replikationsgruppe) finden Sie unter. [Eine Valkey- oder Redis OSS-Replikationsgruppe (Cluster Mode Enabled) von Grund auf neu erstellen ()AWS CLI](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.CLI)
Weitere Informationen finden Sie im Referenzthema.AWS CLI ElastiCache [https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
## Einen Cluster für Valkey oder Redis OSS (ElastiCache API) erstellen
Verwenden Sie die Aktion, um einen Cluster mithilfe der ElastiCache API zu erstellen. `CreateCacheCluster`
**Wichtig**
Sobald Ihr Cluster verfügbar ist, wird Ihnen jede ganze oder angebrochene Stunde in Rechnung gestellt, die der Cluster aktiv ist, auch wenn Sie ihn nicht aktiv nutzen. Damit Ihnen keine Kosten mehr für diesen Cluster entstehen, müssen Sie ihn löschen. Siehe [Löschen eines Clusters in ElastiCache](Clusters.Delete.md).
**Topics**
+ [Erstellen eines Valkey- oder Redis OSS-Clusters (Clustermodus deaktiviert) (ElastiCache API)](#Clusters.Create.API.Redis)
+ [Erstellen eines Clusters in Valkey oder Redis OSS (Clustermodus aktiviert) (API) ElastiCache](#Clusters.Create.API.RedisCluster)
### Erstellen eines Valkey- oder Redis OSS-Clusters (Clustermodus deaktiviert) (ElastiCache API)
Der folgende Code erstellt einen Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) (API). ElastiCache
Die Zeilenumbrüche dienen der besseren Lesbarkeit.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&CacheParameterGroup=default.redis3.2
&Engine=redis
&EngineVersion=3.2.4
&NumCacheNodes=1
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&SnapshotArns.member.1=arn%3Aaws%3As3%3A%3A%3AmyS3Bucket%2Fdump.rdb
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
### Erstellen eines Clusters in Valkey oder Redis OSS (Clustermodus aktiviert) (API) ElastiCache
Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) (API/CLI: Replikationsgruppen) können mit diesem Vorgang nicht erstellt werden. `CreateCacheCluster` Informationen zum Erstellen eines Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert) (API/CLI: Replikationsgruppe) finden Sie unter. [Eine Replikationsgruppe in Valkey oder Redis OSS (Cluster Mode Enabled) von Grund auf neu erstellen (ElastiCache API)](Replication.CreatingReplGroup.NoExistingCluster.Cluster.md#Replication.CreatingReplGroup.NoExistingCluster.Cluster.API)
Weitere Informationen finden Sie im API-Referenzthema. ElastiCache [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
# Einen Cluster für Memcached erstellen
Die folgenden Beispiele zeigen, wie ein Cluster mithilfe der API AWS-Managementkonsole,AWS CLI und ElastiCache erstellt wird.
## Erstellen eines Memcached-Clusters (Konsole)
Wenn Sie die Memcached-Engine verwenden, ElastiCache unterstützt Amazon die horizontale Partitionierung Ihrer Daten über mehrere Knoten. Da Memcached Auto Discovery ermöglicht, brauchen Sie die Endpunkte eines jeden Knotens nicht zu verfolgen. Memcached verfolgt den Endpunkt jedes Knotens und aktualisiert die Endpunktliste beim Hinzufügen oder Entfernen von Knoten. Ihre Anwendung braucht nur mit dem Cluster zu kommunizieren, der als Konfigurationsendpunkt fungiert.
Um einen Memcache-Cluster über die Konsole zu erstellen, folgen Sie den Schritten unter [Erstellen eines Valkey-Clusters (Cluster-Modus deaktiviert) (](Clusters.Create.md#Clusters.Create.CON.RedisCluster)Konsole). Wenn Sie Schritt fünf erreicht haben, wählen Sie **Create** Memcached Cache aus.
Sobald der Status Ihres Clusters *verfügbar* ist, können Sie Amazon EC2 Zugriff darauf gewähren, eine Verbindung herstellen und ihn verwenden. Weitere Informationen finden Sie in den ähnlichen Schritten [Schritt 3. Autorisieren Sie den Zugriff auf den Cluster](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.AuthorizeAccess.valkey) und[Schritt 4. Connect zum Knoten des Clusters her](SubnetGroups.designing-cluster-pre.valkey.md#GettingStarted.ConnectToCacheNode.valkey).
**Wichtig**
Sobald Ihr Cluster verfügbar ist, wird Ihnen jede ganze oder angebrochene Stunde in Rechnung gestellt, die der Cluster aktiv ist, auch wenn Sie ihn nicht aktiv nutzen. Damit Ihnen keine Kosten mehr für diesen Cluster entstehen, müssen Sie ihn löschen. Siehe [Löschen eines Clusters in ElastiCache](Clusters.Delete.md).
## Erstellen eines Clusters (AWS CLI)
Verwenden Sie den `create-cache-cluster` Befehl AWS CLI, um einen Cluster mit dem zu erstellen.
**Wichtig**
Sobald Ihr Cluster verfügbar ist, wird Ihnen jede ganze oder angebrochene Stunde in Rechnung gestellt, die der Cluster aktiv ist, auch wenn Sie ihn nicht aktiv nutzen. Damit Ihnen keine Kosten mehr für diesen Cluster entstehen, müssen Sie ihn löschen. Siehe [Löschen eines Clusters in ElastiCache](Clusters.Delete.md).
### Erstellen eines Memcached-Cache-Clusters (AWS CLI)
Der folgende CLI-Code erstellt einen Memcached-Cluster mit 3 Knoten.
Für Linux, macOS oder Unix:
```
aws elasticache create-cache-cluster \
--cache-cluster-id my-cluster \
--cache-node-type cache.r4.large \
--engine memcached \
--engine-version 1.4.24 \
--cache-parameter-group default.memcached1.4 \
--num-cache-nodes 3
```
Für Windows:
```
aws elasticache create-cache-cluster ^
--cache-cluster-id my-cluster ^
--cache-node-type cache.r4.large ^
--engine memcached ^
--engine-version 1.4.24 ^
--cache-parameter-group default.memcached1.4 ^
--num-cache-nodes 3
```
## Einen Cluster für Memcached (API) erstellen ElastiCache
Verwenden Sie die Aktion, um mithilfe der ElastiCache API einen Cluster zu erstellen. `CreateCacheCluster`
**Wichtig**
Sobald Ihr Cluster verfügbar ist, wird Ihnen jede ganze oder angebrochene Stunde in Rechnung gestellt, die der Cluster aktiv ist, auch wenn Sie ihn nicht aktiv nutzen. Damit Ihnen keine Kosten mehr für diesen Cluster entstehen, müssen Sie ihn löschen. Siehe [Löschen eines Clusters in ElastiCache](Clusters.Delete.md).
**Topics**
+ [Einen Memcached-Cluster (API) ElastiCache erstellen](#Clusters.Create.API.Memcached)
### Einen Memcached-Cluster (API) ElastiCache erstellen
Der folgende Code erstellt einen Memcache-Cluster mit 3 Knoten (API). ElastiCache
Die Zeilenumbrüche dienen der besseren Lesbarkeit.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=CreateCacheCluster
&CacheClusterId=my-cluster
&CacheNodeType=cache.r4.large
&Engine=memcached
&NumCacheNodes=3
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150508T220302Z
&Version=2015-02-02
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Credential=
&X-Amz-Date=20150508T220302Z
&X-Amz-Expires=20150508T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Signature=
```
# Details eines ElastiCache Clusters anzeigen
Sie können detaillierte Informationen zu einem oder mehreren Clustern mithilfe der ElastiCache Konsole oder der ElastiCache API anzeigen. AWS CLI
## Details eines Memcached-Clusters anzeigen (Konsole)
Sie können die Details eines Memcached-Clusters mithilfe der ElastiCache Konsole, des For-Clusters oder der AWS CLI API ElastiCache anzeigen. ElastiCache
Das folgende Verfahren beschreibt, wie Sie die Details eines Memcache-Clusters mithilfe der Konsole anzeigen. ElastiCache
**So zeigen Sie die Details eines Memcached-Clusters an**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Amazon-Konsole unter [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Wählen Sie aus der Liste in der oberen rechten Ecke die AWS Region aus, für die Sie sich interessieren.
1. **Wählen Sie im ElastiCache Engine-Dashboard Memcached aus.** Dadurch wird eine Liste all Ihrer Cluster angezeigt, die auf der Memcached-Engine ausgeführt werden.
1. Um Details eines Clusters anzuzeigen, aktivieren Sie das Kontrollkästchen links neben den Namen des Clusters.
1. Wenn Sie Knoteninformationen anzeigen möchten, wählen Sie die Registerkarte **Nodes** (Knoten) aus, auf der Informationen zum Status und zum Endpunkt der Knoten angezeigt werden.
1. Wenn Sie Metriken anzeigen möchten, wählen Sie die Registerkarte **Metrics** (Metriken) aus, auf der die relevanten Metriken für alle Knoten im Cluster angezeigt werden. Weitere Informationen finden Sie unter [Überwachung der Nutzung mit CloudWatch Metrics](CacheMetrics.md).
1. Wählen Sie die Registerkarte **Network and security** (Netzwerk und Sicherheit) aus, um Details zur Konfiguration von Netzwerkkonnektivität und Subnetzgruppen sowie zur VPC-Sicherheitsgruppe des Clusters anzuzeigen. Weitere Informationen finden Sie unter [Subnetze und Subnetzgruppen](SubnetGroups.md).
1. Wählen Sie die Registerkarte **Maintenance** (Wartung) aus, um Details zu den Wartungseinstellungen des Clusters anzuzeigen. Weitere Informationen finden Sie unter [Verwaltung der ElastiCache Cluster-Wartung](maintenance-window.md).
1. Wählen Sie die Registerkarte **Tags** aus, um Details zu allen Tags anzuzeigen, die auf Cluster-Ressourcen angewendet wurden. Weitere Informationen finden Sie unter [Verschlagworten Sie Ihre Ressourcen ElastiCache](Tagging-Resources.md).
## Details zu Valkey oder Redis OSS (Clustermodus deaktiviert) anzeigen (Konsole)
Sie können die Details eines Valkey- oder Redis OSS-Clusters (Clustermodus deaktiviert) mithilfe der ElastiCache Konsole, des For-Clusters oder der AWS CLI API ElastiCache anzeigen. ElastiCache
Das folgende Verfahren beschreibt, wie Sie die Details eines Valkey- oder Redis OSS-Clusters (Clustermodus deaktiviert) mithilfe der Konsole anzeigen. ElastiCache
**So zeigen Sie die Details eines Valkey- oder Redis OSS-Clusters (Clustermodus deaktiviert) an**
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 Engine-Dashboard entweder **Valkey** oder **Redis OSS** aus, um eine Liste all Ihrer Cluster anzuzeigen, die auf dieser Engine laufen.
1. Markieren Sie das Kontrollkästchen links neben dem Cluster-Namen, um die Details zum Cluster anzuzeigen. Stellen Sie sicher, dass Sie einen Cluster auswählen, auf dem die Valkey- oder Redis OSS-Engine ausgeführt wird, und nicht Clustered Valkey oder Clustered Redis OSS. Damit werden Details des Clusters angezeigt, einschließlich des primären Endpunkts des Clusters.
1. Anzeigen der Knoteninformationen:
1. Wählen Sie den Cluster-Namen aus.
1. Wählen Sie die Registerkarte **Shards and Nodes** (Shards und Knoten) aus. Es werden die Details zu jedem Knoten angezeigt, einschließlich des Knotenendpunkts, der zum Lesen vom Cluster benötigt wird.
1. Wenn Sie Metriken anzeigen möchten, wählen Sie die Registerkarte **Metrics** (Metriken) aus, auf der die relevanten Metriken für alle Knoten im Cluster angezeigt werden. Weitere Informationen finden Sie unter [Überwachung der Nutzung mit CloudWatch Metrics](CacheMetrics.md).
1. Wählen Sie zum Anzeigen von Protokollen die Registerkarte **Logs** (Protokolle) aus. Sie gibt an, ob der Cluster Slow-Protokolle oder Engine-Protokolle verwendet, und enthält relevante Details. Weitere Informationen finden Sie unter [Protokollzustellung](Log_Delivery.md).
1. Wählen Sie die Registerkarte **Network and security** (Netzwerk und Sicherheit) aus, um Details zur Konfiguration von Netzwerkkonnektivität des Clusters und zur Subnetzgruppe anzuzeigen. Weitere Informationen finden Sie unter [Subnetze und Subnetzgruppen](SubnetGroups.md).
1. Wählen Sie die Registerkarte **Maintenance** (Wartung) aus, um Details zu den Wartungseinstellungen des Clusters anzuzeigen. Weitere Informationen finden Sie unter [Verwaltung der ElastiCache Cluster-Wartung](maintenance-window.md).
1. Wählen Sie die Registerkarte **Service updates** (Service-Updates) aus, um Details zu allen verfügbaren Service-Updates sowie deren empfohlenes Mindesthaltbarkeitsdatum einzusehen. Weitere Informationen finden Sie unter [Service-Updates in ElastiCache](Self-Service-Updates.md).
1. Wählen Sie die Registerkarte **Tags** aus, um Details zu allen Tags anzuzeigen, die auf Cluster-Ressourcen angewendet wurden. Weitere Informationen finden Sie unter [Verschlagworten Sie Ihre Ressourcen ElastiCache](Tagging-Resources.md).
## Details für einen Valkey- oder Redis OSS-Cluster (Cluster Mode Enabled) anzeigen (Konsole)
Sie können die Details eines Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert) mithilfe der ElastiCache Konsole, des For-Clusters oder der AWS CLI API ElastiCache anzeigen. ElastiCache
Das folgende Verfahren beschreibt, wie Sie die Details eines Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert) mithilfe der Konsole anzeigen. ElastiCache
**So zeigen Sie die Details eines Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert) an**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Amazon-Konsole unter [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Wählen Sie aus der Liste in der oberen rechten Ecke die AWS Region aus, für die Sie sich interessieren.
1. Wählen Sie im ElastiCache Engine-Dashboard **Valkey** oder **Redis OSS** aus, um eine Liste all Ihrer Cluster anzuzeigen, die auf dieser Engine laufen.
1. Um Details zu einem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) anzuzeigen, wählen Sie das Feld links neben dem Namen des Clusters aus. Stellen Sie sicher, dass Sie einen Cluster auswählen, auf dem die Valkey- oder Clustered Redis OSS-Engine ausgeführt wird.
Der Bildschirm wird unterhalb des Clusters erweitert und zeigt Details zum Cluster an, darunter auch den Konfigurationsendpunkt des Clusters.
1. Wenn Sie eine Auflistung der Shards des Clusters und der Anzahl der Knoten in jedem Shard anzeigen möchten, wählen Sie die Registerkarte **Shards and nodes** (Shards und Knoten) aus.
1. So zeigen Sie spezifische Informationen zu einem Knoten an:
1. Wählen Sie die ID des Shards aus.
Damit werden Informationen zu jedem Knoten angezeigt, einschließlich des Endpunkts des Knotens, den Sie zum Lesen von Daten aus dem Cluster benötigen.
1. Wenn Sie Metriken anzeigen möchten, wählen Sie die Registerkarte **Metrics** (Metriken) aus, auf der die relevanten Metriken für alle Knoten im Cluster angezeigt werden. Weitere Informationen finden Sie unter [Überwachung der Nutzung mit CloudWatch Metrics](CacheMetrics.md).
1. Wählen Sie zum Anzeigen von Protokollen die Registerkarte **Logs** (Protokolle) aus. Sie gibt an, ob der Cluster Slow-Protokolle oder Engine-Protokolle verwendet, und enthält relevante Details. Weitere Informationen finden Sie unter [Protokollzustellung](Log_Delivery.md).
1. Wählen Sie die Registerkarte **Network and security** (Netzwerk und Sicherheit) aus, um Details zur Konfiguration von Netzwerkkonnektivität und Subnetzgruppen des Clusters, zur VPC-Sicherheitsgruppe sowie welche Verschlüsselungsmethode für den Cluster aktiviert ist, sofern zutreffend. Weitere Informationen erhalten Sie unter [Subnetze und Subnetzgruppen](SubnetGroups.md) und [Datensicherheit bei Amazon ElastiCache](encryption.md).
1. Wählen Sie die Registerkarte **Maintenance** (Wartung) aus, um Details zu den Wartungseinstellungen des Clusters anzuzeigen. Weitere Informationen finden Sie unter [Verwaltung der ElastiCache Cluster-Wartung](maintenance-window.md).
1. Wählen Sie die Registerkarte **Service updates** (Service-Updates) aus, um Details zu allen verfügbaren Service-Updates sowie deren empfohlenes Mindesthaltbarkeitsdatum einzusehen. Weitere Informationen finden Sie unter [Service-Updates in ElastiCache](Self-Service-Updates.md).
1. Wählen Sie die Registerkarte **Tags** aus, um Details zu allen Tags anzuzeigen, die auf Cluster-Ressourcen angewendet wurden. Weitere Informationen finden Sie unter [Verschlagworten Sie Ihre Ressourcen ElastiCache](Tagging-Resources.md).
## Details eines ElastiCache Clusters anzeigen ()AWS CLI
Der folgende Code listet die Details für auf*my-cluster*:
```
aws elasticache describe-cache-clusters --cache-cluster-id my-cluster
```
*my-cluster*Ersetzen Sie es durch den Namen Ihres Clusters, wenn der Cluster mit einem Cache-Knoten und 0 Shards mithilfe des `create-cache-cluster` Befehls erstellt wurde.
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"Engine": "redis",
"PreferredMaintenanceWindow": "wed:12:00-wed:13:00",
"CacheSubnetGroupName": "default",
"SnapshotWindow": "08:30-09:30",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"CacheClusterId": "my-cluster1",
"CacheClusterCreateTime": "2018-02-26T21:06:43.420Z",
"PreferredAvailabilityZone": "us-west-2c",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"AutoMinorVersionUpgrade": true,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": false,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:13:24.250Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": false,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": false,
"ReplicationGroupId": "my-cluster2",
"Engine": "redis",
"PreferredMaintenanceWindow": "sun:08:30-sun:09:30",
"CacheClusterId": "my-cluster2-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.10",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
```
```
{
"CacheClusters": [
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0001-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2b",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-001",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2c",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-002",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis3.2.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "3.2.6",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
},
{
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"AuthTokenEnabled": true,
"CacheSubnetGroupName": "default",
"SnapshotWindow": "12:30-13:30",
"AutoMinorVersionUpgrade": true,
"CacheClusterCreateTime": "2018-02-26T21:17:01.439Z",
"CacheClusterStatus": "available",
"AtRestEncryptionEnabled": true,
"PreferredAvailabilityZone": "us-west-2a",
"TransitEncryptionEnabled": true,
"ReplicationGroupId": "my-cluster3",
"Engine": "redis",
"PreferredMaintenanceWindow": "thu:11:00-thu:12:00",
"CacheClusterId": "my-cluster3-0002-003",
"PendingModifiedValues": {},
"CacheNodeType": "cache.r4.large",
"DataTiering": "disabled",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"ParameterApplyStatus": "in-sync",
"CacheParameterGroupName": "default.redis6.x.cluster.on"
},
"SnapshotRetentionLimit": 0,
"EngineVersion": "6.0",
"CacheSecurityGroups": [],
"NumCacheNodes": 1
}
]
}
```
Wenn der Cluster mit dem erstellt wird AWS-Managementkonsole (Clusterknoten aktiviert oder deaktiviert mit einem oder mehreren Shards), verwenden Sie den folgenden Befehl, um die Clusterdetails zu beschreiben (*my-cluster*ersetzen Sie ihn durch den Namen der Replikationsgruppe (Name Ihres Clusters)):
```
aws elasticache describe-replication-groups --replication-group-id my-cluster
```
Weitere Informationen finden Sie im ElastiCache Thema AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html)für.
## Details eines ElastiCache Clusters anzeigen (ElastiCache API)
Sie können die Details für einen Cluster mithilfe der ElastiCache `DescribeCacheClusters` API-Aktion anzeigen. Wenn der Parameter `CacheClusterId` eingeschlossen wird, werden Details für den angegebenen Cluster zurückgegeben. Wenn der Parameter `CacheClusterId` weggelassen wird, werden Details für bis zu `MaxRecords` (Standard 100) Cluster zurückgegeben. Der Wert für `MaxRecords` darf nicht kleiner als 20 oder größer als 100 sein.
Der folgende Code listet die Details für `my-cluster` auf.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=my-cluster
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Der folgende Code listet die Details für bis zu 25 Cluster auf.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&MaxRecords=25
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```
Weitere Informationen finden Sie im ElastiCache API-Referenzthema [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheClusters.html).
# Einen ElastiCache Cluster ändern
Neben dem Hinzufügen oder Entfernen von Knoten aus einem ElastiCache Cluster kann es vorkommen, dass Sie weitere Änderungen vornehmen müssen, z. B. das Hinzufügen einer Sicherheitsgruppe, das Ändern des Wartungsfensters oder einer Parametergruppe.
Es wird empfohlen, dass das Wartungsfenster in den Zeitraum mit der geringsten Nutzung fällt. Dies muss folglich zeitweise korrigiert werden.
Wenn Sie die Parameter eines Clusters ändern, wird die Änderung entweder sofort oder nach dem Neustart des Clusters angewendet. Dies gilt unabhängig davon, ob Sie die Parametergruppe des Clusters oder einen Parameterwert innerhalb der Parametergruppe des Clusters ändern. Informationen darüber, wann eine bestimmte Parameteränderung angewendet wird, finden Sie im Abschnitt „**Änderungen werden wirksam**“ in der Spalte „**Details**“ in den Tabellen für [Memcached-spezifische Parameter](ParameterGroups.Engine.md#ParameterGroups.Memcached)und [Valkey- und Redis OSS-Parameter](ParameterGroups.Engine.md#ParameterGroups.Redis). Weitere Informationen zum Neustarten eines Cluster-Knotens finden Sie unter [Knoten neu starten](nodes.rebooting.md).
## Unter Verwendung der ElastiCache AWS-Managementkonsole
**So modifizieren Sie einen Cluster:**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Konsole unter [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Wählen Sie aus der Liste in der oberen rechten Ecke die AWS Region aus, in der sich der Cluster befindet, den Sie ändern möchten.
1. Wählen Sie im Navigationsbereich die Engine, die auf dem Cluster ausgeführt wird, den Sie modifizieren möchten.
Es wird eine Liste der ausgewählten Engine-Cluster angezeigt.
1. Wählen Sie in der Liste der Cluster den Namen des Clusters aus, den Sie modifizieren möchten..
1. Wählen Sie **Aktionen** und dann **Ändern**.
Das Fenster **Modify Cluster** wird angezeigt.
1. Nehmen Sie im Fenster **Modify Cluster** die gewünschten Änderungen vor. Zu den Optionen gehören:
+ Beschreibung
+ Clustermodus – Wenn Sie den Clustermodus von **Deaktiviert** auf **Aktiviert** ändern möchten, müssen Sie den Clustermodus zuerst auf **Kompatibel** festlegen.
Im kompatiblen Modus können Ihre Valkey- oder Redis OSS-Clients sowohl im Clustermodus als auch im deaktivierten Clustermodus eine Verbindung herstellen. **Nachdem Sie alle Valkey- oder Redis OSS-Clients zur Verwendung des aktivierten Clustermodus migriert haben, können Sie die Konfiguration des Clustermodus abschließen und den Clustermodus auf Aktiviert setzen.**
+ Kompatibilität der Engine-Version
**Wichtig**
Sie können auf neuere Engine-Versionen aktualisieren. Falls Sie eine Hauptversion der Engine aktualisieren, z. B. von 5.0.6 auf 6.0, müssen Sie eine Parametergruppenfamilie auswählen, die mit der neuen Engine-Version kompatibel ist. Weitere Informationen zur Verfahrensweise finden Sie unter [Versionsverwaltung für ElastiCache](VersionManagement.md). Ein Downgrade auf ältere Engine-Versionen ist jedoch nur durch Löschen des vorhandenen Clusters und Erstellen eines neuen Clusters möglich.
+ VPC Security group(s) (VPC-Sicherheitsgruppe(n))
+ Parametergruppe
+ Node Type
**Anmerkung**
Wenn der Cluster einen Knotentyp aus der R6gd-Familie verwendet, können Sie nur eine andere Knotengröße aus dieser Familie auswählen. Wenn Sie einen Knotentyp aus der R6gd-Familie wählen, wird Daten-Tiering automatisch aktiviert. Weitere Informationen finden Sie unter [Daten-Tiering](data-tiering.md).
+ Multi-AZ
+ Automatisches Failover (nur im deaktivierten Cluster-Modus)
+ Aktivieren automatischer Sicherungen
+ ID des Backup-Knotens
+ Aufbewahrungszeitraum für Backups
+ Backup-Fenster
+ Thema für SNS-Benachrichtigung
+ Versionskompatibilität der Memcached Engine
+ Netzwerktyp
**Anmerkung**
Wenn Sie von IPv4 zu wechseln IPv6, müssen Sie Subnetzgruppen auswählen oder erstellen, die kompatibel sind mit. IPv6 Weitere Informationen finden Sie unter [Auswahl eines Netzwerktyps in ElastiCache](network-type.md).
+ VPC Security group(s) (VPC-Sicherheitsgruppe(n))
+ Parametergruppe
+ Wartungsfenster
+ Thema für SNS-Benachrichtigung
Das Feld **Sofort anwenden** gilt nur für Änderungen der Engine-Version und des Knotentyps. Um die Änderungen sofort zu übernehmen, aktivieren Sie das Kontrollkästchen **Apply Immediately (Sofort anwenden)**. Wenn dieses Kontrollkästchen nicht aktiviert ist, werden Änderungen an der Engine-Version während des nächsten Wartungsfensters übernommen. Andere Änderungen, wie z. B. Ändern des Wartungsfensters, werden umgehend übernommen.
**Um die Lieferung für Redis zu enable/disable protokollieren**
1. Suchen Sie in der Liste der Cluster den Cluster aus, den Sie ändern möchten. Wählen Sie den **Clusternamen** und nicht das Kontrollkästchen daneben.
1. Wählen Sie auf der Seite mit den **Cluster-Details** die Registerkarte **Logs** aus.
1. Um langsame Logs zu aktivieren oder zu deaktivieren, wählen Sie entweder **Aktivieren** oder **Deaktivieren**.
Wenn Sie „Aktivieren“ wählen:
1. Wählen Sie unter **Log format** (Protokollformat) entweder **JSON** oder **Text** aus.
1. Wählen **Sie unter Protokollzieltyp** entweder **CloudWatch Logs** oder **Kinesis Firehose** aus.
1. Unter **Protokollziel** können Sie **Create new** auswählen und entweder Ihren CloudWatchLogs Log-Gruppennamen oder Ihren Kinesis Data Firehose-Stream-Namen eingeben. Sie können auch **Select existing auswählen** und dann entweder Ihren CloudWatchLogs Loggruppennamen oder Ihren Kinesis Data Firehose Firehose-Streamnamen wählen.
1. Wählen Sie **Enable (Aktivieren)** aus.
**So ändern Sie Ihre Konfiguration für Redis:**
1. Wählen Sie **Ändern** aus.
1. Wählen Sie unter **Log format** (Protokollformat) entweder **JSON** oder **Text** aus.
1. Wählen Sie unter **Zieltyp** entweder **CloudWatch Logs** oder **Kinesis Firehose** aus.
1. Wählen Sie unter **Protokollziel** entweder **Neu erstellen** aus und geben Sie Ihren CloudWatchLogs Protokollgruppennamen oder Ihren Kinesis Data Firehose Firehose-Stream-Namen ein. Oder wählen Sie **Select existing** und wählen Sie dann Ihren CloudWatchLogs Log-Gruppennamen oder Ihren Kinesis Data Firehose Firehose-Stream-Namen.
## Verwenden Sie das mit AWS CLI ElastiCache
Sie können einen vorhandenen Cluster mithilfe der AWS CLI `modify-cache-cluster` Operation ändern. Um den Konfigurationswert eines Clusters zu ändern, geben Sie die ID des Clusters, den zu ändernden Parameter und den neuen Wert des Parameters ein. Das folgende Beispiel ändert das Wartungsfenster für einen Cluster namens `my-cluster` und übernimmt die Änderung umgehend.
**Wichtig**
Sie können ein Upgrade auf neuere Versionen der Memcached Engine durchführen. Weitere Informationen zur Verfahrensweise finden Sie unter [Versionsverwaltung für ElastiCache](VersionManagement.md). Ein Downgrade auf ältere Engine-Versionen ist jedoch nur durch Löschen des vorhandenen Clusters und Erstellen eines neuen Clusters möglich.
**Wichtig**
Sie können auf neuere Valkey- oder Redis OSS-Engine-Versionen aktualisieren. Wenn Sie wichtige Engine-Versionen aktualisieren, z. B. von Redis OSS 5.0.6 auf Redis OSS 6.0, müssen Sie eine Parametergruppenfamilie auswählen, die mit der neuen Engine-Version kompatibel ist. Weitere Informationen zur Verfahrensweise finden Sie unter [Versionsverwaltung für ElastiCache](VersionManagement.md). Ein Downgrade auf ältere Engine-Versionen ist jedoch nur durch Löschen des vorhandenen Clusters und Erstellen eines neuen Clusters möglich.
Für Linux, macOS oder Unix:
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
Für Windows:
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
Der Parameter `--apply-immediately` gilt nur für Änderungen am Knotentyp, an der Engine-Version und der Anzahl von Knoten in einem Cluster. Wenn Sie solche Änderungen umgehend übernehmen möchten, verwenden Sie den Parameter `--apply-immediately`. Wenn Sie solche Änderungen lieber bis zum nächsten Wartungsfenster aufschieben möchten, verwenden Sie den Parameter `--no-apply-immediately`. Andere Änderungen, wie z. B. Ändern des Wartungsfensters, werden umgehend übernommen.
Weitere Informationen finden Sie im Thema für. AWS CLI ElastiCache [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html)
## Verwenden der ElastiCache API
Sie können einen vorhandenen Cluster mithilfe der ElastiCache `ModifyCacheCluster` API-Operation ändern. Um den Konfigurationswert eines Clusters zu ändern, geben Sie die ID des Clusters, den zu ändernden Parameter und den neuen Wert des Parameters ein. Das folgende Beispiel ändert das Wartungsfenster für einen Cluster namens `my-cluster` und übernimmt die Änderung umgehend.
**Wichtig**
Sie können ein Upgrade auf neuere Versionen der Memcached Engine durchführen. Weitere Informationen zur Verfahrensweise finden Sie unter [Versionsverwaltung für ElastiCache](VersionManagement.md). Ein Downgrade auf ältere Engine-Versionen ist jedoch nur durch Löschen des vorhandenen Clusters und Erstellen eines neuen Clusters möglich.
**Wichtig**
Sie können auf neuere Valkey- oder Redis OSS-Engine-Versionen aktualisieren. Wenn Sie wichtige Engine-Versionen aktualisieren, z. B. von Redis OSS 5.0.6 auf Redis OSS 6.0, müssen Sie eine Parametergruppenfamilie auswählen, die mit der neuen Engine-Version kompatibel ist. Weitere Informationen zur Verfahrensweise finden Sie unter [Versionsverwaltung für ElastiCache](VersionManagement.md). Ein Downgrade auf ältere Engine-Versionen ist jedoch nur durch Löschen des vorhandenen Clusters und Erstellen eines neuen Clusters möglich.
Die Zeilenumbrüche dienen der besseren Lesbarkeit.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&PreferredMaintenanceWindow=sun:23:00-mon:02:00
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150901T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150901T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Der Parameter `ApplyImmediately` gilt nur für Änderungen am Knotentyp, an der Engine-Version und der Anzahl von Knoten in einem Cluster. Wenn Sie solche Änderungen umgehend übernehmen möchten, stellen Sie den Parameter `ApplyImmediately` auf `true` ein. Wenn Sie solche Änderungen lieber bis zum nächsten Wartungsfenster aufschieben möchten, stellen Sie den Parameter `ApplyImmediately` auf `false` ein. Andere Änderungen, wie z. B. Ändern des Wartungsfensters, werden umgehend übernommen.
Weitere Informationen finden Sie im ElastiCache API-Referenzthema. [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html)
# Hinzufügen von Knoten zu einem ElastiCache Cluster
Das Hinzufügen von Knoten zu einem Memcached-Cluster erhöht die Anzahl Ihrer Cluster-Partitionen. Wenn Sie die Anzahl der Partitionen in einem Cluster ändern, müssen einige Ihrer Schlüsselbereiche neu zugeordnet werden, damit sie auf den richtigen Knoten abgebildet werden. Die Neuzuordnung von Schlüsselräumen erhöht vorübergehend die Anzahl der Cache-Fehler auf dem Cluster. Weitere Informationen finden Sie unter [Konfiguration Ihres ElastiCache Clients für einen effizienten Lastenausgleich (Memcached)](BestPractices.LoadBalancing.md).
Informationen zur Neukonfiguration Ihres Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert) finden Sie unter [Skalierung von Valkey- oder Redis OSS-Clustern (Clustermodus aktiviert)](scaling-redis-cluster-mode-enabled.md)
Sie können die ElastiCache Management Console, die AWS CLI oder ElastiCache API verwenden, um Ihrem Cluster Knoten hinzuzufügen.
## Mit dem ElastiCache AWS-Managementkonsole
Wenn Sie einen Knoten zu einem Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) mit einem einzigen Knoten hinzufügen möchten (einem Cluster ohne aktivierte Replikation), müssen Sie zuerst die Replikation hinzufügen und dann einen Replikatknoten hinzufügen.
**Topics**
+ [Um die Replikation zu einem Valkey- oder Redis OSS-Cluster ohne Shards hinzuzufügen](#AddReplication.CON)
+ [Um Knoten zu einem ElastiCache Cluster (Konsole) hinzuzufügen](#AddNode.CON)
Mit dem folgenden Verfahren wird die Replikation zu einem Valkey- oder Redis-OSS mit einem Knoten hinzugefügt, für den die Replikation nicht aktiviert ist. Wenn Sie Replikation hinzufügen, wird der vorhandene Knoten zum primären Knoten im replikationsfähigen Cluster. Nachdem die Replikation hinzugefügt wurde, können Sie dem Cluster bis zu 5 Replikationsknoten hinzufügen.
**Um die Replikation zu einem Valkey- oder Redis OSS-Cluster ohne Shards hinzuzufügen**
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 **Valkey-Cluster** oder **Redis OSS-Cluster** aus.
Eine Liste der Cluster, auf denen diese Engine ausgeführt wird, wird angezeigt.
1. Wählen Sie den Namen eines Clusters, nicht das Kästchen links vom Namen des Clusters, dem Sie Knoten hinzufügen möchten.
Folgendes gilt für einen Redis OSS-Cluster, für den die Replikation nicht aktiviert ist:
+ Es läuft Redis OSS, nicht Clustered Redis OSS.
+ Er besitzt keine Shards.
Wenn der Cluster über Shards verfügt, ist die Replikation für ihn bereits aktiviert und Sie können mit [Um Knoten zu einem ElastiCache Cluster (Konsole) hinzuzufügen](#AddNode.CON) fortfahren.
1. Wählen Sie **Add replication**.
1. Geben Sie unter **Add Replication** eine Beschreibung für diesen replikationsfähigen Cluster ein.
1. Wählen Sie **Hinzufügen** aus.
Sobald der Status des Clusters wieder *available* lautet, können Sie mit dem nächsten Verfahren fortfahren und Replikate zum Cluster hinzufügen.
**Um Knoten zu einem ElastiCache Cluster (Konsole) hinzuzufügen**
Die folgende Vorgehensweise kann verwendet werden, um Knoten zu einem Cluster hinzuzufügen.
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 die Engine, die auf dem Cluster ausgeführt wird, dem Sie Knoten hinzufügen möchten.
Es wird eine Liste der Cluster der ausgewählten Engine angezeigt.
1. Wählen Sie in der Liste der Cluster den Namen des Clusters aus, dem Sie einen Knoten hinzufügen möchten..
Wenn es sich bei Ihrem Cluster um einen Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) handelt, finden Sie weitere Informationen unter. [Skalierung von Valkey- oder Redis OSS-Clustern (Clustermodus aktiviert)](scaling-redis-cluster-mode-enabled.md)
Wenn es sich bei Ihrem Cluster um einen Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) ohne Shards handelt, führen Sie zunächst die Schritte unter aus. [Um die Replikation zu einem Valkey- oder Redis OSS-Cluster ohne Shards hinzuzufügen](#AddReplication.CON)
1. Wählen Sie **Knoten hinzufügen** aus.
1. Geben Sie im Dialogfeld **Add Node (Knoten hinzufügen)** die erforderlichen Informationen ein.
1. Wählen Sie die Schaltfläche **Sofort übernehmen – Ja**, um diesen Knoten sofort hinzuzufügen, oder **Nein**, um das Hinzufügen dieses Knotens bis zum nächsten Wartungsfenster des Clusters aufzuschieben.
**Auswirkung von neuen Hinzufügungs- und Entfernungsanträgen auf ausstehende Anträge**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/Clusters.AddNode.html)
Um festzustellen, welche Vorgänge noch nicht abgeschlossen sind, wählen Sie die Registerkarte **Beschreibung** und prüfen Sie, wie viele ausstehende Erstellungen oder Löschungen angezeigt werden. Sie können nicht sowohl ausstehende Erstellungen als auch ausstehende Löschungen haben.
1. Wählen Sie die Schaltfläche **Add**.
Nach kurzer Zeit sollten die neuen Knoten mit dem Status **creating** in der Knotenliste erscheinen. Wenn dies nicht der Fall ist, aktualisieren Sie die Browserseite. Sobald sich der Status des Knotens in *verfügbar* ändert, kann der neue Knoten verwendet werden.
## Verwenden Sie den AWS CLI ElastiCache
Um einem Cluster mithilfe von Knoten hinzuzufügen AWS CLI, verwenden Sie den AWS CLI Vorgang `modify-cache-cluster` mit den folgenden Parametern:
+ `--cache-cluster-id` Die ID des Clusters, zu dem Sie Knoten hinzufügen möchten.
+ `--num-cache-nodes` Der Parameter `--num-cache-nodes` gibt die Anzahl der Knoten an, die sich nach der Übernahme der Änderung in diesem Cluster befinden sollen. Damit diesem Cluster Knoten hinzugefügt werden, muss `--num-cache-nodes` größer als die aktuelle Anzahl von Knoten in diesem Cluster sein. Wenn dieser Wert kleiner als die aktuelle Anzahl von Knoten ist, ElastiCache erwartet, dass der Parameter `cache-node-ids-to-remove` und eine Liste von Knoten aus dem Cluster entfernt werden. Weitere Informationen finden Sie unter [Verwenden AWS CLI Sie mit ElastiCache](Clusters.DeleteNode.md#Clusters.DeleteNode.CLI).
+ `--apply-immediately` oder `--no-apply-immediately` gibt an, ob diese Knoten umgehend bzw. während des nächsten Wartungsfensters hinzugefügt werden sollen.
Für Linux, macOS oder Unix:
```
aws elasticache modify-cache-cluster \
--cache-cluster-id my-cluster \
--num-cache-nodes 5 \
--apply-immediately
```
Für Windows:
```
aws elasticache modify-cache-cluster ^
--cache-cluster-id my-cluster ^
--num-cache-nodes 5 ^
--apply-immediately
```
Dieser Vorgang erzeugt eine Ausgabe ähnlich der folgenden (JSON-Format):
```
{
"CacheCluster": {
"Engine": "memcached",
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "my-cluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "rlh-mem000.7alc7bf-example.cfg.usw2.cache.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-21T16:28:28.973Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "modifying",
"NumCacheNodes": 2,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"SecurityGroups": [
{
"Status": "active",
"SecurityGroupId": "sg-dbe93fa2"
}
],
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {
"NumCacheNodes": 5
},
"PreferredMaintenanceWindow": "sat:09:00-sat:10:00",
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
}
}
```
Weitere Informationen finden Sie im AWS CLI Thema [https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-cache-cluster.html).
## Verwenden von AWS CLI with ElastiCache
Wenn Sie Knoten zu einem vorhandenen Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) hinzufügen möchten, für den die Replikation nicht aktiviert ist, müssen Sie zuerst die Replikationsgruppe erstellen und dabei den vorhandenen Cluster als primären Cluster angeben. Weitere Informationen finden Sie unter [Erstellen einer Replikationsgruppe mithilfe eines verfügbaren Valkey- oder Redis OSS-Clusters ()AWS CLI](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.CLI). Wenn die Replikationsgruppe *verfügbar* ist, können Sie mit dem folgenden Vorgang fortfahren.
Um einem Cluster mithilfe von Knoten hinzuzufügen AWS CLI, verwenden Sie den AWS CLI Vorgang `increase-replica-count` mit den folgenden Parametern:
+ `--replication-group-id` Die ID der Replikationsgruppe, aus der Sie Knoten entfernen möchten.
+ `--new-replica-count` gibt die Anzahl der Knoten an, die nach Anwendung der Änderung in dieser Replikationsgruppe enthalten sein sollen. Damit diesem Cluster Knoten hinzugefügt werden, muss `--new-replica-count` größer als die aktuelle Anzahl von Knoten in diesem Cluster sein.
+ `--apply-immediately` oder `--no-apply-immediately` gibt an, ob diese Knoten umgehend bzw. während des nächsten Wartungsfensters hinzugefügt werden sollen.
Für Linux, macOS oder Unix:
```
aws elasticache increase-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 4 \
--apply-immediately
```
Für Windows:
```
aws elasticache increase-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 4 ^
--apply-immediately
```
Dieser Vorgang erzeugt eine Ausgabe ähnlich der folgenden (JSON-Format):
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test",
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
Weitere Informationen finden Sie im AWS CLI Thema [https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/increase-replica-count.html).
## Verwenden der ElastiCache API
Wenn Sie Knoten zu einem vorhandenen Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) hinzufügen möchten, für den die Replikation nicht aktiviert ist, müssen Sie zuerst die Replikationsgruppe erstellen und den vorhandenen Cluster als primären Cluster angeben. Weitere Informationen finden Sie unter [Hinzufügen von Replikaten zu einem eigenständigen Valkey- oder Redis OSS-Cluster (Cluster Mode Disabled) (API) ElastiCache](Replication.CreatingReplGroup.ExistingCluster.md#Replication.CreatingReplGroup.ExistingCluster.API). Wenn die Replikationsgruppe *verfügbar* ist, können Sie mit dem folgenden Vorgang fortfahren.
**Um Knoten zu einem Cluster (ElastiCache API) hinzuzufügen**
+ Rufen Sie die API-Operation `IncreaseReplicaCount` mit folgenden Parametern auf:
+ `ReplicationGroupId` Die ID des Clusters, zu dem Sie Knoten hinzufügen möchten.
+ `NewReplicaCount` Der Parameter `NewReplicaCount` gibt die Anzahl der Knoten an, die sich nach der Übernahme der Änderung in diesem Cluster befinden sollen. Damit diesem Cluster Knoten hinzugefügt werden, muss `NewReplicaCount` größer als die aktuelle Anzahl von Knoten in diesem Cluster sein. Wenn dieser Wert kleiner ist als die aktuelle Anzahl der Knoten, verwenden Sie die `DecreaseReplicaCount`-API mit der Anzahl der Knoten, die aus dem Cluster entfernt werden sollen.
+ `ApplyImmediately` Gibt an, ob diese Knoten umgehend oder während des nächsten Wartungsfensters hinzugefügt werden sollen.
+ `Region`Gibt die AWS Region des Clusters an, zu der Sie Knoten hinzufügen möchten.
Das folgende Beispiel zeigt einen Aufruf zum Hinzufügen von Knoten zu einem Cluster.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=IncreaseReplicaCount
&ApplyImmediately=true
&NumCacheNodes=4
&ReplicationGroupId=my-replication-group
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Weitere Informationen finden Sie unter ElastiCache API-Thema [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_IncreaseReplicaCount.html).
## Die ElastiCache API verwenden
**Um Knoten zu einem Cluster hinzuzufügen (ElastiCache API)**
+ Rufen Sie die API-Operation `ModifyCacheCluster` mit folgenden Parametern auf:
+ `CacheClusterId` Die ID des Clusters, zu dem Sie Knoten hinzufügen möchten.
+ `NumCacheNodes` Der Parameter `NumCachNodes` gibt die Anzahl der Knoten an, die sich nach der Übernahme der Änderung in diesem Cluster befinden sollen. Damit diesem Cluster Knoten hinzugefügt werden, muss `NumCacheNodes` größer als die aktuelle Anzahl von Knoten in diesem Cluster sein. Wenn dieser Wert unter der aktuellen Anzahl von Knoten liegt, wird ElastiCache erwartet, dass der Parameter `CacheNodeIdsToRemove` mit einer Liste von Knoten aus dem Cluster entfernt wird (siehe[Verwenden der ElastiCache API mit Memcached](Clusters.DeleteNode.md#Clusters.DeleteNode.API)).
+ `ApplyImmediately` Gibt an, ob diese Knoten umgehend oder während des nächsten Wartungsfensters hinzugefügt werden sollen.
+ `Region`Gibt die AWS Region des Clusters an, zu der Sie Knoten hinzufügen möchten.
Das folgende Beispiel zeigt einen Aufruf zum Hinzufügen von Knoten zu einem Cluster.
**Example**
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&ApplyImmediately=true
&NumCacheNodes=5
&CacheClusterId=my-cluster
&Region=us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Weitere Informationen finden Sie unter ElastiCache API-Thema [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Knoten aus einem ElastiCache Cluster entfernen
Sie können einen Knoten aus einem Valkey-, Memcached- oder Redis-OSS-Cluster löschen, indem Sie die AWS-Managementkonsole, oder die API AWS CLI verwenden. ElastiCache
**Anmerkung**
Jedes Mal, wenn Sie die Anzahl der Knoten in einem Memcached-Cluster ändern, müssen Sie zumindest einen Teil Ihres Keyspace neu zuordnen, sodass er dem richtigen Knoten zugeordnet ist. Detaillierte Informationen zum Lastausgleich eines Memcached-Clusters finden Sie unter [Konfiguration Ihres ElastiCache Clients für einen effizienten Lastenausgleich (Memcached)](BestPractices.LoadBalancing.md).
## Mit dem ElastiCache AWS-Managementkonsole
**Entfernen von Knoten aus einem Cluster (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die ElastiCache Konsole unter [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Wählen Sie aus der Liste in der oberen rechten Ecke die AWS Region des Clusters aus, aus dem Sie Knoten entfernen möchten.
1. Wählen Sie im Navigationsbereich die Engine, die auf dem Cluster ausgeführt wird, von dem Sie einen Knoten entfernen möchten.
Es wird eine Liste der Cluster der ausgewählten Engine angezeigt.
1. Wählen Sie aus der Liste der Cluster den Namen des Clusters aus, aus dem Sie einen Knoten entfernen möchten.
Eine Liste der Knoten des Clusters wird angezeigt.
1. Aktivieren Sie das Kontrollkästchen links neben der Knoten-ID des Knotens, den Sie entfernen möchten. Sie können mithilfe der ElastiCache -Konsole nur jeweils einen Knoten auswählen. Wenn Sie mehrere Knoten auswählen, können Sie die Schaltfläche **Delete node (Knoten löschen)** daher nicht verwenden.
Die Seite *Delete Node (Knoten löschen)* wird angezeigt.
1. Um den Knoten zu löschen, machen Sie alle Angaben auf der Seite **Delete Node** und wählen Sie **Delete Node**. Um den Knoten beizubehalten, wählen Sie **Cancel (Abbrechen)**.
**Wichtig**
Wenn Sie mit Valkey oder Redis OSS die Knotenergebnisse im Cluster löschen, die nicht mehr Multi-AZ-konform sind, stellen Sie sicher, dass Sie zuerst das **Multi-AZ-Kontrollkästchen** deaktivieren und dann den Knoten löschen. Wenn Sie das Kontrollkästchen **Multi-AZ** deaktivieren, können Sie **Auto failover (Automatisches Failover)** aktivieren.
**Auswirkung von neuen Hinzufügungs- und Entfernungsanträgen auf ausstehende Anträge**
| Szenarien | Anstehende Operation | Neue Anfrage | Ergebnisse |
| --- | --- | --- | --- |
| Szenario 1 | Delete | Delete | Der neue Löschantrag, ob anstehend oder sofort, ersetzt den anstehenden Löschantrag.. Wenn z. B. die Knoten 0001, 0003 und 0007 zur Löschung anstehen und ein neuer Löschantrag für die Knoten 0002 und 0004 gestellt wird, werden nur die Knoten 0002 und 0004 gelöscht. Die Knoten 0001, 0003 und 0007 werden nicht gelöscht. |
| Szenario 2 | Delete | Create | Der neue Erstellungsauftrag, ob anstehend oder sofort, ersetzt den ausstehenden Löschauftrag. Wenn beispielsweise die Knoten 0001, 0003 und 0007 zur Löschung anstehen und ein neuer Antrag auf Erstellung eines Knotens gestellt wird, wird ein neuer Knoten erstellt und die Knoten 0001, 0003 und 0007 werden nicht gelöscht. |
| Szenario 3 | Create | Delete | Der neue Löschantrag, ob anstehend oder sofort, ersetzt den ausstehenden Erstellungsantrag. Sind beispielsweise zwei Knoten anzulegen und wird ein neuer Antrag auf Löschung des Knotens 0003 gestellt, werden keine neuen Knoten angelegt und der Knoten 0003 wird gelöscht. |
| Szenario 4 | Create | Create | Der neue Erstellungsauftrag wird dem ausstehenden Erstellungsauftrag hinzugefügt. Wenn z. B. eine ausstehende Anforderung zur Erstellung von zwei Knoten besteht und eine neue Anforderung zur Erstellung von drei Knoten ausgegeben wird, wird die neue Anforderung der ausstehenden Anforderung hinzugefügt und es werden fünf Knoten erstellt. Wenn der neue Erstellungsauftrag auf **Sofort anwenden – Ja** eingestellt ist, werden alle Erstellungsaufträge sofort ausgeführt. Wenn der neue Erstellungsauftrag auf **Sofort anwenden – Nein** eingestellt ist, sind alle Erstellungsaufträge in der Schwebe. |
Um festzustellen, welche Vorgänge noch nicht abgeschlossen sind, wählen Sie die Registerkarte **Beschreibung** und prüfen Sie, wie viele ausstehende Erstellungen oder Löschungen angezeigt werden. Sie können nicht sowohl ausstehende Erstellungen als auch ausstehende Löschungen haben.
## Verwenden AWS CLI Sie mit ElastiCache
1. Identifizieren Sie IDs den Knoten, den Sie entfernen möchten. Weitere Informationen finden Sie unter [Details eines ElastiCache Clusters anzeigen](Clusters.ViewDetails.md).
1. Listen Sie mit der CLI-Operation `decrease-replica-count` wie im folgenden Beispiel die zu entfernenden Knoten auf.
Um über die Befehlszeilenschnittstelle Knoten aus einem Cluster zu entfernen, verwenden Sie den Befehl `decrease-replica-count` mit den folgenden Parametern:
+ `--replication-group-id` Die ID der Replikationsgruppe, aus der Sie Knoten entfernen möchten.
+ `--new-replica-count` Der Parameter `--new-replica-count` gibt die Anzahl der Knoten an, die sich nach der Übernahme der Änderung in diesem Cluster befinden sollen.
+ `--replicas-to-remove`Eine Liste der Knoten IDs , die Sie aus diesem Cluster entfernen möchten.
+ `--apply-immediately` oder `--no-apply-immediately` gibt an, ob diese Knoten umgehend oder während des nächsten Wartungsfensters entfernt werden sollen.
+ `--region`Gibt die AWS Region des Clusters an, aus dem Sie Knoten entfernen möchten.
**Anmerkung**
Sie können nur einen von `--replicas-to-remove` oder `--new-replica-count` Parametern übergeben, wenn Sie diesen Vorgang aufrufen.
Für Linux, macOS oder Unix:
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--new-replica-count 2 \
--region us-east-2 \
--apply-immediately
```
Für Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--new-replica-count 3 ^
--region us-east-2 ^
--apply-immediately
```
Dieser Vorgang erzeugt eine Ausgabe ähnlich der folgenden (JSON-Format):
```
{
"ReplicationGroup": {
"ReplicationGroupId": "node-test",
"Description": "node-test"
},
"Status": "modifying",
"PendingModifiedValues": {},
"MemberClusters": [
"node-test-001",
"node-test-002",
"node-test-003",
"node-test-004",
"node-test-005",
"node-test-006"
],
"NodeGroups": [
{
"NodeGroupId": "0001",
"Status": "modifying",
"PrimaryEndpoint": {
"Address": "node-test.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"ReaderEndpoint": {
"Address": "node-test-ro.zzzzzz.ng.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"NodeGroupMembers": [
{
"CacheClusterId": "node-test-001",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-001.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2a",
"CurrentRole": "primary"
},
{
"CacheClusterId": "node-test-002",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-002.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-003",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-003.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-004",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-004.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2c",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-005",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-005.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
},
{
"CacheClusterId": "node-test-006",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Address": "node-test-006.zzzzzz.0001.usw2.cache.amazonaws.com",
"Port": 6379
},
"PreferredAvailabilityZone": "us-west-2b",
"CurrentRole": "replica"
}
]
}
],
"SnapshottingClusterId": "node-test-002",
"AutomaticFailover": "enabled",
"MultiAZ": "enabled",
"SnapshotRetentionLimit": 1,
"SnapshotWindow": "07:30-08:30",
"ClusterEnabled": false,
"CacheNodeType": "cache.r5.large",
"DataTiering": "disabled",
"TransitEncryptionEnabled": false,
"AtRestEncryptionEnabled": false,
"ARN": "arn:aws:elasticache:us-west-2:123456789012:replicationgroup:node-test"
}
}
```
Alternativ können Sie auch `decrease-replica-count` aufrufen und statt des Parameters `--new-replica-count` den Parameter `--replicas-to-remove` übergeben, wie im Folgenden gezeigt:
Für Linux, macOS oder Unix:
```
aws elasticache decrease-replica-count \
--replication-group-id my-replication-group \
--replicas-to-remove node-test-003 \
--region us-east-2 \
--apply-immediately
```
Für Windows:
```
aws elasticache decrease-replica-count ^
--replication-group-id my-replication-group ^
--replicas-to-remove node-test-003 ^
--region us-east-2 ^
--apply-immediately
```
Weitere Informationen finden Sie in den AWS CLI Themen [https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/decrease-replica-count.html).
## Verwenden der ElastiCache API mit Valkey oder Redis OSS
Um Knoten mithilfe der ElastiCache API zu entfernen, rufen Sie den `DecreaseReplicaCount` API-Vorgang mit der Replikationsgruppen-ID und einer Liste der zu entfernenden Knoten auf, wie hier gezeigt:
+ `ReplicationGroupId` Die ID der Replikationsgruppe, aus der Sie Knoten entfernen möchten.
+ `ReplicasToRemove` Der Parameter `ReplicasToRemove` gibt die Anzahl der Knoten an, die sich nach der Übernahme der Änderung in diesem Cluster befinden sollen.
+ `ApplyImmediately` gibt an, ob diese Knoten umgehend oder während des nächsten Wartungsfensters entfernt werden sollen.
+ `Region`Gibt die AWS Region des Clusters an, aus der Sie einen Knoten entfernen möchten.
Das folgende Beispiel entfernt umgehend Knoten 0004 und 0005 aus dem Cluster my-cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DecreaseReplicaCount
&ReplicationGroupId=my-replication-group
&ApplyImmediately=true
&ReplicasToRemove=node-test-003
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Weitere Informationen finden Sie unter ElastiCache API-Thema [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DecreaseReplicaCount.html).
## Verwenden der ElastiCache API mit Memcached
Um Knoten mithilfe der ElastiCache API zu entfernen, rufen Sie den `ModifyCacheCluster` API-Vorgang mit der Cache-Cluster-ID und einer Liste der zu entfernenden Knoten auf, wie hier gezeigt:
+ `CacheClusterId`Die ID des Clusters, aus dem Sie Knoten entfernen möchten.
+ `NumCacheNodes` Der Parameter `NumCacheNodes` gibt die Anzahl der Knoten an, die sich nach der Übernahme der Änderung in diesem Cluster befinden sollen.
+ `CacheNodeIdsToRemove.member.n`Die Liste der Knoten IDs , die aus dem Cluster entfernt werden sollen.
+ `CacheNodeIdsToRemove.member.1=0004`
+ `CacheNodeIdsToRemove.member.1=0005`
+ `ApplyImmediately` gibt an, ob diese Knoten umgehend oder während des nächsten Wartungsfensters entfernt werden sollen.
+ `Region`Gibt die AWS Region des Clusters an, aus dem Sie einen Knoten entfernen möchten.
Das folgende Beispiel entfernt umgehend Knoten 0004 und 0005 aus dem Cluster my-cluster.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=ModifyCacheCluster
&CacheClusterId=my-cluster
&ApplyImmediately=true
&CacheNodeIdsToRemove.member.1=0004
&CacheNodeIdsToRemove.member.2=0005
&NumCacheNodes=3
&Region us-east-2
&Version=2014-12-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20141201T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20141201T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20141201T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Weitere Informationen finden Sie unter ElastiCache API-Thema [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheCluster.html).
# Abbrechen ausstehender Operationen zum Hinzufügen oder Löschen von Knoten in ElastiCache
Wenn Sie sich dafür entschieden haben, eine ElastiCache Clusteränderung nicht sofort anzuwenden, hat der Vorgang den Status **Ausstehend**, bis er in Ihrem nächsten Wartungsfenster ausgeführt wird. Sie können jeden ausstehenden Vorgang zum Hinzufügen oder Löschen abbrechen.
Verwenden Sie den `modify-cache-cluster` Befehl, um einen ausstehenden Vorgang zum Hinzufügen oder Löschen von Knoten mit dem AWS CLI abzubrechen. Stellen Sie `num-cache-nodes` den Wert auf die aktuelle Anzahl von Cache-Knoten im Cluster ein und fügen Sie dann das `--apply-immediately` Flag hinzu. Dadurch wird die ausstehende Änderung außer Kraft gesetzt.
So stornieren Sie das Hinzufügen oder Löschen eines ausstehenden Knotens:
```
aws elasticache modify-cache-cluster
--cache-cluster-id
--num-cache-nodes
--apply-immediately
```
Wenn nicht klar ist, ob das Hinzufügen oder Löschen von Knoten aussteht, können Sie deren Status mit dem `describe-cache-clusters` folgenden Befehl überprüfen:
```
aws elasticache describe-cache-clusters
--cache-cluster-id
```
Alle ausstehenden Knoten sollten in der `PendingModifiedValues` Ausgabe erscheinen. Zum Beispiel:
```
"PendingModifiedValues": {
"NumCacheNodes": 3
},
```
# Löschen eines Clusters in ElastiCache
Solange sich ein ElastiCache Cluster im Status „*Verfügbar*“ befindet, wird er Ihnen in Rechnung gestellt, unabhängig davon, ob Sie ihn aktiv nutzen oder nicht. Löschen Sie den Cluster, damit keine Gebühren mehr anfallen.
**Warnung**
Wenn Sie einen ElastiCache Cluster löschen, werden Ihre manuellen Snapshots beibehalten. Sie können auch einen letzten Snapshot erstellen, bevor der Cluster gelöscht wird. Automatisch erstellte Cache-Snapshots werden nicht aufbewahrt.
## Mit dem AWS-Managementkonsole
Mit dem folgenden Verfahren wird ein einzelner Cluster aus Ihrer Bereitstellung gelöscht. Um mehrere Cache-Cluster zu löschen, wiederholen Sie das Verfahren für jeden Cluster, den Sie löschen möchten. Sie brauchen nicht zu warten, bis ein Cluster fertig gelöscht ist, bevor Sie den Vorgang zum Löschen eines anderen Clusters starten.
**So löschen Sie einen Cluster**
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 Engine-Dashboard die Engine aus, die in dem Cluster läuft, den Sie löschen möchten.
Eine Liste mit allen Clustern, in denen diese Engine läuft, wird angezeigt.
1. Wählen Sie aus der Liste den Namen des zu löschenden Clusters aus.
**Wichtig**
Sie können jeweils nur einen Cluster von der ElastiCache Konsole aus löschen. Werden mehrere Cluster ausgewählt, wird die Löschoperation deaktiviert.
1. Klicken Sie bei ** Actions** auf **Delete**.
1. Wählen Sie auf dem Bestätigungsbildschirm **Delete Cluster (Cluster löschen)** die Option **Delete (Löschen)**, um den Cluster zu löschen, oder **Cancel (Abbrechen)**, um den Cluster beizubehalten.
Wenn Sie **Delete** auswählen, ändert sich der Status des Clusters zu *deleting*.
Sobald dieser Cluster nicht mehr in der Cluster-Liste erscheint, fallen dafür keine Gebühren mehr an.
## Verwenden Sie den AWS CLI, um einen ElastiCache Cluster zu löschen
Der folgende Code löscht den ElastiCache Cluster`my-cluster`.
```
aws elasticache delete-cache-cluster --cache-cluster-id my-cluster
```
Die `delete-cache-cluster` CLI-Aktion löscht nur einen Cluster. Um mehrere Cluster zu löschen, rufen Sie `delete-cache-cluster` jeden Cache-Cluster auf, den Sie löschen möchten. Sie müssen nicht warten, bis ein Cluster vollständig gelöscht ist, bevor Sie einen anderen löschen.
Für Linux, macOS oder Unix:
```
aws elasticache delete-cache-cluster \
--cache-cluster-id my-cluster \
--region us-east-2
```
Für Windows:
```
aws elasticache delete-cache-cluster ^
--cache-cluster-id my-cluster ^
--region us-east-2
```
Weitere Informationen finden Sie im AWS CLI ElastiCache For-Thema [https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/elasticache/delete-cache-cluster.html).
## Verwenden der ElastiCache API
Der folgende Code löscht den Cluster `my-cluster`.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DeleteCacheCluster
&CacheClusterId=my-cluster
&Region us-east-2
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T220302Z
&X-Amz-Algorithm=&AWS;4-HMAC-SHA256
&X-Amz-Date=20150202T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20150202T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Der `DeleteCacheCluster` API-Vorgang löscht nur einen Cluster. Um mehrere Cluster zu löschen, rufen Sie `DeleteCacheCluster` für jeden Cluster auf, den Sie löschen möchten. Sie müssen nicht warten, bis ein Cluster vollständig gelöscht ist, bevor Sie einen anderen löschen.
Weitere Informationen finden Sie im ElastiCache API-Referenzthema [https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DeleteCacheCluster.html).
# Zugreifen auf Ihren ElastiCache Cluster oder Ihre Replikationsgruppe
Ihre ElastiCache Amazon-Instances sind für den Zugriff über eine EC2 Amazon-Instance konzipiert.
Wenn Sie Ihre ElastiCache Instance in einer Amazon Virtual Private Cloud (Amazon VPC) gestartet haben, können Sie von einer ElastiCache Amazon-Instance in derselben Amazon VPC aus auf Ihre EC2 Instance zugreifen. Oder Sie können mithilfe von VPC-Peering von einem Amazon EC2 in einer anderen Amazon-VPC auf Ihre ElastiCache Instance zugreifen.
Wenn Sie Ihre ElastiCache Instance in EC2 Classic gestartet haben, erlauben Sie der EC2 Instance den Zugriff auf Ihren Cluster, indem Sie der mit der Instance verknüpften EC2 Amazon-Sicherheitsgruppe Zugriff auf Ihre Cache-Sicherheitsgruppe gewähren. Standardmäßig ist der Zugriff auf einen Cluster auf das Konto beschränkt, mit dem der Cluster gestartet wurde.
**Topics**
+ [Zugriff auf Ihren Cluster oder die Replikationsgruppe erteilen](#grant-access)
## Zugriff auf Ihren Cluster oder die Replikationsgruppe erteilen
### Sie haben Ihren Cluster in VPC EC2 gestartet
Wenn Sie Ihren Cluster in einer Amazon Virtual Private Cloud (Amazon VPC) gestartet haben, können Sie nur von einer EC2 Amazon-Instance aus, die in derselben Amazon VPC läuft, eine Verbindung zu Ihrem ElastiCache Cluster herstellen. In diesem Fall müssen Sie Netzwerkzugang zum Cluster gewähren.
**Anmerkung**
Wenn Sie *Local Zones* verwenden, vergewissern Sie sich, dass Sie sie aktiviert haben. Weitere Informationen finden Sie unter [Local Zones aktivieren](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/using-regions-availability-zones.html#opt-in-local-zone). Dadurch wird Ihre VPC auf diese Local Zone ausgedehnt, und Ihre VPC behandelt das Subnetz wie jedes andere Subnetz in jeder anderen Availability Zone, und relevante Gateways, Routentabellen und andere Sicherheitsgruppen werden automatisch angepasst.
**So gewähren Sie einem Cluster den Netzwerkeingang aus einer Amazon-VPC-Sicherheitsgruppe**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die EC2 Amazon-Konsole unter [https://console.aws.amazon.com/ec2/](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. Wählen Sie die Registerkarte **Inbound** und verfahren Sie dann wie folgt:
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. Geben Sie in das Feld **Port Range** die Portnummer Ihres Clusterknotens ein. Diese Nummer muss mit der Nummer übereinstimmen, die Sie beim Starten des Clusters angegeben haben. Der Standardport für Memcached ist **11211** Der Standardport für Valkey und Redis OSS ist. **6379**
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 Ihren Knoten herstellen kann. ElastiCache
**Wichtig**
Durch das Öffnen des ElastiCache Clusters für 0.0.0.0/0 wird der Cluster nicht dem Internet zugänglich gemacht, da er keine öffentliche IP-Adresse hat und daher nicht von außerhalb der VPC darauf zugegriffen werden kann. Die Standardsicherheitsgruppe kann jedoch auf andere EC2 Amazon-Instances im Kundenkonto angewendet werden, und diese Instances können eine öffentliche IP-Adresse haben. Wenn diese Instances zufälligerweise eine Aktion auf dem Standardport ausführen, dann könnte dieser Service unbeabsichtigt zugänglich gemacht werden. Daher wird empfohlen, eine VPC-Sicherheitsgruppe einzurichten, die ausschließlich von ElastiCache genutzt wird. Weitere Informationen finden Sie unter [Benutzerdefinierte Sicherheitsgruppen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#creating-your-own-security-groups).
1. Wählen Sie **Speichern**.
Wenn Sie eine EC2 Amazon-Instance in Ihrer Amazon VPC starten, kann diese Instance eine Verbindung zu Ihrem ElastiCache Cluster herstellen.
### Zugriff auf ElastiCache Ressourcen von außen AWS
Amazon ElastiCache ist ein AWS Service, der einen cloudbasierten In-Memory-Key-Value-Speicher bereitstellt. Der Service ist so konzipiert, dass er ausschließlich von innen abgerufen werden kann.AWS Wenn der ElastiCache Cluster jedoch in einer VPC gehostet wird, können Sie eine Network Address Translation (NAT) -Instance verwenden, um externen Zugriff zu gewähren.
#### Voraussetzungen
Die folgenden Anforderungen müssen erfüllt sein, damit Sie von außerhalb AWS auf Ihre ElastiCache Ressourcen zugreifen können:
+ Der Cluster muss sich innerhalb einer VPC befinden und über eine Network Address Translation (NAT)-Instance zugänglich sein. Für diese Anforderung gibt es keine Ausnahmen.
+ Die NAT-Instance muss in der gleichen VPC gestartet werden wie der Cluster.
+ Die NAT-Instance muss in einem vom Cluster getrennten, öffentlichen Subnetz gestartet werden.
+ Eine Elastic IP-Adresse (EIP) muss der NAT-Instance zugeordnet sein. Die Portweiterleitungsfunktion von iptables wird verwendet, um einen Port auf der NAT-Instance an den Cache-Knotenport innerhalb der VPC weiterzuleiten.
#### Überlegungen
Beachten Sie beim Zugriff auf Ihre ElastiCache -Ressourcen von außerhalb von ElastiCache die folgenden Punkte.
+ Clients stellen eine Verbindung mit der EIP und dem Cache-Port der NAT-Instance her. Die Portweiterleitung auf der NAT-Instance leitet den Datenverkehr an den entsprechenden Clusterknoten weiter.
+ Wenn ein Cluster-Knoten hinzugefügt oder ersetzt wird, müssen die iptables-Regeln entsprechend aktualisiert werden.
#### Einschränkungen
Dieser Ansatz sollte nur zu Test- und Entwicklungszwecken verwendet werden. Er wird aufgrund der folgenden Einschränkungen nicht für die Produktion empfohlen:
+ Die NAT-Instance fungiert als Proxy zwischen Clients und mehreren Clustern. Das Hinzufügen eines Proxys wirkt sich auf die Leistung des Clusters aus. Die Auswirkung nimmt mit der Anzahl der Cluster zu, auf die Sie über die NAT-Instance zugreifen.
+ Der Datenverkehr von den Clients zur NAT-Instance ist nicht verschlüsselt. Daher sollten Sie keine sensiblen Daten über die NAT-Instance senden.
+ Die NAT-Instance bedeutet zusätzlichen Aufwand durch Verwalten einer weiteren Instance.
+ Die NAT-Instance dient als einzelne Fehlerquelle. Informationen zum Einrichten von NAT mit hoher Verfügbarkeit in VPC finden Sie unter [Hohe Verfügbarkeit für Amazon VPC NAT-Instances: Beispiel](https://aws.amazon.com/articles/2781451301784570).
#### Wie greife ich von außen auf ElastiCache Ressourcen zu AWS
Das folgende Verfahren zeigt, wie Sie mithilfe einer NAT-Instanz eine Verbindung zu Ihren ElastiCache Ressourcen herstellen.
Diese Schritte setzen Folgendes voraus:
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379`
+ `iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379`
Als Nächstes benötigen Sie NAT in die entgegengesetzte Richtung:
`iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 10.0.0.55`
Sie müssen auch die IP-Weiterleitung aktivieren, die standardmäßig deaktiviert ist:
`sudo sed -i 's/net.ipv4.ip_forward=0/net.ipv4.ip_forward=1/g' /etc/sysctl.conf sudo sysctl --system`
+ Ihr Zugriff auf einen Memcached-Cluster erfolgt mit:
+ IP-Adresse – *10.0.1.230*
+ Memcached-Standardport – *11211*
+ Sicherheitsgruppe – *\$110\$1.0\$1.0\$1.55\$1*
+ Sie greifen auf einen Valkey- oder Redis OSS-Cluster zu mit:
+ IP-Adresse – *10.0.1.230*
+ *Standardport — 6379*
+ Sicherheitsgruppe – *sg-bd56b7da*
+ AWS*IP-Adresse der Instanz — 198.99.100.27*
+ Die IP-Adresse Ihres vertrauenswürdigen Clients lautet *198.51.100.27*.
+ Ihre NAT-Instance hat die Elastic IP-Adresse *203.0.113.73*.
+ Die Sicherheitsgruppe Ihrer NAT-Instance lautet *sg-ce56b7a9*.
**So stellen Sie mithilfe einer NAT-Instanz eine Verbindung zu Ihren ElastiCache Ressourcen her**
1. Erstellen Sie eine NAT-Instanz in derselben VPC wie Ihr Cluster, jedoch in einem öffentlichen Subnetz.
Standardmäßig startet der VPC-Assistent einen *cache.m1.small*-Knotentyp. Wählen Sie eine Knotengröße aus, die Ihren Anforderungen entspricht. Sie müssen EC2 NAT AMI verwenden, um ElastiCache von außen darauf zugreifen zu können AWS.
Informationen zum Erstellen einer NAT-Instance finden Sie unter [NAT-Instances](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html) im AWS VPC-Benutzerhandbuch.
1. Erstellen Sie Sicherheitsgruppenregeln für den Cluster und die NAT-Instance.
Die Sicherheitsgruppe der NAT-Instance und die Cluster-Instance sollten folgende Regeln besitzen:
+ Zwei Regeln für eingehenden Datenverkehr
+ Bei Memcached besteht die erste Regel darin, TCP-Verbindungen von vertrauenswürdigen Clients zu jedem Cache-Port zuzulassen, der von der NAT-Instanz weitergeleitet wird (11211 — 11213).
+ Bei Valkey und Redis OSS besteht die erste Regel darin, TCP-Verbindungen von vertrauenswürdigen Clients zu jedem Cache-Port zuzulassen, der von der NAT-Instanz weitergeleitet wird (6379 — 6381).
+ Eine zweite Regel ermöglicht den SSH-Zugriff auf vertrauenswürdige Clients.
**Sicherheitsgruppe für NAT-Instanzen — Regeln für eingehenden Datenverkehr mit Memcached**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/accessing-elasticache.html)
**NAT-Instanz-Sicherheitsgruppe — Regeln für eingehenden Datenverkehr mit Valkey oder Redis OSS**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Bei Memcached handelt es sich um eine ausgehende Regel, die TCP-Verbindungen zum Cache-Port (11211) zulässt.
**Sicherheitsgruppe der NAT-Instance – Regeln für ausgehenden Datenverkehr**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Mit Valkey oder Redis OSS, einer ausgehenden Regel, die TCP-Verbindungen zum Cache-Port (6379) zulässt.
**Sicherheitsgruppe der NAT-Instance – Regeln für ausgehenden Datenverkehr**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Mit Memcached, einer Regel für eingehende Nachrichten für die Sicherheitsgruppe des Clusters, die TCP-Verbindungen von der NAT-Instance zum Cache-Port (11211) zulässt.
**Sicherheitsgruppe der Cluster-Instance – Regel für eingehenden Datenverkehr**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/accessing-elasticache.html)
+ Mit Valkey oder Redis OSS, einer eingehenden Regel für die Sicherheitsgruppe des Clusters, die TCP-Verbindungen von der NAT-Instance zum Cache-Port (6379) zulässt.
**Sicherheitsgruppe der Cluster-Instance – Regel für eingehenden Datenverkehr**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/accessing-elasticache.html)
1. Validieren Sie die Regeln.
+ Bestätigen Sie, dass der vertrauenswürdige Client eine SSH-Verbindung mit der NAT-Instance herstellen kann.
+ Bestätigen Sie, dass der vertrauenswürdige Client eine Verbindung mit dem Cluster über die NAT-Instance herstellen kann.
1. **Memcached**
Fügen Sie der NAT-Instance eine iptables-Regel hinzu.
Eine iptables-Regel muss der NAT-Tabelle für jeden Knoten im Cluster hinzugefügt werden, um den Cache-Port von der NAT-Instance an den Cluster-Knoten weiterzuleiten. Ein Beispiel könnte folgendermaßen aussehen:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
```
Die Portnummer muss für jeden Knoten im Cluster eindeutig sein. Wenn Sie z. B. mit einem aus drei Knoten bestehenden Memcached-Cluster unter Verwendung der Ports 11211 – 11213 arbeiten, sehen die Regeln wie folgt aus:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11211 -j DNAT --to 10.0.1.230:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11212 -j DNAT --to 10.0.1.231:11211
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 11213 -j DNAT --to 10.0.1.232:11211
```
Bestätigen Sie, dass der vertrauenswürdige Client eine Verbindung mit dem Cluster herstellen kann.
Der vertrauenswürdige Client sollte eine Verbindung mit dem EIP herstellen, der der NAT-Instance zugewiesen ist, und dem Cluster-Port, der dem entsprechenden Cluster-Knoten entspricht. Die Verbindungszeichenfolge für PHP sieht beispielsweise wie folgt aus:
```
$memcached->connect( '203.0.113.73', 11211 );
$memcached->connect( '203.0.113.73', 11212 );
$memcached->connect( '203.0.113.73', 11213 );
```
Zum Überprüfen der Verbindung kann auch ein Telnet-Client verwendet werden. Beispiel:
```
telnet 203.0.113.73 11211
telnet 203.0.113.73 11212
telnet 203.0.113.73 11213
```
**Valkey oder Redis OSS**
Fügen Sie der NAT-Instance eine iptables-Regel hinzu.
Eine iptables-Regel muss der NAT-Tabelle für jeden Knoten im Cluster hinzugefügt werden, um den Cache-Port von der NAT-Instance an den Cluster-Knoten weiterzuleiten. Ein Beispiel könnte folgendermaßen aussehen:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
```
Die Portnummer muss für jeden Knoten im Cluster eindeutig sein. Wenn Sie beispielsweise mit einem Redis-OSS-Cluster mit drei Knoten arbeiten und die Ports 6379 — 6381 verwenden, würden die Regeln wie folgt aussehen:
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6379 -j DNAT --to 10.0.1.230:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6380 -j DNAT --to 10.0.1.231:6379
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 6381 -j DNAT --to 10.0.1.232:6379
```
Bestätigen Sie, dass der vertrauenswürdige Client eine Verbindung mit dem Cluster herstellen kann.
Der vertrauenswürdige Client sollte eine Verbindung mit dem EIP herstellen, der der NAT-Instance zugewiesen ist, und dem Cluster-Port, der dem entsprechenden Cluster-Knoten entspricht. Die Verbindungszeichenfolge für PHP sieht beispielsweise wie folgt aus:
```
redis->connect( '203.0.113.73', 6379 );
redis->connect( '203.0.113.73', 6380 );
redis->connect( '203.0.113.73', 6381 );
```
Zum Überprüfen der Verbindung kann auch ein Telnet-Client verwendet werden. Beispiel:
```
telnet 203.0.113.73 6379
telnet 203.0.113.73 6380
telnet 203.0.113.73 6381
```
1. Speichern Sie die iptables-Konfiguration.
Speichern Sie die Regeln, nachdem Sie sie getestet und überprüft haben. Wenn Sie eine Redhat-Linux-Verteilung (wie Amazon Linux) verwenden, führen Sie den folgenden Befehl aus:
```
service iptables save
```
#### Verwandte Themen
Die folgenden Themen können von zusätzlichem Interesse sein.
+ [Zugriffsmuster für den Zugriff auf einen ElastiCache Cache in einer Amazon VPC](elasticache-vpc-accessing.md)
+ [Zugriff auf einen ElastiCache Cache von einer Anwendung aus, die im Rechenzentrum eines Kunden ausgeführt wird](elasticache-vpc-accessing.md#elasticache-vpc-accessing-data-center)
+ [NAT-Instances](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html)
+ [Konfiguration von Clients ElastiCache ](ClientConfig.md)
+ [Hohe Verfügbarkeit für Amazon VPC NAT-Instances: Beispiel](https://aws.amazon.com/articles/2781451301784570)
# Verbindungsendpunkte finden in ElastiCache
Ihre Anwendung stellt über Endpunkte eine Verbindung zu Ihrem ElastiCache Cluster her. Ein Endpunkt ist die eindeutige Adresse eines Knotens oder Clusters.
Sie können auch eine private Verbindung zwischen Ihrer VPC und Ihren ElastiCache API-Endpunkten herstellen, indem Sie einen VPC-Schnittstellen-Endpunkt erstellen. AWS PrivateLink Weitere Informationen finden Sie unter [ElastiCache API- und Schnittstellen-VPC-Endpunkte ()AWS PrivateLink](elasticache-privatelink.md).
**Welche Endpunkte sollen mit Valkey oder Redis OSS verwendet werden?**
+ Verwenden Sie bei einem **eigenständigen Knoten** den Endpunkt des Knotens sowohl für Lese- als auch für Schreibvorgänge.
+ Verwenden Sie für **Valkey- oder Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert)** den *primären Endpunkt* für alle Schreibvorgänge. Verwenden Sie *Leser-Endpunkt*, um am Endpunkt ankommende Verbindungen auf alle Lesereplikate zu verteilen. Verwenden Sie die einzelnen *Knotenendpunkte* für Lesevorgänge (in der API/CLI werden diese als Leseendpunkte bezeichnet).
+ Verwenden Sie für **Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert)** den *Konfigurationsendpunkt* des Clusters für alle Operationen, die Befehle mit aktiviertem Clustermodus unterstützen. Sie müssen einen Client verwenden, der entweder Valkey Cluster oder Redis OSS Cluster auf Redis OSS 3.2 und höher unterstützt. Sie können weiterhin von einzelnen Knotenendpunkten lesen (im Folgenden werden API/CLI diese als Lese-Endpunkte bezeichnet).
Die folgenden Abschnitte führen Sie durch die Erkennung der Endpunkte, die Sie für die von Ihnen ausgeführte Engine benötigen.
**Welche Endpunkte sollen mit Memcached verwendet werden?**
Für **ElastiCache serverlosen Cache für Memcached** rufen Sie einfach den DNS und den Port des Cluster-Endpunkts von der Konsole ab.
Verwenden Sie von der aus den `describe-serverless-caches` Befehl AWS CLI, um die Endpunktinformationen abzurufen.
Linux
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Windows
```
aws elasticache describe-serverless-caches --serverless-cache-name CacheName
```
Die Ausgabe der obigen Operation sollte etwa wie nachfolgend dargestellt aussehen (JSON-Format):
```
{
"ServerlessCaches": [
{
"ServerlessCacheName": "serverless-memcached",
"Description": "test",
"CreateTime": 1697659642.136,
"Status": "available",
"Engine": "memcached",
"MajorEngineVersion": "1.6",
"FullEngineVersion": "21",
"SecurityGroupIds": [
"sg-083eda453e1e51310"
],
"Endpoint": {
"Address": "serverless-memcached-01.amazonaws.com",
"Port":11211
},
"ARN": "",
"SubnetIds": [
"subnet-0cf759df15bd4dc65",
"subnet-09e1307e8f1560d17"
],
"SnapshotRetentionLimit": 0,
"DailySnapshotTime": "03:00"
}
]
}
```
Wenn Sie bei einem **instanzbasierten Memcached-Cluster** Automatic Discovery verwenden, können Sie den *Konfigurationsendpunkt* des Clusters verwenden, um Ihren Memcached-Client zu konfigurieren. Dies bedeutet, dass Sie einen Client verwenden müssen, der Automatic Discovery unterstützt.
Wenn Sie Automatic Discovery nicht verwenden, müssen Sie den Client so konfigurieren, dass er die einzelnen Knotenendpunkte für Lese- und Schreibvorgänge verwendet. Auch müssen Sie sie beim Hinzufügen und Entfernen von Knoten verfolgen.
## Finden Sie die Endpunkte eines Valkey- oder Redis OSS-Clusters (Cluster-Modus deaktiviert) (Konsole)
Wenn ein Valkey-, Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) nur einen Knoten hat, wird der Endpunkt des Knotens sowohl für Lese- als auch für Schreibvorgänge verwendet. **Wenn ein Valkey- oder Valkey- oder Redis OSS-Cluster (Cluster-Modus deaktiviert) mehrere Knoten hat, gibt es drei Arten von Endpunkten: den *primären Endpunkt, den Reader-Endpunkt* und die Knotenendpunkte.**
Der primäre Endpunkt ist ein DNS-Name, der immer auf den primären Knoten im Cluster aufgelöst wird. Der primäre Endpunkt ist Änderungen an Ihrem Cluster, wie Heraufstufen einer Read Replica in die Rolle des primären Knotens, gegenüber immun. Für Schreibvorgänge empfehlen wir, dass Anwendungen sich ausschließlich mit dem primären Endpunkt verbinden.
Ein Reader-Endpunkt verteilt eingehende Verbindungen zum Endpunkt gleichmäßig auf alle Read Replicas in einem für Redis OSS bestimmten Cluster. ElastiCache Zusätzliche Faktoren, z. B. wenn die Anwendung die Verbindungen erstellt oder wie die Anwendung die Verbindungen (erneut) verwendet, bestimmen die Verteilung des Datenverkehrs. Reader-Endpunkte bleiben hinsichtlich der Cluster-Änderungen beim Hinzufügen oder Entfernen von Replicas in Echtzeit auf dem aktuellen Stand. Sie können die mehreren Read Replicas Ihres ElastiCache Redis OSS-Clusters in verschiedenen AWS Availability Zones (AZ) platzieren, um eine hohe Verfügbarkeit der Leser-Endpunkte sicherzustellen.
**Anmerkung**
Ein Leser-Endpunkt ist kein Load Balancer. Es handelt sich um einen DNS-Eintrag, der nach dem Rotationsprinzip zu einer IP-Adresse eines der Replikationsknoten aufgelöst wird.
Für Lesevorgänge können Anwendungen Verbindungen zu jedem Knoten im Cluster herstellen. Im Gegensatz zum primären Endpunkt werden Knotenendpunkte auf bestimmte Endpunkte aufgelöst. Wenn Sie eine Änderung am Cluster vornehmen, wie z. B. Hinzufügen oder Löschen eines Replikats, müssen Sie die Knotenendpunkte in Ihrer Anwendung aktualisieren.
**So finden Sie die Endpunkte eines Valkey-, Valkey- oder Redis OSS-Clusters (Clustermodus deaktiviert)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Konsole unter. ElastiCache [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)
1. Wählen Sie im Navigationsbereich **Valkey-Cluster** oder **Redis OSS-Cluster** aus.
Der Cluster-Bildschirm wird mit einer Liste von Valkey- oder Valkey- oder Redis OSS-Clustern (Clustermodus deaktiviert) und Valkey- oder Redis OSS-Clustern (Clustermodus aktiviert) angezeigt.
1. Um die Primary and/or Reader-Endpunkte des Clusters zu finden, wählen Sie den Namen des Clusters (nicht die Schaltfläche links neben dem Cluster).
![\[Bild: Primärer Endpunkt für einen Valkey-, Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert)\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/Reader-Endpoint.png)
*Primäre Endpunkte und Reader-Endpunkte für einen Valkey-, Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert)*
Wenn sich im Cluster nur ein Knoten befindet, ist kein primärer Endpunkt vorhanden. Sie können mit dem nächsten Schritt fortfahren.
1. **Wenn der Valkey-, Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) über Replikatknoten verfügt, können Sie die Replikatknotenendpunkte des Clusters finden, indem Sie den Namen des Clusters und dann die Registerkarte Knoten auswählen.**
Auf dem angezeigten Knotenbildschirm wird jeder Knoten im Cluster, –primärer Knoten und Replikate, – mit seinem Endpunkt aufgelistet.
![\[Bild: Knotenendpunkte für einen Valkey-, Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert)\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/ElastiCache-Endpoints-Redis-Node.png)
*Knotenendpunkte für einen Valkey-, Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert)*
1. So kopieren Sie einen Endpunkt in Ihre Zwischenablage:
1. Suchen Sie einen Endpunkt nach dem anderen nach dem zu kopierenden Endpunkt.
1. Wählen Sie das Kopiersymbol direkt vor dem Endpunkt aus.
Der Endpunkt wird nun in Ihre Zwischenablage kopiert. Informationen zur Verwendung des Endpunkts zur Verbindung mit einem Knoten finden Sie unter [Verbindung zu Memcached-Knoten herstellen](nodes-connecting.md#nodes-connecting.mem).
Ein primärer Endpunkt von Valkey, Valkey oder Redis OSS (Clustermodus deaktiviert) sieht etwa wie folgt aus. Abhängig davon, ob die Verschlüsselung während der Übertragung aktiviert ist oder nicht, unterscheidet sich dies.
**Verschlüsselung während der Übertragung nicht aktiviert**
```
clusterName.xxxxxx.nodeId.regionAndAz.cache.amazonaws.com:port
redis-01.7abc2d.0001.usw2.cache.amazonaws.com:6379
```
**Verschlüsselung während der Übertragung aktiviert**
```
master.clusterName.xxxxxx.regionAndAz.cache.amazonaws.com:port
master.ncit.ameaqx.use1.cache.amazonaws.com:6379
```
## Finden von Endpunkten für einen Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) (Konsole)
Ein Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) hat einen einzigen Konfigurationsendpunkt. Über die Verbindung zum Konfigurationsendpunkt findet die Anwendung für jede Shard im Cluster die primären Endpunkte sowie jene für Schreibvorgänge.
**Um den Endpunkt eines Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert) zu finden**
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 **Valkey-Cluster** oder **Redis OSS-Cluster** aus.
Der Cluster-Bildschirm mit einer Liste von Clustern wird angezeigt. Wählen Sie den Cluster aus, zu dem Sie eine Verbindung herstellen möchten.
1. Um den Konfigurationsendpunkt des Clusters zu suchen, wählen Sie den Namen des Clusters (nicht das Optionsfeld) aus.
1. Der **Configuration endpoint** (Konfigurationsendpunkt) wird unter **Cluster details** (Cluster-Details) angezeigt. Wählen Sie zum Kopieren das Symbol *Copy* (Kopieren) links vom Endpunkt aus.
## Die Endpunkte eines Clusters finden (Konsole) (Memcached)
Alle Memcached-Endpunkte sind Endpunkte. read/write Zum Herstellen einer Verbindung mit Knoten in einem Memcached-Cluster kann Ihre Anwendung entweder die Endpunkte für jeden Knoten oder den Konfigurationsendpunkt des Clusters zusammen mit Automatic Discovery verwenden. Um Automatic Discovery verwenden zu können, benötigen Sie einen Client, der Automatic Discovery unterstützt.
Wenn Automatic Discovery verwendet wird, stellt Ihre Client-Anwendung über den Konfigurationsendpunkt eine Verbindung mit Ihrem Memcached-Cluster her. Während Sie Ihren Cluster durch Hinzufügen oder Entfernen von Knoten skalieren, „kennt“ Ihre Anwendung automatisch alle Knoten im Cluster und kann zu beliebigen von ihnen eine Verbindung herstellen. Ohne Automatic Discovery wäre das Ihre Aufgabe oder Sie müssten die Endpunkte Ihrer Anwendung jedes Mal manuell aktualisieren, wenn Sie einen Knoten hinzufügen oder löschen würden.
Wenn Sie einen Endpunkt kopieren möchten, wählen Sie das Kopiersymbol direkt vor der Endpunktadresse aus. Informationen zur Verwendung des Endpunkts zur Verbindung mit einem Knoten finden Sie unter [Verbindung zu Memcached-Knoten herstellen](nodes-connecting.md#nodes-connecting.mem).
Die Konfiguration und die Knotenendpunkte sehen sehr ähnlich aus. Es folgen die mit **Fettdruck** hervorgehobenen Unterschiede.
```
myclustername.xxxxxx.cfg.usw2.cache.amazonaws.com:port # configuration endpoint contains "cfg"
myclustername.xxxxxx.0001.usw2.cache.amazonaws.com:port # node endpoint for node 0001
```
**Wichtig**
Wenn Sie für Ihren Memcached-Konfigurationsendpunkt einen CNAME erstellen möchten, müssen Sie im CNAME `.cfg.` einschließen, damit Ihr Automatic Discovery-Client den CNAME als Konfigurationsendpunkt erkennen kann.
## Suchen von Endpunkten (AWS CLI)
Für Memcached können Sie AWS CLI for Amazon verwenden, ElastiCache um die Endpunkte für Knoten und Cluster zu ermitteln.
Für Redis OSS können Sie AWS CLI for Amazon verwenden, ElastiCache um die Endpunkte für Knoten, Cluster und auch Replikationsgruppen zu ermitteln.
**Topics**
+ [Suchen von Endpunkten für Knoten und Cluster (AWS CLI)](#Endpoints.Find.CLI.Nodes)
+ [Finden der Endpunkte für Valkey- oder Redis OSS-Replikationsgruppen ()AWS CLI](#Endpoints.Find.CLI.ReplGroups)
### Suchen von Endpunkten für Knoten und Cluster (AWS CLI)
Sie können den verwenden AWS CLI , um die Endpunkte für einen Cluster und seine Knoten mit dem Befehl zu ermitteln. `describe-cache-clusters` Für Valkey- oder Redis OSS-Cluster gibt der Befehl den Cluster-Endpunkt zurück. Für Memcached-Cluster gibt der Befehl den Konfigurationsendpunkt zurück. Wenn Sie den optionalen Parameter `--show-cache-node-info` einschließen, gibt der Befehl auch die Endpunkte der einzelnen Knoten im Cluster zurück.
**Example**
Der folgende Befehl ruft den Konfigurationsendpunkt (`ConfigurationEndpoint`) und einzelne Knotenendpunkte (`Endpoint`) für den Memcached-Cluster *mycluster* ab.
Für Linux, macOS oder Unix:
```
aws elasticache describe-cache-clusters \
--cache-cluster-id mycluster \
--show-cache-node-info
```
Für Windows:
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id mycluster ^
--show-cache-node-info
```
Die Ausgabe der obigen Operation sollte etwa wie nachfolgend dargestellt aussehen (JSON-Format).
```
{
"CacheClusters": [
{
"Engine": "memcached",
"CacheNodes": [
{
"CacheNodeId": "0001",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0002",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
},
{
"CacheNodeId": "0003",
"Endpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheNodeStatus": "available",
"ParameterGroupStatus": "in-sync",
"CacheNodeCreateTime": "2016-09-22T21:30:29.967Z",
"CustomerAvailabilityZone": "us-west-2b"
}
],
"CacheParameterGroup": {
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.memcached1.4",
"ParameterApplyStatus": "in-sync"
},
"CacheClusterId": "mycluster",
"PreferredAvailabilityZone": "us-west-2b",
"ConfigurationEndpoint": {
"Port": 11211,
"Address": "mycluster.amazonaws.com"
},
"CacheSecurityGroups": [],
"CacheClusterCreateTime": "2016-09-22T21:30:29.967Z",
"AutoMinorVersionUpgrade": true,
"CacheClusterStatus": "available",
"NumCacheNodes": 3,
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheSubnetGroupName": "default",
"EngineVersion": "1.4.24",
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "mon:09:00-mon:10:00",
"CacheNodeType": "cache.m4.large",
"DataTiering": "disabled"
}
]
}
```
Wenn Sie sich dafür entscheiden, einen CNAME für Ihren Memcached-Konfigurationsendpunkt zu erstellen, müssen Sie den `.cfg.` in den CNAME aufnehmen, damit Ihr Auto-Discovery-Client den CNAME als Konfigurationsendpunkt erkennen kann. Zum Beispiel `mycluster.cfg.local` in Ihrer php.ini-Datei für den Parameter `session.save_path`.
**Example**
*Für Valkey und Redis OSS ruft der folgende Befehl die Clusterinformationen für den Einzelknotencluster mycluster ab.*
Der Parameter `--cache-cluster-id` kann mit der Cluster-ID Valkey oder Redis OSS (Clustermodus deaktiviert) mit einem Knoten oder mit bestimmten Knoten-IDs in Replikationsgruppen verwendet werden. Der Wert `--cache-cluster-id` einer Replikationsgruppe ist ein vierstelliger Wert wie. `0001` Wenn `--cache-cluster-id` es sich um die ID eines Clusters (Knotens) in einer Replikationsgruppe handelt, `replication-group-id` ist der in der Ausgabe enthalten.
Für Linux, macOS oder Unix:
```
aws elasticache describe-cache-clusters \
--cache-cluster-id redis-cluster \
--show-cache-node-info
```
Für Windows:
```
aws elasticache describe-cache-clusters ^
--cache-cluster-id redis-cluster ^
--show-cache-node-info
```
Die Ausgabe der obigen Operation sollte etwa wie nachfolgend dargestellt aussehen (JSON-Format).
```
{
"CacheClusters": [
{
"CacheClusterStatus": "available",
"SecurityGroups": [
{
"SecurityGroupId": "sg-77186e0d",
"Status": "active"
}
],
"CacheNodes": [
{
"CustomerAvailabilityZone": "us-east-1b",
"CacheNodeCreateTime": "2018-04-25T18:19:28.241Z",
"CacheNodeStatus": "available",
"CacheNodeId": "0001",
"Endpoint": {
"Address": "redis-cluster.amazonaws.com",
"Port": 6379
},
"ParameterGroupStatus": "in-sync"
}
],
"AtRestEncryptionEnabled": false,
"CacheClusterId": "redis-cluster",
"TransitEncryptionEnabled": false,
"CacheParameterGroup": {
"ParameterApplyStatus": "in-sync",
"CacheNodeIdsToReboot": [],
"CacheParameterGroupName": "default.redis3.2"
},
"NumCacheNodes": 1,
"PreferredAvailabilityZone": "us-east-1b",
"AutoMinorVersionUpgrade": true,
"Engine": "redis",
"AuthTokenEnabled": false,
"PendingModifiedValues": {},
"PreferredMaintenanceWindow": "tue:08:30-tue:09:30",
"CacheSecurityGroups": [],
"CacheSubnetGroupName": "default",
"CacheNodeType": "cache.t2.small",
"DataTiering": "disabled"
"EngineVersion": "3.2.10",
"ClientDownloadLandingPage": "https://console.aws.amazon.com/elasticache/home#client-download:",
"CacheClusterCreateTime": "2018-04-25T18:19:28.241Z"
}
]
}
```
Weitere Informationen finden Sie im Thema [describe-cache-clusters](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-cache-clusters.html) .
### Finden der Endpunkte für Valkey- oder Redis OSS-Replikationsgruppen ()AWS CLI
Sie können den verwenden AWS CLI , um die Endpunkte für eine Replikationsgruppe und ihre Cluster mit dem Befehl zu ermitteln. `describe-replication-groups` Der Befehl gibt den primären Endpunkt der Replikationsgruppe und eine Liste aller Cluster (Knoten) in der Replikationsgruppe mit ihren Endpunkten sowie den Reader-Endpunkt zurück.
Die folgende Operation ruft den primären Endpunkt und den Reader-Endpunkt der Replikationsgruppe `myreplgroup` ab. Verwenden Sie den primären Endpunkt für alle Schreibvorgänge.
```
aws elasticache describe-replication-groups \
--replication-group-id myreplgroup
```
Für Windows:
```
aws elasticache describe-replication-groups ^
--replication-group-id myreplgroup
```
Die Ausgabe dieser Operation sollte etwa wie nachfolgend dargestellt aussehen (JSON-Format).
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "test",
"NodeGroups": [
{
"Status": "available",
"NodeGroupMembers": [
{
"CurrentRole": "primary",
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-001.amazonaws.com"
},
"CacheClusterId": "myreplgroup-001"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-002.amazonaws.com"
},
"CacheClusterId": "myreplgroup-002"
},
{
"CurrentRole": "replica",
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-003.amazonaws.com"
},
"CacheClusterId": "myreplgroup-003"
}
],
"NodeGroupId": "0001",
"PrimaryEndpoint": {
"Port": 6379,
"Address": "myreplgroup.amazonaws.com"
},
"ReaderEndpoint": {
"Port": 6379,
"Address": "myreplgroup-ro.amazonaws.com"
}
}
],
"ReplicationGroupId": "myreplgroup",
"AutomaticFailover": "enabled",
"SnapshottingClusterId": "myreplgroup-002",
"MemberClusters": [
"myreplgroup-001",
"myreplgroup-002",
"myreplgroup-003"
],
"PendingModifiedValues": {}
}
]
}
```
Weitere Informationen finden Sie unter [describe-replication-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-replication-groups.html) in der Referenz zum *AWS CLI -Befehl*.
## Endpunkte finden (API) ElastiCache
Für Memcached können Sie die ElastiCache Amazon-API verwenden, um die Endpunkte für Knoten und Cluster zu ermitteln.
Für Redis OSS können Sie die ElastiCache Amazon-API verwenden, um die Endpunkte für Knoten, Cluster und auch Replikationsgruppen zu ermitteln.
**Topics**
+ [Suche nach Endpunkten für Knoten und Cluster (API) ElastiCache](#Endpoints.Find.API.Nodes)
+ [Suche nach Endpunkten für Valkey- oder Redis OSS-Replikationsgruppen (API) ElastiCache](#Endpoints.Find.API.ReplGroups)
### Suche nach Endpunkten für Knoten und Cluster (API) ElastiCache
Sie können die ElastiCache API verwenden, um mit der Aktion die Endpunkte für einen Cluster und seine Knoten zu ermitteln. `DescribeCacheClusters` Für Valkey- oder Redis OSS-Cluster gibt der Befehl den Cluster-Endpunkt zurück. Für Memcached-Cluster gibt der Befehl den Konfigurationsendpunkt zurück. Wenn Sie den optionalen Parameter `ShowCacheNodeInfo` einschließen, gibt die Aktion auch die Endpunkte der einzelnen Knoten im Cluster zurück.
**Example**
*Für Memcached ruft der folgende Befehl den Konfigurationsendpunkt (`ConfigurationEndpoint`) und die einzelnen Knotenendpunkte (`Endpoint`) für den Memcached-Cluster mycluster ab.*
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeCacheClusters
&CacheClusterId=mycluster
&ShowCacheNodeInfo=true
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Wenn Sie sich dafür entscheiden, einen CNAME für Ihren Memcached-Konfigurationsendpunkt zu erstellen, müssen Sie den `.cfg.` in den CNAME aufnehmen, damit Ihr Auto-Discovery-Client den CNAME als Konfigurationsendpunkt erkennen kann. Zum Beispiel `mycluster.cfg.local` in Ihrer php.ini-Datei für den Parameter `session.save_path`.
### Suche nach Endpunkten für Valkey- oder Redis OSS-Replikationsgruppen (API) ElastiCache
Sie können die ElastiCache API verwenden, um mit der Aktion die Endpunkte für eine Replikationsgruppe und ihre Cluster zu ermitteln. `DescribeReplicationGroups` Die Aktion gibt den primären Endpunkt der Replikationsgruppe und eine Liste aller Cluster in der Replikationsgruppe mit ihren Endpunkten sowie den Reader-Endpunkt zurück.
Der folgende Vorgang ruft den primären Endpunkt (PrimaryEndpoint), den Leser-Endpunkt (ReaderEndpoint) und die einzelnen Knotenendpunkte (ReadEndpoint) für die Replikationsgruppe ab. `myreplgroup` Verwenden Sie den primären Endpunkt für alle Schreibvorgänge.
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroups
&ReplicationGroupId=myreplgroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&Version=2015-02-02
&X-Amz-Credential=
```
Weitere Informationen finden Sie unter [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html).
# Arbeiten mit Shards in ElastiCache
Ein Shard (API/CLI: Node Group) ist eine Sammlung von eins bis sechs ElastiCache für Valkey- oder Redis-OSS-Knoten. Ein Valkey- oder Redis OSS-Cluster (Clustermodus deaktiviert) wird niemals mehr als einen Shard haben. Mit Shards können Sie große Datenbanken in kleinere, schnellere und einfacher zu verwaltende Teile aufteilen, die als Daten-Shards bezeichnet werden. Dadurch kann die Datenbankeffizienz erhöht werden, indem die Operationen auf mehrere separate Abschnitte verteilt werden. Die Verwendung von Shards kann viele Vorteile bieten, darunter eine verbesserte Leistung, Skalierbarkeit und Kosteneffizienz.
Sie können einen Cluster mit einer höheren Anzahl an Shards und einer geringeren Anzahl an Replikaten mit bis zu 90 Knoten pro Cluster erstellen. Diese Clusterkonfiguration reicht von 90 Shards und 0 Replikaten bis hin zu 15 Shards und 5 Replikaten, was dem Höchstwert für die Anzahl erlaubter Replikate entspricht. Die Daten des Clusters werden über die Shards des Clusters hinweg partitioniert. Wenn ein Shard mehr als einen Knoten enthält, implementiert der Shard die Replikation, wobei ein Knoten der read/write primäre Knoten und die anderen Knoten schreibgeschützte Replikatknoten sind.
Das Knoten- oder Shard-Limit kann auf maximal 500 pro Cluster erhöht werden, wenn die Engine-Version Valkey 7.2 und höher oder Redis OSS 5.0.6 bis 7.1 ist. Sie können beispielsweise einen Cluster mit 500 Knoten konfigurieren, der zwischen 83 Shards (ein primärer Knoten und 5 Replikate pro Shard) und 500 Shards (ein primärer Knoten und keine Replikate) umfasst. Stellen Sie sicher, dass für die Erhöhung genügend IP-Adressen verfügbar sind. Häufige Fallstricke sind Subnetze in der Subnetzgruppe, die einen zu kleinen CIDR-Bereich haben, oder Subnetze, die gemeinsam genutzt und von anderen Clustern stark beansprucht werden. Weitere Informationen finden Sie unter [Erstellen einer Subnetzgruppe](SubnetGroups.Creating.md).
Für Versionen unter 5.0.6 liegt das Limit bei 250 pro Cluster.
Um eine Erhöhung des Limits zu beantragen, siehe [AWS -Service-Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) und wählen Sie den Limittyp **Knoten pro Cluster pro Instance-Typ**.
Wenn Sie mithilfe der ElastiCache Konsole einen Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) erstellen, geben Sie die Anzahl der Shards im Cluster und die Anzahl der Knoten in den Shards an. Weitere Informationen finden Sie unter [Erstellen eines Valkey- oder Redis OSS-Clusters (Cluster-Modus aktiviert) (Konsole)](Clusters.Create.md#Clusters.Create.CON.RedisCluster). Wenn Sie die ElastiCache API verwenden oder AWS CLI um einen Cluster (in der KnotengruppeAPI/CLI), you can configure the number of nodes in a shard (API/CLI: *Replikationsgruppe* genannt) unabhängig zu erstellen. Weitere Informationen finden Sie hier:
+ API: [CreateReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html)
+ CLI: [create-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/create-replication-group.html)
Für jeden Knoten in einem Shard gelten dieselben Rechner-, Arbeitsspeicher- und Festspeicherspezifikationen. Mit der ElastiCache API können Sie Shard-weite Attribute wie die Anzahl der Knoten, Sicherheitseinstellungen und Systemwartungsfenster steuern.
![\[Bild: Valkey- oder Redis OSS-Shard-Konfigurationen.\]](http://docs.aws.amazon.com/de_de/AmazonElastiCache/latest/dg/images/ElastiCacheClusters-CSN-RedisShards.png)
*Valkey- oder Redis OSS-Shard-Konfigurationen*
Weitere Informationen erhalten Sie unter [Offline-Resharding für Valkey oder Redis OSS (Clustermodus aktiviert)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-offline) und [Online-Resharding für Valkey oder Redis OSS (Clustermodus aktiviert)](scaling-redis-cluster-mode-enabled.md#redis-cluster-resharding-online).
## Auffinden der ID eines Shards
Sie können die ID eines Shards mithilfe der AWS-Managementkonsole, der oder der API finden. AWS CLI ElastiCache
### Unter Verwendung der AWS-Managementkonsole
**Topics**
+ [Für Valkey oder Redis OSS (Clustermodus deaktiviert)](#shard-find-id-con-classic)
+ [Für Valkey oder Redis OSS (Clustermodus aktiviert)](#shard-find-id-con-cluster)
#### Für Valkey oder Redis OSS (Clustermodus deaktiviert)
Für Valkey oder Redis OSS (Cluster-Modus deaktiviert) sind Replikationsgruppen-Shards immer verfügbar. IDs `0001`
#### Für Valkey oder Redis OSS (Clustermodus aktiviert)
Das folgende Verfahren verwendet die AWS-Managementkonsole , um die Shard-ID einer Replikationsgruppe von Valkey oder Redis OSS (Clustermodus aktiviert) zu ermitteln.
**So finden Sie die Shard-ID in einer Valkey- oder Redis OSS-Replikationsgruppe (Clustermodus aktiviert)**
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 **Valkey** oder **Redis OSS** und dann den Namen der Valkey- oder Redis OSS-Replikationsgruppe (Clustermodus aktiviert) aus, für die Sie den Shard suchen möchten. IDs
1. In der Spalte **Shard-Name** ist die Shard-ID die letzten vier Ziffern des Shard-Namens.
### Verwenden Sie den AWS CLI
Um Shard-IDs (Knotengruppen) für entweder Valkey oder Redis OSS (Clustermodus deaktiviert) oder Valkey oder Redis OSS (Clustermodus aktiviert) zu finden, verwenden Sie den AWS CLI Vorgang `describe-replication-groups` mit dem folgenden optionalen Parameter.
+ **`--replication-group-id`**–Ein optionaler Parameter, der bei Verwendung die Ausgabe auf die Details der angegebenen Replikationsgruppe beschränkt. Wenn dieser Parameter weggelassen wird, werden die Details von bis zu 100 Replikationsgruppen zurückgegeben.
**Example**
Dieser Befehl gibt die Details für `sample-repl-group` zurück.
Für Linux, macOS oder Unix:
```
aws elasticache describe-replication-groups \
--replication-group-id sample-repl-group
```
Für Windows:
```
aws elasticache describe-replication-groups ^
--replication-group-id sample-repl-group
```
Die Ausgabe dieses Befehls sieht in etwa wie folgt aus: Die Shard-IDs (Knotengruppen-IDs) sollen das Auffinden erleichtern*highlighted*.
```
{
"ReplicationGroups": [
{
"Status": "available",
"Description": "2 shards, 2 nodes (1 + 1 replica)",
"NodeGroups": [
{
"Status": "available",
"Slots": "0-8191",
"NodeGroupId": "0001",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2c",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0001-002"
}
]
},
{
"Status": "available",
"Slots": "8192-16383",
"NodeGroupId": "0002",
"NodeGroupMembers": [
{
"PreferredAvailabilityZone": "us-west-2b",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-001"
},
{
"PreferredAvailabilityZone": "us-west-2a",
"CacheNodeId": "0001",
"CacheClusterId": "sample-repl-group-0002-002"
}
]
}
],
"ConfigurationEndpoint": {
"Port": 6379,
"Address": "sample-repl-group.9dcv5r.clustercfg.usw2.cache.amazonaws.com"
},
"ClusterEnabled": true,
"ReplicationGroupId": "sample-repl-group",
"SnapshotRetentionLimit": 1,
"AutomaticFailover": "enabled",
"SnapshotWindow": "13:00-14:00",
"MemberClusters": [
"sample-repl-group-0001-001",
"sample-repl-group-0001-002",
"sample-repl-group-0002-001",
"sample-repl-group-0002-002"
],
"CacheNodeType": "cache.m3.medium",
"DataTiering": "disabled",
"PendingModifiedValues": {}
}
]
}
```
### Verwenden der API ElastiCache
Verwenden Sie den AWS CLI Vorgang mit dem folgenden optionalen Parameter, um Shard-IDs (Knotengruppen) für Valkey oder Redis OSS (Clustermodus deaktiviert) oder Valkey- oder Redis OSS-Replikationsgruppen (Clustermodus aktiviert) `describe-replication-groups` zu finden.
+ **`ReplicationGroupId`**–Ein optionaler Parameter, der bei Verwendung die Ausgabe auf die Details der angegebenen Replikationsgruppe beschränkt. Wenn dieser Parameter weggelassen wird, werden die Details von bis zu *xxx* Replikationsgruppen zurückgegeben.
**Example**
Dieser Befehl gibt die Details für `sample-repl-group` zurück.
Für Linux, macOS oder Unix:
```
https://elasticache.us-west-2.amazonaws.com/
?Action=DescribeReplicationGroup
&ReplicationGroupId=sample-repl-group
&Version=2015-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20150202T192317Z
&X-Amz-Credential=
```