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.
# Verwalten von Clustern
Die meisten MemoryDB-Operationen werden auf Clusterebene ausgeführt. Sie können einen Cluster mit einer bestimmten Anzahl von Knoten und einer Parametergruppe einrichten, die die Eigenschaften für jeden Knoten steuert. Alle Knoten innerhalb eines Clusters gehören demselben Knotentyp an und verfügen über die gleichen Einstellungen für Parameter und Sicherheitsgruppen.
Jeder Cluster muss über eine Cluster-Kennung verfügen. Die Cluster-Kennung ist ein vom Kunden angegebener Name für den Cluster. Diese Kennung gibt einen bestimmten Cluster an, wenn mit der MemoryDB-API und den MemoryDB-Befehlen interagiert wird. AWS CLI Die Cluster-ID muss für diesen Kunden in einer AWS Region eindeutig sein.
MemoryDB-Cluster sind für den Zugriff über eine Amazon EC2 EC2-Instance konzipiert. Sie können Ihren MemoryDB-Cluster nur in einer Virtual Private Cloud (VPC) starten, die auf dem Amazon VPC-Service basiert, aber Sie können von außen darauf zugreifen. AWS Weitere Informationen finden Sie unter [Zugriff auf MemoryDB-Ressourcen von außen AWS](accessing-memorydb.md#access-from-outside-aws).
# Daten-Tiering
Bei Clustern, die einen Knotentyp aus der R6GD-Familie verwenden, werden die Daten zwischen Arbeitsspeicher und lokalem SSD-Speicher (Solid State Drives) aufgeteilt. Data Tiering bietet eine neue Preis-Leistungs-Option für Valkey- und Redis-OSS-Workloads, da in jedem Clusterknoten zusätzlich zur Speicherung von Daten im Arbeitsspeicher kostengünstigere Solid-State-Laufwerke (SSDs) verwendet werden. Ähnlich wie bei anderen Knotentypen werden die auf R6GD-Knoten geschriebenen Daten dauerhaft in einem Multi-AZ-Transaktionsprotokoll gespeichert. Daten-Tiering ist ideal für Workloads, die regelmäßig auf bis zu 20 Prozent ihres gesamten Datensatzes zugreifen, und für Anwendungen, die beim Zugriff auf Daten auf SSD zusätzliche Latenz tolerieren können.
In Clustern mit Daten-Tiering überwacht MemoryDB die letzte Zugriffszeit jedes gespeicherten Elements. Wenn der verfügbare Speicher (DRAM) vollständig verbraucht ist, verwendet MemoryDB einen LRU-Algorithmus (Least-Recently Used), um Objekte, auf die selten zugegriffen wird, automatisch vom Speicher auf die SSD zu verschieben. Wenn anschließend auf Daten auf der SSD zugegriffen wird, verschiebt MemoryDB sie automatisch und asynchron zurück in den Arbeitsspeicher, bevor die Anforderung verarbeitet wird. Wenn Sie eine Workload haben, die regelmäßig nur auf eine Teilmenge ihrer Daten zugreift, ist Daten-Tiering eine optimale Möglichkeit, Ihre Kapazität kostengünstig zu skalieren.
Beachten Sie, dass bei der Verwendung von Daten-Tiering die Schlüssel selbst immer im Speicher verbleiben, während die LRU die Platzierung von Werten in dem Speicher im Vergleich zur Festplatte regelt. Im Allgemeinen empfehlen wir, dass Ihre Schlüsselgrößen kleiner als Ihre Wertgrößen sind, wenn Sie Daten-Tiering verwenden.
Das Daten-Tiering ist so konzipiert, dass es minimale Auswirkungen auf die Leistung von Anwendungs-Workloads hat. Wenn Sie beispielsweise von 500-Byte-Zeichenkettenwerten ausgehen, können Sie in der Regel mit einer zusätzlichen Latenz von 450 Mikrosekunden für Leseanforderungen für auf SSD gespeicherte Daten im Vergleich zu Leseanforderungen für Daten im Speicher rechnen.
Mit der größten Data-Tiering-Knotengröße (db.r6gd.8xlarge) können Sie bis zu \$1500 TBs in einem einzigen 500-Knoten-Cluster speichern (250 TB bei Verwendung einer Lesereplik). Für das Daten-Tiering reserviert MemoryDB 19% des (DRAM-) Speichers pro Knoten für die Nichtdatenverwendung. Data Tiering ist mit allen OSS-Befehlen und Datenstrukturen von Valkey und Redis kompatibel, die in MemoryDB unterstützt werden. Um diese Funktion nutzen zu können, sind keine clientseitigen Änderungen erforderlich.
**Topics**
+ [Bewährte Methoden](data-tiering-best-practices.md)
+ [Einschränkungen beim Daten-Tiering](data-tiering-prerequisites.md)
+ [Preise für Daten-Tiering](data-tiering-pricing.md)
+ [Überwachung der Datenklassifizierung](data-tiering-monitoring.md)
+ [Verwenden von Daten-Tiering](data-tiering-enabling.md)
+ [Daten aus einem Snapshot in Clustern wiederherstellen](data-tiering-enabling-snapshots.md)
# Bewährte Methoden
Wir empfehlen Ihnen, die folgenden bewährten Methoden:
+ Daten-Tiering ist ideal für Workloads, die regelmäßig auf bis zu 20 Prozent ihres gesamten Datensatzes zugreifen, und für Anwendungen, die beim Zugriff auf Daten auf SSD zusätzliche Latenz tolerieren können.
+ Bei Verwendung von SSD-Kapazität, die auf Daten-Tiering-Knoten verfügbar ist, empfehlen wir, dass die Wertgröße größer als die Schlüsselgröße ist. Die Wertgröße darf nicht größer als 128 MB sein. Andernfalls wird sie nicht auf die Festplatte verschoben. Wenn Elemente zwischen DRAM und SSD verschoben werden, bleiben die Schlüssel immer im Speicher und nur die Werte werden in die SSD-Ebene verschoben.
# Einschränkungen beim Daten-Tiering
Für Daten-Tiering gelten die folgenden Beschränkungen:
+ Der verwendete Knotentyp muss aus der r6gd-Familie stammen, die in den folgenden Regionen verfügbar ist: `us-east-2`, `us-east-1`, `us-west-2`, `us-west-1`, `eu-west-1`, `eu-west-3`, `eu-central-1`, `ap-northeast-1`, `ap-southeast-1`, `ap-southeast-2`, `ap-south-1`, `ca-central-1` und `sa-east-1`.
+ Sie können einen Snapshot eines r6gd-Clusters nicht in einem anderen Cluster wiederherstellen, es sei denn, dieser verwendet auch r6gd.
+ Sie können einen Snapshot für Data-Tiering-Cluster nicht nach Amazon S3 exportieren.
+ Das unvergabelte Speichern wird nicht unterstützt.
+ Die Skalierung von einem Cluster mit Daten-Tiering (z. B. ein Cluster, der einen R6gd-Knotentyp verwendet) zu einem Cluster ohne Daten-Tiering (z. B. ein Cluster, der einen R6g-Knotentyp verwendet) wird nicht unterstützt.
+ Daten-Tiering unterstützt nur die maxmemory-Richtlinien `volatile-lru`, `allkeys-lru` und `noeviction`.
+ Elemente, die größer als 128 MiB sind, werden nicht auf SSD verschoben.
# Preise für Daten-Tiering
R6gd-Knoten verfügen über eine fünfmal höhere Gesamtkapazität (Arbeitsspeicher \$1 SSD) und können Ihnen helfen, bei maximaler Auslastung im Vergleich zu R6g-Knoten (nur Speicher) mehr als 60 Prozent Speicherkosten einzusparen. [Weitere Informationen finden Sie unter MemoryDB-Preise.](https://aws.amazon.com/memorydb/pricing/)
# Überwachung der Datenklassifizierung
MemoryDB bietet Metriken, die speziell für die Überwachung von Leistungsclustern entwickelt wurden, die Datenklassifizierung verwenden. Um das Verhältnis der Elemente in DRAM im Vergleich zu SSD zu überwachen, können Sie die Metrik unter verwenden. `CurrItems` [Metriken für MemoryDB](metrics.memorydb.md) Sie können den Prozentsatz wie folgt berechnen:`(CurrItems with Dimension: Tier = Memory * 100) / (CurrItems with no dimension filter)`.
Wenn die konfigurierte Löschrichtlinie dies zulässt, beginnt MemoryDB mit dem Löschen von Elementen, wenn der Prozentsatz der Elemente im Speicher unter 5 Prozent sinkt. Auf Knoten, für die die Noeviction-Richtlinie konfiguriert wurde, wird bei Schreibvorgängen der Fehler „Nicht genügend Arbeitsspeicher“ angezeigt.
Es wird dennoch empfohlen, zu berücksichtigen, [Skalierung von MemoryDB-Clustern](scaling-cluster.md) wann der Prozentsatz der Elemente im Arbeitsspeicher unter 5 Prozent sinkt. Weitere Informationen finden Sie unter *Metriken für MemoryDB-Cluster, die Data Tiering verwenden* unter. [Metriken für MemoryDB](metrics.memorydb.md)
# Verwenden von Daten-Tiering
## Verwenden von Daten-Tiering mit dem AWS-Managementkonsole
*Beim Erstellen eines Clusters verwenden Sie Daten-Tiering, indem Sie einen Knotentyp aus der r6gd-Familie auswählen, z. B. db.r6gd.xlarge.* Bei Auswahl dieses Knotentyps wird das Daten-Tiering automatisch aktiviert.
Weitere Informationen zum Erstellen von Clustern finden Sie unter [Schritt 2: Erstellen eines Clusters](getting-started.md#getting-started.createcluster).
## Aktivieren Sie das Daten-Tiering mit dem AWS CLI
Wenn Sie mit dem einen Cluster erstellen AWS CLI, verwenden Sie Daten-Tiering, indem Sie einen Knotentyp aus der r6gd-Familie auswählen, z. B. *db.r6gd.xlarge*, und den Parameter festlegen. `--data-tiering`
Sie können sich das Daten-Tiering nicht abwählen, wenn Sie einen Knotentyp aus der R6gd-Familie auswählen. Wenn Sie den Parameter `--no-data-tiering` festlegen, schlägt die Operation fehl.
Für Linux, macOS oder Unix:
```
aws memorydb create-cluster \
--cluster-name my-cluster \
--node-type db.r6gd.xlarge \
--engine valkey \
--acl-name my-acl \
--subnet-group my-sg \
--data-tiering
```
Für Windows:
```
aws memorydb create-cluster ^
--cluster-name my-cluster ^
--node-type db.r6gd.xlarge ^
--engine valkey ^
--acl-name my-acl ^
--subnet-group my-sg
--data-tiering
```
Nach dem Ausführen dieses Vorgangs sehen Sie eine Antwort ähnlich dem folgenden:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "creating",
"NumberOfShards": 1,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Port": 6379
},
"NodeType": "db.r6gd.xlarge",
"EngineVersion": "7.2",
"EnginePatchVersion": "7.2.6",
"Engine": "valkey"
"ParameterGroupName": "default.memorydb-valkey7",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxxxxxxxxx:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering":"true",
"AutoMinorVersionUpgrade": true
}
}
```
# Daten aus einem Snapshot in Clustern wiederherstellen
Sie können einen Snapshot auf einem neuen Cluster mit aktiviertem Data Tiering mithilfe der (Console), (AWS CLI) oder (MemoryDB-API) wiederherstellen. Wenn Sie einen Cluster mit Knotentypen in der R6gd-Familie erstellen, ist Daten-Tiering aktiviert.
## Wiederherstellen von Daten aus einem Snapshot in Clustern mit aktiviertem Data Tiering (Konsole)
Gehen Sie wie folgt vor, um einen Snapshot auf einem neuen Cluster mit aktiviertem Daten-Tiering wiederherzustellen (Konsole) [Wiederherstellung aus einem Snapshot (Konsole)](snapshots-restoring.md#snapshots-restoring-CON)
Beachten Sie, dass Sie zur Aktivierung von Data-Tiering einen Knotentyp aus der R6GD-Familie auswählen müssen.
## Wiederherstellung von Daten aus einem Snapshot in Clustern mit aktiviertem Data Tiering (AWS CLI)
Beim Erstellen eines Clusters mit dem wird standardmäßig Daten-Tiering verwendet AWS CLI, indem ein Knotentyp aus der r6gd-Familie ausgewählt wird, z. B. *db.r6gd.xlarge*, und der Parameter festgelegt wird. `--data-tiering`
Sie können sich das Daten-Tiering nicht abwählen, wenn Sie einen Knotentyp aus der R6gd-Familie auswählen. Wenn Sie den Parameter `--no-data-tiering` festlegen, schlägt die Operation fehl.
Für Linux, macOS oder Unix:
```
aws memorydb create-cluster \
--cluster-name my-cluster \
--node-type db.r6gd.xlarge \
--engine valkey
--acl-name my-acl \
--subnet-group my-sg \
--data-tiering \
--snapshot-name my-snapshot
```
Für Windows:
```
aws memorydb create-cluster ^
--cluster-name my-cluster ^
--node-type db.r6gd.xlarge ^
--engine valkey ^
--acl-name my-acl ^
--subnet-group my-sg ^
--data-tiering ^
--snapshot-name my-snapshot
```
Nach dem Ausführen dieses Vorgangs sehen Sie eine Antwort ähnlich dem folgenden:
```
{
"Cluster": {
"Name": "my-cluster",
"Status": "creating",
"NumberOfShards": 1,
"AvailabilityMode": "MultiAZ",
"ClusterEndpoint": {
"Port": 6379
},
"NodeType": "db.r6gd.xlarge",
"EngineVersion": "7.2",
"EnginePatchVersion": "7.2.6",
"Engine": "valkey"
"ParameterGroupName": "default.memorydb-valkey7",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:xxxxxxxxxxxxxx:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "true"
}
```
# Vorbereitung eines Clusters
Im Folgenden finden Sie Anweisungen zum Erstellen eines Clusters mithilfe der MemoryDB-Konsole, der oder der MemoryDB-API. AWS CLI
Bei der Erstellung eines Clusters empfiehlt es sich, einige Vorarbeiten zu erledigen, damit Sie nicht sofort ein Upgrade durchführen oder Änderungen vornehmen müssen.
**Topics**
+ [Bestimmung Ihrer Anforderungen](cluster-create-determine-requirements.md)
# Bestimmung Ihrer Anforderungen
**Vorbereitung**
Wenn Sie die Antworten auf die folgenden Fragen kennen, können Sie die Erstellung Ihres Clusters vereinfachen:
+ Stellen Sie sicher, dass Sie eine Subnetzgruppe in derselben VPC erstellen, bevor Sie mit der Erstellung eines Clusters beginnen. Alternativ können Sie die bereitgestellte Standard-Subnetzgruppe verwenden. Weitere Informationen finden Sie unter [Subnetze und Subnetzgruppen](subnetgroups.md).
MemoryDB ist so konzipiert, dass auf Amazon EC2 von innen AWS zugegriffen werden kann. Wenn Sie jedoch in einer VPC starten, die auf Amazon VPC basiert, können Sie Zugriff von außen gewähren. AWS Weitere Informationen finden Sie unter [Zugriff auf MemoryDB-Ressourcen von außen AWS](accessing-memorydb.md#access-from-outside-aws).
+ Müssen Sie irgendwelche Parameterwerte anpassen?
Erstellen Sie in diesem Fall eine benutzerdefinierte Parametergruppe. Weitere Informationen finden Sie unter [Erstellen einer Parametergruppe](parametergroups.creating.md).
+ Müssen Sie eine VPC-Sicherheitsgruppe erstellen?
Weitere Informationen finden Sie unter [Sicherheit in Ihrer VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Security.html).
+ Haben Sie vor, Fehlertoleranz zu implementieren?
Weitere Informationen finden Sie unter [Minimieren von Ausfällen](faulttolerance.md).
**Topics**
+ [Anforderungen an Speicher und Prozessor](#cluster-create-determine-requirements-memory)
+ [MemoryDB-Cluster-Konfiguration](#cluster-configuration)
+ [Verbessertes Multiplexing I/O](#cluster-create-determine-requirements-multiplexing)
+ [Voraussetzungen für Skalierung](#cluster-create-determine-requirements-scaling)
+ [Zugriffsvoraussetzungen](#cluster-create-determine-requirements-access)
+ [Region und Verfügbarkeitszonen](#cluster-create-determine-requirements-region)
## Anforderungen an Speicher und Prozessor
Der Grundbaustein von MemoryDB ist der Knoten. Knoten werden in Shards konfiguriert, um Cluster zu bilden. Berücksichtigen Sie bei der Bestimmung des für den Cluster zu verwendenden Knotentyps die Knotenkonfiguration des Clusters und die zu speichernde Datenmenge.
## MemoryDB-Cluster-Konfiguration
MemoryDB-Cluster bestehen aus 1 bis 500 Shards. Die Daten in einem MemoryDB-Cluster sind auf die Shards im Cluster verteilt. Ihre Anwendung stellt über eine Netzwerkadresse, die als Endpunkt bezeichnet wird, eine Verbindung zu einem MemoryDB-Cluster her. *Zusätzlich zu den Knotenendpunkten hat der MemoryDB-Cluster selbst einen Endpunkt, den Cluster-Endpunkt.* Ihre Anwendung kann diesen Endpunkt verwenden, um aus dem Cluster zu lesen oder in ihn zu schreiben, wobei die Entscheidung, von welchem Knoten gelesen oder auf welchen geschrieben werden soll, MemoryDB überlassen bleibt.
## Verbessertes Multiplexing I/O
Wenn Sie Valkey oder Redis OSS Version 7.0 oder höher verwenden, erhalten Sie zusätzliche Beschleunigung durch erweitertes I/O Multiplexing, bei dem jeder dedizierte Netzwerk-I/O-Thread Befehle von mehreren Clients an die Engine weiterleitet und so die Möglichkeit nutzt, Befehle effizient stapelweise zu verarbeiten. [Weitere Informationen finden Sie unter Extrem schnelle Leistung und.](https://aws.amazon.com/memorydb/features/#Ultra-fast_performance) [Unterstützte Knotentypen](nodes.supportedtypes.md)
## Voraussetzungen für Skalierung
Alle Cluster können auf einen größeren Knotentyp hochskaliert werden. Wenn Sie einen MemoryDB-Cluster hochskalieren, können Sie dies online tun, sodass der Cluster verfügbar bleibt, oder Sie können einen neuen Cluster anhand eines Snapshots erstellen und vermeiden, dass der neue Cluster leer anfängt.
Weitere Informationen finden Sie unter [Skalierung](scaling.md) in diesem Handbuch.
## Zugriffsvoraussetzungen
MemoryDB-Cluster werden standardmäßig von Amazon EC2 EC2-Instances aus aufgerufen. Der Netzwerkzugriff auf einen MemoryDB-Cluster ist auf das Konto beschränkt, mit dem der Cluster erstellt wurde. Bevor Sie von einer Amazon EC2 EC2-Instance aus auf einen Cluster zugreifen können, müssen Sie daher den Zugang zum Cluster autorisieren. Detaillierte Anweisungen finden Sie unter [Schritt 3: Zugriff auf den Cluster autorisieren](getting-started.md#getting-started.authorizeaccess) in diesem Handbuch.
## Region und Verfügbarkeitszonen
Indem Sie Ihre MemoryDB-Cluster in einer AWS Region in der Nähe Ihrer Anwendung platzieren, können Sie die Latenz reduzieren. Bei Clustern mit mehreren Knoten lassen sich die Auswirkungen von Ausfällen auf Ihren Cluster reduzieren, indem Sie Ihre Knoten in verschiedenen Availability Zones platzieren.
Weitere Informationen finden Sie hier:
+ [Auswählen von Regionen und Availability Zones](regionsandazs.md)
+ [Minimieren von Ausfällen](faulttolerance.md)
# Einen Cluster erstellen
MemoryDB bietet drei Möglichkeiten, einen Cluster zu erstellen. Weitere Informationen finden Sie unter [Schritt 2: Erstellen eines Clusters](getting-started.md#getting-started.createcluster).
# Anzeigen der Details eines Clusters
Sie können detaillierte Informationen zu einem oder mehreren Clustern mithilfe der MemoryDB-Konsole oder der MemoryDB-API anzeigen. AWS CLI
## Details für einen MemoryDB-Cluster anzeigen (Konsole)
Das folgende Verfahren beschreibt, wie Sie die Details eines MemoryDB-Clusters mithilfe der MemoryDB-Konsole anzeigen.
****
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. Um Details zu einem Cluster anzuzeigen, wählen Sie das Optionsfeld links neben dem Namen des Clusters und dann Details **anzeigen** aus. Sie können auch direkt auf den Cluster klicken, um die Seite mit den Cluster-Details aufzurufen.
Auf der Seite mit den **Cluster-Details** werden Details zum Cluster angezeigt, einschließlich des Cluster-Endpunkts. Sie können weitere Details mithilfe der verschiedenen Registerkarten auf der Seite mit den **Cluster-Details** anzeigen.
1. Wählen Sie den Tab **Shards and Nodes**, um eine Liste der Shards des Clusters und die Anzahl der Knoten in jedem Shard zu sehen.
1. Um spezifische Informationen zu einem Knoten anzuzeigen, erweitern Sie den Shard in der Tabelle unten. Alternativ können Sie auch über das Suchfeld nach dem Shard suchen.
Dadurch werden Informationen zu jedem Knoten angezeigt, einschließlich seiner Availability Zone slots/keyspaces und seines Status.
1. Wählen Sie die Registerkarte **Metriken**, um die jeweiligen Prozesse zu überwachen, z. B. die **CPU-Auslastung** und die **Engine-CPU-Auslastung**. Weitere Informationen finden Sie unter [Metriken für MemoryDB](metrics.memorydb.md).
1. Wählen Sie die Registerkarte **Netzwerk und Sicherheit**, um Details zur Subnetzgruppe und den Sicherheitsgruppen anzuzeigen.
1. Unter **Subnetzgruppe** sehen Sie den Namen der Subnetzgruppe, einen Link zu der VPC, zu der das Subnetz gehört, und den Amazon-Ressourcennamen (ARN) der Subnetzgruppe.
1. Unter **Sicherheitsgruppen** können Sie die ID, den Namen und die Beschreibung der Sicherheitsgruppe sehen.
1. Wählen Sie die Registerkarte **Wartung und Snapshot**, um Details zu den Snapshot-Einstellungen zu sehen.
1. In **Snapshot** können Sie sehen, ob automatische Snapshots aktiviert sind, wie lange Snapshots aufbewahrt werden und welches Snapshot-Fenster geöffnet ist.
1. Unter **Snapshots** sehen Sie eine Liste aller Snapshots dieses Clusters, einschließlich des Snapshot-Namens, der Größe, der Anzahl der Shards und des Status.
Weitere Informationen finden Sie unter [Snapshot und Wiederherstellung](snapshots.md).
1. Wählen Sie die Registerkarte **Wartung und Snapshot**, um Details zum Wartungsfenster sowie alle ausstehenden ACL-, Resharding- oder Service-Updates anzuzeigen. Weitere Informationen finden Sie unter [Verwaltung der Wartung](maintenance-window.md).
1. Wählen Sie die Registerkarte **Service Updates**, um Details zu allen Service-Updates zu sehen, die für diesen Cluster gelten. Weitere Informationen finden Sie unter [Dienstupdates in MemoryDB](service-updates.md).
1. Wählen Sie die Registerkarte **Tags**, um Details zu allen Ressourcen- oder Kostenzuweisungs-Tags anzuzeigen, die mit diesem Cluster verknüpft sind. Weitere Informationen finden Sie unter [Schnappschüsse taggen](snapshots-tagging.md).
## Details eines Clusters anzeigen (AWS CLI)
Sie können die Details für einen Cluster mit dem AWS CLI `describe-clusters` Befehl anzeigen. Wenn der Parameter `--cluster-name` weggelassen wird, werden Details für mehrere Cluster, bis zu `--max-results`, zurückgegeben. Wenn der Parameter `--cluster-name` eingeschlossen wird, werden Details für den angegebenen Cluster zurückgegeben. Sie können die Anzahl der mit dem Parameter `--max-results` zurückgegebenen Datensätze begrenzen.
Der folgende Code listet die Details für `my-cluster` auf.
```
aws memorydb describe-clusters --cluster-name my-cluster
```
Der folgende Code listet die Details für bis zu 25 Cluster auf.
```
aws memorydb describe-clusters --max-results 25
```
**Example**
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
```
Die folgende JSON-Ausgabe zeigt die Antwort:
```
{
"Clusters": [
{
"Name": "my-cluster",
"Description": "my cluster",
"Status": "available",
"NumberOfShards": 1,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-16383",
"Nodes": [
{
"Name": "my-cluster-0001-001",
"Status": "available",
"AvailabilityZone": "us-east-1a",
"CreateTime": 1629230643.961,
"Endpoint": {
"Address": "my-cluster-0001-001.my-cluster.abcdef.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
},
{
"Name": "my-cluster-0001-002",
"Status": "available",
"CreateTime": 1629230644.025,
"Endpoint": {
"Address": "my-cluster-0001-002.my-cluster.abcdef.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.abcdef.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": "default",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:000000000:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "sat:06:30-sat:07:30",
"SnapshotWindow": "04:00-05:00",
"ACLName": "open-access",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true,
}
```
Weitere Informationen finden Sie im Thema AWS CLI für MemoryDB. [https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html)
## Details eines Clusters anzeigen (MemoryDB-API)
Sie können die Details für einen Cluster mithilfe der MemoryDB-API-Aktion anzeigen. `DescribeClusters` Wenn der Parameter `ClusterName` eingeschlossen wird, werden Details für den angegebenen Cluster zurückgegeben. Wenn der Parameter `ClusterName` weggelassen wird, werden Details für bis zu `MaxResults` (Standard 100) Cluster zurückgegeben. Der Wert für `MaxResults` darf nicht kleiner als 20 oder größer als 100 sein.
Der folgende Code listet die Details für `my-cluster` auf.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=my-cluster
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
Der folgende Code listet die Details für bis zu 25 Cluster auf.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&MaxResults=25
&Version=2021-02-02
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```
Weitere Informationen finden Sie im Referenzthema MemoryDB-API. [https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html)
# Einen MemoryDB-Cluster ändern
Neben dem Hinzufügen oder Entfernen von Knoten aus einem Cluster kann es vorkommen, dass Sie weitere Änderungen an einem vorhandenen Cluster vornehmen müssen, z. B. das Hinzufügen einer Sicherheitsgruppe, das Ändern des Wartungsfensters oder einer Parametergruppe.
Es wird empfohlen, dass das Wartungsfenster in den Zeitraum mit der geringsten Nutzung fällt. Dies muss folglich zeitweise korrigiert werden.
Wenn Sie die Parameter eines Clusters ändern, wird die Änderung sofort auf den Cluster angewendet. Dies gilt unabhängig davon, ob Sie die Parametergruppe des Clusters selbst oder einen Parameterwert innerhalb der Parametergruppe des Clusters ändern.
Sie können auch die Engine-Version Ihres Clusters aktualisieren. Sie können beispielsweise eine neue Engine-Nebenversion auswählen und MemoryDB beginnt sofort mit der Aktualisierung Ihres Clusters.
## Mit dem AWS-Managementkonsole
**So modifizieren Sie einen Cluster:**
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 in der oberen rechten Ecke die AWS Region aus, in der sich der Cluster befindet, den Sie ändern möchten.
1. **Gehen Sie in der linken Navigationsleiste zu Clusters.** Wählen Sie unter **Clusterdetails** den Cluster mithilfe der Optionsschaltfläche aus und gehen Sie zu **Aktionen** und dann zu **Ändern**.
1. Die Seite **Ändern** wird angezeigt.
1. Nehmen **Sie im Fenster Ändern** die gewünschten Änderungen vor. Zu den Optionen gehören:
+ Description
+ Subnetzgruppen
+ VPC Security group(s) (VPC-Sicherheitsgruppe(n))
+ Knotentyp
**Anmerkung**
Wenn der Cluster einen Knotentyp aus der R6gd-Familie verwendet, können Sie nur eine andere Knotengröße aus dieser Familie auswählen. Wenn Sie einen Knotentyp aus der R6gd-Familie wählen, wird Daten-Tiering automatisch aktiviert. Weitere Informationen finden Sie unter [Daten-Tiering](data-tiering.md).
+ Kompatibilität mit Valkey- oder Redis OSS-Versionen
+ Aktivieren Sie automatische Schnappschüsse
+ Aufbewahrungszeitraum für Snapshots
+ Snapshot-Fenster
+ Wartungsfenster
+ Thema für die SNS-Benachrichtigung
1. Wählen Sie **Änderungen speichern ** aus.
Sie können auch auf der Seite mit den **Cluster-Details** auf **Ändern** klicken, um Änderungen am Cluster vorzunehmen. Wenn Sie bestimmte Abschnitte des Clusters ändern möchten, können Sie auf der Seite mit den **Cluster-Details** auf die entsprechende Registerkarte wechseln und auf **Ändern** klicken.
## Verwenden Sie den AWS CLI
Sie können einen vorhandenen Cluster mithilfe der AWS CLI `update-cluster` Operation ändern. Um den Konfigurationswert eines Clusters zu ändern, geben Sie die ID des Clusters, den zu ändernden Parameter und den neuen Wert des Parameters ein. Das folgende Beispiel ändert das Wartungsfenster für einen Cluster namens `my-cluster` und übernimmt die Änderung umgehend.
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--preferred-maintenance-window sun:23:00-mon:02:00
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--preferred-maintenance-window sun:23:00-mon:02:00
```
Weitere Informationen finden Sie unter [update-cluster](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html) in der AWS CLI Befehlsreferenz.
## Verwenden der MemoryDB-API
Sie können einen vorhandenen Cluster mithilfe der MemoryDB-API-Operation ändern. [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html) Um den Konfigurationswert eines Clusters zu ändern, geben Sie die ID des Clusters, den zu ändernden Parameter und den neuen Wert des Parameters ein. Das folgende Beispiel ändert das Wartungsfenster für einen Cluster namens `my-cluster` und übernimmt die Änderung umgehend.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=UpdateCluster
&ClusterName=my-cluster
&PreferredMaintenanceWindow=sun:23:00-mon:02:00
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210801T220302Z
&X-Amz-Algorithm=Amazon4-HMAC-SHA256
&X-Amz-Date=20210802T220302Z
&X-Amz-SignedHeaders=Host
&X-Amz-Expires=20210801T220302Z
&X-Amz-Credential=
&X-Amz-Signature=
```
## Wie löst man ein Engine-übergreifendes Upgrade von Redis OSS auf Valkey aus
Sie können einen vorhandenen Redis OSS-Cluster mithilfe von Konsole, API oder CLI auf die Valkey-Engine aktualisieren.
Wenn Sie über einen vorhandenen Redis OSS-Cluster verfügen, der die Standardparametergruppe verwendet, können Sie ein Upgrade auf Valkey durchführen, indem Sie die neue Engine- und Engine-Version mit der Update-Cluster-API angeben.
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name myCluster \
--engine valkey \
--engine-version 7.2
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name myCluster ^
--engine valkey ^
--engine-version 7.2
```
Wenn Sie eine benutzerdefinierte Parametergruppe auf den vorhandenen Redis OSS-Cluster angewendet haben, den Sie aktualisieren möchten, müssen Sie in der Anfrage auch eine benutzerdefinierte Valkey-Parametergruppe übergeben. Die benutzerdefinierte Valkey-Eingabeparametergruppe muss dieselben statischen Redis OSS-Parameterwerte haben wie die vorhandene benutzerdefinierte Redis OSS-Parametergruppe.
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name myCluster \
--engine valkey \
--engine-version 7.2 \
--parameter-group-name myParamGroup
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name myCluster ^
--engine valkey ^
--engine-version 7.2 ^
--parameter-group-name myParamGroup
```
# Knoten zu einem Cluster hinzufügen/entfernen
Sie können Knoten mit der AWS-Managementkonsole, der oder der MemoryDB-API zu einem Cluster hinzufügen oder daraus entfernen. AWS CLI
## Mit dem AWS-Managementkonsole
****
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, zu dem Sie einen Knoten hinzufügen oder entfernen möchten.
1. Wählen Sie auf der Registerkarte **Shards and nodes** die Option Knoten **hinzufügen/löschen** aus
1. Geben Sie im Feld **Neue Anzahl von Knoten** die gewünschte Anzahl von Knoten ein.
1. Wählen Sie **Bestätigen** aus.
**Wichtig**
Wenn Sie die Anzahl der Knoten auf 1 setzen, ist Multi-AZ für Sie nicht mehr aktiviert. Sie können sich auch dafür entscheiden, **Auto Failover** zu aktivieren.
## Mit dem AWS CLI
1. Identifizieren Sie die Namen der Knoten, die Sie entfernen möchten. Weitere Informationen finden Sie unter [Anzeigen der Details eines Clusters](clusters.viewdetails.md).
1. Listen Sie mit der CLI-Operation `update-cluster` wie im folgenden Beispiel die zu entfernenden Knoten auf.
Um über die Befehlszeilenschnittstelle Knoten aus einem Cluster zu entfernen, verwenden Sie den Befehl `update-cluster` mit den folgenden Parametern:
+ `--cluster-name`Die ID des Clusters, aus dem Sie Knoten entfernen möchten.
+ `--replica-configuration`— Ermöglicht es Ihnen, die Anzahl der Replikate festzulegen:
+ `ReplicaCount`— Legen Sie diese Eigenschaft fest, um die Anzahl der gewünschten Replikatknoten anzugeben.
+ `--region`Gibt die AWS Region des Clusters an, aus dem Sie Knoten entfernen möchten.
Für Linux, macOS oder Unix:
```
aws memorydb update-cluster \
--cluster-name my-cluster \
--replica-configuration \
ReplicaCount=1 \
--region us-east-1
```
Für Windows:
```
aws memorydb update-cluster ^
--cluster-name my-cluster ^
--replica-configuration ^
ReplicaCount=1 ^
--region us-east-1
```
Weitere Informationen finden Sie in den AWS CLI Themen [https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-cluster.html).
## Verwenden der MemoryDB-API
Um Knoten mithilfe der MemoryDB-API zu entfernen, rufen Sie den `UpdateCluster` API-Vorgang mit dem Clusternamen und einer Liste der zu entfernenden Knoten auf, wie hier gezeigt:
+ `ClusterName`Die ID des Clusters, aus dem Sie Knoten entfernen möchten.
+ `ReplicaConfiguration`— Ermöglicht es Ihnen, die Anzahl der Replikate festzulegen:
+ `ReplicaCount`— Legen Sie diese Eigenschaft fest, um die Anzahl der gewünschten Replikatknoten anzugeben.
+ `Region`Gibt die AWS Region des Clusters an, aus dem Sie einen Knoten entfernen möchten.
Weitere Informationen finden Sie unter [UpdateCluster](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateCluster.html).
# Zugriff auf Ihren Cluster
Ihre MemoryDB-Instances sind für den Zugriff über eine EC2 Amazon-Instance konzipiert.
Sie können von einer EC2 Amazon-Instance in derselben Amazon VPC aus auf Ihren MemoryDB-Knoten zugreifen. Oder Sie können mithilfe von VPC-Peering von einem Amazon EC2 in einer anderen Amazon-VPC auf Ihren MemoryDB-Knoten zugreifen.
**Topics**
+ [Gewähren Sie Zugriff auf Ihren Cluster](#grant-access)
+ [Zugriff auf MemoryDB-Ressourcen von außen AWS](#access-from-outside-aws)
## Gewähren Sie Zugriff auf Ihren Cluster
Sie können nur von einer EC2 Amazon-Instance aus, die in derselben Amazon VPC läuft, eine Verbindung zu Ihrem MemoryDB-Cluster herstellen. In diesem Fall müssen Sie Netzwerkzugang zum Cluster gewähren.
**So gewähren Sie einem Cluster den Netzwerkeingang aus einer Amazon-VPC-Sicherheitsgruppe**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die EC2 Amazon-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im linken Navigationsbereich unter **Netzwerk und Sicherheit** die Option **Sicherheitsgruppen** aus.
1. Wählen Sie aus der Liste der Sicherheitsgruppen die Sicherheitsgruppe Ihrer Amazon VPC aus. *Sofern Sie keine Sicherheitsgruppe für die Verwendung von MemoryDB erstellt haben, erhält diese Sicherheitsgruppe den Namen Standard.*
1. Wählen Sie die Registerkarte **Inbound** und verfahren Sie dann wie folgt:
1. Wählen Sie **Bearbeiten** aus.
1. Wählen Sie **Regel hinzufügen** aus.
1. Wählen Sie in der Spalte **Typ** die Option **Benutzerdefinierte TCP-Regel** aus.
1. Geben Sie in das Feld **Port Range** die Portnummer Ihres Clusterknotens ein. Diese Nummer muss mit der Nummer übereinstimmen, die Sie beim Starten des Clusters angegeben haben. Der Standardport für Valkey und Redis OSS ist. **6379**
1. Wählen Sie im Feld **Quelle** die Option **Anywhere** mit dem Portbereich (0.0.0.0/0) aus, sodass jede EC2 Amazon-Instance, die Sie in Ihrer Amazon VPC starten, eine Verbindung zu Ihren MemoryDB-Knoten herstellen kann.
**Wichtig**
Durch das Öffnen des MemoryDB-Clusters für 0.0.0.0/0 wird der Cluster nicht dem Internet zugänglich gemacht, da er keine öffentliche IP-Adresse hat und daher nicht von außerhalb der VPC darauf zugegriffen werden kann. Die Standardsicherheitsgruppe kann jedoch auf andere EC2 Amazon-Instances im Kundenkonto angewendet werden, und diese Instances können eine öffentliche IP-Adresse haben. Wenn diese Instances zufälligerweise eine Aktion auf dem Standardport ausführen, dann könnte dieser Service unbeabsichtigt zugänglich gemacht werden. Daher empfehlen wir, eine VPC-Sicherheitsgruppe zu erstellen, die ausschließlich von MemoryDB verwendet wird. Weitere Informationen finden Sie unter [Benutzerdefinierte Sicherheitsgruppen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#creating-your-own-security-groups).
1. Wählen Sie **Speichern**.
Wenn Sie eine EC2 Amazon-Instance in Ihrer Amazon VPC starten, kann diese Instance eine Verbindung zu Ihrem MemoryDB-Cluster herstellen.
## Zugriff auf MemoryDB-Ressourcen von außen AWS
MemoryDB ist ein Dienst, der für die interne Verwendung in Ihrer VPC konzipiert wurde. Von einem externen Zugriff wird wegen der Latenz des Internetverkehrs und aufgrund von Sicherheitsbedenken abgeraten. Wenn jedoch für Test- oder Entwicklungszwecke ein externer Zugriff auf MemoryDB erforderlich ist, kann dieser über ein VPN erfolgen.
Mit dem AWS Client VPN ermöglichen Sie externen Zugriff auf Ihre MemoryDB-Knoten mit den folgenden Vorteilen:
+ Eingeschränkter Zugriff auf zugelassene Benutzer oder Authentifizierungsschlüssel;
+ Verschlüsselter Verkehr zwischen dem VPN-Client und dem AWS VPN-Endpunkt;
+ beschränkter Zugriff auf bestimmte Subnetze oder Knoten,
+ einfacher Widerruf des Zugriffs von Benutzern oder Authentifizierungsschlüsseln,
+ Prüfung von Verbindungen.
Die folgenden Verfahren veranschaulichen, wie Sie:
**Topics**
+ [Anlegen einer Zertifizierungsstelle](#create-cert)
+ [Konfiguration der AWS Client-VPN-Komponenten](#configure-vpn-components)
+ [Konfigurieren des VPN-Clients](#configure-vpn-client)
### Anlegen einer Zertifizierungsstelle
Es ist möglich, eine Zertifizierungsstelle (Certificate Authority, CA) mit verschiedenen Methoden oder Tools zu erstellen. Wir schlagen dazu das Dienstprogramm easy-rsa vor, das vom [OpenVPN](https://openvpn.net/community-resources/openvpn-project/)-Projekt bereitgestellt wird. Unabhängig von der Option, die Sie wählen, achten Sie darauf, die Schlüssel sicher zu halten. Über das folgende Verfahren werden die easy-rsa-Skripte heruntergeladen, die Zertifizierungsstelle und die Schlüssel zur Authentifizierung des ersten VPN-Clients erstellt:
+ Um die ersten Zertifikate zu erstellen, öffnen Sie ein Terminal und gehen Sie folgendermaßen vor:
+ `git clone`[https://github.com/OpenVPN/easy-rsa](https://github.com/OpenVPN/easy-rsa)
+ `cd easy-rsa`
+ `./easyrsa3/easyrsa init-pki`
+ `./easyrsa3/easyrsa build-ca nopass`
+ `./easyrsa3/easyrsa build-server-full server nopass`
+ `./easyrsa3/easyrsa build-client-full client1.domain.tld nopass`
Es wird ein **pki**-Unterverzeichnis mit den Zertifikaten unter **easy-rsa** erstellt.
+ Senden Sie das Serverzertifikat an den AWS Certificate Manager (ACM):
+ Wählen Sie in der ACM-Konsole die Option **Certificate Manager (Zertifikatmanager)**aus.
+ Wählen Sie **Import Certificate (Zertifikat importieren)**aus.
+ Geben Sie das in der Datei `easy-rsa/pki/issued/server.crt` zur Verfügung stehende Zertifikat des öffentlichen Schlüssels in das Feld **Certificate body (Zertifikattext)** ein.
+ Fügen Sie den unter `easy-rsa/pki/private/server.key` zur Verfügung stehenden privaten Schlüssel in das Feld **Private Certificate Key (Privater Zertifikatsschlüssel)** ein. Achten Sie darauf, dass Sie alle Zeilen zwischen `BEGIN AND END PRIVATE KEY` (einschließlich der Zeilen `BEGIN` und `END`) auswählen.
+ Fügen Sie den in der Datei `easy-rsa/pki/ca.crt` verfügbaren öffentlichen CA-Schlüssel in das Feld **Certificate chain (Zertifikatskette)** ein.
+ Wählen Sie die Option **Review and import (Überprüfen und Importieren)** aus.
+ Klicken Sie auf **Import (Importieren)**.
Führen Sie den folgenden Befehl aus, um die Serverzertifikate mithilfe der AWS CLI an ACM zu senden: `aws acm import-certificate --certificate fileb://easy-rsa/pki/issued/server.crt --private-key file://easy-rsa/pki/private/server.key --certificate-chain file://easy-rsa/pki/ca.crt --region region`
Notieren Sie sich den Zertifikats-ARN für eine spätere Verwendung.
### Konfiguration der AWS Client-VPN-Komponenten
**Verwendung der AWS Konsole**
Wählen Sie auf der AWS Konsole **Dienste** und dann **VPC** aus.
Wählen Sie unter **Virtual Private Network (Virtuelles privates Netzwerk)** die Option **Client VPN Endpoints (Client-VPN-Endpunkte)** aus und führen Sie die folgenden Schritte aus:
**Konfiguration von AWS Client-VPN-Komponenten**
+ Wählen Sie **Create Client VPN Endpoint (Client-VPN-Endpunkt erstellen)** aus.
+ Folgende Optionen stehen Ihnen zur Verfügung:
+ **Client IPv4 CIDR**: Verwenden Sie ein privates Netzwerk mit einer Netzmaske im Bereich /22. Stellen Sie sicher, dass das ausgewählte Subnetz nicht mit den Adressen der VPC-Netzwerke in Konflikt steht. Beispiel: 10.0.0.0/22.
+ Wählen Sie unter **Server certificate ARN (Serverzertifikat-ARN)** den ARN des zuvor importierten Zertifikats aus.
+ Wählen Sie die Option **Use mutual authentication (Gegenseitige Authentifizierung verwenden)** aus.
+ Wählen Sie unter **Client certificate ARN (Client-Zertifikats-ARN)** den ARN des zuvor importierten Zertifikats aus.
+ Wählen Sie **Create Client VPN Endpoint (Client-VPN-Endpunkt erstellen)** aus.
**Mit dem AWS CLI**
Führen Sie den folgenden Befehl aus:
`aws ec2 create-client-vpn-endpoint --client-cidr-block "10.0.0.0/22" --server-certificate-arn arn:aws:acm:us-east-1:012345678912:certificate/0123abcd-ab12-01a0-123a-123456abcdef --authentication-options Type=certificate-authentication,,MutualAuthentication={ClientRootCertificateChainArn=arn:aws:acm:us-east-1:012345678912:certificate/123abcd-ab12-01a0-123a-123456abcdef} --connection-log-options Enabled=false `
Beispielausgabe:
`"ClientVpnEndpointId": "cvpn-endpoint-0123456789abcdefg", "Status": { "Code": "pending-associate" }, "DnsName": "cvpn-endpoint-0123456789abcdefg.prod.clientvpn.us-east-1.amazonaws.com" } `
**Zuordnen der Zielnetzwerke zum VPN-Endpunkt**
+ Wählen Sie den neuen VPN-Endpunkt und dann die Registerkarte **Associations (Zuordnungen)** aus.
+ Wählen Sie **Associate (Zuordnen)** aus und nutzen Sie die folgenden Optionen:
+ **VPC**: Wählen Sie die VPC des MemoryDB-Clusters aus.
+ Wählen Sie eines der Netzwerke des MemoryDB-Clusters aus. Überprüfen Sie im Zweifelsfall die Netzwerke in den **Subnetzgruppen im MemoryDB-Dashboard**.
+ Wählen Sie **Associate (Zuordnen)**aus. Wiederholen Sie ggf. die Schritte für die verbleibenden Netzwerke.
**Mit dem AWS CLI**
Führen Sie den folgenden Befehl aus:
`aws ec2 associate-client-vpn-target-network --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --subnet-id subnet-0123456789abdcdef`
Beispielausgabe:
`"Status": { "Code": "associating" }, "AssociationId": "cvpn-assoc-0123456789abdcdef" } `
**Überprüfen der VPN-Sicherheitsgruppe**
Der VPN-Endpunkt übernimmt automatisch die Standard-Sicherheitsgruppe der VPC. Überprüfen Sie die Regeln für eingehenden und ausgehenden Datenverkehr und bestätigen Sie, ob die Sicherheitsgruppe den Datenverkehr vom VPN-Netzwerk (definiert in den VPN-Endpunkteinstellungen) zu den MemoryDB-Netzwerken an den Serviceports zulässt (standardmäßig 6379 für Redis).
Wenn Sie die Sicherheitsgruppe ändern müssen, die dem VPN-Endpunkt zugewiesen ist, gehen Sie wie folgt vor:
+ Wählen Sie die aktuelle Sicherheitsgruppe aus.
+ Klicken Sie auf **Apply Security Group (Sicherheitsgruppe anwenden)**.
+ Wählen Sie die neue Sicherheitsgruppe aus.
**Verwenden der AWS CLI**
Führen Sie den folgenden Befehl aus:
`aws ec2 apply-security-groups-to-client-vpn-target-network --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefga --vpc-id vpc-0123456789abdcdef --security-group-ids sg-0123456789abdcdef`
Beispielausgabe:
`"SecurityGroupIds": [ "sg-0123456789abdcdef" ] } `
**Anmerkung**
Die MemoryDB-Sicherheitsgruppe muss auch den Datenverkehr zulassen, der von den VPN-Clients kommt. Die Adressen der Clients werden entsprechend dem VPC-Netzwerk mit der VPN-Endpunktadresse maskiert. Berücksichtigen Sie daher das VPC-Netzwerk (nicht das Netzwerk der VPN-Clients), wenn Sie die Regel für eingehenden Datenverkehr für die MemoryDB-Sicherheitsgruppe erstellen.
**Autorisieren des VPN-Zugriffs auf die Zielnetzwerke**
Wählen Sie auf der Registerkarte **Authorization (Autorisierung)** die Option **Authorize Ingress (Autorisierung eingehender Daten)** aus und geben Sie Folgendes an:
+ Zielnetzwerk, um den Zugriff zu ermöglichen: Verwenden Sie entweder 0.0.0.0/0, um den Zugriff auf jedes Netzwerk (einschließlich des Internets) zu ermöglichen, oder schränken Sie die MemoryDB-Netzwerke/Hosts ein.
+ Wählen Sie unter **Grant access to: (Zugriff gewähren für:)** die Option **Allow access to all users (Zugriff für alle Benutzer zulassen)**aus.
+ Wählen Sie **Add Authorization Rules (Autorisierungsregeln hinzufügen)**aus.
**Mit dem AWS CLI**
Führen Sie den folgenden Befehl aus:
`aws ec2 authorize-client-vpn-ingress --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --target-network-cidr 0.0.0.0/0 --authorize-all-groups`
Beispielausgabe:
`{ "Status": { "Code": "authorizing" } }`
**Ermöglichen des Zugriffs auf das Internet über VPN-Clients**
Wenn Sie über das VPN im Internet surfen müssen, müssen Sie eine zusätzliche Route erstellen. Wählen Sie die Registerkarte **Route Table (Routentabelle)** und dann die Option **Create Route (Route erstellen)** aus:
+ Routenziel: 0.0.0.0/0
+ **Target VPC Subnet ID (Ziel-VPC-Subnetz-ID)**: Wählen Sie eines der zugeordneten Subnetze mit Zugang zum Internet aus.
+ Klicken Sie auf **Create Route (Route erstellen)**.
**Mit dem AWS CLI**
Führen Sie den folgenden Befehl aus:
`aws ec2 create-client-vpn-route --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg --destination-cidr-block 0.0.0.0/0 --target-vpc-subnet-id subnet-0123456789abdcdef`
Beispielausgabe:
`{ "Status": { "Code": "creating" } } `
### Konfigurieren des VPN-Clients
Wählen Sie im AWS Client-VPN-Dashboard den kürzlich erstellten VPN-Endpunkt aus und wählen Sie **Client-Konfiguration herunterladen** aus. Kopieren Sie die Konfigurationsdatei sowie die Dateien `easy-rsa/pki/issued/client1.domain.tld.crt` und `easy-rsa/pki/private/client1.domain.tld.key`. Bearbeiten Sie die Konfigurationsdatei und ändern oder fügen Sie die folgenden Parameter hinzu:
+ cert: Fügen Sie eine neue Zeile hinzu, wobei der Parameter „cert“ auf die Datei `client1.domain.tld.crt` verweist. Verwenden Sie den vollständigen Pfad zu der Datei. Beispiel: `cert /home/user/.cert/client1.domain.tld.crt`
+ cert: key: Fügen Sie eine neue Zeile hinzu, wobei der Parameter „key“ auf die Datei `client1.domain.tld.key` verweist. Verwenden Sie den vollständigen Pfad zu der Datei. Beispiel: `key /home/user/.cert/client1.domain.tld.key`
Stellen Sie die VPN-Verbindung mit folgendem Befehl her: `sudo openvpn --config downloaded-client-config.ovpn`
**Aufheben des Zugriffs**
Soll die Gültigkeit des Zugriffs eines bestimmten Clientschlüssels aufgehoben werden, muss der Schlüssel in der Zertifizierungsstelle widerrufen werden. Senden Sie dann die Sperrliste an AWS Client VPN.
Widerrufen des Schlüssels mit easy-rsa:
+ `cd easy-rsa`
+ `./easyrsa3/easyrsa revoke client1.domain.tld`
+ Geben Sie „yes“ (Ja) ein, um fortzufahren, oder nehmen Sie zum Abbrechen eine andere Eingabe vor.
`Continue with revocation: `yes` ... * `./easyrsa3/easyrsa gen-crl`
+ Es wurde eine aktualisierte CRL erstellt. CRL-Datei: `/home/user/easy-rsa/pki/crl.pem`
Import der Sperrliste in das AWS Client VPN:
+ Wählen Sie auf dem AWS-Managementkonsole**Dienste** und dann **VPC** aus.
+ Wählen Sie **Client VPN Endpoints (Client-VPN-Endpunkte** aus.
+ Wählen Sie den Client-VPN-Endpunkt aus und klicken Sie dann auf **Actions (Aktionen)** -> **Import Client Certificate CRL (Client-Zertifikats-CRL importieren)**.
+ Fügen Sie den Inhalt der Datei `crl.pem`-Datei ein:
**Verwenden Sie den AWS CLI**
Führen Sie den folgenden Befehl aus:
`aws ec2 import-client-vpn-client-certificate-revocation-list --certificate-revocation-list file://./easy-rsa/pki/crl.pem --client-vpn-endpoint-id cvpn-endpoint-0123456789abcdefg `
Beispielausgabe:
`Example output: { "Return": true } `
# Ermitteln von Verbindungsendpunkten
Ihre Anwendung stellt über den Endpunkt eine Verbindung zu Ihrem Cluster her. Ein Endpunkt ist die eindeutige Adresse eines Clusters. Verwenden Sie den *Cluster-Endpunkt des Clusters* für alle Operationen.
In den folgenden Abschnitten erfahren Sie, welchen Endpunkt Sie benötigen.
## Den Endpunkt für einen MemoryDB-Cluster finden ()AWS-Managementkonsole
**Um den Endpunkt eines MemoryDB-Clusters zu finden**
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 im Navigationsbereich **Cluster (Cluster)** aus.
Der Cluster-Bildschirm mit einer Liste von Clustern wird angezeigt. Wählen Sie den Cluster aus, zu dem Sie eine Verbindung herstellen möchten.
1. Um den Endpunkt des Clusters zu finden, wählen Sie den Namen des Clusters (nicht das Optionsfeld).
1. Der **Cluster-Endpunkt** wird unter **Cluster-Details** angezeigt. Wählen Sie zum Kopieren das Symbol *Copy* (Kopieren) links vom Endpunkt aus.
## Den Endpunkt für einen MemoryDB-Cluster (AWS CLI) finden
Sie können den `describe-clusters` Befehl verwenden, um den Endpunkt für einen Cluster zu ermitteln. Der Befehl gibt den Endpunkt des Clusters zurück.
Mit der folgenden Operation wird der Endpunkt, der in diesem Beispiel als a dargestellt wird*sample*, für den Cluster `mycluster` abgerufen.
Sie gibt die folgende JSON-Antwort zurück:
```
aws memorydb describe-clusters \
--cluster-name mycluster
```
Für Windows:
```
aws memorydb describe-clusters ^
--cluster-name mycluster
```
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 1,
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
},
"NodeType": "db.r6g.large",
"EngineVersion": "6.2",
"EnginePatchVersion": "6.2.4",
"ParameterGroupName": "default.memorydb-redis6",
"ParameterGroupStatus": "in-sync",
"SubnetGroupName": "my-sg",
"TLSEnabled": true,
"ARN": "arn:aws:memorydb:us-east-1:zzzexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"AutoMinorVersionUpgrade": true
}
]
}
```
Weitere Informationen finden Sie unter [describe-clusters](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-clusters.html).
## Den Endpunkt für einen MemoryDB-Cluster finden (MemoryDB-API)
Sie können die MemoryDB-API verwenden, um den Endpunkt eines Clusters zu ermitteln.
### Den Endpunkt für einen MemoryDB-Cluster finden (MemoryDB-API)
Sie können die MemoryDB-API verwenden, um den Endpunkt für einen Cluster mit der Aktion zu ermitteln. `DescribeClusters` Die Aktion gibt den Endpunkt des Clusters zurück.
Der folgende Vorgang ruft den Cluster-Endpunkt für den Cluster `mycluster` ab.
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=mycluster
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&Version=2021-01-01
&X-Amz-Credential=
```
Weitere Informationen finden Sie unter [DescribeClusters](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_DescribeClusters.html).
# Arbeiten mit Shards
Ein Shard ist eine Sammlung von ein bis sechs Knoten. Sie können einen Cluster mit einer höheren Anzahl von Shards und einer geringeren Anzahl von Replikaten mit insgesamt bis zu 500 Knoten pro Cluster erstellen. Diese Clusterkonfiguration kann von 500 Shards und 0 Replikaten bis hin zu 100 Shards und 4 Replikaten reichen, was der maximal zulässigen Anzahl von Replikaten entspricht. Die Daten des Clusters werden über die Shards des Clusters hinweg partitioniert. Wenn ein Shard mehr als einen Knoten enthält, implementiert der Shard die Replikation, wobei ein Knoten der read/write primäre Knoten und die anderen Knoten schreibgeschützte Replikatknoten sind.
Wenn Sie mit dem einen MemoryDB-Cluster erstellen AWS-Managementkonsole, geben Sie die Anzahl der Shards im Cluster und die Anzahl der Knoten in den Shards an. Weitere Informationen finden Sie unter [Einen MemoryDB-Cluster erstellen](getting-started.md#clusters.create).
Für jeden Knoten in einem Shard gelten dieselben Rechner-, Arbeitsspeicher- und Festspeicherspezifikationen. Mit der MemoryDB-API können Sie clusterweite Attribute wie die Anzahl der Knoten, Sicherheitseinstellungen und Systemwartungsfenster steuern.
Weitere Informationen erhalten Sie unter [Offline-Resharding für MemoryDB](cluster-resharding-offline.md) und [Online-Resharding für MemoryDB](cluster-resharding-online.md).
## Den Namen eines Shards finden
Sie können den Namen eines Shards mithilfe der AWS-Managementkonsole, der AWS CLI oder der MemoryDB-API finden.
### Unter Verwendung der AWS-Managementkonsole
Das folgende Verfahren verwendet die AWS-Managementkonsole , um die Shard-Namen eines MemoryDB-Clusters zu finden.
****
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 im linken Navigationsbereich Clusters aus.**
1. Wählen Sie unter **Name** den Cluster aus, nach dessen Shard-Namen Sie suchen möchten.
1. **Sehen Sie sich auf der Registerkarte **Shards and Nodes** die Liste der Shards unter Name an.** Sie können die einzelnen Knoten auch erweitern, um Details zu ihren Knoten anzuzeigen.
### Mit dem AWS CLI
Um Shard-Namen (Shard) für MemoryDB-Cluster zu finden, verwenden Sie den AWS CLI Vorgang `describe-clusters` mit dem folgenden optionalen Parameter.
+ **`--cluster-name`**— Ein optionaler Parameter, der, wenn er verwendet wird, die Ausgabe auf die Details des angegebenen Clusters beschränkt. Wenn dieser Parameter weggelassen wird, werden die Details von bis zu 100 Clustern zurückgegeben.
+ **`--show-shard-details`**— Gibt Details zu den Shards zurück, einschließlich ihrer Namen.
Dieser Befehl gibt die Details für `my-cluster` zurück.
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 gibt die folgende JSON-Antwort zurück:
Die Zeilenumbrüche dienen der besseren Lesbarkeit.
```
{
"Clusters": [
{
"Name": "my-cluster",
"Status": "available",
"NumberOfShards": 1,
"Shards": [
{
"Name": "0001",
"Status": "available",
"Slots": "0-16383",
"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.xxxxx.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.xxxxx.memorydb.us-east-1.amazonaws.com",
"Port": 6379
}
}
],
"NumberOfNodes": 2
}
],
"ClusterEndpoint": {
"Address": "clustercfg.my-cluster.xxxxx.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:xxxxxexamplearn:cluster/my-cluster",
"SnapshotRetentionLimit": 0,
"MaintenanceWindow": "wed:03:00-wed:04:00",
"SnapshotWindow": "04:30-05:30",
"ACLName": "my-acl",
"DataTiering": "false",
"AutoMinorVersionUpgrade": true
}
]
}
```
### Verwenden der MemoryDB-API
Verwenden Sie die API-Operation mit dem folgenden optionalen Parameter, um Shard-IDs für MemoryDB-Cluster `DescribeClusters` zu finden.
+ **`ClusterName`**— Ein optionaler Parameter, der, wenn er verwendet wird, die Ausgabe auf die Details des angegebenen Clusters beschränkt. Wenn dieser Parameter weggelassen wird, werden die Details von bis zu 100 Clustern zurückgegeben.
+ **`ShowShardDetails`**— Gibt Details zu den Shards zurück, einschließlich ihrer Namen.
**Example**
Dieser Befehl gibt die Details für `my-cluster` zurück.
Für Linux, macOS oder Unix:
```
https://memory-db.us-east-1.amazonaws.com/
?Action=DescribeClusters
&ClusterName=sample-cluster
&ShowShardDetails=true
&Version=2021-01-01
&SignatureVersion=4
&SignatureMethod=HmacSHA256
&Timestamp=20210802T192317Z
&X-Amz-Credential=
```