

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.

# Skalierung von Valkey- oder Redis OSS-Clustern (Clustermodus aktiviert)
<a name="scaling-redis-cluster-mode-enabled"></a>

Wenn sich die Nachfrage nach Ihren Clustern ändert, können Sie entscheiden, die Leistung zu verbessern oder die Kosten zu senken, indem Sie die Anzahl der Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) ändern. Wir empfehlen, dazu die horizontale Online-Skalierung zu verwenden, da Ihr Cluster während des Skalierungsprozesses weiterhin Anforderungen bedienen kann.

Zu den Bedingungen, unter denen Sie den Cluster möglicherweise neu skalieren, gehören folgende:
+ **Speicherbelastung**

  Wenn die Knoten in Ihrem Cluster einer hohen Speicherbelastung ausgesetzt sind, können Sie sich für eine Skalierung entscheiden, sodass Sie über mehr Ressourcen verfügen, um Daten besser speichern und Anforderungen verarbeiten zu können.

  Sie können feststellen, ob Ihre Knoten unter Speicherauslastung stehen, indem Sie die folgenden Messwerte überwachen: *FreeableMemory*, und *SwapUsage*. *BytesUsedForCache*
+ **CPU- oder Netzwerkengpässe:**

  Wenn latency/throughput Probleme in Ihrem Cluster auftreten, müssen Sie möglicherweise eine Skalierung vornehmen, um die Probleme zu lösen.

  Sie können Ihre Latenz und Ihren Durchsatz überwachen, indem Sie die folgenden Messwerte überwachen: *CPUUtilization*, *NetworkBytesIn*, *NetworkBytesOut*CurrConnections**, und. *NewConnections*
+ **Ihr Cluster ist übermäßig skaliert:**

  Der aktuelle Bedarf an Ihrem Cluster ist so hoch, dass eine Skalierung die Leistung nicht beeinträchtigt und Ihre Kosten reduziert.

  Sie können die Nutzung Ihres Clusters überwachen, um anhand der folgenden Metriken festzustellen, ob Sie sicher skalieren können oder nicht: *FreeableMemory*SwapUsage*BytesUsedForCache***, *CPUUtilization*, *NetworkBytesIn*, *NetworkBytesOut*, *CurrConnections*, und *NewConnections*.

**Leistungsbeeinträchtigung durch Skalierung**  
Wenn Sie den Offline-Prozess skalieren, ist Ihr Cluster für einen erheblichen Teil des Prozesses offline und kann daher keine Anforderungen erfüllen. Wenn Sie mithilfe der Onlinemethode skalieren, da die Skalierung eine rechenintensive Operation ist, gibt es eine Leistungseinbuße. Ihr Cluster führt jedoch weiterhin während der Skalierungsoperation Anforderungen aus. Wie stark die Verschlechterung ist, hängt von Ihrer normalen CPU-Auslastung und Ihren Daten ab.

Es gibt zwei Möglichkeiten, Ihren Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) zu skalieren: horizontale und vertikale Skalierung.
+ Mit horizontaler Skalierung ändern Sie die Anzahl der Knotengruppen (Shards) in der Replikationsgruppe, indem Sie Knotengruppen hinzufügen oder entfernen. Der Online-Resharding-Prozess ermöglicht die Skalierung, in/out während der Cluster weiterhin eingehende Anfragen bearbeitet. 

  Konfigurieren Sie die Slots in Ihrem neuen Cluster anders als im alten Cluster. Nur Offline-Methode.
+ Vertikale Skalierung – Ändern Sie den Knotentyp, um die Größe des Clusters anzupassen. Die vertikale Online-Skalierung ermöglicht die Skalierung up/down , während der Cluster weiterhin eingehende Anfragen bearbeitet.

Wenn Sie die Größe und Speicherkapazität des Clusters reduzieren, indem Sie entweder ein- oder herunterskalieren, stellen Sie sicher, dass die neue Konfiguration über ausreichend Speicher für Ihre Daten und den OSS-Overhead von Valkey oder Redis verfügt. 

Weitere Informationen finden Sie unter [Auswahl der Knotengröße](CacheNodes.SelectSize.md).

**Contents**
+ [Offline-Resharding für Valkey oder Redis OSS (Clustermodus aktiviert)](#redis-cluster-resharding-offline)
+ [Online-Resharding für Valkey oder Redis OSS (Clustermodus aktiviert)](#redis-cluster-resharding-online)
  + [Hinzufügen von Shards mit Online-Resharding](#redis-cluster-resharding-online-add)
  + [Entfernen von Shards mit Online-Resharding](#redis-cluster-resharding-online-remove)
    + [Entfernen von Shards (Konsole)](#redis-cluster-resharding-online-remove-console)
    + [Entfernen von Shards (AWS CLI)](#redis-cluster-resharding-online-remove-cli)
    + [Shards entfernen (API) ElastiCache](#redis-cluster-resharding-online-remove-api)
  + [Online-Shard-Rebalancing](#redis-cluster-resharding-online-rebalance)
    + [Online-Shard-Rebalancing (Console)](#redis-cluster-resharding-online-rebalance-console)
    + [Online-Shard-Rebalancing (AWS CLI)](#redis-cluster-resharding-online-rebalance-cli)
    + [Online-Shard-Rebalancing (API) ElastiCache](#redis-cluster-resharding-online-rebalance-api)
+ [Vertikales Online-Skalieren durch Ändern des Knotentyps](redis-cluster-vertical-scaling.md)
  + [Online-aufwärtsskalieren](redis-cluster-vertical-scaling.md#redis-cluster-vertical-scaling-scaling-up)
    + [Skalierung von Valkey- oder Redis OSS-Clustern (Konsole)](redis-cluster-vertical-scaling.md#redis-cluster-vertical-scaling-console)
    + [Skalierung von Valkey- oder Redis OSS-Clustern ()AWS CLI](redis-cluster-vertical-scaling.md#Scaling.RedisStandalone.ScaleUp.CLI)
    + [Skalierung von Valkey- oder Redis OSS-Clustern (API) ElastiCache](redis-cluster-vertical-scaling.md#VeticalScaling.RedisReplGrps.ScaleUp.API)
  + [Online-abwärtsskalieren](redis-cluster-vertical-scaling.md#redis-cluster-vertical-scaling-scaling-down)
    + [Herunterskalierung von Valkey- oder Redis OSS-Clustern (Konsole)](redis-cluster-vertical-scaling.md#redis-cluster-vertical-scaling-down-console)
    + [Herunterskalieren von Valkey- oder Redis OSS-Clustern ()AWS CLI](redis-cluster-vertical-scaling.md#Scaling.RedisStandalone.ScaleDown.CLI)
    + [Herunterskalierung der Valkey- oder Redis OSS-Cluster (API) ElastiCache](redis-cluster-vertical-scaling.md#Scaling.Vertical.ScaleDown.API)

## Offline-Resharding für Valkey oder Redis OSS (Clustermodus aktiviert)
<a name="redis-cluster-resharding-offline"></a>

Der Hauptvorteil der Offline-Shard-Rekonfiguration besteht darin, dass Sie mehr als nur das Hinzufügen oder Entfernen von Shards aus Ihrer Replikationsgruppe tun können. Wenn Sie Resharding und Rebalancing offline durchführen, können Sie nicht nur die Anzahl der Shards in Ihrer Replikationsgruppe ändern, sondern auch Folgendes tun:

**Anmerkung**  
Offline-Resharding wird auf Valkey- oder Redis-OSS-Clustern mit aktiviertem Data Tiering nicht unterstützt. Weitere Informationen finden Sie unter [Datenzuweisung ElastiCache](data-tiering.md).
+ Ändern Sie den Knotentyp Ihrer Replikationsgruppe.
+ Geben Sie die Availability Zone für jeden Knoten in der Replikationsgruppe an.
+ Upgrade auf eine neuere Engine-Version.
+ Geben Sie die Anzahl der Replikatknoten in jeder Shard unabhängig voneinander an.
+ Geben Sie den Keyspace für jede Shard an.

Der Hauptnachteil der Offline-Shard-Neukonfiguration besteht darin, dass Ihr Cluster offline ist und mit dem Wiederherstellungsabschnitt des Prozesses beginnt und so lange fortfährt, bis Sie die Endpunkte in Ihrer Anwendung aktualisieren. Die Dauer, in der Ihr Cluster offline ist, hängt von der Datenmenge in Ihrem Cluster ab.

**Um Ihre Shards Valkey oder Redis OSS-Cluster (Clustermodus aktiviert) offline neu zu konfigurieren**

1. Erstellen Sie ein manuelles Backup Ihres vorhandenen Valkey- oder Redis OSS-Clusters. Weitere Informationen finden Sie unter [Erstellen manueller Backups](backups-manual.md).

1. Erstellen Sie einen neuen Cluster, indem Sie sie aus der Sicherung wiederherstellen. Weitere Informationen finden Sie unter [Wiederherstellen aus einem Backup in einen neuen Cache](backups-restoring.md).

1. Aktualisieren Sie in Ihrer Anwendung die Endpunkte auf die neuen Cluster-Endpunkte. Weitere Informationen finden Sie unter [Verbindungsendpunkte finden in ElastiCache](Endpoints.md).

## Online-Resharding für Valkey oder Redis OSS (Clustermodus aktiviert)
<a name="redis-cluster-resharding-online"></a>

Mithilfe von Online-Resharding und Shard-Rebalancing mit ElastiCache Valkey 7.2 oder neuer oder Redis OSS Version 3.2.10 oder neuer können Sie Ihren Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) dynamisch und ohne Ausfallzeiten skalieren. Dieser Ansatz bedeutet, dass Ihr Cluster weiterhin Anfragen bearbeiten kann, selbst wenn die Skalierung oder das Rebalancing in Bearbeitung ist.

Sie haben die folgenden Möglichkeiten:
+ **Skalierung — Erhöhen Sie die Lese- und Schreibkapazität, indem Sie Ihrem Valkey- oder Redis OSS-Cluster** (Clustermodus aktiviert) (Replikationsgruppe) Shards (Knotengruppen) hinzufügen.

  Wenn Sie Ihrer Replikationsgruppe einen oder mehrere Shards hinzufügen, entspricht die Anzahl der Knoten in jedem neuen Shard der Anzahl der Knoten in der kleinsten der vorhandenen Shards.
+ **Skalierung** — Reduzieren Sie die Lese- und Schreibkapazität und damit die Kosten, indem Sie Shards aus Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) entfernen.
+ **Rebalance** — Verschieben Sie die Keyspaces zwischen den Shards in Ihrem Valkey- oder Redis OSS-Cluster (Cluster-Modus aktiviert), sodass sie so gleichmäßig wie möglich auf die Shards verteilt sind.

Sie haben nicht die folgenden Möglichkeiten:
+ **Konfigurieren Sie Shards unabhängig:**

  Sie können den Keyspace für Shards nicht unabhängig angeben. Um dies zu tun, müssen Sie den Offline-Prozess verwenden.

Derzeit gelten die folgenden Einschränkungen für Online-Resharding und Rebalancing: ElastiCache 
+ Diese Prozesse erfordern Valkey 7.2 und neuer oder Redis OSS 3.2.10 oder neuer. Informationen zum Aktualisieren der Engine-Version finden Sie unter [Versionsverwaltung für ElastiCache](VersionManagement.md).
+ Es gibt Einschränkungen bei Slots oder Keyspaces und großen Elementen:

  Wenn ein Schlüssel in einem Shard ein großes Element enthält, wird dieser Schlüssel beim horizontalen Skalieren oder Neuausrichten nicht in eine neue Shard migriert. Diese Funktionalität kann zu unsymmetrischen Shards führen.

  Wenn einer der Schlüssel in einer Shard ein großes Element enthält (Elemente größer als 256 MB nach der Serialisierung), wird diese Shard beim Skalieren nicht gelöscht. Diese Funktionalität kann dazu führen, dass einige Shards nicht gelöscht werden.
+ Beim Ausskalieren entspricht die Anzahl der Knoten in neuen Shards der Anzahl der Knoten in der kleinsten vorhandenen Shard.
+ Beim Ausskalieren werden alle Tags, die allen vorhandenen Shards gemeinsam sind, in die neuen Shards kopiert.
+ Beim Skalieren eines Global Data Store-Clusters ElastiCache werden Funktionen nicht automatisch von einem der vorhandenen Knoten auf die neuen Knoten repliziert. Wir empfehlen, Ihre Funktionen nach der Aufskalierung Ihres Clusters in den (die) neuen Shard(s) zu laden, sodass alle Shards dieselben Funktionen aufweisen. 

**Anmerkung**  
 ElastiCache Für Valkey 7.2 und höher und ElastiCache für Redis OSS Version 7 und höher: Wenn Sie Ihren Cluster skalieren, repliziert er ElastiCache automatisch die Funktionen, die in einem der vorhandenen Knoten geladen sind (zufällig ausgewählt), auf die neuen Knoten. Wenn Ihre Anwendung [Functions](https://valkey.io/topics/functions-intro/) verwendet, empfehlen wir, alle Ihre Funktionen vor dem Skalieren auf alle Shards zu laden, damit Ihr Cluster nicht mit unterschiedlichen Funktionsdefinitionen auf verschiedenen Shards endet.

Weitere Informationen finden Sie unter [Online-Größenanpassung von Clustern](best-practices-online-resharding.md).

Sie können Ihre Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) mithilfe der API AWS-Managementkonsole, der und der API horizontal skalieren oder neu ausbalancieren AWS CLI. ElastiCache 

### Hinzufügen von Shards mit Online-Resharding
<a name="redis-cluster-resharding-online-add"></a>

Sie können Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) mithilfe der API, oder Shards hinzufügen.AWS-ManagementkonsoleAWS CLI ElastiCache Wenn Sie Shards zu einem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) hinzufügen, werden alle Tags auf den vorhandenen Shards auf die neuen Shards kopiert.

**Topics**

#### Hinzufügen von Shards (Konsole)
<a name="redis-cluster-resharding-online-add-console"></a>

Sie können den verwenden AWS-Managementkonsole, um Ihrem Valkey- oder Redis OSS-Cluster (Cluster-Modus aktiviert) einen oder mehrere Shards hinzuzufügen. Das folgende Verfahren beschreibt den Prozess.

**Um Shards zu Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) hinzuzufügen**

1. Ö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.

1. Suchen Sie den Namen des Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert), dem Sie Shards hinzufügen möchten, und wählen Sie ihn aus, nicht das Feld links neben dem Clusternamen.
**Tipp**  
****Valkey oder Redis OSS (Clustermodus aktiviert) zeigen **Clustered Valkey oder Clustered** Redis OSS in der Modus-Spalte****

1. Wählen Sie **Shard hinzufügen** aus.

   1. Wählen Sie für **Anzahl der hinzuzufügenden Shards**die Anzahl der Shards, die Sie diesem Cluster hinzufügen möchten.

   1. Für **Availability zone(s)**, entweder **No preference** oder **Specify availability zones** angeben.

   1. Wenn Sie **Availability Zones angeben**für jeden Knoten angeben möchten, wählen Sie für jeden Knoten in jeder Shard die Availability Zone des Knotens aus der Liste der Availability Zones.

   1. Wählen Sie **Hinzufügen** aus.

#### Shards hinzufügen (AWS CLI)
<a name="redis-cluster-resharding-online-add-cli"></a>

Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) neu konfigurieren, indem Sie Shards mit dem hinzufügen.AWS CLI

Verwenden Sie die folgenden Parameter mit `modify-replication-group-shard-configuration`.

**Parameters**
+ `--apply-immediately` – Erforderlich. Gibt an, dass die Shard-Rekonfigurationsoperation sofort gestartet werden soll.
+ `--replication-group-id` – Erforderlich. Gibt an, für welche Replikationsgruppe (Cluster) die Shard-Rekonfigurationsoperation ausgeführt werden soll.
+ `--node-group-count` – Erforderlich. Gibt die Anzahl der Shards (Knotengruppen) an, die nach Abschluss des Vorgangs vorhanden sein müssen. Beim Hinzufügen von Shards muss der Wert von `--node-group-count` größer als die aktuelle Anzahl von Shards sein.

  Optional können Sie die Availability Zone für jeden Knoten in der Replikationsgruppe mit `--resharding-configuration` angeben.
+ `--resharding-configuration` – Optional. Eine Liste der bevorzugten Availability Zones für jeden Knoten in jedem Shard in der Replikationsgruppe. Verwenden Sie diesen Parameter nur, wenn der Wert von `--node-group-count` größer ist als die aktuelle Anzahl von Shards. Wenn dieser Parameter beim Hinzufügen von Shards weggelassen wird, ElastiCache wählt Amazon die Availability Zones für die neuen Knoten aus.

Im folgenden Beispiel werden die Keyspaces für vier Shards in einem Valkey- oder Redis OSS-Cluster (Cluster-Modus aktiviert) mit dem Namen neu konfiguriert. `my-cluster` Das Beispiel gibt auch die Availability Zone für jeden Knoten in jedem Shard an. Die Operation beginnt sofort.

**Example - Shards hinzufügen**  
Für Linux, macOS oder Unix:  

```
aws elasticache modify-replication-group-shard-configuration \
    --replication-group-id my-cluster \
    --node-group-count 4 \
    --resharding-configuration \
        "PreferredAvailabilityZones=us-east-2a,us-east-2c" \
        "PreferredAvailabilityZones=us-east-2b,us-east-2a" \
        "PreferredAvailabilityZones=us-east-2c,us-east-2d" \
        "PreferredAvailabilityZones=us-east-2d,us-east-2c" \
    --apply-immediately
```
Für Windows:  

```
aws elasticache modify-replication-group-shard-configuration ^
    --replication-group-id my-cluster ^
    --node-group-count 4 ^
    --resharding-configuration ^
        "PreferredAvailabilityZones=us-east-2a,us-east-2c" ^
        "PreferredAvailabilityZones=us-east-2b,us-east-2a" ^
        "PreferredAvailabilityZones=us-east-2c,us-east-2d" ^
        "PreferredAvailabilityZones=us-east-2d,us-east-2c" ^
    --apply-immediately
```

[Weitere Informationen finden Sie unter -configuration in der Dokumentationmodify-replication-group-shard.](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group-shard-configuration.html)AWS CLI

#### Hinzufügen von Shards (API) ElastiCache
<a name="redis-cluster-resharding-online-add-api"></a>

Sie können die ElastiCache API verwenden, um die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) online neu zu konfigurieren, indem Sie den Vorgang verwenden. `ModifyReplicationGroupShardConfiguration`

Verwenden Sie die folgenden Parameter mit `ModifyReplicationGroupShardConfiguration`.

**Parameters**
+ `ApplyImmediately=true` – Erforderlich. Gibt an, dass die Shard-Rekonfigurationsoperation sofort gestartet werden soll.
+ `ReplicationGroupId` – Erforderlich. Gibt an, für welche Replikationsgruppe (Cluster) die Shard-Rekonfigurationsoperation ausgeführt werden soll.
+ `NodeGroupCount` – Erforderlich. Gibt die Anzahl der Shards (Knotengruppen) an, die nach Abschluss des Vorgangs vorhanden sein müssen. Beim Hinzufügen von Shards muss der Wert von `NodeGroupCount` größer als die aktuelle Anzahl von Shards sein.

  Optional können Sie die Availability Zone für jeden Knoten in der Replikationsgruppe mit `ReshardingConfiguration` angeben.
+ `ReshardingConfiguration` – Optional. Eine Liste der bevorzugten Availability Zones für jeden Knoten in jedem Shard in der Replikationsgruppe. Verwenden Sie diesen Parameter nur, wenn der Wert von `NodeGroupCount` größer ist als die aktuelle Anzahl von Shards. Wenn dieser Parameter beim Hinzufügen von Shards weggelassen wird, ElastiCache wählt Amazon die Availability Zones für die neuen Knoten aus.

Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Cluster-Modus aktiviert) neu konfigurieren, indem Sie Shards mithilfe der API hinzufügen. ElastiCache 

**Example - Shards hinzufügen**  
Im folgenden Beispiel werden dem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) Knotengruppen hinzugefügt`my-cluster`, sodass nach Abschluss des Vorgangs insgesamt vier Knotengruppen vorhanden sind. Das Beispiel gibt auch die Availability Zone für jeden Knoten in jedem Shard an. Die Operation beginnt sofort.  

```
https://elasticache.us-east-2.amazonaws.com/
    ?Action=ModifyReplicationGroupShardConfiguration
    &ApplyImmediately=true
    &NodeGroupCount=4
    &ReplicationGroupId=my-cluster
    &ReshardingConfiguration.ReshardingConfiguration.1.PreferredAvailabilityZones.AvailabilityZone.1=us-east-2a 
    &ReshardingConfiguration.ReshardingConfiguration.1.PreferredAvailabilityZones.AvailabilityZone.2=us-east-2c 
    &ReshardingConfiguration.ReshardingConfiguration.2.PreferredAvailabilityZones.AvailabilityZone.1=us-east-2b 
    &ReshardingConfiguration.ReshardingConfiguration.2.PreferredAvailabilityZones.AvailabilityZone.2=us-east-2a 
    &ReshardingConfiguration.ReshardingConfiguration.3.PreferredAvailabilityZones.AvailabilityZone.1=us-east-2c 
    &ReshardingConfiguration.ReshardingConfiguration.3.PreferredAvailabilityZones.AvailabilityZone.2=us-east-2d 
    &ReshardingConfiguration.ReshardingConfiguration.4.PreferredAvailabilityZones.AvailabilityZone.1=us-east-2d 
    &ReshardingConfiguration.ReshardingConfiguration.4.PreferredAvailabilityZones.AvailabilityZone.2=us-east-2c 
    &Version=2015-02-02
    &SignatureVersion=4
    &SignatureMethod=HmacSHA256
    &Timestamp=20171002T192317Z
    &X-Amz-Credential=<credential>
```

Weitere Informationen finden Sie [ModifyReplicationGroupShardConfiguration](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroupShardConfiguration.html)in der ElastiCache API-Referenz.

### Entfernen von Shards mit Online-Resharding
<a name="redis-cluster-resharding-online-remove"></a>

Sie können Shards mithilfe der API, oder aus Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) entfernen.AWS-ManagementkonsoleAWS CLI ElastiCache 

**Topics**
+ [Entfernen von Shards (Konsole)](#redis-cluster-resharding-online-remove-console)
+ [Entfernen von Shards (AWS CLI)](#redis-cluster-resharding-online-remove-cli)
+ [Shards entfernen (API) ElastiCache](#redis-cluster-resharding-online-remove-api)

#### Entfernen von Shards (Konsole)
<a name="redis-cluster-resharding-online-remove-console"></a>

Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) neu konfigurieren, indem Sie Shards mit dem entfernen.AWS-Managementkonsole

Bevor Sie Knotengruppen (Shards) aus Ihrer Replikationsgruppe entfernen, stellen Sie sicher, ElastiCache dass alle Ihre Daten in die verbleibenden Shards passen. Wenn die Daten passen, werden die angegebenen Shards wie angefordert aus der Replikationsgruppe gelöscht. Wenn die Daten nicht in die verbleibenden Knotengruppen passen, wird der Prozess beendet und die Replikationsgruppe hat dieselbe Knotengruppenkonfiguration wie vor dem Zeitpunkt, an dem die Anforderung erstellt wurde.

Sie können den verwenden AWS-Managementkonsole, um einen oder mehrere Shards aus Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) zu entfernen. Sie können nicht alle Shards in einer Replikationsgruppe entfernen. Stattdessen müssen Sie die Replikationsgruppe löschen. Weitere Informationen finden Sie unter [Löschen einer Replikationsgruppe](Replication.DeletingRepGroup.md). Das folgende Verfahren beschreibt den Vorgang zum Löschen eines oder mehrerer Shards.

**Um Shards aus Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) zu entfernen**

1. Ö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.

1. Suchen Sie den Namen des Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert), aus dem Sie Shards entfernen möchten, und wählen Sie ihn aus, nicht das Feld links neben dem Clusternamen.
**Tipp**  
**Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) haben in der Spalte Shards einen Wert von 1 oder höher.**

1. Wählen Sie in der Liste der Shards das Feld links von den Namen aller Shards, die Sie löschen möchten.

1. Wählen Sie **Delete Shard**.

#### Entfernen von Shards (AWS CLI)
<a name="redis-cluster-resharding-online-remove-cli"></a>

Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) neu konfigurieren, indem Sie Shards mit dem entfernen.AWS CLI

**Wichtig**  
Bevor Sie Knotengruppen (Shards) aus Ihrer Replikationsgruppe entfernen, stellen Sie sicher, ElastiCache dass alle Ihre Daten in die verbleibenden Shards passen. Wenn die Daten passen, werden die angegebenen Shards (`--node-groups-to-remove`) wie angefordert aus der Replikationsgruppe gelöscht und ihre Keyspaces den verbleibenden Shards zugeordnet. Wenn die Daten nicht in die verbleibenden Knotengruppen passen, wird der Prozess beendet und die Replikationsgruppe hat dieselbe Knotengruppenkonfiguration wie vor dem Zeitpunkt, an dem die Anforderung erstellt wurde.

Sie können den verwenden AWS CLI, um einen oder mehrere Shards aus Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) zu entfernen. Sie können nicht alle Shards in einer Replikationsgruppe entfernen. Stattdessen müssen Sie die Replikationsgruppe löschen. Weitere Informationen finden Sie unter [Löschen einer Replikationsgruppe](Replication.DeletingRepGroup.md).

Verwenden Sie die folgenden Parameter mit `modify-replication-group-shard-configuration`.

**Parameters**
+ `--apply-immediately` – Erforderlich. Gibt an, dass die Shard-Rekonfigurationsoperation sofort gestartet werden soll.
+ `--replication-group-id` – Erforderlich. Gibt an, für welche Replikationsgruppe (Cluster) die Shard-Rekonfigurationsoperation ausgeführt werden soll.
+ `--node-group-count` – Erforderlich. Gibt die Anzahl der Shards (Knotengruppen) an, die nach Abschluss des Vorgangs vorhanden sein müssen. Beim Entfernen von Shards muss der Wert von `--node-group-count` kleiner als die aktuelle Anzahl von Shards sein.

  
+ `--node-groups-to-remove`Erforderlich, wenn `--node-group-count` kleiner als die aktuelle Anzahl der Knotengruppen (Shards) ist. Eine Liste von Shards (Knotengruppe), die aus der Replikationsgruppe entfernt IDs werden sollen.

Das folgende Verfahren beschreibt den Vorgang zum Löschen eines oder mehrerer Shards.

**Example - Entfernen von Shards**  
Im folgenden Beispiel werden zwei Knotengruppen aus dem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) entfernt`my-cluster`, sodass nach Abschluss des Vorgangs insgesamt zwei Knotengruppen vorhanden sind. Die Keyspaces der entfernten Shards werden gleichmäßig auf die verbleibenden Shards verteilt.  
Für Linux, macOS oder Unix:  

```
aws elasticache modify-replication-group-shard-configuration \
    --replication-group-id my-cluster \
    --node-group-count 2 \
    --node-groups-to-remove "0002" "0003" \
    --apply-immediately
```
Für Windows:  

```
aws elasticache modify-replication-group-shard-configuration ^
    --replication-group-id my-cluster ^
    --node-group-count 2 ^
    --node-groups-to-remove "0002" "0003" ^
    --apply-immediately
```

#### Shards entfernen (API) ElastiCache
<a name="redis-cluster-resharding-online-remove-api"></a>

Sie können die ElastiCache API verwenden, um die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) online neu zu konfigurieren, indem Sie den Vorgang verwenden. `ModifyReplicationGroupShardConfiguration`

Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) neu konfigurieren, indem Sie Shards mithilfe der API entfernen. ElastiCache 

**Wichtig**  
Bevor Sie Knotengruppen (Shards) aus Ihrer Replikationsgruppe entfernen, stellen Sie sicher, ElastiCache dass alle Ihre Daten in die verbleibenden Shards passen. Wenn die Daten passen, werden die angegebenen Shards (`NodeGroupsToRemove`) wie angefordert aus der Replikationsgruppe gelöscht und ihre Keyspaces den verbleibenden Shards zugeordnet. Wenn die Daten nicht in die verbleibenden Knotengruppen passen, wird der Prozess beendet und die Replikationsgruppe hat dieselbe Knotengruppenkonfiguration wie vor dem Zeitpunkt, an dem die Anforderung erstellt wurde.

Sie können die ElastiCache API verwenden, um einen oder mehrere Shards aus Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) zu entfernen. Sie können nicht alle Shards in einer Replikationsgruppe entfernen. Stattdessen müssen Sie die Replikationsgruppe löschen. Weitere Informationen finden Sie unter [Löschen einer Replikationsgruppe](Replication.DeletingRepGroup.md).

Verwenden Sie die folgenden Parameter mit `ModifyReplicationGroupShardConfiguration`.

**Parameters**
+ `ApplyImmediately=true` – Erforderlich. Gibt an, dass die Shard-Rekonfigurationsoperation sofort gestartet werden soll.
+ `ReplicationGroupId` – Erforderlich. Gibt an, für welche Replikationsgruppe (Cluster) die Shard-Rekonfigurationsoperation ausgeführt werden soll.
+ `NodeGroupCount` – Erforderlich. Gibt die Anzahl der Shards (Knotengruppen) an, die nach Abschluss des Vorgangs vorhanden sein müssen. Beim Entfernen von Shards muss der Wert von `NodeGroupCount` kleiner als die aktuelle Anzahl von Shards sein.
+ `NodeGroupsToRemove`Erforderlich, wenn `--node-group-count` kleiner als die aktuelle Anzahl der Knotengruppen (Shards) ist. Eine Liste von Shards (Knotengruppe), die aus der Replikationsgruppe entfernt IDs werden sollen.

Das folgende Verfahren beschreibt den Vorgang zum Löschen eines oder mehrerer Shards.

**Example - Entfernen von Shards**  
Im folgenden Beispiel werden zwei Knotengruppen aus dem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) entfernt`my-cluster`, sodass nach Abschluss des Vorgangs insgesamt zwei Knotengruppen vorhanden sind. Die Keyspaces der entfernten Shards werden gleichmäßig auf die verbleibenden Shards verteilt.  

```
https://elasticache.us-east-2.amazonaws.com/
    ?Action=ModifyReplicationGroupShardConfiguration
    &ApplyImmediately=true
    &NodeGroupCount=2
    &ReplicationGroupId=my-cluster
    &NodeGroupsToRemove.member.1=0002
    &NodeGroupsToRemove.member.2=0003
    &Version=2015-02-02
    &SignatureVersion=4
    &SignatureMethod=HmacSHA256
    &Timestamp=20171002T192317Z
    &X-Amz-Credential=<credential>
```

### Online-Shard-Rebalancing
<a name="redis-cluster-resharding-online-rebalance"></a>

Sie können Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) mithilfe der API, oder neu verteilen.AWS-ManagementkonsoleAWS CLI ElastiCache 

**Topics**
+ [Online-Shard-Rebalancing (Console)](#redis-cluster-resharding-online-rebalance-console)
+ [Online-Shard-Rebalancing (AWS CLI)](#redis-cluster-resharding-online-rebalance-cli)
+ [Online-Shard-Rebalancing (API) ElastiCache](#redis-cluster-resharding-online-rebalance-api)

#### Online-Shard-Rebalancing (Console)
<a name="redis-cluster-resharding-online-rebalance-console"></a>

Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) neu konfigurieren, indem Sie die Shards mithilfe von neu verteilen.AWS-Managementkonsole

**Um die Schlüsselräume zwischen den Shards auf Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) neu auszurichten**

1. Ö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.

1. Wählen Sie den Namen des Valkey- oder Redis OSS-Clusters (Clustermodus aktiviert), den Sie neu verteilen möchten, und nicht das Feld links neben dem Namen.
**Tipp**  
**Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) haben in der Spalte Shards einen Wert von 1 oder höher.**

1. Wählen Sie **Rebalance** aus.

1. Wählen Sie nach Aufforderung die Option **Rebalance** aus. Möglicherweise wird eine Meldung ähnlich der folgenden angezeigt:. *Slots in the replication group are uniformly distributed. Nothing to do. (Service: AmazonElastiCache; Status Code: 400; Error Code: InvalidReplicationGroupState; Request ID: 2246cebd-9721-11e7-8d5b-e1b0f086c8cf)* Wählen Sie **Cancel** wenn Sie das tun.

#### Online-Shard-Rebalancing (AWS CLI)
<a name="redis-cluster-resharding-online-rebalance-cli"></a>

Verwenden Sie die folgenden Parameter mit `modify-replication-group-shard-configuration`.

**Parameters**
+ `-apply-immediately` – Erforderlich. Gibt an, dass die Shard-Rekonfigurationsoperation sofort gestartet werden soll.
+ `--replication-group-id` – Erforderlich. Gibt an, für welche Replikationsgruppe (Cluster) die Shard-Rekonfigurationsoperation ausgeführt werden soll.
+ `--node-group-count` – Erforderlich. Um die Keyspaces über alle Shards im Cluster neu zu verteilen, muss dieser Wert der aktuellen Anzahl von Shards entsprechen.

Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) neu konfigurieren, indem Sie die Shards mithilfe von neu verteilen.AWS CLI

**Example - Ausgleichen der Shards in einem Cluster**  
Im folgenden Beispiel werden die Steckplätze im Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) neu verteilt, sodass die Steckplätze `my-cluster` so gleichmäßig wie möglich verteilt werden. Der Wert von `--node-group-count` (`4`) ist die Anzahl der derzeit im Cluster befindlichen Shards.  
Für Linux, macOS oder Unix:  

```
aws elasticache modify-replication-group-shard-configuration \
    --replication-group-id my-cluster \
    --node-group-count 4 \
    --apply-immediately
```
Für Windows:  

```
aws elasticache modify-replication-group-shard-configuration ^
    --replication-group-id my-cluster ^
    --node-group-count 4 ^
    --apply-immediately
```

#### Online-Shard-Rebalancing (API) ElastiCache
<a name="redis-cluster-resharding-online-rebalance-api"></a>

Sie können die ElastiCache API verwenden, um die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) online neu zu konfigurieren, indem Sie den Vorgang verwenden. `ModifyReplicationGroupShardConfiguration`

Verwenden Sie die folgenden Parameter mit `ModifyReplicationGroupShardConfiguration`.

**Parameters**
+ `ApplyImmediately=true` – Erforderlich. Gibt an, dass die Shard-Rekonfigurationsoperation sofort gestartet werden soll.
+ `ReplicationGroupId` – Erforderlich. Gibt an, für welche Replikationsgruppe (Cluster) die Shard-Rekonfigurationsoperation ausgeführt werden soll.
+ `NodeGroupCount` – Erforderlich. Um die Keyspaces über alle Shards im Cluster neu zu verteilen, muss dieser Wert der aktuellen Anzahl von Shards entsprechen.

Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) neu konfigurieren, indem Sie die Shards mithilfe der API neu verteilen. ElastiCache 

**Example - Cluster-Ausgleich**  
Im folgenden Beispiel werden die Steckplätze im Valkey- oder Redis OSS-Cluster (Clustermodus aktiviert) neu verteilt, sodass die Steckplätze `my-cluster` so gleichmäßig wie möglich verteilt werden. Der Wert von `NodeGroupCount` (`4`) ist die Anzahl der derzeit im Cluster befindlichen Shards.  

```
https://elasticache.us-east-2.amazonaws.com/
    ?Action=ModifyReplicationGroupShardConfiguration
    &ApplyImmediately=true
    &NodeGroupCount=4
    &ReplicationGroupId=my-cluster
    &Version=2015-02-02
    &SignatureVersion=4
    &SignatureMethod=HmacSHA256
    &Timestamp=20171002T192317Z
    &X-Amz-Credential=<credential>
```

# Vertikales Online-Skalieren durch Ändern des Knotentyps
<a name="redis-cluster-vertical-scaling"></a>

Durch die Verwendung der vertikalen Online-Skalierung mit Valkey Version 7.2 oder neuer oder Redis OSS Version 3.2.10 oder neuer können Sie Ihre Valkey- oder Redis OSS-Cluster dynamisch mit minimalen Ausfallzeiten skalieren. Dadurch kann Ihr Valkey- oder Redis OSS-Cluster Anfragen auch während der Skalierung bearbeiten.

**Anmerkung**  
Die Skalierung zwischen einem Cluster mit Daten-Tiering (z. B. ein Cluster, der einen R6gd-Knotentyp verwendet) und einem Cluster ohne Daten-Tiering (z. B. ein Cluster, der einen R6g-Knotentyp verwendet) wird nicht unterstützt. Weitere Informationen finden Sie unter [Datenzuweisung ElastiCache](data-tiering.md).

Sie haben die folgenden Möglichkeiten:
+ **Skalieren** — Erhöhen Sie die Lese- und Schreibkapazität, indem Sie den Knotentyp Ihres Valkey- oder Redis OSS-Clusters so anpassen, dass ein größerer Knotentyp verwendet wird.

  ElastiCache passt die Größe Ihres Clusters dynamisch an, bleibt aber online und bearbeitet Anfragen.
+ **Herunterskalierung** – Verringern Sie die Lese- und Schreibkapazität, indem Sie den Knotentyp auf die Verwendung eines kleineren Knotens anpassen. Auch hier wird die Größe Ihres Clusters ElastiCache dynamisch angepasst, während er online bleibt und Anfragen bearbeitet. In diesem Fall verringern Sie die Kosten durch die Verkleinerung des Knotens.

**Anmerkung**  
Aufwärts- und Abwärtsskalieren basiert auf der Erstellung von neu ausgewählten Knotentypen und der Synchronisierung der neuen Knoten mit den vorherigen. Gehen Sie wie folgt vor, um einen reibungslosen up/down Ablauf der Skalierung sicherzustellen:  
Stellen Sie Sicher, dass die Elastic Network-Schnittstelle (ENI) über ausreichend Kapazität verfügt. Vergewissern Sie sich beim Abwärtsskalieren, dass der kleinere Knoten über ausreichend Speicher für erwarteten Datenverkehr verfügt.   
Erfahren Sie mehr über bewährte Methoden für die Speicherverwaltung unter [Verwaltung von reserviertem Speicher für Valkey und Redis OSS](redis-memory-management.md). 
Während die vertikale Skalierung ausgelegt ist, vollständig online zu bleiben, basiert sie auf der Synchronisierung von Daten zwischen dem alten und dem neuen Knoten. Wir empfehlen, dass Sie Abwärts-/Aufwärtsskalieren zu einem Zeitpunkt durchführen, an dem der Datenverkehr am geringsten ist. 
Testen Sie das Verhalten Ihrer Anwendung während der Skalierung möglichst in einer Staging-Umgebung. 

**Contents**
+ [Online-aufwärtsskalieren](#redis-cluster-vertical-scaling-scaling-up)
  + [Skalierung von Valkey- oder Redis OSS-Clustern (Konsole)](#redis-cluster-vertical-scaling-console)
  + [Skalierung von Valkey- oder Redis OSS-Clustern ()AWS CLI](#Scaling.RedisStandalone.ScaleUp.CLI)
  + [Skalierung von Valkey- oder Redis OSS-Clustern (API) ElastiCache](#VeticalScaling.RedisReplGrps.ScaleUp.API)
+ [Online-abwärtsskalieren](#redis-cluster-vertical-scaling-scaling-down)
  + [Herunterskalierung von Valkey- oder Redis OSS-Clustern (Konsole)](#redis-cluster-vertical-scaling-down-console)
  + [Herunterskalieren von Valkey- oder Redis OSS-Clustern ()AWS CLI](#Scaling.RedisStandalone.ScaleDown.CLI)
  + [Herunterskalierung der Valkey- oder Redis OSS-Cluster (API) ElastiCache](#Scaling.Vertical.ScaleDown.API)

## Online-aufwärtsskalieren
<a name="redis-cluster-vertical-scaling-scaling-up"></a>

**Topics**
+ [Skalierung von Valkey- oder Redis OSS-Clustern (Konsole)](#redis-cluster-vertical-scaling-console)
+ [Skalierung von Valkey- oder Redis OSS-Clustern ()AWS CLI](#Scaling.RedisStandalone.ScaleUp.CLI)
+ [Skalierung von Valkey- oder Redis OSS-Clustern (API) ElastiCache](#VeticalScaling.RedisReplGrps.ScaleUp.API)

### Skalierung von Valkey- oder Redis OSS-Clustern (Konsole)
<a name="redis-cluster-vertical-scaling-console"></a>

Das folgende Verfahren beschreibt, wie Sie einen Valkey- oder Redis-OSS-Cluster mithilfe der ElastiCache Management Console skalieren. Während dieses Vorgangs bearbeitet Ihr Cluster weiterhin Anfragen mit minimaler Ausfallzeit.

**Um einen Valkey- oder Redis OSS-Cluster (Konsole) zu skalieren**

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.

1. Wählen Sie aus der Liste der Cluster den Cluster aus. 

1. Wählen Sie **Ändern** aus.

1. Gehen Sie im **Modify Cluster**-Assistenten wie folgt vor:

   1. Wählen Sie in der Liste **Node type** den Knotentyp aus, auf den Sie skalieren möchten. Wählen Sie zur Aufwärtsskalierung einen Knotentyp, der größer als Ihr bestehender Knoten ist. 

1. Wenn Sie die Aufwärtsskalierung sofort starten möchten, aktivieren Sie das Kontrollkästchen **Apply immediately**. Wenn Sie das Kontrollkästchen für **Apply immediately** nicht aktivieren, wird die Skalierung während des nächsten Wartungsfensters des Clusters durchgeführt.

1. Wählen Sie **Ändern** aus.

   Wenn Sie im vorherigen Schritt **Apply immediately** aktiviert haben, ändert sich der Cluster-Status zu *modifying*. Wenn der Status zu *available* wechselt, ist die Änderung abgeschlossen und Sie können den neuen Cluster verwenden.

### Skalierung von Valkey- oder Redis OSS-Clustern ()AWS CLI
<a name="Scaling.RedisStandalone.ScaleUp.CLI"></a>

Das folgende Verfahren beschreibt, wie Sie einen Valkey- oder Redis-OSS-Cluster mithilfe von skalieren.AWS CLI Während dieses Vorgangs bearbeitet Ihr Cluster weiterhin Anfragen mit minimaler Ausfallzeit.

**Um einen Valkey- oder Redis OSS-Cluster zu skalieren ()AWS CLI**

1. Ermitteln Sie die Knotentypen, auf die Sie skalieren können, indem Sie den AWS CLI`list-allowed-node-type-modifications` Befehl mit dem folgenden Parameter ausführen.

   Für Linux, macOS oder Unix:

   ```
   aws elasticache list-allowed-node-type-modifications \
   	    --replication-group-id my-replication-group-id
   ```

   Für Windows:

   ```
   aws elasticache list-allowed-node-type-modifications ^
   	    --replication-group-id my-replication-group-id
   ```

   Die Ausgabe des obigen Befehls sieht in etwa folgendermaßen aus (JSON format).

   ```
   {
   	    "ScaleUpModifications": [
   	        "cache.m3.2xlarge", 
   	        "cache.m3.large", 
   	        "cache.m3.xlarge", 
   	        "cache.m4.10xlarge", 
   	        "cache.m4.2xlarge", 
   	        "cache.m4.4xlarge", 
   	        "cache.m4.large", 
   	        "cache.m4.xlarge", 
   	        "cache.r3.2xlarge", 
   	        "cache.r3.4xlarge", 
   	        "cache.r3.8xlarge", 
   	        "cache.r3.large", 
   	        "cache.r3.xlarge"
   	    ]
   	       "ScaleDownModifications": [
   	        "cache.t2.micro", 
   	        "cache.t2.small ", 
   	        "cache.t2.medium",
   	       	"cache.t1.small "
   	    ], 
   }
   ```

   Weitere Informationen finden Sie unter [list-allowed-node-type-modifications](https://docs.aws.amazon.com/cli/latest/reference/elasticache/list-allowed-node-type-modifications.html) in der *AWS CLI-Referenz*.

1. Ändern Sie Ihre Replikationsgruppe mithilfe des AWS CLI`modify-replication-group` Befehls und der folgenden Parameter, sodass sie auf den neuen, größeren Knotentyp skaliert werden kann.
   + `--replication-group-id` Der Name der zu erstellenden Replikationsgruppe, zu der Sie aufwärtsskalieren. 
   + `--cache-node-type`— Der neue Knotentyp, für den Sie den Cluster skalieren möchten. Der Wert muss einer der Knotentypen sein, die in Schritt 1 mit dem Befehl `list-allowed-node-type-modifications` zurückgegeben wurden.
   + `--cache-parameter-group-name` – [Optional) Verwenden Sie diesen Parameter, wenn Sie `reserved-memory` verwenden, um Speicher für den Cluster zu reservieren. Geben Sie eine benutzerdefinierte Cache-Parametergruppe an, die die korrekte Speichermenge für den neuen Knotentyp reserviert. Wenn Sie `reserved-memory-percent` verwenden, können Sie diesen Parameter weglassen.
   + `--apply-immediately` – Führt die Skalierung sofort aus. Wenn Sie die Skalierung für das nächste Wartungsfenster des Clusters planen möchten, verwenden Sie den Parameter `--no-apply-immediately`.

   Für Linux, macOS oder Unix:

   ```
   aws elasticache modify-replication-group  \
   	    --replication-group-id my-redis-cluster \
   	    --cache-node-type cache.m3.xlarge \	    
   	    --apply-immediately
   ```

   Für Windows:

   ```
   aws elasticache modify-replication-group ^
   	    --replication-group-id my-redis-cluster ^
   	    --cache-node-type cache.m3.xlarge ^	   
   	    --apply-immediately
   ```

   Die Ausgabe des obigen Befehls sieht in etwa folgendermaßen aus (JSON format).

   ```
   {
   		"ReplicationGroup": {
           "Status": "modifying",
           "Description": "my-redis-cluster",
           "NodeGroups": [
               {
                   "Status": "modifying",
                   "Slots": "0-16383",
                   "NodeGroupId": "0001",
                   "NodeGroupMembers": [
                       {
                           "PreferredAvailabilityZone": "us-east-1f",
                           "CacheNodeId": "0001",
                           "CacheClusterId": "my-redis-cluster-0001-001"
                       },
                       {
                           "PreferredAvailabilityZone": "us-east-1d",
                           "CacheNodeId": "0001",
                           "CacheClusterId": "my-redis-cluster-0001-002"
                       }
                   ]
               }
           ],
           "ConfigurationEndpoint": {
               "Port": 6379,
               "Address": "my-redis-cluster.r7gdfi.clustercfg.use1.cache.amazonaws.com"
           },
           "ClusterEnabled": true,
           "ReplicationGroupId": "my-redis-cluster",
           "SnapshotRetentionLimit": 1,
           "AutomaticFailover": "enabled",
           "SnapshotWindow": "07:30-08:30",
           "MemberClusters": [
               "my-redis-cluster-0001-001",
               "my-redis-cluster-0001-002"
           ],
           "CacheNodeType": "cache.m3.xlarge",
            "DataTiering": "disabled"
           "PendingModifiedValues": {}
       }
   }
   ```

   Weitere Informationen finden Sie unter [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html) in der *AWS CLI-Referenz*.

1. Wenn Sie den verwendet haben`--apply-immediately`, überprüfen Sie den Status des Clusters mithilfe des AWS CLI`describe-cache-clusters` Befehls mit dem folgenden Parameter. Wenn sich der Status auf *verfügbar* ändert, können Sie mit der Verwendung des neuen, größeren Clusterknotens beginnen.

### Skalierung von Valkey- oder Redis OSS-Clustern (API) ElastiCache
<a name="VeticalScaling.RedisReplGrps.ScaleUp.API"></a>

Der folgende Prozess skaliert Ihren Cluster mithilfe der API von seinem aktuellen Knotentyp auf einen neuen, größeren Knotentyp. ElastiCache Während dieses Vorgangs werden die DNS-Einträge ElastiCache aktualisiert, sodass sie auf die neuen Knoten verweisen. Daher müssen Sie die Endpunkte in Ihrer Anwendung nicht aktualisieren. Für Valkey 7.2 und höher, Redis OSS 5.0.5 und höher, können Sie Cluster mit auto Failover skalieren, während der Cluster weiterhin online bleibt und eingehende Anfragen bearbeitet. Bei Version Redis OSS 4.0.10 und niedriger stellen Sie möglicherweise eine kurze Unterbrechung der Lese- und Schreibvorgänge auf früheren Versionen vom Primärknoten aus fest, während der DNS-Eintrag aktualisiert wird.

Die Zeit, die für die Skalierung auf einen größeren Knotentyp benötigt wird, hängt von Ihrem Knotentyp und der Datenmenge in Ihrem aktuellen Cluster ab.

**So skalieren Sie einen Valkey- oder Redis OSS-Cache-Cluster (API) ElastiCache**

1. Ermitteln Sie, auf welche Knotentypen Sie mithilfe der ElastiCache `ListAllowedNodeTypeModifications` API-Aktion mit dem folgenden Parameter skalieren können.
   + `ReplicationGroupId`  der Name der Replikationsgruppe. Verwenden Sie diesen Parameter, um eine bestimmte Replikationsgruppe zu beschreiben, statt alle Replikationsgruppen anzugeben.

   ```
   https://elasticache.us-west-2.amazonaws.com/
   	   ?Action=ListAllowedNodeTypeModifications
   	   &ReplicationGroupId=MyReplGroup
   	   &Version=2015-02-02
   	   &SignatureVersion=4
   	   &SignatureMethod=HmacSHA256
   	   &Timestamp=20150202T192317Z
   	   &X-Amz-Credential=<credential>
   ```

   Weitere Informationen finden Sie [ListAllowedNodeTypeModifications](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ListAllowedNodeTypeModifications.html) in der *Amazon ElastiCache API-Referenz*.

1. Skalieren Sie Ihre aktuelle Replikationsgruppe mithilfe der `ModifyReplicationGroup` ElastiCache API-Aktion und mit den folgenden Parametern auf den neuen Knotentyp.
   + `ReplicationGroupId`  der Name der Replikationsgruppe.
   + `CacheNodeType`— der neue, größere Knotentyp der Cluster in dieser Replikationsgruppe. Dieser Wert muss einer der Instance-Typen sein, die von der `ListAllowedNodeTypeModifications` Aktion im vorherigen Schritt zurückgegeben wurden.
   + `CacheParameterGroupName` – [Optional) Verwenden Sie diesen Parameter, wenn Sie `reserved-memory` verwenden, um Speicher für den Cluster zu reservieren. Geben Sie eine benutzerdefinierte Cache-Parametergruppe an, die die korrekte Speichermenge für den neuen Knotentyp reserviert. Wenn Sie `reserved-memory-percent` verwenden, können Sie diesen Parameter weglassen.
   + `ApplyImmediately`Legen Sie `true` fest, um die Skalierung sofort auszuführen. Wenn Sie die Skalierung für das nächste Wartungsfenster planen möchten, verwenden Sie `ApplyImmediately``=false`.

   ```
   https://elasticache.us-west-2.amazonaws.com/
   	   ?Action=ModifyReplicationGroup
   	   &ApplyImmediately=true
   	   &CacheNodeType=cache.m3.2xlarge
   	   &CacheParameterGroupName=redis32-m3-2xl
   	   &ReplicationGroupId=myReplGroup
   	   &SignatureVersion=4
   	   &SignatureMethod=HmacSHA256
   	   &Timestamp=20141201T220302Z
   	   &Version=2014-12-01
   	   &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
   	   &X-Amz-Date=20141201T220302Z
   	   &X-Amz-SignedHeaders=Host
   	   &X-Amz-Expires=20141201T220302Z
   	   &X-Amz-Credential=<credential>
   	   &X-Amz-Signature=<signature>
   ```

   Weitere Informationen finden Sie [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html) in der *Amazon ElastiCache API-Referenz*.

1. Falls Sie dies verwendet haben `ApplyImmediately``=true`, überwachen Sie den Status der Replikationsgruppe mithilfe der ElastiCache `DescribeReplicationGroups` API-Aktion mit den folgenden Parametern. Wenn der Status von *modifying* zu *available* wechselt, können Sie die neue, aufskalierte Replikationsgruppe verwenden.
   + `ReplicationGroupId`  der Name der Replikationsgruppe. Verwenden Sie diesen Parameter, um eine bestimmte Replikationsgruppe zu beschreiben, statt alle Replikationsgruppen anzugeben.

   ```
   https://elasticache.us-west-2.amazonaws.com/
   	   ?Action=DescribeReplicationGroups
   	   &ReplicationGroupId=MyReplGroup
   	   &Version=2015-02-02
   	   &SignatureVersion=4
   	   &SignatureMethod=HmacSHA256
   	   &Timestamp=20150202T192317Z
   	   &X-Amz-Credential=<credential>
   ```

   Weitere Informationen finden Sie [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html) in der *Amazon ElastiCache API-Referenz*.

## Online-abwärtsskalieren
<a name="redis-cluster-vertical-scaling-scaling-down"></a>

**Topics**
+ [Herunterskalierung von Valkey- oder Redis OSS-Clustern (Konsole)](#redis-cluster-vertical-scaling-down-console)
+ [Herunterskalieren von Valkey- oder Redis OSS-Clustern ()AWS CLI](#Scaling.RedisStandalone.ScaleDown.CLI)
+ [Herunterskalierung der Valkey- oder Redis OSS-Cluster (API) ElastiCache](#Scaling.Vertical.ScaleDown.API)

### Herunterskalierung von Valkey- oder Redis OSS-Clustern (Konsole)
<a name="redis-cluster-vertical-scaling-down-console"></a>

Das folgende Verfahren beschreibt, wie Sie einen Valkey- oder Redis-OSS-Cluster mithilfe der ElastiCache Management Console herunterskalieren. Während dieses Vorgangs bearbeitet Ihr Valkey- oder Redis OSS-Cluster weiterhin Anfragen mit minimaler Ausfallzeit.

**Um einen Valkey- oder Redis OSS-Cluster herunterzuskalieren (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 **Valkey-Cluster** oder **Redis OSS-Cluster** aus.

1. Wählen Sie aus der Liste der Cluster Ihren bevorzugten Cluster. 

1. Wählen Sie **Ändern** aus.

1. Gehen Sie im **Modify Cluster**-Assistenten wie folgt vor:

   1. Wählen Sie in der Liste **Node type** den Knotentyp aus, auf den Sie skalieren möchten. Wählen Sie zur Abwärtsskalierung einen Knotentyp, der kleiner als Ihr bestehender Knoten ist. Beachten Sie, dass nicht alle Knotentypen für das Herunterskalieren zur Verfügung stehen.

1. Wenn Sie die Abwärtsskalierung sofort starten möchten, aktivieren Sie das Kontrollkästchen **Apply immediately**. Wenn Sie das Kontrollkästchen für **Apply immediately** nicht aktivieren, wird die Abwärtsskalierung während des nächsten Wartungsfensters des Clusters durchgeführt.

1. Wählen Sie **Ändern** aus.

   Wenn Sie im vorherigen Schritt **Apply immediately** aktiviert haben, ändert sich der Cluster-Status zu *modifying*. Wenn der Status zu *available* wechselt, ist die Änderung abgeschlossen und Sie können den neuen Cluster verwenden.

### Herunterskalieren von Valkey- oder Redis OSS-Clustern ()AWS CLI
<a name="Scaling.RedisStandalone.ScaleDown.CLI"></a>

Das folgende Verfahren beschreibt, wie Sie einen Valkey- oder Redis-OSS-Cluster mithilfe von herunterskalieren.AWS CLI Während dieses Vorgangs bearbeitet Ihr Cluster weiterhin Anfragen mit minimaler Ausfallzeit.

**Um einen Valkey- oder Redis OSS-Cluster herunterzuskalieren ()AWS CLI**

1. Ermitteln Sie die Knotentypen, auf die Sie herunterskalieren können, indem Sie den AWS CLI`list-allowed-node-type-modifications` Befehl mit dem folgenden Parameter ausführen.

   Für Linux, macOS oder Unix:

   ```
   aws elasticache list-allowed-node-type-modifications \
   	    --replication-group-id my-replication-group-id
   ```

   Für Windows:

   ```
   aws elasticache list-allowed-node-type-modifications ^
   	    --replication-group-id my-replication-group-id
   ```

   Die Ausgabe des obigen Befehls sieht in etwa folgendermaßen aus (JSON format).

   ```
   {
   	    "ScaleUpModifications": [
   	        "cache.m3.2xlarge", 
   	        "cache.m3.large", 
   	        "cache.m3.xlarge", 
   	        "cache.m4.10xlarge", 
   	        "cache.m4.2xlarge", 
   	        "cache.m4.4xlarge", 
   	        "cache.m4.large", 
   	        "cache.m4.xlarge", 
   	        "cache.r3.2xlarge", 
   	        "cache.r3.4xlarge", 
   	        "cache.r3.8xlarge", 
   	        "cache.r3.large", 
   	        "cache.r3.xlarge"
   	    ]
   	
   	       "ScaleDownModifications": [
   	        "cache.t2.micro", 
   	        "cache.t2.small ", 
   	        "cache.t2.medium ",
     	      "cache.t1.small"
   	    ]
   }
   ```

   Weitere Informationen finden Sie unter [list-allowed-node-type-modifications](https://docs.aws.amazon.com/cli/latest/reference/elasticache/list-allowed-node-type-modifications.html) in der *AWS CLI-Referenz*.

1. Ändern Sie Ihre Replikationsgruppe mithilfe des AWS CLI`modify-replication-group` Befehls und der folgenden Parameter, sodass sie auf den neuen, kleineren Knotentyp herunterskaliert wird.
   + `--replication-group-id` Der Name der Replikationsgruppe, zu der Sie abwärtsskalieren. 
   + `--cache-node-type`— Der neue Knotentyp, für den Sie den Cluster skalieren möchten. Der Wert muss einer der Knotentypen sein, die in Schritt 1 mit dem Befehl `list-allowed-node-type-modifications` zurückgegeben wurden.
   + `--cache-parameter-group-name` – [Optional) Verwenden Sie diesen Parameter, wenn Sie `reserved-memory` verwenden, um Speicher für den Cluster zu reservieren. Geben Sie eine benutzerdefinierte Cache-Parametergruppe an, die die korrekte Speichermenge für den neuen Knotentyp reserviert. Wenn Sie `reserved-memory-percent` verwenden, können Sie diesen Parameter weglassen.
   + `--apply-immediately` – Führt die Skalierung sofort aus. Wenn Sie die Skalierung für das nächste Wartungsfenster des Clusters planen möchten, verwenden Sie den Parameter `--no-apply-immediately`.

   Für Linux, macOS oder Unix:

   ```
   aws elasticache modify-replication-group  \
   	    --replication-group-id my-redis-cluster \
   	    --cache-node-type cache.t2.micro \	    
   	    --apply-immediately
   ```

   Für Windows:

   ```
   aws elasticache modify-replication-group ^
   	    --replication-group-id my-redis-cluster ^
   	    --cache-node-type cache.t2.micro ^	   
   	    --apply-immediately
   ```

   Die Ausgabe des obigen Befehls sieht in etwa folgendermaßen aus (JSON format).

   ```
   {	
   		"ReplicationGroup": {
           "Status": "modifying",
           "Description": "my-redis-cluster",
           "NodeGroups": [
               {
                   "Status": "modifying",
                   "Slots": "0-16383",
                   "NodeGroupId": "0001",
                   "NodeGroupMembers": [
                       {
                           "PreferredAvailabilityZone": "us-east-1f",
                           "CacheNodeId": "0001",
                           "CacheClusterId": "my-redis-cluster-0001-001"
                       },
                       {
                           "PreferredAvailabilityZone": "us-east-1d",
                           "CacheNodeId": "0001",
                           "CacheClusterId": "my-redis-cluster-0001-002"
                       }
                   ]
               }
           ],
           "ConfigurationEndpoint": {
               "Port": 6379,
               "Address": "my-redis-cluster.r7gdfi.clustercfg.use1.cache.amazonaws.com"
           },
           "ClusterEnabled": true,
           "ReplicationGroupId": "my-redis-cluster",
           "SnapshotRetentionLimit": 1,
           "AutomaticFailover": "enabled",
           "SnapshotWindow": "07:30-08:30",
           "MemberClusters": [
               "my-redis-cluster-0001-001",
               "my-redis-cluster-0001-002"
           ],
           "CacheNodeType": "cache.t2.micro",
            "DataTiering": "disabled"
           "PendingModifiedValues": {}
       }
   }
   ```

   Weitere Informationen finden Sie unter [modify-replication-group](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-replication-group.html) in der *AWS CLI-Referenz*.

1. Wenn Sie den verwendet haben`--apply-immediately`, überprüfen Sie den Status des Clusters mithilfe des AWS CLI`describe-cache-clusters` Befehls mit dem folgenden Parameter. Wenn sich der Status auf *verfügbar* ändert, können Sie mit der Verwendung des neuen, kleineren Clusterknotens beginnen.

### Herunterskalierung der Valkey- oder Redis OSS-Cluster (API) ElastiCache
<a name="Scaling.Vertical.ScaleDown.API"></a>

Mit dem folgenden Prozess wird Ihre Replikationsgruppe mithilfe der API vom aktuellen Knotentyp auf einen neuen, kleineren Knotentyp skaliert. ElastiCache Während dieses Vorgangs bearbeitet Ihr Valkey- oder Redis OSS-Cluster weiterhin Anfragen mit minimaler Ausfallzeit.

Die Zeit, die benötigt wird, um auf einen kleineren Knotentyp herunterzuskalieren, hängt von Ihrem Knotentyp und der Datenmenge in Ihrem aktuellen Cluster ab.

**Herunterskalierung (ElastiCache API)**

1. Ermitteln Sie, auf welche Knotentypen Sie mithilfe der ElastiCache `ListAllowedNodeTypeModifications` API-Aktion mit dem folgenden Parameter herunterskalieren können.
   + `ReplicationGroupId`  der Name der Replikationsgruppe. Verwenden Sie diesen Parameter, um eine bestimmte Replikationsgruppe zu beschreiben, statt alle Replikationsgruppen anzugeben.

   ```
   https://elasticache.us-west-2.amazonaws.com/
   	   ?Action=ListAllowedNodeTypeModifications
   	   &ReplicationGroupId=MyReplGroup
   	   &Version=2015-02-02
   	   &SignatureVersion=4
   	   &SignatureMethod=HmacSHA256
   	   &Timestamp=20150202T192317Z
   	   &X-Amz-Credential=<credential>
   ```

   Weitere Informationen finden Sie [ListAllowedNodeTypeModifications](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ListAllowedNodeTypeModifications.html) in der *Amazon ElastiCache API-Referenz*.

1. Skalieren Sie Ihre aktuelle Replikationsgruppe mithilfe der `ModifyReplicationGroup` ElastiCache API-Aktion und mit den folgenden Parametern auf den neuen Knotentyp herunter.
   + `ReplicationGroupId`  der Name der Replikationsgruppe.
   + `CacheNodeType`— der neue, kleinere Knotentyp der Cluster in dieser Replikationsgruppe. Dieser Wert muss einer der Instance-Typen sein, die von der `ListAllowedNodeTypeModifications` Aktion im vorherigen Schritt zurückgegeben wurden.
   + `CacheParameterGroupName` – [Optional) Verwenden Sie diesen Parameter, wenn Sie `reserved-memory` verwenden, um Speicher für den Cluster zu reservieren. Geben Sie eine benutzerdefinierte Cache-Parametergruppe an, die die korrekte Speichermenge für den neuen Knotentyp reserviert. Wenn Sie `reserved-memory-percent` verwenden, können Sie diesen Parameter weglassen.
   + `ApplyImmediately` – Legen Sie `true` fest, um die Abwärtsskalierung sofort auszuführen. Wenn Sie die Abwärtsskalierung für das nächste Wartungsfenster planen möchten, verwenden Sie `ApplyImmediately``=false`.

   ```
   https://elasticache.us-west-2.amazonaws.com/
   	   ?Action=ModifyReplicationGroup
   	   &ApplyImmediately=true
   	   &CacheNodeType=cache.t2.micro
   	   &CacheParameterGroupName=redis32-m3-2xl
   	   &ReplicationGroupId=myReplGroup
   	   &SignatureVersion=4
   	   &SignatureMethod=HmacSHA256
   	   &Timestamp=20141201T220302Z
   	   &Version=2014-12-01
   	   &X-Amz-Algorithm=&AWS;4-HMAC-SHA256
   	   &X-Amz-Date=20141201T220302Z
   	   &X-Amz-SignedHeaders=Host
   	   &X-Amz-Expires=20141201T220302Z
   	   &X-Amz-Credential=<credential>
   	   &X-Amz-Signature=<signature>
   ```

   Weitere Informationen finden Sie [ModifyReplicationGroup](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroup.html) in der *Amazon ElastiCache API-Referenz*.