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
Die Datenmenge, die von einer Anwendung verarbeitet wird, ist selten statisch. Sie steigt und sinkt mit dem Unternehmenswachstum und unterliegt normalen Schwankungen im Bedarf. Wenn Sie Ihre Anwendungen selbst verwalten, müssen Sie ausreichend Hardware für Ihre Bedarfsspitzen bereitstellen, was teuer sein kann. Mit MemoryDB können Sie skalieren, um den aktuellen Bedarf zu decken, und zahlen nur für das, was Sie tatsächlich nutzen.
Im Folgenden finden Sie das richtige Thema für die Skalierungsaktionen, die Sie ausführen möchten.
**Skalierung von MemoryDB**
| Action | MemoryDB |
| --- | --- |
| Ausskalieren | [Online-Resharding für MemoryDB](cluster-resharding-online.md) |
| Ändern von Knotentypen | [Vertikales Online-Skalieren durch Ändern des Knotentyps](cluster-vertical-scaling.md) |
| Änderung der Anzahl der Shards | [Skalierung von MemoryDB-Clustern](scaling-cluster.md) |
# Skalierung von MemoryDB-Clustern
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 MemoryDB-Cluster ä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 Metriken überwachen: *FreeableMemory*SwapUsage**, und DB. BytesUsedForMemory*
+ **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**, *CPUUtilization*, *BytesUsedForMemoryDB *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 MemoryDB-Cluster zu skalieren: horizontale und vertikale Skalierung.
+ Mit der horizontalen Skalierung können Sie die Anzahl der Shards im Cluster ändern, indem Sie Shards hinzufügen oder entfernen. Der Online-Resharding-Prozess ermöglicht die Skalierung, in/out während der Cluster weiterhin eingehende Anfragen bearbeitet.
+ 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 Ihren Daten- und Engine-Overhead verfügt.
# Offline-Resharding für MemoryDB
Der Hauptvorteil der Offline-Shard-Rekonfiguration besteht darin, dass Sie mehr tun können, als nur Shards zu Ihrem Cluster hinzuzufügen oder daraus zu entfernen. Wenn Sie das Resharden offline durchführen, können Sie nicht nur die Anzahl der Shards in Ihrem Cluster ändern, sondern auch Folgendes tun:
+ Ändern Sie den Knotentyp Ihres Clusters.
+ Upgrade auf eine neuere Engine-Version.
**Anmerkung**
Offline-Resharding wird auf Clustern mit aktiviertem Daten-Tiering nicht unterstützt. Weitere Informationen finden Sie unter [Daten-Tiering](data-tiering.md)..
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 den MemoryDB-Cluster Ihrer Shards offline neu zu konfigurieren**
1. Erstellen Sie einen manuellen Snapshot Ihres vorhandenen MemoryDB-Clusters. Weitere Informationen finden Sie unter [Manuelle Snapshots erstellen](snapshots-manual.md).
1. Erstellen Sie einen neuen Cluster, indem Sie ihn aus dem Snapshot wiederherstellen. Weitere Informationen finden Sie unter [Wiederherstellung aus einem Snapshot](snapshots-restoring.md).
1. Aktualisieren Sie in Ihrer Anwendung die Endpunkte auf die neuen Cluster-Endpunkte. Weitere Informationen finden Sie unter [Ermitteln von Verbindungsendpunkten](endpoints.md).
# Online-Resharding für MemoryDB
Mithilfe von Online-Resharding und MemoryDB können Sie Ihre MemoryDB 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:
+ **Scale Out** — Erhöhen Sie die Lese- und Schreibkapazität, indem Sie Ihrem MemoryDB-Cluster Shards hinzufügen.
Wenn Sie Ihrem Cluster einen oder mehrere Shards hinzufügen, entspricht die Anzahl der Knoten in jedem neuen Shard der Anzahl der Knoten im kleinsten der vorhandenen Shards.
+ **Skalieren** — Reduzieren Sie die Lese- und Schreibkapazität und damit die Kosten, indem Sie Shards aus Ihrem MemoryDB-Cluster entfernen.
Derzeit gelten die folgenden Einschränkungen für MemoryDB-Online-Resharding:
+ Es gibt Einschränkungen bei Slots oder Keyspaces und großen Elementen:
Wenn einer der Schlüssel in einem Shard ein großes Objekt enthält, wird dieser Schlüssel beim Skalieren nicht auf einen neuen 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 Skalieren entspricht die Anzahl der Knoten in allen neuen Shards der Anzahl der Knoten in den vorhandenen Shards.
Weitere Informationen finden Sie unter [Bewährte Methoden: Ändern der Cluster-Größe online](best-practices-online-resharding.md).
Sie können Ihre MemoryDB-Cluster mithilfe der AWS-Managementkonsole, der und der MemoryDB-API horizontal skalieren. AWS CLI
## Hinzufügen von Shards mit Online-Resharding
Sie können Ihrem MemoryDB-Cluster mithilfe der,, oder MemoryDB-API Shards hinzufügen. AWS-Managementkonsole AWS CLI
### Hinzufügen von Shards (Konsole)
Sie können den verwenden AWS-Managementkonsole , um Ihrem MemoryDB-Cluster einen oder mehrere Shards hinzuzufügen. Das folgende Verfahren beschreibt den Prozess.
****
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Wählen Sie aus der Clusterliste den Clusternamen aus, aus dem Sie einen Shard hinzufügen möchten.
1. **Wählen Sie auf der Registerkarte **Shards and Nodes** die Option Shards hinzufügen/löschen**
1. Geben Sie im Feld **Neue Anzahl von Shards** die gewünschte Anzahl von Shards ein.
1. Wählen Sie **Bestätigen**, um die Änderungen beizubehalten, oder **Abbrechen, um sie zu verwerfen**.
### Shards hinzufügen (AWS CLI)
Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem MemoryDB-Cluster neu konfigurieren, indem Sie Shards mit dem hinzufügen. AWS CLI
Verwenden Sie die folgenden Parameter mit `update-cluster`.
**Parameters**
+ `--cluster-name` – Erforderlich. Gibt an, auf welchem Cluster (Cluster) die Shard-Rekonfigurationsoperation durchgeführt werden soll.
+ `--shard-configuration` – Erforderlich. Ermöglicht es Ihnen, die Anzahl der Shards festzulegen.
+ `ShardCount`— Legen Sie diese Eigenschaft fest, um die Anzahl der gewünschten Shards anzugeben.
**Example**
Im folgenden Beispiel wird die Anzahl der Shards im Cluster `my-cluster` auf 2 geändert.
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--shard-configuration \
ShardCount=2
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--shard-configuration ^
ShardCount=2
```
Es gibt die folgende JSON-Antwort zurück:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "updating",
"NumberOfShards": 2,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
}
```
*Verwenden Sie den folgenden Befehl, um die Details des aktualisierten Clusters anzuzeigen, sobald sich sein Status von aktuell auf *verfügbar* ändert:*
Für Linux, macOS oder Unix:
```
aws memorydb describe-clusters \
--cluster-name my-cluster
--show-shard-details
```
Für Windows:
```
aws memorydb describe-clusters ^
--cluster-name my-cluster
--show-shard-details
```
Es wird die folgende JSON-Antwort zurückgegeben:
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 2,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-8191",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
},
{
"Name": "0002",
"Status": "available",
"Slots": "8192-16383",
"Nodes": [
{
"Name": "my-cluster-0002-001",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-22T14:26:18.693000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0002-002",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-22T14:26:18.765000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
]
}
```
Weitere Informationen finden Sie unter [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) in der AWS CLI Befehlsreferenz.
### Hinzufügen von Shards (MemoryDB-API)
Sie können die MemoryDB-API verwenden, um die Shards in Ihrem MemoryDB-Cluster online neu zu konfigurieren, indem Sie den Vorgang verwenden. `UpdateCluster`
Verwenden Sie die folgenden Parameter mit `UpdateCluster`.
**Parameters**
+ `ClusterName` – Erforderlich. Gibt an, auf welchem Cluster die Shard-Rekonfiguration durchgeführt werden soll.
+ `ShardConfiguration` – Erforderlich. Ermöglicht es Ihnen, die Anzahl der Shards festzulegen.
+ `ShardCount`— Legen Sie diese Eigenschaft fest, um die Anzahl der gewünschten Shards anzugeben.
Weitere Informationen finden Sie unter [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
## Entfernen von Shards mit Online-Resharding
Sie können Shards mit der, oder MemoryDB-API aus Ihrem MemoryDB-Cluster entfernen. AWS-Managementkonsole AWS CLI
### Entfernen von Shards (Konsole)
Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem MemoryDB-Cluster neu konfigurieren, indem Sie Shards mit dem entfernen. AWS-Managementkonsole
**Wichtig**
Bevor Sie Shards aus Ihrem Cluster entfernen, stellt MemoryDB sicher, dass alle Ihre Daten in die verbleibenden Shards passen. Wenn die Daten passen, werden die Shards wie gewünscht aus dem Cluster gelöscht. Wenn die Daten nicht in die verbleibenden Shards passen, wird der Prozess beendet und der Cluster hat dieselbe Shard-Konfiguration wie vor der Anfrage.
Sie können den verwenden AWS-Managementkonsole , um einen oder mehrere Shards aus Ihrem MemoryDB-Cluster zu entfernen. Sie können nicht alle Shards in einem Cluster entfernen. Stattdessen müssen Sie den Cluster löschen. Weitere Informationen finden Sie unter [Schritt 5: Löschen eines Clusters](getting-started.md#clusters.delete). Das folgende Verfahren beschreibt den Vorgang zum Entfernen eines oder mehrerer Shards.
****
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Wählen Sie aus der Clusterliste den Clusternamen aus, aus dem Sie einen Shard entfernen möchten.
1. **Wählen Sie auf der Registerkarte **Shards and Nodes** die Option Shards hinzufügen/löschen**
1. Geben Sie im Feld **Neue Anzahl von Shards** die gewünschte Anzahl von Shards ein (mindestens 1).
1. Wählen Sie **Bestätigen**, um die Änderungen beizubehalten, oder **Abbrechen, um sie zu verwerfen**.
### Entfernen von Shards (AWS CLI)
Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem MemoryDB-Cluster neu konfigurieren, indem Sie Shards mit dem entfernen. AWS CLI
**Wichtig**
Bevor Sie Shards aus Ihrem Cluster entfernen, stellt MemoryDB sicher, dass alle Ihre Daten in die verbleibenden Shards passen. Wenn die Daten passen, werden die Shards wie gewünscht aus dem Cluster gelöscht und ihre Schlüsselräume den verbleibenden Shards zugeordnet. Wenn die Daten nicht in die verbleibenden Shards passen, wird der Vorgang beendet und der Cluster hat dieselbe Shard-Konfiguration wie vor der Anfrage.
Sie können den verwenden AWS CLI , um einen oder mehrere Shards aus Ihrem MemoryDB-Cluster zu entfernen. Sie können nicht alle Shards in einem Cluster entfernen. Stattdessen müssen Sie den Cluster löschen. Weitere Informationen finden Sie unter [Schritt 5: Löschen eines Clusters](getting-started.md#clusters.delete).
Verwenden Sie die folgenden Parameter mit `update-cluster`.
**Parameters**
+ `--cluster-name` – Erforderlich. Gibt an, auf welchem Cluster (Cluster) die Shard-Rekonfiguration ausgeführt werden soll.
+ `--shard-configuration` – Erforderlich. Ermöglicht es Ihnen, die Anzahl der Shards mithilfe der folgenden Eigenschaft festzulegen: `ShardCount`
`ShardCount`— Legen Sie diese Eigenschaft fest, um die Anzahl der gewünschten Shards anzugeben.
**Example**
Im folgenden Beispiel wird die Anzahl der Shards im Cluster `my-cluster` auf 2 geändert.
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--shard-configuration \
ShardCount=2
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--shard-configuration ^
ShardCount=2
```
Es gibt die folgende JSON-Antwort zurück:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "updating",
"NumberOfShards": 2,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
}
```
*Verwenden Sie den folgenden Befehl, um die Details des aktualisierten Clusters anzuzeigen, sobald sich sein Status von aktuell auf *verfügbar* ändert:*
Für Linux, macOS oder Unix:
```
aws memorydb describe-clusters \
--cluster-name my-cluster
--show-shard-details
```
Für Windows:
```
aws memorydb describe-clusters ^
--cluster-name my-cluster
--show-shard-details
```
Es wird die folgende JSON-Antwort zurückgegeben:
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 2,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-8191",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-21T20:22:12.405000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
},
{
"Name": "0002",
"Status": "available",
"Slots": "8192-16383",
"Nodes": [
{
"Name": "my-cluster-0002-001",
"Status": "available",
"AvailabilityZone": "us-east-1b",
"CreateTime": "2021-08-22T14:26:18.693000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0002-002",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": "2021-08-22T14:26:18.765000-07:00",
"Endpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.6",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
]
}
```
Weitere Informationen finden Sie unter [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) in der AWS CLI Befehlsreferenz.
### Shards entfernen (MemoryDB-API)
Sie können die MemoryDB-API verwenden, um die Shards in Ihrem MemoryDB-Cluster online neu zu konfigurieren, indem Sie den Vorgang verwenden. `UpdateCluster`
Der folgende Prozess beschreibt, wie Sie die Shards in Ihrem MemoryDB-Cluster neu konfigurieren, indem Sie Shards mithilfe der MemoryDB-API entfernen.
**Wichtig**
Bevor Sie Shards aus Ihrem Cluster entfernen, stellt MemoryDB sicher, dass alle Ihre Daten in die verbleibenden Shards passen. Wenn die Daten passen, werden die Shards wie gewünscht aus dem Cluster gelöscht und ihre Schlüsselräume den verbleibenden Shards zugeordnet. Wenn die Daten nicht in die verbleibenden Shards passen, wird der Vorgang beendet und der Cluster hat dieselbe Shard-Konfiguration wie vor der Anfrage.
Sie können die MemoryDB-API verwenden, um einen oder mehrere Shards aus Ihrem MemoryDB-Cluster zu entfernen. Sie können nicht alle Shards in einem Cluster entfernen. Stattdessen müssen Sie den Cluster löschen. Weitere Informationen finden Sie unter [Schritt 5: Löschen eines Clusters](getting-started.md#clusters.delete).
Verwenden Sie die folgenden Parameter mit `UpdateCluster`.
**Parameters**
+ `ClusterName` – Erforderlich. Gibt an, auf welchem Cluster (Cluster) die Shard-Rekonfiguration ausgeführt werden soll.
+ `ShardConfiguration` – Erforderlich. Ermöglicht es Ihnen, die Anzahl der Shards mithilfe der folgenden Eigenschaft festzulegen: `ShardCount`
`ShardCount`— Legen Sie diese Eigenschaft fest, um die Anzahl der gewünschten Shards anzugeben.
# Vertikales Online-Skalieren durch Ändern des Knotentyps
Durch die vertikale Online-Skalierung mit MemoryDB können Sie Ihren Cluster dynamisch und mit minimalen Ausfallzeiten skalieren. Dadurch kann Ihr 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 [Daten-Tiering](data-tiering.md).
Sie haben die folgenden Möglichkeiten:
+ **Skalieren** — Erhöhen Sie die Lese- und Schreibkapazität, indem Sie den Knotentyp Ihres MemoryDB-Clusters so anpassen, dass er einen größeren Knotentyp verwendet.
MemoryDB 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 passt MemoryDB die Größe Ihres Clusters dynamisch an, bleibt aber online und bearbeitet Anfragen. 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 Ablauf der Skalierung up/down sicherzustellen:
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.
# Online-aufwärtsskalieren
**Topics**
+ [Skalieren von MemoryDB-Clustern (Konsole)](#cluster-vertical-scaling-console)
+ [Skalierung von MemoryDB-Clustern (CLI)AWS](#scaling.scaleUp.cli)
+ [Skalieren von MemoryDB-Clustern (MemoryDB-API)](#verticalscaling.scaleup.api)
## Skalieren von MemoryDB-Clustern (Konsole)
Das folgende Verfahren beschreibt, wie Sie einen MemoryDB-Cluster mithilfe von skalieren. AWS-Managementkonsole Während dieses Vorgangs bearbeitet Ihr MemoryDB-Cluster weiterhin Anfragen mit minimaler Ausfallzeit.
**Um einen Cluster (Konsole) hochzuskalieren**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Wählen Sie aus der Liste der Cluster den Cluster aus.
1. Wählen Sie **Aktionen** und dann **Ändern**.
1. Gehen Sie im Dialogfeld „**Cluster modifizieren**“ 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. Wählen Sie **Änderungen speichern ** aus.
Der Status des Clusters ändert sich in „*Ändern*“. Wenn der Status zu *available* wechselt, ist die Änderung abgeschlossen und Sie können den neuen Cluster verwenden.
## Skalierung von MemoryDB-Clustern (CLI)AWS
Das folgende Verfahren beschreibt, wie Sie einen MemoryDB-Cluster mithilfe von skalieren. AWS CLI Während dieses Vorgangs bearbeitet Ihr MemoryDB-Cluster weiterhin Anfragen mit minimaler Ausfallzeit.
**So skalieren Sie einen MemoryDB-Cluster (CLI)AWS**
1. Ermitteln Sie die Knotentypen, auf die Sie skalieren können, indem Sie den AWS CLI `list-allowed-node-type-updates` Befehl mit dem folgenden Parameter ausführen.
Für Linux, macOS oder Unix:
```
aws memorydb list-allowed-node-type-updates \
--cluster-name my-cluster-name
```
Für Windows:
```
aws memorydb list-allowed-node-type-updates ^
--cluster-name my-cluster-name
```
Die Ausgabe des obigen Befehls sieht in etwa folgendermaßen aus (JSON format).
```
{
"ScaleUpNodeTypes": [
"db.r6g.2xlarge",
"db.r6g.large"
],
"ScaleDownNodeTypes": [
"db.r6g.large"
],
}
```
Weitere Informationen finden Sie unter [list-allowed-node-type-updates](https://docs.aws.amazon.com/cli/latest/reference/memorydb/list-allowed-node-type-updates.html) in der *AWS CLI Referenz.*
1. Ändern Sie Ihren Cluster, sodass er auf den neuen, größeren Knotentyp skaliert werden kann. Verwenden Sie dazu den AWS CLI `update-cluster` Befehl und die folgenden Parameter.
+ `--cluster-name`— Der Name des Clusters, auf den Sie skalieren möchten.
+ `--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-updates` zurückgegeben wurden.
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--node-type db.r6g.2xlarge
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--node-type db.r6g.2xlarge ^
```
Weitere Informationen finden Sie unter [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Skalieren von MemoryDB-Clustern (MemoryDB-API)
Der folgende Prozess skaliert Ihren Cluster mithilfe der MemoryDB-API von seinem aktuellen Knotentyp auf einen neuen, größeren Knotentyp. Während dieses Vorgangs aktualisiert MemoryDB die DNS-Einträge, sodass sie auf die neuen Knoten verweisen. Sie können Cluster mit automatischem Failover skalieren, während der Cluster weiterhin online bleibt und eingehende Anfragen bearbeitet.
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 MemoryDB-Cluster (MemoryDB-API)**
1. Ermitteln Sie, auf welche Knotentypen Sie mithilfe der `ListAllowedNodeTypeUpdates` MemoryDB-API-Aktion mit dem folgenden Parameter skalieren können.
+ `ClusterName`— der Name des Clusters. Verwenden Sie diesen Parameter, um einen bestimmten Cluster und nicht alle Cluster zu beschreiben.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=ListAllowedNodeTypeUpdates
&ClusterName=MyCluster
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
Weitere Informationen finden Sie [ListAllowedNodeTypeUpdates](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_ListAllowedNodeTypeUpdates.html)in der *MemoryDB-API-Referenz*.
1. Skalieren Sie Ihren aktuellen Cluster mithilfe der `UpdateCluster` MemoryDB-API-Aktion und mit den folgenden Parametern auf den neuen Knotentyp.
+ `ClusterName`— der Name des Clusters.
+ `NodeType`— der neue, größere Knotentyp der Cluster in diesem Cluster. Der Wert muss einer der Instance-Typen sein, die in Schritt 1 mit dem Aufruf `ListAllowedNodeTypeUpdates` zurückgegeben wurden.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateCluster
&NodeType=db.r6g.2xlarge
&ClusterName=myCluster
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210801T220302Z
&Version=2021-01-01
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Date=20210801T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20210801T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
Weitere Informationen finden Sie unter [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
# Online-abwärtsskalieren
**Topics**
+ [Verkleinern von MemoryDB-Clustern (Konsole)](#cluster-vertical-scaling-down-console)
+ [Verkleinern von MemoryDB-Clustern (CLI)AWS](#scaling.scaledown.cli)
+ [Verkleinern von MemoryDB-Clustern (MemoryDB-API)](#scaling.vertical.scaledown.api)
## Verkleinern von MemoryDB-Clustern (Konsole)
Das folgende Verfahren beschreibt, wie Sie einen MemoryDB-Cluster mithilfe von herunterskalieren. AWS-Managementkonsole Während dieses Vorgangs bearbeitet Ihr MemoryDB-Cluster weiterhin Anfragen mit minimaler Ausfallzeit.
**Um einen MemoryDB-Cluster (Konsole) zu verkleinern**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die MemoryDB-Konsole unter. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. Wählen Sie aus der Liste der Cluster Ihren bevorzugten Cluster.
1. Wählen Sie **Aktionen** und dann **Ändern**.
1. Gehen Sie im Dialogfeld „**Cluster modifizieren**“ 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. Wählen Sie **Änderungen speichern ** aus.
Der Status des Clusters ändert sich in „*Ändern*“. Wenn der Status zu *available* wechselt, ist die Änderung abgeschlossen und Sie können den neuen Cluster verwenden.
## Verkleinern von MemoryDB-Clustern (CLI)AWS
Das folgende Verfahren beschreibt, wie Sie einen MemoryDB-Cluster mithilfe von herunterskalieren. AWS CLI Während dieses Vorgangs bearbeitet Ihr MemoryDB-Cluster weiterhin Anfragen mit minimaler Ausfallzeit.
**So verkleinern Sie einen MemoryDB-Cluster (CLI)AWS**
1. Ermitteln Sie die Knotentypen, auf die Sie herunterskalieren können, indem Sie den AWS CLI `list-allowed-node-type-updates` Befehl mit dem folgenden Parameter ausführen.
Für Linux, macOS oder Unix:
```
aws memorydb list-allowed-node-type-updates \
--cluster-name my-cluster-name
```
Für Windows:
```
aws memorydb list-allowed-node-type-updates ^
--cluster-name my-cluster-name
```
Die Ausgabe des obigen Befehls sieht in etwa folgendermaßen aus (JSON format).
```
{
"ScaleUpNodeTypes": [
"db.r6g.2xlarge",
"db.r6g.large"
],
"ScaleDownNodeTypes": [
"db.r6g.large"
],
}
```
Weitere Informationen finden Sie unter [list-allowed-node-type-updates](https://docs.aws.amazon.com/cli/latest/reference/memorydb/list-allowed-node-type-updates.html).
1. Ändern Sie Ihren Cluster so, dass er auf den neuen, kleineren Knotentyp herunterskaliert wird. Verwenden Sie dazu den `update-cluster` Befehl und die folgenden Parameter.
+ `--cluster-name`— Der Name des Clusters, auf den Sie herunterskalieren.
+ `--node-type`— Der neue Knotentyp, 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-updates` zurückgegeben wurden.
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--node-type db.r6g.large
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--node-type db.r6g.large
```
Weitere Informationen finden Sie unter [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Verkleinern von MemoryDB-Clustern (MemoryDB-API)
Der folgende Prozess skaliert Ihren Cluster mithilfe der MemoryDB-API von seinem aktuellen Knotentyp auf einen neuen, kleineren Knotentyp. Während dieses Vorgangs bearbeitet Ihr MemoryDB-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 (MemoryDB-API)**
1. Ermitteln Sie mit dem folgenden Parameter, auf welche Knotentypen Sie mithilfe der [ListAllowedNodeTypeUpdates](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_ListAllowedNodeTypeUpdates.html)API herunterskalieren können:
+ `ClusterName`— der Name des Clusters. Verwenden Sie diesen Parameter, um einen bestimmten Cluster und nicht alle Cluster zu beschreiben.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=ListAllowedNodeTypeUpdates
&ClusterName=MyCluster
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
1. Skalieren Sie Ihren aktuellen Cluster mithilfe der [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html)API mit den folgenden Parametern auf den neuen Knotentyp herunter.
+ `ClusterName`— der Name des Clusters.
+ `NodeType`— der neue, kleinere Knotentyp der Cluster in diesem Cluster. Der Wert muss einer der Instance-Typen sein, die in Schritt 1 mit dem Aufruf `ListAllowedNodeTypeUpdates` zurückgegeben wurden.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateCluster
&NodeType=db.r6g.2xlarge
&ClusterName=myReplGroup
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210801T220302Z
&Version=2021-01-01
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Date=20210801T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20210801T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```