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.
# Bereitstellungen von Multi-AZ-DB-Clustern für Amazon RDS
Eine *Bereitstellung von Multi-AZ-DB-Clustern* ist ein halbsynchroner Bereitstellungsmodus für Hochverfügbarkeit von Amazon RDS mit zwei lesbaren Replikat-DB-Instances. Ein Multi-AZ-DB-Cluster verfügt über eine Schreiber-DB-Instance und zwei Leser-DB-Instances in drei separaten Availability Zones in der selben AWS-Region. Multi-AZ-DB-Cluster bieten hohe Verfügbarkeit, erhöhte Kapazität für Lese-Workloads und eine geringere Schreiblatenz im Vergleich zu Multi-AZ DB-Instance-Bereitstellungen.
Sie können Daten aus einer On-Premises-Datenbank in einen Multi-AZ-DB-Cluster importieren, indem Sie die Anweisungen unter [Importieren von Daten in eine Datenbank von Amazon RDS für MySQL mit reduzierter Ausfallzeit](mysql-importing-data-reduced-downtime.md) befolgen.
Sie können Reserved DB-Instances für einen Multi-AZ-DB-Cluster erwerben. Weitere Informationen finden Sie unter [Reserved DB-Instances für einen Multi-AZ-DB-Cluster](USER_WorkingWithReservedDBInstances.md#USER_WorkingWithReservedDBInstances.MultiAZDBClusters).
Die Verfügbarkeit von Funktionen und der Support variieren zwischen bestimmten Versionen der einzelnen Datenbank-Engines und in allen AWS-Regionen. Weitere Informationen zu Versions- und Regionsverfügbarkeit von Amazon RDS mit Multi-AZ-DB-Clustern finden Sie unter [Unterstützte Regionen und DB-Engines für DB-Cluster mit Multi-AZ in Amazon RDS.](Concepts.RDS_Fea_Regions_DB-eng.Feature.MultiAZDBClusters.md).
**Topics**
+ [Verfügbarkeit von Instance-Klassen für Multi-AZ-DB-Cluster](#multi-az-db-clusters-concepts.InstanceAvailability)
+ [Architektur von Multi-AZ-DB-Clustern](#multi-az-db-clusters-concepts-overview)
+ [Parametergruppen für Multi-AZ-DB-Cluster](#multi-az-db-clusters-concepts-parameter-groups)
+ [RDS-Proxy mit Multi-AZ-DB-Clustern](#multi-az-db-clusters-proxy)
+ [Replikatverzögerung und Multi-AZ-DB-Cluster](#multi-az-db-clusters-concepts-replica-lag)
+ [Snapshots von Multi-AZ-DB-Clustern](#multi-az-db-clusters-concepts-snapshot)
+ [Erstellen eines Multi-AZ-DB-Clusters für Amazon RDS](create-multi-az-db-cluster.md)
+ [Herstellen einer Verbindung mit einem Multi-AZ-DB-Cluster für Amazon RDS](multi-az-db-clusters-concepts-connection-management.md)
+ [Automatisches Verbinden einer AWS-Rechenressource und eines Multi-AZ-DB-Clusters für Amazon RDS](multi-az-compute-rds-connect.md)
+ [Ändern eines Multi-AZ-DB-Clusters für Amazon RDS](modify-multi-az-db-cluster.md)
+ [Aktualisieren der Engine-Version eines Multi-AZ-DB-Clusters für Amazon RDS](multi-az-db-clusters-upgrading.md)
+ [Umbenennen eines Multi-AZ-DB-Clusters für Amazon RDS](multi-az-db-cluster-rename.md)
+ [Neustarten von Multi-AZ-DB-Clustern und Reader-DB-Instances für Amazon RDS](multi-az-db-clusters-concepts-rebooting.md)
+ [Failover eines Multi-AZ-DB-Clusters für Amazon RDS](multi-az-db-clusters-concepts-failover.md)
+ [Einrichten der logischen PostgreSQL-Replikation mit DB-Clustern mit Multi-AZ für Amazon RDS](USER_MultiAZDBCluster_LogicalRepl.md)
+ [Arbeiten mit Lesereplikaten von DB-Clustern mit Multi-AZ für Amazon RDS](USER_MultiAZDBCluster_ReadRepl.md)
+ [Einrichten der externen Replikation von Multi-AZ-DB-Clustern für Amazon RDS](multi-az-db-clusters-external-replication.md)
+ [Löschen eines DB-Clusters mit Multi-AZ für Amazon RDS](USER_DeleteMultiAZDBCluster.Deleting.md)
+ [Einschränkungen von Multi-AZ-DB-Clustern für Amazon RDS](multi-az-db-clusters-concepts.Limitations.md)
**Wichtig**
Multi-AZ-DB-Cluster sind nicht dasselbe wie Aurora-DB-Cluster. Informationen zu Aurora-DB-Clustern finden Sie im [Amazon-Aurora-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html).
## Verfügbarkeit von Instance-Klassen für Multi-AZ-DB-Cluster
Bereitstellungen von Multi-AZ-DB-Clustern werden für die folgenden DB-Instance-Klassen unterstützt: `db.m5d`, `db.m6gd`, `db.m6id`, `db.m6idn`, `db.r5d`, `db.r6gd`, `db.x2iedn`, `db.r6id` `db.r6idn` und `db.c6gd`.
**Anmerkung**
Die c6gd-Instance-Klassen sind die einzigen, die die Instance-Größe `medium` unterstützen.
Weitere Informationen zu DB-Instance-Klassen finden Sie unter [](Concepts.DBInstanceClass.md).
## Architektur von Multi-AZ-DB-Clustern
Bei einem Multi-AZ-DB-Cluster repliziert Amazon RDS Daten von der Writer-DB-Instance auf beide Reader-DB-Instances mithilfe der nativen Replikationsfunktionen der DB-Engine. Wenn eine Änderung an der Writer-DB-Instance vorgenommen wird, wird sie an jede Reader-DB-Instance gesendet.
Multi-AZ-DB-Cluster-Bereitstellungen verwenden eine halbsynchrone Replikation, bei der eine Bestätigung von mindestens einer Reader-DB-Instance erforderlich ist, damit eine Änderung festgeschrieben wird. Es ist keine Bestätigung dafür erforderlich, dass die Ereignisse vollständig ausgeführt wurden und ein Commit für *alle* Replikate ausgeführt wurde.
Reader-DB-Instances fungieren als automatische Failover-Ziele und dienen auch dem Leseverkehr, um den Lesedurchsatz der Anwendung zu erhöhen. Wenn auf Ihrer Writer-DB-Instance ein Ausfall auftritt, verwaltet RDS das Failover auf eine der Reader-DB-Instances. RDS tut dies basierend darauf, welche Reader-DB-Instance über den neuesten Änderungsdatensatz verfügt.
Das folgende Diagramm zeigt einen Multi-AZ-DB-Cluster.
![\[Multi-AZ-DB-Cluster\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/multi-az-db-cluster.png)
Multi-AZ-DB-Cluster haben in der Regel eine geringere Schreiblatenz im Vergleich zu Multi-AZ-DB-Instance-Bereitstellungen. Auch schreibgeschützte Workloads dürfen auf Reader-DB-Instances ausgeführt werden. Die RDS-Konsole zeigt die Availability Zone der Schreib-DB-Instance und die Availability Zones der Reader DB-Instances an. Sie können auch den [describe-db-clusters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-clusters.html)CLI-Befehl oder den Vorgang [Describe DBClusters](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusters.html) API verwenden, um diese Informationen zu finden.
**Wichtig**
Um Replikatfehler in Multi-AZ-DB-Clustern von RDS für MySQL zu vermeiden, empfehlen wir dringend, dass alle Tabellen über einen Primärschlüssel verfügen sollten.
## Parametergruppen für Multi-AZ-DB-Cluster
In einem Multi-AZ-DB-Cluster fungiert eine *DB-Cluster-Parametergruppe* als Container für Engine-Konfigurationswerte, die auf jede DB-Instance im Multi-AZ-DB-Cluster angewendet werden.
In einem Multi-AZ-DB-Cluster wird eine *DB-Parametergruppe* auf die Standard-DB-Parametergruppe für die DB-Engine und die DB-Engine-Version festgelegt. Die Einstellungen in der Parametergruppe des DB-Clusters werden für alle DB-Instances im Cluster verwendet.
Informationen zu Parametergruppen finden Sie unter [Arbeiten mit DB-Cluster-Parametergruppen für Multi-AZ-DB-Cluster](USER_WorkingWithDBClusterParamGroups.md).
## RDS-Proxy mit Multi-AZ-DB-Clustern
Sie können den Amazon-RDS-Proxy zum Erstellen eines Proxys für Ihre Multi-AZ-DB-Cluster verwenden. Durch die Verwendung des RDS-Proxys können die Anwendungen Datenbankverbindungen bündeln und gemeinsam nutzen, um ihre Skalierbarkeit zu verbessern. Jeder Proxy führt *Multiplexing* von Verbindungen aus, auch bekannt als Wiederverwendung von Verbindungen. Beim Multiplexing führt RDS-Proxy alle Operationen für eine Transaktion mit einer zugrunde liegenden Datenbankverbindung aus. Der RDS-Proxy kann auch die Ausfallzeit für ein kleineres Versionsupgrade eines Multi-AZ-DB-Clusters auf eine Sekunde oder weniger verringern. Weitere Informationen zu den Vorteilen von RDS-Proxy finden Sie unter [Amazon RDS-Proxy ](rds-proxy.md).
Wenn Sie einen Proxy für einen Multi-AZ-DB-Cluster einrichten möchten, wählen Sie während der Cluster-Erstellung **RDS-Proxy erstellen** aus. Anweisungen zum Erstellen und Verwalten von RDS-Proxy-Endpunkten finden Sie unter [Arbeiten mit Amazon-RDS-Proxy-Endpunkten](rds-proxy-endpoints.md).
## Replikatverzögerung und Multi-AZ-DB-Cluster
Die *Replikatverzögerung* ist der Zeitunterschied zwischen der neuesten Transaktion auf der Writer-DB-Instance und der zuletzt angewendeten Transaktion auf einer Reader-DB-Instance. Die CloudWatch Amazon-Metrik `ReplicaLag` repräsentiert diesen Zeitunterschied. Weitere Informationen zu CloudWatch Metriken finden Sie unter[Überwachung von Amazon RDS mit Amazon CloudWatch](monitoring-cloudwatch.md).
Obwohl Multi-AZ-DB-Cluster eine hohe Schreibleistung ermöglichen, kann eine Replikatverzögerung aufgrund der Art der Engine-basierten Replikation immer noch auftreten. Da jedes Failover zuerst die Replikatverzögerung auflösen muss, bevor es eine neue Writer-DB-Instance fördert, ist die Überwachung und Verwaltung dieser Replikatverzögerung eine Überlegung wert.
Bei Multi-AZ-DB-Clustern von RDS für MySQL hängt die Failover-Zeit von der Replikatverzögerung der beiden verbleibenden Reader-DB-Instances ab. Beide Reader-DB-Instances müssen nicht angewendete Transaktionen anwenden, bevor eine von ihnen auf die neue Writer-DB-Instance befördert wird.
Bei Multi-AZ-DB-Clustern von RDS für PostgreSQL hängt die Failover-Zeit von der kleinsten Replikatverzögerung der beiden verbleibenden Reader-DB-Instances ab. Die Reader-DB-Instance mit der kleinsten Replikatverzögerung muss nicht angewendete Transaktionen anwenden, bevor sie auf die neue Writer-DB-Instance befördert wird.
Ein Tutorial, das Ihnen zeigt, wie Sie einen CloudWatch Alarm erstellen, wenn die Replikatverzögerung einen bestimmten Zeitraum überschreitet, finden Sie unter[Tutorial: Erstellen eines Amazon-CloudWatch-Alarms für Multi-AZ-DB-Cluster-Replikatverzögerung für Amazon RDS](multi-az-db-cluster-cloudwatch-alarm.md).
### Häufige Ursachen für Replikatverzögerung
Im Allgemeinen tritt eine Replikatverzögerung auf, wenn die Write-Workload zu hoch ist, als dass die Reader-DB-Instances die Transaktionen effizient anwenden könnten. Verschiedene Workloads können eine vorübergehende oder kontinuierliche Replikatverzögerung verursachen. Einige gängige Beispiele:
+ Hohe Write-Parallelität oder starke Batch-Aktualisierung auf der Writer-DB-Instance, wodurch der Anwendungsprozess auf den Reader-DB-Instances zurückbleibt.
+ Starke Read-Workload, die Ressourcen auf einer oder mehreren Reader-DB-Instances verwendet. Das Ausführen langsamer oder großer Abfragen kann sich auf den Anwendungsprozess auswirken und die Replikatverzögerung verursachen.
+ Transaktionen, die große Datenmengen oder DDL-Anweisungen ändern, können manchmal zu einer vorübergehenden Zunahme der Replikatverzögerung führen, da die Datenbank die Commit-Reihenfolge beibehalten muss.
### Minderung der Replikatverzögerung
Bei Multi-AZ-DB-Clustern für RDS für MySQL und RDS für PostgreSQL können Sie Replikatverzögerung verringern, indem Sie die Belastung Ihrer Writer-DB-Instance reduzieren. Sie können auch die Flusssteuerung verwenden, um Replikatverzögerung zu reduzieren. Die *Flusssteuerung* funktioniert, indem Schreibvorgänge auf der Writer-DB-Instance gedrosselt werden, wodurch sichergestellt wird, dass die Replikatverzögerung nicht unbegrenzt weiter zunimmt. Die Schreibdrosselung wird erreicht, indem am Ende einer Transaktion eine Verzögerung hinzugefügt wird, wodurch der Schreibdurchsatz auf der Writer-DB-Instance verringert wird. Obwohl die Flusskontrolle nicht garantiert, Verzögerungen zu verhindern, kann sie dazu beitragen, die allgemeine Verzögerung bei vielen Workloads zu reduzieren. Die folgenden Abschnitte enthalten Informationen zur Verwendung der Flusssteuerung mit RDS für MySQL und RDS für PostgreSQL.
#### Minderung der Replikatverzögerung durch Flusssteuerung für RDS für MySQL
Wenn Sie die Multi-AZ-DB-Cluster von RDS für MySQL verwenden, ist die Flusssteuerung standardmäßig mit dem dynamischen Parameter `rpl_semi_sync_master_target_apply_lag` aktiviert. Dieser Parameter gibt die Obergrenze an, die für die Replikatverzögerung gewünscht wird. Wenn sich die Replikatverzögerung diesem konfigurierten Limit nähert, drosselt die Flusssteuerung die Schreibtransaktionen auf der Writer-DB-Instance, um zu versuchen, die Replikatverzögerung unter dem angegebenen Wert einzudämmen. In einigen Fällen kann die Replikatverzögerung den angegebenen Grenzwert überschreiten. Standardmäßig ist dieser Parameter auf 120 Sekunden eingestellt. Um die Flusssteuerung zu deaktivieren, legen Sie diesen Parameter auf seinen Maximalwert von 86 400 Sekunden (ein Tag) fest.
Um die aktuelle Verzögerung anzuzeigen, die von der Flusssteuerung injiziert wird, zeigen Sie den Parameter `Rpl_semi_sync_master_flow_control_current_delay` an, indem Sie die folgende Abfrage ausführen.
```
SHOW GLOBAL STATUS like '%flow_control%';
```
Ihre Ausgabe sollte in etwa wie folgt aussehen.
```
+-------------------------------------------------+-------+
| Variable_name | Value |
+-------------------------------------------------+-------+
| Rpl_semi_sync_master_flow_control_current_delay | 2010 |
+-------------------------------------------------+-------+
1 row in set (0.00 sec)
```
**Anmerkung**
Die Verzögerung wird in Mikrosekunden angezeigt.
Wenn Sie Performance Insights für einen Multi-AZ-DB-Cluster von RDS für MySQL aktiviert haben, können Sie das Wait-Ereignis überwachen, das einer SQL-Anweisung entspricht, die angibt, dass die Abfragen durch ein Flusssteuerelement verzögert wurden. Wenn eine Verzögerung durch ein Flusssteuerungselement eingeführt wurde, können Sie das Wait-Rreignis `/wait/synch/cond/semisync/semi_sync_flow_control_delay_cond` anzeigen, das der SQL-Anweisung im Performance-Insights-Dashboard entspricht. Stellen Sie sicher, dass das Leistungsschema aktiviert ist, um diese Metriken anzuzeigen. Weitere Informationen zu Performance Insights finden Sie unter [Überwachung mit Performance Insights auf Amazon RDS](USER_PerfInsights.md).
#### Minderung der Replikatverzögerung durch Flusssteuerung für RDS für PostgreSQL
Wenn Sie die Multi-AZ-DB-Cluster von RDS für PostgreSQL verwenden, wird die Flusssteuerung als Erweiterung bereitgestellt. Sie aktiviert einen Hintergrund-Worker für alle DB-Instances im DB-Cluster. Standardmäßig kommunizieren die Hintergrund-Worker auf den Reader-DB-Instances die aktuelle Replikatverzögerung mit dem Hintergrund-Worker auf der Writer-DB-Instance. Wenn die Verzögerung bei einer Reader-DB-Instance zwei Minuten überschreitet, fügt der Hintergrund-Worker der Writer-DB-Instance am Ende einer Transaktion eine Verzögerung hinzu. Um den Verzögerungsschwellenwert zu steuern, verwenden Sie den Parameter `flow_control.target_standby_apply_lag`.
Wenn eine Flusskontrolle einen PostgreSQL-Prozess drosselt, weist das Warteereignis `Extension` in `pg_stat_activity` und Performance Insights darauf hin. Die Funktion `get_flow_control_stats` zeigt Details darüber an, wie viel Verzögerung gerade hinzugefügt wird.
Die Flusskontrolle kann den meisten Workloads bei der Online-Transaktionsverarbeitung (OLTP) zugute kommen, die kurze, aber sehr gleichzeitige Transaktionen aufweisen. Wenn die Verzögerung durch lang andauernde Transaktionen wie Batchvorgänge verursacht wird, bietet die Flusskontrolle keinen so starken Vorteil.
Sie können die Flusskontrolle ausschalten, indem Sie die Erweiterung aus `shared_preload_libraries` entfernen und Ihre DB-Instance neu starten.
## Snapshots von Multi-AZ-DB-Clustern
Amazon RDS erstellt während des konfigurierten Backup-Zeitfensters automatische Backups Ihres Multi-AZ-DB-Clusters und speichert diese. RDS erstellt einen Snapshot für das Speichervolume des DB-Clusters, sodass der gesamte Cluster gesichert wird und nicht nur einzelne Instances.
Sie können auch manuelle Backups des Multi-AZ-DB-Clusters durchführen. Für sehr langfristige Backups empfehlen wir den Export von Snapshot-Daten in Amazon S3. Weitere Informationen finden Sie unter [Erstellen eines DB-Cluster-Snapshots mit Multi-AZ für Amazon RDS](USER_CreateMultiAZDBClusterSnapshot.md).
Sie können einen Multi-AZ-DB-Cluster auf einen bestimmten Zeitpunkt wiederherstellen, wodurch ein neuer Multi-AZ-DB-Cluster erstellt wird. Detaillierte Anweisungen finden Sie unter [Wiederherstellen eines Multi-AZ-DB-Clusters zu einer bestimmten Zeit](USER_PIT.MultiAZDBCluster.md).
Alternativ können Sie einen Snapshot eines Multi-AZ-DB-Clusters in einer Single-AZ-Bereitstellung oder Multi-AZ-Bereitstellung der DB-Instance wiederherstellen. Detaillierte Anweisungen finden Sie unter [Wiederherstellen über einen Snapshot eines Multi-AZ-DB-Clusters in einer DB-Instance](USER_RestoreFromMultiAZDBClusterSnapshot.md).
# Erstellen eines Multi-AZ-DB-Clusters für Amazon RDS
Ein Multi-AZ-DB-Cluster verfügt über eine Writer-DB-Instance und zwei Reader-DB-Instances in drei separaten Availability Zones. Multi-AZ-DB-Cluster bieten hohe Verfügbarkeit, erhöhte Kapazität für Lese-Workloads und eine geringere Latenz im Vergleich zu Multi-AZ-Bereitstellungen. Weitere Informationen zu Multi-AZ-DB-Clustern finden Sie unter [Bereitstellungen von Multi-AZ-DB-Clustern für Amazon RDS](multi-az-db-clusters-concepts.md).
**Anmerkung**
Multi-AZ-DB-Cluster werden nur für die MySQL- und PostgreSQL-DB-Engines unterstützt.
## Voraussetzungen für DB-Cluster
**Wichtig**
Bevor Sie einen Multi-AZ DB-Cluster erstellen können, müssen Sie die Aufgaben unter [Einrichten Ihrer Umgebung für Amazon RDS](CHAP_SettingUp.md) abschließen.
Die folgenden Voraussetzungen müssen erfüllt sein, bevor Sie einen Multi-AZ DB-Cluster erstellen.
**Topics**
+ [Netzwerk für den DB-Cluster konfigurieren](#create-multi-az-db-cluster-prerequisites-VPC)
+ [Zusätzliche Voraussetzungen](#create-multi-az-db-cluster-prerequisites-additional)
### Netzwerk für den DB-Cluster konfigurieren
Sie können eine DB-Instance nur in einer Virtual Private Cloud (VPC) erstellen, die auf dem Amazon-VPC-Service basiert. Es muss sich in einer befinden AWS-Region , die mindestens drei Availability Zones hat. Die DB-Subnetzgruppe, die Sie für das DB-Cluster wählen, muss mindestens drei Availability Zones abdecken. Diese Konfiguration stellt sicher, dass sich jede DB-Instance im DB-Cluster in einer anderen Availability Zone befindet.
Wenn Sie die Konnektivität zwischen Ihrem neuen DB-Cluster und einer Amazon-EC2-Instance in derselben VPC einrichten möchten, können Sie dies während der Erstellung der DB-Instance tun. Wenn Sie von anderen Ressourcen als EC2-Instances in derselben VPC aus eine Verbindung zu Ihrem DB-Cluster herstellen möchten, konfigurieren Sie die Netzwerkverbindungen manuell.
**Topics**
+ [Automatische Netzwerkkonnektivität mit einer EC2-Instance konfigurieren](#create-multi-az-db-cluster-prerequisites-VPC-automatic)
+ [Manuelles Konfigurieren des Netzwerks](#create-multi-az-db-cluster-prerequisites-VPC-manual)
#### Automatische Netzwerkkonnektivität mit einer EC2-Instance konfigurieren
Wenn Sie einen Multi-AZ-DB-Cluster erstellen, können Sie den verwenden, AWS-Managementkonsole um die Konnektivität zwischen einer EC2-Instance und dem neuen DB-Cluster einzurichten. In diesem Fall konfiguriert RDS Ihre VPC- und Netzwerkeinstellungen automatisch. Der DB-Cluster wird in derselben VPC wie die EC2-Instance erstellt, sodass die EC2-Instance auf den DB-Cluster zugreifen kann.
Im Folgenden sind die Anforderungen für die Verbindung einer EC2-Instance mit dem DB-Cluster aufgeführt:
+ Die EC2-Instance muss in der vorhanden sein, AWS-Region bevor Sie den DB-Cluster erstellen.
Wenn in der keine EC2-Instances vorhanden sind AWS-Region, bietet die Konsole einen Link zum Erstellen einer.
+ Der Benutzer, der den DB-Cluster erstellt, muss über Berechtigungen zum Ausführen der folgenden Vorgänge verfügen:
+ `ec2:AssociateRouteTable`
+ `ec2:AuthorizeSecurityGroupEgress`
+ `ec2:AuthorizeSecurityGroupIngress`
+ `ec2:CreateRouteTable`
+ `ec2:CreateSubnet`
+ `ec2:CreateSecurityGroup`
+ `ec2:DescribeInstances`
+ `ec2:DescribeNetworkInterfaces`
+ `ec2:DescribeRouteTables`
+ `ec2:DescribeSecurityGroups`
+ `ec2:DescribeSubnets`
+ `ec2:ModifyNetworkInterfaceAttribute`
+ `ec2:RevokeSecurityGroupEgress`
Mit dieser Option wird ein privater DB-Cluster erstellt. Der DB-Cluster verwendet eine DB-Subnetzgruppe mit ausschließlich privaten Subnetzen, um den Zugriff auf Ressourcen innerhalb der VPC einzuschränken.
Um eine EC2-Instance mit dem DB-Cluster zu verbinden, wählen Sie **Connect to an EC2 compute resource** (Verbindung mit einer EC2-Compute-Ressource herstellen) im Abschnitt **Connectivity** (Konnektivität) auf der Seite **Create database** (Datenbank erstellen) aus.
![\[Eine EC2-Instance verbinden\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/ec2-set-up-connection-create.png)
Wenn Sie **Verbindung zu einer EC2-Rechenressource herstellen** wählen, legt RDS die folgenden Optionen automatisch fest. Sie können diese Einstellungen nur ändern, wenn Sie sich dafür entscheiden, keine Konnektivität mit einer EC2-Instance einzurichten, indem Sie **Keine Verbindung zu einer EC2-Rechenressource herstellen** wählen.
****
| Konsolenoption | Automatische Einstellung |
| --- | --- |
| **Virtual Private Cloud (VPC)** | RDS legt die VPC auf die VPC fest, die der EC2-Instance zugeordnet ist. |
| **DB-Subnetzgruppe** | RDS erfordert eine DB-Subnetzgruppe mit einem privaten Subnetz in derselben Availability Zone wie die EC2-Instance. Wenn eine DB-Subnetzgruppe vorhanden ist, die diese Anforderung erfüllt, dann verwendet RDS die vorhandene DB-Subnetzgruppe. Standardmäßig ist diese Option auf Automatic setup (Automatische Einrichtung) eingestellt. Wenn Sie **Automatic setup** (Automatische Einrichtung) auswählen und es keine DB-Subnetzgruppe gibt, die diese Anforderung erfüllt, wird die folgende Aktion ausgeführt. RDS verwendet drei verfügbare private Subnetze in drei Availability Zones, wobei eine der Availability Zones mit der AZ der EC2-Instance identisch ist. Wenn kein privates Subnetz in einer Availability Zone verfügbar ist, erstellt RDS ein privates Subnetz in der Availability Zone. Anschließend erstellt RDS die DB-Subnetzgruppe.Wenn ein privates Subnetz verfügbar ist, verwendet RDS die zugehörige Routing-Tabelle und fügt alle Subnetze, die es erstellt, dieser Routing-Tabelle hinzu. Wenn kein privates Subnetz verfügbar ist, erstellt RDS eine Routing-Tabelle ohne Internet-Gateway-Zugriff und fügt die erstellten Subnetze der Routing-Tabelle hinzu.Mit RDS können Sie auch vorhandene DB-Subnetzgruppen verwenden. Wählen Sie **Choose existing** (Vorhandene wählen) aus, wenn Sie eine vorhandene DB-Subnetzgruppe Ihrer Wahl verwenden möchten. |
| **Öffentlicher Zugriff** | RDS wählt **Nein**, so dass der DB-Cluster nicht öffentlich zugänglich ist. Aus Sicherheitsgründen ist es eine bewährte Methode, die Datenbank privat zu halten und sicherzustellen, dass sie nicht über das Internet zugänglich ist. |
| **VPC-Sicherheitsgruppe (Firewall)** | RDS erstellt eine neue Sicherheitsgruppe, die mit dem DB-Cluster verknüpft ist. Die Sicherheitsgruppe heißt `rds-ec2-n`, wobei `n` eine Zahl ist. Diese Sicherheitsgruppe enthält eine Regel für eingehenden Datenverkehr mit der EC2 VPC-Sicherheitsgruppe (Firewall) als Quelle. Diese Sicherheitsgruppe, die dem DB-Cluster zugeordnet ist, ermöglicht der EC2-Instance den Zugriff auf den DB-Cluster. RDS erstellt außerdem eine neue Sicherheitsgruppe, die der EC2-Instance zugeordnet ist. Die Sicherheitsgruppe heißt `ec2-rds-n`, wobei `n` eine Zahl ist. Diese Sicherheitsgruppe enthält eine ausgehende Regel mit der VPC-Sicherheitsgruppe des DB-Clusters als Quelle. Diese Sicherheitsgruppe ermöglicht es der EC2-Instance, Datenverkehr an den DB-Cluster zu senden. Sie können eine weitere neue Sicherheitsgruppe hinzufügen, indem Sie **Neu erstellen** wählen und den Namen der neuen Sicherheitsgruppe eingeben. Sie können vorhandene Sicherheitsgruppen hinzufügen, indem Sie **Bestehende auswählen** und Sicherheitsgruppen auswählen, die hinzugefügt werden sollen. |
| **Availability Zone** | RDS wählt die Availability Zone der EC2-Instance für eine DB-Instance in der Multi-AZ-DB-Cluster-Bereitstellung aus. RDS wählt nach dem Zufallsprinzip eine andere Availability Zone für beide anderen DB-Instances aus. Die Writer-DB-Instance wird in derselben Availability Zone erstellt wie die EC2-Instance. Es besteht die Möglichkeit von Kosten der Availability Zone, wenn ein Failover auftritt und sich die Writer-DB-Instance in einer anderen Availability Zone befindet. |
Weitere Informationen zu diesen Einstellungen finden Sie unter [Einstellungen zum Erstellen von Multi-AZ-DB-Clustern](#create-multi-az-db-cluster-settings).
Wenn Sie diese Einstellungen nach dem Erstellen des DB-Clusters ändern, können sich die Änderungen auf die Verbindung zwischen der EC2-Instance und dem DB-Cluster auswirken.
#### Manuelles Konfigurieren des Netzwerks
Wenn Sie von anderen Ressourcen als EC2-Instances in derselben VPC aus eine Verbindung zu Ihrem DB-Cluster herstellen möchten, konfigurieren Sie die Netzwerkverbindungen manuell. Wenn Sie den verwenden AWS-Managementkonsole , um Ihren Multi-AZ-DB-Cluster zu erstellen, können Sie Amazon RDS automatisch eine VPC für Sie erstellen lassen. Sie können auch eine bestehende VPC verwenden oder eine neue VPC für Ihren Multi-AZ-DB-Cluster erstellen. Ihre VPC muss mindestens ein Subnetz in jeder von mindestens drei Availability Zones haben, damit Sie sie mit einem Multi-AZ-DB-Cluster verwenden können. Informationen dazu finden Sie unter VPCs. [Amazon VPC und Amazon RDS](USER_VPC.md)
Wenn Sie keine Standard-VPC haben oder keine VPC erstellt haben und die Konsole nicht verwenden möchten, gehen Sie wie folgt vor:
+ Erstellen Sie eine VPC mit mindestens einem Subnetz in jeder der mindestens drei Availability Zones in der AWS Region, in der Sie Ihren DB-Cluster bereitstellen möchten. Weitere Informationen finden Sie unter [Arbeiten mit einer DB-Instance in einer VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md#Overview.RDSVPC.Create).
+ Legen Sie eine VPC-Sicherheitsgruppe fest, die Verbindungen mit Ihrem DB-Cluster autorisiert. Weitere Informationen erhalten Sie unter [Ermöglichen des Zugriffs auf Ihre DB-Instance in der VPC durch Erstellen einer Sicherheitsgruppe](CHAP_SettingUp.md#CHAP_SettingUp.SecurityGroup) und [Zugriffskontrolle mit Sicherheitsgruppen](Overview.RDSSecurityGroups.md).
+ Legen Sie eine RDS-DB-Subnetzgruppe fest, die mindestens drei Subnetze in der VPC definiert, die vom Multi-AZ-DB-Cluster verwendet werden können. Weitere Informationen finden Sie unter [Arbeiten mit DB-Subnetzgruppen](USER_VPC.WorkingWithRDSInstanceinaVPC.md#USER_VPC.Subnets).
Informationen zu Einschränkungen für Multi-AZ-DB-Cluster finden Sie unter [Einschränkungen von Multi-AZ-DB-Clustern für Amazon RDS](multi-az-db-clusters-concepts.Limitations.md).
Wenn Sie eine Verbindung mit einer Ressource herstellen möchten, die sich nicht in derselben VPC wie der Multi-AZ-DB-Cluster befindet, sehen Sie sich die entsprechenden Szenarien unter [Szenarien für den Zugriff auf eine DB-Instance in einer VPC](USER_VPC.Scenarios.md) an.
### Zusätzliche Voraussetzungen
Bevor Sie Ihren Multi-AZ-DB-Cluster erstellen, sollten Sie die folgenden zusätzlichen Voraussetzungen berücksichtigen:
+ Wenn Sie die Konfigurationsparameter für Ihren DB-Cluster anpassen möchten, müssen Sie eine DB-Cluster-Parametergruppe mit den erforderlichen Parametereinstellungen festlegen. Informationen über das Erstellen oder Ändern einer DB-Cluster-Parametergruppe finden Sie unter [Parametergruppen für Multi-AZ-DB-Cluster](multi-az-db-clusters-concepts.md#multi-az-db-clusters-concepts-parameter-groups).
+ Ermitteln Sie die TCP/IP Portnummer, die Sie für Ihren DB-Cluster angeben möchten. Die Firewalls einiger Unternehmen blockieren Verbindungen zu diesen Standard-Ports. Wenn die Firewall Ihres Unternehmens den Standard-Port blockiert, wählen Sie einen anderen Port für Ihr DB-Cluster aus. Alle DB-Instances in einem DB-Cluster verwenden denselben Port.
+ Wenn die Haupt-Engine-Version für Ihre Datenbank das Ende des Standard-Supports für RDS erreicht hat, müssen Sie die CLI-Option für Extended Support oder den RDS-API-Parameter verwenden. Weitere Informationen finden Sie im Abschnitt zu RDS Extended Support unter [Einstellungen zum Erstellen von Multi-AZ-DB-Clustern](#create-multi-az-db-cluster-settings).
## Erstellen eines DB-Clusters
Sie können einen Multi-AZ-DB-Cluster mithilfe der AWS-Managementkonsole AWS CLI, der oder der RDS-API erstellen.
### Konsole
Sie können einen Multi-AZ-DB-Cluster erstellen, indem Sie **Multi-AZ-DB-Cluster** im Abschnitt **Verfügbarkeit und Haltbarkeit** auswählen.
**Erstellen Sie einen Multi-AZ-DB-Cluster mithilfe der Konsole wie folgt:**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie in der oberen rechten Ecke des den aus AWS-Managementkonsole, AWS-Region in dem Sie den DB-Cluster erstellen möchten.
Informationen zu den AWS-Regionen , die Multi-AZ-DB-Cluster unterstützen, finden Sie unter. [Einschränkungen von Multi-AZ-DB-Clustern für Amazon RDS](multi-az-db-clusters-concepts.Limitations.md)
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** aus.
1. Wählen Sie **Create database (Datenbank erstellen)** aus.
Stellen Sie zum Erstellen eines Multi-AZ-DB-Clusters sicher, dass **Standarderstellung** ausgewählt ist und **Einfache Erstellung** nicht.
1. Wählen Sie unter **Engine-Typ** **MySQL** oder **PostgreSQL** aus.
1. Wählen Sie unter **Version** die DB-Engine-Version aus.
Weitere Informationen zu DB-Engine-Versionen, die Multi-AZ-DB-Cluster unterstützen, finden Sie unter [Einschränkungen von Multi-AZ-DB-Clustern für Amazon RDS](multi-az-db-clusters-concepts.Limitations.md).
1. Wählen Sie unter **Vorlagen** die entsprechende Vorlage für Ihre Bereitstellung aus.
1. Wählen Sie unter **Verfügbarkeit und Haltbarkeit** die Option **Multi-AZ-DB-Cluster** aus.
![\[Multi-AZ-DB-Cluster-Wahl\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/multi-az-db-cluster-create.png)
1. Geben Sie unter **DB-Cluster-Kennung** die Kennung für Ihren DB-Cluster ein.
1. Geben Sie unter **Haupt-Benutzername** Ihren Haupt-Benutzernamen ein oder behalten Sie die Standardeinstellung bei.
1. Geben Sie Ihr Haupt-Passwort ein:
1. Öffnen Sie im Abschnitt **Settings (Einstellungen)** die Option **Credential Settings (Einstellungen zu Anmeldeinformationen)**.
1. Wenn Sie ein Passwort angeben möchten, deaktivieren Sie das Kontrollkästchen **Passwort automatisch generieren**, wenn es aktiviert ist.
1. (Optional) Ändern Sie den Wert des **Haupt-Benutzernamens**.
1. Geben Sie das gleiche Passwort in **Haupt-Passwort** und **Passwort bestätigen** ein.
1. Wählen Sie unter **DB-Instance-Klasse** eine DB-Instance-Klasse aus. Eine Liste der unterstützten DB-Instance-Klassen, finden Sie unter [Verfügbarkeit von Instance-Klassen für Multi-AZ-DB-Cluster](multi-az-db-clusters-concepts.md#multi-az-db-clusters-concepts.InstanceAvailability).
1. (Optional) Richten Sie eine Verbindung zu einer Rechenressource für diesen DB-Cluster ein.
Sie können die Konnektivität zwischen einer Amazon-EC2-Instance und dem neuen DB-Cluster während der Erstellung eines DB-Clusters konfigurieren. Weitere Informationen finden Sie unter [Automatische Netzwerkkonnektivität mit einer EC2-Instance konfigurieren](#create-multi-az-db-cluster-prerequisites-VPC-automatic).
1. Wenn Sie im Abschnitt **Konnektivität** unter **VPC-Sicherheitsgruppe (Firewall)** die Option **Neu erstellen** auswählen, wird eine VPC-Sicherheitsgruppe mit einer Regel für eingehenden Datenverkehr erstellt, die es der IP-Adresse Ihres lokalen Computers ermöglicht, auf die Datenbank zuzugreifen.
1. In den übrigen Abschnitten geben Sie die Einstellungen für Ihren DB-Cluster an. Weitere Informationen zu den einzelnen Einstellungen finden Sie unter [Einstellungen zum Erstellen von Multi-AZ-DB-Clustern](#create-multi-az-db-cluster-settings).
1. Wählen Sie **Create database (Datenbank erstellen)** aus.
Wenn Sie ein automatisch generiertes Passwort verwenden, wird auf der Seite **Databases (Datenbanken)** die Schaltfläche **View credential details (Details zu Anmeldeinformationen anzeigen)** angezeigt.
Um den Hauptbenutzernamen und das Passwort für den DB-Cluster anzuzeigen, wählen Sie **Anmeldeinformationen anzeigen**.
Verwenden Sie den angezeigten Benutzernamen und das angezeigte Passwort, um sich als Hauptbenutzer mit dem DB-Cluster zu verbinden.
**Wichtig**
Sie können dieses Passwort für den Hauptbenutzer nicht erneut anzeigen.
1. Wählen Sie in **Databases (Datenbanken)** den Namen des neuen DB-Clusters aus.
In der RDS-Konsole werden die Details des neuen DB-Clusters angezeigt. Der DB-Cluster hat den Status **Wird erstellt**, bis der DB-Cluster erstellt und einsatzbereit ist. Wenn der Status zu **Available (Verfügbar)** geändert wird, können Sie eine Verbindung zum DB-Cluster herstellen. Je nach Klasse und Speicher des DB-Clusters kann es einige Minuten dauern, bis der neue DB-Cluster verfügbar ist.
### AWS CLI
Bevor Sie mit dem einen Multi-AZ-DB-Cluster erstellen AWS CLI, stellen Sie sicher, dass die erforderlichen Voraussetzungen erfüllt sind. Dazu gehören das Erstellen einer VPC und einer RDS-DB-Subnetzgruppe. Weitere Informationen finden Sie unter [Voraussetzungen für DB-Cluster](#create-multi-az-db-cluster-prerequisites).
Rufen Sie den Befehl auf, um mit dem einen Multi-AZ-DB-Cluster zu erstellen. AWS CLI[create-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html) Geben Sie `--db-cluster-identifier` an. Geben Sie für die `--engine`-Option entweder `mysql` oder `postgres` an.
Informationen zu den jeweiligen Optionen finden Sie unter [Einstellungen zum Erstellen von Multi-AZ-DB-Clustern](#create-multi-az-db-cluster-settings).
Informationen zu den AWS-Regionen DB-Engines und DB-Engine-Versionen, die Multi-AZ-DB-Cluster unterstützen, finden Sie unter. [Einschränkungen von Multi-AZ-DB-Clustern für Amazon RDS](multi-az-db-clusters-concepts.Limitations.md)
Der Befehl `create-db-cluster` erstellt die Writer-DB-Instance für Ihren DB-Cluster und zwei Reader-DB-Instances. Jede DB-Instance befindet sich in einer anderen Availability Zone.
Der folgende Befehl erstellt beispielsweise einen MySQL 8.0 Multi-AZ-DB-Cluster namens `mysql-multi-az-db-cluster`.
**Example**
Für Linux, macOS oder Unix:
```
1. aws rds create-db-cluster \
2. --db-cluster-identifier mysql-multi-az-db-cluster \
3. --engine mysql \
4. --engine-version 8.0.32 \
5. --master-username admin \
6. --manage-master-user-password \
7. --port 3306 \
8. --backup-retention-period 1 \
9. --db-subnet-group-name default \
10. --allocated-storage 4000 \
11. --storage-type io1 \
12. --iops 10000 \
13. --db-cluster-instance-class db.m5d.xlarge
```
Für Windows:
```
1. aws rds create-db-cluster ^
2. --db-cluster-identifier mysql-multi-az-db-cluster ^
3. --engine mysql ^
4. --engine-version 8.0.32 ^
5. --manage-master-user-password ^
6. --master-username admin ^
7. --port 3306 ^
8. --backup-retention-period 1 ^
9. --db-subnet-group-name default ^
10. --allocated-storage 4000 ^
11. --storage-type io1 ^
12. --iops 10000 ^
13. --db-cluster-instance-class db.m5d.xlarge
```
Der folgende Befehl erstellt einen PostgreSQL 13.4 Multi-AZ DB-Cluster namens `postgresql-multi-az-db-cluster`.
**Example**
Für Linux, macOS oder Unix:
```
1. aws rds create-db-cluster \
2. --db-cluster-identifier postgresql-multi-az-db-cluster \
3. --engine postgres \
4. --engine-version 13.4 \
5. --manage-master-user-password \
6. --master-username postgres \
7. --port 5432 \
8. --backup-retention-period 1 \
9. --db-subnet-group-name default \
10. --allocated-storage 4000 \
11. --storage-type io1 \
12. --iops 10000 \
13. --db-cluster-instance-class db.m5d.xlarge
```
Für Windows:
```
1. aws rds create-db-cluster ^
2. --db-cluster-identifier postgresql-multi-az-db-cluster ^
3. --engine postgres ^
4. --engine-version 13.4 ^
5. --manage-master-user-password ^
6. --master-username postgres ^
7. --port 5432 ^
8. --backup-retention-period 1 ^
9. --db-subnet-group-name default ^
10. --allocated-storage 4000 ^
11. --storage-type io1 ^
12. --iops 10000 ^
13. --db-cluster-instance-class db.m5d.xlarge
```
### RDS-API
Bevor Sie ein Multi-AZ-DB-Cluster über die RDS-API erstellen können, müssen Sie die Voraussetzungen erfüllen, wie das Erstellen einer VPC und einer RDS-DB-Subnetzgruppe. Weitere Informationen finden Sie unter [Voraussetzungen für DB-Cluster](#create-multi-az-db-cluster-prerequisites).
Rufen Sie den Vorgang Create auf, um mithilfe der RDS-API einen Multi-AZ-DB-Cluster [zu erstellen DBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html). Geben Sie `DBClusterIdentifier` an. Geben Sie für den `Engine`-Parameter entweder `mysql` oder `postgresql` an.
Informationen zu den jeweiligen Optionen finden Sie unter [Einstellungen zum Erstellen von Multi-AZ-DB-Clustern](#create-multi-az-db-cluster-settings).
Die Operation `CreateDBCluster` erstellt die Writer-DB-Instance für Ihren DB-Cluster und zwei Reader-DB-Instances. Jede DB-Instance befindet sich in einer anderen Availability Zone.
## Einstellungen zum Erstellen von Multi-AZ-DB-Clustern
Ausführliche Informationen zu den Einstellungen, die Sie beim Erstellen eines Multi-AZ-DB-Clusters auswählen, finden Sie in der folgenden Tabelle. Weitere Informationen zu den AWS CLI Optionen finden Sie unter [create-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html). Weitere Informationen zu den RDS-API-Parametern finden Sie unter [Create DBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html).
| Konsoleneinstellung | Beschreibung der Einstellung | CLI-Option und RDS-API-Parameter |
| --- | --- | --- |
| **Allocated storage** | Die für jede DB-Instance in Ihrem DB-Cluster zuzuweisende Speichermenge (in Gibibyte). Weitere Informationen finden Sie unter [Amazon-RDS-DB-Instance-Speicher](CHAP_Storage.md). | **CLI-Option:** `--allocated-storage` **API-Parameter:** `AllocatedStorage` |
| Automatische Nebenversions-Updates | **Aktivieren Sie das automatische Upgrade der Nebenversion**, damit Ihr DB-Cluster automatisch Upgrades der bevorzugten Nebenversion der DB-Engine erhält, wenn diese verfügbar sind. Amazon RDS führt im Wartungsfenster automatische Nebenversionenupgrades durch. | **CLI-Option:** `--auto-minor-version-upgrade` `--no-auto-minor-version-upgrade` **API-Parameter:** `AutoMinorVersionUpgrade` |
| Aufbewahrungszeitraum für Backups | Die Anzahl der Tage, für die automatischen Backups der DB-Cluster aufbewahrt werden sollen. Bei einem Multi-AZ-DB-Cluster muss dieser Wert auf **1** oder höher gesetzt werden. Weitere Informationen finden Sie unter [Einführung in Backups](USER_WorkingWithAutomatedBackups.md). | **CLI-Option:** `--backup-retention-period` **API-Parameter:** `BackupRetentionPeriod` |
| Backup window | Der Zeitraum, in dem Amazon RDS automatisch ein Backup der DB-Cluster erstellt. Wenn Sie keine bestimmte Zeit haben, zu der Sie Ihre Datenbank sichern möchten, verwenden Sie den Standardwert **No Preference (Keine Präferenz)**. Weitere Informationen finden Sie unter [Einführung in Backups](USER_WorkingWithAutomatedBackups.md). | **CLI-Option:** `--preferred-backup-window` **API-Parameter:** `PreferredBackupWindow` |
| **Zertifizierungsstelle** | Die Zertifizierungsstelle (CA) für das Serverzertifikat, das vom DB-Cluster verwendet wird. Weitere Informationen finden Sie unter [](UsingWithRDS.SSL.md). | **CLI-Option:** `--ca-certificate-identifier` **RDS-API-Parameter:** `CACertificateIdentifier` |
| Tags zu Snapshots kopieren | Diese Option kopiert alle DB-Cluster-Tags in einen DB-Snapshot, wenn Sie einen Snapshot erstellen. Weitere Informationen finden Sie unter [Taggen von Amazon RDS-Ressourcen](USER_Tagging.md). | **CLI-Option:** `-copy-tags-to-snapshot` `-no-copy-tags-to-snapshot` **RDS-API-Parameter:** `CopyTagsToSnapshot` |
| Datenbank-Authentifizierung | Die Datenbankauthentifizierungsoption, die Sie verwenden möchten. Wählen Sie **Passwortauthentifizierung** aus, um Datenbankbenutzer ausschließlich mit Datenbankpasswörtern zu authentifizieren. Wählen Sie **Password and IAM DB authentication** (Passwort- und IAM-DB-Authentifizierung) aus, um Datenbankbenutzer mit Datenbankpasswörtern und Benutzeranmeldeinformationen über Benutzer und Rollen zu authentifizieren. Weitere Informationen finden Sie unter [IAM-Datenbankauthentifizierungfür MariaDB, MySQL und PostgreSQL](UsingWithRDS.IAMDBAuth.md). | **CLI-Option:** `--enable-iam-database-authentication` `--no-enable-iam-database-authentication` **RDS-API-Parameter:** `EnableIAMDatabaseAuthentication` |
| Datenbankport | Der Port, über den Sie auf den DB-Cluster zugreifen wollen. Der Standardport wird angezeigt. Der Port kann nicht geändert werden, nachdem der DB-Cluster erstellt wurde. Die Firewalls einiger Unternehmen blockieren Verbindungen zu diesen Standard-Ports. Wenn die Firewall Ihres Unternehmens den Standard-Port blockiert, geben Sie einen anderen Port für Ihr DB-Cluster ein. | **CLI-Option:** `--port` **RDS-API-Parameter:** `Port` |
| DB-Cluster-Kennung | Der Name für Ihren DB-Cluster. Benennen Sie Ihre DB-Cluster auf die gleiche Weise wie Ihre lokalen Server. Ihre DB-Cluster-ID kann bis zu 63 alphanumerische Zeichen enthalten und muss für Ihr Konto in der von Ihnen ausgewählten AWS Region eindeutig sein. | **CLI-Option:** `--db-cluster-identifier` **RDS-API-Parameter:** `DBClusterIdentifier` |
| DB-Instance-Klasse | Die Rechen- und Arbeitsspeicherkapazität jeder DB-Instance im Multi-AZ-DB-Cluster, zum Beispiel `db.m5d.xlarge`. Wählen Sie möglichst eine DB-Instance-Klasse, die groß genug ist, um einen typischer Abfragesatz im Arbeitsspeicher halten zu können. Wenn Arbeitssätze im Arbeitsspeicher gehalten werden, kann das System das Schreiben auf die Festplatte vermeiden, was die Leistung verbessert. Eine Liste der unterstützten DB-Instance-Klassen, finden Sie unter [Verfügbarkeit von Instance-Klassen für Multi-AZ-DB-Cluster](multi-az-db-clusters-concepts.md#multi-az-db-clusters-concepts.InstanceAvailability). | **CLI-Option:** `--db-cluster-instance-class` **RDS-API-Parameter:** `DBClusterInstanceClass` |
| **DB-Cluster-Parametergruppe** | Die DB-Clusterparametergruppe, die Sie mit dem DB-Cluster verknüpfen möchten. Weitere Informationen finden Sie unter [Parametergruppen für Multi-AZ-DB-Cluster](multi-az-db-clusters-concepts.md#multi-az-db-clusters-concepts-parameter-groups). | **CLI-Option:** `--db-cluster-parameter-group-name` **RDS-API-Parameter:** `DBClusterParameterGroupName` |
| DB-Engine-Version | Die Version der Datenbank-Engine, die Sie verwenden möchten. | **CLI-Option:** `--engine-version` **RDS-API-Parameter:** `EngineVersion` |
| DB-Cluster-Parametergruppe | Die DB-Instance-Parametergruppe, die dem DB-Cluster zugeordnet werden soll. Weitere Informationen finden Sie unter [Parametergruppen für Multi-AZ-DB-Cluster](multi-az-db-clusters-concepts.md#multi-az-db-clusters-concepts-parameter-groups). | **CLI-Option:** `--db-cluster-parameter-group-name` **RDS-API-Parameter:** `DBClusterParameterGroupName` |
| DB subnet group (DB-Subnetzgruppe) | Die DB-Subnetzgruppe, die Sie für den DB-Cluster verwenden möchten. Wählen Sie Choose existing (Vorhandene wählen) aus, um eine vorhandene DB-Subnetzgruppe zu verwenden. Wählen Sie dann die erforderliche Subnetzgruppe aus der Dropdown-Liste Existing DB subnet groups (Vorhandene DB-Subnetzgruppen) aus.Wählen Sie **Automatic setup** (Automatische Einrichtung) aus, damit RDS eine kompatible DB-Subnetzgruppe auswählen kann. Wenn keine vorhanden ist, erstellt RDS eine neue Subnetzgruppe für Ihren Cluster.Weitere Informationen finden Sie unter [Arbeiten mit DB-Subnetzgruppen](USER_VPC.WorkingWithRDSInstanceinaVPC.md#USER_VPC.Subnets). | **CLI-Option:** `--db-subnet-group-name` **RDS-API-Parameter:** `DBSubnetGroupName` |
| Löschschutz | Um zu verhindern, dass Ihr DB-Cluster gelöscht wird, können Sie die Option **Löschschutz aktivieren** aktivieren. Wenn Sie einen Produktions-DB-Cluster über die Konsole erstellen, ist der Löschschutz standardmäßig aktiviert. Weitere Informationen finden Sie unter [Löschen einer DB-Instance](USER_DeleteInstance.md). | **CLI-Option:** `--deletion-protection` `--no-deletion-protection` **RDS-API-Parameter:** `DeletionProtection` |
| Verschlüsselung | **Enable Encryption** (Verschlüsselung aktivieren), um die Verschlüsselung im Ruhezustand für diesen DB-Cluster zu aktivieren. Die Verschlüsselung ist für Multi-AZ-DB-Cluster standardmäßig aktiviert. Weitere Informationen finden Sie unter [Verschlüsseln von Amazon RDS-Ressourcen](Overview.Encryption.md). | **CLI-Optionen:** `--kms-key-id` `--storage-encrypted` `--no-storage-encrypted` **RDS-API-Parameter:** `KmsKeyId` `StorageEncrypted` |
| Verbesserte Überwachung | Wählen Sie **Enable enhanced monitoring (Erweiterte Überwachung aktivieren)** aus, um die Erfassung von Metriken in Echtzeit für das Betriebssystem zu aktivieren, in dem Ihr DB-Cluster ausgeführt wird. Weitere Informationen finden Sie unter [Überwachen von Betriebssystem-Metriken mithilfe von „Enhanced Monitoring“·(Erweiterte·Überwachung)](USER_Monitoring.OS.md). | **CLI-Optionen:** `--monitoring-interval` `--monitoring-role-arn` **RDS-API-Parameter:** `MonitoringInterval` `MonitoringRoleArn` |
| Anfänglicher Datenbankname | Der Name für die Datenbank in Ihrem DB-Cluster. Wenn Sie keinen Namen angeben, erstellt Amazon RDS keine Datenbank im neuen DB-Cluster für MySQL. Es erstellt jedoch eine Datenbank im DB-Cluster für PostgreSQL. Der Name darf kein von der Datenbank-Engine reserviertes Wort sein. Abhängig von der DB-Engine gibt es weitere Einschränkungen. MySQL: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/create-multi-az-db-cluster.html) PostgreSQL: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/create-multi-az-db-cluster.html) | **CLI-Option:** `--database-name` **RDS-API-Parameter:** `DatabaseName` |
| **Protokollexporte** | Die Typen von Datenbank-Protokolldateien, die in Amazon CloudWatch Logs veröffentlicht werden sollen. Weitere Informationen finden Sie unter [Veröffentlichen von Datenbankprotokollen in Amazon CloudWatch Logs](USER_LogAccess.Procedural.UploadtoCloudWatch.md). | **CLI-Option:** `-enable-cloudwatch-logs-exports` **RDS-API-Parameter:** `EnableCloudwatchLogsExports` |
| Wartungsfenster | Das 30-Minuten-Fenster, in dem anstehende Änderungen an Ihrem DB-Cluster durchgeführt werden. Wählen Sie **No Preference (Keine Präferenz)** aus, wenn der Zeitraum nicht wichtig ist. Weitere Informationen finden Sie unter [Amazon-RDS-Wartungsfenster](USER_UpgradeDBInstance.Maintenance.md#Concepts.DBMaintenance). | **CLI-Option:** `--preferred-maintenance-window` **RDS-API-Parameter:** `PreferredMaintenanceWindow` |
| Hauptanmeldedaten verwalten in AWS Secrets Manager | Wählen Sie **Master-Anmeldeinformationen verwalten in AWS Secrets Manager** aus, um das Hauptbenutzerpasswort in Secrets Manager geheim zu verwalten. Wählen Sie optional einen KMS-Schlüssel zum Schutz des Secrets aus. Wählen Sie aus den KMS-Schlüsseln in Ihrem Konto oder geben Sie den Schlüssel eines anderen Kontos ein. Weitere Informationen finden Sie unter [Passwortverwaltung mit Amazon RDS, und AWS Secrets Manager](rds-secrets-manager.md). | **CLI-Option:** `--manage-master-user-password \| --no-manage-master-user-password` `--master-user-secret-kms-key-id` **RDS-API-Parameter:** `ManageMasterUserPassword` `MasterUserSecretKmsKeyId` |
| Hauptpasswort | Das Passwort für das Masterbenutzerkonto. | **CLI-Option:** `--master-user-password` **RDS-API-Parameter:** `MasterUserPassword` |
| Master-Benutzername | Der Name, den Sie als Masterbenutzernamen für die Anmeldung beim DB-Cluster mit allen Datenbankrechten verwenden wollen. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/create-multi-az-db-cluster.html) Sie können den Master-Benutzernamen nicht mehr ändern, nachdem der Multi-AZ-DB-Cluster erstellt wurde. Weitere Informationen zu Berechtigungen, die dem Masterbenutzer gewährt werden, finden Sie unter [Berechtigungen von Hauptbenutzerkonten](UsingWithRDS.MasterAccounts.md). | **CLI-Option:** `--master-username` **RDS-API-Parameter:** `MasterUsername` |
| Performance Insights | **Aktivieren Sie Performance Insights**, um die Last Ihrer DB-Cluster zu überwachen, damit Sie Ihre Datenbankleistung analysieren und Fehler beheben können. Wählen Sie einen Aufbewahrungszeitraum, um festzulegen, wie viele Performance-Insights-Daten aufbewahrt werden sollen. Die Aufbewahrungseinstellung ist **Standard (7 Tage)**. Um Ihre Leistungsdaten länger aufzubewahren, geben Sie 1–24 Monate an. Weitere Informationen zum Aufbewahrungszeitraum finden Sie unter [Preisgestaltung und Datenspeicherung für Performance Insights](USER_PerfInsights.Overview.cost.md). Wählen Sie einen KMS-Schlüssel aus, der zum Schutz des Schlüssels für die Verschlüsselung dieses Datenbankvolumes verwendet wird. Wählen Sie aus den KMS-Schlüsseln in Ihrem Konto oder geben Sie den Schlüssel eines anderen Kontos ein. Weitere Informationen finden Sie unter [Überwachung mit Performance Insights auf Amazon RDS](USER_PerfInsights.md). | **CLI-Optionen:** `--enable-performance-insights` `--no-enable-performance-insights` `--performance-insights-retention-period` `--performance-insights-kms-key-id` **RDS-API-Parameter:** `EnablePerformanceInsights` `PerformanceInsightsRetentionPeriod` `PerformanceInsightsKMSKeyId` |
| Bereitgestellte IOPS | Die Menge von bereitgestellten IOPS (Ein-/Ausgabeoperationen pro Sekunde), die dem DB-Cluster anfänglich zugewiesen werden soll. | **CLI-Option:** `--iops` **RDS-API-Parameter:** `Iops` |
| Öffentlicher Zugriff | **Publicly accessible (Öffentlich zugänglich)**, um dem DB-Cluster eine öffentliche IP-Adresse zuzuweisen (was bedeutet, dass sie von außerhalb der VPC aus zugänglich ist). Damit der öffentliche Zugriff für ein DB-Cluster möglich ist, muss sie sich auch in einem öffentlichen Subnetz der VPC befinden. **Not publicly accessible (Nicht öffentlich zugänglich)**, um den DB-Cluster nur innerhalb der VPC zugänglich zu machen. Weitere Informationen finden Sie unter [Ausblenden einer DB-Instance in einer VPC vor dem Internet](USER_VPC.WorkingWithRDSInstanceinaVPC.md#USER_VPC.Hiding). Um eine Verbindung zu einem DB-Cluster von außerhalb seiner VPC herzustellen, muss der DB-Cluster öffentlich zugänglich sein. Außerdem muss der Zugriff unter Verwendung der eingehenden Regeln der Sicherheitsgruppe dem DB-Cluster gewährt werden, und andere Anforderungen müssen erfüllt sein. Weitere Informationen finden Sie unter [Verbindung zur Amazon-RDS-DB-Instance kann nicht hergestellt werden](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting). Wenn Ihr DB-Cluster nicht öffentlich zugänglich ist, können Sie eine AWS Site-to-Site VPN-Verbindung oder eine Direct Connect Verbindung verwenden, um von einem privaten Netzwerk aus darauf zuzugreifen. Weitere Informationen finden Sie unter [Richtlinie für den Datenverkehr zwischen Netzwerken](inter-network-traffic-privacy.md). | **CLI-Option:** `--publicly-accessible` `--no-publicly-accessible` **RDS-API-Parameter:** `PubliclyAccessible` |
| Erweiterte RDS-Unterstützung | Wählen Sie **Erweiterte RDS-Unterstützung aktivieren** aus, damit unterstützte Engine-Hauptversionen auch nach dem Ende des Standard-Supports von RDS weiter ausgeführt werden können. Wenn Sie einen DB-Cluster erstellen, verwendet Amazon RDS standardmäßig RDS Extended Support. Um zu verhindern, dass nach dem Ende des Standard-Supports von RDS ein neuer DB-Cluster erstellt wird, und um Gebühren für RDS Extended Support zu vermeiden, deaktivieren Sie diese Einstellung. Für Ihre vorhandenen DB-Cluster fallen bis zum Startdatum der Preise für die erweiterte RDS-Unterstützung keine Gebühren an. Weitere Informationen finden Sie unter [Amazon RDS Extended Support mit Amazon RDS](extended-support.md). | **CLI-Option:** `--engine-lifecycle-support` **RDS-API-Parameter:** `EngineLifecycleSupport` |
| **Storage throughput** (Speicherdurchsatz) | Der Speicherdurchsatzwert für den DB-Cluster. Diese Einstellung wird nur angezeigt, wenn Sie als Speichertyp Allzweck-SSD (gp3) auswählen. Diese Einstellung ist nicht konfigurierbar und wird automatisch auf der Grundlage der von Ihnen angegebenen IOPS festgelegt. Weitere Informationen finden Sie unter [gp3-Speicher (empfohlen)](CHAP_Storage.md#gp3-storage). | Dieser Wert wird automatisch berechnet und hat keine CLI-Option. |
| **RDS-Proxy** | Wählen Sie **Create an RDS-Proxy** (RDS-Proxy erstellen) aus, um einen Proxy für Ihren DB-Cluster zu erstellen. Amazon RDS erstellt automatisch eine IAM-Rolle und ein Secrets-Manager-Secret für den Proxy. | Nicht verfügbar beim Erstellen eines DB-Clusters |
| Speichertyp | Der Speichertyp für Ihren DB-Cluster. Es werden nur Allzweck-SSD (gp3), SSD mit bereitgestellter IOPS (io1) und SSD mit bereitgestellter IOPS (io2) unterstützt. Weitere Informationen finden Sie unter [Amazon-RDS-Speichertypen](CHAP_Storage.md#Concepts.Storage). | **CLI-Option:** `--storage-type` **RDS-API-Parameter:** `StorageType` |
| Virtual Private Cloud (VPC) | Eine VPC, die auf dem Amazon-VPC-Service basiert und mit diesem DB-Cluster verknüpft werden soll. Weitere Informationen finden Sie unter [Amazon VPC und Amazon RDS](USER_VPC.md). | Für die CLI und API geben Sie die VPC-Sicherheitsgruppe IDs an. |
| VPC security group (firewall) (VPC-Sicherheitsgruppe (Firewall)) | Die Sicherheitsgruppen, die dem DB-Cluster zugeordnet werden sollen. Weitere Informationen finden Sie unter [Überblick über VPC-Sicherheitsgruppen](Overview.RDSSecurityGroups.md#Overview.RDSSecurityGroups.VPCSec). | **CLI-Option:** `--vpc-security-group-ids` **RDS-API-Parameter:** `VpcSecurityGroupIds` |
## Einstellungen, die beim Erstellen von Multi-AZ-DB-Clustern nicht gelten
Die folgenden Einstellungen im AWS CLI Befehl [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html)und im RDS-API-Vorgang gelten [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html)nicht für Multi-AZ-DB-Cluster.
Sie können diese Einstellungen auch für Multi-AZ-DB-Cluster in der Konsole nicht angeben.
| AWS CLI Einstellung | RDS-API-Einstellung |
| --- | --- |
| `--availability-zones` | `AvailabilityZones` |
| `--backtrack-window` | `BacktrackWindow` |
| `--character-set-name` | `CharacterSetName` |
| `--domain` | `Domain` |
| `--domain-iam-role-name` | `DomainIAMRoleName` |
| `--enable-global-write-forwarding \| --no-enable-global-write-forwarding` | `EnableGlobalWriteForwarding` |
| `--enable-http-endpoint \| --no-enable-http-endpoint` | `EnableHttpEndpoint` |
| `--global-cluster-identifier` | `GlobalClusterIdentifier` |
| `--option-group-name` | `OptionGroupName` |
| `--pre-signed-url` | `PreSignedUrl` |
| `--replication-source-identifier` | `ReplicationSourceIdentifier` |
| `--scaling-configuration` | `ScalingConfiguration` |
# Herstellen einer Verbindung mit einem Multi-AZ-DB-Cluster für Amazon RDS
Ein Multi-AZ-DB-Cluster verfügt über drei DB-Instances anstelle einer einzigen DB-Instance. Jede Verbindung wird von einer bestimmten DB-Instance verarbeitet. Wenn Sie eine Verbindung zu einem Multi-AZ-DB-Cluster herstellen, verweisen der von Ihnen angegebene Hostname und Port auf einen vollqualifizierten Domainnamen, der als *Endpunkt* bezeichnet wird. Der Multi-AZ-DB-Cluster verwendet den Endpunktmechanismus, um diese Verbindungen zu abstrahieren, so dass Sie nicht genau angeben müssen, zu welcher DB-Instance im DB-Cluster eine Verbindung hergestellt werden soll. Sie müssen daher für das Umleiten von Verbindungen nicht alle Hostnamen fest codieren oder Ihre eigene Logik schreiben, wenn einige DB-Instances nicht verfügbar sind.
Der Writer-Endpunkt stellt eine Verbindung zur Writer-DB-Instance des DB-Clusters her, der sowohl Lese- als auch Schreibvorgänge unterstützt. Der Leser-Endpunkt stellt eine Verbindung zu einer der beiden Reader-DB-Instances her, die nur Leseoperationen unterstützen.
Ihrem Anwendungsfall entsprechend können Sie mit Endpunkten jede Verbindung der entsprechenden DB-Instance oder Gruppe von DB-Instances zuordnen. Um beispielsweise DDL- und DML-Anweisungen auszuführen, können Sie eine Verbindung zu einer beliebigen DB-Instance herstellen, die die Writer-DB-Instance ist. Um Abfragen durchzuführen, können Sie eine Verbindung zum Leser-Endpunkt herstellen, wobei der Multi-AZ-DB-Cluster automatisch Verbindungen zwischen den Reader-DB-Instances verwaltet. Zur Diagnose und Optimierung können Sie eine Verbindung mit einem spezifischen DB-Instance-Endpunkt herstellen, um die Details einer bestimmten DB-Instance zu untersuchen.
Weitere Information über das Verbinden mit der DB-Instance finden Sie unter [Herstellen einer Verbindung mit einer Amazon-RDS-DB-Instance](CHAP_CommonTasks.Connect.md).
Weitere Informationen zum Herstellen einer Verbindung mit den Multi-AZ-DB-Clustern finden Sie in den folgenden Themen.
**Topics**
+ [Cluster-Endpunkte](#multi-az-db-clusters-concepts-connection-management-endpoints-cluster)
+ [Reader-Endpunkte](#multi-az-db-clusters-concepts-connection-management-endpoints-reader)
+ [Instance-Endpunkte](#multi-az-db-clusters-concepts-connection-management-endpoints-instance)
+ [Verbindungen für hohe Verfügbarkeit](#multi-az-db-clusters-concepts-connection-management-endpoints-ha)
+ [Verbindung zu Multi-AZ-DB-Clustern mit den AWS Treibern für Amazon RDS herstellenHerstellen einer Verbindung mit den Multi-AZ-DB-Clustern mithilfe des JDBC-Treibers von Amazon Web Services (AWS)](maz-cluster-connect-drivers.md)
## Arten von Multi-AZ-DB-Cluster-Endpunkten
Ein Endpunkt wird durch einen eindeutigen Bezeichner dargestellt, der eine Hostadresse enthält. In einem Multi-AZ-DB-Cluster stehen die folgenden Endpunkt-Typen zur Verfügung:
**Cluster-Endpunkt**
Ein *Cluster-Endpunkt* (oder *Writer-Endpunkt*) für einen Multi-AZ-DB-Cluster stellt eine Verbindung mit der aktuellen Writer-DB-Instance für diesen DB-Cluster her. Nur dieser Endpunkt kann Schreibvorgänge wie z. B. DDL- und DML-Anweisungen durchführen. Dieser Endpunkt kann auch Leseoperationen ausführen.
Jeder Multi-AZ-DB-Cluster verfügt über einen Cluster-Endpunkt und eine Writer-DB-Instance.
Sie verwenden den Cluster-Endpunkt für alle Schreibvorgänge auf dem DB-Cluster, darunter Einfügungs-, Aktualisierungs- und Löschvorgänge sowie DDL-Änderungen. Sie können den Cluster-Endpunkt auch für Lesevorgänge nutzen, beispielsweise Abfragen.
Wenn die aktuelle Writer-DB-Instance eines DB-Clusters ausfällt, wechselt der Multi-AZ-DB-Cluster automatisch zu einer neuen Writer-DB-Instance. Während eines Failovers bedient der DB-Cluster weiterhin Verbindungsanfragen von der neuen Schreib-DB-Instance an den Cluster-Endpunkt mit minimaler Serviceunterbrechung.
Das folgende Beispiel zeigt einen Cluster-Endpunkt für einen Multi-AZ-DB-Cluster.
`mydbcluster.cluster-123456789012.us-east-1.rds.amazonaws.com`
Weitere Informationen zum Herstellen einer Verbindung mit Cluster-Endpunkten finden Sie unter [Cluster-Endpunkte](#multi-az-db-clusters-concepts-connection-management-endpoints-cluster).
**Leser-Endpunkt**
Ein *Reader-Endpunkt* für einen Multi-AZ-DB-Cluster bietet Unterstützung für schreibgeschützte Verbindungen zum DB-Cluster. Verwenden Sie den Leser-Endpunkt für Lesevorgänge, beispielsweise `SELECT`-Abfragen. Durch die Verarbeitung dieser Anweisungen auf den Reader-DB-Instances reduziert dieser Endpunkt den Overhead auf der Writer-DB-Instance. Es hilft dem Cluster auch, die Kapazität zu skalieren, um gleichzeitige `SELECT`-Abfragen zu verarbeiten. Jeder Multi-AZ-DB-Cluster verfügt über einen Reader-Endpunkt.
Der Leser-Endpunkt sendet jede Verbindungsanforderung an eine der Reader-DB-Instances. Wenn Sie den Reader-Endpunkt für eine Sitzung verwenden, können Sie in dieser Sitzung nur schreibgeschützte Anweisungen wie `SELECT` ausführen.
Das folgende Beispiel zeigt einen Leser-Endpunkt für einen Multi-AZ-DB-Cluster. Die schreibgeschützte Absicht eines Reader-Endpunkts wird durch die `-ro` innerhalb des Namen des Cluster-Endpunkts gekennzeichnet.
`mydbcluster.cluster-ro-123456789012.us-east-1.rds.amazonaws.com`
Weitere Informationen zum Herstellen einer Verbindung Reader-Endpunkten finden Sie unter [Reader-Endpunkte](#multi-az-db-clusters-concepts-connection-management-endpoints-reader).
**Instance-Endpunkt**
Ein *Instance-Endpunkt* stellt innerhalb eines DB-Instance eine Verbindung zu einer spezifischen Multi-AZ-DB-Cluster her. Jede DB-Instance in einem DB-Cluster hat einen eigenen, spezifischen Instance-Endpunkt. Es gibt also einen Instance-Endpunkt für die aktuelle Writer-DB-Instance des DB-Clusters und einen Instance-Endpunkt für jede der Reader-DB-Instances im DB-Cluster.
Der Instance-Endpunkt bietet direkte Kontrolle über Verbindungen zum DB-Cluster. Dieses Steuerelement kann Ihnen helfen, Szenarien zu beheben, in denen die Verwendung des Cluster-Endpunkts oder des Leser-Endpunkts möglicherweise nicht angemessen ist. Beispiel: Ihre Client-Anwendung erfordert möglicherweise einen detaillierteren Lastausgleich je nach Workload-Typ. In diesem Fall können Sie mehrere Clients so konfigurieren, dass sie sich mit verschiedenen Reader-DB-Instances in einem DB-Cluster verbinden, um Leseworkloads zu verteilen.
Das folgende Beispiel zeigt einen Instance-Endpunkt für eine DB-Instance in einem Multi-AZ-DB-Cluster.
`mydbinstance.123456789012.us-east-1.rds.amazonaws.com`
Weitere Informationen zum Herstellen einer Verbindung mit den Instance-Endpunkten finden Sie unter [Instance-Endpunkte](#multi-az-db-clusters-concepts-connection-management-endpoints-instance).
## Anzeigen von Endpunkten
Verwenden Sie die Konsole oder die Amazon RDS-API AWS CLI, um die Cluster-, Reader- und Instance-Endpunkte anzuzeigen.
------
#### [ Console ]
In der AWS-Managementkonsole sehen Sie den Cluster-Endpunkt und den Reader-Endpunkt auf der Detailseite für jeden Multi-AZ-DB-Cluster. Der Instance-Endpunkt wird auf der Detailseite der jeweiligen DB-Instance angezeigt.
------
#### [ AWS CLI ]
Mit dem AWS CLI sehen Sie die Writer- und Reader-Endpunkte in der Ausgabe des [describe-db-clusters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-clusters.html)Befehls. Der folgende Befehl zeigt beispielsweise die Endpunktattribute für alle Cluster in Ihrer aktuellen AWS Region.
```
aws rds describe-db-cluster-endpoints
```
------
#### [ Amazon RDS API ]
Mit der Amazon RDS-API rufen Sie die Endpunkte ab, indem Sie die Aktion [Describe DBCluster Endpoints](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusterEndpoints.html) aufrufen. Die Ausgabe zeigt auch Amazon-Aurora-DB-Cluster-Endpunkte an, falls vorhanden.
------
## Cluster-Endpunkte
Jeder Multi-AZ-DB-Cluster verfügt über einen einzelnen integrierten Cluster-Endpunkt, dessen Name und andere Attribute von Amazon RDS verwaltet werden. Sie können einen solchen Endpunkt nicht erstellen, löschen oder ändern.
Den Cluster-Endpunkt verwenden Sie beim Verwalten Ihres DB-Clusters, bei Extraktions-, Transformations- und Ladevorgängen (ETL) oder beim Entwickeln und Testen von Anwendungen. Der Cluster-Endpunkt stellt eine Verbindung zur Writer-DB-Instance des Clusters her. Die Writer-DB-Instance ist die einzige DB-Instance, mit der Sie Tabellen und Indizes erstellen sowie `INSERT`-Anweisungen und andere DDL- und DML-Operationen ausführen können.
Die physische IP-Adresse, auf die der Cluster-Endpunkt verweist, ändert sich, wenn der Failover-Mechanismus eine neue DB-Instance zur Writer-DB-Instance für den Cluster heraufsetzt. Wenn Sie irgendeine Form von Verbindungspooling oder sonstigem Multiplexing verwenden, sollten Sie darauf vorbereitet sein, den Wert für alle zwischengespeicherten DNS-Informationen zu leeren oder zu reduzieren. time-to-live Dadurch wird sichergestellt, dass Sie nicht versuchen, eine read/write Verbindung zu einer DB-Instance herzustellen, die nach einem Failover nicht mehr verfügbar ist oder jetzt schreibgeschützt ist.
## Reader-Endpunkte
Sie verwenden den Reader-Endpunkt für schreibgeschützte Verbindungen zu Ihrem Multi-AZ-DB-Cluster. Dieser Endpunkt hilft Ihrem DB-Cluster bei der Handhabung einer abfragenintensiven Workload. Der Reader-Endpunkt ist der Endpunkt, den Sie Anwendungen zur Verfügung stellen, die Berichterstattung oder andere schreibgeschützte Operationen auf dem Cluster ausführen. Der Leser-Endpunkt sendet Verbindungen zu verfügbaren Reader-DB-Instances in einem Multi-AZ-DB-Cluster.
Jeder Multi-AZ-Cluster verfügt über einen integrierten Cluster-Endpunkt verfügt, dessen Name zusammen mit anderen Attributen durch Amazon RDS verwaltet wird. Sie können einen solchen Endpunkt nicht erstellen, löschen oder ändern.
## Instance-Endpunkte
Jede DB-Instance in einem Multi-AZ-DB-Cluster verfügt über ihren eigenen integrierten Instance-Endpunkt, dessen Name und andere Attribute von Amazon RDS verwaltet werden. Sie können einen solchen Endpunkt nicht erstellen, löschen oder ändern. Bei einem Multi-AZ-DB-Cluster verwenden Sie in der Regel die Writer- und Reader-Endpunkte häufiger als die Instance-Endpunkte.
Im day-to-day operativen Bereich verwenden Sie Instance-Endpunkte hauptsächlich zur Diagnose von Kapazitäts- oder Leistungsproblemen, die sich auf eine bestimmte DB-Instance in einem Multi-AZ-DB-Cluster auswirken. Während eine Verbindung zu einer spezifischen DB-Instance besteht, können Sie unter anderem deren Statusvariablen oder Metriken untersuchen. Hierdurch ist es möglich, Unterschiede zwischen den Aktivitäten verschiedener Cluster-DB-Instances zu ermitteln.
## Verbindungen für hohe Verfügbarkeit
Verwenden Sie für Multi-AZ-DB-Cluster, bei denen hohe Verfügbarkeit wichtig ist, den Writer-Endpunkt für read/write Allzweckverbindungen und den Reader-Endpunkt für schreibgeschützte Verbindungen. Die Schreiber- und Leser-Endpunkte verwalten das Failover von DB-Instances besser als Instance-Endpunkte. Im Gegensatz zu den Instance-Endpunkten ändern die Schreiber- und Leser-Endpunkte automatisch, mit welcher DB-Instance sie eine Verbindung herstellen, wenn eine DB-Instance in Ihrem Cluster nicht mehr verfügbar ist.
Wenn die Writer-DB-Instance eines DB-Clusters ausfällt, führt Amazon RDS automatisch ein Failover zu einer neuen Writer-DB-Instance durch. Dies geschieht durch die Förderung einer Reader-DB-Instance auf eine neue Writer-DB-Instance. Wenn ein Failover auftritt, können Sie den Schreiber-Endpunkt verwenden, um eine Verbindung zu der neu hochgestuften Writer-DB-Instance wiederherzustellen. Oder Sie können den Leser-Endpunkt verwenden, um eine Verbindung zu einer der Reader-DB-Instances im DB-Cluster wiederherzustellen. Während eines Failovers leitet der Reader-Endpunkt Verbindungen möglicherweise für kurze Zeit an die neue Writer-DB-Instance eines DB-Clusters weiter, nachdem eine Reader-DB-Instance zur neuen Writer-DB-Instance hochgestuft wurde. Wenn Sie Ihre Anwendungslogik so entwickeln, dass Verbindungen zu Instance-Endpunkten verwaltet werden können, ist es möglich, den daraus resultierenden Satz an verfügbaren DB-Instances im DB-Cluster manuell oder programmgesteuert zu ermitteln.
# Verbindung zu Multi-AZ-DB-Clustern mit den AWS Treibern für Amazon RDS herstellen
Die AWS Treibersuite wurde so konzipiert, dass sie schnellere Switchover- und Failover-Zeiten sowie Authentifizierung mit AWS Secrets Manager, AWS Identity and Access Management (IAM) und Federated Identity unterstützt. Die AWS Treiber sind darauf angewiesen, den Status des DB-Clusters zu überwachen und die Clustertopologie zu kennen, um den neuen Writer zu ermitteln. Dieser Ansatz reduziert die Umstellungs- und Failover-Zeiten auf Werte im einstelligen Sekundenbereich, im Vergleich zu Werten im zweistelligen Bereich bei Open-Source-Treibern.
Im Zuge der Einführung neuer Servicefunktionen besteht das Ziel der AWS Treibersuite darin, eine integrierte Unterstützung für diese Servicefunktionen zu bieten.
## Herstellen einer Verbindung mit den Multi-AZ-DB-Clustern mithilfe des JDBC-Treibers von Amazon Web Services (AWS)
Der JDBC-Treiber von Amazon Web Services (AWS) ist als fortschrittlicher JDBC-Wrapper konzipiert, um Anwendungen dabei zu unterstützen, die Funktionen geclusterter Datenbanken zu nutzen. Dieser Wrapper ergänzt einen vorhandenen JDBC-Treiber und erweitert dessen Funktionen. Der Treiber ist Drop-In-kompatibel mit den folgenden Community-Treibern:
+ MySQL Connector/J
+ MariaDB Connector/J
+ pgJDBC
Um den AWS JDBC-Treiber zu installieren, hängen Sie die JAR-Datei des AWS JDBC-Treibers an (befindet sich in der Anwendung`CLASSPATH`) und behalten Sie die Verweise auf den jeweiligen Community-Treiber bei. Aktualisieren Sie das jeweilige Verbindungs-URL-Präfix wie folgt:
+ `jdbc:mysql://` auf `jdbc:aws-wrapper:mysql://`
+ `jdbc:mariadb://` auf `jdbc:aws-wrapper:mariadb://`
+ `jdbc:postgresql://` auf `jdbc:aws-wrapper:postgresql://`
Weitere Informationen zum AWS JDBC-Treiber und vollständige Anweisungen zu seiner Verwendung finden Sie im [Amazon Web Services (AWS) JDBC-Treiber-Repository](https://github.com/awslabs/aws-advanced-jdbc-wrapper). GitHub
## Herstellen einer Verbindung mit den Multi-AZ-DB-Clustern mithilfe des Python-Treibers von Amazon Web Services (AWS)
Der Amazon Web Services (AWS)-Python-Treiber ist als fortschrittlicher Python-Wrapper konzipiert. Dieser Wrapper ergänzt den Open-Source-Treiber Psycopg und erweitert dessen Funktionen. Der AWS Python-Treiber unterstützt Python-Versionen 3.8 und höher. Sie können das Paket `aws-advanced-python-wrapper` zusammen mit den Open-Source-Paketen `psycopg` mithilfe des Befehls `pip` installieren.
Weitere Informationen zum AWS Python-Treiber und vollständige Anweisungen zu seiner Verwendung finden Sie im [ GitHub Python-Treiber-Repository von Amazon Web Services (AWS)](https://github.com/awslabs/aws-advanced-python-wrapper).
# Automatisches Verbinden einer AWS-Rechenressource und eines Multi-AZ-DB-Clusters für Amazon RDS
Sie können einen Multi-AZ-DB-Cluster und AWS-Rechenressourcen wie Amazon Elastic Compute Cloud (Amazon EC2)-Instances und Funktionen von AWS Lambda automatisch verbinden.
Die folgenden Themen enthalten detaillierte Anweisungen zur Konfiguration von Netzwerkeinstellungen, Sicherheitsgruppen und Verbindungsparametern, um zuverlässige Verbindungen mit Amazon-RDS-DB-Instances in einer Multi-AZ-DB-Cluster-Bereitstellung herzustellen. Sie konzentrieren sich auf die Optimierung der Netzwerkkonnektivität und -leistung für Anwendungen, die mit einem Multi-AZ-DB-Cluster interagieren, um sichere und effiziente Datenvorgänge zu gewährleisten.
**Topics**
+ [Automatisches Verbinden einer EC2-Instance und eines Multi-AZ-DB-Clusters](multiaz-ec2-rds-connect.md)
+ [Automatisches Verbinden einer Lambda-Funktion und eines Multi-AZ-DB-Clusters](multiaz-lambda-rds-connect.md)
# Automatisches Verbinden einer EC2-Instance und eines Multi-AZ-DB-Clusters
Sie können die Amazon-RDS-Konsole verwenden, um das Einrichten einer Verbindung zwischen einer Amazon Elastic Compute Cloud (Amazon-EC2)-Instance und einem Multi-AZ-DB-Cluster zu vereinfachen. Häufig befindet sich Ihr Multi-AZ-DB-Cluster in einem privaten Subnetz und Ihre EC2-Instance in einem öffentlichen Subnetz innerhalb einer VPC. Sie können einen SQL-Client auf Ihrer EC2-Instance verwenden, um eine Verbindung mit Ihrem Multi-AZ-DB-Cluster herzustellen. Die EC2-Instance kann auch Webserver oder Anwendungen ausführen, die auf Ihren privaten Multi-AZ-DB-Cluster zugreifen.
![\[Automatisches Verbinden eines Multi-AZ-DB-Clusters mit einer EC2-Instance.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/multi-az-ec2-connect-overview.png)
Wenn Sie eine Verbindung mit einer EC2-Instance herstellen möchten, die sich nicht in derselben VPC wie der Multi-AZ-DB-Cluster befindet, sehen Sie sich die entsprechenden Szenarien unter [Szenarien für den Zugriff auf eine DB-Instance in einer VPC](USER_VPC.Scenarios.md) an.
**Topics**
+ [Übersicht über die automatische Verbindung mit einer EC2-Instance](#multiaz-ec2-rds-connect-overview)
+ [Automatisches Verbinden einer EC2-Instance und eines Multi-AZ-DB-Clusters](#multiaz-ec2-rds-connect-connecting)
+ [Anzeigen verbundener Rechenressourcen](#multiaz-ec2-rds-connect-viewing)
## Übersicht über die automatische Verbindung mit einer EC2-Instance
Wenn Sie eine Verbindung zwischen einer EC2-Instance und einem Multi-AZ-DB-Cluster automatisch einrichten, konfiguriert Amazon RDS die VPC-Sicherheitsgruppe für Ihre EC2-Instance und für Ihren DB-Cluster.
Im Folgenden sind die Anforderungen für die Verbindung einer EC2-Instance mit einem Multi-AZ-DB-Cluster aufgeführt:
+ Die EC2-Instance muss sich in derselben VPC wie die der Multi-AZ-DB-Cluster befinden.
Wenn keine EC2-Instances in derselben VPC vorhanden sind, bietet die Konsole einen Link zum Erstellen einer solchen Instance.
+ Der Benutzer, der die Verbindung einrichtet, muss über Berechtigungen zum Ausführen der folgenden EC2-Vorgänge verfügen:
+ `ec2:AuthorizeSecurityGroupEgress`
+ `ec2:AuthorizeSecurityGroupIngress`
+ `ec2:CreateSecurityGroup`
+ `ec2:DescribeInstances`
+ `ec2:DescribeNetworkInterfaces`
+ `ec2:DescribeSecurityGroups`
+ `ec2:ModifyNetworkInterfaceAttribute`
+ `ec2:RevokeSecurityGroupEgress`
Wenn Sie eine Verbindung mit einer EC2-Instance einrichten, führt Amazon RDS eine Aktion aus, die auf der aktuellen Konfiguration der Sicherheitsgruppen basiert, die dem Multi-AZ-DB-Cluster und der EC2-Instance zugeordnet sind, wie in der folgenden Tabelle beschrieben.
| Aktuelle RDS-Sicherheitsgruppenkonfiguration | Aktuelle EC2-Sicherheitsgruppenkonfiguration | RDS-Aktion |
| --- | --- | --- |
| Dem Multi-AZ-DB-Cluster sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `rds-ec2-n` entspricht (wobei `n` für eine Zahl steht). Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der EC2-Instance als Quelle. | Der EC2-Instance sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `rds-ec2-n` entspricht (wobei `n` für eine Zahl steht). Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters als Quelle. | Amazon RDS führt keine Aktion aus. Es wurde bereits automatisch eine Verbindung zwischen der EC2-Instance und dem Multi-AZ-DB-Cluster konfiguriert. Da bereits eine Verbindung zwischen der EC2-Instance und der RDS-Datenbank besteht, werden die Sicherheitsgruppen nicht geändert. |
| Es gilt eine der folgenden Bedingungen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/multiaz-ec2-rds-connect.html) | Es gilt eine der folgenden Bedingungen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/multiaz-ec2-rds-connect.html) | [RDS action: create new security groups](ec2-rds-connect.md#rds-action-create-new-security-groups) |
| Dem Multi-AZ-DB-Cluster sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `rds-ec2-n` entspricht. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der EC2-Instance als Quelle. | Der EC2-Instance sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `ec2-rds-n` entspricht. Keine dieser Sicherheitsgruppen kann jedoch für die Verbindung mit dem Multi-AZ-DB-Cluster verwendet werden. Eine Sicherheitsgruppe kann nicht verwendet werden, wenn sie keine Regel für ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters als Quelle enthält. Eine Sicherheitsgruppe kann auch nicht verwendet werden, wenn sie geändert wurde. | [RDS action: create new security groups](ec2-rds-connect.md#rds-action-create-new-security-groups) |
| Dem Multi-AZ-DB-Cluster sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `rds-ec2-n` entspricht. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der EC2-Instance als Quelle. | Eine gültige EC2-Sicherheitsgruppe für die Verbindung ist vorhanden, jedoch nicht mit der EC2-Instance verknüpft. Die Sicherheitsgruppe trägt einen Namen, der dem Muster `rds-ec2-n` entspricht. Sie wurde nicht geändert. Er enthält nur eine Regel für ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters als Quelle. | [RDS action: associate EC2 security group](ec2-rds-connect.md#rds-action-associate-ec2-security-group) |
| Es gilt eine der folgenden Bedingungen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/multiaz-ec2-rds-connect.html) | Der EC2-Instance sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `rds-ec2-n` entspricht. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters als Quelle. | [RDS action: create new security groups](ec2-rds-connect.md#rds-action-create-new-security-groups) |
**RDS-Aktion : neue Sicherheitsgruppen erstellen**
Amazon RDS führt die folgenden Aktionen durch:
+ Erstellt eine neue Sicherheitsgruppe, die dem Muster `rds-ec2-n` entspricht. Diese Sicherheitsgruppe enthält eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der EC2-Instance als Quelle. Diese Sicherheitsgruppe, die dem Multi-AZ-DB-Cluster zugeordnet ist, ermöglicht der EC2-Instance den Zugriff auf den Multi-AZ-DB-Cluster.
+ Erstellt eine neue Sicherheitsgruppe, die dem Muster `ec2-rds-n` entspricht. Diese Sicherheitsgruppe enthält eine Regel für ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters als Quelle. Diese Sicherheitsgruppe ist der EC2-Instance zugeordnet und ermöglicht es der EC2-Instance, Datenverkehr an den Multi-AZ-DB-Cluster zu senden.
**RDS-Aktion : EC2-Sicherheitsgruppe zuordnen**
Amazon RDS ordnet die gültige, vorhandene EC2-Sicherheitsgruppe der EC2-Instance zu. Diese Sicherheitsgruppe ermöglicht es der EC2-Instance, Datenverkehr an den Multi-AZ-DB-Cluster zu senden.
## Automatisches Verbinden einer EC2-Instance und eines Multi-AZ-DB-Clusters
Bevor Sie eine Verbindung zwischen einer EC2-Instance und einer RDS-Datenbank einrichten, stellen Sie sicher, dass Sie die unter [Übersicht über die automatische Verbindung mit einer EC2-Instance](ec2-rds-connect.md#ec2-rds-connect-overview) beschriebenen Anforderungen erfüllen.
Wenn Sie nach dem Konfigurieren der Verbindung Änderungen an diesen Sicherheitsgruppen vornehmen, können sich die Änderungen auf die Verbindung zwischen der EC2-Instance und der RDS-Datenbank auswirken.
**Anmerkung**
Sie können eine Verbindung zwischen einer EC2-Instance und einer RDS-Datenbank nur automatisch einrichten, indem Sie die AWS-Managementkonsole verwenden. Sie können keine automatische Verbindung mit der AWS CLI oder der RDS-API einrichten.
**So verbinden Sie eine EC2-Instance und eine RDS-Datenbank automatisch**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Databases** (Datenbanken) und dann den DB-Cluster aus.
1. Wählen Sie für **Aktionen** die Option **EC2-Verbindung einrichten** aus.
Die Seite **Set up EC2 connection** (EC2-Verbindung einrichten) wird angezeigt.
1. Wählen Sie auf der Seite **Set up EC2 connection** (EC2-Verbindung einrichten) die EC2-Instance aus.
![\[Seite zum Einrichten der EC2-Verbindung.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/auto-connect-rds-ec2-set-up.png)
Wenn keine EC2-Instances in derselben VPC vorhanden sind, wählen Sie **Create EC2 instance** (EC2-Instance erstellen) aus, um eine solche Instance zu erstellen. Stellen Sie in diesem Fall sicher, dass sich die neue EC2-Instance in derselben VPC wie die RDS-Datenbank befindet.
1. Klicken Sie auf **Weiter**.
Die Seite **Review and confirm** (Überprüfen und bestätigen) wird angezeigt.
![\[Seite zum Überprüfen und Bestätigen der EC2-Verbindung.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/auto-connect-rds-ec2-confirm.png)
1. Sehen Sie sich auf der Seite **Review and confirm** (Überprüfen und bestätigen) die Änderungen an, die RDS beim Einrichten der Verbindung mit der EC2-Instance vornehmen wird.
Wenn die Änderungen korrekt sind, wählen Sie **Bestätigen und einrichten**.
Sind die Änderungen nicht korrekt, wählen Sie **Previous** (Zurück) oder **Cancel** (Abbrechen) aus.
## Anzeigen verbundener Rechenressourcen
Sie können den verwenden AWS-Managementkonsole , um die Rechenressourcen anzuzeigen, die mit einem mit einer RDS-Datenbank verbunden sind. Zu den angezeigten Ressourcen gehören Rechenressourcenverbindungen, die automatisch eingerichtet wurden. Sie können die Konnektivität mit Rechenressourcen auf folgende Weise automatisch einrichten:
+ Sie können die Rechenressource auswählen, wenn Sie die Datenbank erstellen.
Weitere Informationen erhalten Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md) und [Erstellen eines Multi-AZ-DB-Clusters für Amazon RDS](create-multi-az-db-cluster.md).
+ Sie können die Konnektivität zwischen einer vorhandenen Datenbank und einer Rechenressource einrichten.
Weitere Informationen finden Sie unter [Automatisches Verbinden einer EC2-Instance und einer RDS-Datenbank](ec2-rds-connect.md#ec2-rds-connect-connecting).
Die aufgelisteten Rechenressourcen enthalten keine Ressourcen, die manuell mit der Datenbank verbunden wurden. Sie können beispielsweise einer Rechenressource den manuellen Zugriff auf eine Datenbank erlauben, indem Sie der VPC-Sicherheitsgruppe, die der Datenbank zugeordnet ist, eine Regel hinzufügen.
Für die Auflistung einer Rechenressource müssen die folgenden Bedingungen erfüllt sei:
+ Der Name der Sicherheitsgruppe, die der Rechenressource zugeordnet ist, entspricht dem Muster `ec2-rds-n` (wobei `n` für eine Zahl steht).
+ Die Sicherheitsgruppe, die der Rechenressource zugeordnet ist, hat eine Regel für ausgehenden Datenverkehr, wobei der Portbereich auf den Port festgelegt ist, den die RDS-Datenbank verwendet.
+ Die Sicherheitsgruppe, die der Rechenressource zugeordnet ist, hat eine Regel für ausgehenden Datenverkehr, wobei die Quelle auf eine Sicherheitsgruppe festgelegt ist, die der RDS-Datenbank zugeordnet ist.
+ Der Name der Sicherheitsgruppe, die der RDS-Datenbank zugeordnet ist, entspricht dem Muster `rds-ec2-n` entspricht (wobei `n` für eine Zahl steht).
+ Die Sicherheitsgruppe, die der RDS-Datenbank zugeordnet ist, hat eine Regel für eingehenden Datenverkehr, wobei der Portbereich auf den Port festgelegt ist, den die RDS-Datenbank verwendet.
+ Die Sicherheitsgruppe, die der RDS-Datenbank zugeordnet ist, hat eine Regel für eingehenden Datenverkehr, wobei die Quelle auf eine Sicherheitsgruppe festgelegt ist, die der Rechenressource zugeordnet ist.
**So zeigen Sie Rechenressourcen an, die mit einer RDS-Datenbank verbunden sind**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Databases** (Datenbanken) und dann den Namen des DB-Clusters aus.
1. Sehen Sie sich auf der Registerkarte **Connectivity & security** (Konnektivität und Sicherheit) die Rechenressourcen unter **Verbundene Rechenressourcen** an.
![\[Verbundene Rechenressourcen.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/ec2-connected-compute-resources.png)
# Automatisches Verbinden einer Lambda-Funktion und eines Multi-AZ-DB-Clusters
Sie können die RDS-Konsole verwenden, um das Einrichten einer Verbindung zwischen einer Lambda-Funktion und einem Multi-AZ-DB-Cluster zu vereinfachen. Sie können die RDS-Konsole verwenden, um das Einrichten einer Verbindung zwischen einer Lambda-Funktion und einem Multi-AZ-DB-Cluster zu vereinfachen. Häufig befindet sich Ihre Multi-AZ-DB-Cluster in einem privaten Subnetz innerhalb einer VPC. Die Lambda-Funktion kann von Anwendungen verwendet werden, um auf Ihren privaten Multi-AZ-DB-Cluster zuzugreifen.
Das folgende Bild zeigt eine direkte Verbindung zwischen Ihrem Multi-AZ-DB-Cluster und Ihrer Lambda-Funktion.
![\[Automatisches Verbinden eines Multi-AZ-DB-Clusters mit einer Lambda-Funktion\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/auto-connect-maz-lambda.png)
Sie können die Verbindung zwischen Ihrer Lambda-Funktion und Ihrer Datenbank über RDS-Proxy einrichten, um die Leistung und Stabilität Ihrer Datenbank zu verbessern. Oft stellen Lambda-Funktionen häufige, kurze Datenbankverbindungen her, die von dem von RDS Proxy angebotenen Verbindungspooling profitieren. Sie können eine der IAM-Authentifizierungen nutzen, die Sie bereits für Lambda-Funktionen eingerichtet haben, anstatt Datenbankanmeldeinformationen im Lambda-Anwendungscode zu verwalten. Weitere Informationen finden Sie unter [Amazon RDS-Proxy ](rds-proxy.md).
Sie können die Konsole verwenden, um automatisch einen Proxy für Ihre Verbindung zu erstellen. Sie können auch vorhandene Proxys auswählen. Die Konsole aktualisiert die Proxy-Sicherheitsgruppe, um Verbindungen von Ihrer Datenbank und der Lambda-Funktion aus zuzulassen. Sie können Ihre Datenbankanmeldeinformationen eingeben oder das Secrets-Manager-Secret auswählen, das Sie für den Zugriff auf die Datenbank benötigen.
![\[Automatisches Verbinden eines Multi-AZ-DB-Clusters mit einer Lambda-Funktion über RDS Proxy\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/auto-connect-maz-lambda-Proxy.png)
**Topics**
+ [Überblick über die automatische Konnektivität mit einer Lambda-Funktion](#multiaz-lambda-rds-connect-overview)
+ [Automatisches Verbinden einer Lambda-Funktion und eines Multi-AZ-DB-Clusters](#multiaz-lambda-rds-connect-connecting)
+ [Anzeigen verbundener Rechenressourcen](#multiaz-lambda-rds-connect-viewing)
## Überblick über die automatische Konnektivität mit einer Lambda-Funktion
Wenn Sie eine Verbindung zwischen einer Lambda-Funktion und einem Multi-AZ-DB-Cluster automatisch einrichten, konfiguriert Amazon RDS die VPC-Sicherheitsgruppe für Ihre Lambda-Funktion und für Ihren DB-Cluster.
Im Folgenden sind die Anforderungen für die Verbindung einer Lambda-Funktion mit einem Multi-AZ-DB-Cluster aufgeführt:
+ Die Lambda-Funktion muss sich in derselben VPC befinden wie der Multi-AZ-DB-Cluster.
Wenn keine Lambda-Funktion in derselben VPC vorhanden ist, bietet die Konsole einen Link zum Erstellen einer solchen Funktion.
+ Der Benutzer, der die Verbindung einrichtet, muss über Berechtigungen zum Ausführen der folgenden Vorgänge von Amazon RDS, Amazon EC2, Lambda, Secrets Manager und IAM verfügen:
+ Amazon RDS
+ `rds:CreateDBProxies`
+ `rds:DescribeDBInstances`
+ `rds:DescribeDBProxies`
+ `rds:ModifyDBInstance`
+ `rds:ModifyDBProxy`
+ `rds:RegisterProxyTargets`
+ Amazon EC2
+ `ec2:AuthorizeSecurityGroupEgress`
+ `ec2:AuthorizeSecurityGroupIngress`
+ `ec2:CreateSecurityGroup`
+ `ec2:DeleteSecurityGroup`
+ `ec2:DescribeSecurityGroups`
+ `ec2:RevokeSecurityGroupEgress`
+ `ec2:RevokeSecurityGroupIngress`
+ Lambda
+ `lambda:CreateFunctions`
+ `lambda:ListFunctions`
+ `lambda:UpdateFunctionConfiguration`
+ Secrets Manager
+ `sercetsmanager:CreateSecret`
+ `secretsmanager:DescribeSecret`
+ IAM
+ `iam:AttachPolicy`
+ `iam:CreateRole`
+ `iam:CreatePolicy`
+ AWS KMS
+ `kms:describeKey`
Wenn Sie eine Verbindung zwischen einer Lambda-Funktion und einem Multi-AZ-DB-Cluster einrichten, konfiguriert Amazon RDS die VPC-Sicherheitsgruppe für Ihre Funktion und für Ihren Multi-AZ-DB-Cluster. Wenn Sie RDS-Proxy verwenden, konfiguriert Amazon RDS auch die VPC-Sicherheitsgruppe für den Proxy. Amazon RDS handelt gemäß der aktuellen Konfiguration der Sicherheitsgruppen, die dem Multi-AZ-DB-Cluster und der Lambda-Funktion zugeordnet sind, wie in der folgenden Tabelle beschrieben.
| Aktuelle RDS-Sicherheitsgruppenkonfiguration | Aktuelle Konfiguration der Lambda-Sicherheitsgruppe | Aktuelle Konfiguration der Proxy-Sicherheitsgruppe | RDS-Aktion |
| --- | --- | --- | --- |
| Amazon RDS führt keine Aktion aus, da Sicherheitsgruppen aller Ressourcen dem richtigen Benennungsmuster folgen und über die richtigen Regeln für ein- und ausgehenden Datenverkehr verfügen. | Dem Multi-AZ-DB-Cluster sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `rds-lambda-n` entspricht (wobei `n` für eine Zahl steht), oder wenn `TargetHealth` eines zugeordneten Proxys `AVAILABLE` ist. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der Lambda-Funktion oder dem Proxy als Quelle. | Der Lambda-Funktion sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `lambda-rds-n` oder `lambda-rdsproxy-n` entspricht (wobei `n` für eine Zahl steht). Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe hat nur eine Regel für ausgehenden Datenverkehr, wobei entweder die VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters oder der Proxy das Ziel ist. | Dem Proxy sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `rdsproxy-lambda-n` entspricht (wobei `n` für eine Zahl steht). Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe verfügt über Regeln für ein- und ausgehenden Datenverkehr mit den VPC-Sicherheitsgruppen der Lambda-Funktion und des Multi-AZ-DB-Clusters. |
| Es gilt eine der folgenden Bedingungen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/multiaz-lambda-rds-connect.html) Amazon RDS kann eine Sicherheitsgruppe nicht verwenden, wenn sie keine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der Lambda-Funktion oder dem Proxy als Quelle enthält. Amazon RDS kann auch keine Sicherheitsgruppe verwenden, die geändert wurde. Beispiele für Änderungen sind das Hinzufügen einer Regel oder das Ändern des Ports einer vorhandenen Regel. | Es gilt eine der folgenden Bedingungen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/multiaz-lambda-rds-connect.html) Amazon RDS kann eine Sicherheitsgruppe nicht verwenden, wenn diese keine Regel für ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters oder dem Proxy als Quelle enthält. Amazon RDS kann auch keine Sicherheitsgruppe verwenden, die geändert wurde. | Es gilt eine der folgenden Bedingungen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/multiaz-lambda-rds-connect.html)Amazon RDS kann eine Sicherheitsgruppe nicht verwenden, wenn diese keine Regel für ein- und ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters oder der Lambda-Funktion enthält. Amazon RDS kann auch keine Sicherheitsgruppe verwenden, die geändert wurde. | [RDS action: create new security groups](#maz-lam-action-create-new-security-groups) |
| Dem Multi-AZ-DB-Cluster sind eine oder mehrere Sicherheitsgruppe zugeordnet, deren Name dem Muster `rds-lambda-n` entspricht, oder wenn `TargetHealth` eines zugeordneten Proxys `AVAILABLE` ist. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der Lambda-Funktion oder dem Proxy als Quelle. | Der Lambda-Funktion sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `lambda-rds-n` oder `lambda-rdsproxy-n` entspricht. Amazon RDS kann jedoch keine dieser Sicherheitsgruppen für die Verbindung mit dem Multi-AZ-DB-Cluster verwenden. Amazon RDS kann eine Sicherheitsgruppe nicht verwenden, wenn diese keine Regel für ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters als Ziel enthält. Amazon RDS kann auch keine Sicherheitsgruppe verwenden, die geändert wurde. | Dem Proxy sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `rdsproxy-lambda-n` entspricht. Amazon RDS kann jedoch keine dieser Sicherheitsgruppen für die Verbindung mit dem Multi-AZ-DB-Cluster oder der Lambda-Funktion verwenden. Amazon RDS kann eine Sicherheitsgruppe nicht verwenden, wenn diese keine Regel für ein- und ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters oder der Lambda-Funktion enthält. Amazon RDS kann auch keine Sicherheitsgruppe verwenden, die geändert wurde. | [RDS action: create new security groups](#maz-lam-action-create-new-security-groups) |
| Dem Multi-AZ-DB-Cluster sind eine oder mehrere Sicherheitsgruppe zugeordnet, deren Name dem Muster `rds-lambda-n` entspricht, oder wenn `TargetHealth` eines zugeordneten Proxys `AVAILABLE` ist. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe enthält nur eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der Lambda-Funktion oder dem Proxy als Quelle. | Eine gültige Lambda-Sicherheitsgruppe für die Verbindung ist vorhanden, jedoch nicht mit der Lambda-Funktion verknüpft. Die Sicherheitsgruppe hat einen Namen, der dem Muster `lambda-rds-n` oder `lambda-rdsproxy-n` entspricht. Sie wurde nicht geändert. Sie enthält nur eine Regel für ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters oder dem Proxy als Quelle. | Eine gültige Proxy-Sicherheitsgruppe für die Verbindung ist vorhanden, jedoch nicht mit dem Proxy verknüpft. Die Sicherheitsgruppe trägt einen Namen, der dem Muster `rdsproxy-lambda-n` entspricht. Sie wurde nicht geändert. Sie verfügt über Regeln für ein- und ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters und der Lambda-Funktion. | [RDS action: associate Lambda security group](#maz-lam-action-associate-lam-security-group) |
| Es gilt eine der folgenden Bedingungen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/multiaz-lambda-rds-connect.html) | Der Lambda-Funktion sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `lambda-rds-n` oder `lambda-rdsproxy-n` entspricht. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe hat nur eine Regel für ausgehenden Datenverkehr, wobei die VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters oder der Proxy das Ziel ist. | Dem Proxy sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `rdsproxy-lambda-n` entspricht. Eine Sicherheitsgruppe, die dem Muster entspricht, wurde nicht geändert. Diese Sicherheitsgruppe verfügt über Regeln für ein- und ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters und der Lambda-Funktion. | [RDS action: create new security groups](#maz-lam-action-create-new-security-groups) |
| Dem Multi-AZ-DB-Cluster sind eine oder mehrere Sicherheitsgruppen zugeordnet, deren Name dem Muster `rds-rdsproxy-n` entspricht (wobei `n` für eine Zahl steht). | Es gilt eine der folgenden Bedingungen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/multiaz-lambda-rds-connect.html) Amazon RDS kann eine Sicherheitsgruppe nicht verwenden, wenn diese keine Regel für ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters als Ziel enthält. Amazon RDS kann auch keine Sicherheitsgruppe verwenden, die geändert wurde. | Es gilt eine der folgenden Bedingungen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/multiaz-lambda-rds-connect.html)Amazon RDS kann eine Sicherheitsgruppe nicht verwenden, wenn diese keine Regel für ein- und ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters oder der Lambda-Funktion enthält. Amazon RDS kann auch keine Sicherheitsgruppe verwenden, die geändert wurde. | [RDS action: create new security groups](#maz-lam-action-create-new-security-groups) |
**RDS-Aktion : neue Sicherheitsgruppen erstellen**
Amazon RDS führt die folgenden Aktionen durch:
+ Erstellt eine neue Sicherheitsgruppe, die dem Muster `rds-lambda-n` entspricht. Diese Sicherheitsgruppe enthält eine Regel für eingehenden Datenverkehr mit der VPC-Sicherheitsgruppe der Lambda-Funktion oder dem Proxy als Quelle. Diese Sicherheitsgruppe, die dem Multi-AZ-DB-Cluster zugeordnet ist, ermöglicht der Funktion oder dem Proxy den Zugriff auf den Multi-AZ-DB-Cluster.
+ Erstellt eine neue Sicherheitsgruppe, die dem Muster `lambda-rds-n` entspricht. Diese Sicherheitsgruppe hat eine Regel für ausgehenden Datenverkehr, wobei die VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters oder der Proxy das Ziel ist. Diese Sicherheitsgruppe ist der Lambda-Funktion zugeordnet und ermöglicht es der Lambda-Funktion, Datenverkehr an den Multi-AZ-DB-Cluster zu senden oder Datenverkehr über einen Proxy zu senden.
+ Erstellt eine neue Sicherheitsgruppe, die dem Muster `rdsproxy-lambda-n` entspricht. Diese Sicherheitsgruppe verfügt über Regeln für ein- und ausgehenden Datenverkehr mit der VPC-Sicherheitsgruppe des Multi-AZ-DB-Clusters und der Lambda-Funktion.
**RDS-Aktion : Lambda-Sicherheitsgruppe zuordnen**
Amazon RDS ordnet die gültige, vorhandene Lambda-Sicherheitsgruppe der Lambda-Funktion zu. Diese Sicherheitsgruppe ermöglicht es der Funktion, Datenverkehr an den Multi-AZ-DB-Cluster zu senden oder Datenverkehr über einen Proxy zu senden.
## Automatisches Verbinden einer Lambda-Funktion und eines Multi-AZ-DB-Clusters
Sie können die Amazon-RDS-Konsole verwenden, um eine Lambda-Funktion automatisch mit Ihrem Multi-AZ-DB-Cluster zu verbinden. Dies vereinfacht das Einrichten einer Verbindung zwischen diesen Ressourcen.
Sie können den RDS-Proxy auch verwenden, um einen Proxy in Ihre Verbindung aufzunehmen. Lambda-Funktionen stellen häufige, kurze Datenbankverbindungen her, die von dem von RDS-Proxy angebotenen Verbindungspooling profitieren. Sie können auch eine IAM-Authentifizierung nutzen, die Sie bereits für Lambda-Funktionen eingerichtet haben, anstatt Datenbankanmeldeinformationen im Lambda-Anwendungscode zu verwalten.
Sie können einen vorhandenen Multi-AZ-DB-Cluster mit neuen oder bestehenden Lambda-Funktionen unter Verwendung der Seite **Lambda-Verbindung einrichten** verbinden. Beim Einrichtungsvorgang werden automatisch die erforderlichen Sicherheitsgruppen für Sie eingerichtet.
Vor dem Einrichten einer Verbindung zwischen einer Lambda-Funktion und einem Multi-AZ-DB-Cluster stellen Sie Folgendes sicher:
+ Ihre Lambda-Funktion und der Multi-AZ-DB-Cluster befinden sich in derselben VPC.
+ Sie verfügen über die richtigen Berechtigungen für Ihr Benutzerkonto. Weitere Informationen zu den Anforderungen finden Sie unter [Überblick über die automatische Konnektivität mit einer Lambda-Funktion](lambda-rds-connect.md#lambda-rds-connect-overview).
Wenn Sie Sicherheitsgruppen nach dem Konfigurieren der Verbindung ändern, können sich diese Änderungen auf die Verbindung zwischen der Lambda-Funktion und dem Multi-AZ-DB-Cluster auswirken.
**Anmerkung**
Sie können automatisch eine Verbindung zwischen einem Multi-AZ-DB-Cluster und einer Lambda-Funktion nur in der einrichten. AWS-Managementkonsole Zum Herstellen einer Verbindung mit einer Lambda-Funktion müssen sich alle Instances im Multi-AZ-DB-Cluster im Status **Verfügbar** befinden.
**So verbinden Sie eine Lambda-Funktion und einen Multi-AZ-DB-Cluster automatisch**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Datenbanken** und dann den Multi-AZ-DB-Cluster aus, den Sie mit einer Lambda-Funktion verbinden möchten, aus.
1. Wählen Sie für **Aktionen** die Option **Lambda-Verbindung einrichten** aus.
1. Führen Sie auf der Seite **Lambda-Verbindung einrichten** unter **Lambda-Funktion auswählen** einen der folgenden Schritte aus:
+ Wenn eine Lambda-Funktion in derselben VPC wie Ihr Multi-AZ-DB-Cluster vorhanden ist, wählen Sie **Vorhandene Funktion auswählen** aus und wählen Sie dann die Funktion aus.
+ Wenn Sie keine Lambda-Funktion in derselben VPC vorhanden ist, wählen Sie **Neue Funktion erstellen** aus und geben Sie dann einen Namen im Feld **Funktionsname** ein. Die Standard-Laufzeit ist auf Nodejs.18 festgelegt. Sie können die Einstellungen für Ihre neue Lambda-Funktion in der Lambda-Konsole ändern, nachdem Sie die Verbindungseinrichtung abgeschlossen haben.
1. (Optional) Wählen Sie unter **RDS-Proxy** die Option **Über RDS-Proxy verbinden** aus und führen Sie dann einen der folgenden Schritte aus:
+ Wenn Sie einen vorhandenen Proxy haben, den Sie verwenden möchten, klicken Sie auf **Vorhandenen Proxy auswählen** und wählen Sie dann den Proxy aus.
+ Wenn Sie keinen Proxy haben und möchten, dass Amazon RDS automatisch einen für Sie erstellt, wählen Sie **Neuen Proxy erstellen** aus. Führen Sie dann für **Datenbankanmeldeinformationen** einen der folgenden Schritte aus:
1. Wählen Sie **Datenbankbenutzername und Passwort** aus und geben Sie dann den **Benutzernamen** und das **Passwort** für Ihren Multi-AZ-DB-Cluster ein.
1. Wählen Sie **Secrets-Manager-Secret** aus. Wählen Sie dann für **Select secret** ein AWS Secrets Manager Secret aus. Wenn Sie kein Secrets-Manager-Secret haben, wählen Sie **Neues Secrets-Manager-Secret erstellen** aus, um [ein neues Secret zu erstellen](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html). Nachdem Sie das Secret erstellt haben, wählen Sie das neue Secret unter **Secret auswählen** aus.
Nachdem Sie den neuen Proxy erstellt haben, wählen Sie **Vorhandenen Proxy auswählen** aus und wählen Sie dann den Proxy aus. Beachten Sie, dass es einige Zeit dauern kann, bis Ihr Proxy für die Verbindung verfügbar ist.
1. (Optional) Erweitern Sie die **Verbindungsübersicht** und überprüfen Sie die hervorgehobenen Updates für Ihre Ressourcen.
1. Wählen Sie **Einrichten** aus.
Nachdem Sie die Einrichtung bestätigt haben, beginnt Amazon RDS mit dem Herstellen der Verbindung Ihrer Lambda-Funktion, Ihres RDS-Proxys (falls Sie einen Proxy verwendet haben) und Ihres Multi-AZ-DB-Clusters. Die Konsole zeigt das Dialogfeld **Verbindungsdetails** an, in dem die Änderungen der Sicherheitsgruppe aufgeführt sind, die Verbindungen zwischen Ihren Ressourcen ermöglichen.
## Anzeigen verbundener Rechenressourcen
Sie können den verwenden AWS-Managementkonsole , um die Rechenressourcen anzuzeigen, die mit Ihrem Multi-AZ-DB-Cluster verbunden sind. Zu den angezeigten Ressourcen gehören Rechenressourcenverbindungen, die von Amazon RDS automatisch eingerichtet wurden.
Die aufgelisteten Rechenressourcen umfassen keine Ressourcen, die manuell mit dem Multi-AZ-DB-Cluster verbunden sind. Sie können beispielsweise einer Rechenressource den manuellen Zugriff auf Ihren Multi-AZ-DB-Cluster erlauben, indem Sie der VPC-Sicherheitsgruppe, die dem Cluster zugeordnet ist, eine Regel hinzufügen.
Damit die Konsole eine Lambda-Funktion auflistet, müssen die folgenden Bedingungen gelten:
+ Der Name der Sicherheitsgruppe, die der Rechenressource zugeordnet ist, entspricht dem Muster `lambda-rds-n` oder `lambda-rdsproxy-n` (wobei `n` für eine Zahl steht).
+ Die Sicherheitsgruppe, die der Rechenressource zugeordnet ist, enthält eine Regel für ausgehenden Datenverkehr, wobei der Portbereich auf den Port des Multi-AZ-DB-Clusters oder auf einen zugeordneten Proxy festgelegt ist. Das Ziel für die Regel für ausgehenden Datenverkehr muss auf eine dem Multi-AZ-DB-Cluster zugeordneten Sicherheitsgruppe oder auf einen zugeordneten Proxy festgelegt werden.
+ Der Name der Sicherheitsgruppe, die an den mit Ihrer Datenbank verknüpften Proxy angefügt ist, entspricht dem Muster `rds-rdsproxy-n` (wobei `n` für eine Zahl steht).
+ Die Sicherheitsgruppe, die der Funktion zugeordnet ist, hat eine Regel für ausgehenden Datenverkehr, wobei der Port auf den Port festgelegt ist, den der Multi-AZ-DB-Cluster oder ein zugeordneter Proxy verwendet. Das Ziel muss auf eine dem Multi-AZ-DB-Cluster zugeordneten Sicherheitsgruppe oder auf einen zugeordneten Proxy festgelegt werden.
**So zeigen Sie Rechenressourcen an, die automatisch mit einem Multi-AZ-DB-Cluster verbunden sind**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich die Option **Datenbanken** und anschließend den Multi-AZ-DB-Cluster aus.
1. Sehen Sie sich auf der Registerkarte **Konnektivität und Sicherheit** die Rechenressourcen unter **Verbundene Rechenressourcen** an.
# Ändern eines Multi-AZ-DB-Clusters für Amazon RDS
Ein Multi-AZ-DB-Cluster verfügt über eine Writer-DB-Instance und zwei Reader-DB-Instances in drei separaten Availability Zones. Multi-AZ-DB-Cluster bieten hohe Verfügbarkeit, erhöhte Kapazität für Lese-Workloads und eine geringere Latenz im Vergleich zu Multi-AZ-Bereitstellungen. Weitere Informationen zu Multi-AZ-DB-Clustern finden Sie unter [Bereitstellungen von Multi-AZ-DB-Clustern für Amazon RDS](multi-az-db-clusters-concepts.md).
Sie können einen Multi-AZ-DB-Cluster ändern, um seine Einstellungen zu ändern. Sie können auch Vorgänge an einem Multi-AZ-DB-Cluster ausführen, z. B. einen Snapshot davon machen.
**Wichtig**
Sie können die DB-Instances in einem Multi-AZ-DB-Cluster nicht ändern. Alle Änderungen müssen auf DB-Cluster-Ebene vorgenommen werden. Den einzigen Vorgang, den Sie auf einer DB-Instance in einem Multi-AZ-DB-Cluster durchführen können, ist ihr Neustart.
Sie können einen Multi-AZ-DB-Cluster mithilfe der AWS-Managementkonsole AWS CLI, der oder der RDS-API ändern.
## Konsole
**Ändern eines Multi-AZ-DB-Clusters**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** und dann den zu ändernden Multi-AZ-DB-Cluster aus.
1. Wählen Sie **Ändern** aus. Die Seite **DB-Cluster ändern** wird angezeigt.
1. Ändern Sie alle Einstellungen nach Bedarf. Weitere Informationen zu den einzelnen Einstellungen finden Sie unter [Einstellungen zum Ändern von Multi-AZ-DB-Clustern](#modify-multi-az-db-cluster-settings).
1. Nachdem Sie die gewünschten Änderungen vorgenommen haben, wählen Sie **Weiter** und überprüfen Sie die Zusammenfassung aller Änderungen.
1. (Optional) Klicken Sie auf **Apply immediately (Sofort anwenden)**, um die Änderungen direkt zu übernehmen. Die Auswahl dieser Option kann in einigen Fällen Ausfallzeiten verursachen. Weitere Informationen finden Sie unter [Änderungen sofort anwenden](#modify-multi-az-db-cluster-apply-immediately).
1. Überprüfen Sie auf der Bestätigungsseite Ihre Änderungen. Wenn sie korrekt sind, wählen Sie **Modify DB cluster (DB-Cluster ändern)** aus, um Ihre Änderungen zu speichern.
Oder klicken Sie auf **Zurück**, um Ihre Änderungen zu bearbeiten, oder auf **Abbrechen**, um Ihre Änderungen zu verwerfen.
## AWS CLI
Um einen Multi-AZ-DB-Cluster mithilfe von zu ändern AWS CLI, rufen Sie den [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html)Befehl auf. Geben Sie die DB-Cluster-ID und die Werte für die Optionen an, die Sie ändern möchten. Informationen zu den jeweiligen Optionen finden Sie unter [Einstellungen zum Ändern von Multi-AZ-DB-Clustern](#modify-multi-az-db-cluster-settings).
**Example**
Mit folgendem Code wird `my-multi-az-dbcluster` geändert, da der Aufbewahrungszeitraum für Backups auf 1 Woche (7 Tage) festgelegt wird. Der Code ermöglicht den Löschschutz durch Verwendung von `--deletion-protection`. Um den Löschschutz zu deaktivieren, verwenden Sie `--no-deletion-protection`. Die Änderungen werden während des nächsten Wartungsfensters (mit ) übernommen `--no-apply-immediately`. Verwenden Sie `--apply-immediately`, damit Änderungen sofort angewendet werden. Weitere Informationen finden Sie unter [Änderungen sofort anwenden](#modify-multi-az-db-cluster-apply-immediately).
Für Linux, macOS oder Unix:
```
aws rds modify-db-cluster \
--db-cluster-identifier my-multi-az-dbcluster \
--backup-retention-period 7 \
--deletion-protection \
--no-apply-immediately
```
Für Windows:
```
aws rds modify-db-cluster ^
--db-cluster-identifier my-multi-az-dbcluster ^
--backup-retention-period 7 ^
--deletion-protection ^
--no-apply-immediately
```
## RDS-API
Um einen Multi-AZ-DB-Cluster mithilfe der Amazon RDS-API zu ändern, rufen Sie den DBCluster Vorgang [Modify](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) auf. Geben Sie die DB-Cluster-Kennung und die Parameter für die Einstellungen an, die geändert werden sollen. Weitere Informationen zu den einzelnen Parametern finden Sie unter [Einstellungen zum Ändern von Multi-AZ-DB-Clustern](#modify-multi-az-db-cluster-settings).
## Änderungen sofort anwenden
Wenn Sie einen Multi-AZ-DB-Cluster ändern, können Sie die Änderungen sofort anwenden. Damit Änderungen sofort übernommen werden, wählen Sie die Option **Apply Immediately (Sofort anwenden)** in der AWS-Managementkonsole aus. Oder Sie verwenden die `--apply-immediately` Option beim Aufrufen der AWS CLI oder setzen den `ApplyImmediately` Parameter auf, `true` wenn Sie die Amazon RDS-API verwenden.
Wenn Sie sich entscheiden, die Änderungen nicht sofort zu übernehmen, werden die Änderungen in die Warteschlange für ausstehende Änderungen aufgenommen. Während des nächsten Wartungsfensters, werden alle ausstehenden Änderungen in der Warteschlange angewandt. Wenn Sie sich entscheiden, die Änderungen sofort zu übernehmen, werden alle Ihre neuen Änderungen sowie alle ausstehenden Änderungen in der Warteschlange übernommen.
**Wichtig**
Wenn es eine der ausstehenden Änderungen erfordert, dass der DB-Cluster vorübergehend nicht verfügbar ist (*Ausfallzeiten*), kann die Auswahl der Option „Sofort anwenden“ zu unerwarteten Ausfallzeiten führen.
Wenn Sie sich dafür entscheiden, eine Änderung sofort anzuwenden, werden alle anstehenden Änderungen ebenfalls sofort und nicht erst im nächsten Wartungsfenster übernommen.
Wenn Sie nicht möchten, dass eine ausstehende Änderung im nächsten Wartungsfenster übernommen wird, können Sie die DB-Instance so abändern, dass die Änderung rückgängig gemacht wird. Sie können dies tun, indem Sie die `--apply-immediately` Option AWS CLI und angeben.
Änderungen an Datenbankeinstellungen werden unmittelbar übernommen, auch wenn Sie sich entscheiden, Ihre Änderungen auf einen späteren Zeitpunkt zu verschieben. Informationen darüber, wie die verschiedenen Datenbankeinstellungen mit der Einstellung „Apply Immediately (Sofort Anwenden)“ interagieren, finden Sie unter [Einstellungen zum Ändern von Multi-AZ-DB-Clustern](#modify-multi-az-db-cluster-settings).
## Einstellungen zum Ändern von Multi-AZ-DB-Clustern
Weitere Informationen zu Einstellungen, die Sie zum Ändern eines Multi-AZ-DB-Clusters verwenden können, finden Sie in der folgenden Tabelle. Weitere Informationen zu den AWS CLI Optionen finden Sie unter [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html). Weitere Informationen zu den RDS-API-Parametern finden Sie unter [Ändern DBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html).
| Konsoleneinstellung | Beschreibung der Einstellung | CLI-Option und RDS-API-Parameter | Wann wird die Änderung übernommen | Hinweise zur Ausfallzeit |
| --- | --- | --- | --- | --- |
| **Allocated storage** | Die für jede DB-Instance in Ihrem DB-Cluster zuzuweisende Speichermenge (in Gibibyte). Weitere Informationen finden Sie unter [Amazon-RDS-DB-Instance-Speicher](CHAP_Storage.md). | **CLI-Option:** `--allocated-storage` **RDS-API-Parameter:** `AllocatedStorage` | Wenn Sie die Änderung sofort anwenden möchten, tritt sie sofort auf. Wenn Sie die Änderung nicht sofort anwenden möchten, tritt sie während des nächsten Wartungsfensters auf. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| Automatische Nebenversions-Updates | **Aktivieren Sie das automatische Upgrade der Nebenversion**, damit Ihr DB-Cluster automatisch Upgrades der bevorzugten Nebenversion der DB-Engine erhält, wenn diese verfügbar sind. Amazon RDS führt im Wartungsfenster automatische Nebenversionenupgrades durch. | **CLI-Option:** `--auto-minor-version-upgrade` `--no-auto-minor-version-upgrade` **RDS-API-Parameter:** `AutoMinorVersionUpgrade` | Die Änderung wird sofort übernommen. Diese Einstellung ignoriert die Einstellung „Apply Immediately (Sofort Anwenden)“. | Während dieser Änderung treten Ausfallzeiten auf. |
| Aufbewahrungszeitraum für Backups | Die Anzahl der Tage, für die automatische Backups der DB-Cluster beibehalten werden sollen. Dieser Wert muss größer als null sein. Weitere Informationen finden Sie unter [Einführung in Backups](USER_WorkingWithAutomatedBackups.md). | **CLI-Option:** `--backup-retention-period` **RDS-API-Parameter:** `BackupRetentionPeriod` | Wenn Sie die Änderung sofort anwenden möchten, tritt sie sofort auf. Wenn Sie die Änderung nicht sofort anwenden möchten, tritt sie während des nächsten Wartungsfensters auf. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| Backup window | Der Zeitraum, in dem Amazon RDS automatisch ein Backup der DB-Cluster erstellt. Wenn Sie keine bestimmte Zeit haben, zu der Sie Ihre Datenbank sichern möchten, verwenden Sie den Standardwert **No Preference (Keine Präferenz)**. Weitere Informationen finden Sie unter [Einführung in Backups](USER_WorkingWithAutomatedBackups.md). | **CLI-Option:** `--preferred-backup-window` **RDS-API-Parameter:** `PreferredBackupWindow` | Die Änderung wird asynchron zum nächstmöglichen Zeitpunkt übernommen. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| **Zertifizierungsstelle** | Die Zertifizierungsstelle (CA) für das Serverzertifikat, das vom DB-Cluster verwendet wird. Weitere Informationen finden Sie unter [](UsingWithRDS.SSL.md). | **CLI-Option:** `--ca-certificate-identifier` **RDS-API-Parameter:** `CACertificateIdentifier` | Wenn Sie die Änderung sofort anwenden möchten, tritt sie sofort auf. Wenn Sie die Änderung nicht sofort anwenden möchten, tritt sie während des nächsten Wartungsfensters auf. | Ein Ausfall tritt nur auf, wenn die DB-Engine keine Rotation ohne Neustart unterstützt. Sie können den [describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html) AWS CLI Befehl verwenden, um festzustellen, ob die DB-Engine die Rotation ohne Neustart unterstützt. |
| Tags zu Snapshots kopieren | Diese Option kopiert alle DB-Cluster-Tags in einen DB-Snapshot, wenn Sie einen Snapshot erstellen. Weitere Informationen finden Sie unter [Taggen von Amazon RDS-Ressourcen](USER_Tagging.md). | **CLI-Option:** `-copy-tags-to-snapshot` `-no-copy-tags-to-snapshot` **RDS-API-Parameter:** `CopyTagsToSnapshot` | Die Änderung wird sofort übernommen. Diese Einstellung ignoriert die Einstellung „Apply Immediately (Sofort Anwenden)“. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| Datenbank-Authentifizierung | Für Multi-AZ-DB-Cluster wird nur die **Passwortauthentifizierung** unterstützt. | Keine, da die Passwortauthentifizierung der Standard ist. | Wenn Sie die Änderung sofort anwenden möchten, tritt sie sofort auf. Wenn Sie die Änderung nicht sofort anwenden möchten, tritt sie während des nächsten Wartungsfensters auf. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| **DB-Cluster-Kennung** | Die DB-Cluster-ID. Dieser Wert wird als Zeichenfolge in Kleinbuchstaben gespeichert. Wenn Sie die DB-Cluster-ID ändern, wird der DB-Cluster-Endpunkt geändert. Die IDs und Endpunkte der DB-Instances im DB-Cluster ändern sich ebenfalls. Der neue DB-Clustername muss eindeutig sein. Die maximale Länge beträgt 63 Zeichen. Die Namen der DB-Instances im DB-Cluster werden so geändert, dass sie dem neuen Namen des DB-Clusters entsprechen. Ein neuer DB-Instance-Name darf nicht mit dem Namen einer vorhandenen DB-Instance identisch sein. Wenn Sie beispielsweise den DB-Clusternamen in `maz` ändern, wird möglicherweise ein DB-Instance-Name in `maz-instance-1` geändert. In diesem Fall darf keine DB-Instance mit dem Namen `maz-instance-1` vorhanden sein. Weitere Informationen finden Sie unter [Umbenennen eines Multi-AZ-DB-Clusters für Amazon RDS](multi-az-db-cluster-rename.md). | **CLI-Option:** `--new-db-cluster-identifier` **RDS-API-Parameter:** `NewDBClusterIdentifier` | Wenn Sie die Änderung sofort anwenden möchten, tritt sie sofort auf. Wenn Sie die Änderung nicht sofort anwenden möchten, tritt sie während des nächsten Wartungsfensters auf. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| DB-Cluster-Instance-Klasse | Die Rechen- und Arbeitsspeicherkapazität jeder DB-Instance im Multi-AZ-DB-Cluster, zum Beispiel `db.r6gd.xlarge`. Wählen Sie möglichst eine DB-Instance-Klasse, die groß genug ist, um einen typischer Abfragesatz im Arbeitsspeicher halten zu können. Wenn Arbeitssätze im Arbeitsspeicher gehalten werden, kann das System das Schreiben auf die Festplatte vermeiden, was die Leistung verbessert. Weitere Informationen finden Sie unter [Verfügbarkeit von Instance-Klassen für Multi-AZ-DB-Cluster](multi-az-db-clusters-concepts.md#multi-az-db-clusters-concepts.InstanceAvailability). | **CLI-Option:** `--db-cluster-instance-class` **RDS-API-Parameter:** `DBClusterInstanceClass` | Wenn Sie die Änderung sofort anwenden möchten, tritt sie sofort auf. Wenn Sie die Änderung nicht sofort anwenden möchten, tritt sie während des nächsten Wartungsfensters auf. | Während dieser Änderung treten Ausfallzeiten auf. |
| **DB-Cluster-Parametergruppe** | Die DB-Clusterparametergruppe, die Sie mit dem DB-Cluster verknüpfen möchten. Weitere Informationen finden Sie unter [Parametergruppen für Multi-AZ-DB-Cluster](multi-az-db-clusters-concepts.md#multi-az-db-clusters-concepts-parameter-groups). | **CLI-Option:** `--db-cluster-parameter-group-name` **RDS-API-Parameter:** `DBClusterParameterGroupName` | Die Änderung der Parametergruppe wird sofort übernommen. | Während dieser Änderung treten keine Ausfallzeiten auf. Wenn Sie die Parametergruppe ändern, werden die Änderungen an einigen Parametern ohne Neustart sofort auf die DB-Instances im Multi-AZ-DB-Cluster angewendet. Änderungen an anderen Parametern werden erst angewendet, nachdem die DB-Instances neu gestartet wurden. |
| DB-Engine-Version | Die Version der Datenbank-Engine, die Sie verwenden möchten. | **CLI-Option:** `--engine-version` **RDS-API-Parameter:** `EngineVersion` | Wenn Sie die Änderung sofort anwenden möchten, tritt sie sofort auf. Wenn Sie die Änderung nicht sofort anwenden möchten, tritt sie während des nächsten Wartungsfensters auf. | Während dieser Änderung treten Ausfallzeiten auf. |
| Löschschutz | Um zu verhindern, dass Ihr DB-Cluster gelöscht wird, können Sie die Option **Löschschutz aktivieren** aktivieren. Weitere Informationen finden Sie unter [Löschen einer DB-Instance](USER_DeleteInstance.md). | **CLI-Option:** `--deletion-protection` `--no-deletion-protection` **RDS-API-Parameter:** `DeletionProtection` | Die Änderung wird sofort übernommen. Diese Einstellung ignoriert die Einstellung „Apply Immediately (Sofort Anwenden)“. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| Wartungsfenster | Das 30-Minuten-Fenster, in dem anstehende Änderungen an Ihrem DB-Cluster durchgeführt werden. Wählen Sie **No Preference (Keine Präferenz)** aus, wenn der Zeitraum nicht wichtig ist. Weitere Informationen finden Sie unter [Amazon-RDS-Wartungsfenster](USER_UpgradeDBInstance.Maintenance.md#Concepts.DBMaintenance). | **CLI-Option:** `--preferred-maintenance-window` **RDS-API-Parameter:** `PreferredMaintenanceWindow` | Die Änderung wird sofort übernommen. Diese Einstellung ignoriert die Einstellung „Apply Immediately (Sofort Anwenden)“. | Sofern eine oder mehrere Aktionen ausstehen, die Ausfallzeiten verursachen, und Sie das Wartungsfenster auf die aktuelle Zeit ändern, werden die ausstehenden Aktionen sofort angewendet und es kommt zu Ausfallzeiten. |
| Hauptanmeldedaten verwalten in AWS Secrets Manager | Wählen Sie **Master-Anmeldeinformationen verwalten in AWS Secrets Manager** aus, um das Hauptbenutzerpasswort in Secrets Manager geheim zu verwalten. Wählen Sie optional einen KMS-Schlüssel zum Schutz des Secrets aus. Wählen Sie aus den KMS-Schlüsseln in Ihrem Konto oder geben Sie den Schlüssel eines anderen Kontos ein. Wenn RDS bereits das Hauptbenutzerpasswort für den DB-Cluster verwaltet, können Sie dieses Passwort mit der Option **Rotate secret immediately** (Sofortige Secret-Drehung) rotieren. Weitere Informationen finden Sie unter [Passwortverwaltung mit Amazon RDS, und AWS Secrets Manager](rds-secrets-manager.md). | **CLI-Option:** `--manage-master-user-password \| --no-manage-master-user-password` `--master-user-secret-kms-key-id` `--rotate-master-user-password \| --no-rotate-master-user-password` **RDS-API-Parameter:** `ManageMasterUserPassword` `MasterUserSecretKmsKeyId` `RotateMasterUserPassword` | Wenn Sie die automatische Passwortverwaltung für Hauptbenutzer ein- oder ausschalten, erfolgt die Änderung sofort. Bei dieser Änderung wird die Einstellung zum sofortigen Anwenden ignoriert. Wenn Sie das Hauptbenutzerpasswort ändern, müssen Sie angeben, dass die Änderung sofort übernommen wird. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| Neues Master-Passwort | Das Passwort für das Masterbenutzerkonto. | **CLI-Option:** `--master-user-password` **RDS-API-Parameter:** `MasterUserPassword` | Die Änderung wird asynchron zum nächstmöglichen Zeitpunkt übernommen. Diese Einstellung ignoriert die Einstellung „Apply Immediately (Sofort Anwenden)“. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| Bereitgestellte IOPS | Die Menge von bereitgestellten IOPS (Ein-/Ausgabeoperationen pro Sekunde), die dem DB-Cluster anfänglich zugewiesen werden soll. | **CLI-Option:** `--iops` **RDS-API-Parameter:** `Iops` | Wenn Sie die Änderung sofort anwenden möchten, tritt sie sofort auf. Wenn Sie die Änderung nicht sofort anwenden möchten, tritt sie während des nächsten Wartungsfensters auf. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| Öffentlicher Zugriff | **Öffentlich zugänglich**, um dem DB-Cluster eine öffentliche IP-Adresse zuzuweisen, was bedeutet, dass er außerhalb seiner Virtual Private Cloud (VPC) zugänglich ist. Damit der öffentliche Zugriff für ein DB-Cluster möglich ist, muss sie sich auch in einem öffentlichen Subnetz der VPC befinden. **Not publicly accessible (Nicht öffentlich zugänglich)**, um den DB-Cluster nur innerhalb der VPC zugänglich zu machen. Weitere Informationen finden Sie unter [Ausblenden einer DB-Instance in einer VPC vor dem Internet](USER_VPC.WorkingWithRDSInstanceinaVPC.md#USER_VPC.Hiding). Um eine Verbindung zu einem DB-Cluster von außerhalb seiner VPC herzustellen, muss der DB-Cluster öffentlich zugänglich sein. Außerdem muss der Zugriff unter Verwendung der eingehenden Regeln der Sicherheitsgruppe dem DB-Cluster gewährt werden, und andere Anforderungen müssen erfüllt sein. Weitere Informationen finden Sie unter [Verbindung zur Amazon-RDS-DB-Instance kann nicht hergestellt werden](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting). Wenn Ihr DB-Cluster nicht öffentlich zugänglich ist, können Sie eine AWS Site-to-Site VPN-Verbindung oder eine Direct Connect Verbindung verwenden, um von einem privaten Netzwerk aus darauf zuzugreifen. Weitere Informationen finden Sie unter [Richtlinie für den Datenverkehr zwischen Netzwerken](inter-network-traffic-privacy.md). | Nicht verfügbar beim Ändern eines DB-Clusters. | Die Änderung wird sofort übernommen. Diese Einstellung ignoriert die Einstellung „Apply Immediately (Sofort Anwenden)“. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| Speichertyp | Der Speichertyp für Ihren DB-Cluster. Es werden nur Allzweck-SSD (gp3), SSD mit bereitgestellter IOPS (io1) und SSD mit bereitgestellter IOPS (io2) unterstützt. Weitere Informationen finden Sie unter [Amazon-RDS-Speichertypen](CHAP_Storage.md#Concepts.Storage). | **CLI-Option:** `--storage-type` **RDS-API-Parameter:** `StorageType` | Wenn Sie die Änderung sofort anwenden möchten, tritt sie sofort auf. Wenn Sie die Änderung nicht sofort anwenden möchten, tritt sie während des nächsten Wartungsfensters auf. | Während dieser Änderung treten keine Ausfallzeiten auf. |
| VPC Security Group (VPC-Sicherheitsgruppe) | Die Sicherheitsgruppen, die dem DB-Cluster zugeordnet werden sollen. Weitere Informationen finden Sie unter [Überblick über VPC-Sicherheitsgruppen](Overview.RDSSecurityGroups.md#Overview.RDSSecurityGroups.VPCSec). | **CLI-Option:** `--vpc-security-group-ids` **RDS-API-Parameter:** `VpcSecurityGroupIds` | Die Änderung wird asynchron zum nächstmöglichen Zeitpunkt übernommen. Diese Einstellung ignoriert die Einstellung „Apply Immediately (Sofort Anwenden)“. | Während dieser Änderung treten keine Ausfallzeiten auf. |
## Einstellungen, die beim Ändern von Multi-AZ-DB-Clustern nicht gelten
Die folgenden Einstellungen im AWS CLI Befehl [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html)und im RDS-API-Vorgang [Ändern](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) gelten DBCluster nicht für Multi-AZ-DB-Cluster.
Sie können diese Einstellungen auch für Multi-AZ-DB-Cluster in der Konsole nicht ändern.
| AWS CLI Einstellung | RDS-API-Einstellung |
| --- | --- |
| `--backtrack-window` | `BacktrackWindow` |
| `--cloudwatch-logs-export-configuration` | `CloudwatchLogsExportConfiguration` |
| `--copy-tags-to-snapshot \| --no-copy-tags-to-snapshot` | `CopyTagsToSnapshot` |
| `--db-instance-parameter-group-name` | `DBInstanceParameterGroupName` |
| `--domain` | `Domain` |
| `--domain-iam-role-name` | `DomainIAMRoleName` |
| `--enable-global-write-forwarding \| --no-enable-global-write-forwarding` | `EnableGlobalWriteForwarding` |
| `--enable-http-endpoint \| --no-enable-http-endpoint` | `EnableHttpEndpoint` |
| `--option-group-name` | `OptionGroupName` |
| `--port` | `Port` |
| `--scaling-configuration` | `ScalingConfiguration` |
| `--storage-type` | `StorageType` |
# Aktualisieren der Engine-Version eines Multi-AZ-DB-Clusters für Amazon RDS
Amazon RDS stellt neuere Versionen jeder unterstützten Datenbank-Engine zur Verfügung, sodass Sie den Multi-AZ-DB-Cluster auf dem neuesten Stand halten können. In diesem Thema wird das Upgrade eines Multi-AZ-DB-Clusters auf neuere Versionen erläutert.
Das Upgrade eines Multi-AZ-DB-Clusters beinhaltet die Auswahl einer neuen kompatiblen Engine-Version und die Planung möglicher Ausfallzeiten. Der Prozess gewährleistet minimale Unterbrechungen, indem die Failover-Funktionen der Multi-AZ-Architektur genutzt werden. Zu den bewährten Methoden gehören die Durchführung von Upgrades in Zeiträumen mit geringem Datenverkehr, Tests in Nicht-Produktionsumgebungen und die Überprüfung der Anwendungskompatibilität mit der neuen Version.
**Topics**
+ [Unterversion-Upgrades](#multi-az-db-clusters-upgrade-minor)
+ [Hauptversions-Upgrades](#multi-az-db-clusters-upgrade-major)
+ [Aktualisieren eines Multi-AZ-DB-Clusters](#multi-az-db-clusters-upgrade-process)
+ [Aktualisieren von Lesereplikaten des Multi-AZ-DB-Clusters](#multi-az-db-clusters-upgrade-replicas)
+ [Überwachung von Multi-AZ-DB-Cluster-Upgrades mit Ereignissen](#multi-az-db-clusters-upgrade-monitoring)
## Unterversion-Upgrades
Ein Nebenversion-Upgrade enthalten nur Änderungen, die abwärtskompatibel mit bestehenden Anwendungen sind. Wenn Sie ein Nebenversions-Upgrade initiieren, aktualisiert Amazon RDS zunächst die Reader-DB-Instances nacheinander. Dann wechselt eine der Reader-DB-Instances zur neuen Writer-DB-Instance. Amazon RDS aktualisiert anschließend die alte Writer-Instance (die nun eine Reader-Instance ist).
Die Ausfallzeit während des Upgrades ist auf die Zeitdauer beschränkt, bis eine der Reader-DB-Instances die neue Writer-DB-Instance wird. Diese Ausfallzeit wirkt wie ein automatischer Failover. Weitere Informationen finden Sie unter [Failover eines Multi-AZ-DB-Clusters für Amazon RDS](multi-az-db-clusters-concepts-failover.md). Beachten Sie, dass die Replikatverzögerung des Multi-AZ-DB-Clusters die Ausfallzeit beeinflussen kann. Weitere Informationen finden Sie unter [Replikatverzögerung und Multi-AZ-DB-Cluster](multi-az-db-clusters-concepts.md#multi-az-db-clusters-concepts-replica-lag).
Bei Lesereplikaten des Multi-AZ-DB-Clusters von RDS für PostgreSQL aktualisiert Amazon RDS die Cluster-Mitglieds-Instances nacheinander. Die Cluster-Rollen „Reader“ und „Writer“ wechseln während des Upgrades nicht. Daher kommt es im DB-Cluster möglicherweise zu Ausfallzeiten, während Amazon RDS die Writer-Instance aktualisiert.
**Anmerkung**
Die Ausfallzeit beim Nebenversions-Upgrade des Multi-AZ-DB-Clusters beträgt normalerweise 35 Sekunden. Bei Verwendung mit dem RDS-Proxy können Sie die Ausfallzeit weiter auf eine Sekunde oder weniger reduzieren. Weitere Informationen finden Sie unter [Amazon RDS-Proxy ](rds-proxy.md). Alternativ können Sie einen Open-Source-Datenbank-Proxy wie [ProxySQL](https://aws.amazon.com/blogs/database/achieve-one-second-or-less-of-downtime-with-proxysql-when-upgrading-amazon-rds-multi-az-deployments-with-two-readable-standbys/) oder den [AWS Advanced JDBC [PgBouncer](https://aws.amazon.com/blogs/database/fast-switchovers-with-pgbouncer-on-amazon-rds-multi-az-deployments-with-two-readable-standbys-for-postgresql/)](https://aws.amazon.com/blogs/database/achieve-one-second-or-less-downtime-with-the-advanced-jdbc-wrapper-driver-when-upgrading-amazon-rds-multi-az-db-clusters/)Wrapper Driver verwenden.
## Hauptversions-Upgrades
In Hauptversions-Upgrades Änderungen können enthalten sein, die nicht mit vorhandenen Anwendungen kompatibel sind.
Wenn Sie ein Hauptversions-Upgrade eines Multi-AZ-DB-Clusters von RDS für PostgreSQL initiieren, aktualisiert Amazon RDS gleichzeitig die Reader- und Writer-Instances. Der DB-Cluster ist daher möglicherweise erst verfügbar, wenn das Upgrade abgeschlossen wurde.
Wenn Sie ein Hauptversions-Upgrade eines Multi-AZ-DB-Clusters von RDS für MySQL initiieren, aktualisiert Amazon RDS die Cluster-Mitglieds-Instances nacheinander, sodass die Replikation von einer niedrigeren Engine-Version auf eine höhere erfolgt. Es ist wichtig, sich zu vergewissern, dass der Workload während eines Hauptversions-Upgrades sowohl mit der Quell- als auch mit der Ziel-Engine-Version kompatibel ist, da Engine-Versionen sich hinsichtlich Syntax und Funktionen unterscheiden können.
**Anmerkung**
Wie bei Nebenversions-Upgrades beträgt die Ausfallzeit bei einem Hauptversions-Upgrade von RDS für MySQL normalerweise 35 Sekunden. Bei Verwendung mit dem RDS-Proxy können Sie die Ausfallzeit weiter auf eine Sekunde oder weniger reduzieren. Weitere Informationen finden Sie unter [Amazon RDS-Proxy ](rds-proxy.md).
## Aktualisieren eines Multi-AZ-DB-Clusters
Der Vorgang für das Upgrade der Engine-Version eines Multi-AZ-DB-Clusters entspricht dem Vorgang für das Upgrade der Version einer DB-Instance-Engine. Detaillierte Anweisungen finden Sie unter [Upgrade der Engine-Version für eine DB-Instance ](USER_UpgradeDBInstance.Upgrading.md). Der einzige Unterschied besteht darin, dass Sie bei der Verwendung von AWS Command Line Interface (AWS CLI) den [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html)Befehl verwenden und den `--db-cluster-identifier` Parameter (zusammen mit dem Parameter) angeben. `--allow-major-version-upgrade`
Weitere Informationen zu Haupt- und Nebenversions-Upgrades finden Sie in der folgenden Dokumentation für Ihre DB-Engine:
+ [Upgrades der DB-Engine von RDS für PostgreSQL](USER_UpgradeDBInstance.PostgreSQL.md)
+ [Upgrades der DB-Engine von RDS für MySQL](USER_UpgradeDBInstance.MySQL.md)
## Aktualisieren von Lesereplikaten des Multi-AZ-DB-Clusters
Amazon RDS aktualisiert Lesereplikate von Multi-AZ-DB-Clustern nicht automatisch. Bei Upgrades von *Nebenversionen* müssen Sie zuerst manuell alle Lesereplikate und dann den Cluster aktualisieren. Andernfalls wird das Upgrade blockiert. Bei Upgrades der *Hauptversion* eines Clusters ändert sich der Replikationsstatus aller Lesereplikate in **Beendet**. Sie müssen die Lesereplikate nach Abschluss des Upgrades löschen und neu erstellen. Weitere Informationen finden Sie unter [Überwachen der Lesereplikation](USER_ReadRepl.Monitoring.md).
## Überwachung von Multi-AZ-DB-Cluster-Upgrades mit Ereignissen
Wenn Sie die Engine-Version eines Multi-AZ-DB-Clusters aktualisieren, gibt Amazon RDS in jeder Phase des Prozesses ein bestimmtes Ereignis aus. Um den Fortschritt eines Upgrades zu verfolgen, können Sie diese Ereignisse anzeigen oder abonnieren.
Weitere Informationen zu RDS-Ereignissen finden Sie unter[Überwachung von Amazon-RDS-Ereignissen](working-with-events.md).
Ausführliche Informationen zu einem bestimmten Amazon RDS-Ereignis, das während Ihres Engine-Upgrades auftritt, finden Sie unter[Amazon RDS-Ereigniskategorien und Ereignisnachrichten ](USER_Events.Messages.md).
# Umbenennen eines Multi-AZ-DB-Clusters für Amazon RDS
Sie können einen Multi-AZ-DB-Cluster umbenennen, indem Sie die AWS-Managementkonsole, den AWS CLI-Befehl `modify-db-cluster` oder die Operation `ModifyDBCluster` von Amazon-RDS-API verwenden. Das Umbenennen eines Multi-AZ-DB-Clusters kann erhebliche Auswirkungen haben. Im Folgenden finden Sie eine Liste von Überlegungen, die zu beachten sind, bevor Sie einen Multi-AZ-DB-Cluster umbenennen.
+ Wenn Sie einen Multi-AZ-DB-Cluster umbenennen, ändern sich die Cluster-Endpunkte für den Multi-AZ-DB-Cluster. Diese Endpunkte ändern sich, weil sie den Namen enthalten, den Sie dem Multi-AZ-DB-Cluster zugewiesen haben. Sie können Datenverkehr von einem alten Endpunkt auf einen neuen umleiten. Weitere Informationen zu Endpunkten von Multi-AZ-DB-Clustern finden Sie unter [Herstellen einer Verbindung mit einem Multi-AZ-DB-Cluster für Amazon RDS](multi-az-db-clusters-concepts-connection-management.md).
+ Wenn Sie einen Multi-AZ-DB-Cluster umbenennen, wird der alte DNS-Name des Multi-AZ-DB-Clusters gelöscht (obwohl er noch einige Minuten im Cache verbleiben könnte). Der neue DNS-Name für den umbenannten Multi-AZ-DB-Cluster wird nach etwa zwei Minuten wirksam. Der umbenannte Multi-AZ-DB-Cluster ist erst verfügbar, wenn der neue Name wirksam ist.
+ Sie können beim Umbenennen eines Clusters keinen vorhandenen Multi-AZ-DB-Clusternamen verwenden.
+ Metriken und Ereignisse, die dem Namen eines Multi-AZ-DB-Clusters zugeordnet sind, bleiben erhalten, wenn Sie einen DB-Instance-Namen erneut verwenden.
+ Multi-AZ-DB-Cluster-Tags verbleiben unabhängig von der Umbenennung beim Multi-AZ-DB-Cluster.
+ DB-Cluster-Snapshots werden für einen umbenannten Multi-AZ-DB-Cluster beibehalten.
**Anmerkung**
Eine DB-Instance ist eine isolierte Datenbankumgebung, die in der Cloud ausgeführt wird. Ein Multi-AZ-DB-Cluster kann mehrere Datenbanken hosten. Informationen zum Ändern eines Datenbanknamens finden Sie in der Dokumentation für Ihre DB-Engine.
## Umbenennen, um einen bestehenden Multi-AZ-DB-Cluster zu ersetzen
Zu den häufigsten Szenarien für das Umbenennen eines Multi-AZ-DB-Clusters gehören die Wiederherstellung von Daten aus einem DB-Cluster-Snapshot oder die Durchführung einer zeitpunktbezogenen Wiederherstellung (PITR). Durch das Umbenennen des Multi-AZ-DB-Clusters können Sie den Multi-AZ-DB-Cluster ersetzen, ohne den Anwendungscode zu ändern, der auf den Multi-AZ-DB-Cluster verweist. Führen Sie in diesen Fällen die folgenden Schritte aus:
1. Stoppen Sie den gesamten Datenverkehr an den Multi-AZ-DB-Cluster. Sie können den Datenverkehr umleiten, sodass er nicht auf die Datenbanken des Multi-AZ-DB-Clusters zugreift, oder eine andere Methode auswählen, um zu verhindern, dass Datenverkehr auf Ihre Datenbanken auf dem Multi-AZ-DB-Cluster zugreift.
1. Benennen Sie den bestehenden Multi-AZ-DB-Cluster um.
1. Erstellen Sie einen neuen Multi-AZ-DB-Cluster, indem Sie die Wiederherstellung aus einem DB-Cluster-Snapshot oder eine zeitpunktbezogene Wiederherstellung durchführen. Geben Sie dann dem neuen Multi-AZ-DB-Cluster den Namen des vorherigen Multi-AZ-DB-Clusters.
Wenn Sie den alten Multi-AZ-DB-Cluster löschen, sind Sie für die Löschung aller nicht benötigten DB-Cluster-Snapshots des alten Multi-AZ-DB-Clusters verantwortlich.
## Konsole
**So benennen Sie einen Multi-AZ-DB-Cluster um**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** aus.
1. Wählen Sie den Multi-AZ-DB-Cluster aus, den Sie umbenennen möchten.
1. Wählen Sie **Ändern** aus.
1. Geben Sie unter **Settings** (Einstellungen) einen neuen Namen für **DB cluster identifier** (DB-Cluster-ID) ein.
1. Klicken Sie auf **Weiter**.
1. Wählen Sie **Apply immediately**, um die Änderungen sofort anzuwenden. Die Auswahl dieser Option kann in einigen Fällen einen Ausfall verursachen. Weitere Informationen finden Sie unter [Änderungen sofort anwenden](modify-multi-az-db-cluster.md#modify-multi-az-db-cluster-apply-immediately).
1. Überprüfen Sie auf der Bestätigungsseite Ihre Änderungen. Wenn sie korrekt sind, wählen Sie **Modify cluster (Cluster ändern)** aus, um Ihre Änderungen zu speichern.
Klicken Sie anderenfalls auf **Back** (Zurück), um Ihre Änderungen zu bearbeiten, oder wählen Sie **Cancel** (Abbrechen) aus, um Ihre Änderungen zu verwerfen.
## AWS CLI
Verwenden Sie den AWS CLI-Befehl [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html), um einen Multi-AZ-DB-Cluster umzubenennen. Geben Sie für den aktuellen `--db-cluster-identifier`-Wert und den `--new-db-cluster-identifier`-Parameter den neuen Namen des Multi-AZ-DB-Clusters an.
**Example**
Für Linux, macOS oder Unix:
```
1. aws rds modify-db-cluster \
2. --db-cluster-identifier DBClusterIdentifier \
3. --new-db-cluster-identifier NewDBClusterIdentifier
```
Für Windows:
```
1. aws rds modify-db-cluster ^
2. --db-cluster-identifier DBClusterIdentifier ^
3. --new-db-cluster-identifier NewDBClusterIdentifier
```
## RDS-API
Zum Umbenennen eines Multi-AZ-DB-Clusters rufen Sie die API-Operation [ModifyDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) von Amazon RDS mit den folgenden Parametern auf:
+ `DBClusterIdentifier` – der bestehende Name des DB-Clusters.
+ `NewDBClusterIdentifier` – der neue Name des DB-Clusters.
# Neustarten von Multi-AZ-DB-Clustern und Reader-DB-Instances für Amazon RDS
Möglicherweise müssen Sie Ihren Multi-AZ-DB-Cluster neu starten, normalerweise aus Wartungsgründen. Wenn Sie beispielsweise bestimmte Änderungen vornehmen oder die einer DB-Cluster zugeordnete DB-Cluster-Parametergruppe ändern, starten Sie den DB-Cluster neu. Dies führt dazu, dass die Änderungen wirksam werden.
Wenn ein DB-Cluster nicht die neuesten Änderungen an seiner zugehörigen DB-Cluster-Parametergruppe verwendet, AWS-Managementkonsole zeigt das die DB-Cluster-Parametergruppe mit dem Status **Pending-reboot** an. Die Parametergruppe **pending-reboot** führt während des nächsten Wartungsfensters nicht zu einem automatischen Neustart. Um die neuesten Parameteränderungen auf diesen DB-Cluster anzuwenden, starten Sie den DB-Cluster manuell neu. Weitere Informationen zu Parametergruppen finden Sie unter [Parametergruppen für Multi-AZ-DB-Cluster](multi-az-db-clusters-concepts.md#multi-az-db-clusters-concepts-parameter-groups).
Durch das Neustarten eines DB-Clusters, wird der Datenbank-Engine-Service neu gestartet. Der Neustart eines DB-Clusters führt zu einem vorübergehenden Ausfall, während dessen der DB-Cluster-Status auf **Neustart** gesetzt wird.
Sie können Ihren DB-Cluster nicht neu starten, wenn er sich nicht im Status **Verfügbar** befindet. Ihre Datenbank kann aus mehreren Gründen nicht verfügbar sein. Zum Beispiel ein laufender Sicherungsvorgang oder eine zuvor von Kunden angefragte Änderung oder eine Aktion im Wartungsfenster.
Die für den Neustart Ihres DB-Clusters erforderliche Zeit hängt vom Wiederherstellungsprozess nach einem Systemabsturz, der Datenbankaktivität zum Zeitpunkt des Neustarts und dem Verhalten Ihres spezifischen DB-Clusters ab. Wir empfehlen, während eines Neustarts die Datenbankaktivitäten möglichst zu minimieren, um die Dauer des Neustarts zu verkürzen. Die Reduzierung der Datenbankaktivität reduziert die Rollback-Aktivität für übertragene Transaktionen.
**Wichtig**
Multi-AZ-DB-Cluster unterstützen keinen Neustart mit einem Failover. Wenn Sie die Writer-Instance eines Multi-AZ-DB-Clusters neu starten, wirkt sich dies nicht auf die Reader-DB-Instances in diesem DB-Cluster aus und es tritt kein Failover auf. Wenn Sie eine Reader-DB-Instance neu starten, erfolgt kein Failover. Um ein Failover für einen Multi-AZ-DB-Cluster durchzuführen, wählen Sie in der Konsole **Failover** aus, rufen Sie den AWS CLI Befehl auf oder rufen Sie den [https://docs.aws.amazon.com/cli/latest/reference/rds/failover-db-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/rds/failover-db-cluster.html)API-Vorgang auf. [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_FailoverDBCluster.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_FailoverDBCluster.html)
## Konsole
**So starten Sie einen DB-Cluster neu**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Datenbanken** und dann den Multi-AZ-DB-Cluster aus, den Sie neu starten möchten.
1. Wählen Sie unter **Aktionen** die Option **Neustart** aus.
Die Seite **Reboot DB cluster** (DB-Cluster neu starten) wird angezeigt.
1. Wählen Sie **Neustart**, um Ihren DB-Cluster neu zu starten.
Oder klicken Sie auf **Abbrechen**.
## AWS CLI
Rufen Sie den [reboot-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/reboot-db-cluster.html)Befehl auf, um einen Multi-AZ-DB-Cluster mithilfe von neu zu starten. AWS CLI
```
aws rds reboot-db-cluster --db-cluster-identifier mymultiazdbcluster
```
## RDS-API
Um einen Multi-AZ-DB-Cluster mithilfe der Amazon RDS-API neu zu starten, rufen Sie den DBCluster Vorgang [Reboot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RebootDBCluster.html) auf.
# Failover eines Multi-AZ-DB-Clusters für Amazon RDS
Wenn es einen geplanten oder ungeplanten Ausfall Ihrer Writer-DB-Instance in einem Multi-AZ-DB-Cluster gibt, führt Amazon RDS automatisch ein Failover auf eine Reader-DB-Instance in einer anderen Availability Zone durch. Hierdurch wird eine hohe Verfügbarkeit mit minimaler Unterbrechung gewährleistet. Failovers können bei Hardwarefehlern, Netzwerkproblemen oder manuellen Anfragen auftreten. In diesem Thema werden die automatische Erkennung von Fehlern, die Reihenfolge der Ereignisse während eines Failovers und deren Auswirkungen auf Lese- und Schreibvorgänge beschrieben. Außerdem werden bewährte Methoden zur Überwachung und Minimierung von Failover-Zeiten erläutert.
Die Zeit bis zum Abschluss des Failovers hängt von der Datenbankaktivität und anderen Bedingungen ab, wenn die Writer-DB-Instance nicht verfügbar war. Der Failover-Prozess dauert normalerweise unter 35 Sekunden. Das Failover wird abgeschlossen, wenn beide Reader-DB-Instances ausstehende Transaktionen vom fehlgeschlagenen Schreiber angewendet haben. Wenn der eigentliche Failover-Prozess abgeschlossen ist, kann es noch einmal etwas dauern, bis die RDS-Konsole die Daten für die neue Availability Zone geladen hat.
**Topics**
+ [Automatische Failover](#multi-az-db-clusters-concepts-failover-automatic)
+ [Manuelles Versagen über einen Multi-AZ-DB-Cluster](#multi-az-db-clusters-concepts-failover-manual)
+ [Ermitteln, ob ein Multi-AZ-DB-Cluster ausgefallen ist](#multi-az-db-clusters-concepts-failover-determining)
+ [Festlegen des JVM-TTL-Werts für DNS-Name-Lookups](#multi-az-db-clusters-concepts-failover-java-dns)
## Automatische Failover
Amazon RDS führt den Failover-Prozess automatisch durch, sodass der Datenbankbetrieb so schnell wie möglich und ohne Verwaltungseingriff wieder aufgenommen werden kann. Zum Ausfall wechselt die Writer-DB-Instance automatisch zu einer Reader-DB-Instance.
## Manuelles Versagen über einen Multi-AZ-DB-Cluster
Wenn Sie für einen Multi-AZ-DB-Cluster einen manuellen Failover erstellen, beendet RDS zunächst die primäre DB-Instance. Anschließend erkennt das interne Überwachungssystem, dass die primäre DB-Instance fehlerhaft ist, und stuft eine lesbare Replikat-DB-Instance hoch. Der Failover-Prozess dauert normalerweise unter 35 Sekunden.
Sie können für einen Multi-AZ-DB-Cluster manuell mit der AWS-Managementkonsole, AWS CLI oder RDS-API einen Failover erstellen.
### Konsole
**Manuelles Ausfallen eines Multi-AZ-DB-Clusters**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** aus.
1. Wählen Sie den Multi-AZ-DB-Cluster aus, den Sie ausfallen möchten.
1. Wählen Sie für **Aktionen** die Option **Failover** aus.
Die Seite **Failover-DB-Cluster** wird angezeigt.
1. Wählen Sie **Failover**, um das manuelle Failover zu bestätigen.
### AWS CLI
Verwenden Sie zum manuellen Failover eines Multi-AZ-DB-Clusters den AWS CLI-Befehl [ failover-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/failover-db-cluster.html).
**Example**
```
1. aws rds failover-db-cluster --db-cluster-identifier mymultiazdbcluster
```
### RDS-API
Um ein manuelles Failover eines Multi-AZ-DB-Clusters durchzuführen, rufen Sie die Amazon-RDS-API [FailoverDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_FailoverDBCluster.html) auf und geben Sie die `DBClusterIdentifier` an.
## Ermitteln, ob ein Multi-AZ-DB-Cluster ausgefallen ist
Um festzustellen, ob Ihr Multi-AZ-DB-Cluster erfolgreich ausgeführt wurde, können Sie Folgendes tun:
+ Sie können Benachrichtigungen per E-Mail oder per SMS für DB-Ereignisse abonnieren, bei denen ein Failover ausgelöst wird. Weitere Informationen über -Ereignisse finden Sie unter [Arbeiten mit Amazon-RDS-Ereignisbenachrichtigungen](USER_Events.md).
+ Sie können Ihre DB-Ereignisse über die Amazon-RDS-Konsole oder mittels API-Operationen anzeigen.
+ Zeigen Sie den aktuellen Status Ihres Multi-AZ-DB-Clusters an, indem Sie die Amazon-RDS-Konsole, die AWS CLI und die RDS-API verwenden.
Informationen zur empfohlenen Vorgehensweise bei Failover-Situationen, zur Verringerung der Wiederherstellungsdauer und zu bewährten Methoden für Amazon RDS finden Sie unter [Bewährte Methoden für Amazon RDS](CHAP_BestPractices.md).
## Festlegen des JVM-TTL-Werts für DNS-Name-Lookups
Bei dem Failover-Prozess wird der DNS-Datensatz (Domain Name System) der DB-Instance so geändert, dass er auf die Reader-DB-Instance verweist. Als Ergebnis müssen alle bestehenden Verbindungen zu Ihrer DB-Instance neu hergestellt werden. In einer JVM-Umgebung (Java Virtual Machine) müssen Sie aufgrund der besonderen Funktionsweise der Zwischenspeicherung von DNS-Informationen in Java möglicherweise die JVM-Einstellungen rekonfigurieren.
Die JVM speichert DNS-Name-Lookups zwischen. Wenn die JVM einen Hostnamen zu einer IP-Adresse auflöst, speichert sie die IP-Adresse für einen bestimmten Zeitraum zwischen. Diese Zeit ist als *Time-to-Live* (TTL, Lebensdauer) bekannt.
Da AWS-Ressourcen DNS-Namenseinträge nutzen, die sich gelegentlich ändern, empfehlen wir, dass Sie Ihre JVM mit einem TTL-Wert von maximal 60 Sekunden konfigurieren. Auf diese Weise wird bei Änderung der IP-Adresse einer Ressource sichergestellt, dass Ihre Anwendung die neue IP-Adresse der Ressource durch erneute Abfrage des DNS abrufen und nutzen kann.
Bei einigen Java-Konfigurationen ist die JVM-Standard-TTL so festgelegt, dass DNS-Einträge nie aktualisiert werden, bis die JVM neu gestartet wird. Ändert sich die IP-Adresse einer AWS-Ressource also, während Ihre Anwendung läuft, kann die Anwendung die Ressource erst wieder nutzen, nachdem Sie die JVM manuell neu starten und die zwischengespeicherten IP-Informationen aktualisiert wurden. In diesem Fall ist es wichtig, die TTL der JVM so einzustellen, dass sie die zwischengespeicherten IP-Daten von Zeit zu Zeit aktualisiert.
**Anmerkung**
Die Standard-TTL kann je nach Version Ihrer JVM und abhängig davon, ob ein Sicherheits-Manager installiert ist, unterschiedlich sein. Viele JVMs bieten eine Standard-TTL von weniger als 60 Sekunden. Wenn Sie eine solche JVM und keinen Sicherheits-Manager nutzen, können Sie den Rest dieses Themas ignorieren. Weitere Informationen zu Sicherheits-Managern in Oracle finden Sie unter [The Security Manager](https://docs.oracle.com/javase/tutorial/essential/environment/security.html) in der Oracle-Dokumentation.
Um die TTL der JVM zu ändern, legen Sie den Eigenschaftswert [https://docs.oracle.com/javase/7/docs/technotes/guides/net/properties.html](https://docs.oracle.com/javase/7/docs/technotes/guides/net/properties.html) fest. Nutzen Sie dazu eine der folgenden Methoden je nach Ihrem Bedarf:
+ Legen Sie in der `networkaddress.cache.ttl`-Datei `$JAVA_HOME/jre/lib/security/java.security` fest, um den Eigenschaftswert global für alle Anwendungen festzulegen, die die JVM verwenden.
```
networkaddress.cache.ttl=60
```
+ Um die Eigenschaft nur für Ihre Anwendung lokal festzulegen, legen Sie `networkaddress.cache.ttl` im Initialisierungscode Ihrer Anwendung fest, bevor Netzwerkverbindungen hergestellt werden.
```
java.security.Security.setProperty("networkaddress.cache.ttl" , "60");
```
# Einrichten der logischen PostgreSQL-Replikation mit DB-Clustern mit Multi-AZ für Amazon RDS
Durch die Verwendung der logischen PostgreSQL-Replikation mit Ihrem Multi-AZ-DB-Cluster können Sie einzelne Tabellen anstelle der gesamten Datenbank-Instance replizieren und synchronisieren. Für die logische Replikation wird ein Veröffentlichungs- und Abonnementmodell verwendet, um Änderungen aus einer Quelle an einen oder mehrere Empfänger zu replizieren. Dazu werden Änderungsdatensätze aus dem Write-Ahead-Protokoll (WAL) von PostgreSQL verwendet. Weitere Informationen finden Sie unter [Ausführen der logischen Replikation für Amazon RDS für PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.LogicalReplication.md).
Wenn Sie einen neuen Slot für die logische Replikation auf der Writer-DB-Instance eines Multi-AZ-DB-Clusters erstellen, wird der Slot asynchron in jede Reader-DB-Instance im Cluster kopiert. Die Slots auf den Reader-DB-Instances werden kontinuierlich mit den Slots auf der Writer-DB-Instance synchronisiert.
Die logische Replikation wird für Multi-AZ-DB-Cluster unterstützt, auf denen RDS für PostgreSQL Version 14.8-R2 und höher sowie 15.3-R2 und höher ausgeführt wird.
**Anmerkung**
Zusätzlich zu der nativen logischen Replikationsfunktion von PostgreSQL unterstützen Multi-AZ-DB-Cluster, auf denen RDS für PostgreSQL ausgeführt wird, auch die `pglogical`-Erweiterung.
Weitere Informationen über die logische Replikation in PostgreSQL finden Sie unter [Logische Replikation](https://www.postgresql.org/docs/current/logical-replication.html) in der PostgreSQL-Dokumentation.
**Topics**
+ [Voraussetzungen](#multi-az-db-clusters-logical-replication-prereqs)
+ [Einrichten der logischen Replikation](#multi-az-db-clusters-logical-replication)
+ [Einschränkungen und Empfehlungen](#multi-az-db-clusters-logical-replication-limitations)
## Voraussetzungen
Um die logische Replikation von PostgreSQL für Multi-AZ-DB-Cluster zu konfigurieren, müssen Sie die folgenden Voraussetzungen erfüllen.
+ Ihr Benutzerkonto muss Mitglied der `rds_superuser`-Gruppe sein und über `rds_superuser`-Rechte verfügen. Weitere Informationen finden Sie unter [Grundlegendes zu PostgreSQL-Rollen und -Berechtigungen](Appendix.PostgreSQL.CommonDBATasks.Roles.md).
+ Ihr Multi-AZ-DB-Cluster muss einer benutzerdefinierten DB-Cluster-Parametergruppe zugeordnet sein, damit Sie die im folgenden Verfahren beschriebenen Parameterwerte konfigurieren können. Weitere Informationen finden Sie unter [Arbeiten mit DB-Cluster-Parametergruppen für Multi-AZ-DB-Cluster](USER_WorkingWithDBClusterParamGroups.md).
## Einrichten der logischen Replikation
Um eine logische Replikation für einen Multi-AZ-DB-Cluster einzurichten, aktivieren Sie bestimmte Parameter innerhalb der zugehörigen DB-Cluster-Parametergruppe und erstellen dann Slots für die logische Replikation.
**Anmerkung**
Ab PostgreSQL-Version 16 können Sie Reader-DB-Instances des DB-Clusters mit Multi-AZ für die logische Replikation verwenden.
**So richten Sie eine logische Replikation für einen Multi-AZ-DB-Cluster von RDS für PostgreSQL ein**
1. Öffnen Sie die benutzerdefinierte DB-Cluster-Parametergruppe, die Ihrem Multi-AZ-DB-Cluster von RDS für PostgreSQL zugeordnet ist.
1. Suchen Sie im Suchfeld **Parameter** nach dem statischen Parameter `rds.logical_replication` und legen Sie als Wert für den Parameter `1` fest. Diese Parameteränderung kann zu einer verstärkten WAL-Generierung führen. Aktivieren Sie sie daher nur, wenn Sie logische Slots verwenden.
1. Konfigurieren Sie im Rahmen dieser Änderung die folgenden DB-Cluster-Parameter.
+ `max_wal_senders`
+ `max_replication_slots`
+ `max_connections`
Abhängig von Ihrer erwarteten Auslastung müssen Sie möglicherweise auch die Werte der folgenden Parameter ändern. In vielen Fällen sind die Standardwerte jedoch ausreichend.
+ `max_logical_replication_workers`
+ `max_sync_workers_per_subscription`
1. Starten Sie den Multi-AZ-DB-Cluster neu, damit die Parameterwerte wirksam werden. Detaillierte Anweisungen finden Sie unter [Neustarten von Multi-AZ-DB-Clustern und Reader-DB-Instances für Amazon RDS](multi-az-db-clusters-concepts-rebooting.md).
1. Erstellen Sie einen Slot für die logische Replikation auf der Writer-DB-Instance des Multi-AZ-DB-Clusters, wie unter [Arbeiten mit logischen Replikations-Slots](PostgreSQL.Concepts.General.FeatureSupport.LogicalReplication.md#PostgreSQL.Concepts.General.FeatureSupport.LogicalReplicationSlots) beschrieben. Für diesen Prozess ist es erforderlich, dass Sie ein Decodier-Plugin angeben. Derzeit unterstützt RDS für PostgreSQL die `test_decoding`-, `wal2json`- und `pgoutput`-Plugins, die mit PostgreSQL geliefert werden.
Der Slot wird asynchron in jede Reader-DB-Instance im Cluster kopiert.
1. Überprüfen Sie den Status des Slots auf allen Reader-DB-Instances des Multi-AZ-DB-Clusters. Überprüfen Sie hierfür die Ansicht `pg_replication_slots` auf allen Reader-DB-Instances und stellen Sie sicher, dass der `confirmed_flush_lsn`-Status voranschreitet, während die Anwendung aktiv logische Änderungen verarbeitet.
Die folgenden Befehle veranschaulichen, wie der Replikationsstatus auf den Reader-DB-Instances überprüft werden kann.
```
% psql -h test-postgres-instance-2.abcdefabcdef.us-west-2.rds.amazonaws.com
postgres=> select slot_name, slot_type, confirmed_flush_lsn from pg_replication_slots;
slot_name | slot_type | confirmed_flush_lsn
--------------+-----------+---------------------
logical_slot | logical | 32/D0001700
(1 row)
postgres=> select slot_name, slot_type, confirmed_flush_lsn from pg_replication_slots;
slot_name | slot_type | confirmed_flush_lsn
--------------+-----------+---------------------
logical_slot | logical | 32/D8003628
(1 row)
% psql -h test-postgres-instance-3.abcdefabcdef.us-west-2.rds.amazonaws.com
postgres=> select slot_name, slot_type, confirmed_flush_lsn from pg_replication_slots;
slot_name | slot_type | confirmed_flush_lsn
--------------+-----------+---------------------
logical_slot | logical | 32/D0001700
(1 row)
postgres=> select slot_name, slot_type, confirmed_flush_lsn from pg_replication_slots;
slot_name | slot_type | confirmed_flush_lsn
--------------+-----------+---------------------
logical_slot | logical | 32/D8003628
(1 row)
```
Beenden Sie nach Abschluss Ihrer Replikationsaufgaben den Replikationsprozess, löschen Sie die Replikationsslots und deaktivieren Sie die logische Replikation. Um die logische Replikation zu deaktivieren, ändern Sie Ihre DB-Cluster-Parametergruppe und setzen Sie den Wert von `rds.logical_replication` auf `0` zurück. Starten Sie den Cluster neu, damit die Parameteränderung in Kraft tritt.
## Einschränkungen und Empfehlungen
Die folgenden Einschränkungen und Empfehlungen gelten für die Verwendung der logischen Replikation mit DB-Clustern mit Multi-AZ, auf denen PostgreSQL-Version 16 ausgeführt wird:
+ Sie können nur Writer-DB-Instances verwenden, um logische Replikationsslots zu erstellen oder zu löschen. Beispielsweise muss der Befehl `CREATE SUBSCRIPTION` den Cluster-Writer-Endpunkt in der Host-Verbindungszeichenfolge verwenden.
+ Sie müssen den Cluster-Writer-Endpunkt bei jeder Tabellensynchronisation oder erneuten Synchronisierung verwenden. Beispielsweise können Sie die folgenden Befehle verwenden, um eine neu hinzugefügte Tabelle erneut zu synchronisieren:
```
Postgres=>ALTER SUBSCRIPTION subscription-name CONNECTION host=writer-endpoint
Postgres=>ALTER SUBSCRIPTION subscription-name REFRESH PUBLICATION
```
+ Sie müssen warten, bis die Tabellensynchronisation abgeschlossen ist, bevor Sie die Reader-DB-Instances für die logische Replikation verwenden können. Sie können die Katalogtabelle `[pg\$1subscription\$1rel](https://www.postgresql.org/docs/current/catalog-pg-subscription-rel.html)` verwenden, um die Tabellensynchronisation zu überwachen. Die Tabellensynchronisation ist abgeschlossen, wenn die Spalte `srsubstate` auf „bereit“ (`r`) gesetzt ist.
+ Es wird empfohlen, Instance-Endpunkte für die logische Replikationsverbindung zu verwenden, sobald die erste Tabellensynchronisation abgeschlossen ist. Der folgende Befehl reduziert die Belastung der Writer-DB-Instance, indem die Replikation auf eine der Reader-DB-Instances verlagert:
```
Postgres=>ALTER SUBSCRIPTION subscription-name CONNECTION host=reader-instance-endpoint
```
Sie können denselben Slot für mehr als eine DB-Instance gleichzeitig verwenden. Wenn zwei oder mehr Anwendungen logische Änderungen von verschiedenen DB-Instances im Cluster replizieren, können einige Änderungen aufgrund eines Cluster-Failovers oder eines Netzwerkproblems verloren gehen. In diesen Situationen können Sie Instance-Endpunkte für die logische Replikation in der Host-Verbindungszeichenfolge verwenden. Die andere Anwendung, die dieselbe Konfiguration verwendet, zeigt die folgende Fehlermeldung an:
```
replication slot slot_name is already active for PID x providing immediate feedback.
```
+ Wenn Sie die `pglogical`-Erweiterung verwenden, können Sie nur den Cluster-Writer-Endpunkt verwenden. Die Erweiterung hat bekannte Einschränkungen, die dazu führen können, dass bei der Tabellensynchronisation ungenutzte logische Replikationsslots entstehen. Veraltete Replikationsslots reservieren Write-Ahead-Protokolldateien (WAL) und können zu Speicherplatzproblemen führen.
# Arbeiten mit Lesereplikaten von DB-Clustern mit Multi-AZ für Amazon RDS
Ein DB-Cluster-Lesereplikat ist eine spezielle Art von Cluster, den Sie aus einer Quell-DB-Instance erstellen. Nachdem Sie ein Lesereplikat erstellt haben, werden in der primären DB-Instance ausgeführte Aktualisierungen asynchron in das Lesereplikat des Multi-AZ-DB-Clusters kopiert. Sie können die Arbeitslast für Ihre primären DB-Instance reduzieren, indem Sie Leseabfragen aus Ihren Anwendungen an das Lesereplikat weiterleiten. Mit Lesereplikaten können Sie die Kapazitätseinschränkungen einer einzelnen DB-Instance für leseintensive Datenbank-Workloads elastisch erweitern.
Sie können auch ein oder mehrere DB-Instance-Lesereplikate aus einem Multi-AZ-DB-Cluster erstellen. Mit DB-Instance-Lesereplikaten können Sie über die Rechen- oder I/O-Kapazität des Multi-AZ-DB-Quell-Clusters hinaus skalieren, indem Sie überschüssigen Leseverkehr an die Lesereplikate weiterleiten. Derzeit können Sie kein Lesereplikat eines Multi-AZ-DB-Clusters aus einem vorhandenen Multi-AZ-DB-Cluster erstellen.
Berücksichtigen Sie Ihren spezifischen Anwendungsfall und Ihre Leistungsanforderungen, wenn Sie entscheiden, ob Sie mithilfe eines Lesereplikats zu einem DB-Cluster mit Multi-AZ migrieren oder ein Lesereplikat einer DB-Instance aus einem DB-Cluster mit Multi-AZ erstellen möchten.
**Migrieren zu einem Multi-AZ-DB-Cluster mithilfe eines Lesereplikats**
Dieser Ansatz ist ideal, wenn Sie die Verfügbarkeit und Haltbarkeit Ihrer Datenbank verbessern und gleichzeitig Ausfallzeiten minimieren möchten. Wenn Sie ein Lesereplikat für die Migration zu einem DB-Cluster mit Multi-AZ verwenden, können Sie einen kontinuierlichen Betrieb und Datenkonsistenz sicherstellen. Diese Methode eignet sich besonders für Produktionsumgebungen, in denen die Aufrechterhaltung der Verfügbarkeit und die Reduzierung der Auswirkungen auf Live-Workloads von entscheidender Bedeutung sind.
**Erstellen eines DB-Instance-Lesereplikats aus einem Multi-AZ-DB-Cluster**
Diese Methode eignet sich, wenn Sie Lesevorgänge skalieren oder den Lesedatenverkehr von Ihrer primären Datenbank-Instance weg verlagern möchten. Indem Sie ein Lesereplikat eines vorhandenen DB-Clusters mit Multi-AZ erstellen, können Sie leseintensive Workloads verteilen und die Leistung verbessern, ohne dass die Stabilität der primären Instance beeinträchtigt wird.
Die Wahl des richtigen Ansatzes hängt davon ab, ob Ihre Priorität darin besteht, eine hohe Verfügbarkeit und Haltbarkeit sicherzustellen oder die Leseleistung zu skalieren. Bewerten Sie Ihre Workload-Merkmale und betrieblichen Anforderungen, um eine fundierte Entscheidung zu treffen.
**Topics**
+ [Migrieren zu einem Multi-AZ-DB-Cluster mithilfe eines Lesereplikats](multi-az-db-clusters-migrating-to-with-read-replica.md)
+ [Erstellen eines DB-Instance-Lesereplikats aus einem Multi-AZ-DB-Cluster](multi-az-db-clusters-create-instance-read-replica.md)
# Migrieren zu einem Multi-AZ-DB-Cluster mithilfe eines Lesereplikats
Wenn Sie eine Single-AZ-Bereitstellung oder Multi-AZ-Bereitstellung einer DB-Instance zu einer Multi-AZ-Bereitstellung eines DB-Clusters mit reduzierter Ausfallzeit migrieren möchten, können Sie ein Lesereplikat des Multi-AZ-DB-Clusters erstellen. Für die Quelle geben Sie die DB-Instance in der Single-AZ-Bereitstellung oder die primäre DB-Instance in der Multi-AZ-Bereitstellung der DB-Instance an. Die DB-Instance kann während der Migration zu einem Multi-AZ-DB-Cluster Schreibtransaktionen verarbeiten.
Beachten Sie die folgenden Überlegungen, bevor Sie ein Multi-AZ-DB-Cluster-Lesereplikat erstellen:
+ Die Version der Quell-DB-Instance muss Multi-AZ-DB-Cluster unterstützen. Weitere Informationen finden Sie unter [Unterstützte Regionen und DB-Engines für DB-Cluster mit Multi-AZ in Amazon RDS.](Concepts.RDS_Fea_Regions_DB-eng.Feature.MultiAZDBClusters.md).
+ Das Lesereplikat des Multi-AZ-DB-Clusters muss dieselbe Hauptversion wie seine Quelle und dieselbe oder eine höhere Nebenversion haben.
+ Sie müssen automatische Backups für die Quell-DB-Instance aktivieren, indem Sie den Aufbewahrungszeitraum für Backups auf einen anderen Wert als 0 festlegen.
+ Der zugewiesene Speicher der Quell-DB-Instance muss 100 GiB oder mehr betragen.
+ Für RDS für MySQL müssen die Parameter `gtid-mode` und `enforce_gtid_consistency` beide auf `ON` für die Quell-DB-Instance festgelegt sein. Sie müssen eine benutzerdefinierte Parametergruppe und keine Standardparametergruppe verwenden. Weitere Informationen finden Sie unter [DB-Parametergruppen für DB-Instances von Amazon RDS](USER_WorkingWithDBInstanceParamGroups.md).
+ Eine aktive, langlaufende Transaktion kann den Prozess der Erstellung des Lesereplikats verlangsamen. Wir empfehlen Ihnen zu warten, bis langlaufende Transaktionen abgeschlossen sind, bevor ein Lesereplikat erstellt wird.
+ Wenn Sie die Quell-DB-Instance für das Lesereplikat eines Multi-AZ-DB-Clusters löschen, wird das Lesereplikat zu einem eigenständigen Multi-AZ-DB-Cluster hochgestuft.
## Erstellen und Hochstufen des Lesereplikats eines Multi-AZ-DB-Clusters
Sie können das Lesereplikat eines Multi-AZ-DB-Clusters mit der AWS-Managementkonsole, der AWS CLI oder der RDS-API erstellen und hochstufen.
**Anmerkung**
Wir empfehlen dringend, alle Lesereplikate in derselben Virtual Private Cloud (VPC) basierend auf Amazon VPC als Quell-DB-Instance zu erstellen.
Wenn Sie ein Lesereplikat in einer anderen VPC als der Quell-DB-Instance erstellen, können CIDR-Bereiche (Classless Inter-Domain Routing) zwischen dem Replikat und dem Amazon-RDS-System einander überlappen. Die CIDR-Überlappung macht das Replikat instabil, was sich negativ auf Anwendungen auswirken kann, die eine Verbindung herstellen. Wenn beim Erstellen des Lesereplikats eine Fehlermeldung angezeigt wird, wählen Sie eine andere Ziel-DB-Subnetzgruppe aus. Weitere Informationen finden Sie unter [Arbeiten mit einer DB-Instance in einer VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md).
### Konsole
Führen Sie die folgenden Schritte unter Verwendung der AWS-Managementkonsole aus, um eine Single-AZ-Bereitstellung oder Multi-AZ-Bereitstellung einer DB-Instance mithilfe eines Lesereplikats zu einem Multi-AZ-DB-Cluster zu migrieren.
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Erstellen Sie das Lesereplikat des Multi-AZ-DB-Clusters.
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** aus.
1. Wählen Sie die DB-Instance aus, die Sie als Quelle für eine Read Replica verwenden möchten.
1. Wählen Sie unter **Aktionen** **Create read replica (Read Replica erstellen)** aus.
1. Wählen Sie unter **Availability and durability** (Verfügbarkeit und Beständigkeit) die Option **Multi-AZ DB cluster** (Multi-AZ-DB-Cluster) aus.
1. Geben Sie unter **DB instance identifier (DB-Instance-Kennung)** einen Namen für das Lesereplikat ein.
1. In den übrigen Abschnitten geben Sie die Einstellungen für Ihren DB-Cluster an. Weitere Informationen zu einer Einstellung finden Sie unter [Einstellungen zum Erstellen von Multi-AZ-DB-Clustern](create-multi-az-db-cluster.md#create-multi-az-db-cluster-settings).
1. Wählen Sie **Read Replica erstellen** aus.
1. Wenn Sie bereit sind, stufen Sie das Lesereplikat zu einem eigenständigen Multi-AZ-DB-Cluster hoch:
1. Halten Sie alle Transaktionen in die Quell-DB-Instance an und warten Sie anschließend, bis alle Updates für das Lesereplikat abgeschlossen wurden.
Datenbank-Updates werden im Lesereplikat durchgeführt, nachdem sie in der primären DB-Instance vorgenommen wurden. Diese Replikationsverzögerung kann erheblich variieren. Verwenden Sie die Metrik `ReplicaLag`, um zu bestimmen, wann alle Aktualisierungen am Lesereplikat vorgenommen wurden. Weitere Informationen zur Replikationsverzögerung finden Sie unter [Überwachen der Lesereplikation](USER_ReadRepl.Monitoring.md).
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie in der Amazon-RDS-Konsole **Databases (Datenbanken)** aus.
Der Bereich **Databases (Datenbanken)** wird angezeigt. Jedes Lesereplikat zeigt **Replica (Replikat)** in der Spalte **Role (Rolle)** an.
1. Wählen Sie das Lesereplikat des Multi-AZ-DB-Clusters aus, das Sie hochstufen möchten.
1. Wählen Sie für **Actions (Aktionen)** **Promote (Hochstufen)** aus.
1. Geben Sie auf der Seite **Promote read replica** (Lesereplikat hochstufen) den Aufbewahrungszeitraum und das Backup-Fenster für den neu hochgestuften DB-Cluster an.
1. Wenn die Einstellungen Ihren Wünschen entsprechen, wählen Sie **Promote read replica** (Lesereplikat hochstufen) aus.
1. Warten Sie, bis der Status des hochgestuften Multi-AZ-DB-Clusters `Available` lautet.
1. Weisen Sie Ihre Anwendungen an, den hochgestuften Multi-AZ-DB-Cluster zu verwenden.
Löschen Sie optional die Single-AZ-Bereitstellung oder die Multi-AZ-Bereitstellung der DB-Instance, wenn sie nicht mehr benötigt wird. Detaillierte Anweisungen finden Sie unter [Löschen einer DB-Instance](USER_DeleteInstance.md).
### AWS CLI
Führen Sie die folgenden Schritte unter Verwendung der AWS CLI aus, um eine Single-AZ-Bereitstellung oder Multi-AZ-Bereitstellung einer DB-Instance mithilfe eines Lesereplikats zu einem Multi-AZ-DB-Cluster zu migrieren.
1. Erstellen Sie das Lesereplikat des Multi-AZ-DB-Clusters.
Verwenden Sie den AWS CLI-Befehl [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html), um ein Lesereplikat aus einer Quell-DB-Instance zu erstellen. Geben Sie für `--replication-source-identifier` den Amazon-Ressourcennamen (ARN) der Quell-DB-Instance an.
Für Linux, macOS oder Unix:
```
aws rds create-db-cluster \
--db-cluster-identifier mymultiazdbcluster \
--replication-source-identifier arn:aws:rds:us-east-2:123456789012:db:mydbinstance
--engine postgres \
--db-cluster-instance-class db.m5d.large \
--storage-type io1 \
--iops 1000 \
--db-subnet-group-name defaultvpc \
--backup-retention-period 1
```
Für Windows:
```
aws rds create-db-cluster ^
--db-cluster-identifier mymultiazdbcluster ^
--replication-source-identifier arn:aws:rds:us-east-2:123456789012:db:mydbinstance
--engine postgres ^
--db-cluster-instance-class db.m5d.large ^
--storage-type io1 ^
--iops 1000 ^
--db-subnet-group-name defaultvpc ^
--backup-retention-period 1
```
1. Halten Sie alle Transaktionen in die Quell-DB-Instance an und warten Sie anschließend, bis alle Updates für das Lesereplikat abgeschlossen wurden.
Datenbank-Updates werden im Lesereplikat durchgeführt, nachdem sie in der primären DB-Instance vorgenommen wurden. Diese Replikationsverzögerung kann erheblich variieren. Verwenden Sie die Metrik `Replica Lag`, um zu bestimmen, wann alle Aktualisierungen am Lesereplikat vorgenommen wurden. Weitere Informationen zur Replikationsverzögerung finden Sie unter [Überwachen der Lesereplikation](USER_ReadRepl.Monitoring.md).
1. Wenn Sie bereit sind, stufen Sie das Lesereplikat zu einem eigenständigen Multi-AZ-DB-Cluster hoch.
Verwenden Sie den AWS CLI-Befehl [https://docs.aws.amazon.com/cli/latest/reference/rds/promote-read-replica-db-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/rds/promote-read-replica-db-cluster.html), um ein Lesereplikat eines Multi-AZ-DB-Clusters hochzustufen. Geben Sie für `--db-cluster-identifier` die ID des Lesereplikats des Multi-AZ-DB-Clusters an.
```
aws rds promote-read-replica-db-cluster --db-cluster-identifier mymultiazdbcluster
```
1. Warten Sie, bis der Status des hochgestuften Multi-AZ-DB-Clusters `Available` lautet.
1. Weisen Sie Ihre Anwendungen an, den hochgestuften Multi-AZ-DB-Cluster zu verwenden.
Löschen Sie optional die Single-AZ-Bereitstellung oder die Multi-AZ-Bereitstellung der DB-Instance, wenn sie nicht mehr benötigt wird. Detaillierte Anweisungen finden Sie unter [Löschen einer DB-Instance](USER_DeleteInstance.md).
### RDS-API
Führen Sie die folgenden Schritte unter Verwendung der RDS-API aus, um eine Single-AZ-Bereitstellung oder Multi-AZ-Bereitstellung einer DB-Instance mithilfe eines Lesereplikats zu einem Multi-AZ-DB-Cluster zu migrieren.
1. Erstellen Sie das Lesereplikat des Multi-AZ-DB-Clusters.
Verwenden Sie die Operation [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html) mit dem erforderlichen Parameter `DBClusterIdentifier`, um ein Lesereplikat des Multi-AZ-DB-Clusters zu erstellen. Geben Sie für `ReplicationSourceIdentifier` den Amazon-Ressourcennamen (ARN) der Quell-DB-Instance an.
1. Halten Sie alle Transaktionen in die Quell-DB-Instance an und warten Sie anschließend, bis alle Updates für das Lesereplikat abgeschlossen wurden.
Datenbank-Updates werden im Lesereplikat durchgeführt, nachdem sie in der primären DB-Instance vorgenommen wurden. Diese Replikationsverzögerung kann erheblich variieren. Verwenden Sie die Metrik `Replica Lag`, um zu bestimmen, wann alle Aktualisierungen am Lesereplikat vorgenommen wurden. Weitere Informationen zur Replikationsverzögerung finden Sie unter [Überwachen der Lesereplikation](USER_ReadRepl.Monitoring.md).
1. Wenn Sie bereit sind, stufen Sie das Lesereplikat zu einem eigenständigen Multi-AZ-DB-Cluster hoch.
Verwenden Sie die Operation [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_PromoteReadReplicaDBCluster.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_PromoteReadReplicaDBCluster.html) mit dem erforderlichen Parameter `DBClusterIdentifier`, um ein Lesereplikat des Multi-AZ-DB-Clusters hochzustufen. Geben Sie die ID des Lesereplikats des Multi-AZ-DB-Clusters an.
1. Warten Sie, bis der Status des hochgestuften Multi-AZ-DB-Clusters `Available` lautet.
1. Weisen Sie Ihre Anwendungen an, den hochgestuften Multi-AZ-DB-Cluster zu verwenden.
Löschen Sie optional die Single-AZ-Bereitstellung oder die Multi-AZ-Bereitstellung der DB-Instance, wenn sie nicht mehr benötigt wird. Detaillierte Anweisungen finden Sie unter [Löschen einer DB-Instance](USER_DeleteInstance.md).
## Einschränkungen beim Erstellen eines Lesereplikats eines Multi-AZ-DB-Clusters
Die folgenden Einschränkungen gelten für die Erstellung eines Lesereplikats eines Multi-AZ-DB-Clusters aus einer Single-AZ-Bereitstellung oder einer Multi-AZ-Bereitstellung einer DB-Instance.
+ Sie können kein Lesereplikat eines Multi-AZ-DB-Clusters in einem anderen AWS-Konto erstellen als das AWS-Konto, das die Quell-DB-Instance besitzt.
+ Sie können kein Lesereplikat eines Multi-AZ-DB-Clusters in einer von der Quell-DB-Instance abweichenden AWS-Region erstellen.
+ Sie können ein Lesereplikat eines Multi-AZ-DB-Clusters nicht auf einen bestimmten Zeitpunkt wiederherstellen.
+ Die Speicherverschlüsselung muss dieselben Einstellungen für die Quell-DB-Instance und den Multi-AZ-DB-Cluster haben.
+ Wenn die Quell-DB-Instance verschlüsselt ist, muss das Lesereplikat des Multi-AZ-DB-Clusters mit demselben KMS-Schlüssel verschlüsselt werden.
+ Wenn die Quell-DB-Instance Allzweck-SSD-Speicher (gp3) verwendet und weniger als 400 GiB an zugewiesenem Speicherplatz hat, können Sie die bereitgestellten IOPS für das Lesereplikat des Multi-AZ-DB-Clusters nicht ändern.
+ Wenn Sie ein Nebenversions-Upgrade für die Quell-DB-Instance durchführen möchten, müssen Sie das Nebenversions-Upgrade zuerst auf dem Lesereplikat des Multi-AZ-DB-Clusters vornehmen.
+ Wenn Sie ein Nebenversions-Upgrade für ein Lesereplikat des Multi-AZ-DB-Clusters von RDS für PostgreSQL durchführen, wechselt die Reader-DB-Instance nach dem Upgrade nicht zur Writer-DB-Instance. Daher kommt es im DB-Cluster möglicherweise zu Ausfallzeiten, während Amazon RDS die Writer-Instance aktualisiert.
+ Sie können kein Hauptversions-Upgrade für ein Lesereplikat des Multi-AZ-DB-Clusters durchführen.
+ Sie können ein Hauptversions-Upgrade auf der Quell-DB-Instance des Lesereplikats eines Multi-AZ-DB-Clusters durchführen, die Replikation auf das Lesereplikat wird jedoch angehalten und kann nicht neu gestartet werden.
+ Das Lesereplikat des Multi-AZ-DB-Clusters unterstützt keine kaskadierenden Lesereplikate.
+ Bei RDS für PostgreSQL können Lesereplikate eines Multi-AZ-DB-Clusters kein Failover durchführen.
# Erstellen eines DB-Instance-Lesereplikats aus einem Multi-AZ-DB-Cluster
Sie können eine Read Replica einer DB-Instance aus einem Multi-AZ-DB-Cluster erstellen, um bei leseintensiven Datenbank-Workloads die I/O Rechenleistung oder Kapazität des Clusters zu überschreiten. Sie können diesen übermäßigen Datenverkehr an Lesevorgängen einem oder mehreren DB-Instance-Lesereplikaten zuweisen. Sie können auch Lesereplikate verwenden, um von einem Multi-AZ-DB-Cluster zu einer DB-Instance zu migrieren.
Wenn Sie ein Lesereplikat erstellen möchten, geben Sie einen Multi-AZ-DB-Cluster als Replikationsquelle an. Eine der Reader-Instances des Multi-AZ-DB-Clusters ist immer die Quelle der Replikation, nicht die Writer-Instance. Diese Bedingung stellt sicher, dass das Replikat immer mit dem Quell-Cluster synchronisiert ist, auch im Falle eines Failovers.
**Topics**
+ [Vergleichen von Reader-DB-Instances und DB-Instance-Lesereplikaten](#multi-az-db-clusters-readerdb-vs-dbrr)
+ [Überlegungen](#multi-az-db-clusters-instance-read-replica-considerations)
+ [Erstellen eines DB-Instance-Lesereplikats](#multi-az-db-clusters-instance-read-replica-create)
+ [Hochstufen des DB-Instance-Lesereplikats](#multi-az-db-clusters-promote-instance-read-replica)
+ [Einschränkungen für die Erstellung eines DB-Instance-Lesereplikats aus einem Multi-AZ-DB-Cluster](#multi-az-db-clusters-create-instance-read-replica-limitations)
## Vergleichen von Reader-DB-Instances und DB-Instance-Lesereplikaten
Ein *DB-Instance-Lesereplikat* eines Multi-AZ-DB-Clusters unterscheidet sich in den folgenden Punkten von den *Reader-DB-Instances* des Multi-AZ-DB-Clusters:
+ Die Reader-DB-Instances fungieren als automatische Failover-Ziele, DB-Instance-Lesereplikate hingegen nicht.
+ Reader-DB-Instances müssen eine Änderung gegenüber der Writer-DB-Instance bestätigen, bevor ein Commit für die Änderung ausgeführt werden kann. Bei DB-Instance-Lesereplikaten werden Updates jedoch asynchron in das Lesereplikat des Lesereplikats kopiert, ohne dass eine Bestätigung erforderlich ist.
+ Reader-DB-Instances verwenden immer die gleiche Instance-Klasse, den gleichen Speichertyp und die gleiche Engine-Version wie die Writer-DB-Instance des Multi-AZ-DB-Clusters. DB-Instance-Lesereplikate müssen jedoch nicht unbedingt dieselben Konfigurationen wie der Quell-Cluster verwenden.
+ Sie können ein DB-Instance-Lesereplikat zu einer eigenständigen DB-Instance hochstufen. Eine Reader-DB-Instance eines Multi-AZ-DB-Clusters können Sie nicht zu einer eigenständigen Instance hochstufen.
+ Der Reader-Endpunkt leitet nur Anfragen an die Reader-DB-Instances des Multi-AZ-DB-Clusters weiter. Er leitet niemals Anfragen an ein DB-Instance-Lesereplikat weiter.
Weitere Informationen über Reader- und Writer-DB-Instances finden Sie unter [Architektur von Multi-AZ-DB-Clustern](multi-az-db-clusters-concepts.md#multi-az-db-clusters-concepts-overview).
## Überlegungen
Beachten Sie Folgendes, bevor Sie DB-Instance-Lesereplikat aus einem Multi-AZ-DB-Cluster erstellen:
+ Wenn Sie das DB-Instance-Lesereplikat erstellen, muss es dieselbe Hauptversion wie seine Quelle und dieselbe oder eine höhere Nebenversion haben. Nachdem Sie das Lesereplikat erstellt haben, können Sie es optional auf eine höhere Nebenversion als den Quell-Cluster aktualisieren.
+ Wenn Sie das DB-Instance-Lesereplikat erstellen, muss der zugewiesene Speicher dem zugewiesenen Speicher des Multi-AZ-DB-Quell-Clusters entsprechen. Sie können den zugewiesenen Speicher ändern, nachdem das Lesereplikat erstellt wurde.
+ Für RDS für MySQL muss der Parameter `gtid-mode` für den Multi-AZ-Quell-DB-Cluster auf `ON` festgelegt werden. Weitere Informationen finden Sie unter [Arbeiten mit DB-Cluster-Parametergruppen für Multi-AZ-DB-Cluster](USER_WorkingWithDBClusterParamGroups.md).
+ Eine aktive, langlaufende Transaktion kann den Prozess der Erstellung des Lesereplikats verlangsamen. Wir empfehlen Ihnen zu warten, bis langlaufende Transaktionen abgeschlossen sind, bevor ein Lesereplikat erstellt wird.
+ Wenn Sie den Multi-AZ-Quell-DB-Cluster für ein DB-Instance-Lesereplikat löschen, werden alle Lesereplikate, auf die geschrieben wird, zu eigenständigen DB-Instances hochgestuft.
## Erstellen eines DB-Instance-Lesereplikats
Sie können eine DB-Instance-Read-Replica aus einem Multi-AZ-DB-Cluster mithilfe der, oder RDS-API erstellen. AWS-Managementkonsole AWS CLI
**Anmerkung**
Wir empfehlen dringend, alle Lesereplikate in derselben Virtual Private Cloud (VPC) basierend auf Amazon VPC als Multi-AZ-Quell-DB-Cluster zu erstellen.
Wenn Sie ein Lesereplikat in einer anderen VPC als dem Multi-AZ-Quell-DB-Cluster erstellen, können Classless Inter-Domain Routing (CIDR)-Bereiche zwischen dem Replikat und dem RDS-System einander überlappen. Die CIDR-Überlappung macht das Replikat instabil, was sich negativ auf Anwendungen auswirken kann, die eine Verbindung herstellen. Wenn beim Erstellen des Lesereplikats eine Fehlermeldung angezeigt wird, wählen Sie eine andere Ziel-DB-Subnetzgruppe aus. Weitere Informationen finden Sie unter [Arbeiten mit einer DB-Instance in einer VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md).
### Konsole
Führen Sie die folgenden Schritte über die AWS-Managementkonsole aus, um ein DB-Instance-Lesereplikat aus einem Multi-AZ-DB-Cluster zu erstellen.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Datenbanken** aus.
1. Wählen Sie den Multi-AZ-DB-Cluster aus, den Sie als Quelle für ein Lesereplikat verwenden möchten.
1. Wählen Sie unter **Aktionen** **Create read replica (Read Replica erstellen)** aus.
1. Vergewissern Sie sich, dass unter **Replikatquelle** der richtige Multi-AZ-DB-Cluster ausgewählt ist.
1. Geben Sie unter **DB-Kennung** einen Namen für das Lesereplikat ein.
1. Geben Sie für die restlichen Abschnitte die gewünschten Einstellungen für die DB-Instance an. Weitere Informationen zu einer Einstellung finden Sie unter [Einstellungen für DB-Instances](USER_CreateDBInstance.Settings.md).
**Anmerkung**
Der zugewiesene Speicher für das DB-Instance-Lesereplikat muss dem zugewiesenen Speicher des Multi-AZ-DB-Quell-Clusters entsprechen.
1. Wählen Sie **Read Replica erstellen** aus.
### AWS CLI
Verwenden Sie den Befehl, um eine DB-Instance Read Replica aus einem Multi-AZ-DB-Cluster zu erstellen. AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance-read-replica.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance-read-replica.html) Geben Sie für `--source-db-cluster-identifier` die ID des Multi-AZ-DB-Clusters an.
Für Linux, macOS oder Unix:
```
aws rds create-db-instance-read-replica \
--db-instance-identifier myreadreplica \
--source-db-cluster-identifier mymultiazdbcluster
```
Für Windows:
```
aws rds create-db-instance-read-replica ^
--db-instance-identifier myreadreplica ^
--source-db-cluster-identifier mymultiazdbcluster
```
### RDS-API
Verwenden Sie die Operation [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstanceReadReplica.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstanceReadReplica.html), um ein DB-Instance-Lesereplikat aus einem Multi-AZ-DB-Cluster zu erstellen.
## Hochstufen des DB-Instance-Lesereplikats
Wenn Sie das DB-Instance-Lesereplikat nicht mehr benötigen, können Sie es zu einer eigenständigen DB-Instance hochstufen. Wenn Sie ein Lesereplikat hochstufen, wird die DB-Instance neu gestartet, bevor sie wieder verfügbar ist. Detaillierte Anweisungen finden Sie unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md).
Wenn Sie das Lesereplikat verwenden, um eine Multi-AZ-Bereitstellung eines DB-Clusters zu einer Single-AZ- oder einer Multi-AZ-Bereitstellung einer DB-Instance zu migrieren, sollten Sie alle Transaktionen beenden, die auf den DB-Quell-Cluster geschrieben werden. Warten Sie anschließend, bis alle Updates für das Lesereplikat abgeschlossen wurden. Datenbank-Updates werden für das Lesereplikat durchgeführt, nachdem sie in einer der Reader-DB-Instances des Multi-AZ-DB-Clusters vorgenommen wurden. Diese Replikationsverzögerung kann erheblich variieren. Verwenden Sie die Metrik `ReplicaLag`, um zu bestimmen, wann alle Aktualisierungen am Lesereplikat vorgenommen wurden. Weitere Informationen zur Replikationsverzögerung finden Sie unter [Überwachen der Lesereplikation](USER_ReadRepl.Monitoring.md).
Nachdem Sie das Lesereplikat hochgestuft haben, warten Sie, bis der Status der hochgestuften DB-Instance `Available` lautet, bevor Sie Ihre Anwendungen an die hochgestufte DB-Instance weiterleiten. Löschen Sie optional die Multi-AZ-Bereitstellung des DB-Clusters, wenn Sie sie nicht mehr benötigen. Detaillierte Anweisungen finden Sie unter [Löschen eines DB-Clusters mit Multi-AZ für Amazon RDS](USER_DeleteMultiAZDBCluster.Deleting.md).
## Einschränkungen für die Erstellung eines DB-Instance-Lesereplikats aus einem Multi-AZ-DB-Cluster
Die folgenden Einschränkungen gelten für die Erstellung eines Lesereplikats eines DB-Instance-Lesereplikats aus einer Multi-AZ-Bereitstellung eines DB-Clusters.
+ Sie können keine Read Replica einer DB-Instance in einem anderen System als dem erstellen AWS-Konto , dem der AWS-Konto Quell-Multi-AZ-DB-Cluster gehört.
+ Sie können keine Read Replica einer DB-Instance in einem anderen Multi-AZ-DB-Cluster als AWS-Region dem Quell-DB-Cluster erstellen.
+ Sie können ein DB-Instance-Lesereplikat nicht auf einen bestimmten Zeitpunkt wiederherstellen.
+ Die Speicherverschlüsselung muss dieselben Einstellungen für den Multi-AZ-DB-Quell-Cluster und das DB-Instance-Lesereplikat haben.
+ Wenn der Multi-AZ-DB-Quell-Cluster verschlüsselt ist, muss das DB-Instance-Lesereplikat mit demselben KMS-Schlüssel verschlüsselt werden.
+ Wenn Sie ein Nebenversions-Upgrade für den Multi-AZ-DB-Quell-Cluster durchführen möchten, müssen Sie das Nebenversions-Upgrade zuerst auf dem DB-Instance-Lesereplikat vornehmen.
+ Das DB-Instance-Lesereplikat unterstützt keine kaskadierenden Lesereplikate.
+ Für RDS für PostgreSQL muss der Multi-AZ-Quell-DB-Cluster PostgreSQL-Version 13.11, 14.8 oder 15.2-R2 oder höher ausführen, um ein DB-Instance-Lesereplikat zu erstellen.
+ Sie können ein Hauptversions-Upgrade auf dem Multi-AZ-Quell-DB-Instance des Lesereplikats einer DB-Instance durchführen, die Replikation auf das Lesereplikat wird jedoch angehalten und kann nicht neu gestartet werden.
# Einrichten der externen Replikation von Multi-AZ-DB-Clustern für Amazon RDS
Sie können eine Replikation zwischen einem Multi-AZ-DB-Cluster und einer Datenbank außerhalb von Amazon RDS einrichten.
Die externe Replikation ermöglicht Multi-AZ-DB-Clustern die Replikation von Daten zwischen einer RDS-DB-Instance und einer externen Datenbank, entweder On-Premises oder in einer anderen Cloud-Umgebung. Dies ist vorteilhaft für die Notfallwiederherstellung, die Datenmigration und die Wahrung der Konsistenz zwischen Systemen an verschiedenen Standorten. In diesem Abschnitt werden die Voraussetzungen für die Einrichtung der Replikation, die Konfiguration des Prozesses und wichtige Faktoren wie Replikationslatenz, Bandbreite und Kompatibilität mit verschiedenen Datenbank-Engines behandelt.
## RDS für MySQL
Um die externe Replikation für einen Multi-AZ-DB-Cluster von RDS für MySQL einzurichten, müssen Sie Binärprotokolldateien auf den DB-Instances im Cluster so lange aufbewahren, bis die Änderungen auf das Replikat angewendet wurden, bevor Amazon RDS die Binärprotokolldatei löscht. Konfigurieren Sie hierfür die Aufbewahrungszeit von Binärprotokollen, indem Sie die gespeicherte Prozedur `mysql.rds_set_configuration` aufrufen und den Parameter `binlog retention hours` festlegen. Weitere Informationen finden Sie unter [binlog retention hours](mysql-stored-proc-configuring.md#mysql_rds_set_configuration-usage-notes.binlog-retention-hours).
Der Standardwert für `binlog retention hours` ist `NULL`, was bedeutet, dass Binärprotokolle nicht aufbewahrt werden (0 Stunden). Wenn Sie eine externe Replikation für einen Multi-AZ-DB-Cluster einrichten möchten, müssen Sie den Parameter auf einen anderen Wert als `NULL` festlegen.
Sie können die Aufbewahrungszeit von Binärprotokollen nur von der Writer-DB-Instance des Multi-AZ-DB-Clusters aus konfigurieren und die Einstellung wird asynchron an alle Reader-DB-Instances weitergegeben.
Darüber hinaus empfehlen wir dringend, die GTID-basierte Replikation für das externe Replikat zu aktivieren. Wenn dann eine der DB-Instances ausfällt, können Sie die Replikation von einer anderen fehlerfreien DB-Instance im Cluster fortsetzen. Weitere Informationen finden Sie unter [Replikation mit globalen Transaktionskennungen](https://dev.mysql.com/doc/refman/8.0/en/replication-gtids.html) in der MySQL-Dokumentation.
## RDS für PostgreSQL
Um eine externe Replikation für einen Multi-AZ-DB-Cluster von RDS für PostgreSQL einzurichten, müssen Sie die logische Replikation aktivieren. Detaillierte Anweisungen finden Sie unter [Einrichten der logischen PostgreSQL-Replikation mit DB-Clustern mit Multi-AZ für Amazon RDS](USER_MultiAZDBCluster_LogicalRepl.md).
# Löschen eines DB-Clusters mit Multi-AZ für Amazon RDS
Sie können ein DB-Multi-AZ-DB-Clusters über die AWS-Managementkonsole, die AWS CLI oder die RDS-API löschen.
Die Zeit, die zum Löschen eines DB-Clusters mit Multi-AZ erforderlich ist, kann je nach den folgenden Faktoren variieren:
+ Aufbewahrungszeitraum für Backups (d. h. wie viele Backups gelöscht werden sollen).
+ Wie viele Daten gelöscht werden.
+ Ob ein letzter Snapshot erstellt wurde.
Der Löschschutz muss auf dem DB-Cluster mit Multi-AZ deaktiviert werden, bevor Sie ihn löschen können. Weitere Informationen finden Sie unter [Voraussetzungen für das Löschen einer DB-Instance](USER_DeleteInstance.md#USER_DeleteInstance.DeletionProtection). Sie können den Löschschutz deaktivieren, indem Sie den DB-Cluster mit Multi-AZ bearbeiten. Weitere Informationen finden Sie unter [Ändern eines Multi-AZ-DB-Clusters für Amazon RDS](modify-multi-az-db-cluster.md).
## Konsole
**Löschen eines Multi-AZ-DB-Clusters**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** und dann den Multi-AZ-DB-Cluster aus, den Sie löschen möchten.
1. Klicken Sie bei ** Actions** auf **Delete**.
1. Wählen Sie **Letzten Snapshot erstellen?** um einen endgültigen DB-Snapshot für den Multi-AZ-DB-Cluster zu erstellen.
Wenn Sie einen endgültigen Snapshot erstellen, geben Sie einen Namen für den **endgültigen Snapshot-Namen** ein.
1. Wählen Sie **Automatische Backups beibehalten**, um automatisierte Backups beizubehalten.
1. Geben Sie **delete me** in das Feld ein.
1. Wählen Sie **Delete (Löschen)**.
## AWS CLI
Um einen Multi-AZ-DB-Cluster mit AWS CLI zu löschen, rufen Sie den Befehl [delete-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-cluster.html) mit den folgenden Optionen auf:
+ `--db-cluster-identifier`
+ `--final-db-snapshot-identifier` oder `--skip-final-snapshot`
**Example Mit einem letzten Snapshot**
Für Linux, macOS oder Unix:
```
aws rds delete-db-cluster \
--db-cluster-identifier mymultiazdbcluster \
--final-db-snapshot-identifier mymultiazdbclusterfinalsnapshot
```
Für Windows:
```
aws rds delete-db-cluster ^
--db-cluster-identifier mymultiazdbcluster ^
--final-db-snapshot-identifier mymultiazdbclusterfinalsnapshot
```
**Example Mit keinem letzten Snapshot**
Für Linux, macOS oder Unix:
```
aws rds delete-db-cluster \
--db-cluster-identifier mymultiazdbcluster \
--skip-final-snapshot
```
Für Windows:
```
aws rds delete-db-cluster ^
--db-cluster-identifier mymultiazdbcluster ^
--skip-final-snapshot
```
## RDS-API
Um einen Multi-AZ-DB-Cluster mithilfe der Amazon-RDS-API zu löschen, rufen Sie die [DeleteDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteDBCluster.html)-Operation mit den folgenden Parametern auf:
+ `DBClusterIdentifier`
+ `FinalDBSnapshotIdentifier` oder `SkipFinalSnapshot`
# Einschränkungen von Multi-AZ-DB-Clustern für Amazon RDS
Ein Multi-AZ-DB-Cluster verfügt über eine Writer-DB-Instance und zwei Reader-DB-Instances in drei separaten Availability Zones. Multi-AZ-DB-Cluster bieten hohe Verfügbarkeit, erhöhte Kapazität für Lese-Workloads und eine geringere Latenz im Vergleich zu Multi-AZ-Bereitstellungen. Weitere Informationen zu Multi-AZ-DB-Clustern finden Sie unter [Bereitstellungen von Multi-AZ-DB-Clustern für Amazon RDS](multi-az-db-clusters-concepts.md).
Die folgenden Einschränkungen gelten für Multi-AZ-DB-Cluster.
+ Multi-AZ-DB-Cluster unterstützen die folgenden Funktionen nicht:
+ IPv6-Verbindungen (Dual-Stack-Modus)
+ Regionsübergreifende automatisierte Backups
+ Kerberos-Authentifizierung
+ Ändern des Ports Alternativ können Sie einen Multi-AZ-DB-Cluster zu einem bestimmten Zeitpunkt wiederherstellen und einen anderen Port angeben.
+ Optionsgruppen
+ Zeitpunktbezogene Wiederherstellung (PITR) für gelöschte Cluster
+ Automatische Skalierung des Speichers durch Festlegen des maximal zugewiesenen Speichers Alternativ können Sie den Speicher manuell skalieren.
+ Stoppen und Starten des Multi-AZ-DB-Clusters
+ Kopieren eines Snapshot eines Multi-AZ-DB-Clusters
+ Verschlüsselung eines unverschlüsselten Multi-AZ-DB-Clusters
+ Multi-AZ-DB-Cluster von RDS für MySQL unterstützen nur die folgenden gespeicherten Systemprozeduren:
+ `mysql.rds_rotate_general_log`
+ `mysql.rds_rotate_slow_log`
+ `mysql.rds_show_configuration`
+ `mysql.rds_set_external_master_with_auto_position`
+ `mysql.rds_set_configuration`
+ Multi-AZ-DB-Cluster von RDS für PostgreSQL unterstützen die folgenden Erweiterungen nicht: `aws_s3` und `pg_transport`.
+ Multi-AZ-DB-Cluster von RDS für PostgreSQL unterstützen nicht die Verwendung eines benutzerdefinierten DNS-Servers für ausgehenden Netzwerkzugriff.