$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_D**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Fri Sep 30 22:44:49 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_D"
Connected as SYSDG.
DGMGRL>
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 11.00 KByte/s
Instance(s):
ORCL
SUCCESS
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B| DBA | | Ändern Sie die Einstellung für den Protokolltransport, indem Sie vom Primärknoten aus eine Verbindung zu DGMGRL herstellen. | Ändern Sie den Protokolltransportmodus auf`FastSync`, der der Redo-Transport-Einstellung entspricht. `SYNC+NOAFFIRM` Um sicherzustellen, dass Sie nach dem Rollenwechsel über gültige Einstellungen verfügen, ändern Sie diese Einstellungen sowohl für die Primärdatenbank als auch für die Standby-Datenbank.**Nicht-CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 11 20:24:11 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_B"
Connected as SYSDG.
DGMGRL>
DGMGRL> show database rdscdb_b
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 2.00 KByte/s
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL>
DGMGRL>**CDB**
DGMGRL> edit database orcl_d set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database orcl_d LogXptMode;
LogXptMode = 'fastsync'
DGMGRL> edit database orcl_a set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database orcl_a logxptmode;
LogXptMode = 'fastsync'
DGMGRL>
DGMGRL> edit database rdscdb_b set property logxptmode=fastsync;DGMGRL> edit database rdscdb_b set property logxptmode=fastsync;| DBA | | Ändern Sie den Schutzmodus auf MaxAvailability. | Ändern Sie den Schutzmodus auf, `MaxAvailability` indem Sie `DGMGRL` vom primären Knoten aus eine Verbindung herstellen.**Nicht-CDB**
Property "logxptmode" updated
DGMGRL> show database rdscdb_b LogXptMode;
LogXptMode = 'fastsync'
DGMGRL> edit database rdscdb_a set property logxptmode=fastsync;
Property "logxptmode" updated
DGMGRL> show database rdscdb_a logxptmode;
LogXptMode = 'fastsync'
DGMGRL>
DGMGRL> edit configuration set protection mode as maxavailability;**CDB**
Succeeded.
DGMGRL> show configuration;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 38 seconds ago)
DGMGRL>
DGMGRL> show configuration| DBA | ### Ändern Sie den Replikatstatus von Mount in Read-Only und aktivieren Sie Redo Apply | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Beenden Sie die Redo-Anwendung für die Standby-Datenbank. | Die Read Replica wird standardmäßig im `MOUNT` Modus erstellt. Um es im schreibgeschützten Modus zu öffnen, müssen Sie zuerst Redo Apply deaktivieren, indem Sie vom Primär- oder Standby-Knoten `DGMGRL` aus eine Verbindung zu herstellen.**Kein CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 57 seconds ago)
DGMGRL>
DGMGRL> show database orcl_dDGMGRL> show database orcl_d**CDB**
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 11.00 KByte/s
Real Time Query: OFF
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL> edit database orcl_d set state=apply-off;
Succeeded.
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-OFF
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 42 seconds (computed 1 second ago)
Average Apply Rate: (unknown)
Real Time Query: OFF
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL>
DGMGRL> show configurationDGMGRL> show configuration| DBA | | Öffnen Sie die Read Replica-Instanz im schreibgeschützten Modus. | Stellen Sie mithilfe des TNS-Eintrags eine Connect zur Standby-Datenbank her und öffnen Sie sie im schreibgeschützten Modus, indem Sie vom Primär- oder Standby-Knoten aus eine Verbindung herstellen.**Nicht-CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 57 seconds ago)
DGMGRL> show database rdscdb_b;
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 2.00 KByte/s
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL> edit database rdscdb_b set state=apply-off;
Succeeded.
DGMGRL> show database rdscdb_b;
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-OFF
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: (unknown)
Real Time Query: OFF
Instance(s):
RDSCDB
Database Status:
SUCCESS
$ sqlplus RDS_DATAGUARD@RDS_CUSTOM_ORCL_D as sysdg**CDB**
-bash-4.2$ sqlplus RDS_DATAGUARD@RDS_CUSTOM_ORCL_D as sysdg
SQL*Plus: Release 19.0.0.0.0 - Production on Fri Sep 30 23:00:14 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2020, Oracle. All rights reserved.
Enter password:
Last Successful login time: Fri Sep 30 2022 22:48:27 +00:00
Connected to:
Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production
Version 19.10.0.0.0
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
MOUNTED
SQL> alter database open read only;
Database altered.
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
READ ONLY
SQL>
-bash-4.2$ sqlplus C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B as sysdg| DBA | | Aktivieren Sie Redo Apply auf der Read Replica-Instanz. | Aktivieren Sie Redo Apply auf der Read Replica-Instanz, indem Sie `DGMGR` L vom Primär- oder Standby-Knoten aus verwenden.**Nicht-CDB**
SQL*Plus: Release 19.0.0.0.0 - Production on Wed Jan 11 21:14:07 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2022, Oracle. All rights reserved.
Enter password:
Last Successful login time: Wed Jan 11 2023 21:12:05 +00:00
Connected to:
Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production
Version 19.16.0.0.0
SQL> select name,open_mode from v$database;
NAME OPEN_MODE
--------- --------------------
RDSCDB MOUNTED
SQL> alter database open read only;
Database altered.
SQL> select name,open_mode from v$database;
NAME OPEN_MODE
--------- --------------------
RDSCDB READ ONLY
SQL>
$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_D**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Fri Sep 30 23:02:16 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_D"
Connected as SYSDG.
DGMGRL>
edit database orcl_d set state=apply-on;
DGMGRL> edit database orcl_d set state=apply-on;
Succeeded.
DGMGRL> show database orcl_d
Database - orcl_d
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 496.00 KByte/s
Real Time Query: ON
Instance(s):
ORCL
Database Status:
SUCCESS
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_B| DBA | ## Zugehörige Ressourcen + [Konfiguration von Amazon RDS als PeopleSoft Oracle-Datenbank](https://d1.awsstatic.com/whitepapers/configuring-amazon-rds-as-peoplesoft-database.pdf) (AWS-Whitepaper) + [Handbuch zu Oracle Data Guard Broker](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/index.html) (Oracle-Referenzdokumentation) + [Konzepte und Verwaltung von Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/index.html) (Oracle-Referenzdokumentation) ## Zusätzliche Informationen **Wählen Sie Ihren Datenbank-Schutzmodus** Oracle Data Guard bietet drei Schutzmodi, mit denen Sie Ihre Data Guard-Umgebung auf der Grundlage Ihrer Verfügbarkeits-, Schutz- und Leistungsanforderungen konfigurieren können. In der folgenden Tabelle werden diese drei Modi zusammengefasst. | | | Datenschutzmodus | Transporteinstellung wiederholen | Description | | --- |--- |--- | | ***MAXIMALE LEISTUNG*** | `ASYNC` | Bei Transaktionen, die in der Primärdatenbank stattfinden, werden Redo-Daten asynchron übertragen und in das Redo-Log der Standby-Datenbank geschrieben. Daher sind die Auswirkungen auf die Leistung minimal.`MaxPerformance`RPO=0 kann aufgrund des asynchronen Protokollversands nicht bereitgestellt werden. | | ***MAXIMALER SCHUTZ*** | `SYNC+AFFIRM` | Bei Transaktionen in der Primärdatenbank werden Redo-Daten synchron übertragen und in das Redo-Log der Standby-Datenbank auf der Festplatte geschrieben, bevor die Transaktion bestätigt wird. Wenn die Standby-Datenbank nicht mehr verfügbar ist, fährt sich die Primärdatenbank selbst herunter, um sicherzustellen, dass die Transaktionen geschützt sind. | | ***MAXIMALE VERFÜGBARKEIT*** | `SYNC+AFFIRM` | Dies ist dem `MaxProtection` Modus ähnlich, außer wenn keine Bestätigung von der Standby-Datenbank empfangen wird. In diesem Fall verhält es sich so, als ob es sich im `MaxPerformance` Modus zur Aufrechterhaltung der Verfügbarkeit der Primärdatenbank befinde, bis es seinen Redo-Stream wieder in eine synchronisierte Standby-Datenbank schreiben kann. | | `SYNC+NOAFFIRM` | Bei Transaktionen in der Primärdatenbank wird Redo synchron an die Standby-Datenbank übertragen, und die Primärdatenbank wartet nur auf die Bestätigung, dass das Redo in der Standby-Datenbank empfangen wurde, nicht darauf, dass es auf das Standby-Laufwerk geschrieben wurde. Dieser Modus, auch bekannt als`FastSync`, kann in einem speziellen Fall mehrerer gleichzeitiger Ausfälle einen Leistungsvorteil bieten, allerdings auf Kosten potenzieller Datenverluste. | Read Replicas in RDS Custom for Oracle werden im Schutzmodus mit maximaler Leistung erstellt, der auch der Standardschutzmodus für Oracle Data Guard ist. Der Modus mit maximaler Leistung hat die geringste Auswirkung auf die Leistung der Primärdatenbank, sodass Sie die in Sekunden gemessene Recovery Point Objective (RPO) -Anforderung erfüllen können. Um ein Ziel ohne Datenverlust (RPO=0) zu erreichen, können Sie den Oracle Data Guard-Schutzmodus so anpassen, dass er die `SYNC+NOAFFIRM` Einstellung für Redo-Transport `MaxAvailability` enthält, um eine bessere Leistung zu erzielen. Da Commits in der Primärdatenbank erst bestätigt werden, nachdem die entsprechenden Redo-Vektoren erfolgreich an die Standby-Datenbank übertragen wurden, kann die Netzwerklatenz zwischen der Primärinstanz und dem Replikat für Workloads, bei denen ein Commit berücksichtigt wird, entscheidend sein. Wir empfehlen, Belastungstests für Ihren Workload durchzuführen, um die Auswirkungen auf die Leistung zu beurteilen, wenn die Read Replica so angepasst ist, dass sie im Modus ausgeführt wird. `MaxAvailability` Die Bereitstellung der Read Replica in derselben Availability Zone wie die Primärdatenbank bietet eine geringere Netzwerklatenz als die Bereitstellung der Read Replica in einer anderen Availability Zone. Die Bereitstellung der primären Replicas und der Read Replicas in derselben Availability Zone entspricht jedoch möglicherweise nicht Ihren HA-Anforderungen, da in dem unwahrscheinlichen Fall, dass die Availability Zone nicht verfügbar ist, sowohl die primäre Instanz als auch die Read Replica-Instanz betroffen sind. # Analysieren Sie Objektabhängigkeiten für partielle Datenbankmigrationen von Oracle nach PostgreSQL *anuradha chintha, Amazon Web Services* ## Zusammenfassung Dieses Muster beschreibt, wie wichtig es ist, Systemabhängigkeiten systematisch zu identifizieren und zu verwalten, wenn eine Oracle-Teildatenbank entweder zu Amazon Relational Database Service (Amazon RDS) oder Amazon Aurora PostgreSQL migriert wird. Bei einer teilweisen Migration wird nur eine Teilmenge der Datenbankobjekte und Daten aus der ursprünglichen Datenbank migriert, während die Quelldatenbank weiterhin Anwendungen betreibt und bereitstellt, die von nicht migrierten Komponenten abhängen Sie müssen den Umfang der Migration ermitteln und analysieren, wenn es um umfangreiche Datenbanken geht, bei denen Anwendungen eng mit Upstream- und Downstream-Abhängigkeiten verknüpft sind. Um mit einer teilweisen Migration zu beginnen, müssen Sie die Bereichsobjekte identifizieren, darunter Tabellen, Trigger, Ansichten, gespeicherte Prozeduren, Funktionen und Pakete. Der Prozess zur Identifizierung des Bereichs folgt einem umfassenden Ansatz: + Bereichsobjekte der ersten Ebene werden durch direkte Verweise im Anwendungscode und kritische modulspezifische Jobs identifiziert. + Objekte der zweiten Ebene werden durch eine umfassende Abhängigkeitsanalyse abgeleitet. Wenn Sie verstehen, wie verschiedene Teile Ihres Systems interagieren, können Sie die richtige Reihenfolge für das Verschieben von Datenbankkomponenten besser planen und das Risiko von Migrationsfehlern verringern. In der folgenden Tabelle sind verschiedene Arten der Abhängigkeitsanalyse aufgeführt. | | | Art der Analyse | Schwerpunktbereiche | Zweck | | --- |--- |--- | | Objektabhängigkeiten | TabellenAnsichtenGespeicherte ProzedurenFunktionenAuslöser | Identifiziert Beziehungen zwischen Datenbankobjekten und ihren hierarchischen Strukturen | | Segmentieren Sie Abhängigkeiten | Schlüsselbeziehungen im AuslandPrimäre SchlüsselkettenSchemaübergreifende Referenzen | Ordnet Datenbeziehungen zu und wahrt die referenzielle Integrität | | Sicherheitsabhängigkeiten | BenutzerberechtigungenRollenhierarchienObjektberechtigung | Sorgt für eine ordnungsgemäße Zugriffskontrolle, Migration und Sicherheitswartung | | Zugriffsmuster | LesevorgängeSchreibvorgänge | Ermittelt die Interaktionsmuster der Datenbank | Um die Konsistenz zwischen Quell- und Zielsystemen aufrechtzuerhalten, sollten Sie während der Übergangsphase Mechanismen zur Datensynchronisierung einrichten. Sie müssen auch den Anwendungscode und die Funktionen ändern, um die Datenverteilung sowohl in der Oracle-Quelldatenbank als auch in der PostgreSQL-Zieldatenbank zu handhaben. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktiver AWS-Konto + Eine Oracle-Datenbank (Quelle) + Ein Amazon RDS oder Amazon Aurora PostgreSQL (Ziel) **Produktversionen** + Oracle 19c oder höher + PostgreSQL 16 oder höher ## Architektur **Quelltechnologie-Stack** + Oracle 19c oder höher **Zieltechnologie-Stack** + Amazon RDS oder Amazon Aurora PostgreSQL **Zielarchitektur** Das folgende Diagramm zeigt den Migrationsprozess von einer lokalen Oracle-Datenbank zu Amazon RDS for Oracle, der Folgendes umfasst: + Identifizieren von Datenbankabhängigkeiten + Migrieren von Datenbankcode und Objekten mit AWS Schema Conversion Tool ()AWS SCT + Daten mit AWS Database Migration Service () migrieren AWS DMS + Replikation laufender Änderungen durch Change Data Capture (CDC) mithilfe von AWS DMS Weitere Informationen finden Sie in der Dokumentation unter [AWS Schema Conversion Tool Integrieren AWS Database Migration Service mit](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_DMSIntegration.html). AWS ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/90160825-3199-4382-95a8-ad63139c5c89/images/b09c36a4-27fa-412e-877e-57a31bcce0dc.png) ## Tools **AWS-Services** + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) für Oracle unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Oracle-Datenbank in der. AWS Cloud + Amazon Aurora ist eine vollständig verwaltete relationale Datenbank-Engine, die für die Cloud entwickelt wurde und mit MySQL und PostgreSQL kompatibel ist. + AWS Schema Conversion Tool (AWS SCT) unterstützt heterogene Datenbankmigrationen, indem das Quelldatenbankschema und ein Großteil des benutzerdefinierten Codes automatisch in ein Format konvertiert werden, das mit der Zieldatenbank kompatibel ist. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) unterstützt Sie bei der Migration von Datenspeichern in die AWS Cloud oder zwischen Kombinationen von Cloud- und lokalen Setups. **Andere Dienste** + [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) ist eine integrierte Entwicklungsumgebung, die die Entwicklung und Verwaltung von Oracle-Datenbanken sowohl in herkömmlichen als auch in Cloud-basierten Bereitstellungen vereinfacht. Für dieses Muster können Sie [SQL\$1Plus](https://docs.oracle.com/cd/B19306_01/server.102/b14357/qstart.htm) verwenden. ## Best Practices Bewährte Methoden zur Bereitstellung und Migration einer Oracle-Datenbank finden Sie unter [Bewährte Methoden für die Migration zu Amazon RDS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html) for Oracle. ## Epen ### Identifizieren Sie Objektabhängigkeiten | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Objekttabelle. | Identifizieren Sie Objekte, die für die Funktionalität der Anwendung unerlässlich sind, und erstellen Sie eine Tabelle mit dem Namen`DEPENDENT_ANALYSIS_BASELINE`. Fügen Sie der Tabelle Datensätze für jedes Objekt hinzu. Ein Beispiel finden Sie im Abschnitt *Zusätzliche Informationen*. | Dateningenieur, DBA | | Erstellen Sie eine Datenbankprozedur. | Erstellen Sie eine gespeicherte Prozedur mit dem Namen`sp_object_dependency_analysis`, um Objektabhängigkeiten in beide Richtungen (vorwärts und rückwärts) zu analysieren, indem Sie Daten aus der `DBA_DEPENDENCIES` Tabelle verwenden. Ein Beispiel finden Sie im Abschnitt *Zusätzliche Informationen*. | Dateningenieur, DBA | | Führen Sie das Verfahren aus. | Führen Sie die Skripts auf jeder nachfolgenden Ebene aus, bis keine neuen Objektabhängigkeiten gefunden werden. Alle Abhängigkeiten und Ebenen werden in der `DEPENDENT_ANALYSIS_BASELINE` Tabelle gespeichert. | DBA, Dateningenieur | ### Erstellen Sie ein Verfahren für Abhängigkeiten auf Segmentebene | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Abhängigkeitstabelle. | Erstellen Sie eine Abhängigkeitstabelle auf Segmentebene mit dem Namen. `REFERENTIAL_ANALYSIS_BASELINE` Wenn alle Abhängigkeiten auf Objektebene erkannt wurden, überprüfen Sie die übergeordneten Tabellen von, `DEPENDENT_ANALYSIS_BASELINE` indem Sie die Tabelle abfragen. `DBA_CONSTRAINT`Schließen Sie Abhängigkeiten aus, bei denen Baseline-Tabellen von anderen Tabellen referenziert werden. Beim Backfilling werden diese Beziehungen behandelt. Im Folgenden finden Sie ein Beispielskript:
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 11 21:21:11 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_B"
Connected as SYSDG.
DGMGRL> edit database rdscdb_b set state=apply-on;
Succeeded.
DGMGRL> show database rdscdb_b
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Average Apply Rate: 35.00 KByte/s
Real Time Query: ON
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL> show database rdscdb_b
Database - rdscdb_b
Role: PHYSICAL STANDBY
Intended State: APPLY-ON
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Average Apply Rate: 16.00 KByte/s
Real Time Query: ON
Instance(s):
RDSCDB
Database Status:
SUCCESS
DGMGRL>
CREATE TABLE REFERENTIAL_ANALYSIS_BASELINE| Dateningenieur, DBA | | Erstellen Sie eine Datenbankprozedur. | Erstellen Sie eine Prozedur namens `SP_OBJECT_REFERENTIAL_ANALYSIS` und generieren Sie eine Referenzanalyse für alle identifizierten Objekte. Ein Beispiel finden Sie im Abschnitt *Zusätzliche Informationen*. | Dateningenieur, DBA | | Führen Sie das Verfahren aus. | Führen Sie die Prozedur aus, um referenzielle Abhängigkeiten abzurufen. Generieren Sie Objektdetails für die referenzielle Analyse in. `REFERENTIAL_ANALYSIS_BASELINE` | Dateningenieur, DBA | ### Identifizieren Sie Objekte, die lesen und schreiben | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie Tabellen für Lese- und Schreibobjekte. | Verwenden Sie das folgende Skript, um eine Lese-Objekttabelle mit dem Namen `TABLE_READ_OBJECT_DETAILS` und eine Schreibobjekttabelle mit dem Namen zu erstellen`TABLE_WRITE_OBJECT_DETAILS`:
(CHILD_OWNER VARCHAR2(50 BYTE),
CHILD_NAME VARCHAR2(100 BYTE),
PARENT_OWNER VARCHAR2(50 BYTE),
PARENT_NAME VARCHAR2(50 BYTE),
REFERENCE_PATH VARCHAR2(1000 BYTE));
CREATE TABLE TABLE_READ_OBJECT_DETAILS
(OWNER VARCHAR2(50 BYTE),
TAB_NAME VARCHAR2(50 BYTE),
READER_OWNER VARCHAR2(50 BYTE),
READER_NAME VARCHAR2(50 BYTE),
READER_TYPE VARCHAR2(50 BYTE));
CREATE TABLE TABLE_WRITE_OBJECT_DETAILS| Dateningenieur, DBA | | Erstellen Sie ein Analyseverfahren. | Erstellen Sie die `SP_READER_OBJECTS_ANALYSIS` Prozeduren `SP_WRITER_OBJECTS_ANALYSIS` für die Analyse von Leseobjekten bzw. Schreibobjekten. Diese Verfahren verwenden Musterabgleich, um verwandte Objekte zu finden. Ein Beispiel finden Sie im Abschnitt *Zusätzliche Informationen*. | Dateningenieur, DBA | | Führen Sie die Verfahren aus. | Führen Sie diese Verfahren aus, um abhängige Objekte zu identifizieren. | DBA, Dateningenieur | ### Überprüfen Sie die Datenbankberechtigungen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Tabelle zur Überprüfung der Rechte. | Erstellen Sie eine Tabelle zur Analyse der genannten Rechte`OBJECT_PRIVS_ANALYSIS`. Verwenden Sie das folgende Skript, um Objektberechtigungen in der `DEPENDENT_ANALYSIS_BASELINE` Tabelle rekursiv zu erfassen:
(TABLE_NAME VARCHAR2(100 BYTE),
WRITEOBJ_OWNER VARCHAR2(100 BYTE),
WRITEOBJ_NAME VARCHAR2(100 BYTE),
WRITEOBJ_TYPE VARCHAR2(100 BYTE),
LINE VARCHAR2(100 BYTE),
TEXT VARCHAR2(4000 BYTE),
OWNER VARCHAR2(50 BYTE));
CREATE TABLE OBJECT_PRIVS_ANALYSIS| Dateningenieur, DBA | | Erstellen Sie ein Verfahren zur Überprüfung von Rechten. | Erstellen Sie eine Prozedur mit dem Namen`SP_OBJECT_PRIVS_ANALYSIS`. Generieren Sie eine Rechteanalyse für identifizierte Objekte. Ein Beispiel finden Sie im Abschnitt *Zusätzliche Informationen*. | DBA, Dateningenieur | | Führen Sie das Verfahren aus. | Führen Sie die Prozedur aus, um sie in der `OBJECT_PRIVS_ANALYSIS` Tabelle zu erfassen. | DBA, Dateningenieur | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | Auf Wörterbuchtabellen kann nicht zugegriffen werden | Stellen Sie sicher, dass der Benutzer, der die Analyseobjekte erstellt hat, auf die DBA-Tabellen zugreifen kann. | ## Zugehörige Ressourcen **AWS-Dokumentation** + [Dokumentation zu Amazon RDS und Aurora](https://docs.aws.amazon.com/rds/) + [Leitfaden für die Migration von Oracle Database 19c zu Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/dms/latest/oracle-to-aurora-postgresql-migration-playbook/chap-oracle-aurora-pg.html) + [AWS Database Migration Service Was ist?](https://docs.aws.amazon.com/dms/latest/userguide/) + [Was ist das AWS Schema Conversion Tool?](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/) **Andere Dokumentation** + [Oracle-Datenbankobjekte](https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Database-Objects.html) ## Zusätzliche Informationen **Skript für `DEPENDENT_ANALYSIS_BASELINE`** ``` CREATE TABLE DEPENDENT_ANALYSIS_BASELINE (OWNER VARCHAR2(128 BYTE) NOT NULL ENABLE, OBJECT_NAME VARCHAR2(128 BYTE) NOT NULL ENABLE, OBJECT_TYPE VARCHAR2(20 BYTE), DEPEDNCY_LEVEL NUMBER, PROJECT_NEED VARCHAR2(20 BYTE), CATAGORY VARCHAR2(4000 BYTE), COMMENTS VARCHAR2(4000 BYTE), CATAGORY1 CLOB, COMMENTS1 CLOB, CUSTOMER_COMMENTS VARCHAR2(1000 BYTE), BACKFILL_TO_GUS VARCHAR2(1000 BYTE), BACKFILL_NEAR_REAL_TIME_OR_BATCH VARCHAR2(1000 BYTE), PK_EXISTS VARCHAR2(3 BYTE), UI_EXISTS VARCHAR2(3 BYTE), LOB_EXISTS VARCHAR2(3 BYTE), MASTER_LINK VARCHAR2(100 BYTE), CONSTRAINT PK_DEPENDENT_ANALYSIS_BASELINE PRIMARY KEY (OWNER,OBJECT_NAME,OBJECT_TYPE)); ``` **Verfahren für `SP_WRITER_OBJECTS_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_WRITER_OBJECTS_ANALYSIS IS BEGIN EXECUTE IMMEDIATE 'TRUNCATE TABLE TABLE_WRITE_OBJECT_DETAILS'; FOR I IN (SELECT OWNER, OBJECT_NAME FROM DEPENDENT_ANALYSIS_BASELINE WHERE OBJECT_TYPE = 'TABLE') LOOP INSERT INTO TABLE_WRITE_OBJECT_DETAILS(OWNER, TABLE_NAME, WRITEOBJ_OWNER, WRITEOBJ_NAME, WRITEOBJ_TYPE, LINE, TEXT) SELECT DISTINCT I.OWNER, I.OBJECT_NAME, OWNER WRITEOBJ_OWNER, NAME, TYPE, LINE, TRIM(TEXT) FROM DBA_SOURCE WHERE UPPER(TEXT) LIKE '%' || I.OBJECT_NAME || '%' AND (UPPER(TEXT) LIKE '%INSERT%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%UPDATE%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%DELETE%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%UPSERT%' || I.OBJECT_NAME || '%' OR UPPER(TEXT) LIKE '%MERGE%' || I.OBJECT_NAME || '%') AND UPPER(TEXT) NOT LIKE '%PROCEDURE%' AND UPPER(TEXT) NOT LIKE 'PROCEDURE%' AND UPPER(TEXT) NOT LIKE '%FUNCTION%' AND UPPER(TEXT) NOT LIKE 'FUNCTION%' AND UPPER(TEXT) NOT LIKE '%TRIGGER%' AND UPPER(TEXT) NOT LIKE 'TRIGGER%' AND UPPER(TRIM(TEXT)) NOT LIKE '%AFTER UPDATE%' AND UPPER(TRIM(TEXT)) NOT LIKE 'BEFORE UPDATE%' AND UPPER(TRIM(TEXT)) NOT LIKE 'BEFORE INSERT%' AND UPPER(TRIM(TEXT)) NOT LIKE 'AFTER INSERT%' AND UPPER(TRIM(TEXT)) NOT LIKE 'BEFORE DELETE%' AND UPPER(TRIM(TEXT)) NOT LIKE 'AFTER DELETE%' AND UPPER(TRIM(TEXT)) NOT LIKE '%GGLOGADM.GG_LOG_ERROR%' AND (TRIM(TEXT) NOT LIKE '/*%' AND TRIM(TEXT) NOT LIKE '--%' ) AND (OWNER, NAME, TYPE) IN (SELECT OWNER, NAME, TYPE FROM DBA_DEPENDENCIES WHERE REFERENCED_NAME = I.OBJECT_NAME); END LOOP; END; ``` **Skript für `SP_READER_OBJECTS_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_READER_OBJECTS_ANALYSIS IS BEGIN EXECUTE IMMEDIATE 'TRUNCATE TABLE TABLE_READ_OBJECT_DETAILS'; FOR I IN (SELECT OWNER, OBJECT_NAME FROM DEPENDENT_ANALYSIS_BASELINE WHERE OBJECT_TYPE = 'TABLE') LOOP INSERT INTO TABLE_READ_OBJECT_DETAILS SELECT DISTINCT i.owner, i.object_name, owner, name, type FROM dba_dependencies WHERE referenced_name = I.OBJECT_NAME AND referenced_type = 'TABLE' AND type NOT IN ('SYNONYM', 'MATERIALIZED VIEW', 'VIEW') AND (owner, name, type) NOT IN ( SELECT DISTINCT owner, trigger_name, 'TRIGGER' FROM dba_triggers WHERE table_name = I.OBJECT_NAME AND table_owner = i.owner UNION ALL SELECT DISTINCT owner, name, type FROM dba_source WHERE upper(text) LIKE '%' || I.OBJECT_NAME || '%' AND (upper(text) LIKE '%INSERT %' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%UPDATE% ' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%DELETE %' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%UPSERT %' || I.OBJECT_NAME || '%' OR upper(text) LIKE '%MERGE %' || I.OBJECT_NAME || '%') AND upper(text) NOT LIKE '%PROCEDURE %' AND upper(text) NOT LIKE 'PROCEDURE %' AND upper(text) NOT LIKE '%FUNCTION %' AND upper(text) NOT LIKE 'FUNCTION %' AND upper(text) NOT LIKE '%TRIGGER %' AND upper(text) NOT LIKE 'TRIGGER %' AND upper(trim(text)) NOT LIKE 'BEFORE INSERT %' AND upper(trim(text)) NOT LIKE 'BEFORE UPDATE %' AND upper(trim(text)) NOT LIKE 'BEFORE DELETE %' AND upper(trim(text)) NOT LIKE 'AFTER INSERT %' AND upper(trim(text)) NOT LIKE 'AFTER UPDATE %' AND upper(trim(text)) NOT LIKE 'AFTER DELETE %' AND (trim(text) NOT LIKE '/*%' AND trim(text) NOT LIKE '--%')); END LOOP; END; ``` **Drehbuch für `SP_OBJECT_REFERENTIAL_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_OBJECT_REFERENTIAL_ANALYSIS IS BEGIN EXECUTE IMMEDIATE 'TRUNCATE TABLE REFERENTIAL_ANALYSIS_BASELINE'; INSERT INTO REFERENTIAL_ANALYSIS_BASELINE WITH rel AS ( SELECT DISTINCT c.owner, c.table_name, c.r_owner r_owner, (SELECT table_name FROM dba_constraints WHERE constraint_name = c.r_constraint_name AND owner = c.r_owner) r_table_name FROM dba_constraints c WHERE constraint_type = 'R' AND c.owner NOT IN (SELECT username FROM dba_users WHERE oracle_maintained = 'Y') AND c.r_owner NOT IN (SELECT username FROM dba_users WHERE oracle_maintained = 'Y')), tab_list AS ( SELECT OWNER, object_name FROM DEPENDENT_ANALYSIS_BASELINE WHERE UPPER(OBJECT_TYPE) = 'TABLE') SELECT DISTINCT owner child_owner, table_name child, r_owner parent_owner, r_table_name parent, SYS_CONNECT_BY_PATH(r_table_name, ' -> ') || ' -> ' || table_name PATH FROM rel START WITH (r_owner, r_table_name) IN (SELECT * FROM tab_list) CONNECT BY NOCYCLE (r_owner, r_table_name) = ((PRIOR owner, PRIOR table_name)) UNION SELECT DISTINCT owner child_owner, table_name child, r_owner parent_owner, r_table_name parent, SYS_CONNECT_BY_PATH(table_name, ' -> ') || ' -> ' || r_table_name PATH FROM rel START WITH (owner, table_name) IN (SELECT * FROM tab_list) CONNECT BY NOCYCLE (owner, table_name) = ((PRIOR r_owner, PRIOR r_table_name)); END; ``` **Drehbuch für `SP_OBJECT_PRIVS_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_OBJECT_PRIVS_ANALYSIS IS V_SQL VARCHAR2(4000); V_CNT NUMBER; BEGIN V_SQL := 'TRUNCATE TABLE OBJECT_PRIVS_ANALYSIS'; EXECUTE IMMEDIATE V_SQL; FOR I IN (SELECT OWNER, OBJECT_NAME FROM DEPENDENT_ANALYSIS_BASELINE WHERE OBJECT_TYPE = 'TABLE') LOOP INSERT INTO OBJECT_PRIVS_ANALYSIS(OWNER, OBJECT_NAME, USER_NAME, PRIVS) WITH obj_to_role AS ( SELECT DISTINCT GRANTEE role_name, DECODE(privilege, 'SELECT', 'READ', 'REFERENCE', 'READ', 'INSERT', 'WRITE', 'UPDATE', 'WRITE', 'DELETE', 'WRITE', privilege) privs FROM DBA_TAB_PRIVS t, DBA_ROLES r WHERE OWNER = I.OWNER AND TYPE = 'TABLE' AND TABLE_NAME = I.OBJECT_NAME AND t.GRANTEE = r.ROLE AND r.ROLE IN (SELECT ROLE FROM DBA_ROLES WHERE ORACLE_MAINTAINED = 'N') ) SELECT I.OWNER, I.OBJECT_NAME, grantee, privs FROM ( -- Recursively Role to User mapping with privilege SELECT DISTINCT grantee, privs FROM (SELECT rp.granted_role, rp.grantee, privs, (SELECT DECODE(COUNT(*), 0, 'ROLE', 'USER') FROM (SELECT 'User' FROM DBA_users WHERE username = rp.GRANTEE)) grantee_type FROM DBA_role_privs rp, obj_to_role r WHERE rp.granted_role = r.role_name AND grantee IN ((SELECT USERNAME FROM DBA_USERS WHERE ORACLE_MAINTAINED = 'N') UNION (SELECT ROLE FROM DBA_ROLES WHERE ORACLE_MAINTAINED = 'N')) AND granted_role IN (SELECT ROLE FROM DBA_ROLES WHERE ORACLE_MAINTAINED = 'N') START WITH granted_role IN (SELECT DISTINCT role_name FROM obj_to_role) CONNECT BY granted_role = PRIOR grantee) WHERE grantee_type = 'USER' ) UNION ( -- Direct Object grants to User SELECT I.OWNER, I.OBJECT_NAME, GRANTEE, DECODE(privilege, 'SELECT', 'READ', 'REFERENCE', 'READ', 'INSERT', 'WRITE', 'UPDATE', 'WRITE', 'DELETE', 'WRITE', privilege) privs FROM DBA_TAB_PRIVS, DBA_USERS WHERE GRANTEE = USERNAME AND OWNER = I.OWNER AND TYPE = 'TABLE' AND TABLE_NAME = I.OBJECT_NAME ) ORDER BY 2 DESC; END LOOP; END; ``` **Verfahren für `SP_OBJECT_DEPENDENCY_ANALYSIS`** ``` CREATE OR REPLACE PROCEDURE SP_OBJECT_DEPENDENCY_ANALYSIS (v_level NUMBER) IS TYPE typ IS RECORD ( schema VARCHAR2(100), obj_type VARCHAR2(100), obj_name VARCHAR2(100), path VARCHAR2(5000) ); TYPE array IS TABLE OF typ; l_data array; c SYS_REFCURSOR; l_errors NUMBER; l_errno NUMBER; l_msg VARCHAR2(4000); l_idx NUMBER; l_level NUMBER; BEGIN l_level := v_level + 1; OPEN c FOR WITH obj_list AS ( SELECT owner schema_name, object_type, object_name FROM DEPENDENT_ANALYSIS_BASELINE WHERE depedncy_level = v_level ), fw_dep_objects AS ( SELECT level lvl, owner, name, type, referenced_owner, referenced_name, referenced_type, SYS_CONNECT_BY_PATH(name, ' -> ') || ' -> ' || referenced_name PATH FROM dba_dependencies START WITH (owner, CASE WHEN type = 'PACKAGE BODY' THEN 'PACKAGE' ELSE type END, name) IN (SELECT schema_name, object_type, object_name FROM obj_list) CONNECT BY NOCYCLE (owner, type, name) = ((PRIOR referenced_owner, PRIOR referenced_type, PRIOR referenced_name)) ), bw_dep_objects AS ( SELECT level lvl, owner, name, type, referenced_owner, referenced_name, referenced_type, SYS_CONNECT_BY_PATH(name, ' <- ') || ' <- ' || referenced_name PATH FROM dba_dependencies START WITH (referenced_owner, CASE WHEN referenced_type = 'PACKAGE BODY' THEN 'PACKAGE' ELSE referenced_type END, referenced_name) IN (SELECT schema_name, object_type, object_name FROM obj_list) CONNECT BY NOCYCLE (referenced_owner, referenced_type, referenced_name) = ((PRIOR owner, PRIOR type, PRIOR name)) ) SELECT * FROM ( (SELECT DISTINCT referenced_owner schema, referenced_type obj_type, referenced_name obj_name, path FROM fw_dep_objects) UNION (SELECT DISTINCT owner schema, type obj_type, name obj_name, path FROM bw_dep_objects) ) WHERE schema IN (SELECT username FROM all_users WHERE oracle_maintained = 'N') ORDER BY obj_type; LOOP FETCH c BULK COLLECT INTO l_data LIMIT 100; BEGIN FORALL i IN 1..l_data.count SAVE EXCEPTIONS INSERT INTO DEPENDENT_ANALYSIS_BASELINE ( owner, object_name, object_type, catagory, depedncy_level, project_need, comments ) VALUES ( l_data(i).schema, l_data(i).obj_name, CASE WHEN l_data(i).obj_type = 'PACKAGE BODY' THEN 'PACKAGE' ELSE l_data(i).obj_type END, 'level ' || l_level || ' dependency', l_level, '', 'from dependency proc' || l_data(i).path ); EXCEPTION WHEN OTHERS THEN l_errors := sql%bulk_exceptions.count; FOR i IN 1..l_errors LOOP l_errno := sql%bulk_exceptions(i).error_code; l_msg := SQLERRM(-l_errno); l_idx := sql%bulk_exceptions(i).error_index; UPDATE DEPENDENT_ANALYSIS_BASELINE SET catagory1 = catagory1 || ', found in level' || l_level || ' dependent of ' || l_data(l_idx).path, comments1 = comments1 || ', from dependency proc exception ' || l_data(i).path WHERE owner = l_data(l_idx).schema AND object_name = l_data(l_idx).obj_name AND object_type = l_data(l_idx).obj_type; END LOOP; END; EXIT WHEN c%NOTFOUND; END LOOP; CLOSE c; END; ``` # Beurteilen Sie die Abfrageleistung für die Migration von SQL Server-Datenbanken zu MongoDB Atlas auf AWS *Battulga Purevragchaa, Amazon Web Services* *Krishnakumar Sathyanarayana PeerIslands , USA Inc* *Babu Srinivasan, MongoDB* ## Zusammenfassung Dieses Muster bietet Anleitungen zum Laden von MongoDB mit nahezu realen Daten und zur Bewertung der MongoDB-Abfrageleistung, die dem Produktionsszenario so nahe wie möglich kommt. Die Bewertung liefert Informationen, die Ihnen bei der Planung Ihrer Migration von einer relationalen Datenbank zu MongoDB helfen. Das Muster verwendet [PeerIslands Test Data Generator und Performance Analyzer](https://tools.peerislands.io/), um die Abfrageleistung zu testen. Dieses Muster ist besonders nützlich für die Migration von Microsoft SQL Server zu MongoDB, da das Durchführen von Schematransformationen und das Laden von Daten aus aktuellen SQL Server-Instanzen nach MongoDB sehr komplex sein kann. Stattdessen können Sie nahezu reale Daten in MongoDB laden, die MongoDB-Leistung verstehen und das Schemadesign verfeinern, bevor Sie mit der eigentlichen Migration beginnen. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto + Vertrautheit mit [MongoDB Atlas](https://www.mongodb.com/docs/atlas/getting-started/) + MongoDB-Zielschema + Typische Abfragemuster **Einschränkungen** + Die Ladezeiten und die Leistung von Daten werden durch die Größe der MongoDB-Clusterinstanz begrenzt. Wir empfehlen Ihnen, Instances auszuwählen, die für den Produktionseinsatz empfohlen werden, um die Leistung in der Praxis zu verstehen. + PeerIslands Test Data Generator und Performance Analyzer unterstützen derzeit nur Online-Datenladungen und -abfragen. Die Offline-Batchverarbeitung (z. B. das Laden von Daten in MongoDB mithilfe von Spark-Konnektoren) wird noch nicht unterstützt. + PeerIslands Test Data Generator und Performance Analyzer unterstützen Feldbeziehungen innerhalb einer Sammlung. Es unterstützt keine Beziehungen zwischen Sammlungen. **Produkteditionen** + Dieses Muster unterstützt sowohl [MongoDB Atlas](https://www.mongodb.com/atlas) als auch [MongoDB Enterprise Advanced](https://www.mongodb.com/products/mongodb-enterprise-advanced). ## Architektur **Zieltechnologie-Stack** + MongoDB Atlas oder MongoDB Enterprise Advanced **Architektur** ![\[Architektur zur Bewertung der Abfrageleistung für die Migration der SQL Server-Datenbank zu MongoDB Atlas auf AWS.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/25f0ab73-d587-4bd0-9fc0-ac675d5aa349/images/717caae4-d52e-4c78-bb7d-2ecb5acccd42.png) PeerIslands Test Data Generator and Performance Analyzer wurde mithilfe von Java und Angular erstellt und speichert die generierten Daten im Amazon Elastic Block Store (Amazon EBS). Das Tool besteht aus zwei Workflows: Generierung von Testdaten und Leistungstests. + Bei der Testdatengenerierung erstellen Sie eine Vorlage, bei der es sich um die JSON-Darstellung des Datenmodells handelt, das generiert werden muss. Nachdem Sie die Vorlage erstellt haben, können Sie die Daten in einer Zielsammlung generieren, wie in der Konfiguration zur Ladegenerierung definiert. + Bei Leistungstests erstellen Sie ein Profil. Ein Profil ist ein mehrstufiges Testszenario, in dem Sie CRUD-Operationen (Create, Lese, Update and Delete), Aggregationspipelines, die Gewichtung für jeden Vorgang und die Dauer jeder Phase konfigurieren können. Nachdem Sie das Profil erstellt haben, können Sie auf der Grundlage der Konfiguration Leistungstests für die Zieldatenbank ausführen. PeerIslands Test Data Generator and Performance Analyzer speichert seine Daten auf Amazon EBS, sodass Sie Amazon EBS mit MongoDB verbinden können, indem Sie jeden von MongoDB unterstützten Verbindungsmechanismus verwenden, einschließlich Peering, Zulassungslisten und privaten Endpunkten. Standardmäßig enthält das Tool keine Betriebskomponenten. Es kann jedoch bei Bedarf mit Amazon Managed Service for Prometheus, Amazon Managed Grafana CloudWatch, Amazon und AWS Secrets Manager konfiguriert werden. ## Tools + [PeerIslands Test Data Generator und Performance Analyzer bestehen](https://tools.peerislands.io/) aus zwei Komponenten. Die Komponente Test Data Generator hilft Ihnen dabei, hochgradig kundenspezifische, reale Daten auf der Grundlage Ihres MongoDB-Schemas zu generieren. Das Tool ist vollständig UI-gesteuert und verfügt über eine umfangreiche Datenbibliothek. Es kann verwendet werden, um schnell Milliarden von Datensätzen auf MongoDB zu generieren. Das Tool bietet auch Funktionen zum Implementieren von Beziehungen zwischen Feldern im MongoDB-Schema. Die Performance Analyzer-Komponente hilft Ihnen dabei, hochgradig kundenspezifische Abfragen und Aggregationen zu generieren und realistische Leistungstests auf MongoDB durchzuführen. Sie können den Performance Analyzer verwenden, um die MongoDB-Leistung mit umfangreichen Lastprofilen und parametrisierten Abfragen für Ihren speziellen Anwendungsfall zu testen. ## Best Practices Weitere Informationen finden Sie in den folgenden Ressourcen: + [Bewährte Methoden für das MongoDB-Schemadesign](https://www.mongodb.com/developer/products/mongodb/mongodb-schema-design-best-practices/) (MongoDB-Entwickler-Website) + [Bewährte Methoden für die Bereitstellung von MongoDB Atlas auf AWS](https://www.mongodb.com/presentation/best-practices-of-deploying-mongodb-atlas-on-aws) (MongoDB-Website) + [Sicheres Verbinden von Anwendungen mit einer MongoDB Atlas-Datenebene mit AWS PrivateLink (AWS-Blogbeitrag](https://aws.amazon.com/blogs/apn/connecting-applications-securely-to-a-mongodb-atlas-data-plane-with-aws-privatelink/)) + [Leitfaden mit bewährten Methoden für die Leistung von MongoDB](https://www.mongodb.com/basics/best-practices) (MongoDB-Website) ## Epen ### Verstehen Sie Ihre Quelldaten | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Machen Sie sich mit dem Datenbank-Footprint der aktuellen SQL Server-Quelle vertraut. | Machen Sie sich mit Ihrem aktuellen SQL Server-Footprint vertraut. Dies kann erreicht werden, indem Abfragen anhand des `INFORMATION` Datenbankschemas ausgeführt werden. Ermitteln Sie die Anzahl der Tabellen und die Größe jeder Tabelle. Analysieren Sie den Index, der jeder Tabelle zugeordnet ist. Weitere Informationen zur SQL-Analyse finden Sie im Blogbeitrag [SQL2Mongo: Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) auf der PeerIslands Website. | DBA | | Verstehen Sie das Quellschema. | Ermitteln Sie das Tabellenschema und die geschäftliche Darstellung der Daten (z. B. Postleitzahlen, Namen und Währung). Verwenden Sie Ihr vorhandenes Entitätsbeziehungsdiagramm (ER) oder generieren Sie das ER-Diagramm aus der vorhandenen Datenbank. Weitere Informationen finden Sie im Blogbeitrag [SQL2Mongo: Data Migration Journey](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) auf der PeerIslands Website. | DBA | | Verstehen Sie Abfragemuster. | Dokumentieren Sie die 10 am häufigsten verwendeten SQL-Abfragen. Sie können die Tabellen **performance\$1schema.events\$1statements\$1summary\$1by\$1digest** verwenden, die in der Datenbank verfügbar sind, um die häufigsten Abfragen zu verstehen. [Weitere Informationen finden Sie im Blogbeitrag Mongo: Data Migration Journey auf der Website. SQL2](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) PeerIslands | DBA | | Machen Sie sich mit den SLA-Verpflichtungen vertraut. | Dokumentieren Sie die angestrebten Service Level Agreements (SLAs) für Datenbankoperationen. Zu den typischen Messgrößen gehören Abfragelatenz und Abfragen pro Sekunde. Die Maßnahmen und ihre Ziele sind in der Regel in Dokumenten zu den nichtfunktionalen Anforderungen (NFR) enthalten. | DBA | ### Definieren Sie das MongoDB-Schema | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Definieren Sie das Zielschema. | Definieren Sie verschiedene Optionen für das MongoDB-Zielschema. Weitere Informationen finden Sie unter [Schemas](https://www.mongodb.com/docs/atlas/app-services/schemas/) in der MongoDB Atlas-Dokumentation. Beachten Sie die bewährten Methoden und Entwurfsmuster, die auf den Tabellenbeziehungen basieren. | MongoDB-Ingenieur | | Definieren Sie Zielabfragemuster. | Definieren Sie MongoDB-Abfragen und Aggregationspipelines. Diese Abfragen entsprechen den häufigsten Abfragen, die Sie für Ihre SQL Server-Arbeitslast erfasst haben. [Informationen zum Aufbau von MongoDB-Aggregationspipelines finden Sie in der MongoDB-Dokumentation.](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) | MongoDB-Ingenieur | | Definieren Sie den MongoDB-Instanztyp. | Ermitteln Sie die Größe der Instanz, die Sie zum Testen verwenden möchten. Anleitungen finden Sie in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/sizing-tier-selection/). | MongoDB-Ingenieur | ### Bereiten Sie die Zieldatenbank vor | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Richten Sie den MongoDB Atlas-Cluster ein. | Folgen Sie den Anweisungen in der MongoDB-Dokumentation, um einen [MongoDB-Cluster](https://www.mongodb.com/docs/atlas/tutorial/create-new-cluster/) auf AWS einzurichten. | MongoDB-Ingenieur | | Erstellen Sie Benutzer in der Zieldatenbank. | Konfigurieren Sie den MongoDB Atlas-Cluster für Zugriffs- und Netzwerksicherheit, indem Sie den Anweisungen in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/connect-to-database-deployment/) folgen. | MongoDB-Ingenieur | | Erstellen Sie entsprechende Rollen in AWS und konfigurieren Sie die rollenbasierte Zugriffskontrolle für Atlas. | Richten Sie bei Bedarf weitere Benutzer ein, indem Sie den Anweisungen in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/security/set-up-unified-aws-access/) folgen. Konfigurieren Sie [Authentifizierung und Autorisierung](https://www.mongodb.com/docs/atlas/security/config-db-auth/) über AWS-Rollen. | MongoDB-Ingenieur | | Richten Sie Compass für den MongoDB Atlas-Zugriff ein. | Richten Sie das [MongoDB Compass GUI Utility](https://www.mongodb.com/products/compass) ein, um die Navigation und den Zugriff zu vereinfachen. | MongoDB-Ingenieur | ### Richten Sie die Grundlast mithilfe von Test Data Generator ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Installieren Sie den Testdatengenerator. | Installieren Sie [PeerIsland Test Data Generator](https://github.com/PeerIslands/loadgen_binary) in Ihrer Umgebung. | MongoDB-Ingenieur | | Konfigurieren Sie den Testdatengenerator, um die entsprechenden Daten zu generieren. | Erstellen Sie eine Vorlage, indem Sie die Datenbibliothek verwenden, um spezifische Daten für jedes Feld im MongoDB-Schema zu generieren. Weitere Informationen finden Sie unter [MongoDB Data Generator & Perf. Videoanalysator](https://vimeo.com/570068857). | MongoDB-Ingenieur | | Skalieren Sie den Testdatengenerator horizontal, um die erforderliche Last zu generieren. | Verwenden Sie die von Ihnen erstellte Vorlage, um die Lastgenerierung für die Zielsammlung zu starten, indem Sie die erforderliche Parallelität konfigurieren. Legen Sie die Zeitrahmen und den Umfang für die Generierung der erforderlichen Daten fest. | MongoDB-Ingenieur | | Überprüfen Sie die Ladung in MongoDB Atlas. | Überprüfen Sie die in MongoDB Atlas geladenen Daten. | MongoDB-Ingenieur | | Generieren Sie die erforderlichen Indizes auf MongoDB. | Definieren Sie Indizes nach Bedarf auf der Grundlage von Abfragemustern. Bewährte Methoden finden Sie in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/manual/applications/indexes/). | MongoDB-Ingenieur | ### Führen Sie Leistungstests durch | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Richten Sie Lastprofile in Performance Analyzer ein. | Erstellen Sie ein Leistungstestprofil in Performance Analyzer, indem Sie spezifische Abfragen und deren entsprechende Gewichtung, Dauer des Testlaufs und Phasen konfigurieren. Weitere Informationen finden Sie unter [MongoDB Data Generator & Perf. Videoanalysator](https://vimeo.com/570068857). | MongoDB-Ingenieur | | Führen Sie Leistungstests durch. | Verwenden Sie das von Ihnen erstellte Leistungstestprofil, um den Test anhand der Zielsammlung zu starten, indem Sie die erforderliche Parallelität konfigurieren. Skalieren Sie das Leistungstest-Tool horizontal, um Abfragen gegen MongoDB Atlas auszuführen. | MongoDB-Ingenieur | | Testergebnisse aufzeichnen. | Zeichnen Sie die P95- und P99-Latenz für die Abfragen auf. | MongoDB-Ingenieur | | Optimieren Sie Ihr Schema und Ihre Abfragemuster. | Ändern Sie Indizes und Abfragemuster, um Leistungsprobleme zu beheben. | MongoDB-Ingenieur | ### Schließe das Projekt | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Fahren Sie temporäre AWS-Ressourcen herunter. | Löschen Sie alle temporären Ressourcen, die Sie für Test Data Generator und Performance Analyzer verwendet haben. | AWS-Administrator | | Aktualisieren Sie die Ergebnisse der Leistungstests. | Verstehen Sie die Leistung von MongoDB-Abfragen und vergleichen Sie sie mit Ihrer SLAs. Passen Sie bei Bedarf das MongoDB-Schema an und führen Sie den Vorgang erneut aus. | MongoDB-Ingenieur | | Schließe das Projekt ab. | Schließen Sie das Projekt ab und geben Sie Feedback. | MongoDB-Ingenieur | ## Zugehörige Ressourcen + GitHub [Repositorium: S3ToAtlas](https://github.com/mongodb-partners/S3toAtlas) + Schema: [MongoDB-Schemadesign](https://www.mongodb.com/developer/products/mongodb/mongodb-schema-design-best-practices/) + Aggregationspipelines: [MongoDB-Aggregationspipelines](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) + MongoDB Atlas Sizing: Auswahl [der Größenstufen](https://www.mongodb.com/docs/atlas/sizing-tier-selection/) + Video: [MongoDB-Datengenerator](https://vimeo.com/570068857) und Perf. Analysator + Referenzen: [MongoDB-Dokumentation](https://www.mongodb.com/docs/) + Tutorials:**** [MongoDB-Entwicklerhandbuch,](https://www.mongodb.com/docs/develop-applications/) [MongoDB](https://www.youtube.com/playlist?list=PL4RCxklHWZ9v2lcat4oEVGQhZg6r4IQGV) Jumpstart + AWS Marketplace:**** [MongoDB Atlas auf AWS](https://aws.amazon.com/marketplace/seller-profile?id=c9032c7b-70dd-459f-834f-c1e23cf3d092) Marketplace + AWS-Partnerlösungen:**** [MongoDB Atlas auf AWS-Referenzbereitstellung](https://aws.amazon.com/quickstart/architecture/mongodb-atlas/) Weitere Ressourcen: + [SQL-Analyse](https://engineering.peerislands.io/sql2mongo-data-migration-journey-fec91a421d60) + [Foren der MongoDB-Entwickler-Community](https://www.mongodb.com/community/forums/) + [Fragen zur MongoDB-Leistungsoptimierung](https://www.mongodb.com/developer/products/mongodb/performance-tuning-tips/) + [Operational Analytics mit Atlas und Redshift](https://github.com/mongodb-partners/Atlas_to_Redshift) + [Anwendungsmodernisierung mit MongoDB Atlas und AWS Elastic Beanstalk](https://github.com/mongodb-partners/MEANStack_with_Atlas_on_AWS_EB) # Automatisieren Sie blue/green die Bereitstellung globaler Amazon Aurora Aurora-Datenbanken mithilfe von IaC-Prinzipien *Ishwar Chauthaiwale, ANKIT JAIN und Ramu Jagini, Amazon Web Services* ## Zusammenfassung Die Verwaltung von Datenbank-Updates, Migrationen oder Skalierungsmaßnahmen kann für Unternehmen, die kritische Workloads auf globalen [Amazon Aurora Aurora-Datenbanken](https://aws.amazon.com/rds/aurora/global-database/) ausführen, eine Herausforderung darstellen. Die Sicherstellung, dass diese Vorgänge reibungslos und ohne Ausfallzeiten ausgeführt werden, ist für die Aufrechterhaltung der Serviceverfügbarkeit und die Vermeidung von Unterbrechungen für Ihre Benutzer von entscheidender Bedeutung. Eine blue/green Bereitstellungsstrategie bietet eine Lösung für dieses Problem, da Sie zwei identische Umgebungen gleichzeitig ausführen können: blau (die aktuelle Umgebung) und grün (die neue Umgebung). Eine blue/green Strategie ermöglicht es Ihnen, Änderungen zu implementieren, Tests durchzuführen und den Datenverkehr zwischen Umgebungen mit minimalem Risiko und minimalen Ausfallzeiten zu verlagern. Dieses Muster hilft Ihnen, den blue/green Bereitstellungsprozess für globale Aurora-Datenbanken zu automatisieren, indem Sie die Prinzipien von Infrastructure as Code (IaC) verwenden. Es verwendet [AWS CloudFormation[AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html), und [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html), um blue/green Bereitstellungen zu vereinfachen. Um die Zuverlässigkeit zu verbessern, verwendet es globale Transaktions-Identifikatoren (GTIDs) für die Replikation. Die GTID-basierte Replikation bietet im Vergleich zur Replikation von Binärprotokollen (Binlog) eine bessere Datenkonsistenz und Failover-Funktionen zwischen Umgebungen. **Anmerkung** Bei diesem Muster wird davon ausgegangen, dass Sie einen globalen Datenbankcluster der Aurora MySQL-Compatible Edition verwenden. Wenn Sie stattdessen Aurora PostgreSQL-kompatibel verwenden, verwenden Sie bitte die PostgreSQL-Entsprechungen der MySQL-Befehle. Wenn Sie den Schritten in diesem Muster folgen, können Sie: + Stellen Sie eine grüne globale Aurora-Datenbank bereit: Mithilfe von CloudFormation Vorlagen erstellen Sie eine grüne Umgebung, die Ihre bestehende blaue Umgebung widerspiegelt. + GTID-basierte Replikation einrichten: Sie konfigurieren die GTID-Replikation so, dass die blauen und grünen Umgebungen synchronisiert bleiben. + Nahtloses Umschalten des Datenverkehrs: Sie verwenden Route 53 und Lambda, um den Verkehr nach der vollständigen Synchronisation automatisch von der blauen in die grüne Umgebung umzuschalten. + Schließen Sie die Bereitstellung ab: Sie überprüfen, ob die grüne Umgebung als primäre Datenbank voll funktionsfähig ist, beenden dann die Replikation und bereinigen alle temporären Ressourcen. Der Ansatz in diesem Muster bietet die folgenden Vorteile: + Reduziert Ausfallzeiten bei wichtigen Datenbankaktualisierungen oder Migrationen: Die Automatisierung gewährleistet einen reibungslosen Übergang zwischen Umgebungen mit minimalen Serviceunterbrechungen. + Ermöglicht schnelle Rollbacks: Wenn nach der Umstellung des Datenverkehrs auf die grüne Umgebung ein Problem auftritt, können Sie schnell zur blauen Umgebung zurückkehren und die Servicekontinuität aufrechterhalten. + Verbessert das Testen und Überprüfen: Die grüne Umgebung kann vollständig getestet werden, ohne dass die Live-Blue-Umgebung beeinträchtigt wird, wodurch die Wahrscheinlichkeit von Produktionsfehlern verringert wird. + Sorgt für Datenkonsistenz: Die GTID-basierte Replikation sorgt dafür, dass Ihre blauen und grünen Umgebungen synchron bleiben, wodurch Datenverlust oder Inkonsistenzen während der Migration vermieden werden. + Sorgt für Geschäftskontinuität: Durch die Automatisierung Ihrer blue/green Bereitstellungen können Sie lange Ausfälle und finanzielle Verluste vermeiden, da Ihre Dienste auch bei Updates oder Migrationen verfügbar bleiben. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + AWS-Konto Ein aktiver. + Ein mit Aurora MySQL kompatibler globaler Quelldatenbankcluster (blaue Umgebung). Globale Datenbanken bieten eine Konfiguration mit mehreren Regionen für Hochverfügbarkeit und Notfallwiederherstellung. Anweisungen zum Einrichten eines globalen Datenbank-Clusters finden Sie in der [Aurora-Dokumentation](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html). + Die [GTID-basierte Replikation ist auf dem Quell-Cluster](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) aktiviert. **Einschränkungen** + Einige AWS-Services sind nicht in allen verfügbar. AWS-Regionen Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie [AWS-Services unter Nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie auf der Seite [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus. **Produktversionen** + Aurora MySQL-kompatibel 8.0 oder höher ## Architektur ![\[Mithilfe der GTID-Replikation werden blaue und grüne Umgebungen in verschiedenen Regionen synchronisiert.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/19922266-c2e5-460b-9a0f-22e6d6736094/images/7a8c3095-7904-4080-906f-0c403c289a4f.png) Das Diagramm veranschaulicht folgende Vorgänge: + Globales Datenbank-Setup: Ein globaler Aurora-Datenbankcluster wird strategisch in zwei Clustern eingesetzt AWS-Regionen. Diese Konfiguration ermöglicht eine geografische Verteilung und regionale Redundanz für verbesserte Disaster Recovery-Funktionen. + Replikation von primärer zu sekundärer Region: Der logische Replikationsmechanismus gewährleistet eine nahtlose Datensynchronisierung von der primären Region zur sekundären Region. Diese Replikation gewährleistet die Datenkonsistenz mit minimaler Latenz über geografische Entfernungen hinweg. + GTID-basierte Replikation zwischen Clustern: Die GTID-basierte Replikation gewährleistet die Transaktionskonsistenz und den geordneten Datenfluss zwischen dem blauen Primärcluster und dem grünen Primärcluster und gewährleistet eine zuverlässige Datensynchronisierung. + Blaue Primär- zu Sekundärreplikation: Die logische Replikation stellt eine robuste Datenpipeline zwischen dem blauen Primärcluster und seinem sekundären Cluster her. Diese Replikation ermöglicht eine kontinuierliche Datensynchronisierung und hohe Verfügbarkeit. + Route 53-DNS-Konfiguration: Route 53-Einträge für gehostete Zonen verwalten die DNS-Auflösung für alle blauen und grünen Cluster-Datenbank-Endpunkte. Diese Konfiguration ermöglicht eine nahtlose Zuordnung von Endpunkten und ermöglicht eine effiziente Weiterleitung des Datenverkehrs in Failover-Szenarien. ## Tools **AWS-Services** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) ist eine vollständig verwaltete relationale Datenbank-Engine, die für die Cloud entwickelt wurde und mit MySQL und PostgreSQL kompatibel ist. + [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)hilft Ihnen dabei, Ihre AWS Ressourcen zu modellieren und einzurichten, sodass Sie weniger Zeit mit der Verwaltung dieser Ressourcen verbringen und sich mehr auf Ihre Anwendungen konzentrieren können, auf denen sie ausgeführt werden. AWS Sie erstellen eine Vorlage, die alle AWS Ressourcen beschreibt, die Sie benötigen, und CloudFormation kümmert sich um die Bereitstellung und Konfiguration dieser Ressourcen für Sie. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)ist ein Rechendienst, der die Ausführung von Code unterstützt, ohne Server bereitzustellen oder zu verwalten. Lambda führt Ihren Code nur bei Bedarf aus und skaliert automatisch – von einigen Anforderungen pro Tag bis zu Tausenden pro Sekunde. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) ist ein hochverfügbarer und skalierbarer DNS-Web-Service. ## Best Practices Wir empfehlen Ihnen, die AWS Dokumentation gründlich zu lesen, um Ihr Verständnis der [Blau/Grün-Implementierungsstrategie](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-overview.html), der [GTID-basierten Replikation](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) und der [gewichteten](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) Routing-Richtlinien in Route 53 zu vertiefen. Dieses Wissen ist entscheidend für die effektive Implementierung und Verwaltung Ihrer Datenbankmigrationen, die Sicherstellung der Datenkonsistenz und die Optimierung des Datenverkehrs. Wenn Sie sich ein umfassendes Verständnis dieser AWS Funktionen und Best Practices aneignen, sind Sie besser gerüstet, um future Updates zu bewältigen, Ausfallzeiten zu minimieren und eine belastbare und sichere Datenbankumgebung aufrechtzuerhalten. Richtlinien für die Verwendung von AWS-Services für dieses Muster finden Sie in der folgenden AWS Dokumentation: + [Bewährte Methoden mit Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.BestPractices.html) + [CloudFormation bewährte Verfahren](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/best-practices.html) + [Bewährte Methoden für die Arbeit mit AWS Lambda Funktionen](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) + [Bewährte Methoden für Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/best-practices.html) ## Epen ### Schaffen Sie die grüne Umgebung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie ein Snapshot-Backup aus dem blauen Cluster. | In einer blue/green Bereitstellung steht die grüne Umgebung für eine neue, identische Version Ihrer aktuellen (blauen) Datenbankumgebung. Sie verwenden die grüne Umgebung, um Updates sicher zu testen, Änderungen zu validieren und die Stabilität sicherzustellen, bevor Sie den Produktionsdatenverkehr wechseln. Sie dient als Zwischenstation für die Implementierung von Datenbankänderungen bei minimaler Unterbrechung der Live-Umgebung.Um eine grüne Umgebung zu schaffen, erstellen Sie zunächst einen Snapshot des primären (blauen) Clusters in Ihrer Aurora MySQL-kompatiblen globalen Datenbank. Dieser Snapshot dient als Grundlage für die Schaffung einer grünen Umgebung.Um einen Snapshot zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Alternativ können Sie das AWS Command Line Interface (AWS CLI) verwenden, um den Snapshot zu erstellen:
(OWNER VARCHAR2(50 BYTE),
OBJECT_NAME VARCHAR2(50 BYTE),
USER_NAME VARCHAR2(50 BYTE),
PRIVS VARCHAR2(50 BYTE));
aws rds create-db-cluster-snapshot --db-cluster-snapshot-identifier blue-green-demo --db-cluster-identifier ex-global-cluster --region eu-west-1Stellen Sie sicher, dass der Snapshot erfolgreich abgeschlossen wurde, bevor Sie mit dem nächsten Schritt fortfahren. | DBA | | Generieren Sie die CloudFormation Vorlage für Ihre globale Datenbank und ihre Ressourcen. | Der CloudFormation IaC-Generator hilft Ihnen, CloudFormation Vorlagen aus vorhandenen AWS Ressourcen zu generieren. Verwenden Sie diese Funktion, um eine CloudFormation Vorlage für Ihre bestehende Aurora MySQL-kompatible globale Datenbank und die zugehörigen Ressourcen zu erstellen. Diese Vorlage konfiguriert Subnetzgruppen, Sicherheitsgruppen, Parametergruppen und andere Einstellungen.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html) | DBA | | Ändern Sie die CloudFormation Vorlage für die grüne Umgebung. | Passen Sie die CloudFormation Vorlage an die Einstellungen für die grüne Umgebung an. Dazu gehört die Aktualisierung der Ressourcennamen und -kennungen, um sicherzustellen, dass die grüne Umgebung unabhängig vom blauen Cluster funktioniert.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Wenn Sie die `SnapshotIdentifier` Eigenschaft verwenden, um einen DB-Cluster wiederherzustellen, vermeiden Sie es, Eigenschaften wie `GlobalClusterIdentifier``MasterUsername`, oder anzugeben`MasterUserPassword`. | DBA | | Stellen Sie den CloudFormation Stack bereit, um Ressourcen für eine grüne Umgebung zu schaffen. | In diesem Schritt stellen Sie die benutzerdefinierte CloudFormation Vorlage bereit, um die Ressourcen für die grüne Umgebung zu erstellen.So stellen Sie den CloudFormation Stack bereit:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)CloudFormation leitet den Prozess der Schaffung der Ressourcen für eine grüne Umwelt ein. Dieser Vorgang kann mehrere Minuten in Anspruch nehmen. | DBA | | Validieren Sie den CloudFormation Stack und die Ressourcen. | Wenn die CloudFormation Stack-Bereitstellung abgeschlossen ist, müssen Sie überprüfen, ob die grüne Umgebung erfolgreich erstellt wurde:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Nach der Überprüfung ist Ihre grüne Umgebung bereit für die weitere Einrichtung, einschließlich der Replikation aus der blauen Umgebung. | DBA | ### GTID-basierte Replikation konfigurieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Überprüfen Sie die GTID-Einstellungen auf dem blauen Cluster. | GTIDs bieten eine äußerst zuverlässige Methode für die Replikation von Daten zwischen Ihren blauen und grünen Umgebungen. Die [GTID-basierte Replikation](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) bietet einen robusten, vereinfachten Ansatz, bei dem jeder Transaktion in der blauen Umgebung eine eindeutige Kennung zugewiesen wird. Diese Methode stellt sicher, dass die Datensynchronisierung zwischen Umgebungen nahtlos, konsistent und einfacher zu verwalten ist als die herkömmliche Binlog-Replikation.Bevor Sie die Replikation konfigurieren, müssen Sie sicherstellen, dass die GTID-basierte Replikation auf dem blauen Cluster ordnungsgemäß aktiviert ist. Dieser Schritt garantiert, dass jede Transaktion in der blauen Umgebung eindeutig nachverfolgt wird und in der grünen Umgebung repliziert werden kann.Um zu überprüfen, ob GTID aktiviert ist:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Diese Einstellungen ermöglichen das GTID-Tracking für alle future Transaktionen in der blauen Umgebung. Nachdem Sie diese Einstellungen bestätigt haben, können Sie mit der Einrichtung der Replikation beginnen. | DBA | | Erstellen Sie einen Replikationsbenutzer. | Um Daten aus der blauen Umgebung in die grüne Umgebung zu replizieren, müssen Sie einen dedizierten Replikationsbenutzer auf dem blauen Cluster erstellen. Dieser Benutzer ist für die Verwaltung des Replikationsprozesses verantwortlich.So richten Sie den Replikationsbenutzer ein:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Dieser Benutzer verfügt jetzt über die erforderlichen Berechtigungen, um Daten zwischen den beiden Umgebungen zu replizieren. | DBA | | Konfigurieren Sie die GTID-basierte Replikation auf dem grünen Cluster. | Der nächste Schritt besteht darin, den grünen Cluster für die GTID-basierte Replikation zu konfigurieren. Dieses Setup stellt sicher, dass die grüne Umgebung kontinuierlich alle Transaktionen widerspiegelt, die in der blauen Umgebung stattfinden.Um den grünen Cluster zu konfigurieren:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html) | DBA | | Starten Sie die Replikation auf dem grünen Cluster. | Sie können jetzt den Replikationsprozess starten. Führen Sie auf dem grünen Cluster den folgenden Befehl aus:
START SLAVE;Dadurch kann die grüne Umgebung mit der Datensynchronisierung und dem Empfangen und Anwenden von Transaktionen aus der blauen Umgebung beginnen. | DBA | | Überprüfen Sie den Replikationsprozess. | Gehen Sie wie folgt vor, um zu überprüfen, ob die grüne Umgebung die Daten aus dem blauen Cluster korrekt repliziert:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Wenn alle Indikatoren korrekt sind, funktioniert die GTID-basierte Replikation reibungslos und die grüne Umgebung ist vollständig mit der blauen Umgebung synchronisiert. | DBA | ### Schalten Sie den Verkehr vom blauen auf den grünen Cluster um | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Konfigurieren Sie Richtlinien für gewichtetes Route-53-Routing. | Nachdem Sie die Datenkonsistenz zwischen der blauen und der grünen Umgebung überprüft haben, können Sie den Datenverkehr vom blauen Cluster auf den grünen Cluster umstellen. Dieser Übergang sollte reibungslos ablaufen, Ausfallzeiten minimieren und die Integrität der Datenbank Ihrer Anwendung sicherstellen. Um diesen Anforderungen gerecht zu werden, können Sie Route 53 für DNS-Routing und Lambda zur Automatisierung des Verkehrswechsels verwenden. Darüber hinaus stellt ein klar definierter Rollback-Plan sicher, dass Sie bei Problemen zum blauen Cluster zurückkehren können.Der erste Schritt besteht darin, gewichtetes Routing in Route 53 zu konfigurieren. Mit gewichtetem Routing können Sie die Verteilung des Datenverkehrs zwischen den blauen und grünen Clustern steuern und den Verkehr schrittweise von einer Umgebung in die andere verlagern.So konfigurieren Sie gewichtetes Routing:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Weitere Informationen zu Richtlinien für gewichtetes Routing finden Sie in der [Dokumentation zu Route 53.](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) | AWS DevOps | | Stellen Sie eine Lambda-Funktion bereit, um die Replikationsverzögerung zu überwachen. | Um sicherzustellen, dass die grüne Umgebung vollständig mit der blauen Umgebung synchronisiert ist, stellen Sie eine Lambda-Funktion bereit, die die Replikationsverzögerung zwischen den Clustern überwacht. Diese Funktion kann den Replikationsstatus, insbesondere die **Seconds\$1Behind\$1Master-Metrik**, überprüfen, um festzustellen, ob der grüne Cluster bereit ist, den gesamten Datenverkehr zu verarbeiten.Hier ist ein Beispiel für eine Lambda-Funktion, die Sie verwenden können:
import boto3Diese Funktion überprüft die Verzögerung bei der Replikation und gibt den Wert zurück. Wenn die Verzögerung Null ist, ist der grüne Cluster vollständig mit dem blauen Cluster synchronisiert. | AWS DevOps | | Automatisieren Sie die DNS-Gewichtsanpassung mithilfe von Lambda. | Wenn die Verzögerung bei der Replikation Null erreicht, ist es an der Zeit, den gesamten Datenverkehr auf den grünen Cluster umzustellen. Sie können diesen Übergang automatisieren, indem Sie eine weitere Lambda-Funktion verwenden, die die DNS-Gewichtungen in Route 53 so anpasst, dass 100 Prozent des Datenverkehrs an den grünen Cluster weitergeleitet werden.Hier ist ein Beispiel für eine Lambda-Funktion, die den Traffic Switch automatisiert:
def check_replication_lag(event, context):
client = boto3.client('rds')
response = client.describe_db_instances(DBInstanceIdentifier='green-cluster-instance')
replication_status = response['DBInstances'][0]['ReadReplicaDBInstanceIdentifiers']
if replication_status:
lag = replication_status[0]['ReplicationLag']
return lag
return -1
import boto3Diese Funktion überprüft die Replikationsverzögerung und aktualisiert die Route 53-DNS-Gewichtungen, wenn die Verzögerung Null ist, um den Datenverkehr vollständig auf den grünen Cluster umzuleiten.****Wenn während der Umstellung auf den blauen Cluster ein hoher Schreibverkehr auftritt, sollten Sie erwägen, die Schreibvorgänge während der Umstellung vorübergehend zu unterbrechen. Dadurch wird sichergestellt, dass die Replikation aufholt, und Dateninkonsistenzen zwischen den blauen und grünen Clustern werden vermieden. | AWS DevOps | | Überprüfen Sie den Traffic Switch. | Nachdem die Lambda-Funktion die DNS-Gewichtungen angepasst hat, sollten Sie überprüfen, ob der gesamte Datenverkehr an den grünen Cluster geleitet wird und ob der Switch erfolgreich war.Um zu überprüfen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Wenn alles wie erwartet funktioniert, ist der Traffic Switch abgeschlossen. | AWS DevOps | | Wenn Sie auf Probleme stoßen, machen Sie die Änderungen rückgängig. | Ein Rollback-Plan ist entscheidend für den Fall, dass nach dem Verkehrswechsel Probleme auftreten. So können Sie bei Bedarf schnell zum blauen Cluster zurückkehren:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Durch die Implementierung dieses Rollback-Plans können Sie sicherstellen, dass Ihre Benutzer bei unerwarteten Problemen so wenig wie möglich gestört werden. | AWS DevOps | ### Validieren und beenden Sie die GTID-basierte Replikation | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Beenden Sie die GTID-basierte Replikation auf dem grünen Cluster. | Nachdem Sie den Datenverkehr von der blauen Umgebung auf die grüne Umgebung umgestellt haben, sollten Sie den Erfolg der Umstellung überprüfen und sicherstellen, dass der grüne Cluster wie erwartet funktioniert. Darüber hinaus muss die GTID-basierte Replikation zwischen den blauen und grünen Clustern gestoppt werden, da die grüne Umgebung jetzt als primäre Datenbank dient. Durch die Ausführung dieser Aufgaben wird sichergestellt, dass Ihre Umgebung sicher, optimiert und für den laufenden Betrieb optimiert ist.So beenden Sie die Replikation:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Wenn Sie die Replizierung beenden, wird der grüne Cluster vollständig unabhängig und fungiert als primäre Datenbankumgebung für Ihre Workloads. | DBA | | Bereinigen Sie die Ressourcen. | Durch die Bereinigung aller temporären oder ungenutzten Ressourcen, die während der Migration vom blauen zum grünen Cluster entstanden sind, wird sichergestellt, dass Ihre Umgebung optimiert, sicher und kostengünstig bleibt. Die Säuberung umfasst die Anpassung der Sicherheitseinstellungen, die Erstellung letzter Backups und die Außerbetriebnahme unnötiger Ressourcen.So bereinigen Sie Ressourcen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/p-automate-blue-green-deployments-aurora-global-databases-iac.html)Die Bereinigung von Ressourcen trägt zur Aufrechterhaltung einer sicheren und optimierten Umgebung bei, senkt die Kosten und stellt sicher, dass nur die benötigte Infrastruktur erhalten bleibt. | AWS DevOps | ## Zugehörige Ressourcen CloudFormation: + [CloudFormation Benutzerhandbuch](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) + [CloudFormation bewährte Verfahren](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/best-practices.html) + [Generieren Sie mit IaC Generator Vorlagen aus vorhandenen Ressourcen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC.html) + [Importieren Sie ganze Anwendungen in CloudFormation](https://aws.amazon.com/blogs/devops/import-entire-applications-into-aws-cloudformation/) (AWS Blogbeitrag) Amazon Aurora: + [Amazon Aurora Benutzerhandbuch](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Welcome.html) + [Verwaltung eines Amazon Aurora Aurora-DB-Clusters](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_Aurora.html) Blaue/grüne Bereitstellungsstrategie: + [Überblick über Amazon Aurora Blue/Green Aurora-Bereitstellungen](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/blue-green-deployments-overview.html) GTID-basierte Replikation: + [Verwenden der GTID-basierten Replikation](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/mysql-replication-gtid.html) (Amazon RDS-Dokumentation) AWS Lambda: + [AWS Lambda Entwicklerhandbuch](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) + [Bewährte Methoden für die Arbeit mit Funktionen AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) Amazonas-Route 53: + [Entwicklerhandbuch zu Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) + [Gewichtetes Routing](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) MySQL-Client-Tools: + [PyMySQL](https://github.com/PyMySQL/PyMySQL) # Automatisieren Sie die Replikation von Amazon RDS-Instances auf AWS-Konten *Parag Nagwekar und Arun Chandapillai, Amazon Web Services* ## Zusammenfassung Dieses Muster zeigt Ihnen, wie Sie den Prozess der Replikation, Nachverfolgung und Wiederherstellung Ihrer Amazon Relational Database Service (Amazon RDS) -DB-Instances auf verschiedenen Ebenen mithilfe AWS-Konten AWS Step Functions von und automatisieren können. AWS Lambda Sie können diese Automatisierung verwenden, um eine groß angelegte Replikation von RDS-DB-Instances ohne Leistungseinbußen oder betrieblichen Mehraufwand durchzuführen — unabhängig von der Größe Ihres Unternehmens. Sie können dieses Muster auch verwenden, um Ihr Unternehmen bei der Einhaltung verbindlicher Datenverwaltungsstrategien oder Compliance-Anforderungen zu unterstützen, die eine Replikation und Redundanz Ihrer Daten über verschiedene Länder hinweg erfordern. AWS-Konten AWS-Regionen Die kontenübergreifende Replikation von Amazon RDS-Daten in großem Umfang ist ein ineffizienter und fehleranfälliger manueller Prozess, der kostspielig und zeitaufwändig sein kann. Die Automatisierung in diesem Muster kann Ihnen jedoch dabei helfen, die kontenübergreifende Replikation sicher, effektiv und effizient durchzuführen. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Zwei AWS-Konten + Eine RDS-DB-Instance, die in der Quelle läuft AWS-Konto + Eine Subnetzgruppe für die RDS-DB-Instance im Ziel AWS-Konto + Ein AWS Key Management Service (AWS KMS) -Schlüssel, der in der Quelle erstellt AWS-Konto und für das Zielkonto freigegeben wurde (Weitere Informationen zu Richtliniendetails finden Sie im Abschnitt [Zusätzliche Informationen](#automate-the-replication-of-amazon-rds-instances-across-aws-accounts-additional) dieses Musters.) + Ein AWS KMS key im Ziel AWS-Konto , um die Datenbank im Zielkonto zu verschlüsseln **Einschränkungen** + Einige AWS-Services sind nicht in allen AWS-Regionen verfügbar. Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie [AWS-Services unter Nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie auf der Seite [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus. **Produktversionen** + Python 3.9 (verwenden AWS Lambda) + PostgreSQL 11.3, 13.x und 14.x ## Architektur **Technologie-Stack** + Amazon Relational Database Service (Amazon RDS) + Amazon-Simple-Notification-Service (Amazon-SNS) + AWS Key Management Service (AWS KMS) + AWS Lambda + AWS Secrets Manager + AWS Step Functions **Zielarchitektur** Das folgende Diagramm zeigt eine Architektur für die Verwendung von Step Functions zur Orchestrierung der geplanten On-Demand-Replikation von RDS-DB-Instances von einem Quellkonto (Konto A) zu einem Zielkonto (Konto B). ![\[Replizieren von Amazon RDS-DB-Instances über Quell- und Zielkonten hinweg mithilfe von Step Functions.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/6310ad9b-1b1a-4a67-b684-ef605fef3e87/images/001550bb-cf6b-493d-9de9-0229a43753a1.png) Im Quellkonto (Konto A im Diagramm) führt die Step Functions-Zustandsmaschine Folgendes aus: 1. Erstellt einen Snapshot von der RDS-DB-Instance in Konto A. 1. Kopiert und verschlüsselt den Snapshot mit einem AWS KMS key From-Konto A. Um die Verschlüsselung während der Übertragung sicherzustellen, wird der Snapshot verschlüsselt, unabhängig davon, ob die DB-Instance verschlüsselt ist oder nicht. 1. Teilt den DB-Snapshot mit Konto B, indem Konto B Zugriff auf den Snapshot gewährt wird. 1. Sendet eine Benachrichtigung an das SNS-Thema, und dann ruft das SNS-Thema die Lambda-Funktion in Konto B auf. Im Zielkonto (Konto B im Diagramm) führt die Lambda-Funktion die Step Functions Functions-Zustandsmaschine aus, um Folgendes zu orchestrieren: 1. Kopiert den gemeinsam genutzten Snapshot von Konto A auf Konto B, wobei zuerst das AWS KMS key Absenderkonto A verwendet wird, um die Daten zu entschlüsseln und dann die Daten mit dem Konto B zu verschlüsseln. AWS KMS key 1. Liest das Geheimnis aus Secrets Manager, um den Namen der aktuellen DB-Instance zu erfassen. 1. Stellt die DB-Instance aus dem Snapshot mit einem neuen Namen und Standard AWS KMS key für Amazon RDS wieder her. 1. Liest den Endpunkt der neuen Datenbank und aktualisiert das Geheimnis in Secrets Manager mit dem neuen Datenbank-Endpunkt und kennzeichnet dann die vorherige DB-Instance, sodass sie später gelöscht werden kann. 1. Behält die letzten N Instanzen der Datenbanken bei und löscht alle anderen Instanzen. ## Tools **AWS-Services** + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Datenbank in der. AWS Cloud + [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) unterstützt Sie bei der Koordination und Verwaltung des Nachrichtenaustauschs zwischen Herausgebern und Kunden, einschließlich Webservern und E-Mail-Adressen. + [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)hilft Ihnen dabei, AWS Ressourcen einzurichten, sie schnell und konsistent bereitzustellen und sie während ihres gesamten Lebenszyklus über AWS-Konten und AWS-Regionen zu verwalten. + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) hilft Ihnen dabei, kryptografische Schlüssel zu erstellen und zu kontrollieren, um Ihre Daten zu schützen. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Datenverarbeitungsservice, mit dem Sie Code ausführen können, ohne dass Sie Server bereitstellen oder verwalten müssen. Es führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen. + [AWS SDK für Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html)ist ein Softwareentwicklungskit, mit dem Sie Ihre Python-Anwendung, -Bibliothek oder Ihr Skript integrieren können AWS-Services. + Mit [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) können Sie fest codierte Anmeldeinformationen im Code (einschließlich Passwörter) durch einen API-Aufruf an Secrets Manager ersetzen und das Geheimnis programmgesteuert abrufen. + [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html)ist ein serverloser Orchestrierungsservice, mit dem Sie Lambda-Funktionen und andere Funktionen kombinieren können, um geschäftskritische Anwendungen AWS-Services zu erstellen. **Code-Repository** Der Code für dieses Muster ist im GitHub [Crossaccount RDS Replication](https://github.com/aws-samples/aws-rds-crossaccount-replication) Repository verfügbar. ## Epen ### Automatisieren Sie die Replikation von RDS-DB-Instances AWS-Konten mit einem einzigen Klick | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Stellen Sie den CloudFormation Stack im Quellkonto bereit. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Cloud-Administrator, Cloud-Architekt | | Stellen Sie den CloudFormation Stack im Zielkonto bereit. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Cloud-Architekt, DevOps Ingenieur, Cloud-Administrator | | Überprüfen Sie die Erstellung der RDS-DB-Instance im Zielkonto. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Cloud-Administrator, Cloud-Architekt, DevOps Ingenieur | | Abonnieren Sie die Lambda-Funktion für das SNS-Thema. | Sie müssen die folgenden Befehle AWS Command Line Interface (AWS CLI) ausführen, um die Lambda-Funktion im Zielkonto (Konto B) für das SNS-Thema im Quellkonto (Konto A) zu abonnieren.Führen Sie in Konto A den folgenden Befehl aus:
def switch_traffic(event, context):
route53 = boto3.client('route53')
lag = check_replication_lag(event, context)
if lag == 0:
response = route53.change_resource_record_sets(
HostedZoneId='YOUR_HOSTED_ZONE_ID',
ChangeBatch={
'Changes': [
{
'Action': 'UPSERT',
'ResourceRecordSet': {
'Name': 'db.example.com',
'Type': 'CNAME',
'SetIdentifier': 'GreenCluster',
'Weight': 100,
'TTL': 60,
'ResourceRecords': [{'Value': 'green-cluster-endpoint'}]
}
},
{
'Action': 'UPSERT',
'ResourceRecordSet': {
'Name': 'db.example.com',
'Type': 'CNAME',
'SetIdentifier': 'BlueCluster',
'Weight': 0,
'TTL': 60,
'ResourceRecords': [{'Value': 'blue-cluster-endpoint'}]
}
}
]
}
)
return response
aws sns add-permission \Führen Sie in Konto B den folgenden Befehl aus:
--label lambda-access --aws-account-id\
--topic-arn\
--action-name Subscribe ListSubscriptionsByTopic
aws lambda add-permission \Führen Sie in Konto B den folgenden Befehl aus:
--function-name\
--source-arn\
--statement-id function-with-sns \
--action lambda:InvokeFunction \
--principal sns.amazonaws.com
aws sns subscribe \| Cloud-Administrator, Cloud-Architekt, DBA | | Synchronisieren Sie die RDS-DB-Instance vom Quellkonto mit dem Zielkonto. | Initiieren Sie die On-Demand-Datenbankreplikation, indem Sie die Step Functions-Zustandsmaschine im Quellkonto starten.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html)Es gibt einen Scheduler, mit dem Sie die Replikation automatisch und planmäßig ausführen können. Der Scheduler ist jedoch standardmäßig ausgeschaltet. Den Namen der CloudWatch Amazon-Regel für den Scheduler finden Sie auf der Registerkarte **Ressourcen** des CloudFormation Stacks im Zielkonto. Anweisungen zum Ändern der CloudWatch Ereignisregel finden Sie in der Dokumentation unter [Löschen oder Deaktivieren einer CloudWatch Ereignisregel](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Delete-or-Disable-Rule.html). CloudWatch | Cloud-Architekt, DevOps Ingenieur, Cloud-Administrator | | Führen Sie bei Bedarf ein Rollback Ihrer Datenbank auf eine der vorherigen Kopien durch. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-the-replication-of-amazon-rds-instances-across-aws-accounts.html) | Cloud-Administrator, DBA, Ingenieur DevOps | ## Zugehörige Ressourcen + [Regionsübergreifende Read Replicas](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionReadReplicas.html) (Amazon RDS-Dokumentation) + [Blaue/grüne Bereitstellungen](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.BlueGreenDeployments.html) (Amazon RDS-Dokumentation) ## Zusätzliche Informationen Sie können die folgende Beispielrichtlinie verwenden, um Ihre AWS KMS key Across gemeinsam zu nutzen. AWS-Konten ``` { "Version": "2012-10-17", "Id": "cross-account-rds-kms-key", "Statement": [ { "Sid": "Enable user permissions", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::
--protocol "lambda" \
--topic-arn\
--notification-endpoint
sqlcmd -S servername -U username -P password -i[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html)
| AWS DevOps, DBA | | Erstellen Sie Aufgaben im Taskplaner. | Gehen Sie wie folgt vor, um eine Aufgabe im Taskplaner zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html)**Um die Aufgabe manuell auszuführen, klicken Sie mit der rechten Maustaste auf die neu erstellte Aufgabe und wählen Sie dann Ausführen.** | DBA | | Aufgabenstatus anzeigen. | Gehen Sie wie folgt vor, um den Status einer Aufgabe im Taskplaner anzuzeigen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html) | DBA, AWS DevOps | ### Automatisieren Sie Aufgaben mit AWS Lambda | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Implementieren Sie die Lösung. | Gehen Sie wie folgt vor, um die Lösung dieses Musters zu implementieren:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.html) | AWS DevOps, DevOps Ingenieur | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | Lambda-Probleme | Hilfe zu Fehlern und Problemen, die bei der Verwendung auftreten können AWS Lambda, finden Sie in der AWS Dokumentation unter [Problembehandlung in Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-troubleshooting.html). | ## Zugehörige Ressourcen + [ EC2 Amazon-Instance-Typen](https://aws.amazon.com/ec2/instance-types/) + [AWS Lambda Dokumentation](https://docs.aws.amazon.com/lambda/latest/dg/with-eventbridge-scheduler.html) + [AWS Lambda Preisgestaltung](https://aws.amazon.com/lambda/pricing/) + [Taskplaner für Entwickler](https://learn.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page) (Microsoft-Website) # Automatisieren Sie regionsübergreifendes Failover und Failback mithilfe des DR Orchestrator Framework *Jitendra Kumar, Pavithra Balasubramanian und Oliver Francis, Amazon Web Services* ## Zusammenfassung Dieses Muster beschreibt, wie [DR Orchestrator Framework](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/dr-orchestrator-framework-overview.html) verwendet wird, um die manuellen, fehleranfälligen Schritte zur Durchführung der Notfallwiederherstellung in allen Amazon Web Services () -Regionen zu orchestrieren und zu automatisieren.AWS Das Muster deckt die folgenden Datenbanken ab: + Amazon Relational Database Service (Amazon RDS) für MySQL, Amazon RDS for PostgreSQL oder Amazon RDS for MariaDB + Amazon Aurora MySQL-Compatible Edition oder Amazon Aurora PostgreSQL-Compatible Edition (mit einer zentralisierten Datei) + Amazon ElastiCache (Redis OSS) Um die Funktionalität von DR Orchestrator Framework zu demonstrieren, erstellen Sie zwei DB-Instances oder Cluster. Die primäre befindet sich in der und AWS-Region `us-east-1` die sekundäre befindet sich in`us-west-2`. Um diese Ressourcen zu erstellen, verwenden Sie die AWS CloudFormation Vorlagen im `App-Stack` Ordner des GitHub Repositorys [aws-cross-region-dr-databases](https://github.com/aws-samples/aws-cross-region-dr-databases). ## Voraussetzungen und Einschränkungen **Allgemeine Voraussetzungen** + DR Orchestrator Framework wird sowohl primär als auch sekundär bereitgestellt AWS-Regionen + Zwei [Amazon Simple Storage Service-Buckets](https://aws.amazon.com/s3/) + Eine [virtuelle private Cloud (VPC)](https://aws.amazon.com/vpc/) mit zwei Subnetzen und einer AWS Sicherheitsgruppe **Engine-spezifische Voraussetzungen** + **Amazon Aurora** — Mindestens eine globale Aurora-Datenbank muss in zwei verfügbar sein AWS-Regionen. Sie können `us-east-1` es als primäre Region und `us-west-2` als sekundäre Region verwenden. + **Amazon ElastiCache (Redis OSS)** — Ein ElastiCache globaler Datenspeicher muss in zwei Einheiten verfügbar sein. AWS-Regionen Sie können `use us-east-1` es als primäre Region und `us-west-2` als sekundäre Region verwenden. **Einschränkungen von Amazon RDS** + DR Orchestrator Framework überprüft die Verzögerung bei der Replikation nicht, bevor ein Failover oder Failback durchgeführt wird. Die Replikationsverzögerung muss manuell überprüft werden. + Diese Lösung wurde mit einer primären Datenbankinstanz mit einer Read Replica getestet. Wenn Sie mehr als eine Read Replica verwenden möchten, testen Sie die Lösung gründlich, bevor Sie sie in einer Produktionsumgebung implementieren. **Einschränkungen von Aurora** + Die Verfügbarkeit und der Support von Funktionen variieren je nach Version der einzelnen Datenbank-Engines und zwischen den einzelnen Versionen AWS-Regionen. Weitere Informationen zur Verfügbarkeit von Funktionen und Regionen für die regionsübergreifende Replikation finden Sie unter [Regionsübergreifende Read Replicas](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.CrossRegionReadReplicas.html). + Für globale Aurora-Datenbanken gelten spezifische Konfigurationsanforderungen für unterstützte Aurora-DB-Instance-Klassen und die maximale Anzahl von AWS-Regionen. Weitere Informationen finden Sie unter [Konfigurationsanforderungen für eine globale Amazon Aurora Aurora-Datenbank](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database.configuration.requirements). + Diese Lösung wurde mit einer primären Datenbank-Instance mit einer Read Replica getestet. Wenn Sie mehr als eine Read Replica verwenden möchten, testen Sie die Lösung gründlich, bevor Sie sie in einer Produktionsumgebung implementieren. **ElastiCache Einschränkungen** + Informationen zur regionalen Verfügbarkeit für Global Datastore und zu den ElastiCache Konfigurationsanforderungen finden Sie in der [ ElastiCache Dokumentation unter Voraussetzungen und Einschränkungen](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastores-Getting-Started.html). **Amazon **RDS-Produktversionen**** Amazon RDS unterstützt die folgenden Engine-Versionen: + **MySQL** — Amazon RDS unterstützt DB-Instances, auf denen die folgenden Versionen von [MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MySQL.html) ausgeführt werden: MySQL 8.0 und MySQL 5.7 + **PostgreSQL** — Informationen zu unterstützten Versionen von Amazon RDS for PostgreSQL finden Sie unter [Verfügbare](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.DBVersions) PostgreSQL-Datenbankversionen. + **MariaDB** [— Amazon RDS unterstützt DB-Instances, auf denen die folgenden Versionen von MariaDB ausgeführt werden:](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_MariaDB.html) + MariaDB 10.11 + MariaDB 10.6 + MariaDB 10.5 **Aurora-Produktversionen** + Für den globalen Datenbank-Switchover von Amazon Aurora ist Aurora MySQL-kompatibel mit MySQL 5.7-Kompatibilität, Version 2.09.1 und höher erforderlich Weitere Informationen finden Sie unter [Einschränkungen der globalen Amazon Aurora Aurora-Datenbanken](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html#aurora-global-database.limitations). **ElastiCache (Redis OSS) -Produktversionen** Amazon ElastiCache (Redis OSS) unterstützt die folgenden Redis-Versionen: + Redis 7.1 (erweitert) + Redis 7.0 (erweitert) + Redis 6.2 (erweitert) + Redis 6.0 (erweitert) + Redis 5.0.6 (erweitert) Weitere Informationen finden Sie unter [Unterstützte Versionen ElastiCache (Redis OSS](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastores-Getting-Started.html)). ## Architektur **Amazon **RDS-Architektur**** Die Amazon RDS-Architektur umfasst die folgenden Ressourcen: + Die primäre Amazon RDS-DB-Instance, die in der primären Region (`us-east-1`) mit read/write Zugriff für Kunden erstellt wurde + Eine Amazon RDS-Lesereplik, die in der sekundären Region (`us-west-2`) mit schreibgeschütztem Zugriff für Kunden erstellt wurde + Das DR Orchestrator Framework wird sowohl in der primären als auch in der sekundären Region eingesetzt ![\[Diagramm der RDS-Architektur mit zwei Regionen in einem einzigen AWS-Konto.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/ad217033-600c-40da-929c-b9f9aecb4c2c.png) Das Diagramm zeigt Folgendes: 1. Asynchrone Replikation zwischen der primären Instance und der sekundären Instance 1. Lese-/Schreibzugriff für Clients in der primären Region 1. Nur-Lese-Zugriff für Clients in der sekundären Region **Aurora-Architektur** Die Amazon Aurora Aurora-Architektur umfasst die folgenden Ressourcen: + Der primäre Aurora-DB-Cluster, der in der primären Region (`us-east-1`) mit einem Active-Writer-Endpunkt erstellt wurde + Ein Aurora-DB-Cluster, der in der sekundären Region (`us-west-2`) mit einem inaktiven Writer-Endpunkt erstellt wurde + Das DR Orchestrator Framework wird sowohl in der primären als auch in der sekundären Region eingesetzt ![\[Diagramm der Aurora-Bereitstellung in zwei Regionen in einem einzigen AWS-Konto.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/524ec002-5aa7-47b2-8c8d-6d1a3b535e9e.png) Das Diagramm zeigt Folgendes: 1. Asynchrone Replikation zwischen dem primären Cluster und dem sekundären Cluster 1. Der primäre DB-Cluster mit einem Active-Writer-Endpunkt 1. Der sekundäre DB-Cluster mit einem inaktiven Writer-Endpunkt **ElastiCache (Redis OSS) -Architektur** Die Amazon-Architektur ElastiCache (Redis OSS) umfasst die folgenden Ressourcen: + Ein globaler Datenspeicher ElastiCache (Redis OSS), der mit zwei Clustern erstellt wurde: 1. Der primäre Cluster in der primären Region () `us-east-1` 1. Der sekundäre Cluster in der sekundären Region (`us-west-2`) + Ein regionsübergreifender Amazon-Link mit TLS 1.2-Verschlüsselung zwischen den beiden Clustern + DR Orchestrator Framework wird sowohl in primären als auch in sekundären Regionen eingesetzt ![\[Diagramm einer ElastiCache Bereitstellung in zwei Regionen mit regionenübergreifendem Amazon-Link.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/8d39561f-924e-4b3e-8175-c5c3cab163bd/images/cf6620a0-dd42-4042-8dc2-012bf514ffc0.png) **Automatisierung und Skalierung** DR Orchestrator Framework ist skalierbar und unterstützt den Failover oder Failback von mehr als einer AWS Datenbank parallel. Sie können den folgenden Payload-Code verwenden, um ein Failover für mehrere AWS Datenbanken in Ihrem Konto durchzuführen. In diesem Beispiel führen drei AWS Datenbanken (zwei globale Datenbanken wie Aurora MySQL-kompatibel oder Aurora PostgreSQL-kompatibel und eine Amazon RDS for MySQL MySQL-Instance) ein Failover zur DR-Region durch: ``` { "StatePayload": [ { "layer": 1, "resources": [ { "resourceType": "PlannedFailoverAurora", "resourceName": "Switchover (planned failover) of Amazon Aurora global databases (MySQL)", "parameters": { "GlobalClusterIdentifier": "!Import dr-globaldb-cluster-mysql-global-identifier", "DBClusterIdentifier": "!Import dr-globaldb-cluster-mysql-cluster-identifier" } }, { "resourceType": "PlannedFailoverAurora", "resourceName": "Switchover (planned failover) of Amazon Aurora global databases (PostgreSQL)", "parameters": { "GlobalClusterIdentifier": "!Import dr-globaldb-cluster-postgres-global-identifier", "DBClusterIdentifier": "!Import dr-globaldb-cluster-postgres-cluster-identifier" } }, { "resourceType": "PromoteRDSReadReplica", "resourceName": "Promote RDS for MySQL Read Replica", "parameters": { "RDSInstanceIdentifier": "!Import rds-mysql-instance-identifier", "TargetClusterIdentifier": "!Import rds-mysql-instance-global-arn" } } ] } ] } ``` ## Tools **AWS Dienste** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) ist eine vollständig verwaltete relationale Datenbank-Engine, die für die Cloud entwickelt wurde und mit MySQL und PostgreSQL kompatibel ist. + [Amazon ElastiCache](https://docs.aws.amazon.com/elasticache/) unterstützt Sie bei der Einrichtung, Verwaltung und Skalierung verteilter In-Memory-Cache-Umgebungen in der AWS Cloud. Dieses Muster verwendet Amazon ElastiCache (Redis OSS). + [AWS Lambda](https://aws.amazon.com/lambda/) ist ein Datenverarbeitungsservice, mit dem Sie Code ausführen können, ohne dass Sie Server bereitstellen oder verwalten müssen. Es führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen. In diesem Muster werden Lambda-Funktionen verwendet AWS Step Functions , um die Schritte auszuführen. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Datenbank in der. AWS Cloud Dieses Muster unterstützt Amazon RDS for MySQL, Amazon RDS for PostgreSQL und Amazon RDS for MariaDB. + [AWS SDK für Python (Boto3)](https://aws.amazon.com/sdk-for-python/)hilft Ihnen bei der Integration Ihrer Python-Anwendung, -Bibliothek oder Ihres Skripts mit AWS-Services. In diesem Muster APIs werden Boto3 verwendet, um mit den Datenbankinstanzen oder globalen Datenbanken zu kommunizieren. + [AWS Step Functions](https://aws.amazon.com/step-functions/)ist ein serverloser Orchestrierungsdienst, mit dem Sie AWS Lambda Funktionen und andere Funktionen kombinieren können, um geschäftskritische Anwendungen AWS-Services zu erstellen. In diesem Muster werden Step Functions Functions-Zustandsmaschinen verwendet, um den regionsübergreifenden Failover und das Failback der Datenbankinstanzen oder globalen Datenbanken zu orchestrieren und auszuführen. **Code-Repository** Der Code für dieses Muster ist im Repository [aws-cross-region-dr-databases](https://github.com/aws-samples/aws-cross-region-dr-databases/tree/main/App-Stack) unter GitHub verfügbar. ## Epen ### Installieren Sie DR Orchestrator Framework | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Klonen Sie das GitHub Repository. | Führen Sie den folgenden Befehl aus, um das Repository zu klonen:
@echo off
sqlcmd -S [ServerName] -d [DatabaseName] -U username -P password -i "PathToSQLScript\Script.sql" -o "PathToOutput\Output.txt"
git clone https://github.com/aws-samples/aws-cross-region-dr-databases.git| AWS DevOps, AWS-Administrator | | Paketieren Sie den Code der Lambda-Funktionen in einem ZIP-Dateiarchiv. | Erstellen Sie die Archivdateien für Lambda-Funktionen, um die DR Orchestrator Framework-Abhängigkeiten einzubeziehen:
cd| AWS-Administrator | | Erstellen Sie S3-Buckets. | S3-Buckets werden benötigt, um DR Orchestrator Framework zusammen mit Ihrer neuesten Konfiguration zu speichern. Erstellen Sie zwei S3-Buckets, einen in der primären Region (`us-east-1`) und einen in der sekundären Region (): `us-west-2`[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html)`xxxxxx`Ersetzen Sie ihn durch einen zufälligen Wert, um die Bucket-Namen eindeutig zu machen. | AWS-Administrator | | Erstellen Sie Subnetze und Sicherheitsgruppen. | Erstellen Sie sowohl in der primären Region (`us-east-1`) als auch in der sekundären Region (`us-west-2`) zwei Subnetze und eine Sicherheitsgruppe für die Bereitstellung von Lambda-Funktionen in Ihrer VPC:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | AWS-Administrator | | Aktualisieren Sie die DR Orchestrator-Parameterdateien. | Aktualisieren Sie in dem `/DR-Orchestration-artifacts
bash scripts/deploy-orchestrator-sh.sh
[| AWS-Administrator | | Laden Sie den DR Orchestrator Framework-Code in den S3-Bucket hoch. | Der Code ist in einem S3-Bucket sicherer als im lokalen Verzeichnis. Laden Sie das `DR-Orchestration-artifacts` Verzeichnis einschließlich aller Dateien und Unterordner in die S3-Buckets hoch.Gehen Sie wie folgt vor, um den Code hochzuladen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | AWS-Administrator | | Stellen Sie das DR Orchestrator Framework in der primären Region bereit. | Führen Sie die folgenden Befehle aus, um DR Orchestrator Framework in der primären Region (`us-east-1`) bereitzustellen:
{
"ParameterKey": "TemplateStoreS3BucketName",
"ParameterValue": "dr-orchestrator-xxxxxx-us-east-1"
},
{
"ParameterKey": "TemplateVPCId",
"ParameterValue": "vpc-xxxxxx"
},
{
"ParameterKey": "TemplateLambdaSubnetID1",
"ParameterValue": "subnet-xxxxxx"
},
{
"ParameterKey": "TemplateLambdaSubnetID2",
"ParameterValue": "subnet-yyyyyy"
},
{
"ParameterKey": "TemplateLambdaSecurityGroupID",
"ParameterValue": "sg-xxxxxxxxxx"
}
]
cd| AWS-Administrator | | Stellen Sie das DR Orchestrator Framework in der sekundären Region bereit. | Führen Sie in der sekundären Region (`us-west-2`) die folgenden Befehle aus:/DR-Orchestration-artifacts/cloudformation
aws cloudformation deploy \
--region us-east-1 \
--stack-name dr-orchestrator \
--template-file Orchestrator-Deployer.yaml \
--parameter-overrides file://Orchestrator-Deployer-parameters-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cd| AWS-Administrator | | Überprüfen Sie die Bereitstellung. | Wenn der CloudFormation Befehl erfolgreich ausgeführt wird, gibt er die folgende Ausgabe zurück:/DR-Orchestration-artifacts/cloudformation
aws cloudformation deploy \
--region us-west-2 \
--stack-name dr-orchestrator \
--template-file Orchestrator-Deployer.yaml \
--parameter-overrides file://Orchestrator-Deployer-parameters-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
Successfully created/updated stack - dr-orchestratorAlternativ können Sie zur CloudFormation Konsole navigieren und den Status des `dr-orchestrator` Stacks überprüfen. | AWS-Administrator | ### Erstellen Sie die Datenbank-Instances oder Cluster | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie die Datenbank-Subnetze und Sicherheitsgruppen. | Erstellen Sie in Ihrer VPC zwei Subnetze und eine Sicherheitsgruppe für die DB-Instance oder globale Datenbank sowohl in der primären (`us-east-1`) als auch in der sekundären (`us-west-2`) Region:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automate-cross-region-failover-and-failback-by-using-dr-orchestrator-framework.html) | AWS-Administrator | | Aktualisieren Sie die Parameterdatei für die primäre DB-Instance oder den Cluster. | Aktualisieren `
{
"Parameters": {
"SubnetIds": "subnet-xxxxxx,subnet-xxxxxx",
"DBSecurityGroup": "sg-xxxxxxxxxx",
"MySqlGlobalIdentifier":"rds-mysql-instance",
"InitialDatabaseName": "mysqldb",
"DBPortNumber": "3789",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/rds-mysql-instance-KmsKeyId"
}
}
**Amazon Aurora** Aktualisieren Sie in der `Aurora-MySQL-parameter-us-east-1.json` Datei `SubnetIds` und `DBSecurityGroup` mit den Namen der Ressourcen, die Sie erstellt haben:{
"Parameters": {
"SubnetIds": "subnet1-xxxxxx,subnet2-xxxxxx",
"DBSecurityGroup": "sg-xxxxxxxxxx",
"GlobalClusterIdentifier":"dr-globaldb-cluster-mysql",
"DBClusterName":"dbcluster-01",
"SourceDBClusterName":"dbcluster-02",
"DBPortNumber": "3787",
"DBInstanceClass":"db.r5.large",
"InitialDatabaseName": "sampledb",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/dr-globaldb-cluster-mysql-KmsKeyId"
}
}**Amazon ElastiCache (Redis OSS)**Geben Sie in der `ElastiCache-parameter-us-east-1.json` Datei das Update ein `SubnetIds` und geben `DBSecurityGroup` Sie die Namen der Ressourcen an, die Sie erstellt haben.{
"Parameters": {
"CacheNodeType": "cache.m5.large",
"DBSecurityGroup": "sg-xxxxxxxxxx",
"SubnetIds": "subnet-xxxxxx,subnet-xxxxxx",
"EngineVersion": "5.0.6",
"GlobalReplicationGroupIdSuffix": "demo-redis-global-datastore",
"NumReplicas": "1",
"NumShards": "1",
"ReplicationGroupId": "demo-redis-cluster",
"DBPortNumber": "3788",
"TransitEncryption": "true",
"KMSKeyAliasName": "elasticache/demo-redis-global-datastore-KmsKeyId",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2"
}
} | AWS-Administrator |
| Stellen Sie Ihre DB-Instance oder Ihren Cluster in der primären Region bereit. | Um Ihre Instance oder Ihren Cluster in der primären Region (`us-east-1`) bereitzustellen, führen Sie die folgenden Befehle basierend auf Ihrer Datenbank-Engine aus.**Amazon RDS**cd**Amazon Aurora**/App-Stack
aws cloudformation deploy \
--region us-east-1 \
--stack-name rds-mysql-app-stack \
--template-file RDS-MySQL-Primary.yaml \
--parameter-overrides file://RDS-MySQL-parameter-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cd**Amazon ElastiCache (Redis OSS)**/App-Stack
aws cloudformation deploy \
--region us-east-1 \
--stack-name aurora-mysql-app-stack \
--template-file Aurora-MySQL-Primary.yaml \
--parameter-overrides file://Aurora-MySQL-parameter-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cdStellen Sie sicher, dass die CloudFormation Ressourcen erfolgreich bereitgestellt wurden. | AWS-Administrator | | Aktualisieren Sie die Parameterdatei für die sekundäre DB-Instance oder den Cluster. | Aktualisieren `/App-Stack
aws cloudformation deploy \
--region us-east-1 --stack-name elasticache-ds-app-stack \
--template-file ElastiCache-Primary.yaml \
--parameter-overrides file://ElastiCache-parameter-us-east-1.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
{
"Parameters": {
"SubnetIds": "subnet-aaaaaaaaa,subnet-bbbbbbbbb",
"DBSecurityGroup": "sg-cccccccccc",
"MySqlGlobalIdentifier":"rds-mysql-instance",
"InitialDatabaseName": "mysqldb",
"DBPortNumber": "3789",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/rds-mysql-instance-KmsKeyId",
"PrimaryRegionKMSKeyArn":"arn:aws:kms:us-east-1:xxxxxxxxx:key/mrk-xxxxxxxxxxxxxxxxxxxxx"
}
} **Amazon Aurora**Aktualisieren Sie in der `Aurora-MySQL-parameter-us-west-2.json` Datei `SubnetIDs` und `DBSecurityGroup` mit den Namen der Ressourcen, die Sie erstellt haben. Aktualisieren Sie den `PrimaryRegionKMSKeyArn` mit dem Wert `AuroraKmsKeyId` aus dem Abschnitt **Outputs** des CloudFormation Stacks für die primäre DB-Instance:{
"Parameters": {
"SubnetIds": "subnet1-aaaaaaaaa,subnet2-bbbbbbbbb",
"DBSecurityGroup": "sg-cccccccccc",
"GlobalClusterIdentifier":"dr-globaldb-cluster-mysql",
"DBClusterName":"dbcluster-01",
"SourceDBClusterName":"dbcluster-02",
"DBPortNumber": "3787",
"DBInstanceClass":"db.r5.large",
"InitialDatabaseName": "sampledb",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2",
"KMSKeyAliasName": "rds/dr-globaldb-cluster-mysql-KmsKeyId"
}
}**Amazon ElastiCache (Redis OSS)**Geben Sie in der `ElastiCache-parameter-us-west-2.json` Datei das Update ein `SubnetIDs` und geben `DBSecurityGroup` Sie die Namen der Ressourcen an, die Sie erstellt haben. Aktualisieren Sie den `PrimaryRegionKMSKeyArn` mit dem Wert von `ElastiCacheKmsKeyId` aus dem Abschnitt **Outputs** des CloudFormation Stacks für die primäre DB-Instance:{
"Parameters": {
"CacheNodeType": "cache.m5.large",
"DBSecurityGroup": "sg-cccccccccc",
"SubnetIds": "subnet-aaaaaaaaa,subnet-bbbbbbbbb",
"EngineVersion": "5.0.6",
"GlobalReplicationGroupIdSuffix": "demo-redis-global-datastore",
"NumReplicas": "1",
"NumShards": "1",
"ReplicationGroupId": "demo-redis-cluster",
"DBPortNumber": "3788",
"TransitEncryption": "true",
"KMSKeyAliasName": "elasticache/demo-redis-global-datastore-KmsKeyId",
"PrimaryRegion": "us-east-1",
"SecondaryRegion": "us-west-2"
}
} | AWS-Administrator |
| Stellen Sie Ihre DB-Instance oder Ihren Cluster in der sekundären Region bereit. | Führen Sie die folgenden Befehle basierend auf Ihrer Datenbank-Engine aus.**Amazon RDS**cd**Amazon Aurora**/App-Stack
aws cloudformation deploy \
--region us-west-2 \
--stack-name rds-mysql-app-stack \
--template-file RDS-MySQL-DR.yaml \
--parameter-overrides file://RDS-MySQL-parameter-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cd**Amazon ElastiCache (Redis OSS)**/App-Stack
aws cloudformation deploy \
--region us-west-2 \
--stack-name aurora-mysql-app-stack \
--template-file Aurora-MySQL-DR.yaml \
--parameter-overrides file://Aurora-MySQL-parameter-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
cdStellen Sie sicher, dass die CloudFormation Ressourcen erfolgreich bereitgestellt wurden. | AWS-Administrator | ## Zugehörige Ressourcen + [Strategie zur Notfallwiederherstellung für Datenbanken auf AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/welcome.html) (AWS Prescriptive Guidance-Strategie) + [Automatisieren Sie Ihre DR-Lösung für relationale Datenbanken auf AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/dr-orchestrator-framework-overview.html) (AWS Prescriptive Guidance Guide Guide) + [Verwenden von Amazon Aurora Global Databases](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html) + [Replikation über globale Datenspeicher hinweg AWS-Regionen](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Redis-Global-Datastore.html) + [Automatisieren Sie Ihre DR-Lösung für relationale Datenbanken auf AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/automate-dr-solution-relational-database/introduction.html) (AWS Prescriptive Guidance Guide) # Automatisches Backup von SAP HANA-Datenbanken mit Systems Manager und EventBridge *Ambarish Satarkar und Gaurav Rath, Amazon Web Services* ## Zusammenfassung Dieses Muster beschreibt, wie SAP HANA-Datenbanksicherungen mithilfe von AWS Systems Manager, Amazon EventBridge, Amazon Simple Storage Service (Amazon S3) und AWS Backint Agent for SAP HANA automatisiert werden. Dieses Muster bietet einen Shell-Skriptbasierten Ansatz unter Verwendung des `BACKUP DATA` Befehls und macht es überflüssig, Skripts und Jobkonfigurationen für jede Betriebssysteminstanz (OS) auf zahlreichen Systemen zu verwalten. | | | Hinweis: Im April 2023 kündigte AWS Backup die Unterstützung für SAP HANA-Datenbanken auf Amazon Elastic Compute Cloud (Amazon EC2) an. Weitere Informationen finden Sie unter [Backup von SAP HANA-Datenbanken auf EC2 Amazon-Instances](https://docs.aws.amazon.com/aws-backup/latest/devguide/backup-saphana.html).Je nach den Anforderungen Ihres Unternehmens können Sie den AWS Backup Backup-Service verwenden, um Ihre SAP HANA-Datenbanken automatisch zu sichern, oder Sie können dieses Muster verwenden. | | --- | ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Eine bestehende SAP HANA-Instance mit einer unterstützten Version im Running-Status auf einer verwalteten Amazon Elastic Compute Cloud (Amazon EC2) -Instance, die für Systems Manager konfiguriert ist + Systems Manager Agent (SSM Agent) 2.3.274.0 oder höher installiert + Ein S3-Bucket, für den der öffentliche Zugriff nicht aktiviert ist + Ein `hdbuserstore` Schlüssel mit dem Namen `SYSTEM` + Eine AWS Identity and Access Management (IAM) -Rolle für das Automation-Runbook zur planmäßigen Ausführung + `AmazonSSMManagedInstanceCore`und `ssm:StartAutomationExecution` Richtlinien sind der Systems Manager Automation-Servicerolle zugeordnet. **Einschränkungen** + AWS Backint Agent for SAP HANA unterstützt keine Deduplizierung. + AWS Backint Agent for SAP HANA unterstützt keine Datenkomprimierung. **Produktversionen** AWS Backint Agent wird auf den folgenden Betriebssystemen unterstützt: + SUSE-Linux-Enterprise-Server + SUSE Linux Enterprise Server für SAP + RedHat Enterprise Linux für SAP AWS Backint Agent unterstützt die folgenden Datenbanken: + SAP HANA 1.0 SP12 (einzelner Knoten und mehrere Knoten) + SAP HANA 2.0 und höher (einzelner Knoten und mehrere Knoten) ## Architektur **Zieltechnologie-Stack** + AWS-Backing-Agent + Amazon S3 + AWS Systems Manager + Amazon EventBridge + SAP HANA **Zielarchitektur** Das folgende Diagramm zeigt die Installationsskripte, die AWS Backint Agent, den S3-Bucket und Systems Manager installieren und die ein Command-Dokument verwenden EventBridge, um regelmäßige Backups zu planen. ![\[Arbeitsablauf für die Planung regelmäßiger Backups.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/0aa22a27-d100-483d-95f9-c3101f40402c/images/201d2b9a-b88e-4432-82cd-240b81da981e.png) **Automatisierung und Skalierung** + Mithilfe eines Systems Manager Automation-Runbooks können mehrere AWS-Backint-Agents installiert werden. + Jeder Lauf des Systems Manager Manager-Runbooks kann je nach Zielauswahl auf *n* SAP HANA-Instanzen skaliert werden. + EventBridge kann SAP HANA-Backups automatisieren. ## Tools + [AWS Backint Agent for SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-sap-hana.html) ist eine eigenständige Anwendung, die sich in Ihre bestehenden Workflows integriert, um Ihre SAP HANA-Datenbank in einem S3-Bucket zu sichern, den Sie in der Konfigurationsdatei angeben. AWS Backint Agent unterstützt vollständige, inkrementelle und differenzielle Backups von SAP HANA-Datenbanken. Es läuft auf einem SAP HANA-Datenbankserver, auf dem Backups und Kataloge von der SAP HANA-Datenbank auf den AWS Backint Agent übertragen werden. + [Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html) ist ein serverloser Event-Bus-Service, mit dem Sie Ihre Anwendungen mit Daten aus einer Vielzahl von Quellen verbinden können. EventBridge liefert einen Stream von Echtzeitdaten aus Ihren Anwendungen, SaaS-Anwendungen (Software as a Service) und AWS-Services an Ziele wie AWS Lambda-Funktionen, HTTP-Aufruf-Endpunkte, die API-Ziele verwenden, oder Event-Busse in anderen Konten. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein Objektspeicherservice. Mit Amazon S3 können Sie jederzeit beliebige Mengen von Daten von überall aus im Internet speichern und aufrufen. + [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) hilft Ihnen dabei, Ihre Infrastruktur auf AWS anzuzeigen und zu steuern. Mithilfe der Systems Manager Manager-Konsole können Sie Betriebsdaten von mehreren AWS-Services anzeigen und betriebliche Aufgaben in Ihren AWS-Ressourcen automatisieren. **Code** Der Code für dieses Muster ist im [aws-backint-automated-backup](https://github.com/aws-samples/aws-backint-automated-backup) GitHub Repository verfügbar. ## Epen ### Erstellen Sie ein hdbuserstore-SchlüsselSYSTEM | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie einen hdbuserstore-Schlüssel. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html) | AWS-Administrator, SAP HANA-Administrator | ### Installieren Sie den AWS Backint Agent | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Installieren Sie den AWS Backint Agent. | Folgen Sie den Anweisungen unter [Installieren und Konfigurieren von AWS Backint Agent für SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-installing-configuring.html) in der Dokumentation zu AWS Backint Agent. | AWS-Administrator, SAP HANA-Administrator | ### Erstellen Sie das Systems Manager Manager-Befehlsdokument | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie das Systems Manager Manager-Befehlsdokument. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html) | AWS-Administrator, SAP HANA-Administrator | ### Planen Sie Backups in regelmäßigen Abständen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Planen Sie regelmäßige Backups mit Amazon EventBridge. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.html)Sie können den Erfolg der Sicherung anhand des S3-Bucket-Pfads überprüfen./App-Stack
aws cloudformation deploy \
--region us-west-2 \
--stack-name elasticache-ds-app-stack \
--template-file ElastiCache-DR.yaml \
--parameter-overrides file://ElastiCache-parameter-us-west-2.json \
--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM \
--disable-rollback
s3:/Sie können Backups auch aus dem SAP HANA-Backup-Katalog überprüfen. | AWS-Administrator, SAP HANA-Administrator | ## Zugehörige Ressourcen + [AWS-Backing-Agent für SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-sap-hana.html) + [Installieren und konfigurieren Sie den AWS Backint Agent für SAP HANA](https://docs.aws.amazon.com/sap/latest/sap-hana/aws-backint-agent-installing-configuring.html) # Automatisches Generieren eines PynamoDB-Modells und CRUD-Funktionen für Amazon DynamoDB mithilfe einer Python-Anwendung *Vijit Vashishtha, Dheeraj Alimchandani und Dhananjay Karanjkar, Amazon Web Services* ## Zusammenfassung Es ist üblich, Entitäten und CRUD-Operationsfunktionen (Create, Read, Update and Delete) zu verlangen, um Amazon DynamoDB DynamoDB-Datenbankoperationen effizient durchzuführen. PynamoDB ist eine Python-basierte Schnittstelle, die Python 3 unterstützt. Es bietet auch Funktionen wie Unterstützung für Amazon DynamoDB-Transaktionen, automatische Serialisierung und Deserialisierung von Attributwerten sowie Kompatibilität mit gängigen Python-Frameworks wie Flask und Django. Dieses Muster hilft Entwicklern, die mit Python und DynamoDB arbeiten, indem es eine Bibliothek bereitstellt, die die automatische Erstellung von PynamoDB-Modellen und CRUD-Betriebsfunktionen optimiert. Es generiert zwar wichtige CRUD-Funktionen für Datenbanktabellen, kann aber auch PynamoDB-Modelle und CRUD-Funktionen aus Amazon DynamoDB-Tabellen zurückentwickeln. Dieses Muster wurde entwickelt, um Datenbankoperationen mithilfe einer Python-basierten Anwendung zu vereinfachen. Im Folgenden sind die Hauptmerkmale dieser Lösung aufgeführt: + **JSON-Schema zu PynamoDB-Modell** — Generieren Sie automatisch PynamoDB-Modelle in Python, indem Sie eine JSON-Schemadatei importieren. + Generierung von **CRUD-Funktionen — Generieren** Sie automatisch Funktionen zur Ausführung von CRUD-Operationen in DynamoDB-Tabellen. + **Reverse Engineering von DynamoDB** — Verwenden Sie PynamoDB Object-Relational Mapping (ORM), um PynamoDB-Modelle und CRUD-Funktionen für bestehende Amazon DynamoDB-Tabellen zurückzuentwickeln. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktiver AWS-Konto + Python Version 3.8 oder höher, [heruntergeladen](https://www.python.org/downloads/) und installiert + [Jinja2 Version 3.1.2 oder höher, heruntergeladen und installiert](https://pypi.org/project/Jinja2/#files) + Amazon DynamoDB-Tabellen, für die Sie ORM generieren möchten + AWS Command Line Interface [(AWS CLI), [installiert und konfiguriert](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) + [PynamoDB Version 5.4.1 oder höher, installiert](https://pynamodb.readthedocs.io/en/stable/tutorial.html#installation) ## Architektur **Zieltechnologie-Stack** + JSON-Skript + Python-Anwendung + PynamoDB-Modell + Amazon DynamoDB DynamoDB-Datenbank-Instance **Zielarchitektur** ![\[Verwenden einer Python-App zum Generieren von CRUD-Funktionen und eines PynamoDB-Modells aus DynamoDB-Tabellen.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/74cc4c73-5c8b-448d-98fb-b681cfa5f860/images/c2c367d6-d88a-4f49-8571-89160539eb08.png) 1. Sie erstellen eine Eingabe-JSON-Schemadatei. Diese JSON-Schemadatei stellt die Attribute der jeweiligen DynamoDB-Tabellen dar, aus denen Sie PynamoDB-Modelle und CRUD-Funktionen erstellen möchten. Sie enthält die folgenden drei wichtigen Schlüssel: + `name`— Der Name der DynamoDB-Zieltabelle. + `region`— Der AWS-Region Ort, an dem die Tabelle gehostet wird + `attributes`— Die Attribute, die Teil der Zieltabelle sind, wie z. B. der [Partitionsschlüssel](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) (auch als *Hash-Attribut* bezeichnet), der [Sortierschlüssel](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey), [lokale Sekundärindizes](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSI.html), [globale Sekundärindizes](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) und alle [Nichtschlüsselattribute](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes). Dieses Tool erwartet, dass das Eingabeschema nur die Nicht-Schlüsselattribute bereitstellt, da die Anwendung die Schlüsselattribute direkt aus der Zieltabelle abruft. Ein Beispiel für die Angabe von Attributen in der JSON-Schemadatei finden Sie im Abschnitt [Zusätzliche Informationen](#automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application-additional) dieses Musters. 1. Führen Sie die Python-Anwendung aus und geben Sie die JSON-Schemadatei als Eingabe an. 1. Die Python-Anwendung liest die JSON-Schemadatei. 1. Die Python-Anwendung stellt eine Verbindung zu den DynamoDB-Tabellen her, um das Schema und die Datentypen abzuleiten. Die Anwendung führt den Vorgang [describe\$1table](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb/client/describe_table.html) aus und ruft die Schlüssel- und Indexattribute für die Tabelle ab. 1. Die Python-Anwendung kombiniert die Attribute aus der JSON-Schemadatei und der DynamoDB-Tabelle. Es verwendet die Jinja-Template-Engine, um ein PynamoDB-Modell und entsprechende CRUD-Funktionen zu generieren. 1. Sie greifen auf das PynamoDB-Modell zu, um CRUD-Operationen in der DynamoDB-Tabelle durchzuführen. ## Tools **AWS-Services** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) ist ein vollständig verwalteter NoSQL-Datenbank-Service, der schnelle und planbare Leistung mit nahtloser Skalierbarkeit bereitstellt. **Andere Tools** + [Jinja](https://jinja.palletsprojects.com/en/) ist eine erweiterbare Templating-Engine, die Vorlagen zu optimiertem Python-Code kompiliert. Dieses Muster verwendet Jinja, um dynamische Inhalte zu generieren, indem Platzhalter und Logik in Vorlagen eingebettet werden. + [PynamoDB](https://pynamodb.readthedocs.io/en/stable/) ist eine Python-basierte Schnittstelle für Amazon DynamoDB. + [Python](https://www.python.org/) ist eine Allzweck-Computerprogrammiersprache. **Code-Repository** Der Code für dieses Muster ist im Repository für GitHub [automatisch generierte PynamoDB-Modelle und](https://github.com/aws-samples/amazon-reverse-engineer-dynamodb) CRUD-Funktionen verfügbar. Das Repository ist in zwei Hauptteile unterteilt: das Controller-Paket und die Vorlagen. *Controller-Paket* Das Controller-Python-Paket enthält die Hauptanwendungslogik, die bei der Generierung des PynamoDB-Modells und der CRUD-Funktionen hilft. Sie enthält Folgendes: + `input_json_validator.py`— Dieses Python-Skript validiert die Eingabe-JSON-Schemadatei und erstellt die Python-Objekte, die die Liste der DynamoDB-Zieltabellen und die jeweils erforderlichen Attribute enthalten. + `dynamo_connection.py`— Dieses Skript stellt eine Verbindung zur DynamoDB-Tabelle her und verwendet die `describe_table` Operation, um die Attribute zu extrahieren, die für die Erstellung des PynamoDB-Modells erforderlich sind. + `generate_model.py`— Dieses Skript enthält eine Python-Klasse`GenerateModel`, die das PynamoDB-Modell auf der Grundlage der Eingabe-JSON-Schemadatei und der Operation erstellt. `describe_table` + `generate_crud.py`— Für die DynamoDB-Tabellen, die in der JSON-Schemadatei definiert sind, verwendet dieses Skript den `GenerateCrud` Vorgang, um die Python-Klassen zu erstellen. *Vorlagen* Dieses Python-Verzeichnis enthält die folgenden Jinja-Vorlagen: + `model.jinja`— Diese Jinja-Vorlage enthält den Vorlagenausdruck für die Generierung des PynamoDB-Modellskripts. + `crud.jinja`— Diese Jinja-Vorlage enthält den Vorlagenausdruck für die Generierung des CRUD-Funktionsskripts. ## Epen ### Richte die Umgebung ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Klonen Sie das Repository | Geben Sie den folgenden Befehl ein, um das Repository für [automatisch generierte PynamoDB-Modelle und](https://github.com/aws-samples/amazon-reverse-engineer-dynamodb) CRUD-Funktionen zu klonen./ / /usr/sap/ /SYS/global/hdb/backint/DB_ /
git clone https://github.com/aws-samples/amazon-reverse-engineer-dynamodb.git| App-Developer | | Richten Sie die Python-Umgebung ein. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | App-Developer | ### Generieren Sie das PynamoDB-Modell und die CRUD-Funktionen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Ändern Sie die JSON-Schemadatei. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | App-Developer | | Führen Sie die Python-Anwendung aus. | Geben Sie den folgenden Befehl ein, um die PynamoDB-Modelle und CRUD-Funktionen zu generieren, wobei der Name Ihrer JSON-Schemadatei `
python main.py --file| App-Developer | ### Überprüfen Sie das PynamoDB-Modell und die CRUD-Funktionen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Überprüfen Sie das generierte PynamoDB-Modell. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | App-Developer | | Überprüfen Sie die generierten CRUD-Funktionen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.html) | App-Developer | ## Zugehörige Ressourcen + [Kernkomponenten von Amazon DynamoDB (DynamoDB-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html)) + [Verbesserung des Datenzugriffs mit Sekundärindizes](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) (DynamoDB-Dokumentation) ## Zusätzliche Informationen **Beispielattribute für die JSON-Schemadatei** ``` [ { "name": "test_table", "region": "ap-south-1", "attributes": [ { "name": "id", "type": "UnicodeAttribute" }, { "name": "name", "type": "UnicodeAttribute" }, { "name": "age", "type": "NumberAttribute" } ] } ] ``` # Blockieren Sie den öffentlichen Zugriff auf Amazon RDS mithilfe von Cloud Custodian *Abhay Kumar und Dwarika Patra, Amazon Web Services* ## Zusammenfassung Viele Unternehmen führen ihre Workloads und Dienste auf mehreren Cloud-Anbietern aus. In diesen Hybrid-Cloud-Umgebungen erfordert die Cloud-Infrastruktur zusätzlich zur Sicherheit, die von den einzelnen Cloud-Anbietern bereitgestellt wird, eine strenge Cloud-Governance. Eine Cloud-Datenbank wie Amazon Relational Database Service (Amazon RDS) ist ein wichtiger Dienst, der auf Zugriffs- und Berechtigungsschwachstellen überwacht werden muss. Sie können zwar den Zugriff auf die Amazon RDS-Datenbank einschränken, indem Sie eine Sicherheitsgruppe konfigurieren, aber Sie können eine zweite Schutzebene hinzufügen, um Aktionen wie den öffentlichen Zugriff zu verbieten. Die Sperrung des öffentlichen Zugangs hilft Ihnen bei der Einhaltung der Allgemeinen Datenschutzverordnung (DSGVO), des Health Insurance Portability and Accountability Act (HIPAA), des National Institute of Standards and Technology (NIST) und des Payment Card Industry Data Security Standard (PCI DSS). Cloud Custodian ist eine Open-Source-Regel-Engine, mit der Sie Zugriffsbeschränkungen für Amazon Web Services (AWS) -Ressourcen wie Amazon RDS durchsetzen können. Mit Cloud Custodian können Sie Regeln festlegen, die die Umgebung anhand definierter Sicherheits- und Compliance-Standards validieren. Sie können Cloud Custodian verwenden, um Ihre Cloud-Umgebungen zu verwalten, indem Sie dazu beitragen, die Einhaltung von Sicherheitsrichtlinien, Tag-Richtlinien und die Müllsammlung ungenutzter Ressourcen sowie das Kostenmanagement sicherzustellen. Mit Cloud Custodian können Sie eine einzige Oberfläche für die Implementierung von Governance in einer Hybrid-Cloud-Umgebung verwenden. Sie könnten beispielsweise die Cloud Custodian-Schnittstelle verwenden, um mit Microsoft Azure zu interagieren AWS und so den Aufwand für die Arbeit mit Mechanismen wie AWS Config AWS Sicherheitsgruppen und Azure-Richtlinien zu reduzieren. Dieses Muster enthält Anweisungen zur Verwendung von Cloud Custodian AWS , um die Einschränkung des öffentlichen Zugriffs auf Amazon RDS-Instances durchzusetzen. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktiver AWS-Konto + [Ein key pair](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-creds-create) + AWS Lambda installiert ## Architektur Das folgende Diagramm zeigt, wie Cloud Custodian die Richtlinie für Amazon AWS Lambda RDS bereitstellt, das `CreateDBInstance` Ereignis AWS CloudTrail auslöst und die Lambda-Funktion `PubliclyAccessible` auf False gesetzt hat. ![\[Verwendung von Cloud Custodian auf AWS, um den öffentlichen Zugriff auf Amazon RDS-Instances einzuschränken.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/90f9537e-9365-4da2-8a28-da0ff374743c/images/6d04ca3b-6aa4-4c62-ade9-8b7474928c5e.png) ## Tools **AWS-Services** + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html)hilft Ihnen bei der Prüfung der Unternehmensführung, der Einhaltung von Vorschriften und des betrieblichen Risikos Ihrer AWS-Konto. + [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie AWS-Services über Befehle in Ihrer Befehlszeilen-Shell interagieren können. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) hilft Ihnen dabei, den Zugriff auf Ihre AWS Ressourcen sicher zu verwalten, indem es kontrolliert, wer authentifiziert und autorisiert ist, diese zu verwenden. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Datenverarbeitungsservice, mit dem Sie Code ausführen können, ohne dass Sie Server bereitstellen oder verwalten müssen. Es führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Datenbank in der. AWS Cloud **Andere Tools** + [Cloud Custodian](https://cloudcustodian.io/) vereint die Tools und Skripte, die viele Unternehmen zur Verwaltung ihrer Public-Cloud-Konten verwenden, in einem Open-Source-Tool. Es verwendet eine Engine für statuslose Regeln zur Definition und Durchsetzung von Richtlinien mit Metriken, strukturierten Ergebnissen und detaillierten Berichten für die Cloud-Infrastruktur. Sie lässt sich eng in eine serverlose Runtime integrieren, um Problembehebung und Reaktion in Echtzeit bei geringem Betriebsaufwand zu ermöglichen. ## Epen ### Richten Sie das ein AWS CLI | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Installiere das AWS CLI. | Folgen Sie den Anweisungen in der [AWS Dokumentation AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html), um das zu installieren. | AWS-Administrator | | Richten Sie AWS Anmeldeinformationen ein. | Konfigurieren Sie die Einstellungen, mit denen die AWS CLI Benutzer interagieren AWS, einschließlich des AWS-Region Ausgabeformats, das Sie verwenden möchten.
$>aws configureWeitere Informationen finden Sie in der [AWS -Dokumentation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html). | AWS-Administrator | | Erstellen Sie eine IAM-Rolle. | Führen Sie den folgenden Befehl aus, um eine IAM-Rolle mit der Lambda-Ausführungsrolle zu erstellen.
AWS Access Key ID [None]:
AWS Secret Access Key [None]:
Default region name [None]:
Default output format [None]:
aws iam create-role --role-name lambda-ex --assume-role-policy-document '{"Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Principal": {"Service": "lambda.amazonaws.com"}, "Action": "sts:AssumeRole"}]} | AWS DevOps |
### Richten Sie Cloud Custodian ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Installieren Sie Cloud Custodian. | Um Cloud Custodian für Ihr Betriebssystem und Ihre Umgebung zu installieren, folgen Sie den Anweisungen in der [Cloud Custodian-Dokumentation](https://cloudcustodian.io/docs/quickstart/index.html#install-cc). | DevOps Ingenieur |
| Überprüfen Sie das Cloud Custodian-Schema. | Verwenden Sie den folgenden Befehl, um die vollständige Liste der Amazon RDS-Ressourcen anzuzeigen, für die Sie Richtlinien ausführen können.custodian schema aws.rds| DevOps Ingenieur | | Erstellen Sie die Cloud Custodian-Richtlinie. | Speichern Sie den Code, der sich unter der *Cloud Custodian-Richtliniendatei* im Abschnitt [Zusätzliche Informationen befindet](#block-public-access-to-amazon-rds-by-using-cloud-custodian-additional), mit einer YAML-Erweiterung. | DevOps Ingenieur | | Definieren Sie Cloud Custodian-Aktionen, um das Kennzeichen „Öffentlich zugänglich“ zu ändern. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/block-public-access-to-amazon-rds-by-using-cloud-custodian.html) | DevOps Ingenieur | | Führen Sie einen Probelauf durch. | (Optional) Verwenden Sie den folgenden Befehl, um zu überprüfen, welche Ressourcen durch die Richtlinie identifiziert werden, ohne Aktionen für die Ressourcen auszuführen.
custodian run -dryrun| DevOps Ingenieur | ### Stellen Sie die Richtlinie bereit | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Stellen Sie die Richtlinie mithilfe von Lambda bereit. | Verwenden Sie den folgenden Befehl, um die Lambda-Funktion zu erstellen, mit der die Richtlinie ausgeführt wird..yaml -s
custodian run -s policy.yamlDiese Richtlinie wird dann durch das AWS CloudTrail `CreateDBInstance` Ereignis initiiert.Daher AWS Lambda wird die Kennzeichnung `false` für öffentlich zugängliche Instanzen, die den Kriterien entsprechen, auf „öffentlich zugänglich“ gesetzt. | DevOps Ingenieur | ## Zugehörige Ressourcen + [AWS Lambda website](https://aws.amazon.com/lambda/) + [Amazon RDS-Webseite](https://aws.amazon.com/rds/) + [Dokumentation zu Cloud Custodian](https://cloudcustodian.io/docs/quickstart/index.html) ## Zusätzliche Informationen **YAML-Datei zur Cloud-Custodian-Richtlinie** ``` policies: - name: "block-public-access" resource: rds description: | This Enforcement blocks public access for RDS instances. mode: type: cloudtrail events: - event: CreateDBInstance # Create RDS instance cloudtrail event source: rds.amazonaws.com ids: requestParameters.dBInstanceIdentifier role: arn:aws:iam::1234567890:role/Custodian-compliance-role filters: - type: event key: 'detail.requestParameters.publiclyAccessible' value: true actions: - type: set-public-access state: false ``` **Datei rds.py für c7n-Ressourcen** ``` @actions.register('set-public-access') class RDSSetPublicAvailability(BaseAction): schema = type_schema( "set-public-access", state={'type': 'boolean'}) permissions = ('rds:ModifyDBInstance',) def set_accessibility(self, r): client = local_session(self.manager.session_factory).client('rds') waiter = client.get_waiter('db_instance_available') waiter.wait(DBInstanceIdentifier=r['DBInstanceIdentifier']) client.modify_db_instance( DBInstanceIdentifier=r['DBInstanceIdentifier'], PubliclyAccessible=self.data.get('state', False)) def process(self, rds): with self.executor_factory(max_workers=2) as w: futures = {w.submit(self.set_accessibility, r): r for r in rds} for f in as_completed(futures): if f.exception(): self.log.error( "Exception setting public access on %s \n %s", futures[f]['DBInstanceIdentifier'], f.exception()) return rds ``` **Security Hub CSPM-Integration** Cloud Custodian kann integriert werden, um Sicherheitsergebnisse [AWS Security Hub CSPM](https://aws.amazon.com/security-hub/)zu senden und Abhilfemaßnahmen zu ergreifen. Weitere Informationen finden Sie unter [Ankündigung der Cloud Custodian-Integration](https://aws.amazon.com/blogs/opensource/announcing-cloud-custodian-integration-aws-security-hub/) mit. AWS Security Hub CSPM # Konfigurieren Sie die Windows-Authentifizierung für Amazon RDS for Microsoft SQL Server mit AWS Managed Microsoft AD *Ramesh Babu Donti, Amazon Web Services* ## Zusammenfassung Dieses Muster zeigt, wie die Windows-Authentifizierung für einen Amazon Relational Database Service (Amazon RDS) für SQL Server-Instances mithilfe von AWS Directory Service for Microsoft Active Directory (AWS Managed Microsoft AD) konfiguriert wird. Die Windows-Authentifizierung ermöglicht es Benutzern, sich mit ihren Domänenanmeldedaten anstelle von datenbankspezifischen Benutzernamen und Passwörtern mit der RDS-Instance zu verbinden. Sie können die Windows-Authentifizierung entweder beim Erstellen einer neuen RDS-SQL Server-Datenbank oder durch Hinzufügen zu einer vorhandenen Datenbankinstanz aktivieren. Die Datenbankinstanz lässt sich integrieren AWS Managed Microsoft AD , um eine zentrale Authentifizierung und Autorisierung für Domänenbenutzer bereitzustellen, die auf die SQL Server-Datenbank zugreifen. Diese Konfiguration erhöht die Sicherheit, indem sie die bestehende Active Directory-Infrastruktur nutzt und die Verwaltung separater Datenbankanmeldeinformationen für Domänenbenutzer überflüssig macht. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein Aktiv AWS-Konto mit den entsprechenden Berechtigungen + Eine virtuelle private Cloud (VPC) mit folgenden Funktionen: + Konfigurierte Internet-Gateways und Routing-Tabellen + NAT-Gateways in öffentlichen Subnetzen (wenn für Instanzen Internetzugang erforderlich ist) + AWS Identity and Access Management (IAM) -Rollen: + Eine Domänenrolle mit den folgenden AWS verwalteten Richtlinien: + `AmazonSSMManagedInstanceCore`um zu aktivieren AWS Systems Manager + `AmazonSSMDirectoryServiceAccess`um Berechtigungen zum Verbinden von Instanzen mit Verzeichnissen bereitzustellen + Eine erweiterte RDS-Überwachungsrolle (wenn die erweiterte Überwachung aktiviert ist) + Sicherheitsgruppen: + Sicherheitsgruppe für den Verzeichnisdienst, um Active Directory-Kommunikationsports zuzulassen + Eine Amazon Elastic Compute Cloud (Amazon EC2) -Sicherheitsgruppe, die RDP `3389` - und Domain-Kommunikation ermöglicht + Eine RDS-Sicherheitsgruppe, die SQL Server-Ports `1433` von autorisierten Quellen zulässt + Netzwerk-Konnektivität: + Richtige DNS-Auflösung und Netzwerkkonnektivität zwischen Subnetzen **Einschränkungen** + Informationen zu AWS-Regionen dieser Unterstützung AWS Managed Microsoft AD mit RDS für SQL Server finden Sie unter [Verfügbarkeit von Regionen und Versionen](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerWinAuth.html#USER_SQLServerWinAuth.RegionVersionAvailability). + Einige AWS-Services sind nicht in allen verfügbar AWS-Regionen. Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie [AWS-Services unter Nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie auf der Seite [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus. ## Architektur **Quelltechnologie-Stack** + Ein lokales Active Directory oder AWS Managed Microsoft AD **Zieltechnologie-Stack** + Amazon EC2 + Amazon RDS für Microsoft SQL Server + AWS Managed Microsoft AD **Zielarchitektur** ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/e02f6059-6631-46f6-819c-5961af7ba4ae/images/1aa50e3b-b4f6-4d44-9f9e-6cbb248a159c.png) Die Architektur umfasst Folgendes: + Eine IAM-Rolle, die die EC2 Amazon-Instance mit der AWS Managed Microsoft AD Domain verbindet. + Eine Amazon EC2 Windows-Instance für Datenbankverwaltung und Tests. + Eine Amazon-VPC mit einem privaten Subnetz zum Hosten der Amazon RDS-Instance und interner Ressourcen in Availability Zones. + Sicherheitsgruppen für die Netzwerkzugriffskontrolle: + Eine Amazon RDS-Sicherheitsgruppe zur Steuerung des eingehenden Zugriffs auf den SQL Server-Port `1433` aus autorisierten Quellen. + Eine EC2 Amazon-Sicherheitsgruppe zur Verwaltung des RDP-Zugriffs über Port `3389` - und Domain-Kommunikationsports. + Eine Directory Services-Sicherheitsgruppe für die Active Directory-Kommunikation über die Ports `53``88`,`389`, und`445`. + AWS Managed Microsoft AD um zentralisierte Authentifizierungs- und Autorisierungsdienste für Windows-Ressourcen bereitzustellen. + Eine Amazon RDS for SQL Server Server-Datenbank-Instance im privaten Subnetz mit aktivierter Windows-Authentifizierung. ## Tools **AWS-Services** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) bietet skalierbare Rechenkapazität in der AWS Cloud. Sie können so viele virtuelle Server wie nötig nutzen und sie schnell nach oben oder unten skalieren. + Amazon Relational Database Service (Amazon RDS) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Datenbank in der. AWS Cloud + [AWS Directory Service](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/what_is.html)bietet mehrere Möglichkeiten, Microsoft Active Directory (AD) mit anderen AWS-Services wie Amazon Elastic Compute Cloud (Amazon EC2), Amazon Relational Database Service (Amazon RDS) für SQL Server und Amazon FSx für Windows File Server zu verwenden. + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)ermöglicht Ihren verzeichnissensitiven Workloads und AWS Ressourcen die Verwendung von Microsoft Active Directory in der. AWS Cloud + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) hilft Ihnen dabei, den Zugriff auf Ihre AWS Ressourcen sicher zu verwalten, indem kontrolliert wird, wer authentifiziert und autorisiert ist, diese zu verwenden. **Andere Dienste** + [Microsoft SQL Server Management Studio (SSMS)](https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) ist ein Tool für die Verwaltung von SQL Server, einschließlich des Zugriffs auf, der Konfiguration und der Verwaltung von SQL Server-Komponenten. ## Best Practices + Allgemeine bewährte Methoden finden Sie unter [Bewährte Methoden für Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_BestPractices.html). ## Epen ### Konfiguration AWS Managed Microsoft AD | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Richten Sie den Verzeichnistyp ein. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Konfigurieren Sie die Verzeichnisinformationen. | Geben Sie im Abschnitt **Verzeichnisinformationen** die erforderlichen Informationen ein und behalten Sie die optionalen Werte bei:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Konfigurieren Sie die VPC und die Subnetze. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Überprüfen und erstellen Sie das Verzeichnis. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | ### Eine EC2 Amazon-Instance erstellen und konfigurieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Konfigurieren Sie ein AMI für Windows. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Konfigurieren von Netzwerkeinstellungen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Speicher konfigurieren. | Konfigurieren Sie die Amazon EBS-Volumes nach Bedarf. | DBA, Ingenieur DevOps | | Konfigurieren Sie erweiterte Details und starten Sie die Instanz. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | ### Erstellen und konfigurieren Sie RDS für SQL Server mit Windows-Authentifizierung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Datenbank und konfigurieren Sie die Engine-Optionen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Auswahl einer Vorlage. | Wählen Sie eine Mustervorlage, die Ihren Anforderungen entspricht. | DBA, Ingenieur DevOps | | Konfigurieren Sie die Datenbankeinstellungen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Konfigurieren Sie die Instanz. | Wählen Sie im Abschnitt **Instanzkonfiguration** unter **DB-Instance-Klasse** eine Instance-Größe aus, die Ihren Anforderungen entspricht. | DBA, Ingenieur DevOps | | Speicher konfigurieren. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Konnektivität konfigurieren. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Konfigurieren Sie die Windows-Authentifizierung. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Konfigurieren Sie die Überwachung. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html)Hinweis: Metriken sind nützlich, wenn Sie sehen möchten, wie verschiedene Prozesse oder Threads die CPU nutzen. Sie können Fehlerprotokolle auch nach Amazon exportieren, CloudWatch wenn das **Fehlerprotokoll** aktiviert ist. | DBA, Ingenieur DevOps | | Konfigurieren Sie zusätzliche Einstellungen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Überprüfen Sie die Kosten und erstellen Sie eine Datenbank. | Sehen Sie sich den Abschnitt **Geschätzte monatliche Kosten** an und wählen Sie dann **Datenbank erstellen** aus. | DBA, Ingenieur DevOps | ### Datenbankzugriff konfigurieren und Verbindungen testen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Connect zum Windows-Computer her. | Connect zu Ihrem Windows-Computer her und starten Sie SQL Server Management Studio.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Konfigurieren Sie die SSMS-Verbindung. | Richten Sie die Datenbankverbindung mithilfe der Windows-Authentifizierung ein.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Konfigurieren Sie Sicherheitseinstellungen. | Stellen Sie die erforderlichen Sicherheitsparameter für SSMS Version 20 oder höher ein.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | | Erstellen Sie ein Windows-Login. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html)
CREATE LOGIN [| DBA, Ingenieur DevOps | | Testen Sie die Windows-Authentifizierung. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-windows-authentication-for-amazon-rds-using-microsoft-ad.html) | DBA, Ingenieur DevOps | ## Zugehörige Ressourcen + [Erstellen Sie Ihre AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) + [Hinzufügen einer Amazon EC2 Windows-Instance zu Ihrer AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/launching_instance.html) + [Unterstützte Regionen und DB-Engines für die Kerberos-Authentifizierung in Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.html) + [Was ist SQL Server Management Studio (SSMS)?](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-ssms) # Kontenübergreifenden Zugriff auf Amazon DynamoDB konfigurieren *Shashi Dalmia, Imhoertha Ojior und Esteban Serna Parra, Amazon Web Services* ## Zusammenfassung In diesem Muster werden die Schritte zur Konfiguration des kontoübergreifenden Zugriffs auf Amazon DynamoDB mithilfe ressourcenbasierter Richtlinien erläutert. Für Workloads, die DynamoDB verwenden, wird es immer üblicher, [Strategien zur Workload-Isolierung](https://aws.amazon.com/solutions/guidance/workload-isolation-on-aws/?did=sl_card&trk=sl_card) zu verwenden, um Sicherheitsbedrohungen zu minimieren und Compliance-Anforderungen zu erfüllen. Die Implementierung von Strategien zur Workload-Isolierung erfordert häufig konto- und regionsübergreifenden Zugriff auf DynamoDB-Ressourcen mithilfe identitätsbasierter AWS Identity and Access Management (IAM-) Richtlinien. Dazu gehören das Festlegen von IAM-Berechtigungen und das Herstellen einer Vertrauensbeziehung zwischen den. AWS-Konten [Ressourcenbasierte Richtlinien für DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-resource-based.html) vereinfachen die Sicherheitslage für kontenübergreifende Workloads erheblich. Dieses Muster enthält Schritte und Beispielcode, um zu demonstrieren, wie Sie AWS Lambda Funktionen in einem konfigurieren können AWS-Konto , um Daten in eine DynamoDB-Datenbanktabelle in einem anderen Konto zu schreiben. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Zwei aktiv. AWS-Konten Dieses Muster bezeichnet diese Konten als *Konto A* und *Konto B.* + AWS Command Line Interface (AWS CLI) für den Zugriff auf Konto A [installiert](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) und [konfiguriert](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html), um die DynamoDB-Tabelle zu erstellen. Die anderen Schritte in diesem Muster enthalten Anweisungen zur Verwendung der IAM-, DynamoDB- und Lambda-Konsolen. Wenn Sie es AWS CLI stattdessen verwenden möchten, konfigurieren Sie es so, dass es auf beide Konten zugreift. **Einschränkungen** + Einige AWS-Services sind nicht in allen verfügbar AWS-Regionen. Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie [AWS-Services unter Nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie auf der Seite [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus. ## Architektur Das folgende Diagramm zeigt eine Architektur mit einem einzigen Konto. AWS Lambda, Amazon Elastic Compute Cloud (Amazon EC2) und DynamoDB befinden sich alle in demselben Konto. In diesem Szenario können Lambda-Funktionen und EC2 Amazon-Instances auf DynamoDB zugreifen. Um Zugriff auf die DynamoDB-Tabelle zu gewähren, können Sie eine identitätsbasierte Richtlinie in IAM oder eine ressourcenbasierte Richtlinie in DynamoDB erstellen. ![\[Verwenden von IAM-Berechtigungen für den Zugriff auf eine DynamoDB-Tabelle im selben Konto.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/bfc32fe8-5db0-4cac-a30f-b870a1a82875/images/cbb009eb-422d-4833-a1bc-0c571d83c21f.png) Das folgende Diagramm zeigt eine Architektur mit mehreren Konten. Wenn Ressourcen in einem AWS-Konto Konto Zugriff auf eine DynamoDB-Tabelle in einem anderen Konto benötigen, müssen Sie in DynamoDB eine ressourcenbasierte Richtlinie einrichten, um den erforderlichen Zugriff zu gewähren. Im folgenden Diagramm wird beispielsweise einer Lambda-Funktion in Konto B mithilfe einer ressourcenbasierten Richtlinie Zugriff auf die DynamoDB-Tabelle in Konto A gewährt. ![\[Verwenden einer ressourcenbasierten Richtlinie für den Zugriff auf eine DynamoDB-Tabelle in einem anderen Konto.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/bfc32fe8-5db0-4cac-a30f-b870a1a82875/images/9f9165a8-b767-4427-a2ae-31b5b8c83326.png) Dieses Muster beschreibt den kontenübergreifenden Zugriff zwischen Lambda und DynamoDB. Sie können ähnliche Schritte für andere Konten verwenden, AWS-Services wenn die entsprechenden Berechtigungen für beide Konten konfiguriert sind. Wenn Sie beispielsweise einer Lambda-Funktion Zugriff auf einen Amazon Simple Storage Service (Amazon S3) -Bucket in Konto A gewähren möchten, können Sie eine [ressourcenbasierte Richtlinie](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-policies.html) in Amazon S3 erstellen und die Berechtigungen zur [Lambda-Ausführungsrolle](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) in Konto B hinzufügen. ## Tools **AWS-Services** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) ist ein vollständig verwalteter NoSQL-Datenbank-Service, der schnelle und planbare Leistung mit nahtloser Skalierbarkeit bereitstellt. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) hilft Ihnen dabei, den Zugriff auf Ihre AWS-Ressourcen sicher zu verwalten, indem kontrolliert wird, wer authentifiziert und autorisiert ist, sie zu verwenden. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Datenverarbeitungsservice, mit dem Sie Code ausführen können, ohne dass Sie Server bereitstellen oder verwalten müssen. Es führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen. **Code** Dieses Muster enthält Beispielcode im Abschnitt [Zusätzliche Informationen](#configure-cross-account-access-to-amazon-dynamodb-additional), der zeigt, wie Sie eine Lambda-Funktion in Konto B so konfigurieren können, dass sie in die DynamoDB-Tabelle in Konto A schreibt. Der Code wird nur zur Veranschaulichung und zu Testzwecken bereitgestellt. Wenn Sie dieses Muster in einer Produktionsumgebung implementieren, verwenden Sie den Code als Referenz und passen Sie ihn an Ihre eigene Umgebung an. ## Best Practices + Folgen Sie den [Best Practices für ressourcenbasierte Richtlinien](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/rbac-best-practices.html) in der DynamoDB-Dokumentation. + Folgen Sie dem Prinzip der geringsten Rechte und gewähren Sie die für die Ausführung einer Aufgabe erforderlichen Mindestberechtigungen. Weitere Informationen finden Sie in der IAM-Dokumentation unter [Gewährung der geringsten Rechte](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) und [bewährte Methoden zur Sicherheit](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html). ## Epen ### Erstellen Sie eine IAM-Richtlinie und -Rolle für die Lambda-Funktion in Konto B | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Richtlinie in Konto B. | Diese IAM-Richtlinie ermöglicht die [PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html)Aktion für eine DynamoDB-Tabelle in Konto A.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | Allgemeines AWS | | Erstellen Sie eine Rolle in Konto B. | Die Lambda-Funktion in Konto B verwendet diese IAM-Rolle, um auf die DynamoDB-Tabelle in Konto A zuzugreifen.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Weitere Informationen zum Erstellen von Rollen finden Sie in der [IAM-Dokumentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html). | Allgemeines AWS | | Beachten Sie die Rollen-ARN. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | Allgemeines AWS | ### Erstellen Sie eine DynamoDB-Tabelle in Konto A | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine DynamoDB-Tabelle. | Verwenden Sie den folgenden AWS CLI Befehl, um eine DynamoDB-Tabelle zu erstellen.\ ] FROM WINDOWS;
GO
aws dynamodb create-table \Ersetzen Sie in diesem Codebeispiel Folgendes:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Sie geben die ressourcenbasierte Richtlinienkonfiguration in der `create-table` Anweisung mithilfe des `--resource-policy` Flags an. Diese Richtlinie bezieht sich auf den ARN für die DynamoDB-Tabelle in Konto A.Weitere Informationen zum Erstellen von Tabellen finden Sie in der [DynamoDB-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html). | Allgemeines AWS | ### Erstellen Sie eine Lambda-Funktion in Konto B | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Lambda-Funktion, um Daten in DynamoDB zu schreiben. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)Weitere Informationen zum Erstellen von Lambda-Funktionen finden Sie in der [Lambda-Dokumentation](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html). | Allgemeines AWS | ### Bereinigen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Löschen Sie -Ressourcen. | Um zu vermeiden, dass im Zusammenhang mit den nach diesem Muster erstellten Ressourcen Kosten anfallen, gehen Sie wie folgt vor, um diese Ressourcen zu löschen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) | Allgemeines AWS | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | Beim Erstellen der Lambda-Funktion erhalten Sie eine `ResourceNotFoundException` Fehlermeldung. | Vergewissern Sie sich, dass Sie die ID AWS-Region und die ID von Konto A korrekt eingegeben haben. Diese sind Teil des ARN für die DynamoDB-Tabelle. | ## Zugehörige Ressourcen + [Erste Schritte mit DynamoDB (DynamoDB-Dokumentation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html)) + [Erste Schritte mit Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) (Lambda-Dokumentation) + [Verwenden ressourcenbasierter Richtlinien für DynamoDB (DynamoDB-Dokumentation)](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-resource-based.html) + [IAM-Richtlinien erstellen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) (IAM-Dokumentation) + [Logik zur kontenübergreifenden Bewertung von Richtlinien (IAM-Dokumentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html)) + [Referenz zu den IAM-JSON-Richtlinienelementen](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) (IAM-Dokumentation) ## Zusätzliche Informationen *Beispielcode* ``` import boto3 from datetime import datetime dynamodb_client = boto3.client('dynamodb') def lambda_handler(event, context): now = datetime.now().isoformat() data = dynamodb_client.put_item(TableName='arn:aws:dynamodb:
--table-name Table-Account-A \
--attribute-definitions \
AttributeName=category,AttributeType=S \
AttributeName=item,AttributeType=S \
--key-schema \
AttributeName=category,KeyType=HASH \
AttributeName=item,KeyType=RANGE \
--provisioned-throughput \
ReadCapacityUnits=5,WriteCapacityUnits=5 \
--resource-policy \
'{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Statement1",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::role/ "
},
"Action": "dynamodb:PutItem",
"Resource": "arn:aws:dynamodb:: :table/Table-Account-A"
}
]
}'
SELECT SERVERPROPERTY('ComputernamePhysicalNetBios') .In der Ausgabe wird der aktuelle Name des sekundären Replikats (`WSFCNODE1`) angezeigt. | DBA |
## Fehlerbehebung
| Problem | Lösung |
| --- | --- |
| Das Erstellen des Listeners schlägt fehl und es wird die Meldung „Der WSFC-Cluster konnte die Netzwerknamenressource nicht online bringen“ angezeigt. | Weitere Informationen finden Sie im Microsoft-Blogbeitrag [Create Listener Fails with Message 'The WSFC-Cluster could not bring the Network Name resource online'](https://techcommunity.microsoft.com/t5/sql-server-support-blog/create-listener-fails-with-message-the-wsfc-cluster-could-not/ba-p/318235). |
| Mögliche Probleme, einschließlich anderer Listener-Probleme oder Netzwerkzugriffsprobleme. | Weitere Informationen finden Sie unter [Problembehandlung bei der Konfiguration von Always-On-Verfügbarkeitsgruppen (SQL Server)](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/troubleshoot-always-on-availability-groups-configuration-sql-server?view=sql-server-ver16) in der Microsoft-Dokumentation. |
## Zugehörige Ressourcen
+ [Konfigurieren Sie schreibgeschütztes Routing für eine Always-On-Verfügbarkeitsgruppe](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/configure-read-only-routing-for-an-availability-group-sql-server?view=sql-server-ver16)
+ [Problembehandlung bei der Konfiguration von AlwaysOn-Verfügbarkeitsgruppen (SQL Server)](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/troubleshoot-always-on-availability-groups-configuration-sql-server?view=sql-server-ver16)
## Zusätzliche Informationen
**Schritt 1. Aktualisieren Sie die Replikate auf schreibgeschützt**
```
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE1' WITH (SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY))
GO
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE2' WITH (SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY))
GO
```
**Schritt 2. Erstellen Sie die Routing-URL**
```
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE1' WITH (SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://WSFCNode1.tagechtalk.com:1433'))
GO
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE2' WITH (SECONDARY_ROLE (READ_ONLY_ROUTING_URL = N'TCP://WSFCNode2.tagechtalk.com:1433'))
GO
```
**Schritt 3. Erstellen Sie die Routing-Liste**
```
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE1' WITH (PRIMARY_ROLE(READ_ONLY_ROUTING_LIST=('WSFCNODE2','WSFCNODE1')));
GO
ALTER AVAILABILITY GROUP [SQLAG1] MODIFY REPLICA ON N'WSFCNODE2' WITH (PRIMARY_ROLE (READ_ONLY_ROUTING_LIST=('WSFCNODE1','WSFCNODE2')));
GO
```
**Schritt 4. Validieren Sie die Routing-Liste**
```
SELECT AGSrc.replica_server_name AS PrimaryReplica, AGRepl.replica_server_name AS ReadOnlyReplica, AGRepl.read_only_routing_url AS RoutingURL , AGRL.routing_priority AS RoutingPriority FROM sys.availability_read_only_routing_lists AGRL INNER JOIN sys.availability_replicas AGSrc ON AGRL.replica_id = AGSrc.replica_id INNER JOIN sys.availability_replicas AGRepl ON AGRL.read_only_replica_id = AGRepl.replica_id INNER JOIN sys.availability_groups AV ON AV.group_id = AGSrc.group_id ORDER BY PrimaryReplica
```
**Schritt 5. SQL-Befehlsdienstprogramm**
```
sqlcmd -S SQLAG1,1433 -E -d test -K ReadOnly
```
# Stellen Sie eine Connect über einen SSH-Tunnel in pgAdmin her
*Jeevan Shetty und Bhanu Ganesh Gudivada, Amazon Web Services*
## Zusammenfassung
Aus Sicherheitsgründen ist es immer gut, Datenbanken in einem privaten Subnetz zu platzieren. Abfragen an der Datenbank können ausgeführt werden, indem eine Verbindung über einen Amazon Elastic Compute Cloud (Amazon EC2) -Bastion-Host in einem öffentlichen Subnetz in der Amazon Web Services (AWS) Cloud hergestellt wird. Dies erfordert die Installation von Software wie pgAdmin oder DBeaver, die häufig von Entwicklern oder Datenbankadministratoren verwendet werden, auf dem EC2 Amazon-Host.
Das Ausführen von pgAdmin auf einem Linux-Server und der Zugriff darauf über einen Webbrowser erfordert die Installation zusätzlicher Abhängigkeiten, die Einrichtung von Berechtigungen und die Konfiguration.
Als alternative Lösung können Entwickler oder Datenbankadministratoren eine Verbindung zu einer PostgreSQL-Datenbank herstellen, indem sie pgAdmin verwenden, um einen SSH-Tunnel von ihrem lokalen System aus zu aktivieren. Bei diesem Ansatz verwendet pgAdmin den EC2 Amazon-Host im öffentlichen Subnetz als Zwischenhost, bevor eine Verbindung zur Datenbank hergestellt wird. Das Diagramm im Abschnitt *Architektur* zeigt das Setup.
**Anmerkung**
Stellen Sie sicher, dass die an die PostgreSQL-Datenbank angehängte Sicherheitsgruppe eine Verbindung über Port 5432 vom Amazon-Host aus zulässt. EC2
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein bestehendes AWS-Konto
+ Eine virtuelle private Cloud (VPC) mit einem öffentlichen Subnetz und einem privaten Subnetz
+ Eine EC2 Instanz mit einer angehängten Sicherheitsgruppe
+ Eine Amazon Aurora PostgreSQL-kompatible Edition-Datenbank mit einer angehängten Sicherheitsgruppe
+ Ein Secure Shell (SSH) -Schlüsselpaar für die Einrichtung des Tunnels
**Versionen der Produkte**
+ pgAdmin versie 6.2\$1
+ Amazon Aurora PostgreSQL-kompatible Edition, Version 12.7\$1
## Architektur
**Zieltechnologie-Stack**
+ Amazon EC2
+ Amazon Aurora PostgreSQL-kompatibel
**Zielarchitektur**
Das folgende Diagramm zeigt die Verwendung von pgAdmin mit einem SSH-Tunnel, um über ein Internet-Gateway eine Verbindung zu der EC2 Instanz herzustellen, die eine Verbindung zur Datenbank herstellt.
![\[pgAdmin mit SSH-Tunnel stellt über das Internet-Gateway eine Verbindung zur EC2 Instanz her, die eine Verbindung zur Datenbank herstellt.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/7d25d570-5685-4f1a-bef0-212e257cb589/images/4556d930-f9b3-4b65-be5d-d40dd9437d5a.png)
## Tools
**AWS-Services**
+ [Amazon Aurora PostgreSQL-Compatible Edition](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) ist eine vollständig verwaltete, ACID-konforme relationale Datenbank-Engine, die Sie bei der Einrichtung, dem Betrieb und der Skalierung von PostgreSQL-Bereitstellungen unterstützt.
+ [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/ec2/) bietet skalierbare Rechenkapazität in der AWS-Cloud. Sie können so viele virtuelle Server wie nötig nutzen und sie schnell nach oben oder unten skalieren.
**Andere Dienste**
+ [pgAdmin](https://www.pgadmin.org/) ist ein Open-Source-Verwaltungstool für PostgreSQL. Es bietet eine grafische Oberfläche, mit der Sie Datenbankobjekte erstellen, verwalten und verwenden können.
## Epen
### Stellen Sie die Verbindung her
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie einen Server. | Wählen Sie in pgAdmin **Create** und dann **Server** aus. *Zusätzliche Hilfe zur Einrichtung von pgAdmin für die Registrierung eines Servers, die Konfiguration einer Verbindung und die Verbindung über SSH-Tunneling mithilfe des Server-Dialogs finden Sie unter den Links im Abschnitt Verwandte Ressourcen.* | DBA |
| Geben Sie einen Namen für den Server ein. | Geben Sie auf der Registerkarte **Allgemein** einen Namen ein. | DBA |
| Geben Sie die Datenbankdetails ein. | Geben Sie auf der Registerkarte **Verbindung** Werte für Folgendes ein:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/connect-by-using-an-ssh-tunnel-in-pgadmin.html) | DBA |
| Geben Sie die EC2 Amazon-Serverdetails ein. | Geben Sie auf der Registerkarte **SSH-Tunnel** die Details der EC2 Amazon-Instance ein, die sich im öffentlichen Subnetz befindet.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/connect-by-using-an-ssh-tunnel-in-pgadmin.html) | DBA |
| Speichern und verbinden. | Wählen Sie **Speichern**, um die Einrichtung abzuschließen und mithilfe des SSH-Tunnels eine Verbindung zur Aurora PostgreSQL-kompatiblen Datenbank herzustellen. | DBA |
## Zugehörige Ressourcen
+ [Dialogfeld „Server“](https://www.pgadmin.org/docs/pgadmin4/latest/server_dialog.html)
+ [Connect zum Server her](https://www.pgadmin.org/docs/pgadmin4/latest/connect_to_server.html)
# JSON-Oracle-Abfragen in PostgreSQL-Datenbank-SQL konvertieren
*Pinesh Singal und Lokesh Gurram, Amazon Web Services*
## Zusammenfassung
Dieser Migrationsprozess für den Umstieg von der lokalen Umgebung zur Amazon Web Services (AWS) -Cloud verwendet das AWS Schema Conversion Tool (AWS SCT), um den Code aus einer Oracle-Datenbank in eine PostgreSQL-Datenbank zu konvertieren. Der größte Teil des Codes wird automatisch von AWS SCT konvertiert. JSON-bezogene Oracle-Abfragen werden jedoch nicht automatisch konvertiert.
Ab der Version Oracle 12.2 unterstützt Oracle Database verschiedene JSON-Funktionen, die bei der Konvertierung von JSON-basierten Daten in zeilenbasierte Daten helfen. AWS SCT konvertiert JSON-basierte Daten jedoch nicht automatisch in eine Sprache, die von PostgreSQL unterstützt wird.
Dieses Migrationsmuster konzentriert sich hauptsächlich auf die manuelle Konvertierung der JSON-bezogenen Oracle-Abfragen mit Funktionen wie `JSON_OBJECT``JSON_ARRAYAGG`, und `JSON_TABLE` von einer Oracle-Datenbank in eine PostgreSQL-Datenbank.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktives AWS-Konto
+ Eine lokale Oracle-Datenbankinstanz (läuft)
+ Eine Amazon Relational Database Service (Amazon RDS) für PostgreSQL oder Amazon Aurora PostgreSQL-kompatible Edition-Datenbank-Instance (betriebsbereit)
**Einschränkungen**
+ JSON-bezogene Abfragen erfordern ein festes UND-Format. `KEY` `VALUE` Wenn dieses Format nicht verwendet wird, wird das falsche Ergebnis zurückgegeben.
+ Wenn durch eine Änderung der JSON-Struktur neue `KEY` und `VALUE` Paare im Ergebnisabschnitt hinzugefügt werden, muss die entsprechende Prozedur oder Funktion in der SQL-Abfrage geändert werden.
+ Einige JSON-bezogene Funktionen werden in früheren Versionen von Oracle und PostgreSQL unterstützt, verfügen jedoch über weniger Funktionen.
**Produktversionen**
+ Oracle Database Version 12.2 und höher
+ Amazon RDS for PostgreSQL oder Aurora PostgreSQL-kompatible Version 9.5 und höher
+ Aktuelle Version von AWS SCT (getestet mit Version 1.0.664)
## Architektur
**Quelltechnologie-Stack**
+ Eine Oracle-Datenbankinstanz mit Version 19c
**Zieltechnologie-Stack**
+ Eine Amazon RDS for PostgreSQL- oder Aurora PostgreSQL-kompatible Datenbank-Instance mit Version 13
**Zielarchitektur**
![\[Die Beschreibung folgt dem Diagramm.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/5e2c3b07-9ef5-417f-b049-bcea58f2c3ec/images/2ff8b00b-8849-4ef1-9be1-579f7b51be10.png)
1. Verwenden Sie AWS SCT mit dem JSON-Funktionscode, um den Quellcode von Oracle nach PostgreSQL zu konvertieren.
1. Die Konvertierung erzeugt PostgreSQL-unterstützte migrierte .sql-Dateien.
1. Konvertieren Sie die nicht konvertierten Oracle-JSON-Funktionscodes manuell in PostgreSQL-JSON-Funktionscodes.
1. Führen Sie die .sql-Dateien auf der Aurora PostgreSQL-kompatiblen Ziel-DB-Instance aus.
## Tools
**AWS-Services**
+ [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) ist eine vollständig verwaltete relationale Datenbank-Engine, die für die Cloud entwickelt wurde und mit MySQL und PostgreSQL kompatibel ist.
+ [Amazon Relational Database Service (Amazon RDS) für PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen PostgreSQL-Datenbank in der AWS-Cloud.
+ Das [AWS Schema Conversion Tool (AWS SCT)](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) unterstützt heterogene Datenbankmigrationen, indem das Quelldatenbankschema und ein Großteil des benutzerdefinierten Codes automatisch in ein Format konvertiert werden, das mit der Zieldatenbank kompatibel ist.
**Andere Dienste**
+ [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) ist eine integrierte Entwicklungsumgebung, die die Entwicklung und Verwaltung von Oracle-Datenbanken sowohl in herkömmlichen als auch in Cloud-basierten Bereitstellungen vereinfacht.
+ pgAdmin oder DBeaver. [pgAdmin](https://www.pgadmin.org/) ist ein Open-Source-Verwaltungstool für PostgreSQL. Es bietet eine grafische Oberfläche, mit der Sie Datenbankobjekte erstellen, verwalten und verwenden können. [DBeaver](https://dbeaver.io/)ist ein universelles Datenbanktool.
## Best Practices
Die Oracle-Abfrage verwendet `CAST` standardmäßig den Typ, wenn die `JSON_TABLE` Funktion verwendet wird. Eine bewährte Methode ist die Verwendung auch `CAST` in PostgreSQL, wobei das Doppelte größer als Zeichen () verwendet wird. `>>`
*Weitere Informationen finden Sie unter *Postgres\$1SQL\$1Read\$1JSON* im Abschnitt Zusätzliche Informationen.*
## Epen
### Generieren Sie die JSON-Daten in den Oracle- und PostgreSQL-Datenbanken
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Speichern Sie die JSON-Daten in der Oracle-Datenbank. | Erstellen Sie eine Tabelle in der Oracle-Datenbank und speichern Sie die JSON-Daten in der `CLOB` Spalte. *Verwenden Sie das *Oracle\$1Table\$1Creation\$1Insert\$1Script*, das sich im Abschnitt Zusätzliche Informationen befindet.* | Migrationsingenieur |
| Speichern Sie die JSON-Daten in der PostgreSQL-Datenbank. | Erstellen Sie eine Tabelle in der PostgreSQL-Datenbank und speichern Sie die JSON-Daten in der `TEXT` Spalte. *Verwenden Sie das *Postgres\$1Table\$1Creation\$1Insert\$1Script*, das sich im Abschnitt Zusätzliche Informationen befindet.* | Migrationsingenieur |
### Konvertiert das JSON in das ROW-Format
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Konvertieren Sie die JSON-Daten in der Oracle-Datenbank. | Schreiben Sie eine Oracle-SQL-Abfrage, um die JSON-Daten in das ROW-Format zu lesen. *Weitere Informationen und eine Beispielsyntax finden Sie unter *Oracle\$1SQL\$1Read\$1JSON* im Abschnitt Zusätzliche Informationen.* | Migrationsingenieur |
| Konvertiert die JSON-Daten in der PostgreSQL-Datenbank. | Schreiben Sie eine PostgreSQL-Abfrage, um die JSON-Daten in das ROW-Format zu lesen. *Weitere Informationen und eine Beispielsyntax finden Sie unter *Postgres\$1SQL\$1Read\$1JSON* im Abschnitt Zusätzliche Informationen.* | Migrationsingenieur |
### Konvertieren Sie die JSON-Daten manuell mithilfe der SQL-Abfrage und melden Sie die Ausgabe im JSON-Format
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Führen Sie Aggregationen und Validierungen für die Oracle SQL-Abfrage durch. | Um die JSON-Daten manuell zu konvertieren, führen Sie eine Verknüpfung, Aggregation und Validierung der Oracle SQL-Abfrage durch und melden Sie die Ausgabe im JSON-Format. *Verwenden Sie den Code unter *Oracle\$1SQL\$1JSON\$1Aggregation\$1Join im Abschnitt Zusätzliche Informationen*.*[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/convert-json-oracle-queries-into-postgresql-database-sql.html) | Ingenieur für Migration |
| Führen Sie Aggregationen und Validierungen für die Postgres-SQL-Abfrage durch. | Um die JSON-Daten manuell zu konvertieren, führen Sie eine Verknüpfung, Aggregation und Validierung der PostgreSQL-Abfrage durch und melden Sie die Ausgabe im JSON-Format. *Verwenden Sie den Code unter *Postgres\$1SQL\$1JSON\$1Aggregation\$1Join* im Abschnitt Zusätzliche Informationen.*[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/convert-json-oracle-queries-into-postgresql-database-sql.html) | Ingenieur für Migration |
### Konvertieren Sie die Oracle-Prozedur in eine PostgreSQL-Funktion, die JSON-Abfragen enthält
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Konvertieren Sie die JSON-Abfragen in der Oracle-Prozedur in Zeilen. | *Verwenden Sie für die Oracle-Beispielprozedur die vorherige Oracle-Abfrage und den Code unter *Oracle\$1Procedure\$1with\$1JSON\$1Query* im Abschnitt Zusätzliche Informationen.* | Ingenieur für Migration |
| Konvertieren Sie die PostgreSQL-Funktionen mit JSON-Abfragen in zeilenbasierte Daten. | *Verwenden Sie für die PostgreSQL-Beispielfunktionen die vorherige PostgreSQL-Abfrage und den Code, der sich unter *Postgres\$1Function\$1with\$1JSON\$1Query* im Abschnitt Zusätzliche Informationen befindet.* | Migrationsingenieur |
## Zugehörige Ressourcen
+ [Oracle JSON-Funktionen](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/adjsn/generation.html)
+ [PostgreSQL JSON-Funktionen](https://www.postgresql.org/docs/13/functions-json.html)
+ [Beispiele für Oracle JSON-Funktionen](https://oracle-base.com/articles/12c/sql-json-functions-12cr2)
+ [Beispiele für PostgreSQL JSON-Funktionen](https://dba.stackexchange.com/questions/69655/select-columns-inside-json-agg)
+ [AWS-Schemakonvertierungstool](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html)
## Zusätzliche Informationen
Verwenden Sie die folgenden Skripten der Reihe nach, um JSON-Code von der Oracle-Datenbank in die PostgreSQL-Datenbank zu konvertieren.
**1. Oracle\$1Table\$1Creation\$1Insert\$1Script**
```
create table aws_test_table(id number,created_on date default sysdate,modified_on date,json_doc clob);
REM INSERTING into EXPORT_TABLE
SET DEFINE OFF;
Insert into aws_test_table (ID,CREATED_ON,MODIFIED_ON,json_doc)
values (1,to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),TO_CLOB(q'[{
"metadata" : {
"upperLastNameFirstName" : "ABC XYZ",
"upperEmailAddress" : "abc@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "032323323",
"displayName" : "Abc, Xyz",
"firstName" : "Xyz",
"lastName" : "Abc",
"emailAddress" : "abc@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0100",
"arrayPattern" : " -'",
"a]')
|| TO_CLOB(q'[ccount" : {
"companyId" : "SMGE",
"businessUnitId" : 7,
"accountNumber" : 42000,
"parentAccountNumber" : 32000,
"firstName" : "john",
"lastName" : "doe",
"street1" : "retOdertcaShr ",
"city" : "new york",
"postalcode" : "XY ABC",
"country" : "United States"
},
"products" : [
{
"appUserGuid" : "i0acc4450000001823fbad478e2eab8a0",
"id" : "0000000046",
]')
|| TO_CLOB(q'[ "name" : "ProView",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}]'));
Insert into aws_test_table (ID,CREATED_ON,MODIFIED_ON,json_doc) values (2,to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),to_date('02-AUG-2022 12:30:14','DD-MON-YYYY HH24:MI:SS'),TO_CLOB(q'[{
"metadata" : {
"upperLastNameFirstName" : "PQR XYZ",
"upperEmailAddress" : "pqr@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "54534343",
"displayName" : "Xyz, pqr",
"firstName" : "pqr",
"lastName" : "Xyz",
"emailAddress" : "pqr@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0090",
"arrayPattern" : " -'",
"account" : {
"companyId" : "CARS",
"busin]')
|| TO_CLOB(q'[essUnitId" : 6,
"accountNumber" : 42001,
"parentAccountNumber" : 32001,
"firstName" : "terry",
"lastName" : "whitlock",
"street1" : "UO 123",
"city" : "TOTORON",
"region" : "NO",
"postalcode" : "LKM 111",
"country" : "Canada"
},
"products" : [
{
"appUserGuid" : "ia744d7790000016899f8cf3f417d6df6",
"id" : "0000000014",
"name" : "ProView eLooseleaf",
]')
|| TO_CLOB(q'[ "domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}]'));
commit;
```
**2. Postgres\$1Table\$1Creation\$1Insert\$1Script**
```
create table aws_test_pg_table(id int,created_on date ,modified_on date,json_doc text);
insert into aws_test_pg_table(id,created_on,modified_on,json_doc)
values(1,now(),now(),'{
"metadata" : {
"upperLastNameFirstName" : "ABC XYZ",
"upperEmailAddress" : "abc@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "032323323",
"displayName" : "Abc, Xyz",
"firstName" : "Xyz",
"lastName" : "Abc",
"emailAddress" : "abc@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0100",
"arrayPattern" : " -",
"account" : {
"companyId" : "SMGE",
"businessUnitId" : 7,
"accountNumber" : 42000,
"parentAccountNumber" : 32000,
"firstName" : "john",
"lastName" : "doe",
"street1" : "retOdertcaShr ",
"city" : "new york",
"postalcode" : "XY ABC",
"country" : "United States"
},
"products" : [
{
"appUserGuid" : "i0acc4450000001823fbad478e2eab8a0",
"id" : "0000000046",
"name" : "ProView",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}');
insert into aws_test_pg_table(id,created_on,modified_on,json_doc)
values(2,now(),now(),'{
"metadata" : {
"upperLastNameFirstName" : "PQR XYZ",
"upperEmailAddress" : "pqr@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "54534343",
"displayName" : "Xyz, pqr",
"firstName" : "pqr",
"lastName" : "Xyz",
"emailAddress" : "a*b**@h**.k**",
"productRegistrationStatus" : "Not registered",
"positionId" : "0090",
"arrayPattern" : " -",
"account" : {
"companyId" : "CARS",
"businessUnitId" : 6,
"accountNumber" : 42001,
"parentAccountNumber" : 32001,
"firstName" : "terry",
"lastName" : "whitlock",
"street1" : "UO 123",
"city" : "TOTORON",
"region" : "NO",
"postalcode" : "LKM 111",
"country" : "Canada"
},
"products" : [
{
"appUserGuid" : "ia744d7790000016899f8cf3f417d6df6",
"id" : "0000000014",
"name" : "ProView eLooseleaf",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}');
```
**3. Oracle\$1SQL\$1Read\$1JSON**
Die folgenden Codeblöcke zeigen, wie Oracle JSON-Daten in das Zeilenformat konvertiert werden.
*Beispielabfrage und Syntax*
```
SELECT JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
) ) ) ) FROM
(SELECT tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END) clerk_count
FROM aws_test_table scco,JSON_TABLE ( json_doc, '$' ERROR ON ERROR COLUMNS (
parent_account_number NUMBER PATH
'$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}', '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data
ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number );
```
Das JSON-Dokument speichert die Daten als Sammlungen. Jede Sammlung kann aus `KEY` und aus `VALUE` Paaren bestehen. Jeder `VALUE` kann Verschachtelungen `KEY` und `VALUE` Paare haben. Die folgende Tabelle enthält Informationen zum Lesen der spezifischen Daten `VALUE` aus dem JSON-Dokument.
|
|
| KEY | HIERARCHY oder PATH, die zum Abrufen des WERTS verwendet werden sollen | VALUE |
| --- |--- |--- |
| `profileType` | `metadata` -> `profileType` | „P“ |
| `positionId` | `data` -> `positionId` | „0100" |
| `accountNumber` | `data`-> Konto -> `accountNumber` | 42000 |
In der vorherigen Tabelle `KEY` `profileType` ist der ein `VALUE` von. `metadata` `KEY` Das `KEY` `positionId` ist ein `VALUE` von `data``KEY`. Das `KEY` `accountNumber` ist ein `VALUE` von `account``KEY`, und das `account` `KEY` ist ein `VALUE` von `data``KEY`.
*Beispiel für ein JSON-Dokument*
```
{
"metadata" : {
"upperLastNameFirstName" : "ABC XYZ",
"upperEmailAddress" : "abc@gmail.com",
"profileType" : "P"
},
"data" : {
"onlineContactId" : "032323323",
"displayName" : "Abc, Xyz",
"firstName" : "Xyz",
"lastName" : "Abc",
"emailAddress" : "abc@gmail.com",
"productRegistrationStatus" : "Not registered",
"positionId" : "0100",
"arrayPattern" : " -",
"account" : {
"companyId" : "SMGE",
"businessUnitId" : 7,
"accountNumber" : 42000,
"parentAccountNumber" : 32000,
"firstName" : "john",
"lastName" : "doe",
"street1" : "retOdertcaShr ",
"city" : "new york",
"postalcode" : "XY ABC",
"country" : "United States"
},
"products" : [
{
"appUserGuid" : "i0acc4450000001823fbad478e2eab8a0",
"id" : "0000000046",
"name" : "ProView",
"domain" : "EREADER",
"registrationStatus" : false,
"status" : "11"
}
]
}
}
```
*SQL-Abfrage, die verwendet wird, um die ausgewählten Felder aus dem JSON-Dokument abzurufen*
```
select parent_account_number,account_number,business_unit_id,position_id from aws_test_table aws,JSON_TABLE ( json_doc, '$' ERROR ON ERROR
COLUMNS (
parent_account_number NUMBER PATH '$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId'
)) as sc
```
In der vorherigen Abfrage `JSON_TABLE` ist eine in Oracle integrierte Funktion enthalten, die die JSON-Daten in das Zeilenformat konvertiert. Die Funktion JSON\$1TABLE erwartet Parameter im JSON-Format.
Jedes Element in `COLUMNS` hat ein vordefiniertes`PATH`, und dort wird ein `VALUE` für ein bestimmtes Element geeignetes Objekt im `KEY` Zeilenformat zurückgegeben.
*Ergebnis der vorherigen Abfrage*
|
|
| PARENT\$1ACCOUNT\$1NUMBER | KONTONUMMER | ID DER GESCHÄFTSEINHEIT | POSITIONS-ID |
| --- |--- |--- |--- |
| 32000 | 42000 | 7 | 0 100 |
| 32001 | 42001 | 6 | 0090 |
**4 Postgres\$1SQL\$1Read\$1JSON**
*****Beispielabfrage und Syntax*
```
select *
from (
select (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER as parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER as accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER as businessUnitId,
(json_doc::json->'data'->>'positionId')::VARCHAR as positionId
from aws_test_pg_table) d ;
```
`PATH`Wird in Oracle verwendet, um das spezifische `KEY` und zu identifizieren`VALUE`. PostgreSQL verwendet jedoch ein `HIERARCHY` Modell zum Lesen `KEY` und `VALUE` aus JSON. In den folgenden Beispielen werden dieselben JSON-Daten `Oracle_SQL_Read_JSON` verwendet, die unten erwähnt werden.
*SQL-Abfrage mit dem Typ CAST ist nicht zulässig*
(Wenn Sie die Eingabe erzwingen`CAST`, schlägt die Abfrage mit einem Syntaxfehler fehl.)
```
select *
from (
select (json_doc::json->'data'->'account'->'parentAccountNumber') as parentAccountNumber,
(json_doc::json->'data'->'account'->'accountNumber')as accountNumber,
(json_doc::json->'data'->'account'->'businessUnitId') as businessUnitId,
(json_doc::json->'data'->'positionId')as positionId
from aws_test_pg_table) d ;
```
Wenn Sie einen einzigen Operator für größer als (`>`) verwenden, wird der dafür `VALUE` definierte Wert zurückgegeben. `KEY` Zum Beispiel`KEY`:`positionId`, und`VALUE`:. `"0100"`
Typ `CAST` ist nicht zulässig, wenn Sie den einzelnen Operator „Größer als“ () `>` verwenden.
*SQL-Abfrage mit dem Typ CAST ist zulässig*
```
select *
from (
select (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER as parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER as accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER as businessUnitId,
(json_doc::json->'data'->>'positionId')::varchar as positionId
from aws_test_pg_table) d ;
```
Um den Typ zu verwenden`CAST`, müssen Sie den Operator Double Greater-than verwenden. Wenn Sie den Operator „Größer als“ verwenden, gibt die Abfrage den `VALUE` definierten Operator zurück (z. B.`KEY`:`positionId`, und:). `VALUE` `"0100"` Wenn Sie den Operator für ein doppeltes Größer-als-Zeichen (`>>`) verwenden, wird der tatsächlich dafür definierte Wert zurückgegeben `KEY` (z. B.`KEY`:, und`VALUE`: `positionId``0100`, ohne doppelte Anführungszeichen).
Im vorherigen Fall ist Typ zu, `parentAccountNumber` ist Typ `CAST` zu`INT`, `accountNumber` ist Typ `CAST` zu`INT`, `businessUnitId` ist Typ `CAST` zu `INT` und `positionId` ist Typ `CAST` zu. `VARCHAR`
Die folgenden Tabellen zeigen Abfrageergebnisse, in denen die Rolle des Operators für einen einzelnen Größer-als-Operator (`>`) und des doppelten Größer-als-Operators () erklärt wird. `>>`
In der ersten Tabelle verwendet die Abfrage den einzigen Operator „Größer als“ (). `>` Jede Spalte ist vom Typ JSON und kann nicht in einen anderen Datentyp konvertiert werden.
|
|
| parentAccountNumber | Kontonummer | businessUnitId | Positions-ID |
| --- |--- |--- |--- |
| 2003565430 | 2003564830 | 7 | „0100" |
| 2005284042 | 2005284042 | 6 | „0090" |
| 2000272719 | 2000272719 | 1 | „0100" |
In der zweiten Tabelle verwendet die Abfrage den doppelten Größer-als-Operator (). `>>` Jede Spalte unterstützt den Typ, der auf dem Spaltenwert `CAST` basiert. Zum Beispiel `INTEGER` in diesem Kontext.
|
|
| parentAccountNumber | Kontonummer | businessUnitId | Positions-ID |
| --- |--- |--- |--- |
| 2003565430 | 2003564830 | 7 | 0 100 |
| 2005284042 | 2005284042 | 6 | 0090 |
| 2000272719 | 2000272719 | 1 | 0 100 |
**5. Oracle\$1SQL\$1JSON\$1Aggregation\$1Join**
*Beispiel für eine Abfrage*
```
SELECT
JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
) ) ) )
FROM
(SELECT
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END) clerk_count
FROM aws_test_table scco,JSON_TABLE ( json_doc, '$' ERROR ON ERROR COLUMNS (
parent_account_number NUMBER PATH
'$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}', '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data
ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number
);
```
Um die Daten auf Zeilenebene in das JSON-Format zu konvertieren, verfügt Oracle über integrierte Funktionen wie`JSON_OBJECT`, `JSON_ARRAY``JSON_OBJECTAGG`, und. `JSON_ARRAYAGG`
+ `JSON_OBJECT`akzeptiert zwei Parameter: `KEY` und. `VALUE` Der `KEY` Parameter sollte fest codiert oder statisch sein. Der `VALUE` Parameter wird aus der Tabellenausgabe abgeleitet.
+ `JSON_ARRAYAGG`akzeptiert `JSON_OBJECT` als Parameter. Dies hilft bei der Gruppierung des Satzes von `JSON_OBJECT` Elementen als Liste. Wenn Sie beispielsweise ein `JSON_OBJECT` Element haben, das mehrere Datensätze hat (mehrere `KEY` und `VALUE` Paare im Datensatz), `JSON_ARRAYAGG` fügen Sie den Datensatz an und erstellen eine Liste. Gemäß der Datenstruktursprache `LIST` handelt es sich um eine Gruppe von Elementen. In diesem Zusammenhang `LIST` handelt es sich um eine Gruppe von `JSON_OBJECT` Elementen.
Das folgende Beispiel zeigt ein `JSON_OBJECT` Element.
```
{
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
```
Das nächste Beispiel zeigt zwei `JSON_OBJECT` Elemente, die durch eckige Klammern (`[ ]`) `LIST` gekennzeichnet sind.
```
[
{
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
,
{
"taxProfessionalCount": 2,
"attorneyCount": 1,
"nonAttorneyCount": 3,
"clerkCount":4
}
]
```
*Beispiel für eine SQL-Abfrage*
```
SELECT
JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
)
)
)
)
FROM
(SELECT
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END
) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END
) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END
) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END
) clerk_count
FROM
aws_test_table scco, JSON_TABLE ( json_doc, '$' ERROR ON ERROR
COLUMNS (
parent_account_number NUMBER PATH '$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}', '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number
);
```
*Beispielausgabe der vorherigen SQL-Abfrage*
```
{
"accountCounts": [
{
"businessUnitId": 6,
"parentAccountNumber": 32001,
"accountNumber": 42001,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": 7,
"parentAccountNumber": 32000,
"accountNumber": 42000,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
**6. Postgres\$1SQL\$1JSON\$1Aggregation\$1Join**
Die integrierten Funktionen `JSON_BUILD_OBJECT` von PostgreSQL `JSON_AGG` konvertieren die Daten auf Zeilenebene in das JSON-Format. PostgreSQL `JSON_BUILD_OBJECT` und `JSON_AGG` entsprechen Oracle `JSON_OBJECT` und. `JSON_ARRAYAGG`
*Beispielabfrage*
```
select
JSON_BUILD_OBJECT ('accountCounts',
JSON_AGG(
JSON_BUILD_OBJECT ('businessUnitId',businessUnitId
,'parentAccountNumber',parentAccountNumber
,'accountNumber',accountNumber
,'totalOnlineContactsCount',online_contacts_count,
'countByPosition',
JSON_BUILD_OBJECT (
'taxProfessionalCount',tax_professional_count
,'attorneyCount',attorney_count
,'nonAttorneyCount',non_attorney_count
,'clerkCount',clerk_count
)
)
)
)
from (
with tab as (select * from (
select (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER as parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER as accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER as businessUnitId,
(json_doc::json->'data'->>'positionId')::varchar as positionId
from aws_test_pg_table) a ) ,
tab1 as ( select
(json_array_elements(b.jc -> 'accounts') ->> 'accountNumber')::integer accountNumber,
(json_array_elements(b.jc -> 'accounts') ->> 'businessUnitId')::integer businessUnitId,
(json_array_elements(b.jc -> 'accounts') ->> 'parentAccountNumber')::integer parentAccountNumber
from (
select '{
"accounts": [{
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}, {
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}]
}'::json as jc) b)
select
tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab.positionId::text = '0095' THEN 1 ELSE 0 END) tax_professional_count,
SUM(CASE WHEN tab.positionId::text = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab.positionId::text = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab.positionId::text = '0050' THEN 1 ELSE 0 END) clerk_count
from tab1,tab
where tab.parentAccountNumber::INTEGER=tab1.parentAccountNumber::INTEGER
and tab.accountNumber::INTEGER=tab1.accountNumber::INTEGER
and tab.businessUnitId::INTEGER=tab1.businessUnitId::INTEGER
GROUP BY tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text) a;
```
*Beispielausgabe aus der vorherigen Abfrage*
Die Ausgabe von Oracle und PostgreSQL ist exakt identisch.
```
{
"accountCounts": [
{
"businessUnitId": 6,
"parentAccountNumber": 32001,
"accountNumber": 42001,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": 7,
"parentAccountNumber": 32000,
"accountNumber": 42000,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
**7. Oracle\$1Procedure\$1with\$1JSON\$1Query**
Dieser Code konvertiert die Oracle-Prozedur in eine PostgreSQL-Funktion mit JSON-SQL-Abfragen. Es zeigt, wie die Abfrage JSON in Zeilen und umgekehrt transponiert.
```
CREATE OR REPLACE PROCEDURE p_json_test(p_in_accounts_json IN varchar2, p_out_accunts_json OUT varchar2)
IS
BEGIN
/*
p_in_accounts_json paramter should have following format:
{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}
*/
SELECT
JSON_OBJECT(
'accountCounts' VALUE JSON_ARRAYAGG(
JSON_OBJECT(
'businessUnitId' VALUE business_unit_id,
'parentAccountNumber' VALUE parent_account_number,
'accountNumber' VALUE account_number,
'totalOnlineContactsCount' VALUE online_contacts_count,
'countByPosition' VALUE
JSON_OBJECT(
'taxProfessionalCount' VALUE tax_count,
'attorneyCount' VALUE attorney_count,
'nonAttorneyCount' VALUE non_attorney_count,
'clerkCount' VALUE clerk_count
) ) ) )
into p_out_accunts_json
FROM
(SELECT
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab_data.position_id = '0095' THEN 1 ELSE 0 END) tax_count,
SUM(CASE WHEN tab_data.position_id = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab_data.position_id = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab_data.position_id = '0050' THEN 1 ELSE 0 END) clerk_count
FROM aws_test_table scco,JSON_TABLE ( json_doc, '$' ERROR ON ERROR
COLUMNS (
parent_account_number NUMBER PATH '$.data.account.parentAccountNumber',
account_number NUMBER PATH '$.data.account.accountNumber',
business_unit_id NUMBER PATH '$.data.account.businessUnitId',
position_id VARCHAR2 ( 4 ) PATH '$.data.positionId' )
) AS tab_data
INNER JOIN JSON_TABLE ( p_in_accounts_json, '$.accounts[*]' ERROR ON ERROR
COLUMNS (
parent_account_number PATH '$.parentAccountNumber',
account_number PATH '$.accountNumber',
business_unit_id PATH '$.businessUnitId')
) static_data
ON ( static_data.parent_account_number = tab_data.parent_account_number
AND static_data.account_number = tab_data.account_number
AND static_data.business_unit_id = tab_data.business_unit_id )
GROUP BY
tab_data.business_unit_id,
tab_data.parent_account_number,
tab_data.account_number
);
EXCEPTION
WHEN OTHERS THEN
raise_application_error(-20001,'Error while running the JSON query');
END;
/
```
*Das Verfahren wird ausgeführt*
Der folgende Codeblock erklärt, wie Sie die zuvor erstellte Oracle-Prozedur mit einer Beispiel-JSON-Eingabe für die Prozedur ausführen können. Außerdem erhalten Sie das Ergebnis oder die Ausgabe dieser Prozedur.
```
set serveroutput on;
declare
v_out varchar2(30000);
v_in varchar2(30000):= '{
"accounts": [{
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}, {
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}]
}';
begin
p_json_test(v_in,v_out);
dbms_output.put_line(v_out);
end;
/
```
*Ausgabe der Prozedur*
```
{
"accountCounts": [
{
"businessUnitId": 6,
"parentAccountNumber": 32001,
"accountNumber": 42001,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": 7,
"parentAccountNumber": 32000,
"accountNumber": 42000,
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
**8. Postgres\$1Function\$1with\$1JSON\$1Query**
*Beispielfunktion*
```
CREATE OR REPLACE FUNCTION f_pg_json_test(p_in_accounts_json text)
RETURNS text
LANGUAGE plpgsql
AS
$$
DECLARE
v_out_accunts_json text;
BEGIN
SELECT
JSON_BUILD_OBJECT ('accountCounts',
JSON_AGG(
JSON_BUILD_OBJECT ('businessUnitId',businessUnitId
,'parentAccountNumber',parentAccountNumber
,'accountNumber',accountNumber
,'totalOnlineContactsCount',online_contacts_count,
'countByPosition',
JSON_BUILD_OBJECT (
'taxProfessionalCount',tax_professional_count
,'attorneyCount',attorney_count
,'nonAttorneyCount',non_attorney_count
,'clerkCount',clerk_count
))))
INTO v_out_accunts_json
FROM (
WITH tab AS (SELECT * FROM (
SELECT (json_doc::json->'data'->'account'->>'parentAccountNumber')::INTEGER AS parentAccountNumber,
(json_doc::json->'data'->'account'->>'accountNumber')::INTEGER AS accountNumber,
(json_doc::json->'data'->'account'->>'businessUnitId')::INTEGER AS businessUnitId,
(json_doc::json->'data'->>'positionId')::varchar AS positionId
FROM aws_test_pg_table) a ) ,
tab1 AS ( SELECT
(json_array_elements(b.jc -> 'accounts') ->> 'accountNumber')::integer accountNumber,
(json_array_elements(b.jc -> 'accounts') ->> 'businessUnitId')::integer businessUnitId,
(json_array_elements(b.jc -> 'accounts') ->> 'parentAccountNumber')::integer parentAccountNumber
FROM (
SELECT p_in_accounts_json::json AS jc) b)
SELECT
tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text,
SUM(1) online_contacts_count,
SUM(CASE WHEN tab.positionId::text = '0095' THEN 1 ELSE 0 END) tax_professional_count,
SUM(CASE WHEN tab.positionId::text = '0100' THEN 1 ELSE 0 END) attorney_count,
SUM(CASE WHEN tab.positionId::text = '0090' THEN 1 ELSE 0 END) non_attorney_count,
SUM(CASE WHEN tab.positionId::text = '0050' THEN 1 ELSE 0 END) clerk_count
FROM tab1,tab
WHERE tab.parentAccountNumber::INTEGER=tab1.parentAccountNumber::INTEGER
AND tab.accountNumber::INTEGER=tab1.accountNumber::INTEGER
AND tab.businessUnitId::INTEGER=tab1.businessUnitId::INTEGER
GROUP BY tab.businessUnitId::text,
tab.parentAccountNumber::text,
tab.accountNumber::text) a;
RETURN v_out_accunts_json;
END;
$$;
```
*Die Funktion wird ausgeführt*
```
select f_pg_json_test('{
"accounts": [{
"accountNumber": 42001,
"parentAccountNumber": 32001,
"businessUnitId": 6
}, {
"accountNumber": 42000,
"parentAccountNumber": 32000,
"businessUnitId": 7
}]
}') ;
```
*Ausgabe der Funktion*
Die folgende Ausgabe ähnelt der Ausgabe der Oracle-Prozedur. Der Unterschied besteht darin, dass diese Ausgabe im Textformat vorliegt.
```
{
"accountCounts": [
{
"businessUnitId": "6",
"parentAccountNumber": "32001",
"accountNumber": "42001",
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 0,
"nonAttorneyCount": 1,
"clerkCount": 0
}
},
{
"businessUnitId": "7",
"parentAccountNumber": "32000",
"accountNumber": "42000",
"totalOnlineContactsCount": 1,
"countByPosition": {
"taxProfessionalCount": 0,
"attorneyCount": 1,
"nonAttorneyCount": 0,
"clerkCount": 0
}
}
]
}
```
# Kopieren Sie Amazon DynamoDB-Tabellen zwischen Konten mit AWS Backup
*Ramkumar Ramanujam, Amazon Web Services*
## Zusammenfassung
Wenn Sie mit Amazon DynamoDB arbeiten AWS, besteht ein häufiger Anwendungsfall darin, DynamoDB-Tabellen in Entwicklungs-, Test- oder Staging-Umgebungen mit den Tabellendaten in der Produktionsumgebung zu kopieren oder zu synchronisieren. Standardmäßig verwendet jede Umgebung eine andere. AWS-Konto
AWS Backup unterstützt regionsübergreifende und kontoübergreifende Sicherung und Wiederherstellung von Daten für DynamoDB, Amazon Simple Storage Service (Amazon S3) und andere. AWS-Services Dieses Muster enthält die Schritte für die Verwendung von AWS Backup kontoübergreifender Sicherung und Wiederherstellung, um DynamoDB-Tabellen zwischen diesen zu kopieren. AWS-Konten
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Zwei aktive AWS-Konten , die derselben Organisation angehören in AWS Organizations
+ Berechtigungen zum Erstellen von DynamoDB-Tabellen in beiden Konten
+ AWS Identity and Access Management (IAM) -Berechtigungen zum Erstellen und Verwenden von Tresoren AWS Backup
**Einschränkungen**
+ Quelle und Ziel AWS-Konten sollten Teil derselben Organisation in sein. AWS Organizations
## Architektur
**Zieltechnologie-Stack**
+ AWS Backup
+ Amazon DynamoDB
**Zielarchitektur**
![\[Die Beschreibung des Kopierens von Tabellen zwischen Backup-Tresoren folgt dem Diagramm.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/ef6e7393-edb6-4744-be26-43f1cbff9de9/images/fa9f3f2f-7a01-4093-9bd5-fc355e57ba67.png)
1. Erstellen Sie die DynamoDB-Tabellensicherung im AWS Backup Backup-Tresor des Quellkontos.
1. Kopieren Sie das Backup in den Backup-Tresor im Zielkonto.
1. Stellen Sie die DynamoDB-Tabelle im Zielkonto wieder her, indem Sie die Sicherung aus dem Backup-Tresor im Zielkonto verwenden.
**Automatisierung und Skalierung**
Sie können Backups so AWS Backup planen, dass sie in bestimmten Intervallen ausgeführt werden.
## Tools
+ [AWS Backup](https://docs.aws.amazon.com/aws-backup/latest/devguide/whatisbackup.html)ist ein vollständig verwalteter Service zur Zentralisierung und Automatisierung des Datenschutzes in der Cloud und vor Ort. AWS-Services Mit diesem Service können Sie Backup-Richtlinien konfigurieren und die Aktivitäten für Ihre AWS Ressourcen von einem zentralen Ort aus überwachen. Er ermöglicht Ihnen die Automatisierung und Konsolidierung von Backup-Aufgaben, die zuvor Service für Service ausgeführt wurden, und macht die Erstellung benutzerdefinierter Skripts und manueller Prozesse überflüssig.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) ist ein vollständig verwalteter NoSQL-Datenbankservice, der schnelle und vorhersehbare Leistung mit nahtloser Skalierbarkeit bietet.
## Epen
### Aktiviere AWS Backup Funktionen in den Quell- und Zielkonten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Aktivieren Sie erweiterte Funktionen für DynamoDB und kontoübergreifendes Backup. | Gehen Sie sowohl in der Quelle als auch im Ziel wie AWS-Konten folgt vor:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, Migrationsingenieur |
### Erstellen Sie Backup-Tresore in den Quell- und Zielkonten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie Backup-Tresore. | Gehen Sie sowohl in der Quelle als auch im Ziel AWS-Konten wie folgt vor:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html)Der ARNs des Quell- und des Ziel-Backup-Tresors ist erforderlich, wenn Sie das DynamoDB-Tabellen-Backup zwischen dem Quell- und dem Zielkonto kopieren. | AWS DevOps, Migrationsingenieur |
### Führen Sie Backups und Wiederherstellungen mithilfe von Backup-Tresoren durch
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie im Quellkonto eine DynamoDB-Tabellensicherung. | Gehen Sie wie folgt vor, um ein Backup für die DynamoDB-Tabelle im Quellkonto zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html)Ein neuer Backup-Job wird erstellt. Um den Status des Backup-Jobs zu überwachen, wählen Sie auf der Seite AWS Backup **Jobs** die Registerkarte **Backup-Jobs**. Alle aktiven, laufenden und abgeschlossenen Backup-Jobs werden auf dieser Registerkarte aufgelistet. | AWS DevOps, DBA, Migrationsingenieur |
| Kopieren Sie das Backup vom Quellkonto auf das Zielkonto. | Nachdem der Backup-Job abgeschlossen ist, kopieren Sie die DynamoDB-Tabellensicherung aus dem Backup-Tresor im Quellkonto in den Backup-Tresor im Zielkonto.Gehen Sie wie folgt vor, um den Backup-Tresor im Quellkonto zu kopieren:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, Migrationsingenieur, DBA |
| Stellen Sie das Backup im Zielkonto wieder her. | Gehen Sie im Ziel AWS-Konto wie folgt vor:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-aws-backup.html) | AWS DevOps, DBA, Migrationsingenieur |
## Zugehörige Ressourcen
+ [Verwendung AWS Backup mit DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/backuprestore_HowItWorksAWS.html)
+ [Erstellen von Sicherungskopien auf AWS-Konten](https://docs.aws.amazon.com/aws-backup/latest/devguide/create-cross-account-backup.html)
+ [AWS Backup Preisgestaltung](https://aws.amazon.com/backup/pricing/)
# Amazon DynamoDB-Tabellen mithilfe einer benutzerdefinierten Implementierung kontenübergreifend kopieren
*Ramkumar Ramanujam, Amazon Web Services*
## Zusammenfassung
Bei der Arbeit mit Amazon DynamoDB auf Amazon Web Services (AWS) besteht ein häufiger Anwendungsfall darin, DynamoDB-Tabellen in Entwicklungs-, Test- oder Staging-Umgebungen mit den Tabellendaten in der Produktionsumgebung zu kopieren oder zu synchronisieren. Standardmäßig verwendet jede Umgebung ein anderes AWS-Konto.
DynamoDB unterstützt jetzt kontoübergreifende Backups mit AWS Backup. Informationen zu den damit verbundenen Speicherkosten bei der Nutzung von AWS Backup finden Sie unter [AWS Backup Backup-Preise](https://aws.amazon.com/backup/pricing/). Wenn Sie AWS Backup zum Kopieren zwischen Konten verwenden, müssen die Quell- und Zielkonten Teil einer Organisation von AWS Organizations sein. Es gibt andere Lösungen für kontoübergreifende Sicherung und Wiederherstellung mithilfe von AWS-Services wie AWS Glue. Die Verwendung dieser Lösungen erhöht jedoch den Anwendungsbedarf, da mehr AWS-Services bereitgestellt und verwaltet werden müssen.
Sie können Amazon DynamoDB Streams auch verwenden, um Tabellenänderungen im Quellkonto zu erfassen. Anschließend können Sie eine AWS Lambda Lambda-Funktion initiieren und die entsprechenden Änderungen in der Zieltabelle im Zielkonto vornehmen. Diese Lösung gilt jedoch für Anwendungsfälle, in denen Quell- und Zieltabellen immer synchron gehalten werden müssen. Sie gilt möglicherweise nicht für Entwicklungs-, Test- und Staging-Umgebungen, in denen Daten häufig aktualisiert werden.
Dieses Muster enthält Schritte zur Implementierung einer benutzerdefinierten Lösung zum Kopieren einer Amazon DynamoDB-Tabelle von einem Konto in ein anderes. Dieses Muster kann mit gängigen Programmiersprachen wie C\$1, Java und Python implementiert werden. Wir empfehlen die Verwendung einer Sprache, die von einem [AWS-SDK](https://aws.amazon.com/tools/) unterstützt wird.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Zwei aktive AWS-Konten
+ DynamoDB-Tabellen in beiden Konten
+ Kenntnis der Rollen und Richtlinien von AWS Identity and Access Management (IAM)
+ Kenntnis des Zugriffs auf Amazon DynamoDB-Tabellen mit einer gängigen Programmiersprache wie C\$1, Java oder Python
**Einschränkungen**
Dieses Muster gilt für DynamoDB-Tabellen mit einer Größe von etwa 2 GB oder weniger. Es verfügt über zusätzliche Logik zur Behandlung von Verbindungs- oder Sitzungsunterbrechungen, Drosselungen sowie Ausfällen und Wiederholungsversuchen und kann daher für größere Tabellen verwendet werden.
Der DynamoDB-Scanvorgang, der Elemente aus der Quelltabelle liest, kann in einem einzigen Aufruf nur bis zu 1 MB an Daten abrufen. Bei größeren Tabellen, die größer als 2 GB sind, kann diese Beschränkung die Gesamtzeit bis zum vollständigen Kopieren der Tabelle verlängern.
## Architektur
Das folgende Diagramm zeigt die benutzerdefinierte Implementierung zwischen den AWS-Quell- und Zielkonten. Bei der benutzerdefinierten Implementierung werden IAM-Richtlinien und Sicherheitstoken verwendet. Daten werden aus Amazon DynamoDB im Quellkonto gelesen und im Zielkonto in DynamoDB geschrieben.
![\[Quell- und Zielkontoarchitektur für das Kopieren mithilfe der benutzerdefinierten Implementierung.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/ba8175be-9809-4c2e-b2d1-6b9180ed056c/images/d9d4c2c8-ff04-443f-9137-e37b8e23ccb5.png)
**Automatisierung und Skalierung**
Dieses Muster gilt für DynamoDB-Tabellen, die kleiner sind, etwa 2 GB.
Um dieses Muster auf größere Tabellen anzuwenden, beheben Sie die folgenden Probleme:
+ Während des Tabellenkopiervorgangs werden zwei aktive Sitzungen aufrechterhalten, wobei unterschiedliche Sicherheitstoken verwendet werden. Wenn der Vorgang zum Kopieren der Tabelle länger dauert als die Ablaufzeiten der Token, müssen Sie eine Logik zur Aktualisierung der Sicherheitstoken einrichten.
+ Wenn nicht genügend Lesekapazitätseinheiten (RCUs) und Schreibkapazitätseinheiten (WCUs) bereitgestellt werden, werden Lese- oder Schreibvorgänge in der Quell- oder Zieltabelle möglicherweise gedrosselt. Achten Sie darauf, diese Ausnahmen zu erkennen und zu behandeln.
+ Behandeln Sie alle anderen Fehler oder Ausnahmen und richten Sie einen Wiederholungsmechanismus ein, um es erneut zu versuchen oder an der Stelle fortzusetzen, an der der Kopiervorgang fehlgeschlagen ist.
## Tools
**Tools**
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) — Amazon DynamoDB ist ein vollständig verwalteter NoSQL-Datenbankservice, der schnelle und vorhersehbare Leistung mit nahtloser Skalierbarkeit bietet.
+ Welche zusätzlichen Tools erforderlich sind, hängt von der Programmiersprache ab, die Sie für die Implementierung auswählen. Wenn Sie beispielsweise C\$1 verwenden, benötigen Sie Microsoft Visual Studio und die folgenden NuGet Pakete:
+ `AWSSDK`
+ `AWSSDK.DynamoDBv2`
**Code**
Der folgende Python-Codeausschnitt löscht eine DynamoDB-Tabelle mithilfe der Boto3-Bibliothek und erstellt sie neu.
Verwenden Sie nicht das `AWS_ACCESS_KEY_ID` und `AWS_SECRET_ACCESS_KEY` eines IAM-Benutzers, da es sich dabei um langfristige Anmeldeinformationen handelt, die für den programmatischen Zugriff auf AWS-Services vermieden werden sollten. Weitere Informationen zu temporären Anmeldeinformationen finden Sie im Abschnitt *Bewährte Methoden*.
Die im folgenden Codeausschnitt `TEMPORARY_SESSION_TOKEN` verwendeten `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, und sind temporäre Anmeldeinformationen, die vom AWS Security Token Service (AWS STS) abgerufen wurden.
```
import boto3
import sys
import json
#args = input-parameters = GLOBAL_SEC_INDEXES_JSON_COLLECTION, ATTRIBUTES_JSON_COLLECTION, TARGET_DYNAMODB_NAME, TARGET_REGION, ...
#Input param: GLOBAL_SEC_INDEXES_JSON_COLLECTION
#[{"IndexName":"Test-index","KeySchema":[{"AttributeName":"AppId","KeyType":"HASH"},{"AttributeName":"AppType","KeyType":"RANGE"}],"Projection":{"ProjectionType":"INCLUDE","NonKeyAttributes":["PK","SK","OwnerName","AppVersion"]}}]
#Input param: ATTRIBUTES_JSON_COLLECTION
#[{"AttributeName":"PK","AttributeType":"S"},{"AttributeName":"SK","AttributeType":"S"},{"AttributeName":"AppId","AttributeType":"S"},{"AttributeName":"AppType","AttributeType":"N"}]
region = args['TARGET_REGION']
target_ddb_name = args['TARGET_DYNAMODB_NAME']
global_secondary_indexes = json.loads(args['GLOBAL_SEC_INDEXES_JSON_COLLECTION'])
attribute_definitions = json.loads(args['ATTRIBUTES_JSON_COLLECTION'])
# Drop and create target DynamoDB table
dynamodb_client = boto3.Session(
aws_access_key_id=args['AWS_ACCESS_KEY_ID'],
aws_secret_access_key=args['AWS_SECRET_ACCESS_KEY'],
aws_session_token=args['TEMPORARY_SESSION_TOKEN'],
).client('dynamodb')
# Delete table
print('Deleting table: ' + target_ddb_name + ' ...')
try:
dynamodb_client.delete_table(TableName=target_ddb_name)
#Wait for table deletion to complete
waiter = dynamodb_client.get_waiter('table_not_exists')
waiter.wait(TableName=target_ddb_name)
print('Table deleted.')
except dynamodb_client.exceptions.ResourceNotFoundException:
print('Table already deleted / does not exist.')
pass
print('Creating table: ' + target_ddb_name + ' ...')
table = dynamodb_client.create_table(
TableName=target_ddb_name,
KeySchema=[
{
'AttributeName': 'PK',
'KeyType': 'HASH' # Partition key
},
{
'AttributeName': 'SK',
'KeyType': 'RANGE' # Sort key
}
],
AttributeDefinitions=attribute_definitions,
GlobalSecondaryIndexes=global_secondary_indexes,
BillingMode='PAY_PER_REQUEST'
)
waiter = dynamodb_client.get_waiter('table_exists')
waiter.wait(TableName=target_ddb_name)
print('Table created.')
```
## Best Practices
**Temporäre Anmeldeinformationen**
Aus Sicherheitsgründen sollten Sie beim programmgesteuerten Zugriff auf AWS-Services die Verwendung `AWS_SECRET_ACCESS_KEY` des `AWS_ACCESS_KEY_ID` und eines IAM-Benutzers vermeiden, da es sich dabei um langfristige Anmeldeinformationen handelt. Versuchen Sie immer, temporäre Anmeldeinformationen zu verwenden, um programmgesteuert auf AWS-Services zuzugreifen.
Beispielsweise kodiert ein Entwickler während der Entwicklung das `AWS_ACCESS_KEY_ID` Ende eines IAM-Benutzers in `AWS_SECRET_ACCESS_KEY` der Anwendung fest, kann die hartcodierten Werte jedoch nicht entfernen, bevor die Änderungen in das Code-Repository übertragen werden. Diese offengelegten Anmeldeinformationen können von unbeabsichtigten oder böswilligen Benutzern verwendet werden, was schwerwiegende Folgen haben kann (insbesondere, wenn die offengelegten Anmeldeinformationen Administratorrechte haben). Diese offengelegten Anmeldeinformationen sollten sofort mithilfe der IAM-Konsole oder der AWS-Befehlszeilenschnittstelle (AWS CLI) deaktiviert oder gelöscht werden.
Verwenden Sie AWS STS, um temporäre Anmeldeinformationen für den programmatischen Zugriff auf AWS-Services zu erhalten. Temporäre Anmeldeinformationen sind nur für die angegebene Zeit gültig (von 15 Minuten bis zu 36 Stunden). Die maximal zulässige Dauer temporärer Anmeldeinformationen hängt von Faktoren wie Rolleneinstellungen und Rollenverkettung ab. Weitere Informationen zu AWS STS finden Sie in der [Dokumentation](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html).
## Epen
### DynamoDB-Tabellen einrichten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie DynamoDB-Tabellen. | Erstellen Sie DynamoDB-Tabellen mit Indizes in AWS-Quell- und Zielkonten.Stellen Sie die Kapazitätsbereitstellung auf den On-Demand-Modus ein, sodass DynamoDB read/write Kapazitäten dynamisch auf der Grundlage der Arbeitslast skalieren kann. Alternativ können Sie die bereitgestellte Kapazität mit 4000 und 4000 verwenden. RCUs WCUs | App-Entwickler, DBA, Migrationsingenieur |
| Füllen Sie die Quelltabelle aus. | Füllen Sie die DynamoDB-Tabelle im Quellkonto mit Testdaten auf. Wenn Sie mindestens 50 MB an Testdaten haben, können Sie den Spitzenwert und den RCUs Durchschnittsverbrauch beim Kopieren der Tabelle ermitteln. Anschließend können Sie die Kapazitätsbereitstellung nach Bedarf ändern. | App-Entwickler, DBA, Migrationsingenieur |
### Anmeldeinformationen für den Zugriff auf die DynamoDB-Tabellen einrichten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie IAM-Rollen für den Zugriff auf die DynamoDB-Quell- und Zieltabellen. | Erstellen Sie eine IAM-Rolle im Quellkonto mit Berechtigungen für den Zugriff (das Lesen) der DynamoDB-Tabelle im Quellkonto.Fügen Sie das Quellkonto als vertrauenswürdige Entität für diese Rolle hinzu.Erstellen Sie eine IAM-Rolle im Zielkonto mit Zugriffsberechtigungen (Erstellen, Lesen, Aktualisieren, Löschen) auf die DynamoDB-Tabelle im Zielkonto. Fügen Sie das Zielkonto als vertrauenswürdige Entität für diese Rolle hinzu. | App-Entwickler, AWS DevOps |
### Kopieren Sie Tabellendaten von einem Konto in ein anderes
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Besorgen Sie sich temporäre Anmeldeinformationen für die IAM-Rollen. | Rufen Sie temporäre Anmeldeinformationen für die IAM-Rolle ab, die im Quellkonto erstellt wurde.Rufen Sie temporäre Anmeldeinformationen für die im Zielkonto erstellte IAM-Rolle ab.Eine Möglichkeit, die temporären Anmeldeinformationen für die IAM-Rolle abzurufen, besteht darin, AWS STS über die AWS-CLI zu verwenden.aws sts assume-role --role-arn arn:aws:iam::Verwenden Sie das entsprechende AWS-Profil (entspricht dem Quell- oder Zielkonto).Weitere Informationen zu den verschiedenen Möglichkeiten, temporäre Anmeldeinformationen zu erhalten, finden Sie im Folgenden:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html) | App-Entwickler, Migrationsingenieur | | Initialisieren Sie die DynamoDB-Clients für den Quell- und Ziel-DynamoDB-Zugriff. | Initialisieren Sie die DynamoDB-Clients, die vom AWS-SDK bereitgestellt werden, für die DynamoDB-Quell- und Zieltabellen.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)Weitere Informationen zum Stellen von Anfragen mithilfe temporärer IAM-Anmeldeinformationen finden Sie in der [AWS-Dokumentation](https://docs.aws.amazon.com/AmazonS3/latest/userguide/AuthUsingTempSessionToken.html). | App-Developer | | Löschen Sie die Zieltabelle und erstellen Sie sie neu. | Löschen Sie die DynamoDB-Zieltabelle (zusammen mit den Indizes) im Zielkonto und erstellen Sie sie neu, indem Sie den DynamoDB-Client für das Zielkonto verwenden.Das Löschen aller Datensätze aus einer DynamoDB-Tabelle ist ein kostspieliger Vorgang, da dafür bereitgestellte Daten verbraucht werden. WCUs Durch das Löschen und Neuerstellen der Tabelle werden diese zusätzlichen Kosten vermieden.Sie können einer Tabelle Indizes hinzufügen, nachdem Sie sie erstellt haben, aber das dauert 2—5 Minuten länger. Das Erstellen von Indizes während der Tabellenerstellung, indem die Indexsammlung an den `createTable` Aufruf übergeben wird, ist effizienter. | App-Developer | | Führen Sie die Tabellenkopie durch. | Wiederholen Sie die folgenden Schritte, bis alle Daten kopiert sind:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/copy-amazon-dynamodb-tables-across-accounts-using-a-custom-implementation.html)*Weitere Informationen finden Sie in der Referenzimplementierung in C\$1 (zum Löschen, Erstellen und Auffüllen von Tabellen) im Abschnitt Anlagen.* Ein Beispiel für eine JavaScript Objektnotationsdatei (JSON) für die Tabellenkonfiguration ist ebenfalls angehängt. | App-Developer | ## Zugehörige Ressourcen + [Dokumentation zu Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) + [Einen IAM-Benutzer in Ihrem AWS-Konto erstellen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html) + [AWS SDKs](https://aws.amazon.com/tools/) + [Temporäre Anmeldeinformationen mit AWS-Ressourcen verwenden](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) ## Zusätzliche Informationen Dieses Muster wurde mithilfe von C\$1 implementiert, um eine DynamoDB-Tabelle mit 200.000 Elementen (durchschnittliche Elementgröße von 5 KB und Tabellengröße von 250 MB) zu kopieren. Die DynamoDB-Zieltabelle wurde mit einer bereitgestellten Kapazität von 4000 und 4000 RCUs eingerichtet. WCUs Das vollständige Kopieren der Tabelle (vom Quellkonto zum Zielkonto), einschließlich Löschen und Neuerstellen der Tabelle, dauerte 5 Minuten. Insgesamt verbrauchte Kapazitätseinheiten: 30.000 RCUs und etwa 400.000 WCUs. Weitere Informationen zu DynamoDB-Kapazitätsmodi finden Sie unter [Kapazitätsmodus Lesen/Schreiben](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html) in der AWS-Dokumentation. ## Anlagen [Um auf zusätzliche Inhalte zuzugreifen, die mit diesem Dokument verknüpft sind, entpacken Sie die folgende Datei: attachment.zip](samples/p-attach/ba8175be-9809-4c2e-b2d1-6b9180ed056c/attachments/attachment.zip) # Erstellen Sie detaillierte Kosten- und Nutzungsberichte für Amazon RDS und Amazon Aurora *Lakshmanan Lakshmanan und Sudarshan Narasimhan, Amazon Web Services* ## Zusammenfassung Dieses Muster zeigt, wie die Nutzungskosten für Amazon Relational Database Service (Amazon RDS) - oder Amazon Aurora Aurora-Cluster verfolgt werden, indem [benutzerdefinierte Kostenzuweisungs-Tags](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/custom-tags.html) konfiguriert werden. Sie können diese Tags verwenden, um detaillierte Kosten- und Nutzungsberichte im AWS Cost Explorer für Cluster in mehreren Dimensionen zu erstellen. Sie können beispielsweise die Nutzungskosten auf Team-, Projekt- oder Kostenstellenebene verfolgen und die Daten anschließend in Amazon Athena analysieren. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto + Eine oder mehrere [Amazon RDS- oder Amazon](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.html) [Aurora Aurora-Instances](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.CreateInstance.html) **Einschränkungen** Informationen zu Tagging-Einschränkungen finden Sie im [AWS Billing User Guide](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/allocation-tag-restrictions.html). ## Architektur **Zieltechnologie-Stack** + Amazon RDS oder Amazon Aurora + AWSKosten- und Nutzungsbericht + AWS Cost Explorer + Amazon Athena **Arbeitsablauf und Architektur** Der Tagging- und Analyse-Workflow besteht aus den folgenden Schritten: 1. Ein Dateningenieur, Datenbankadministrator oder AWS-Administrator erstellt benutzerdefinierte Kostenzuweisungs-Tags für die Amazon RDS- oder Aurora-Cluster. 1. Ein AWS-Administrator aktiviert die Tags. 1. Die Tags melden Metadaten an AWS Cost Explorer. 1. Ein Dateningenieur, Datenbankadministrator oder AWS-Administrator erstellt einen [monatlichen Kostenverteilungsbericht](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/configurecostallocreport.html#allocation-viewing). 1. Ein Dateningenieur, Datenbankadministrator oder AWS-Administrator analysiert den monatlichen Kostenzuordnungsbericht mithilfe von Amazon Athena. Das folgende Diagramm zeigt, wie Sie Tags anwenden, um die Nutzungskosten für Amazon RDS- oder Aurora-Instances nachzuverfolgen. ![\[Anwenden von Tags zur Erfassung der Nutzungskosten für Datenbank-Instances und Cluster\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/eab5001d-5115-4aa6-bdd2-23063b08b262/images/63292b18-01d6-4523-b8ac-2c3b12b11b84.png) Das folgende Architekturdiagramm zeigt, wie der Kostenzuordnungsbericht zu Analysezwecken in Amazon Athena integriert ist. ![\[Abfragen von Kostenverteilungsberichten in Athena\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/eab5001d-5115-4aa6-bdd2-23063b08b262/images/9c028405-1e93-4f6a-a0e5-36154e2b8eab.png) Der monatliche Kostenzuordnungsbericht wird in einem von Ihnen angegebenen Amazon S3 S3-Bucket gespeichert. Wenn Sie Athena mit der CloudFormation AWS-Vorlage einrichten, wie im Abschnitt *Epics* beschrieben, stellt die Vorlage mehrere zusätzliche Ressourcen bereit, darunter einen AWS Glue-Crawler, eine AWS Glue Glue-Datenbank, ein Amazon Simple Notification System (Amazon SNS) -Ereignis, AWS Lambda Lambda-Funktionen und AWS Identity and Access Management (IAM) -Rollen für die Lambda-Funktionen. Wenn neue Kostendatendateien im S3-Bucket ankommen, werden diese Dateien mithilfe von Ereignisbenachrichtigungen zur Verarbeitung an eine Lambda-Funktion weitergeleitet. Die Lambda-Funktion initiiert einen AWS Glue Glue-Crawler-Job, um die Tabelle im AWS Glue Glue-Datenkatalog zu erstellen oder zu aktualisieren. Diese Tabelle wird dann verwendet, um Daten in Athena abzufragen. ## Tools + [Amazon Athena](https://aws.amazon.com/athena/) ist ein interaktiver Abfrageservice, der es einfach macht, Daten in Amazon S3 mithilfe von Standard-SQL zu analysieren. + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) ist eine vollständig verwaltete relationale Datenbank-Engine, die für die Cloud entwickelt wurde und mit MySQL und PostgreSQL kompatibel ist. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Datenbank in der AWS-Cloud. + [AWS CloudFormation](https://aws.amazon.com/cloudformation/) ist ein Infrastructure-as-Code-Service (IaC), mit dem Sie Ressourcen von AWS und Drittanbietern einfach modellieren, bereitstellen und verwalten können. + Mit [AWS Cost Explorer](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/ce-what-is.html) können Sie Ihre AWS-Kosten und -Nutzung anzeigen und analysieren. ## Epen ### Erstellen und aktivieren Sie Tags für Ihren Amazon RDS- oder Aurora-Cluster | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie benutzerdefinierte Kostenzuweisungs-Tags für Ihren Amazon RDS- oder Aurora-Cluster. | Um Tags zu einem neuen oder vorhandenen Amazon RDS- oder Aurora-Cluster hinzuzufügen, folgen Sie den Anweisungen [unter Hinzufügen, Auflisten und Entfernen von Tags](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html#Tagging.HowTo) im *Amazon Aurora Aurora-Benutzerhandbuch*.Informationen zur Einrichtung eines Amazon Aurora Aurora-Clusters finden Sie in den Anweisungen für [MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.Aurora.html) und [PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html) im *Amazon Aurora Aurora-Benutzerhandbuch*. | AWS-Administrator, Dateningenieur, DBA | | Aktivieren Sie die benutzerdefinierten Tags für die Kostenzuweisung. | Folgen Sie den Anweisungen unter [Aktivierung von benutzerdefinierten Kostenzuweisungs-Tags](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/activating-tags.html) im *AWS-Abrechnungsbenutzerhandbuch*. | AWS-Administrator | ### Kosten- und Nutzungsberichte erstellen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen und konfigurieren Sie Kosten- und Nutzungsberichte für Ihre Cluster. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/create-detailed-cost-and-usage-reports-for-amazon-rds-and-amazon-aurora.html)Die Daten werden in 24 Stunden verfügbar sein. | App-Besitzer, AWS-Administrator, DBA, General AWS, Dateningenieur | ### Analysieren Sie die Kosten- und Nutzungsberichtsdaten | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Analysieren Sie die Daten des Kosten- und Nutzungsberichts. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/create-detailed-cost-and-usage-reports-for-amazon-rds-and-amazon-aurora.html):role/ --role-session-name --profile
select status from cost_and_usage_data_statusWeitere Informationen finden Sie unter [Ausführen von Amazon Athena Athena-Abfragen](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html) im *AWS-Benutzerhandbuch für Kosten- und Nutzungsberichte*.Wenn Sie Ihre SQL-Abfrage ausführen, stellen Sie sicher, dass die richtige Datenbank aus der Dropdownliste ausgewählt ist. | App-Besitzer, AWS-Administrator, DBA, General AWS, Dateningenieur | ## Zugehörige Ressourcen **Referenzen** + [Athena mithilfe von CloudFormation AWS-Vorlagen einrichten](https://docs.aws.amazon.com/cur/latest/userguide/use-athena-cf.html) (empfohlen) + [Manuelles Einrichten von Athena](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-manual.html) + [Amazon Athena Athena-Abfragen ausführen](https://docs.aws.amazon.com/cur/latest/userguide/cur-ate-run.html) + [Berichtsdaten werden in andere Ressourcen geladen](https://docs.aws.amazon.com/cur/latest/userguide/cur-query-other.html) **Tutorials und Videos** + [Analysieren Sie Kosten- und Nutzungsberichte mit Amazon Athena](https://youtu.be/KEeJEZTYE8E) (YouTube Video) # Stellen Sie mithilfe von Terraform SQL Server-Failover-Cluster-Instances auf Amazon EC2 und Amazon FSx bereit *Mark Hudson und Matt Burgess, Amazon Web Services* ## Zusammenfassung Dieses Muster verwendet Terraform, um SQL Server-Failover-Cluster-Instances (FCIs) auf Windows Server Failover Cluster (WSFC) -Knoten auf Amazon Elastic Compute Cloud (Amazon) bereitzustellen. EC2 Darüber hinaus verwendet das Muster FSx gemeinsam genutzten Speicher von Amazon für Daten und Protokolldateien. Wenn SQL Server-Datenbanken migriert werden AWS, ist Amazon RDS for SQL Server die erste Wahl. Manchmal ist Amazon RDS for SQL Server jedoch nicht geeignet und SQL Server muss auf Amazon EC2 in einer hochverfügbaren Architektur bereitgestellt werden. In dieser Lösung FCIs werden SQL Server auf allen WSFC-Knoten installiert. Das in diesem Muster enthaltene Terraform-Modul stellt bis zu zwei Amazon EC2 SQL Server-Instances bereit. Ein Dateisystem von Amazon FSx für Windows File Server fungiert als Quorum-Zeuge und speichert gemeinsam genutzte Daten und Protokolldateien. Unabhängig von der Anzahl der konfigurierten Instances erstellen die SQL Server-Instanzknoten immer einen FCI-Cluster und schließen sich diesem an, um die Umgebungsparität sicherzustellen. (In der Regel wird eine Instanz für die Entwicklung und zwei Instanzen für Produktionsumgebungen konfiguriert.) Für Konfigurationen, die zwei Knoten für hohe Verfügbarkeit verwenden, wird ein interner Network Load Balancer bereitgestellt. Der Network Load Balancer verwendet eine auf dem FCI-Cluster konfigurierte Integritätsprüfung, um zu ermitteln, welcher Knoten der primäre ist. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktiver. AWS-Konto + Amazon Virtual Private Cloud (Amazon VPC) mit zwei Subnetzen in separaten Availability Zones. + Amazon VPC [DHCP-Optionssatz](https://docs.aws.amazon.com/vpc/latest/userguide/DHCPOptionSet.html). Konfigurieren Sie den Domänennamen so, dass er in Ihren Active Directory-Domänennamen aufgelöst wird, und konfigurieren Sie die Domänen- und NetBIOS-Nameserver so, dass sie auf Ihre Active Directory-Domänencontroller verweisen. Weitere Informationen finden Sie unter *VPC-Konfiguration* unter [Zusätzliche Informationen](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). + AWS Directory Service for Microsoft Active Directory (AWS Managed Microsoft AD). + Benutzerdefiniertes Amazon Machine Image (AMI). Weitere Informationen finden Sie unter *AMI-Konfiguration* unter [Zusätzliche Informationen](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). + Amazon Simple Storage Service (Amazon S3) -Bucket, der das SQL Server-ISO-Image enthält. Diese Voraussetzung ist nur erforderlich, wenn Sie [EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) mit der bereitgestellten `component.yaml` Datei verwenden, um das benutzerdefinierte AMI zu erstellen. + AWS Key Management Service (AWS KMS) Verschlüsselungsschlüssel. + Standardmäßig wird SQL Server mit einem Product Key für die Developer Edition installiert. Von Produktionssystemen wird erwartet, dass sie einen gültigen Produktschlüssel verwenden, der von der entsprechenden Variablen an das Modul übergeben wird. **Einschränkungen** + Diese Lösung erfordert AWS Managed Microsoft AD. Wenn Sie möchten, können Sie jedoch stattdessen eine selbstverwaltete Active Directory-Implementierung verwenden. Ändern Sie dazu das enthaltene Amazon FSx Terraform-Modul, um das Attribut zu entfernen. `active_directory_id` [Fügen Sie dann die vier Attribute hinzu, die für selbstverwaltetes Active Directory erforderlich sind, wie in der Terraform-Dokumentation gezeigt.](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/fsx_windows_file_system) + SQL Server ist für die Verwendung der Authentifizierung im gemischten Modus eingerichtet. Wenn Sie möchten, können Sie die reine Windows-Authentifizierung verwenden. Entfernen Sie dazu im bereitgestellten Benutzerdatenskript die `/SAPWD` Parameter `/SECURITYMODE` und, die für den `setup.exe` Befehl angegeben wurden. Sie können die `sql_accounts.tf` Datei entfernen, und Sie können die `instances.tf` Datei ändern, um den `sql_sa_password` Eintrag zu entfernen. + Wenn Sie einen bereitgestellten Cluster löschen, müssen Sie die entsprechenden virtuellen Computerobjekte und einzelne Computerobjekte in Active Directory entfernen. Verwenden Sie die Active Directory-Verwaltungstools, um die Objekte zu entfernen. + Einige AWS-Services sind nicht in allen verfügbar AWS-Regionen. Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie unter [AWS Dienste nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie unter [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus. **Produktversionen** Diese Lösung wurde mit den folgenden Versionen getestet: + Windows Server 2019 + SQL Server 2019 + [Terraform v0.13.0](https://developer.hashicorp.com/terraform/language/v1.1.x/upgrade-guides/0-13) ## Architektur **Quelltechnologie-Stack** + SQL Server **Zieltechnologie-Stack** + SQL Server FCI auf WSFC-Knoten mit Amazon EC2 + Amazon FSx für Windows-Dateiserver + Amazon-S3-Bucket + AWS Secrets Manager + AWS Managed Microsoft AD + AWS KMS + AWS Identity and Access Management (IAM) **Zielarchitektur** Das folgende Diagramm zeigt die Architektur für diese Lösung. ![\[Architektur für die Bereitstellung von SQL Server-Failover-Cluster-Instances auf Windows Server-Failover-Cluster-Knoten auf Amazon. EC2\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/45f3ab19-d240-4353-ab6e-f6e565f537a4/images/0bff16f2-94e7-4e86-91ea-7ab5f3725620.png) Das Diagramm zeigt Folgendes: + Eine IAM-Rolle, die den EC2 Instances Zugriff auf AWS KMS und Secrets Manager bietet + Zwei SQL Server-Knoten, die auf EC2 Amazon-Instances in privaten Subnetzen in zwei Availability Zones bereitgestellt werden + Ein Network Load Balancer zur Erleichterung von Verbindungen zur aktiven SQL Server-Instanz (wird nicht bei der Einrichtung eines Clusters mit einem einzelnen Knoten bereitgestellt) + Das Dateisystem Amazon FSx for Windows File Server wird in beiden privaten Subnetzen für gemeinsamen Speicher durch die SQL Server-Knoten bereitgestellt + Secrets Manager zum Speichern von Anmeldeinformationen und Konfigurationen für Active Directory und SQL Server + Amazon S3 S3-Bucket zum Speichern des SQL Server-Installationsabbilds + AWS Managed Microsoft AD für die Windows-Authentifizierung + AWS KMS zur Erstellung des Verschlüsselungsschlüssels **Automatisierung und Skalierung** [Sie können die Bereitstellung der Zielarchitektur automatisieren, indem Sie die Terraform-Module verwenden, die sich im GitHub Repository befinden.](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server) Sie müssen die `terraform.tfvars` Datei so ändern, dass sie Variablenwerte enthält, die für Ihre Umgebung spezifisch sind. Der Amazon S3 S3-Bucket, die AWS Managed Microsoft AD Komponenten, der AWS KMS Verschlüsselungsschlüssel und einige Geheimnisse sind Voraussetzungen für diese Bereitstellung und nicht im Terraform-Code enthalten. ## Tools **AWS-Services** + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)ermöglicht Ihren verzeichnissensitiven Workloads und AWS Ressourcen die Verwendung von Microsoft Active Directory in der. AWS Cloud In diesem Muster AWS Managed Microsoft AD wird es für die Windows Server- und SQL Server-Authentifizierung sowie für DNS verwendet. + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) bietet skalierbare Rechenkapazität in der AWS Cloud. Sie können so viele virtuelle Server wie nötig nutzen und sie schnell nach oben oder unten skalieren. In diesem Muster werden SQL Server-Failover-Cluster-Instances auf EC2 Amazon-Instances installiert. + EC2 Mit [Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) können Sie die Erstellung, Verwaltung und Bereitstellung von benutzerdefinierten Server-Images automatisieren. + [Amazon FSx für Windows File Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) bietet vollständig verwalteten gemeinsamen Speicher auf Windows Server. In diesem Muster stellt der Dateiserver FSx für Windows gemeinsam genutzten Speicher für SQL Server-Daten und Protokolldateien sowie den Quorum-Zeugen bereit. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) unterstützt Sie bei der sicheren Verwaltung des Zugriffs auf Ihre AWS Ressourcen, indem kontrolliert wird, wer authentifiziert und autorisiert ist, diese zu verwenden. + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) hilft Ihnen dabei, kryptografische Schlüssel zu erstellen und zu kontrollieren, um Ihre Daten zu schützen. In diesem Muster wird es verwendet, um Secrets Manager Manager-Geheimnisse, den SQL Server-Speicher auf Amazon Elastic Block Store (Amazon EBS) -Volumes und das Dateisystem FSx für Windows File Server zu verschlüsseln. + Mit [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) können Sie fest codierte Anmeldeinformationen im Code (einschließlich Passwörter) durch einen API-Aufruf an Secrets Manager ersetzen und das Geheimnis programmgesteuert abrufen. In diesem Muster werden die Active Directory-Anmeldeinformationen für die Installation und Ausführung von SQL Server, die `sa` Benutzeranmeldeinformationen und die Datenbankverbindungsinformationen in Secrets Manager gespeichert. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt. Dieses Muster verwendet einen Amazon S3 S3-Bucket, um das SQL Server-Installationsabbild zu speichern. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) hilft Ihnen dabei, AWS Ressourcen in einem von Ihnen definierten virtuellen Netzwerk bereitzustellen. Dieses virtuelle Netzwerk entspricht einem herkömmlichen Netzwerk, wie Sie es in Ihrem Rechenzentrum betreiben würden, mit den Vorteilen der Verwendung der skalierbaren Infrastruktur von AWS. ******Andere Tools** + [Microsoft SQL Server FCIs](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/always-on-failover-cluster-instances-sql-server?view=sql-server-ver15) werden auf allen Windows Server-Clusterknoten installiert. Darüber hinaus können sie in mehreren Subnetzen installiert werden. In diesem Muster werden SQL Server-FCI-Instanzen auf allen WSFC-Knoten installiert. + [Terraform](https://www.terraform.io/) ist ein IaC-Tool (Infrastructure as Code), mit dem Sie mithilfe von Code Cloud-Infrastruktur und -Ressourcen bereitstellen und verwalten können. In diesem Muster wird Terraform verwendet, um die Ressourcen zu erstellen und die SQL Server-FCI-Instanzen zu konfigurieren. + [Windows Server Failover Clustering](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/windows-server-failover-clustering-wsfc-with-sql-server?view=sql-server-ver15) bietet Infrastrukturfunktionen, die die Hochverfügbarkeit von gehosteten Serveranwendungen wie SQL Server unterstützen. In diesem Muster nutzen die FCI-Knoten die WSFC-Funktionalität, um lokale Hochverfügbarkeit durch Redundanz auf Instanzebene zu gewährleisten. **Code-Repository** Der Code für dieses Muster ist im Repository GitHub [cluster-amazon-elastic-compute- cloud-amazon-fsx-microsoft -sql-server](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server) verfügbar. Die folgenden Ressourcen sind im Repository verfügbar: + Eine `README.md` Datei, die einen Überblick über die Lösung und zusätzliche Installations- und Nutzungsinformationen bietet + Ein Basissatz von Terraform-Konfigurationsdateien und ein FSx Amazon-spezifisches Modul zur Bereitstellung der Komponenten für dieses Muster + Ein Instance-Setup-Skript, das als EC2 Amazon-Benutzerdatenskript ausgeführt wird + Eine `component.yam` l-Datei, mit der Image Builder ein benutzerdefiniertes AMI erstellen kann ## Best Practices **Sicherheit und Patching** + Die erforderlichen AMI-Installationen und -Konfigurationen sind die Mindestanforderungen für die Bereitstellung von SQL Server-FCI-Clustern. Zusätzliche Software und Konfigurationen sind möglicherweise erforderlich, um die Standards und Sicherheitsanforderungen Ihres Unternehmens zu erfüllen. + Patchen Sie Windows nach der Bereitstellung regelmäßig. Patchen Sie entweder direkt die laufenden Instances oder erstellen Sie ein neues AMI mit den neuesten Windows-Patches und ersetzen Sie die Instances (nacheinander) mithilfe des neuen AMI. AWS veröffentlicht AMIs monatlich neue Windows-Versionen, die die neuesten Betriebssystem-Patches, Treiber und Start-Agents enthalten. Wir empfehlen Ihnen, beim Starten neuer Instances oder beim Erstellen eigener benutzerdefinierter Images nach dem neuesten AMI zu suchen. + Die EC2 Amazon-Instances sind so konfiguriert, dass sie den gesamten ausgehenden Datenverkehr zulassen. Bei der Bereitstellung in einer Produktionsumgebung sollten Regeln für ausgehenden Datenverkehr in der Sicherheitsgruppe eingerichtet werden, um diesen Datenverkehr auf die erforderlichen Ziele zu beschränken. + Das Dateisystem FSx für Windows File Server kann automatisch Auditprotokolle für Dateifreigaben sowie Datei- und Ordnerzugriffe aufzeichnen und sie an das gewünschte Ziel senden, falls dies in Ihrer Umgebung erforderlich ist. + Rotieren Sie Secrets Manager-Geheimnisse automatisch und regelmäßig. Ziehen Sie für das EC2 Amazon-Instance-Schlüsselpaar eine automatisierte Rotationslösung in Betracht, wie unter [So verwenden Sie AWS Secrets Manager zum sicheren Speichern und Rotieren von SSH-Schlüsselpaaren](https://aws.amazon.com/blogs/security/how-to-use-aws-secrets-manager-securely-store-rotate-ssh-key-pairs/) beschrieben. Richten Sie für die Active Directory-Anmeldeinformationen und die SQL `sa` Server-Anmeldeinformationen eine automatische Rotation gemäß Ihren Richtlinien für die Passwortverwaltung ein. **Active Directory-Verwaltung** + Als Teil des FCI-Clusters generiert Windows ein Computer Name Object (CNO) in Active Directory. Das CNO reagiert auf DNS-Anfragen und leitet den Datenverkehr an den aktiven SQL-Knoten weiter. Wir empfehlen *nicht*, dieses von Active Directory bereitgestellte DNS zu verwenden. Die TTL ist zu hoch, um eine angemessene Failover-Zeit zu gewährleisten, und es dauert oft mehr als 5 Minuten, bis die neue primäre IP-Adresse wiedergegeben wird. Im Gegensatz dazu ist der interne Network Load Balancer für Installationen mit hoher Verfügbarkeit so konfiguriert, dass er innerhalb von 30 Sekunden ein Failover durchführt. + Für die Erstellung des Clusters ist ein Active Directory-Domänenadministrator erforderlich. Diese Anforderung ist auf die erhöhten Berechtigungen zurückzuführen, die zum Erstellen der Clusterobjekte und zum Ändern von Berechtigungen in Active Directory erforderlich sind. Die SQL Server-Dienste müssen jedoch nicht als Domänenadministrator ausgeführt werden. Daher empfehlen wir, dass Sie zu diesem Zweck einen zweiten Active Directory-Benutzer erstellen. Sie können diesen Benutzer jedoch entfernen, wenn die Dienste als Domänenadministratorbenutzer ausgeführt werden. In diesem Fall muss der Domänenadministratorbenutzer der Active Directory-Administratorgruppe hinzugefügt werden, die als Teil dieses Musters erstellt wurde. ## Epen ### Richten Sie Cluster-Anmeldeinformationen ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie Active Directory-Gruppen. | Erstellen AWS Managed Microsoft AD Sie in die folgenden Gruppen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Weitere Informationen finden Sie in der AWS Dokumentation unter [AWS Managed Microsoft AD Gruppe erstellen](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_create_group.html). | AD-Administrator | | Erstellen Sie Active Directory-Benutzer. | Erstellen AWS Managed Microsoft AD Sie in die folgenden Benutzer[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Weitere Informationen finden Sie in der AWS Dokumentation unter [AWS Managed Microsoft AD Benutzer erstellen](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups_create_user.html). | AD-Administrator | | Fügen Sie Active Directory-Anmeldeinformationen zu Geheimnissen hinzu. | Verwenden Sie Secrets Manager, um vier Secrets zum Speichern der folgenden Informationen zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html)Weitere Informationen finden Sie in der AWS Dokumentation unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html). | AWS-Administrator | ### Bereiten Sie die Umgebung vor | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie das Windows-AMI. | Erstellen Sie ein benutzerdefiniertes Windows-AMI, das die erforderliche Software und die erforderlichen Konfigurationen enthält. Weitere Informationen finden Sie unter [Zusätzliche Informationen](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-additional). | AWS-Administrator, AWS DevOps | | Installieren Sie Terraform. | [Folgen Sie den Anweisungen auf der Terraform-Website, um Terraform zu installieren.](https://learn.hashicorp.com/tutorials/terraform/install-cli) | AWS DevOps | | Klonen Sie das Repository | Klonen Sie das [Repository](https://github.com/aws-samples/cluster-amazon-elastic-compute-cloud-amazon-fsx-microsoft-sql-server) dieses Musters. Weitere Informationen finden Sie unter [Klonen eines Repositorys](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) auf der GitHub Website. | AWS DevOps | ### Installieren Sie den Cluster | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Ändern Sie die Terraform-Variablen. | Aktualisieren Sie die bereitgestellte `terraform.tfvars` Datei, um alle Variablen auf Werte zu setzen, die für Ihre Umgebung geeignet sind.Aktualisieren Sie beispielsweise die `domain_group_rdp_users` Variablen `domain_group_administrators` und, sodass sie Ihren Active Directory-Domänennamen und den Namen der zuvor erstellten Active Directory-Gruppen verwenden. | AWS DevOps | | Initialisieren Sie Terraform. | Um die vorgeschlagene Bereitstellung zu sehen, navigieren Sie zum Stammverzeichnis des Repositorys. Verwenden Sie die Terraform-Befehlszeilenschnittstelle (CLI) zum Ausführen `terraform init` und dann zum Ausführen. `terraform plan` | AWS DevOps | | Ressourcen bereitstellen. | Um den SQL-Cluster und die zugehörigen Ressourcen bereitzustellen, verwenden Sie zum Ausführen die Terraform-CLI. `terraform apply` | AWS DevOps, AWS-Administrator | | Validieren Sie die Bereitstellung. | Gehen Sie wie folgt vor, um die Bereitstellung zu validieren:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html) | DBA, AWS-Systemadministrator | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | Die Terraform-Bereitstellung wurde abgeschlossen, aber Windows Failover Cluster Manager zeigt nicht an, dass ein Cluster erstellt wurde oder der Cluster nicht betriebsbereit ist. | Die gesamte Installation der Ressourcen und die Konfiguration der Cluster können 45 bis 60 Minuten dauern. Nach Abschluss von Terraform muss das Benutzerdatenskript vollständig ausgeführt werden, was mehrere Neustarts erfordert. Um den Fortschritt zu überwachen, können Sie das `Checkpoints` Verzeichnis im `C:\` Laufwerk verwenden und die SQL Server-Installation meldet sich an. `C:\Program Data\Microsoft SQL Server\150\Log` Wenn der Vorgang abgeschlossen ist, ist die Meldung **Installation abgeschlossen** in der `C:\ProgramData\Amazon\EC2-Windows\Launch\Log\UserdataExecution.log` Datei verfügbar. | | Nach der Bereitstellung eines funktionierenden Clusters ist die Verwendung von Terraform zum Löschen und Neuerstellen des Clusters nicht erfolgreich. Terraform wird abgeschlossen, aber der Cluster ist nicht richtig eingerichtet. | Ein Teil des Bereitstellungsprozesses umfasst die Registrierung von Maschinen und virtuellen Objekten in Active Directory und Active Directory-DNS. Wenn Computernamen für die EC2 Amazon-Cluster-Knoten und den Cluster-Knoten existieren, kann FCI nicht korrekt initialisiert werden und die Bereitstellung schlägt fehl.Gehen Sie wie folgt vor, um dieses Problem zu beheben: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.html) | ## Zugehörige Ressourcen **AWS Dokumentation** + [Erstellen Sie benutzerdefinierte Bilder mit Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-images.html) + [Erstellen Sie einen KMS-Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) + [Einen Allzweck-Bucket erstellen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) + [Eine wichtige Richtlinie erstellen](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) + [Erstellen Sie Ihre AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) ## Zusätzliche Informationen **Informationen zum Terraform-Modul** Dieses Modul verwendet eine Mischung aus AMI-Konfiguration und Benutzerdatenkonfiguration, um eine gute Mischung aus Bereitstellungszeit und Stabilität zu erzielen. Während der Bereitstellung erfordert Windows mehrere Neustarts und Wartezeiten. Zum Schutz vor Endlosschleifen bei Neustarts der persistenten Benutzerdaten wurde eine Checkpoint-Methode implementiert. Benutzerdaten sind so konfiguriert, dass sie persistent sind. Daher müssen die Skripts zur Konfiguration von Benutzerdaten so weiterentwickelt werden, dass sie idempotent sind, und müssen dies auch weiterhin tun. Durch Idempotenz wird der Aktualisierungsprozess optimiert, sodass Instanzen während eines Aktualisierungszyklus ausgetauscht werden können, ohne dass eine manuelle Konfiguration erforderlich ist, um FCI-Clustern erneut beizutreten oder sie neu zu erstellen. **SQL Server-Verbindungszeichenfolgen und Failover-Clustering** Das Modul veröffentlicht einen geheimen Schlüssel, der die Endpunktadresse enthält, die in Verbindungszeichenfolgen für diese Datenbank verwendet werden soll. Der geheime Name folgt dem Format`{environment_name}/sqlserver/{cluster_name}/endpoint`. Bei Installationen, in denen nur ein Knoten verwendet wird, können Sie davon ausgehen, dass dies die IP-Adresse der SQL Server-Schnittstelle der EC2 Amazon-Instance ist. Bei Installationen mit hoher Verfügbarkeit (zwei Instanzen) können Sie davon ausgehen, dass dies der DNS-Name des internen Network Load Balancer ist. Virtuelles Failover-Clustering wird in diesem Modul IPs nicht unterstützt. Eine virtuelle IP muss im selben Subnetz verbleiben, um zu funktionieren. In kann AWS sich ein einzelnes Subnetz nicht über mehrere Availability Zones erstrecken. Daher IPs würde die Verwendung von Virtual dazu führen, dass dieses Modul nicht mehr als hochverfügbar angesehen werden kann. Jede EC2 Amazon-Instance erhält drei private IP-Adressen. Ihre Verwendung ist wie folgt: + **Primäre IP für Netzwerkverkehr** — Die Quell-IP für ausgehenden Verkehr. + **FCI-Kommunikation** — Wird verwendet, um den Status und die Synchronisierung des Failover-Clusters aufrechtzuerhalten. + **SQL Server (TCP-Port 1433)** — Listener und überwacht auch den Heartbeat-Verkehr, um festzustellen, welche Instanz primär ist. **VPC-Konfiguration** In den [Voraussetzungen](#deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx-prereqs) ist ein DHCP-Optionssatz aufgeführt, der für die Verwendung von Active Directory für die DNS-Auflösung konfiguriert ist. Diese Voraussetzung ist jedoch keine zwingende Anforderung. Die grundlegende Anforderung besteht darin, dass die EC2 Instanzen in der Lage sein müssen, Ihren Active Directory-Domänennamen aufzulösen. Die Erfüllung dieser Anforderung kann auch auf andere Weise erreicht werden, z. B. durch die Verwendung von Amazon Route 53 Resolver Endpunkten. Weitere Informationen finden Sie unter [Integrieren der DNS-Auflösung Ihres Verzeichnisdienstes mit Amazon Route 53-Resolvern](https://aws.amazon.com/blogs/networking-and-content-delivery/integrating-your-directory-services-dns-resolution-with-amazon-route-53-resolvers/) (AWS Blogbeitrag). **AMI-Konfiguration** Das in diesem Muster verwendete AMI muss die folgenden Softwarevoraussetzungen und Konfigurationen enthalten: 1. Laden Sie die SQL Server 2019-Installationsdateien herunter und erweitern Sie sie in`C:\SQL_Install_media`. 1. Installieren Sie die folgenden Windows-Funktionen: + `Install-WindowsFeature Failover-Clustering` + `Install-WindowsFeature RSAT-AD-PowerShell` + `Install-WindowsFeature RSAT-AD-Tools` + `Install-WindowsFeature RSAT-Clustering-Mgmt` + `Install-WindowsFeature RSAT-Clustering-PowerShell` + `Install-WindowsFeature RSAT-Clustering-CmdInterface` 1. Deaktivieren Sie die Windows-Firewall wie folgt: + `Get-NetFirewallProfile | Set-NetFirewallProfile -Enabled False` 1. Aktivieren Sie die CredSSP-Authentifizierungsmethode (`
DECLARE| DBA | | Lass den PL/SQL Block laufen. | Führen Sie den PL/SQL Quellblock in Oracle aus. Wenn zwischen den Indexwerten eines assoziativen Arrays Lücken bestehen, werden in diesen Lücken keine Daten gespeichert. Dadurch kann die Oracle-Schleife nur durch die Indexpositionen iterieren. | DBA | | Überprüfen Sie die Ausgabe. | Fünf Elemente wurden in nicht aufeinanderfolgenden Intervallen in das Array (`cc`) eingefügt. Die Anzahl der Arrays wird in der folgenden Ausgabe angezeigt:
TYPE country_codes IS TABLE OF VARCHAR2(100) INDEX BY pls_integer;
cc country_codes;
cc_idx NUMBER := NULL;
BEGIN
cc(7) := 'India';
cc(3) := 'UK';
cc(5) := 'USA';
cc(0) := 'China';
cc(-2) := 'Invalid';
dbms_output.put_line('cc_length:' || cc.COUNT);
IF (cc.COUNT > 0) THEN
cc_idx := cc.FIRST;
FOR i IN 1..cc.COUNT LOOP
dbms_output.put_line('cc_idx:' || cc_idx || ' country:' || cc(cc_idx));
cc_idx := cc.next(cc_idx);
END LOOP;
END IF;
END;
cc_length:5| DBA | ### Verhalten assoziativer PostgreSQL-Arrays (Ziel) | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie einen PL/pgSQL Zielblock in PostgreSQL. | Erstellen Sie einen PL/pgSQL Zielblock in PostgreSQL, der das folgende assoziative Array verwendet:
cc_idx:-2 country:Invalid
cc_idx:0 country:China
cc_idx:3 country:UK
cc_idx:5 country:USA
cc_idx:7 country:India
DO $$| DBA | | Lass den PL/pgSQL Block laufen. | Führen Sie den PL/pgSQL Zielblock in PostgreSQL aus. Wenn zwischen den Indexwerten eines assoziativen Arrays Lücken bestehen, werden in diesen Lücken keine Daten gespeichert. Dadurch kann die Oracle-Schleife nur durch die Indexpositionen iterieren. | DBA | | Überprüfen Sie die Ausgabe. | Die Array-Länge ist größer als 5, weil sie in den Lücken zwischen den Indexpositionen gespeichert `NULL` wird. Wie in der folgenden Ausgabe gezeigt, führt die Schleife 10 Iterationen durch, um 5 Werte im Array abzurufen.
DECLARE
cc character varying(100)[];
cc_idx integer := NULL;
BEGIN
cc[7] := 'India';
cc[3] := 'UK';
cc[5] := 'USA';
cc[0] := 'China';
cc[-2] := 'Invalid';
RAISE NOTICE 'cc_length: %', ARRAY_LENGTH(cc, 1);
IF (ARRAY_LENGTH(cc, 1) > 0) THEN
FOR i IN ARRAY_LOWER(cc, 1)..ARRAY_UPPER(cc, 1)
LOOP
RAISE NOTICE 'cc_idx:% country:%', i, cc[i];
END LOOP;
END IF;
END;
$$;
cc_length:10| DBA | ### Emuliert das Verhalten assoziativer Oracle-Arrays | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie einen PL/pgSQL Zielblock mit einem Array und einem benutzerdefinierten Typ. | Um die Leistung zu optimieren und der Funktionalität von Oracle zu entsprechen, können wir einen benutzerdefinierten Typ erstellen, der sowohl Indexpositionen als auch die entsprechenden Daten speichert. Dieser Ansatz reduziert unnötige Iterationen, indem direkte Verknüpfungen zwischen Indizes und Werten beibehalten werden.
cc_idx:-2 country:Invalid
cc_idx:-1 country:
cc_idx:0 country:China
cc_idx:1 country:
cc_idx:2 country:
cc_idx:3 country:UK
cc_idx:4 country:
cc_idx:5 country:USA
cc_idx:6 country:
cc_idx:7 country:India
DO $$| DBA | | Lass den PL/pgSQL Block laufen. | Führen Sie den PL/pgSQL Zielblock aus. Wenn zwischen den Indexwerten eines assoziativen Arrays Lücken bestehen, werden in diesen Lücken keine Daten gespeichert. Dadurch kann die Oracle-Schleife nur durch die Indexpositionen iterieren. | DBA | | Überprüfen Sie die Ausgabe. | Wie in der folgenden Ausgabe gezeigt, speichert der benutzerdefinierte Typ nur aufgefüllte Datenelemente, was bedeutet, dass die Länge des Arrays der Anzahl der Werte entspricht. Daher sind `LOOP` Iterationen so optimiert, dass nur vorhandene Daten verarbeitet werden, sodass leere Positionen nicht mehr nachverfolgt werden müssen.
DECLARE
cc country_codes[];
cc_append country_codes := NULL;
i record;
BEGIN
cc_append.idx = 7;
cc_append.val = 'India';
cc := array_append(cc, cc_append);
cc_append.idx = 3;
cc_append.val = 'UK';
cc := array_append(cc, cc_append);
cc_append.idx = 5;
cc_append.val = 'USA';
cc := array_append(cc, cc_append);
cc_append.idx = 0;
cc_append.val = 'China';
cc := array_append(cc, cc_append);
cc_append.idx = - 2;
cc_append.val = 'Invalid';
cc := array_append(cc, cc_append);
RAISE NOTICE 'cc_length: %', ARRAY_LENGTH(cc, 1);
IF (ARRAY_LENGTH(cc, 1) > 0) THEN
FOR i IN (
SELECT
*
FROM
unnest(cc)
ORDER BY
idx)
LOOP
RAISE NOTICE 'cc_idx:% country:%', i.idx, i.val;
END LOOP;
END IF;
END;
$$;
cc_length:5| DBA | ## Zugehörige Ressourcen **AWS Dokumentation** + [AWS Datenbank-Blog](https://aws.amazon.com/blogs/database/) + [Leitfaden für die Migration von Oracle nach Aurora PostgreSQL](https://docs.aws.amazon.com/dms/latest/oracle-to-aurora-postgresql-migration-playbook/chap-oracle-aurora-pg.html) **Weitere Dokumentation** + [Assoziative Oracle-Arrays](https://docs.oracle.com/en/database/oracle/oracle-database/23/lnpls/associative-arrays.html#GUID-8060F01F-B53B-48D4-9239-7EA8461C2170) + [PostgreSQL-Array-Funktionen und -Operatoren](https://www.postgresql.org/docs/current/functions-array.html) + [Benutzerdefinierte PostgreSQL-Typen](https://www.postgresql.org/docs/current/sql-createtype.html) # Aktivieren Sie verschlüsselte Verbindungen für PostgreSQL-DB-Instances in Amazon RDS *Rohit Kapoor, Amazon Web Services* ## Zusammenfassung Amazon Relational Database Service (Amazon RDS) unterstützt SSL-Verschlüsselung für PostgreSQL-DB-Instances. Mit SSL können Sie eine PostgreSQL-Verbindung zwischen Ihren Anwendungen und Ihren Amazon RDS for PostgreSQL PostgreSQL-DB-Instances verschlüsseln. Standardmäßig verwendet Amazon RDS for PostgreSQL Verschlüsselung SSL/TLS und erwartet, dass alle Clients eine Verbindung herstellen. SSL/TLS Amazon RDS for PostgreSQL unterstützt die TLS-Versionen 1.1 und 1.2. Dieses Muster beschreibt, wie Sie verschlüsselte Verbindungen für eine Amazon RDS for PostgreSQL PostgreSQL-DB-Instance aktivieren können. Sie können dasselbe Verfahren verwenden, um verschlüsselte Verbindungen für Amazon Aurora PostgreSQL-Compatible Edition zu aktivieren. ## Voraussetzungen und Einschränkungen + Ein aktives AWS-Konto + Eine [Amazon RDS for PostgreSQL PostgreSQL-DB-Instance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_RDS_Configuring.html) + [Ein SSL-Bundle](https://www.postgresql.org/docs/current/ssl-tcp.html) ## Architektur ![\[Aktivieren verschlüsselter Verbindungen für PostgreSQL-DB-Instances in Amazon RDS\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/4f87c6a3-b4ff-4248-96d3-a4a498659735/images/ccc5c880-1191-4c12-a255-6908b96b96a5.png) ## Tools + [pgAdmin](https://www.pgadmin.org/) ist eine Open-Source-Verwaltungs- und Entwicklungsplattform für PostgreSQL. Sie können pgAdmin unter Linux, Unix, macOS und Windows verwenden, um Ihre Datenbankobjekte in PostgreSQL 10 und höher zu verwalten. + [PostgreSQL-Editoren](https://wiki.postgresql.org/wiki/PostgreSQL_Clients) bieten eine benutzerfreundlichere Oberfläche, mit der Sie Abfragen erstellen, entwickeln und ausführen und Code gemäß Ihren Anforderungen bearbeiten können. ## Best Practices + Überwachen Sie unsichere Datenbankverbindungen. + Überwachen Sie die Datenbankzugriffsrechte. + Stellen Sie sicher, dass Backups und Snapshots im Ruhezustand verschlüsselt sind. + Überwachen Sie den Datenbankzugriff. + Vermeiden Sie Gruppen mit uneingeschränktem Zugriff. + Verbessern Sie Ihre Benachrichtigungen mit [Amazon GuardDuty](https://docs.aws.amazon.com/guardduty/latest/ug/what-is-guardduty.html). + Überwachen Sie regelmäßig die Einhaltung der Richtlinien. ## Epen ### Laden Sie ein vertrauenswürdiges Zertifikat herunter und importieren Sie es in Ihren Trust Store | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Laden Sie ein vertrauenswürdiges Zertifikat auf Ihren Computer. | Gehen Sie wie folgt vor, um Zertifikate zum Speicher vertrauenswürdiger Stammzertifizierungsstellen für Ihren Computer hinzuzufügen. (In diesen Anweisungen wird Windows Server als Beispiel verwendet.)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html) | DevOps Ingenieur, Migrationsingenieur, DBA | ### SSL-Verbindungen erzwingen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Parametergruppe und legen Sie den rds.force\$1ssl-Parameter fest. | Wenn die PostgreSQL-DB-Instance über eine benutzerdefinierte Parametergruppe verfügt, bearbeiten Sie die Parametergruppe und ändern Sie `rds.force_ssl` sie auf 1.Wenn die DB-Instance die Standardparametergruppe verwendet, für die keine `rds.force_ssl` Option aktiviert wurde, erstellen Sie eine neue Parametergruppe. Sie können die neue Parametergruppe mithilfe der Amazon RDS-API oder manuell wie in der folgenden Anleitung beschrieben ändern.Um eine neue Parametergruppe zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)So verknüpfen Sie die Parametergruppe mit Ihrer PostgreSQL-DB-Instance:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Weitere Informationen finden Sie in der [Dokumentation zu Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithDBInstanceParamGroups.html). | DevOps Ingenieur, Migrationsingenieur, DBA | | SSL-Verbindungen erzwingen. | Connect zur Amazon RDS for PostgreSQL PostgreSQL-DB-Instance her. Verbindungsversuche, die kein SSL verwenden, werden mit einer Fehlermeldung zurückgewiesen. Weitere Informationen finden Sie in der [Dokumentation zu Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html#PostgreSQL.Concepts.General.SSL.Requiring). | DevOps Ingenieur, Migrationsingenieur, DBA | ### Installieren Sie die SSL-Erweiterung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Installieren Sie die SSL-Erweiterung. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Weitere Informationen finden Sie in der [Dokumentation zu Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html). | DevOps Ingenieur, Migrationsingenieur, DBA | ### Konfigurieren Sie Ihren PostgreSQL-Client für SSL | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Konfigurieren Sie einen Client für SSL. | Mithilfe von SSL können Sie den PostgreSQL-Server mit Unterstützung für verschlüsselte Verbindungen starten, die TLS-Protokolle verwenden. Der Server überwacht sowohl Standard- als auch SSL-Verbindungen auf demselben TCP-Port und verhandelt mit jedem Client, der eine Verbindung herstellt, darüber, ob SSL verwendet werden soll. Standardmäßig ist dies eine Client-Option.Wenn Sie den PSQL-Client verwenden:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Für andere PostgreSQL-Clients:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html)Sehen Sie sich die folgenden Seiten für diese Clients an:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.html) | DevOps Ingenieur, Migrationsingenieur, DBA | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | Das SSL-Zertifikat kann nicht heruntergeladen werden. | Überprüfen Sie Ihre Verbindung zur Website und versuchen Sie erneut, das Zertifikat auf Ihren lokalen Computer herunterzuladen. | ## Zugehörige Ressourcen + [Dokumentation zu Amazon RDS for PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) + [Verwenden von SSL mit einer PostgreSQL-DB-Instance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html) (Amazon RDS-Dokumentation) + [Sichere TCP/IP Verbindungen mit SSL](https://www.postgresql.org/docs/9.1/ssl-tcp.html) (PostgreSQL-Dokumentation) + [Verwendung von SSL](https://jdbc.postgresql.org/documentation/ssl/) (JDBC-Dokumentation) # Verschlüsseln Sie eine bestehende Amazon RDS for PostgreSQL PostgreSQL-DB-Instance *Piyush Goyal, Shobana Raghu und Yaser Raja, Amazon Web Services* ## Zusammenfassung Dieses Muster erklärt, wie eine bestehende Amazon Relational Database Service (Amazon RDS) für PostgreSQL-DB-Instance in der AWS-Cloud mit minimalen Ausfallzeiten verschlüsselt wird. Dieser Prozess funktioniert auch für Amazon RDS for MySQL MySQL-DB-Instances. Sie können die Verschlüsselung für eine Amazon RDS-DB-Instance aktivieren, wenn Sie sie erstellen, aber nicht, nachdem sie erstellt wurde. Sie können jedoch einer unverschlüsselten DB-Instance Verschlüsselung hinzufügen, indem Sie einen Snapshot Ihrer DB-Instance und anschließend eine verschlüsselte Kopie dieses Snapshots erstellen. Anschließend können Sie eine DB-Instance aus dem verschlüsselten Snapshot wiederherstellen, um eine verschlüsselte Kopie Ihrer ursprünglichen DB-Instance zu erhalten. Wenn Ihr Projekt während dieser Aktivität Ausfallzeiten (zumindest für Schreibtransaktionen) zulässt, ist dies alles, was Sie tun müssen. Wenn die neue, verschlüsselte Kopie der DB-Instance verfügbar ist, können Sie Ihre Anwendungen auf die neue Datenbank verweisen. Wenn Ihr Projekt jedoch keine nennenswerten Ausfallzeiten für diese Aktivität vorsieht, benötigen Sie einen alternativen Ansatz, der dazu beiträgt, die Ausfallzeiten zu minimieren. Dieses Muster verwendet den AWS Database Migration Service (AWS DMS), um die Daten zu migrieren und kontinuierlich zu replizieren, sodass die Umstellung auf die neue, verschlüsselte Datenbank mit minimalen Ausfallzeiten erfolgen kann. Amazon RDS-verschlüsselte DB-Instances verwenden den Industriestandard-Verschlüsselungsalgorithmus AES-256, um Ihre Daten auf dem Server zu verschlüsseln, der Ihre Amazon RDS-DB-Instances hostet. Nachdem Ihre Daten verschlüsselt wurden, verarbeitet Amazon RDS die Authentifizierung des Zugriffs und die Entschlüsselung Ihrer Daten transparent und mit minimalen Auswirkungen auf die Leistung. Sie müssen Ihre Datenbank-Client-Anwendungen nicht ändern, um Verschlüsselung anzuwenden. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto + Eine unverschlüsselte Amazon RDS for PostgreSQL PostgreSQL-DB-Instance + Erfahrung in der Arbeit mit (Erstellen, Ändern oder Stoppen) von AWS DMS-Aufgaben (siehe [Arbeiten mit AWS DMS-Aufgaben](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.html) in der AWS DMS-Dokumentation) + Vertrautheit mit dem AWS Key Management Service (AWS KMS) zur Verschlüsselung von Datenbanken (siehe die [AWS KMS KMS-Dokumentation](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)) **Einschränkungen** + Sie können die Verschlüsselung für eine Amazon RDS-DB-Instance nur aktivieren, wenn Sie sie erstellen, nicht nachdem die DB-Instance erstellt wurde. + Daten in [Tabellen, die nicht protokolliert](https://www.postgresql.org/docs/current/sql-createtable.html) wurden, werden nicht mithilfe von Snapshots wiederhergestellt. Weitere Informationen finden Sie unter [Bewährte Methoden für die Arbeit mit PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_BestPractices.html#CHAP_BestPractices.PostgreSQL). + Es ist nicht möglich, ein verschlüsseltes Lesereplikat einer unverschlüsselten DB-Instance oder ein unverschlüsseltes Lesereplikat einer verschlüsselten DB-Instance zu erstellen. + Sie können ein unverschlüsseltes Backup oder einen solchen Snapshot nicht als verschlüsselte DB-Instance wiederherstellen. + AWS DMS überträgt die Sequenzen nicht automatisch, daher sind zusätzliche Schritte erforderlich, um dies zu handhaben. Weitere Informationen finden Sie unter [Einschränkungen von Amazon RDS-verschlüsselten DB-Instances](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html#Overview.Encryption.Limitations) in der Amazon RDS-Dokumentation. ## Architektur **Quellarchitektur** + Unverschlüsselte RDS-DB-Instance **Zielarchitektur** + Verschlüsselte RDS-DB-Instance + Die Ziel-RDS-DB-Instance wird erstellt, indem die DB-Snapshot-Kopie der Quell-RDS-DB-Instance wiederhergestellt wird. + Ein AWS-KMS-Schlüssel wird für die Verschlüsselung bei der Wiederherstellung des Snapshots verwendet. + Eine AWS DMS-Replikationsaufgabe wird verwendet, um die Daten zu migrieren. ![\[Process verwendet AWS DMS, um eine bestehende Amazon RDS for PostgreSQL PostgreSQL-DB-Instance in eine neue DB zu verschlüsseln.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/820d17c0-0eed-4ed9-9f43-cbada081d924/images/44dd8420-d89d-466e-b7fb-1bdafab8f7f9.png) ## Tools **Tools, die zur Aktivierung der Verschlüsselung verwendet werden:** + AWS-KMS-Schlüssel für die Verschlüsselung — Wenn Sie eine verschlüsselte DB-Instance erstellen, können Sie einen vom Kunden verwalteten Schlüssel oder den von AWS verwalteten Schlüssel für Amazon RDS wählen, um Ihre DB-Instance zu verschlüsseln. Wenn Sie die Schlüssel-ID für einen vom Kunden verwalteten Schlüssel nicht angeben, verwendet Amazon RDS den von AWS verwalteten Schlüssel für Ihre neue DB-Instance. Amazon RDS erstellt einen AWS-verwalteten Schlüssel für Amazon RDS für Ihr AWS-Konto. Ihr AWS-Konto hat für jede AWS-Region einen anderen AWS-verwalteten Schlüssel für Amazon RDS. Weitere Informationen zur Verwendung von KMS-Schlüsseln für die Amazon RDS-Verschlüsselung finden Sie unter [Amazon RDS-Ressourcen verschlüsseln](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html). **Tools, die für die laufende Replikation verwendet werden**: + AWS DMS — Sie können den AWS Database Migration Service (AWS DMS) verwenden, um Änderungen von der Quell-DB in die Ziel-DB zu replizieren. Es ist wichtig, die Quell- und Ziel-DB synchron zu halten, um Ausfallzeiten auf ein Minimum zu reduzieren. Informationen zur Einrichtung von AWS DMS und zur Erstellung von Aufgaben finden Sie in der [AWS DMS-Dokumentation](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html). ## Epen ### Erstellen Sie einen Snapshot der Quell-DB-Instance und verschlüsseln Sie ihn | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Überprüfen Sie die Details für die Quell-PostgreSQL-DB-Instance. | Wählen Sie in der Amazon RDS-Konsole die Quell-PostgreSQL-DB-Instance aus. Stellen Sie auf der Registerkarte **Konfiguration** sicher, dass die Verschlüsselung für die Instance nicht aktiviert ist. Eine Bildschirmdarstellung finden Sie im Abschnitt [Zusätzliche Informationen](#encrypt-an-existing-amazon-rds-for-postgresql-db-instance-additional). | DBA | | Erstellen Sie den DB-Snapshot. | Erstellen Sie einen DB-Snapshot der Instance, die Sie verschlüsseln möchten. Wie lange es dauert, einen Snapshot zu erstellen, hängt von der Größe Ihrer Datenbank ab. Anweisungen finden Sie unter [Erstellen eines DB-Snapshots](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) in der Amazon RDS-Dokumentation. | DBA | | Verschlüsseln Sie den Snapshot. | Wählen Sie im Navigationsbereich der Amazon RDS-Konsole **Snapshots** und wählen Sie den DB-Snapshot aus, den Sie erstellt haben. Wählen Sie für **Actions (Aktionen)** die Option **Copy Snapshot (Snapshot kopieren)**. Geben Sie die AWS-Zielregion und den Namen der DB-Snapshot-Kopie in die entsprechenden Felder ein. Wählen Sie das Kontrollkästchen **Verschlüsselung aktivieren** aus. Geben Sie für **Master Key (Masterschlüssel)** den Bezeichner des zum Verschlüsseln der DB-Snapshot-Kopie zu verwendenden KMS-Schlüssel an. Wählen Sie **Copy Snapshot (Snapshot kopieren)** aus. Weitere Informationen finden Sie unter [Kopieren eines Snapshots](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CopySnapshot.html) in der Amazon RDS-Dokumentation. | DBA | ### Bereiten Sie die Ziel-DB-Instance vor | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Stellen Sie den DB-Snapshot wieder her. | Wählen Sie auf der Amazon RDS-Konsole **Snapshots** aus. Wählen Sie den verschlüsselten Snapshot aus, den Sie erstellt haben. Wählen Sie unter **Actions (Aktionen)** die Option **Restore Snapshot (Snapshot wiederherstellen)**. Geben Sie für **DB Instance Identifier** einen eindeutigen Namen für die neue DB-Instance ein. Überprüfen Sie die Instance-Details und wählen Sie dann **Restore DB Instance** aus. Aus Ihrem Snapshot wird eine neue, verschlüsselte DB-Instance erstellt. Weitere Informationen finden Sie unter [Wiederherstellen aus einem DB-Snapshot](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RestoreFromSnapshot.html) in der Amazon RDS-Dokumentation. | DBA | | Migrieren Sie Daten mithilfe von AWS DMS. | Erstellen Sie auf der AWS DMS-Konsole eine AWS DMS-Aufgabe. Wählen Sie als **Migrationstyp** die Option **Bestehende Daten migrieren und laufende Änderungen replizieren aus.** Wählen Sie in den **Aufgabeneinstellungen** für **Target-Tabellenvorbereitungsmodus** die Option **Truncate** aus. Weitere Informationen finden Sie in der AWS DMS-Dokumentation unter [Aufgabe erstellen](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html). | DBA | | Aktivieren Sie die Datenvalidierung. | Wählen Sie in **den Aufgabeneinstellungen** die Option **Validierung aktivieren** aus. Auf diese Weise können Sie die Quelldaten mit den Zieldaten vergleichen, um sicherzustellen, dass die Daten korrekt migriert wurden. | DBA | | Deaktivieren Sie Einschränkungen für die Ziel-DB-Instance. | [Deaktivieren Sie alle Trigger und Fremdschlüsseleinschränkungen](https://www.postgresql.org/docs/current/sql-altertable.html) auf der Ziel-DB-Instance und starten Sie dann die AWS DMS-Aufgabe. Weitere Informationen zur Deaktivierung von Triggern und Fremdschlüsseleinschränkungen finden Sie in der [AWS DMS-Dokumentation](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.PostgreSQL.html). | DBA | | Daten verifizieren. | Nachdem der vollständige Ladevorgang abgeschlossen ist, überprüfen Sie die Daten auf der Ziel-DB-Instance, um festzustellen, ob sie mit den Quelldaten übereinstimmen. Weitere Informationen finden Sie unter [AWS DMS-Datenvalidierung](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Validating.html) in der AWS DMS-Dokumentation. | DBA | ### Wechseln Sie zur Ziel-DB-Instance | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Beenden Sie Schreibvorgänge auf der Quell-DB-Instance. | Stoppen Sie die Schreibvorgänge auf der Quell-DB-Instance, sodass die Ausfallzeit der Anwendung beginnen kann. Stellen Sie sicher, dass AWS DMS die Replikation für die Daten in der Pipeline abgeschlossen hat. Aktivieren Sie Trigger und Fremdschlüssel auf der Ziel-DB-Instance. | DBA | | Datenbanksequenzen aktualisieren | Wenn die Quelldatenbank Sequenznummern enthält, überprüfen und aktualisieren Sie die Sequenzen in der Zieldatenbank. | DBA | | Konfigurieren Sie den Anwendungsendpunkt. | Konfigurieren Sie Ihre Anwendungsverbindungen für die Verwendung der neuen Amazon RDS-DB-Instance-Endpunkte. Die DB-Instance ist jetzt verschlüsselt. | DBA, Besitzer der Anwendung | ## Zugehörige Ressourcen + [Eine AWS-DMS-Aufgabe erstellen](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html) + [Überwachung von Replikationsaufgaben mit Amazon CloudWatch](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Monitoring.html#CHAP_Monitoring.CloudWatch) + [Überwachung von AWS DMS-Aufgaben](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Monitoring.html) + [Aktualisierung des Amazon RDS-Verschlüsselungsschlüssels](https://aws.amazon.com/premiumsupport/knowledge-center/update-encryption-key-rds/) ## Zusätzliche Informationen Überprüfung der Verschlüsselung für die Quell-PostgreSQL-DB-Instance: ![\[Auf der Übersichtsseite der Quell-PostgreSQL-DB-Instance wird angezeigt, dass die Verschlüsselung für den Speicher nicht aktiviert ist.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/820d17c0-0eed-4ed9-9f43-cbada081d924/images/d53d1dab-b5c2-452d-b823-ba3d6508ad15.png) Zusätzliche Hinweise zu diesem Muster: + Aktivieren Sie die Replikation auf PostgreSQL, indem Sie den `rds.logical_replication` Parameter auf 1 setzen. **Wichtiger Hinweis:** In Replikationsslots werden die Write-Ahead-Log-Dateien (WAL) aufbewahrt, bis die Dateien extern verwendet werden, z. B. durch `pg_recvlogical` ETL-Jobs (Extrahieren, Transformieren und Laden) oder durch AWS DMS. Wenn Sie den `rds.logical_replication` Parameterwert auf 1 setzen, legt AWS DMS die `max_connections` Parameter`wal_level`, `max_wal_senders``max_replication_slots`, und fest. Wenn logische Replikationssteckplätze vorhanden sind, es aber keinen Verbraucher für die im Replikationssteckplatz gespeicherten WAL-Dateien gibt, kann es zu einem Anstieg der Festplattennutzung im Transaktionsprotokoll und zu einer ständigen Verringerung des freien Speicherplatzes kommen. Weitere Informationen und Schritte zur Behebung dieses Problems finden Sie im Artikel [Wie kann ich feststellen, was die Ursache für den Fehler „Kein Speicherplatz auf dem Gerät übrig“ oder "DiskFull" in Amazon RDS for PostgreSQL ist](https://aws.amazon.com/premiumsupport/knowledge-center/diskfull-error-rds-postgresql/)? im AWS Support Knowledge Center. + Alle Schemaänderungen, die Sie nach der Erstellung des DB-Snapshots an der Quell-DB-Instance vornehmen, sind in der Ziel-DB-Instance nicht vorhanden. + Nachdem Sie eine verschlüsselte DB-Instance erstellt haben, können Sie den von dieser DB-Instance verwendeten KMS-Schlüssel nicht ändern. Stellen Sie sicher, dass Sie Ihre KMS-Schlüsselanforderungen ermitteln, bevor Sie Ihre verschlüsselte DB-Instance erstellen. + Sie müssen Trigger und Fremdschlüssel auf der Ziel-DB-Instance deaktivieren, bevor Sie die AWS DMS-Aufgabe ausführen. Sie können diese wieder aktivieren, wenn die Aufgabe abgeschlossen ist. # Automatisches Tagging von Amazon RDS-Datenbanken beim Start erzwingen *Susanne Kangnoh und Architekt Mathur, Amazon Web Services* ## Zusammenfassung Amazon Relational Database Service (Amazon RDS) ist ein Webservice, der die Einrichtung, den Betrieb und die Skalierung einer relationalen Datenbank in der Amazon Web Services (AWS) Cloud erleichtert. Dieser Service bietet kostengünstige und anpassbare Kapazität für eine Branchenstandards entsprechende relationale Datenbank sowie die Verwaltung gängiger Datenbankaufgaben. Sie können Tagging verwenden, um Ihre AWS-Ressourcen auf unterschiedliche Weise zu kategorisieren. Relationales Datenbank-Tagging ist nützlich, wenn Sie viele Ressourcen in Ihrem Konto haben und Sie anhand der Tags schnell eine bestimmte Ressource identifizieren möchten. Sie können Amazon RDS-Tags verwenden, um Ihren RDS-DB-Instances benutzerdefinierte Metadaten hinzuzufügen. Ein Tag besteht aus einem benutzerdefinierten Schlüssel und Wert. Wir empfehlen Ihnen, einen konsistenten Satz von Stichwörtern zu erstellen, um die Anforderungen Ihrer Organisation zu erfüllen. Dieses Muster bietet eine CloudFormation AWS-Vorlage, mit der Sie RDS-DB-Instances überwachen und kennzeichnen können. Die Vorlage erstellt ein Amazon CloudWatch Events-Ereignis, das nach dem AWS CloudTrail **DBInstanceCreate-Ereignis Ausschau** hält. (CloudTrail erfasst API-Aufrufe für Amazon RDS als Ereignisse.) Wenn es dieses Ereignis erkennt, ruft es eine AWS-Lambda-Funktion auf, die automatisch von Ihnen definierte Tag-Schlüssel und -Werte anwendet. Die Vorlage sendet auch eine Benachrichtigung, dass die Instance mithilfe von Amazon Simple Notification Service (Amazon SNS) markiert wurde. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto. + Ein Amazon Simple Storage Service (Amazon S3) -Bucket zum Hochladen des Lambda-Codes. + Eine E-Mail-Adresse, an die Sie Tagging-Benachrichtigungen erhalten möchten. **Einschränkungen** + Die Lösung unterstützt CloudTrail **Create DBInstance** Events. Es werden keine Benachrichtigungen für andere Ereignisse erstellt. ## Architektur **Workflow-Architektur** ![\[Workflow diagram showing AWS-Services interaction for RDS instance creation and notification.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/5541bc1e-e00f-4b5a-94b7-bb1808b5591a/images/ec0bcf92-f986-4af3-bfe7-d2c5e04051c5.png) **Automatisierung und Skalierung** + Sie können die CloudFormation AWS-Vorlage mehrfach für verschiedene AWS-Regionen und Konten verwenden. Sie müssen die Vorlage in jeder Region oder jedem Konto nur einmal ausführen. ## Tools **AWS-Services** + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) — AWS CloudTrail ist ein AWS-Service, der Sie bei der Steuerung, Einhaltung von Vorschriften sowie der Betriebs- und Risikoprüfung Ihres AWS-Kontos unterstützt. Aktionen, die von einem Benutzer, einer Rolle oder einem AWS-Service ausgeführt werden, werden als Ereignisse in aufgezeichnet CloudTrail. + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) — Amazon CloudWatch Events bietet einen Stream von Systemereignissen, die Änderungen an AWS-Ressourcen beschreiben, nahezu in Echtzeit. CloudWatch Events wird sofort auf betriebliche Änderungen aufmerksam und ergreift bei Bedarf Korrekturmaßnahmen, indem es Nachrichten sendet, um auf die Umgebung zu reagieren, Funktionen aktiviert, Änderungen vornimmt und Statusinformationen erfasst. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) — AWS Lambda ist ein Rechenservice, der die Ausführung von Code unterstützt, ohne dass Server bereitgestellt oder verwaltet werden müssen. Lambda führt Ihren Code nur bei Bedarf aus und skaliert automatisch – von einigen Anforderungen pro Tag bis zu Tausenden pro Sekunde. Sie bezahlen nur für die Datenverarbeitungszeit, die Sie wirklich nutzen und es werden keine Gebühren in Rechnung gestellt, wenn Ihr Code nicht ausgeführt wird. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) — Amazon Simple Storage Service (Amazon S3) ist ein hoch skalierbarer Objektspeicherservice, der für eine Vielzahl von Speicherlösungen verwendet werden kann, darunter Websites, mobile Anwendungen, Backups und Data Lakes. + [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) — Amazon Simple Notification Service (Amazon SNS) ist ein Webservice, der es Anwendungen, Endbenutzern und Geräten ermöglicht, sofort Benachrichtigungen aus der Cloud zu senden und zu empfangen. **Code** Dieses Muster beinhaltet einen Anhang mit zwei Dateien: + `index.zip`ist eine komprimierte Datei, die den Lambda-Code für dieses Muster enthält. + `rds.yaml`ist eine CloudFormation Vorlage, die den Lambda-Code bereitstellt. Informationen zur Verwendung dieser Dateien finden Sie im Abschnitt *Epics*. ## Epen ### Stellen Sie den Lambda-Code bereit | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Laden Sie den Code in einen S3-Bucket hoch. | Erstellen Sie einen neuen S3-Bucket oder verwenden Sie einen vorhandenen S3-Bucket, um die angehängte `index.zip` Datei hochzuladen (Lambda-Code). Dieser Bucket muss sich in derselben AWS-Region befinden wie die Ressourcen (RDS-DB-Instances), die Sie überwachen möchten. | Cloud-Architekt | | Stellen Sie die CloudFormation Vorlage bereit. | Öffnen Sie die Cloudformation-Konsole in derselben AWS-Region wie der S3-Bucket und stellen Sie die `rds.yaml` Datei bereit, die im Anhang bereitgestellt wird. Geben Sie im nächsten Epic Werte für die Vorlagenparameter an. | Cloud-Architekt | ### Vervollständigen Sie die Parameter in der CloudFormation Vorlage | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Geben Sie den S3-Bucket-Namen an. | Geben Sie den Namen des S3-Buckets ein, den Sie im ersten Epic erstellt oder ausgewählt haben. Dieser S3-Bucket enthält die ZIP-Datei für den Lambda-Code und muss sich in derselben AWS-Region befinden wie die CloudFormation Vorlage und die RDS-DB-Instances, die Sie überwachen möchten. | Cloud-Architekt | | Geben Sie den S3-Schlüssel an. | Geben Sie den Speicherort der Lambda-Code-ZIP-Datei in Ihrem S3-Bucket an, ohne vorangestellte Schrägstriche (z. B. `index.zip` oder). `controls/index.zip` | Cloud-Architekt | | Geben Sie eine E-Mail-Adresse an. | Geben Sie eine aktive E-Mail-Adresse an, unter der Sie Benachrichtigungen über Verstöße erhalten möchten. | Cloud-Architekt | | Geben Sie eine Protokollierungsebene an. | Geben Sie die Protokollierungsebene und die Ausführlichkeit an. `Info`bezeichnet detaillierte Informationsmeldungen über den Fortschritt der Anwendung und sollte nur zum Debuggen verwendet werden. `Error`bezeichnet Fehlerereignisse, die es der Anwendung dennoch ermöglichen könnten, weiter zu laufen. `Warning`bezeichnet potenziell schädliche Situationen. | Cloud-Architekt | | Geben Sie die Tag-Schlüssel und Werte für Ihre RDS-DB-Instances ein. | Geben Sie die erforderlichen Tag-Schlüssel und -Werte ein, die Sie automatisch auf die RDS-Instance anwenden möchten. Weitere Informationen finden Sie unter [Tagging Amazon RDS-Ressourcen](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) in der AWS-Dokumentation. | Cloud-Architekt | ### Bestätigen Sie das Abonnement | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Bestätigen Sie das E-Mail-Abonnement. | Wenn die CloudFormation Vorlage erfolgreich bereitgestellt wurde, sendet sie eine Abonnement-E-Mail-Nachricht an die von Ihnen angegebene E-Mail-Adresse. Um Benachrichtigungen zu erhalten, wenn Ihre Instances markiert wurden, müssen Sie dieses E-Mail-Abonnement bestätigen. | Cloud-Architekt | ## Zugehörige Ressourcen + [Einen Bucket erstellen](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) (Amazon S3 S3-Dokumentation) + [Taggen von Amazon RDS-Ressourcen](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_Tagging.html) (Amazon Aurora Aurora-Dokumentation) + [Objekte hochladen](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) (Amazon S3 S3-Dokumentation) + [Erstellen einer CloudWatch Ereignisregel, die bei einem AWS-API-Aufruf mithilfe von AWS ausgelöst](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-CloudTrail-Rule.html) wird CloudTrail ( CloudWatch Amazon-Dokumentation) ## Anlagen [Um auf zusätzliche Inhalte zuzugreifen, die mit diesem Dokument verknüpft sind, entpacken Sie die folgende Datei: attachment.zip](samples/p-attach/5541bc1e-e00f-4b5a-94b7-bb1808b5591a/attachments/attachment.zip) # Schätzen Sie die Kosten einer DynamoDB-Tabelle für On-Demand-Kapazität *Moinul Al-Mamun, Amazon Web Services* ## Zusammenfassung [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) ist eine NoSQL-Transaktionsdatenbank, die selbst im Petabyte-Bereich Latenz im einstelligen Millisekundenbereich bietet. Dieses serverlose Angebot von Amazon Web Services (AWS) erfreut sich aufgrund seiner gleichbleibenden Leistung und Skalierbarkeit immer größerer Beliebtheit. Sie müssen die zugrunde liegende Infrastruktur nicht bereitstellen. Ihre einzelne Tabelle kann bis zu Petabyte groß werden. Im On-Demand-Kapazitätsmodus zahlen Sie pro Anfrage für die Lese- und Schreibvorgänge, die Ihre Anwendung an den Tabellen durchführt. Die AWS-Gebühren basieren auf den kumulierten Leseanforderungseinheiten (RRUs) und Schreibanforderungseinheiten (WRUs) in einem Monat. DynamoDB überwacht den ganzen Monat über kontinuierlich die Größe Ihrer Tabelle, um Ihre Speichergebühren zu ermitteln. Es unterstützt kontinuierliches Backup mit point-in-time-recovery (PITR). DynamoDB überwacht den ganzen Monat über kontinuierlich die Größe Ihrer PITR-fähigen Tabellen, um Ihre Backup-Gebühren zu ermitteln. Um die DynamoDB-Kosten für ein Projekt abzuschätzen, ist es wichtig zu berechnen, wie viel RRU, WRU und Speicherplatz in den verschiedenen Phasen Ihres Produktlebenszyklus verbraucht werden. Für eine grobe Kostenschätzung können Sie den [AWS-Preisrechner](https://calculator.aws/#/createCalculator/DynamoDB) verwenden. Sie müssen jedoch eine ungefähre Anzahl von RRUs WRUs, und Speicheranforderungen für Ihre Tabelle angeben. Zu Beginn des Projekts kann es schwierig sein, diese abzuschätzen. Der AWS-Preisrechner berücksichtigt weder die Datenwachstumsrate noch die Artikelgröße und berücksichtigt auch nicht die Anzahl der Lese- und Schreibvorgänge für die Basistabelle und die globalen Sekundärindizes (GSIs) getrennt. Um den AWS-Preisrechner verwenden zu können, müssen Sie all diese Aspekte abschätzen, um von ungefähren Zahlen für WRU, RRU und Speichergröße auszugehen, um Ihre Kostenschätzung zu erhalten. Dieses Muster bietet einen Mechanismus und eine wiederverwendbare Microsoft Excel-Vorlage zur Schätzung grundlegender DynamoDB-Kostenfaktoren wie Schreib-, Lese-, Speicher-, Sicherungs- und Wiederherstellungskosten für den On-Demand-Kapazitätsmodus. Er ist detaillierter als der AWS-Preisrechner und berücksichtigt die Basistabelle und die GSIs Anforderungen unabhängig voneinander. Es berücksichtigt auch die monatliche Wachstumsrate der Artikeldaten und prognostiziert die Kosten für drei Jahre. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Grundkenntnisse in DynamoDB und DynamoDB-Datenmodelldesign + Grundkenntnisse zu DynamoDB-Preisen, WRU, RRU, Speicher sowie Backup und Recovery (weitere Informationen finden Sie unter [Preise](https://aws.amazon.com/dynamodb/pricing/on-demand/) für On-Demand-Kapazität) + Kenntnis Ihrer Daten, Ihres Datenmodells und Ihrer Elementgröße in DynamoDB + Kenntnisse von DynamoDB GSIs **Einschränkungen** + Die Vorlage bietet Ihnen eine ungefähre Berechnung, ist jedoch nicht für alle Konfigurationen geeignet. Um eine genauere Schätzung zu erhalten, müssen Sie die individuelle Artikelgröße für jeden Artikel in der Basistabelle und messen GSIs. + Für eine genauere Schätzung müssen Sie die erwartete Anzahl von Schreibvorgängen (Einfügen, Aktualisieren und Löschen) und Lesevorgängen für jedes Element in einem durchschnittlichen Monat berücksichtigen. + Dieses Muster ermöglicht es, nur die Schreib-, Lese-, Speicher-, Sicherungs- und Wiederherstellungskosten für die nächsten Jahre auf der Grundlage fester Annahmen zum Datenwachstum zu schätzen. ## Tools **AWS-Services** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) ist ein vollständig verwalteter NoSQL-Datenbank-Service, der schnelle und planbare Leistung mit nahtloser Skalierbarkeit bereitstellt. **Andere Tools** + Der [AWS-Preisrechner](https://calculator.aws/#/createCalculator/DynamoDB) ist ein webbasiertes Planungstool, mit dem Sie Schätzungen für Ihre AWS-Anwendungsfälle erstellen können. ## Best Practices Um die Kosten niedrig zu halten, sollten Sie die folgenden Best Practices für den DynamoDB-Entwurf berücksichtigen. + [Entwerfen von Partitionsschlüsseln](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-partition-key-uniform-load.html) – Verwenden Sie einen Partitionsschlüssel mit hoher Kardinalität, um die Last gleichmäßig zu verteilen. + [Entwurfsmuster für Adjazenzlisten](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency-graphs.html) — Verwenden Sie dieses Entwurfsmuster für Verwaltung one-to-many und Beziehungen. many-to-many + [Sparse-Index](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-indexes-general-sparse-indexes.html) — Verwenden Sie den Sparse-Index für Ihren. GSIs Wenn Sie einen GSI erstellen, geben Sie einen Partitionsschlüssel und optional einen Sortierschlüssel an. Nur Elemente in der Basistabelle, die einen entsprechenden GSI-Partitionsschlüssel enthalten, werden im Sparse-Index angezeigt. Dies hilft, kleiner zu bleiben GSIs . + [Überladen von Indizes](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-gsi-overloading.html) – Verwenden Sie dieselbe GSI für die Indizierung verschiedener Arten von Elementen. + [GSI Write-Sharding](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-indexes-gsi-sharding.html)— Sharden Sie mit Bedacht, um Daten auf die Partitionen zu verteilen und so effiziente und schnellere Abfragen zu ermöglichen. + [Große Gegenstände](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-use-s3-too.html) – Speichern Sie nur Metadaten in der Tabelle, speichern Sie den Blob in Amazon S3 und behalten Sie die Referenz in DynamoDB bei. Teilen Sie große Elemente in mehrere Elemente auf und indizieren Sie sie effizient mithilfe von Sortierschlüsseln. Weitere bewährte Methoden finden Sie im [Leitfaden für Entwickler](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html) von Amazon DynamoDB. ## Epen ### Extrahieren Sie Artikelinformationen aus Ihrem DynamoDB-Datenmodell | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Artikelgröße ermitteln. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Dateningenieur | | Schätzen Sie die Schreibkosten ab. | Um die Schreibkosten im On-Demand-Kapazitätsmodus zu schätzen, müssen Sie zunächst messen, wie viele Kapazitäten in einem Monat verbraucht WRUs werden. Dazu müssen Sie die folgenden Faktoren berücksichtigen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html)Weitere Informationen finden Sie im Abschnitt *Zusätzliche Informationen*. | Dateningenieur | | Schätzen Sie die Lesekosten ab. | Um die Lesekosten im On-Demand-Modus zu schätzen, müssen Sie zunächst messen, wie viele Lesekosten in einem Monat verbraucht RRUs werden. Dazu müssen Sie die folgenden Faktoren berücksichtigen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Dateningenieur, App-Entwickler | | Schätzen Sie die Speichergröße und die Kosten ab. | Schätzen Sie zunächst den durchschnittlichen monatlichen Lagerbedarf auf der Grundlage Ihrer Artikelgröße in der Tabelle. Berechnen Sie dann die Speicherkosten, indem Sie die Speichergröße mit dem Speicherpreis pro GB für Ihre AWS-Region multiplizieren. Wenn Sie bereits Daten zur Schätzung der Schreibkosten eingegeben haben, müssen Sie diese zur Berechnung der Speichergröße nicht erneut eingeben. Andernfalls müssen Sie bei der Schätzung der Speichergröße die folgenden Faktoren berücksichtigen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Dateningenieur | ### Geben Sie die Artikel- und Objektinformationen in die Excel-Vorlage ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Laden Sie die Excel-Vorlage aus dem Bereich Anlagen herunter und passen Sie sie an Ihre Anwendungsfalltabelle an. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html) | Dateningenieur | | Geben Sie Informationen in die Excel-Vorlage ein. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.html)In der Vorlage gibt es drei Elemente oder Entitäten: Informationen, Metadaten und Beziehung. Es gibt zwei GSIs. Wenn Sie für Ihren Anwendungsfall mehr Elemente benötigen, erstellen Sie neue Zeilen. Wenn Sie mehr benötigen GSIs, kopieren Sie einen vorhandenen GSI-Block und fügen Sie ihn ein, um so viele GSI-Blöcke zu erstellen, wie Sie benötigen. Passen Sie dann die Berechnungen der Spalten SUM und TOTAL an. | Dateningenieur | ## Zugehörige Ressourcen **Referenzen** + [Amazon DynamoDB DynamoDB-Preise für On-Demand-Kapazität](https://aws.amazon.com/dynamodb/pricing/on-demand/) + [AWS-Preisrechner für DynamoDB](https://calculator.aws/#/createCalculator/DynamoDB) + [Bewährte Methoden für Design und Architektur mit DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html) + [Erste Schritte mit DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) **Anleitungen und Muster** + [Modellieren von Daten mit Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/) + [Schätzung der Speicherkosten für eine Amazon DynamoDB-Tabelle](https://apg-library.amazonaws.com/content/9b74399d-9655-47ee-b9b3-de46b65bc4e3) ## Zusätzliche Informationen **Schreiben Sie ein Beispiel für eine Kostenberechnung** Das DynamoDB-Datenmodelldesign zeigt drei Elemente für ein Produkt und eine durchschnittliche Artikelgröße von 4 KB. Wenn Sie der DynamoDB-Basistabelle ein neues Produkt hinzufügen, verbraucht es die Anzahl der Elemente \$1 (Artikelgröße/1 KB Schreibeinheit) = 3 \$1 (4/1) = 12 WRU. In diesem Beispiel verbraucht das Produkt beim Schreiben von 1 KB 1 WRU. **Lesen Sie das Beispiel für die Kostenberechnung** Um die RRU-Schätzung zu erhalten, berücksichtigen Sie den Durchschnitt, wie oft jeder Artikel in einem Monat gelesen wird. Beispielsweise wird das Informationselement im Durchschnitt zehnmal pro Monat gelesen, und das Metadatenelement wird zweimal gelesen und das Beziehungselement wird fünfmal gelesen. In der Beispielvorlage gilt: Gesamt-RRU für alle Komponenten = Anzahl der jeden Monat neu erstellten Komponenten \$1 RRU pro Komponente pro Monat = 10 Millionen \$1 17 RRU = 170 Millionen RRU pro Monat. Jeden Monat werden neue Dinge (Komponenten oder Produkte) hinzugefügt, und die Gesamtzahl der Produkte wird im Laufe der Zeit zunehmen. Daher werden auch die RRU-Anforderungen im Laufe der Zeit steigen. + Im ersten Monat RRU wird der Verbrauch 170 Millionen betragen. + Im zweiten Monat wird der RRU-Verbrauch 2 \$1 170 Millionen = 340 Millionen betragen. + Im dritten Monat wird der RRU-Verbrauch 3 × 170 Millionen = 510 Millionen betragen. Die folgende Grafik zeigt die monatlichen RRU-Verbrauchs- und Kostenprognosen. ![\[Der RRU-Verbrauch steigt stärker als die Kosten.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/1797b48f-a183-4f25-811f-44921c3a48ee/images/3505bfc8-694d-4acc-8585-cd71258fa315.png) Beachten Sie, dass die Preise in der Grafik nur zur Veranschaulichung dienen. Um genaue Prognosen für Ihren Anwendungsfall zu erstellen, besuchen Sie die AWS-Preisseite und verwenden Sie diese Preise in der Excel-Tabelle. **Beispiele für die Berechnung der Kosten für Speicherung, Sicherung und Wiederherstellung** DynamoDB-Speicher, Backup und Wiederherstellung sind alle miteinander verbunden. Das Backup ist direkt mit dem Speicher verbunden, und die Wiederherstellung ist direkt mit der Größe des Backups verbunden. Mit zunehmender Tabellengröße steigen die entsprechenden Speicher-, Sicherungs- und Wiederherstellungskosten proportional. *Speichergröße und Kosten* Die Speicherkosten werden im Laufe der Zeit entsprechend Ihrer Datenwachstumsrate steigen. Nehmen wir beispielsweise an, dass die durchschnittliche Größe einer Komponente oder eines Produkts in der Basistabelle 11 KB GSIs beträgt und dass Ihrer Datenbanktabelle jeden Monat 10 Millionen neue Produkte hinzugefügt werden. In diesem Fall wächst die Größe Ihrer DynamoDB-Tabelle (11 KB x 10 Millionen) /1024/1024 = 105 GB pro Monat. Im ersten Monat beträgt Ihre Tabellenspeichergröße 105 GB, im zweiten Monat 105 \$1 105 = 210 usw. GBs + Im ersten Monat betragen die Speicherkosten 105 GB\$1 Speicherpreis pro GB für Ihre AWS-Region. + Für den zweiten Monat belaufen sich die Speicherkosten auf 210 GB\$1 Speicherpreis pro GB für Ihre Region. + Für den dritten Monat belaufen sich die Speicherkosten auf 315 GB\$1 Speicherpreis pro GB für Ihre Region. Informationen zur Speichergröße und zu den Kosten für die nächsten drei Jahre finden Sie im Abschnitt *Speichergröße und Prognose*. *Backup-Kosten* Die Backup-Kosten werden im Laufe der Zeit entsprechend Ihrer Datenwachstumsrate steigen. Wenn Sie Continuous Backup mit point-in-time-recovery (PITR) aktivieren, basieren die Gebühren für kontinuierliches Backup auf dem durchschnittlichen Speichervolumen pro Monat. In einem Kalendermonat würde die durchschnittliche Backup-Größe der Größe Ihres Tabellenspeichers entsprechen, obwohl die tatsächliche Größe etwas anders sein könnte. Da jeden Monat neue Produkte hinzugefügt werden, werden die Gesamtspeichergröße und die Backup-Größe im Laufe der Zeit zunehmen. Beispielsweise könnte die durchschnittliche Backup-Größe von 105 GB für den ersten Monat auf 210 GB für den zweiten Monat ansteigen. + Im ersten Monat betragen die Backup-Kosten 105 GB-Monat\$1 Preis für kontinuierliches Backup pro GB für Ihre AWS-Region. + Im zweiten Monat belaufen sich die Backup-Kosten auf 210 GB-Monat\$1 Preis für kontinuierliches Backup pro GB für Ihre Region. + Im dritten Monat belaufen sich die Backup-Kosten auf 315 GB pro Monat \$1 Preis für kontinuierliches Backup pro GB für Ihre Region. + und so weiter Die Backup-Kosten sind in der Grafik im Abschnitt *Speichergröße und Kostenprognose* enthalten. *Kosten für die Wiederherstellung* Wenn Sie ein kontinuierliches Backup mit aktiviertem PITR erstellen, richten sich die Gebühren für den Wiederherstellungsvorgang nach dem Umfang der Wiederherstellung. Bei jeder Wiederherstellung zahlen Sie auf der Grundlage von Gigabyte wiederhergestellter Daten. Wenn Ihre Tabelle groß ist und Sie die Wiederherstellung mehrmals im Monat durchführen, ist dies kostspielig. Um die Wiederherstellungskosten abzuschätzen, wird in diesem Beispiel davon ausgegangen, dass Sie einmal pro Monat am Monatsende eine PITR-Wiederherstellung durchführen. In dem Beispiel wird die durchschnittliche monatliche Backup-Größe als Größe der Wiederherstellungsdaten für diesen Monat verwendet. Für den ersten Monat beträgt die durchschnittliche Backup-Größe 105 GB, und für die Wiederherstellung am Monatsende würde die Größe der Wiederherstellungsdaten 105 GB betragen. Für den zweiten Monat wären es 210 GBs und so weiter. Die Wiederherstellungskosten werden im Laufe der Zeit entsprechend Ihrer Datenwachstumsrate steigen. + Im ersten Monat betragen die Wiederherstellungskosten 105 GB\$1 Wiederherstellungspreis pro GB für Ihre AWS-Region. + Im zweiten Monat belaufen sich die Wiederherstellungskosten auf 210 GB\$1 Wiederherstellungspreis pro GB für Ihre Region. + Im dritten Monat belaufen sich die Wiederherstellungskosten auf 315 GB\$1 Wiederherstellungspreis pro GB für Ihre Region. Weitere Informationen finden Sie auf der Registerkarte Speicher, Sicherung und Wiederherstellung in der Excel-Vorlage und in der Grafik im folgenden Abschnitt. *Prognose der Speichergröße und der Kosten* In der Vorlage wird die tatsächliche fakturierbare Speichergröße berechnet, indem das kostenlose Kontingent 25 GB pro Monat für die Standard-Tabellenklasse subtrahiert wird. In dem Blatt erhalten Sie ein Prognosediagramm, das in monatliche Werte unterteilt ist. Das folgende Beispieldiagramm prognostiziert die monatliche Speichergröße in GB, die fakturierbaren Speicherkosten, die Kosten für On-Demand-Backups und die Wiederherstellungskosten für die nächsten 36 Kalendermonate. Alle Kosten sind in USD angegeben. Aus der Grafik wird deutlich, dass die Speicher-, Backup- und Wiederherstellungskosten proportional zur Speichergröße steigen. ![\[Die Speichergröße steigt auf über dreitausend, während die Kosten unter eintausend liegen.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/1797b48f-a183-4f25-811f-44921c3a48ee/images/fd9f06d0-bc9c-4b4e-8cbd-3e527fe09e88.png) Beachten Sie, dass die in der Grafik verwendeten Preise nur zur Veranschaulichung dienen. Um genaue Preise für Ihren Anwendungsfall zu erstellen, besuchen Sie die AWS-Preisseite und verwenden Sie diese Preise in der Excel-Vorlage. ## Anlagen [Um auf zusätzliche Inhalte zuzugreifen, die mit diesem Dokument verknüpft sind, entpacken Sie die folgende Datei: attachment.zip](samples/p-attach/1797b48f-a183-4f25-811f-44921c3a48ee/attachments/attachment.zip) # Schätzung der Speicherkosten für eine Amazon DynamoDB-Tabelle *Moinul Al-Mamun, Amazon Web Services* ## Zusammenfassung Amazon DynamoDB ist eine NoSQL-Transaktionsdatenbank, die selbst im Petabyte-Bereich Latenz im einstelligen Millisekundenbereich bietet. Dieses beliebte serverlose Angebot von bietet konsistente Leistung und Skalierbarkeit. AWS Sie müssen keinen Speicher bereitstellen, und Ihre einzelne Tabelle kann bis zu Petabyte anwachsen. DynamoDB überwacht den ganzen Monat über kontinuierlich die Größe Ihrer Tabelle, um Ihre Speichergebühren zu ermitteln. AWS berechnet Ihnen dann die durchschnittliche Speichergröße in Gigabyte. Je mehr Ihre Tabelle im Laufe der Zeit wächst, desto stärker steigen Ihre Speicherkosten. Um die Speicherkosten zu berechnen, können Sie den [AWS Preisrechner](https://calculator.aws/#/createCalculator/DynamoDB) verwenden. Sie müssen jedoch die ungefähre Größe Ihrer Tabelle einschließlich der globalen Sekundärindizes (GSIs) angeben, was zu Beginn des Projekts nur schwer abzuschätzen ist. Außerdem berücksichtigt der AWS Preisrechner nicht die Datenwachstumsrate. Dieses Muster bietet einen Mechanismus und eine wiederverwendbare Microsoft Excel-Vorlage zur Berechnung von DynamoDB-Speichergröße und -kosten. Es berücksichtigt die Speicheranforderungen für die Basistabelle und die GSIs unabhängige Tabelle. Es berechnet die Speichergröße unter Berücksichtigung der Größe Ihrer einzelnen Elemente und der Datenwachstumsrate im Laufe der Zeit. Um eine Schätzung zu erhalten, fügen Sie zwei Informationen in die Vorlage ein: + Die Größe der einzelnen Elemente in Kilobyte für die Basistabelle und GSIs + Wie viele neue Objekte oder Produkte könnten der Tabelle im Durchschnitt in einem Monat hinzugefügt werden (z. B. 10 Millionen) Die Vorlage generiert ein Diagramm zur Speicher- und Kostenprognose für die nächsten drei Jahre, das im folgenden Beispiel dargestellt wird. ![\[Die untere Zeile für die Kosten wird langsam nach oben bewegt und die obere Zeile für den Speicher schneller nach oben.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/9b74399d-9655-47ee-b9b3-de46b65bc4e3/images/c0436252-cc42-4ea3-ac50-c0455aece39d.png) ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Grundkenntnisse in DynamoDB, einschließlich DynamoDB-Speicher und Preisgestaltung + Kenntnis Ihrer Daten, Ihres Datenmodells und Ihrer Elementgröße in DynamoDB + Kenntnis der globalen Sekundärindizes von DynamoDB () GSIs **Einschränkungen** + Die Vorlage bietet Ihnen eine ungefähre Berechnung, ist jedoch nicht für alle Konfigurationen geeignet. Um eine genauere Schätzung zu erhalten, müssen Sie die individuelle Artikelgröße für jeden Artikel in der Basistabelle und messen GSIs. + Dieses Muster unterstützt lediglich die Schätzung der Speichergröße und der Kosten für die nächsten Jahre auf der Grundlage fester Annahmen zum Datenwachstum. ## Tools **AWS-Services** + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) ist ein vollständig verwalteter NoSQL-Datenbank-Service, der schnelle und planbare Leistung mit nahtloser Skalierbarkeit bereitstellt. **Andere Tools** + [AWS Pricing Calculator](https://docs.aws.amazon.com/pricing-calculator/latest/userguide/what-is-pricing-calculator.html) ist ein webbasiertes Planungstool, mit dem Sie Schätzungen für Ihre AWS Anwendungsfälle erstellen können. ## Epen ### Extrahieren Sie Artikelinformationen aus Ihrem DynamoDB-Datenmodell | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Artikelgröße ermitteln. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Dateningenieur | | Ermittelt die Anzahl der Objekte, die in einem Monat hinzugefügt wurden. | Schätzen Sie, wie viele Komponenten oder Objekte durchschnittlich in einem Monat zur DynamoDB-Tabelle hinzugefügt werden. | Dateningenieur | ### Geben Sie die Artikel- und Objektinformationen in die Excel-Vorlage ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Laden Sie die Excel-Tabelle herunter und passen Sie sie an. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Dateningenieur | | Geben Sie Informationen in die Excel-Vorlage ein. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-storage-costs-for-an-amazon-dynamodb-table.html) | Dateningenieur | ## Zugehörige Ressourcen + [Preise für On-Demand-Kapazität](https://aws.amazon.com/dynamodb/pricing/on-demand/) für Amazon DynamoDB + [AWS Preisrechner für DynamoDB](https://calculator.aws/#/createCalculator/DynamoDB) ## Zusätzliche Informationen Beachten Sie, dass in der beigefügten Vorlage nur die Speichergröße und die Kosten für die Standard-Speichertabellenklasse prognostiziert werden. Auf der Grundlage der Prognose für die Lagerkosten und unter Berücksichtigung der Größe einzelner Artikel und der Wachstumsrate von Produkten oder Objekten können Sie Folgendes abschätzen: + Kosten für den Datenexport + Kosten für Backup und Wiederherstellung + Anforderungen an die Datenspeicherung. **Amazon DynamoDB DynamoDB-Datenspeicherkosten** DynamoDB überwacht kontinuierlich die Größe Ihrer Tabellen, um Ihre Speichergebühren zu ermitteln. DynamoDB misst die Größe Ihrer fakturierbaren Daten, indem es die Roh-Byte-Größe Ihrer Daten mit einem Speicher-Overhead pro Element addiert, der von den Funktionen abhängt, die Sie aktiviert haben. Weitere Informationen finden Sie im [DynamoDB Developer Guide](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/CapacityUnitCalculations.html). Der Preis für die Datenspeicherung hängt von Ihrer Tabellenklasse ab. Die ersten 25 GB, die jeden Monat gespeichert werden, sind kostenlos, wenn Sie die DynamoDB-Standard-Tabellenklasse verwenden. [Weitere Informationen zu den Speicherkosten für die Tabellenklassen Standard und Standard Infrequent Access in den verschiedenen AWS-Regionen Tabellenklassen finden Sie unter Preise für On-Demand-Kapazität.](https://aws.amazon.com/dynamodb/pricing/on-demand/) ## Anlagen [Um auf zusätzliche Inhalte zuzugreifen, die mit diesem Dokument verknüpft sind, entpacken Sie die folgende Datei: attachment.zip](samples/p-attach/9b74399d-9655-47ee-b9b3-de46b65bc4e3/attachments/attachment.zip) # Schätzen Sie die Größe der Amazon RDS-Engine für eine Oracle-Datenbank mithilfe von AWR-Berichten *Abhishek Verma und Eduardo Valentim, Amazon Web Services* ## Zusammenfassung Wenn Sie eine Oracle-Datenbank zu Amazon Relational Database Service (Amazon RDS) oder Amazon Aurora migrieren, ist die Berechnung der CPU, des Speichers und der Festplatte I/O für die Zieldatenbank eine wichtige Anforderung. Sie können die erforderliche Kapazität der Zieldatenbank abschätzen, indem Sie die AWR-Berichte (Oracle Automatic Workload Repository) analysieren. Dieses Muster erklärt, wie AWR-Berichte verwendet werden, um diese Werte zu schätzen. Die Oracle-Quelldatenbank kann vor Ort sein oder auf einer Amazon Elastic Compute Cloud (Amazon EC2) -Instance gehostet werden, oder es könnte sich um eine Amazon RDS for Oracle DB-Instance handeln. Die Zieldatenbank kann eine beliebige Amazon RDS- oder Aurora-Datenbank sein. **Anmerkung** Kapazitätsschätzungen sind genauer, wenn es sich bei Ihrer Zieldatenbank-Engine um Oracle handelt. Bei anderen Amazon RDS-Datenbanken kann die Engine-Größe aufgrund von Unterschieden in der Datenbankarchitektur variieren. Wir empfehlen, dass Sie den Leistungstest ausführen, bevor Sie Ihre Oracle-Datenbank migrieren. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Eine Oracle Database Enterprise Edition-Lizenz und eine Oracle Diagnostics Pack-Lizenz, um AWR-Berichte herunterzuladen. **Produktversionen** + Alle Oracle Database-Editionen für die Versionen 11g (Versionen 11.2.0.3.v1 und höher) und bis zu 12.2 und 18c,19c. + Dieses Muster gilt nicht für Oracle Engineered Systems oder Oracle Cloud Infrastructure (OCI). ## Architektur **Quelltechnologie-Stack** Eine der beiden folgenden Komponenten: + Eine lokale Oracle-Datenbank + Eine Oracle-Datenbank auf einer Instanz EC2 + Eine Amazon RDS for Oracle Oracle-DB-Instance **Zieltechnologie-Stack** + Beliebige Amazon RDS- oder Amazon Aurora Aurora-Datenbank **Zielarchitektur** Informationen zum vollständigen Migrationsprozess finden Sie im Muster [Migrieren Sie eine Oracle-Datenbank mithilfe von AWS DMS und AWS SCT zu Aurora PostgreSQL](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.html). **Automatisierung und Skalierung** Wenn Sie mehrere Oracle-Datenbanken migrieren müssen und zusätzliche Leistungskennzahlen verwenden möchten, können Sie den Prozess automatisieren, indem Sie die im Blogbeitrag [Skalierbare Größe von Amazon RDS-Instances auf der Grundlage von Oracle-Leistungskennzahlen](https://aws.amazon.com/blogs/database/right-sizing-amazon-rds-instances-at-scale-based-on-oracle-performance-metrics/) anpassen beschriebenen Schritte ausführen. ## Tools + Das [Oracle Automatic Workload Repository (AWR)](https://docs.oracle.com/en-us/iaas/performance-hub/doc/awr-report-ui.html) ist ein Repository, das in Oracle-Datenbanken integriert ist. Es sammelt und speichert regelmäßig Systemaktivitäts- und Workload-Daten, die dann vom Automatic Database Diagnostic Monitor (ADDM) analysiert werden. AWR erstellt in regelmäßigen Abständen (standardmäßig alle 60 Minuten) Snapshots der Systemleistungsdaten und speichert die Informationen (standardmäßig bis zu 8 Tage). Sie können AWR-Ansichten und -Berichte verwenden, um diese Daten zu analysieren. ## Best Practices + Um den Ressourcenbedarf für Ihre Zieldatenbank zu berechnen, können Sie einen einzelnen AWR-Bericht, mehrere AWR-Berichte oder dynamische AWR-Ansichten verwenden. Wir empfehlen, dass Sie während der Spitzenlastperiode mehrere AWR-Berichte verwenden, um abzuschätzen, welche Ressourcen zur Bewältigung dieser Spitzenlasten erforderlich sind. Darüber hinaus bieten dynamische Ansichten mehr Datenpunkte, mit denen Sie den Ressourcenbedarf genauer berechnen können. + Sie sollten die IOPS nur für die Datenbank schätzen, die Sie migrieren möchten, nicht für andere Datenbanken und Prozesse, die die Festplatte verwenden. + Verwenden Sie nicht die Informationen im Abschnitt „Ladeprofil“ des AWR-Berichts, um zu berechnen, wie viel I/O von der Datenbank genutzt wird. Verwenden Sie stattdessen den Abschnitt I/O Profil, sofern er verfügbar ist, oder springen Sie zum Abschnitt Instanzaktivitätsstatistiken und sehen Sie sich die Gesamtwerte für physische Lese- und Schreibvorgänge an. + Wenn Sie die CPU-Auslastung schätzen, empfehlen wir, die Methode der Datenbankmetriken anstelle von Betriebssystemstatistiken (OS) zu verwenden, da sie auf der CPU basiert, die nur von Datenbanken verwendet wird. (Betriebssystemstatistiken beinhalten auch die CPU-Auslastung durch andere Prozesse.) Sie sollten auch die CPU-bezogenen Empfehlungen im ADDM-Bericht überprüfen, um die Leistung nach der Migration zu verbessern. + Berücksichtigen Sie bei der Bestimmung des richtigen Instance-Typs die I/O Durchsatzgrenzen — den Durchsatz von Amazon Elastic Block Store (Amazon EBS) und den Netzwerkdurchsatz — für die jeweilige Instance-Größe. + Führen Sie vor der Migration den Leistungstest durch, um die Engine-Größe zu überprüfen. ## Epen ### Erstellen Sie einen AWR-Bericht | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Aktivieren Sie den AWR-Bericht. | Folgen Sie den Anweisungen in der [Oracle-Dokumentation](https://docs.oracle.com/en/database/oracle/oracle-database/18/tgdba/gathering-database-statistics.html#GUID-26D359FA-F809-4444-907C-B5AFECD9AE29), um den Bericht zu aktivieren. | DBA | | Überprüfen Sie die Aufbewahrungsfrist. | Verwenden Sie die folgende Abfrage, um den Aufbewahrungszeitraum des AWR-Berichts zu überprüfen.
cc_idx:-2 country:Invalid
cc_idx:0 country:China
cc_idx:3 country:UK
cc_idx:5 country:USA
cc_idx:7 country:India
SQL> SELECT snap_interval,retention FROM dba_hist_wr_control;| DBA | | Generieren Sie den Snapshot. | Wenn das AWR-Snapshot-Intervall nicht detailliert genug ist, um die Spitze der Arbeitslast zu erfassen, können Sie den AWR-Bericht manuell generieren. Verwenden Sie die folgende Abfrage, um den manuellen AWR-Snapshot zu generieren.
SQL> EXEC dbms_workload_repository.create_snapshot;| DBA | | Sehen Sie sich die letzten Schnappschüsse an. | Verwenden Sie die folgende Abfrage, um die letzten AWR-Snapshots zu überprüfen.
SQL> SELECT snap_id, to_char(begin_interval_time,'dd/MON/yy hh24:mi') Begin_Interval,| DBA | ### Schätzen Sie die Festplattenanforderungen I/O | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Wählen Sie eine Methode aus. | IOPS ist das Standardmaß für Eingabe- und Ausgabevorgänge pro Sekunde auf einem Speichergerät und umfasst sowohl Lese- als auch Schreibvorgänge. Wenn Sie eine lokale Datenbank zu AWS migrieren, müssen Sie den Spitzendatenträger ermitteln, der von der Datenbank I/O verwendet wird. Sie können die folgenden Methoden verwenden, um die Festplattenkapazität I/O für Ihre Zieldatenbank zu schätzen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)In den folgenden Schritten werden diese vier Methoden beschrieben. | DBA | | Option 1: Verwenden Sie das Lastprofil. | Die folgende Tabelle zeigt ein Beispiel für den Abschnitt „Lastprofil“ des AWR-Berichts.Für genauere Informationen empfehlen wir, Option 2 (I/O-Profile) oder Option 3 (Instanzaktivitätsstatistiken) anstelle des Lastprofils zu verwenden.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Auf der Grundlage dieser Informationen können Sie den Durchsatz wie folgt berechnen IOPs :*IOPS = I/O Leseanforderungen: \$1 I/O Schreibanforderungen = 3.586,8 \$1 574,7 = 4134,5**Durchsatz = Physisches Lesen (Blöcke) \$1 Physisches Schreiben (Blöcke) = 13.575,1 \$1 3.467,3 = 17.042,4*Da die Blockgröße in Oracle 8 KB beträgt, können Sie den Gesamtdurchsatz wie folgt berechnen:*Der Gesamtdurchsatz in MB beträgt 17042,4 \$1 8 \$1 1024/ 1024/ 1024 = 133,2 MB*Verwenden Sie nicht das Lastprofil, um die Instance-Größe zu schätzen. Es ist nicht so präzise wie Statistiken oder I/O Profile zur Instanzaktivität. | DBA | | Option 2: Verwenden Sie Statistiken zur Instanzaktivität. | Wenn Sie eine Oracle-Datenbankversion vor 12c verwenden, können Sie den Abschnitt Instance Activity Stats des AWR-Berichts verwenden, um IOPS und Durchsatz zu schätzen. Die folgende Tabelle zeigt ein Beispiel für diesen Abschnitt.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Basierend auf diesen Informationen können Sie die Gesamt-IOPS und den Durchsatz wie folgt berechnen:*Gesamt-IOPS = 3.610,28 \$1 757,11 = 4367**Mbit/s insgesamt = 114.482.426,26 \$1 36.165.631,84 = 150648058,1/1024/ 1024 = 143 Mbit/s* | DBA | | Option 3: Verwenden Sie I/O Profile. | In Oracle Database 12c enthält der AWR-Bericht einen Abschnitt mit I/O Profilen, in dem alle Informationen in einer einzigen Tabelle dargestellt werden und genauere Daten zur Datenbankleistung bereitgestellt werden. Die folgende Tabelle zeigt ein Beispiel für diesen Abschnitt.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Diese Tabelle enthält die folgenden Werte für den Durchsatz und die Gesamt-IOPS:*Durchsatz = 143 MBPS (aus der fünften Zeile mit der Bezeichnung Gesamt, zweite Spalte)**IOPS = 4.367,4 (aus der ersten Zeile mit der Bezeichnung Gesamtzahl der Anfragen, zweite Spalte)* | DBA | | Option 4: Verwenden Sie AWR-Ansichten. | Mithilfe von AWR-Ansichten können Sie dieselben IOPS- und Durchsatzinformationen anzeigen. Verwenden Sie die folgende Abfrage, um diese Informationen abzurufen:
to_char(end_interval_time,'dd/MON/yy hh24:mi') End_Interval
FROM dba_hist_snapshot
ORDER BY 1;
break on report| DBA | | | Pro Sekunde | Pro Transaktion | Pro Führungskraft | Pro Anruf | | --- |--- |--- |--- |--- | | **DB-Zeit (en):** | 26,6 | 0.2 | 0,00 | 0,02 | | **DB-CPU (n):** | 18,0 | 0.1 | 0,00 | 0.01 | | **CPU (s) im Hintergrund:** | 0.2 | 0.0 | 0,00 | 0,00 | | **Redo-Größe (Byte):** | 2.458.539,9 | 17.097,5 | | | | **Logisches Lesen (Blöcke):** | 3.371.931,5 | 23.449,6 | | | | **Änderungen blockieren:** | 21.643,5 | 150,5 | | | | **Physikalisches Lesen (Blöcke):** | 13.575,1 | 94,4 | | | | **Physisches Schreiben (Blöcke):** | 3.467,3 | 24,1 | | | | **IO-Anfragen lesen:** | 3.586,8 | 24,9 | | | | **Schreiben Sie IO-Anfragen:** | 574.7 | 4,0 | | | | **I/O lesen (MB):** | 106,1 | 0.7 | | | | **Schreiben Sie IO (MB):** | 27,1 | 0.2 | | | | **IM-Scan-Zeilen:** | 0.0 | 0.0 | | | | **Sitzung, logisches Lesen, IM:** | | | | | | **Benutzer ruft an:** | 1.245,7 | 8,7 | | | | **Analysiert (SQL):** | 4.626,2 | 32,2 | | | | **Harte Analysen (SQL):** | 8.9 | 0.1 | | | | **SQL-Arbeitsbereich (MB):** | 824,9 | 5,7 | | | | **Anmeldungen:** | 1,7 | 0.0 | | | | **Führt aus (SQL):** | 136.656,5 | 950,4 | | | | **Rollbacks:** | 22,9 | 0.2 | | | | **Transaktionen:** | 143.8 | | | | | Statistik | Gesamt | pro Sekunde | pro Trans | | --- |--- |--- |--- | | **Gesamtzahl der physischen Lesevorgänge der I/O-Anfragen** | 2.547.333.217 | 3.610,28 | 25,11 | | **Gesamtzahl der physisch gelesenen Bytes** | 80.776.296.124.928 | 114.482.426,26 | 796.149,98 | | **Gesamtzahl der I/O-Anfragen beim physischen Schreiben** | 534.198.208 | 757,11 | 5,27 | | **Gesamtzahl der physischen Schreibvorgänge** | 25.517.678.849.024 | 36.165.631,84 | 251.508,18 | | | Lesen\$1Schreiben pro Sekunde | Lesen pro Sekunde | Schreiben Sie pro Sekunde | | --- |--- |--- |--- | | **Anfragen insgesamt:** | 4.367,4 | 3.610,3 | 757,1 | | **Datenbankanfragen:** | 4.161,5 | 3.586,8 | 574,7 | | **Optimierte Anfragen:** | 0.0 | 0.0 | 0.0 | | **Anfragen wiederholen:** | 179,3 | 2,8 | 176,6 | | **Insgesamt (MB):** | 143,7 | 109,2 | 34,5 | | **Datenbank (MB):** | 133,1 | 106,1 | 27,1 | | **Optimierte Summe (MB):** | 0.0 | 0.0 | 0.0 | | **Wiederholen (MB):** | 7.6 | 2.7 | 4,9 bis 4,9 | | **Datenbank (Blöcke):** | 17.042,4 | 13.575,1 | 3.467,3 | | **Über Buffer Cache (Blöcke):** | 5.898,5 | 5.360,9 | 537,6 | | **Direkt (Blöcke):** | 11.143,9 | 8.214,2 | 2.929,7 | ### Schätzen Sie die CPU-Anforderungen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Wählen Sie eine Methode aus. | Sie können den CPU-Bedarf für die Zieldatenbank auf drei Arten abschätzen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Wenn Sie die ausgelasteten Kerne betrachten, empfehlen wir Ihnen, die Methode der Datenbankmetriken anstelle von Betriebssystemstatistiken zu verwenden, da sie auf der CPU basiert, die nur von den Datenbanken genutzt wird, die Sie migrieren möchten. (Betriebssystemstatistiken beinhalten auch die CPU-Auslastung durch andere Prozesse.) Sie sollten auch die CPU-bezogenen Empfehlungen im ADDM-Bericht überprüfen, um die Leistung nach der Migration zu verbessern.Sie können die Anforderungen auch anhand der CPU-Generierung abschätzen. Wenn Sie verschiedene CPU-Generationen verwenden, können Sie den CPU-Bedarf der Zieldatenbank schätzen, indem Sie den Anweisungen im Whitepaper [Demystifying the Number of v CPUs for](https://d1.awsstatic.com/whitepapers/Demystifying_vCPUs.df200b766578b75009ad8d15c72e493d6408c68a.pdf) Optimal Workload Performance folgen. | DBA | | Option 1: Schätzung der Anforderungen auf der Grundlage der verfügbaren Kerne. | In AWR-Berichten:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Sie können die verfügbaren Kerne auf zwei Arten schätzen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)**Um die verfügbaren Kerne mithilfe von Betriebssystembefehlen zu schätzen**Verwenden Sie den folgenden Befehl, um die Kerne im Prozessor zu zählen.
compute sum of Value on report
select METRIC_NAME,avg(AVERAGE) as "Value"
from dba_hist_sysmetric_summary
where METRIC_NAME in ('Physical Read Total IO Requests Per Sec','Physical Write Total IO Requests Per Sec')
group by metric_name;
$ cat /proc/cpuinfo |grep "cpu cores"|uniqVerwenden Sie den folgenden Befehl, um die Sockets im Prozessor zu zählen.
cpu cores : 4
cat /proc/cpuinfo | egrep "core id|physical id" | tr -d "\n" | sed s/physical/\\nphysical/g | grep -v ^$ | sort | uniq | wc -l
grep "physical id" /proc/cpuinfo | sort -uEs wird nicht empfohlen, Betriebssystembefehle wie **nmon** und **sar** zu verwenden, um die CPU-Auslastung zu ermitteln. Das liegt daran, dass diese Berechnungen die CPU-Auslastung durch andere Prozesse beinhalten und möglicherweise nicht die tatsächliche CPU-Auslastung der Datenbank widerspiegeln.**Um die verfügbaren Kerne mithilfe des AWR-Berichts zu schätzen**Sie können die CPU-Auslastung auch aus dem ersten Abschnitt des AWR-Berichts ableiten. Hier ist ein Auszug aus dem Bericht.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)In diesem Beispiel ist die CPUs Anzahl 80, was darauf hinweist, dass diese logisch (virtuell) sind. CPUs Sie können auch sehen, dass diese Konfiguration über zwei Sockets, einen physischen Prozessor auf jedem Socket (also insgesamt zwei physische Prozessoren) und 40 Kerne für jeden physischen Prozessor oder Socket verfügt. | DBA | | Option 2: Schätzen Sie die CPU-Auslastung mithilfe von Betriebssystemstatistiken. | Sie können die Statistiken zur CPU-Auslastung des Betriebssystems entweder direkt im Betriebssystem überprüfen (mit **sar** oder einem anderen Host-Betriebssystemprogramm) oder indem Sie die IDLE/ (IDLE\$1BUSY) -Werte aus dem Abschnitt Betriebssystemstatistiken des AWR-Berichts überprüfen. **Sie können die CPU-Auslastung in Sekunden direkt in v\$1osstat sehen.** In den AWR- und Statspack-Berichten werden diese Daten auch im Abschnitt Betriebssystemstatistiken angezeigt.Wenn sich mehrere Datenbanken auf derselben Box befinden, haben sie alle dieselben **v\$1osstat-Werte** für BUSY\$1TIME.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Wenn es im System keine anderen großen CPU-Verbraucher gibt, verwenden Sie die folgende Formel, um den Prozentsatz der CPU-Auslastung zu berechnen:*Auslastung = Betriebszeit/Gesamtzeit**Betriebszeit = Anforderungen = v\$1osstat.BUSY\$1TIME**C = Gesamtzeit (Beschäftigt \$1 Inaktiv)**C = Kapazität = v\$1ostat.BUSY\$1TIME \$1 V\$1OSTAT.IDLE\$1TIME**Auslastung = BUSY\$1TIME/(BUSY\$1TIME \$1 IDLE\$1TIME)**= -1.305.569.937/(1.305.569.937 \$1 4.312.718,839)**= 23% genutzt* | DBA | | Option 3: Schätzen Sie die CPU-Auslastung mithilfe von Datenbankmetriken. | Wenn mehrere Datenbanken im System laufen, können Sie die Datenbankmetriken verwenden, die zu Beginn des Berichts angezeigt werden.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.html)Verwenden Sie diese Formel, um Metriken zur CPU-Auslastung zu erhalten:*CPU-Auslastung der Datenbank (% der verfügbaren CPU-Leistung) = CPU-Zeit/NUM\$1CPUS/verstrichene Zeit*wobei die CPU-Auslastung durch die *CPU-Zeit beschrieben wird und die für die CPU* aufgewendete Zeit darstellt, nicht die Wartezeit auf die CPU. Diese Berechnung ergibt:*= 312.625,40/11.759,64/80 = 33% der CPU werden genutzt**Anzahl der Kerne (33%) \$1 80 = 26,4 Kerne**Gesamtzahl der Kerne = 26,4 \$1 (120%) = 31,68 Kerne*Sie können den größeren dieser beiden Werte verwenden, um die CPU-Auslastung der Amazon RDS- oder Aurora-DB-Instance zu berechnen.Auf IBM AIX stimmt die berechnete Auslastung nicht mit den Werten aus dem Betriebssystem oder der Datenbank überein. Diese Werte stimmen auf anderen Betriebssystemen überein. | DBA | | DB-Name | DB-ID | Instance | Instanznummer | Startzeit | Veröffentlichung | RAC | | --- |--- |--- |--- |--- |--- |--- | | XXXX |
physical id : 0
physical id : 1
call mysql.rds_set_configuration('binlog retention hours', XX)Bestätigen Sie die Einstellung, indem Sie den folgenden Befehl ausführen.call mysql.rds_show_configuration;MySQL-kompatible Datenbanken, die von AWS verwaltet werden, löschen die Binärprotokolle so schnell wie möglich. Daher muss der Aufbewahrungszeitraum lang genug sein, um sicherzustellen, dass die Protokolle nicht gelöscht werden, bevor die AWS DMS-Aufgabe ausgeführt wird. Ein Wert von 24 Stunden ist normalerweise ausreichend, der Wert sollte jedoch auf der Zeit basieren, die für die Einrichtung der AWS DMS-Aufgabe in der DR-Region erforderlich ist. | DBA | ### Aktualisieren Sie die bestehende AWS DMS-Aufgabe in der primären Region | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Notieren Sie den ARN der AWS-DMS-Aufgabe. | Verwenden Sie den Amazon Resource Name (ARN), um den AWS DMS-Aufgabennamen für die spätere Verwendung abzurufen. Um den ARN der AWS-DMS-Aufgabe abzurufen, zeigen Sie die Aufgabe in der Konsole an oder führen Sie den folgenden Befehl aus.
aws dms describe-replication-tasksEin ARN sieht wie folgt aus.
arn:aws:dms:us-east-1:Die Zeichen nach dem letzten Doppelpunkt entsprechen dem Aufgabennamen, der in einem späteren Schritt verwendet wird. | AWS-Administrator | | Ändern Sie die bestehende AWS DMS-Aufgabe, um den Checkpoint aufzuzeichnen. | AWS DMS erstellt Prüfpunkte, die Informationen enthalten, sodass die Replikationsengine den Wiederherstellungspunkt für den Change-Stream kennt. Um Checkpoint-Informationen aufzuzeichnen, führen Sie die folgenden Schritte in der Konsole aus:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html) | AWS-Administrator | | Überprüfen Sie die Checkpoint-Informationen. | Verwenden Sie einen MySQL-Client, der mit dem Writer-Endpunkt für den Cluster verbunden ist, und fragen Sie die neue Metadatentabelle im Reporter-Datenbank-Cluster ab, um zu überprüfen, ob sie existiert und die Informationen zum Replikationsstatus enthält. Führen Sie den folgenden Befehl aus.:task:AN6HFFMPM246XOZVEUHCNSOVF7MQCLTOZUIRAMY
select * from awsdms_control.awsdms_txn_state;Der Aufgabenname aus dem ARN sollte in dieser Tabelle in der `Task_Name` Spalte zu finden sein. | DBA | ### Erweitern Sie beide Amazon Aurora Aurora-Cluster auf eine DR-Region | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Schaffen Sie eine Basisinfrastruktur in der DR-Region. | Erstellen Sie die Basiskomponenten, die für die Erstellung von und den Zugriff auf die Amazon Aurora Aurora-Cluster erforderlich sind:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html)Stellen Sie sicher, dass die Konfiguration beider Parametergruppen mit der Konfiguration in der primären Region übereinstimmt. | AWS-Administrator | | Fügen Sie die DR-Region zu beiden Amazon Aurora Aurora-Clustern hinzu. | Fügen Sie eine sekundäre Region (die DR-Region) zu den Haupt- und Reporter-Clustern von Amazon Aurora hinzu. Weitere Informationen finden Sie unter [Hinzufügen einer AWS-Region zu einer globalen Amazon Aurora Aurora-Datenbank](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-getting-started.html#aurora-global-database-attaching). | AWS-Administrator | ### Failover durchführen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Beenden Sie die AWS DMS-Aufgabe. | Die AWS-DMS-Aufgabe in der primären Region funktioniert nach einem Failover nicht ordnungsgemäß und sollte gestoppt werden, um Fehler zu vermeiden. | AWS-Administrator | | Führen Sie ein verwaltetes Failover durch. | Führen Sie einen verwalteten Failover des Hauptdatenbankclusters zur DR-Region durch. Anweisungen finden Sie unter [Durchführen von verwalteten geplanten Failovers für globale Amazon Aurora Aurora-Datenbanken](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-disaster-recovery.html#aurora-global-database-disaster-recovery.managed-failover). Nachdem das Failover auf dem Haupt-Datenbank-Cluster abgeschlossen ist, führen Sie dieselbe Aktivität auf dem Reporter-Datenbank-Cluster durch. | AWS-Administrator, DBA | | Daten in die Hauptdatenbank laden. | Fügen Sie Testdaten in den Writer-Knoten der Hauptdatenbank im DR-Datenbankcluster ein. Diese Daten werden verwendet, um zu überprüfen, ob die Replikation ordnungsgemäß funktioniert. | DBA | | Erstellen Sie die AWS DMS-Replikationsinstanz. | Informationen zum Erstellen der AWS DMS-Replikationsinstanz in der DR-Region finden Sie unter [Erstellen einer Replikationsinstanz](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.Creating.html). | AWS-Administrator, DBA | | Erstellen Sie die AWS DMS-Quell- und Zielendpunkte. | Informationen zum Erstellen der AWS DMS-Quell- und Zielendpunkte in der DR-Region finden Sie unter [Quell- und Zielendpunkte erstellen](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Endpoints.Creating.html). Die Quelle sollte auf die Writer-Instance des Haupt-Datenbank-Clusters verweisen. Das Ziel sollte auf die Writer-Instanz des Reporter-Datenbank-Clusters verweisen. | AWS-Administrator, DBA | | Besorgen Sie sich den Replikationsprüfpunkt. | Um den Replikationsprüfpunkt zu erhalten, verwenden Sie einen MySQL-Client, um die Metadatentabelle abzufragen, indem Sie Folgendes für den Writer-Knoten im Reporter-Datenbank-Cluster in der DR-Region ausführen.
select * from awsdms_control.awsdms_txn_state;Suchen Sie in der Tabelle nach dem Wert task\$1name, der dem ARN der AWS-DMS-Aufgabe entspricht, der in der primären Region existiert und den Sie im zweiten Epic abgerufen haben. | DBA | | Erstellen Sie eine AWS DMS-Aufgabe. | Erstellen Sie mit der Konsole eine AWS DMS-Aufgabe in der DR-Region. Geben Sie in der Aufgabe die Migrationsmethode Nur **Datenänderungen replizieren** an. Weitere Informationen finden Sie unter [Aufgabe erstellen](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html)Stellen Sie die Einstellung AWS DMS-Aufgabe **Migrationsaufgabe starten** **auf Automatisch bei Erstellung ein**. | AWS-Administrator, DBA | | Notieren Sie den ARN der AWS-DMS-Aufgabe. | Verwenden Sie den ARN, um den AWS DMS-Aufgabennamen für die spätere Verwendung abzurufen. Führen Sie den folgenden Befehl aus, um den ARN für die AWS-DMS-Aufgabe abzurufen.
aws dms describe-replication-tasks| AWS-Administrator, DBA | | Validieren Sie die replizierten Daten. | Fragen Sie den Reporter-Datenbankcluster in der DR-Region ab, um zu bestätigen, dass die Testdaten, die Sie in den Haupt-Datenbank-Cluster geladen haben, repliziert wurden. | DBA | ### Führen Sie ein Failback durch | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Beenden Sie die AWS DMS-Aufgabe. | Die AWS-DMS-Aufgabe in der DR-Region funktioniert nach einem Failback nicht ordnungsgemäß und sollte gestoppt werden, um Fehler zu vermeiden. | AWS-Administrator | | Führen Sie ein verwaltetes Failback durch. | Führen Sie ein Failback des Haupt-Datenbank-Clusters auf die primäre Region durch. Anweisungen finden Sie unter [Durchführen von verwalteten geplanten Failovers für globale Amazon Aurora Aurora-Datenbanken](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database-disaster-recovery.html#aurora-global-database-disaster-recovery.managed-failover). Nachdem das Failback auf dem Haupt-Datenbank-Cluster abgeschlossen ist, führen Sie dieselbe Aktivität auf dem Reporter-Datenbank-Cluster durch. | AWS-Administrator, DBA | | Besorgen Sie sich den Replikationsprüfpunkt. | Um den Replikationsprüfpunkt zu erhalten, verwenden Sie einen MySQL-Client, um die Metadatentabelle abzufragen, indem Sie Folgendes für den Writer-Knoten im Reporter-Datenbank-Cluster in der DR-Region ausführen.
select * from awsdms_control.awsdms_txn_state;Suchen Sie in der Tabelle nach dem `task_name` Wert, der dem ARN der AWS-DMS-Aufgabe entspricht, der in der DR-Region existiert und den Sie im vierten Epic erhalten haben. | DBA | | Aktualisieren Sie die AWS DMS-Quell- und Zielendpunkte. | Nachdem die Datenbankcluster ausgefallen sind, überprüfen Sie die Cluster in der primären Region, um festzustellen, welche Knoten die Writer-Instances sind. Stellen Sie anschließend sicher, dass die vorhandenen AWS-DMS-Quell- und Zielendpunkte in der primären Region auf die Writer-Instances verweisen. Falls nicht, aktualisieren Sie die Endpunkte mit den DNS-Namen (Domain Name System) der Writer-Instance. | AWS-Administrator | | Erstellen Sie eine AWS DMS-Aufgabe. | Erstellen Sie mit der Konsole eine AWS DMS-Aufgabe in der primären Region. Geben Sie in der Aufgabe die Migrationsmethode Nur **Datenänderungen replizieren** an. Weitere Informationen finden Sie unter [Aufgabe erstellen](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.html) | AWS-Administrator, DBA | | Notieren Sie die AWS-DMS-Aufgabe Amazon Resource Name (ARN). | Verwenden Sie den ARN, um den AWS DMS-Aufgabennamen für die spätere Verwendung abzurufen. Führen Sie den folgenden Befehl aus, um den ARN für die AWS-DMS-Aufgabe abzurufen:
aws dms describe-replication-tasksDer Aufgabenname wird bei der Durchführung eines weiteren verwalteten Failovers oder während eines DR-Szenarios benötigt. | AWS-Administrator, DBA | | Löschen Sie AWS DMS-Aufgaben. | Löschen Sie die ursprüngliche (derzeit angehaltene) AWS DMS-Aufgabe in der primären Region und die bestehende AWS DMS-Aufgabe (derzeit gestoppt) in der sekundären Region. | AWS-Administrator | ## Zugehörige Ressourcen + [Konfiguration Ihres Amazon Aurora Aurora-DB-Clusters](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraSettingUp.html) + [Verwenden von Amazon Aurora Global Databases](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-global-database.html) + [Arbeiten mit Amazon Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraMySQL.html) + [Arbeiten mit einer AWS DMS-Replikationsinstanz](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html) + [Arbeiten mit AWS DMS-Endpunkten](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Endpoints.html) + [Arbeiten mit AWS DMS-Aufgaben](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.html) + [Was ist AWS CloudFormation?](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) ## Zusätzliche Informationen Die globalen Datenbanken von Amazon Aurora werden in diesem Beispiel für DR verwendet, da sie ein effektives Recovery Time Objective (RTO) von 1 Sekunde und ein Recovery Point Objective (RPO) von weniger als 1 Minute bieten. Beides ist niedriger als bei herkömmlichen replizierten Lösungen und ideal für DR-Szenarien. Die globalen Datenbanken von Amazon Aurora bieten viele weitere Vorteile, darunter die folgenden: + Globale Lesevorgänge mit lokaler Latenz — Verbraucher auf der ganzen Welt können mit lokaler Latenz auf Informationen in einer lokalen Region zugreifen. + Skalierbare sekundäre Amazon Aurora Aurora-DB-Cluster — Sekundäre Cluster können unabhängig voneinander skaliert werden, sodass bis zu 16 schreibgeschützte Replikate hinzugefügt werden können. + Schnelle Replikation vom primären zum sekundären Amazon Aurora Aurora-DB-Cluster — Die Replikation hat nur geringe Auswirkungen auf die Leistung des primären Clusters. Sie erfolgt auf der Speicherebene mit typischen regionsübergreifenden Replikationslatenzen von weniger als 1 Sekunde. Dieses Muster verwendet auch AWS DMS für die Replikation. Amazon Aurora Aurora-Datenbanken bieten die Möglichkeit, Read Replicas zu erstellen, was den Replikationsprozess und die DR-Einrichtung vereinfachen kann. AWS DMS wird jedoch häufig zur Replikation verwendet, wenn Datentransformationen erforderlich sind oder wenn die Zieldatenbank zusätzliche Indizes benötigt, über die die Quelldatenbank nicht verfügt. # Migrieren Sie Oracle-Funktionen und -Prozeduren mit mehr als 100 Argumenten nach PostgreSQL *Srinivas Potlachervoo, Amazon Web Services* ## Zusammenfassung Dieses Muster zeigt, wie Oracle-Datenbankfunktionen und -prozeduren mit mehr als 100 Argumenten nach PostgreSQL migriert werden. Sie können dieses Muster beispielsweise verwenden, um Oracle-Funktionen und -Prozeduren auf einen der folgenden PostgreSQL-kompatiblen AWS-Datenbankservices zu migrieren: + Amazon Relational Database Service (Amazon RDS) für PostgreSQL + Amazon Aurora PostgreSQL-Compatible Edition PostgreSQL unterstützt keine Funktionen oder Prozeduren mit mehr als 100 Argumenten. Um das Problem zu umgehen, können Sie einen neuen Datentyp definieren, der Typfelder enthält, die den Argumenten der Quellfunktion entsprechen. Anschließend können Sie eine PL/pgSQL Funktion erstellen und ausführen, die den benutzerdefinierten Datentyp als Argument verwendet. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto + Eine [Amazon RDS-Oracle-Datenbank-Instance (DB)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) + Eine [Amazon RDS for PostgreSQL PostgreSQL-DB-Instance](https://aws.amazon.com/getting-started/hands-on/create-connect-postgresql-db/) oder eine [Aurora PostgreSQL-kompatible](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html) DB-Instance **Produktversionen** + Amazon RDS Oracle DB-Instance-Versionen 10.2 und höher + Amazon RDS PostgreSQL-DB-Instance-Versionen 9.4 und höher oder Aurora PostgreSQL-kompatible DB-Instance-Versionen 9.4 und höher + Oracle SQL Developer Version 18 und höher + pgAdmin Version 4 und höher ## Architektur **Quelltechnologie-Stack** + Amazon RDS Oracle DB-Instance-Versionen 10.2 und höher **Zieltechnologie-Stack** + Amazon RDS PostgreSQL-DB-Instance-Versionen 9.4 und höher oder Aurora PostgreSQL-kompatible DB-Instance-Versionen 9.4 und höher ## Tools **AWS-Services** + [Amazon Relational Database Service (Amazon RDS) für PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen PostgreSQL-Datenbank in der AWS-Cloud. + [Amazon Aurora PostgreSQL-Compatible Edition](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) ist eine vollständig verwaltete, ACID-konforme relationale Datenbank-Engine, die Sie bei der Einrichtung, dem Betrieb und der Skalierung von PostgreSQL-Bereitstellungen unterstützt. **Andere Dienste** + [Oracle SQL Developer](https://www.oracle.com/database/technologies/appdev/sqldeveloper-landing.html) ist eine integrierte Entwicklungsumgebung, die die Entwicklung und Verwaltung von Oracle-Datenbanken sowohl in herkömmlichen als auch in Cloud-basierten Bereitstellungen vereinfacht. + [pgAdmin](https://www.pgadmin.org/) ist ein Open-Source-Verwaltungstool für PostgreSQL. Es bietet eine grafische Oberfläche, mit der Sie Datenbankobjekte erstellen, verwalten und verwenden können. ## Best Practices Stellen Sie sicher, dass der Datentyp, den Sie erstellen, mit den Typfeldern übereinstimmt, die in der Oracle-Quellfunktion oder -prozedur enthalten sind. ## Epen ### Führen Sie eine Oracle-Funktion oder -Prozedur mit mehr als 100 Argumenten aus | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen oder identifizieren Sie eine bestehende Oracle/PLSQL Funktion oder Prozedur mit mehr als 100 Argumenten. | Erstellen Sie eine Oracle/PLSQL Funktion oder Prozedur mit mehr als 100 Argumenten.–oder–Identifizieren Sie eine vorhandene Oracle/PLSQL Funktion oder Prozedur mit mehr als 100 Argumenten.Weitere Informationen finden Sie in den Abschnitten [14.7 CREATE FUNCTION-Anweisung](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/lnpls/CREATE-FUNCTION-statement.html#GUID-B71BC5BD-B87C-4054-AAA5-213E856651F2) und [14.11 CREATE PROCEDURE-Anweisung](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/lnpls/CREATE-PROCEDURE-statement.html#GUID-5F84DB47-B5BE-4292-848F-756BF365EC54) in der Oracle-Datenbankdokumentation. | Oracle/PLSQL-Kenntnisse | | Kompilieren Sie die Funktion oder Prozedur Oracle/PLSQL . | Kompilieren Sie die Oracle/PLSQL Funktion oder Prozedur.Weitere Informationen finden Sie unter [Funktion kompilieren](https://docs.oracle.com/cd/E37097_01/doc.42/e35128/GUID-6B7B6F82-616D-4915-82BE-D4AE7F59CF37.htm#AEUTL165) in der Oracle Database-Dokumentation. | Oracle/PLSQL-Kenntnisse | | Führen Sie die Funktion aus. Oracle/PLSQL | Führen Sie die Oracle/PLSQL Funktion oder Prozedur aus. Speichern Sie dann die Ausgabe. | Oracle/PLSQL-Kenntnisse | ### Definieren Sie einen neuen Datentyp, der den Argumenten der Quellfunktion oder -prozedur entspricht | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Definieren Sie einen neuen Datentyp in PostgreSQL. | Definieren Sie einen neuen Datentyp in PostgreSQL, der dieselben Felder enthält, die in den Argumenten der Oracle-Quellfunktion oder -prozedur vorkommen.Weitere Informationen finden Sie unter [CREATE TYPE](https://www.postgresql.org/docs/current/sql-createtype.html) in der PostgreSQL-Dokumentation. | PostgreSQL-Kenntnisse PL/pgSQL | ### Erstellen Sie eine PostgreSQL-Funktion, die das neue TYPE-Argument enthält | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine PostgreSQL-Funktion, die den neuen Datentyp enthält. | Erstellen Sie eine PostgreSQL-Funktion, die das neue `TYPE` Argument enthält.Eine Beispielfunktion finden Sie im Abschnitt **Zusätzliche Informationen** dieses Musters. | PostgreSQL-Kenntnisse PL/pgSQL | | Kompilieren Sie die PostgreSQL-Funktion. | Kompilieren Sie die Funktion in PostgreSQL. Wenn die neuen Datentypfelder mit den Argumenten der Quellfunktion oder -prozedur übereinstimmen, wird die Funktion erfolgreich kompiliert. | PostgreSQL-Kenntnisse PL/pgSQL | | Führen Sie die PostgreSQL-Funktion aus. | Führen Sie die PostgreSQL-Funktion aus. | PostgreSQL-Kenntnisse PL/pgSQL | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | Die Funktion gibt den folgenden Fehler zurück:**FEHLER: Syntaxfehler in der Nähe von ""**
hdbnsutil -sr_enable --name=siteA| SAP-Basisverwaltung | | Registrieren Sie die Ziel-SAP HANA DB als Sekundärsystem. | Um die Ziel-SAP-HANA-DB als sekundäres Quellsystem für SAP HSR zu registrieren, wählen Sie **asynchrone Replikation**.
(sid)adm $> HDB stopAlternativ können Sie die `–online` Option zur Registrierung wählen. In diesem Fall müssen Sie die SAP HANA DB nicht stoppen und starten. | SAP-Basisverwaltung | | Synchronisation validieren. | Stellen Sie in der SAP HANA-Quelldatenbank sicher, dass alle Protokolle auf das Zielsystem angewendet werden (da es sich um eine asynchrone Replikation handelt).Um die Replikation zu überprüfen, führen Sie auf der Quelle die folgenden Befehle aus.
(sid)adm $> hdbnsutil -sr_register –name=siteB –remotehost=hdbhost /
--remoteInstance=00 –replicationMode=async –operationMode=logreplay
(sid)adm $> HDB start
(sid)adm $> cdpy| SAP-Basisverwaltung | | Fahren Sie die SAP-Quellanwendung und die SAP HANA DB herunter. | Führen Sie während der Umstellung auf die Migration das Quellsystem (die SAP-Anwendung und die SAP HANA-Datenbank) herunter. | SAP-Basisverwaltung | | Führen Sie eine Übernahme am Zielort durch. | Führen Sie den Befehl aus, um eine Übernahme am Ziel auf AWS durchzuführen`hdbnsutil -sr_takeover`. | SAP-Basisverwaltung | | Schalten Sie auf der Ziel-SAP HANA-Datenbank die Replikation aus. | Um die Replikationsmetadaten zu löschen, beenden Sie die Replikation auf dem Zielsystem, indem Sie den Befehl ausführen`hdbnsutil -sr_disable`. Dies entspricht dem SAP-Hinweis 2693441 — Ein SAP HANA-System konnte aufgrund eines Fehlers nicht umbenannt werden. | SAP-Basisverwaltung | | Sichern Sie die Ziel-SAP HANA-Datenbank. | Nach erfolgreicher Übernahme empfehlen wir, ein vollständiges SAP HANA DB-Backup durchzuführen. | SAP-Basisverwaltung | ### Kehren Sie zum ursprünglichen Hostnamen im Zielsystem zurück | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Setzen Sie den Hostnamen der SAP HANA DB-Zieldatenbank auf den ursprünglichen Hostnamen zurück. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-sap-hana-to-aws-using-sap-hsr-with-the-same-hostname.html)Sie können andere Optionen nach Bedarf validieren. Achten Sie jedoch darauf, dass Sie die Host-Umbenennung nicht mit einer SID-Änderung verwechseln (SAP-Hinweis 2598814 — hdblcm: SID-Umbenennung schlägt fehl). | SAP-Basisverwaltung | | Passen Sie hdbuserstore an. | Passen Sie die `hdbuserstore` Details an, die auf die Quelldetails verweisen. `schema/user` Die detaillierten Schritte finden Sie in der [SAP-Dokumentation](https://help.sap.com/viewer/b3ee5778bc2e4a089d3299b82ec762a7/2.0.02/en-US/ddbdd66b632d4fe7b3c2e0e6e341e222.html?q=hdbuserstore). Führen Sie den Befehl aus, um diesen Schritt zu validieren`R3trans -d`. Das Ergebnis sollte eine erfolgreiche Verbindung zur SAP HANA-Datenbank widerspiegeln. | SAP-Basisverwaltung | | Starten Sie die Client-Verbindungen. | Starten Sie in der Zielumgebung die SAP-Anwendungsserver und andere Client-Verbindungen. | SAP-Basisverwaltung | ## Zugehörige Ressourcen **SAP-Referenzen** Referenzen zur SAP-Dokumentation werden häufig von SAP aktualisiert. Um auf dem Laufenden zu bleiben, lesen Sie den SAP-Hinweis 2407186 — Anleitungen und Whitepapers für SAP HANA High Availability. *Zusätzliche SAP-Hinweise* + 2550327 — So benennen Sie ein SAP HANA-System um + 1999880 — Häufig gestellte Fragen: SAP HANA-Systemreplikation + 2078425 — Hinweis zur Fehlerbehebung für das Lifecycle-Management-Tool hdblcm für die SAP HANA-Plattform + 2592227 — Änderung des FQDN-Suffixes in HANA-Systemen + 2048681 — Durchführung von Verwaltungsaufgaben für das Lebenszyklusmanagement der SAP HANA-Plattform auf Systemen mit mehreren Hosts ohne SSH- oder Root-Anmeldeinformationen *SAP-Dokumente* + [Netzwerkverbindung zur Systemreplikation](https://help.sap.com/docs/SAP_HANA_PLATFORM/4e9b18c116aa42fc84c7dbfd02111aba/47190b425eb1433697b026ecd46ff5f9.html) + [Auflösung des Hostnamens für die Systemreplikation](https://help.sap.com/viewer/eb3777d5495d46c5b2fa773206bbfb46/1.0.12/en-US/c0cba1cb2ba34ec89f45b48b2157ec7b.html) **AWS Verweise** + [Migration von SAP HANA von anderen Plattformen auf AWS](https://docs.aws.amazon.com/sap/latest/sap-hana/migrating-hana-hana-to-aws.html) ## Zusätzliche Informationen Die Änderungen, die im `hdblcm` Rahmen der Aktivität zur Umbenennung von Hostnamen vorgenommen wurden, werden im folgenden ausführlichen Protokoll zusammengefasst. ![\[Code, der zeigt, dass Prozesse auf temp-host gestoppt wurden, auf hdbhost gestartet wurden und das SAP HANA-DB-System umbenannt wurde.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/004781c1-96df-43dd-a52e-ed1db5bdf9ef/images/9e0c11ca-6555-484f-9639-107f60f725f5.png) # Migrieren Sie die Microsoft SQL Server Always On-Verfügbarkeitsgruppe mithilfe von AWS Application Migration Service *Sreenivas Nettem, Bharath Kumar Pammi Ramesh, Anantharaman Seshadri und Gireesh Sreekantan, Amazon Web Services* ## Zusammenfassung AWS Application Migration Service (AWS MGN) ist ein bevorzugtes Tool für das Rehosting vorhandener Umgebungen in der, sodass Kunden ihre Rechenzentren vor Ort verlassen können. AWS Cloud Dieses Muster beschreibt den Prozess der Verwendung von AWS MGN zur Migration von Windows-Clustern mit Microsoft SQL Server AlwaysOn-Verfügbarkeitsgruppen. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktiver AWS-Konto. + Eine AWS Identity and Access Management (IAM-) Rolle für die AWS MGN-Orchestrierung. + Zugriff auf Quelldatenbankserver (SQL Server Always On-Verfügbarkeitsgruppe). + Active Directory in einer AWS landing zone zur Beibehaltung von DNS-Namen. + Ein Staging-Subnetz mit geschlossener Netzwerkkommunikation mit Active Directory. + Zielsubnetze, die mit Active Directory kommunizieren können. + Zwei reservierte IP-Adressen für den Windows-Cluster in einem Zielsubnetz (eine in jeder Availability Zone). + Zwei reservierte IP-Adressen für den SQL Always On-Listener in einem Zielsubnetz (eine in jeder Availability Zone). **Produktversionen** + Windows Server 2012 oder höher + SQL Server 2012 oder höher ## Architektur **Quelltechnologie-Stack** Microsoft Windows-Cluster (lokale physische oder virtuelle Maschine) Microsoft SQL Server Always On-Verfügbarkeitsgruppe **Zieltechnologie-Stack** Amazon EC2 Windows-Instanz **Zielarchitektur** ![\[AWS-Architektur für die Migration der Verfügbarkeit von SQL Server Always On mithilfe von AWS MGN.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/aa94040b-5ecf-42f9-90e3-929d0fa5e715/images/0b85c613-51df-475b-9598-3da3f9cd47c6.png) ## Tools *AWS-Services* + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) bietet skalierbare Rechenkapazität in der AWS Cloud. Sie können so viele virtuelle Server wie nötig nutzen und sie schnell nach oben oder unten skalieren. + [AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html)hilft Ihnen beim Rehosten (Lift and Shift) von Anwendungen AWS Cloud ohne Änderungen und mit minimalen Ausfallzeiten. + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) hilft Ihnen dabei, den Zugriff auf Ihre AWS Ressourcen sicher zu verwalten, indem kontrolliert wird, wer authentifiziert und autorisiert ist, diese zu verwenden. *Andere Tools* + [Microsoft SQL Server Management Studio (SSMS)](https://learn.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms) ist ein Tool für die Verwaltung von SQL Server, einschließlich des Zugriffs auf, der Konfiguration und der Verwaltung von SQL Server-Komponenten. ## Best Practices Informationen zu AWS MGN finden Sie unter [Bewährte](https://docs.aws.amazon.com/mgn/latest/ug/best_practices_mgn.html) Methoden für. AWS Application Migration Service ## Epen ### Bereiten Sie das Zielkonto vor | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Initialisieren Sie AWS MGN. | Initialisieren Sie AWS MGN im Ziel. AWS-Region Dadurch werden die erforderlichen IAM-Rollen und -Richtlinien erstellt. Weitere Informationen finden Sie unter [Initialisieren des Application Migration Service mit der Konsole](https://docs.aws.amazon.com/mgn/latest/ug/mgn-initialize-console.html). | Cloud-Administrator | | Erstellen Sie Replikations- und Startvorlagen. | Konfigurieren Sie die Replikations- und Startvorlagen für die Verwendung mit AWS MGN. Weitere Informationen finden Sie in [der AWS Dokumentation unter Konfiguration der Vorlagen](https://docs.aws.amazon.com/mgn/latest/ug/mgn-initialization-templates.html). | Cloud-Administrator | | Kommunikationsanschlüsse zulassen. | Um die Netzwerkkommunikation für AWS MGN zu aktivieren, lassen Sie den Verkehr über die TCP-Ports 443 und 1500 zu. Weitere Informationen finden Sie in der AWS Dokumentation unter [Netzwerkanforderungen für den Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/Network-Requirements.html). | Cloud-Administrator, Netzwerkadministrator | ### Bereiten Sie den Quellserver vor | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Überprüfen Sie die AWS MGN-Voraussetzungen. | Stellen Sie sicher, dass die Quellserver die Voraussetzungen für die Installation des AWS MGN-Agenten erfüllen. Weitere Informationen finden Sie in der AWS Dokumentation unter [Installationsanforderungen](https://docs.aws.amazon.com/mgn/latest/ug/installation-requirements.html). | Ingenieur für Migration | | Installieren Sie den AWS MGN Agent. | Installieren Sie den AWS MGN-Agenten auf den Quellservern. Wählen Sie während der Installation aus, AWS-Region wohin die Server migriert werden sollen. Nach der Installation kommuniziert der Agent mit dem Dienst und startet die Replikation. Weitere Informationen finden Sie unter [Installation des AWS Replication Agents auf Windows-Servern](https://docs.aws.amazon.com/mgn/latest/ug/windows-agent.html). | Migrationsingenieur | | Überprüfen Sie den Status des Quellservers. | Überprüfen Sie in der AWS MGN-Konsole den Status der Quellserver. Wenn die Replikation beginnt, wird auf den Servern die Meldung **Bereit zum Testen** angezeigt.Wenn Sie auf Fehler stoßen, finden Sie in der AWS MGN-Dokumentation weitere Informationen unter [Problembehandlung bei Kommunikationsfehlern](https://docs.aws.amazon.com/mgn/latest/ug/Troubleshooting-Communication-Errors.html). | Cloud-Administrator, Migrationsingenieur | | Optimieren Sie die Replikationseinstellungen. | SQL Always On-Cluster verwenden eine I/O hochsynchrone Replikation vom Primärserver zum Sekundärserver. Um die Replikation zu optimieren und Verzögerungen zu vermeiden, verwenden Sie für jeden SQL Always [On-Server einen eigenen Replikationsserver](https://docs.aws.amazon.com/mgn/latest/ug/replication-settings-template.html).**Wenn die Datenbank größer als 5 TB ist, sollten Sie erwägen, eine größere Instanzgröße für den Replikationsserver wie **m5.large** anstelle der Standardgröße t3.small zu wählen.** | Cloud-Administrator, Migrationsingenieur | | Startvorlage aktualisieren. | Aktualisieren Sie die [Starteinstellungen](https://docs.aws.amazon.com/mgn/latest/ug/launch-settings.html) und wählen Sie Subnetze für die SQL Always On-Server aus. Die SQL Always On-Clusterserver sind aus Gründen der Hochverfügbarkeit auf verschiedene AWS Availability Zones Standorte verteilt. | Migrationsingenieur, Migrationsleiter | | Aktualisieren Sie die Starteinstellungen. | Aktualisieren Sie je nach Größe und Leistungsanforderungen den Instanztyp und die input/output Operationen pro Sekunde (IOPS) in den Starteinstellungen.(Optional) Wählen Sie in den Starteinstellungen eine vorhandene elastic network interface aus. | Migrationsingenieur, Migrationsleiter | ### Umstellung testen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Überprüfen Sie die Quellserver. | Stellen Sie in der AWS MGN-Konsole sicher, dass der Status des Quellservers **Bereit zum Testen** lautet. | Cloud-Administrator, Migrationsingenieur | | Starten Sie die Testinstanzen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | Cloud-Administrator, Migrationsingenieur | | Testen Sie die Konnektivität und Datenbankintegrität. | Testen Sie die Konnektivität und Datenbankintegrität der Testinstanzen. Markieren Sie dann die Quellserver in der ** AWS MGN-Konsole als Bereit für** die Übernahme. | Cloud-Administrator, Migrationsingenieur | ### Aufgaben vor der Migration | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Testen Sie die Datenbankintegrität. | Auf diese Weise wird sichergestellt, dass vor der Migration keine Probleme mit der Datenbankintegrität an der Quelle aufgetreten sind. Führen Sie aus `DBCC CHECKDB` und geben Sie an`WITH_PHYSICAL_ONLY`. Wenn Sie diese Prüfung ohne ausführen, `WITH_PHYSICAL_ONLY` kann dies zu Leistungseinbußen an der Quelle führen. Um die Datenbankintegrität aufrechtzuerhalten, führen Sie eine wöchentliche vollständige Überprüfung der Datenbank durch.Mit diesen Befehlen wird die logische und physische Integrität der Datenbank überprüft, indem potenzielle Korruptionsprobleme erkannt werden. Bei der Prüfung wird die Struktur der Datenbank überprüft, z. B. Seiten, Zeilen, Indizes und Systemtabellen. | Dateningenieur, DBA | | Testen Sie die Verbindungen zu Verbindungsservern. | Testen Sie die Verbindungen zwischen allen vorhandenen Servern und dokumentieren Sie deren Status. Auf diese Weise wird sichergestellt, dass die Verbindungsserver nach der Migration wie vorgesehen funktionieren. | Dateningenieur, DBA | | Überprüfen Sie die Backups. | Bestätigen Sie die Integrität der Quell-Backups. | Dateningenieur, DBA | ### AWS MGN-Umstellung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Beenden Sie den SQL Server und die Clusterdienste. | Beenden Sie die SQL Server- und Microsoft-Clusterdienste auf allen SQL-Clusterknoten. | DBA, Migrationsingenieur | | Überprüfen Sie die Server. | **Stellen Sie in der AWS MGN-Konsole sicher, dass der Status der Quellserver **Bereit für die Übernahme und der** Status der Datenreplikation Fehlerfrei lautet.** | Migrationsingenieur | | Starten Sie die Umstellung. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html)Weitere Informationen finden Sie in der AWS MGN-Dokumentation unter [Starten einer Übernahmeinstanz](https://docs.aws.amazon.com/mgn/latest/ug/launch-cutover-gs.html). | Ingenieur für Migration | | Testen Sie die gestarteten Server. | Melden Sie sich bei den gestarteten EC2 Amazon-Instances an und überprüfen Sie den Zustand des Clusters. Stellen Sie sicher, dass sich die Server in den richtigen Subnetzen befinden, dass die Instance-Größe und die IOPS-Einstellungen korrekt sind und dass auf den Zeugenserver zugegriffen werden kann. | DBA, Migrationsingenieur | ### Aufgaben nach der Umstellung auf Datenbanken | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Aktualisieren Sie die Cluster-IP-Adresse. | Aktualisieren Sie die Cluster-IP-Adresse für den Windows-Cluster mithilfe der beiden reservierten IP-Adressen in den Zielsubnetzen. Weitere Informationen finden Sie unter [Ändern der IP-Adresse einer Failoverclusterinstanz](https://learn.microsoft.com/en-us/sql/sql-server/failover-clusters/windows/change-the-ip-address-of-a-failover-cluster-instance?view=sql-server-2016). | DBA, Migrationsingenieur | | Aktualisieren Sie den Always-On-Verfügbarkeitsgruppenlistener IPs. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | DBA, Migrationsingenieur | | Überprüfen Sie die Verbindung. | Stellen Sie mithilfe von SSMS eine Verbindung zum Always-On-Verfügbarkeitsgruppenlistener her und vergewissern Sie sich, dass die Verbindung erfolgreich hergestellt wurde. | DBA, Migrationsingenieur | | Überprüfen Sie den Zustand der Always-On-Verfügbarkeitsgruppe. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-microsoft-sql-server-always-on-group-using-mgn.html) | DBA, Migrationsingenieur | | Überprüfen Sie das Fehlerprotokoll. | Öffnen Sie das Fehlerprotokoll und überprüfen Sie alle für die SQL Server-Instanz gemeldeten Fehler. Stellen Sie sicher, dass die Wiederherstellung für alle Datenbanken abgeschlossen ist. | DBA, Migrationsingenieur | | Testen Sie die verknüpften Server. | Testen Sie die Konnektivität aller Verbindungsserver. Stellen Sie bei Verbindungsproblemen sicher, dass der Zielserver und der Zielport zugänglich sind. | DBA, Migrationsingenieur | ### Schließen Sie die Umstellung ab | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Schließen Sie die Umstellung ab. | Nachdem Sie die SQL Always On-Zielcluster validiert haben, schließen Sie [die Übernahme über](https://docs.aws.amazon.com/mgn/latest/ug/launch-cutover-gs.html#revert-finalize-cutover-gs) die MGN-Konsole ab. AWS Dadurch wird die Datenreplikation von den Quellservern gestoppt und die Daten vom Replikationsserver verworfen. Außerdem werden der Replikationsserver und die zugehörigen Ressourcen entfernt. | Cloud-Administrator, Migrationsingenieur | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | AWS MGN-Fehlerbehebung | Allgemeine Probleme und Lösungen finden Sie in den Abschnitten [Fehlerbehebung](https://docs.aws.amazon.com/mgn/latest/ug/troubleshooting.html) und [häufig gestellte Fragen](https://docs.aws.amazon.com/mgn/latest/ug/FAQ.html) in der AWS MGN-Dokumentation. | ## Zugehörige Ressourcen *AWS Ressourcen* + [Option-1 Erneut hosten - () AWS Application Migration ServiceAWS](https://catalog.us-east-1.prod.workshops.aws/workshops/c6bdf8dc-d2b2-4dbd-b673-90836e954745/en-US/04-application-migration/01-mgn) + [Was ist? AWS Application Migration Service](https://docs.aws.amazon.com/mgn/latest/ug/what-is-application-migration-service.html) *SQL Server-Ressourcen* + [Was ist SQL Server Management Studio (SSMS)?](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-ssms) ## Zusätzliche Informationen Die Standardsicherheitsanforderungen für die Migration von Workloads auf die AWS Cloud finden Sie auf der Website unter [Best Practices for Security, Identity and Compliance](https://aws.amazon.com/architecture/security-identity-compliance/). AWS # Migrieren Sie SQL Server mithilfe verteilter Verfügbarkeitsgruppen zu AWS *Praveen Marthala, Amazon Web Services* ## Zusammenfassung Microsoft SQL Server Always On-Verfügbarkeitsgruppen bieten eine Hochverfügbarkeits- (HA) und Notfallwiederherstellungslösung (DR) für SQL Server. Eine Verfügbarkeitsgruppe besteht aus einem primären Replikat, das read/write Datenverkehr akzeptiert, und bis zu acht sekundären Replikaten, die Lesedatenverkehr akzeptieren. Eine Verfügbarkeitsgruppe wird auf einem Windows Server Failover Cluster (WSFC) mit zwei oder mehr Knoten konfiguriert. Verteilte Verfügbarkeitsgruppen von Microsoft SQL Server Always On bieten eine Lösung für die Konfiguration von zwei separaten Verfügbarkeitsgruppen zwischen zwei unabhängigen WFSCs. Die Verfügbarkeitsgruppen, die Teil der verteilten Verfügbarkeitsgruppe sind, müssen sich nicht im selben Rechenzentrum befinden. Eine Verfügbarkeitsgruppe kann sich vor Ort befinden, und die andere Verfügbarkeitsgruppe kann sich in der Amazon Web Services (AWS) Cloud auf Amazon Elastic Compute Cloud (Amazon EC2) -Instances in einer anderen Domain befinden. Dieses Muster beschreibt die Schritte zur Verwendung einer verteilten Verfügbarkeitsgruppe zur Migration von lokalen SQL Server-Datenbanken, die Teil einer vorhandenen Verfügbarkeitsgruppe sind, zu SQL Server mit Verfügbarkeitsgruppen, die auf Amazon EC2 eingerichtet sind. Wenn Sie diesem Muster folgen, können Sie die Datenbanken mit minimalen Ausfallzeiten während der Umstellung in die AWS-Cloud migrieren. Die Datenbanken sind unmittelbar nach der Umstellung auf AWS hochverfügbar. Sie können dieses Muster auch verwenden, um das zugrunde liegende Betriebssystem von lokal auf AWS umzustellen und dabei dieselbe Version von SQL Server beizubehalten. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto + AWS Direct Connect oder AWS Site-to-Site VPN + Dieselbe Version von SQL Server ist lokal und auf den beiden Knoten auf AWS installiert **Produktversionen** + SQL Server Version 2016 und höher + SQL Server Enterprise Edition ## Architektur **Quelltechnologie-Stack** + Microsoft SQL Server-Datenbank mit lokalen Always-On-Verfügbarkeitsgruppen **Zieltechnologie-Stack** + Microsoft SQL Server-Datenbank mit Always-On-Verfügbarkeitsgruppen EC2 auf Amazon in der AWS-Cloud **Migrationsarchitektur** ![\[SQL Server mit synchroner Replikation in Verfügbarkeitsgruppen vor Ort und auf AWS.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/6e229e30-9b11-4ccb-bccd-cbe6601139c0/images/79ee7911-d68f-4db7-9b94-113dcf09c28b.png) *Terminologie* + WSFC 1 — WSFC vor Ort + WSFC 2 — WSFC in der AWS-Cloud + AG 1 — Erste Verfügbarkeitsgruppe, die sich in WSFC 1 befindet + AG 2 — Zweite Verfügbarkeitsgruppe, die sich in WSFC 2 befindet + Primäres SQL Server-Replikat — Knoten in AG 1, der als globaler primärer Knoten für alle Schreibvorgänge gilt + SQL Server-Forwarder — Knoten in AG 2, der Daten asynchron vom primären SQL Server-Replikat empfängt + Sekundäres SQL Server-Replikat — Knoten in AG 1 oder AG 2, die Daten synchron vom primären Replikat oder der Weiterleitung empfangen ## Tools + [AWS Direct Connect](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html) — AWS Direct Connect verbindet Ihr internes Netzwerk über ein Standard-Ethernet-Glasfaserkabel mit einem AWS Direct Connect Connect-Standort. Mit dieser Verbindung können Sie *virtuelle Schnittstellen* direkt zu öffentlichen AWS-Services erstellen und dabei Internetdienstanbieter in Ihrem Netzwerkpfad umgehen. + [Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/concepts.html) — Amazon Elastic Compute Cloud (Amazon EC2) bietet skalierbare Rechenkapazität in der AWS-Cloud. Sie können Amazon verwenden EC2 , um so viele oder so wenige virtuelle Server zu starten, wie Sie benötigen, und Sie können nach oben oder unten skalieren. + [ Site-to-SiteAWS-VPN](https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html) — AWS Site-to-Site VPN unterstützt die Erstellung eines site-to-site virtuellen privaten Netzwerks (VPN). Sie können das VPN so konfigurieren, dass es Datenverkehr zwischen Instances, die Sie auf AWS starten, und Ihrem eigenen Remote-Netzwerk weiterleitet. + [Microsoft SQL Server Management Studio](https://docs.microsoft.com/en-us/sql/ssms/sql-server-management-studio-ssms?view=sql-server-ver15) — Microsoft SQL Server Management Studio (SSMS) ist eine integrierte Umgebung für die Verwaltung der SQL Server-Infrastruktur. Es bietet eine Benutzeroberfläche und eine Gruppe von Tools mit umfangreichen Skripteditoren, die mit SQL Server interagieren. ## Epen ### Richten Sie eine zweite Verfügbarkeitsgruppe auf AWS ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine WSFC auf AWS. | Erstellen Sie WSFC 2 auf EC2 Amazon-Instances mit zwei Knoten für HA. Sie verwenden diesen Failover-Cluster, um die zweite Verfügbarkeitsgruppe (AG 2) auf AWS zu erstellen. | Systemadministrator, SysOps Administrator | | Erstellen Sie die zweite Verfügbarkeitsgruppe auf WSFC 2. | Erstellen Sie mithilfe von SSMS AG 2 auf zwei Knoten in WSFC 2. Der erste Knoten in WSFC 2 fungiert als Forwarder. Der zweite Knoten in WSFC 2 wird als sekundäres Replikat von AG 2 fungieren.Derzeit sind in AG 2 keine Datenbanken verfügbar. Dies ist der Ausgangspunkt für die Einrichtung der verteilten Verfügbarkeitsgruppe. | DBA, Entwickler | | Erstellen Sie Datenbanken ohne Wiederherstellungsoption auf AG 2. | Sichern Sie Datenbanken in der lokalen Verfügbarkeitsgruppe (AG 1). Stellen Sie die Datenbanken sowohl auf dem Forwarder als auch auf dem sekundären Replikat von AG 2 ohne Wiederherstellungsoption wieder her. Geben Sie beim Wiederherstellen der Datenbanken einen Speicherort mit ausreichend Speicherplatz für die Datenbankdatendateien und die Protokolldateien an.Zu diesem Zeitpunkt befinden sich die Datenbanken im Wiederherstellungsstatus. Sie sind nicht Teil von AG 2 oder der Distributed Availability Group und werden nicht synchronisiert. | DBA, Entwickler | ### Konfigurieren Sie die verteilte Verfügbarkeitsgruppe | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie die verteilte Verfügbarkeitsgruppe auf AG 1. | Um die verteilte Verfügbarkeitsgruppe auf AG 1 zu erstellen, verwenden Sie die `CREATE AVAILABILITY GROUP` `DISTRIBUTED` Option with.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html) | DBA, Entwickler | | Erstellen Sie die verteilte Verfügbarkeitsgruppe auf AG 2. | Verwenden Sie die `DISTRIBUTED` Option, um die verteilte Verfügbarkeitsgruppe auf AG 2 `ALTER AVAILABILITY GROUP` zu erstellen.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html)Die verteilte Verfügbarkeitsgruppe wird zwischen AG 1 und AG 2 erstellt.Die Datenbanken in AG 2 sind noch nicht so konfiguriert, dass sie am Datenfluss von AG 1 nach AG 2 teilnehmen. | DBA, Entwickler | | Fügen Sie dem Forwarder und dem sekundären Replikat auf AG 2 Datenbanken hinzu. | Fügen Sie die Datenbanken der verteilten Verfügbarkeitsgruppe hinzu, indem Sie `ALTER DATABASE` die `SET HADR` `AVAILABILITY GROUP` Option sowohl im Forwarder als auch im sekundären Replikat auf AG 2 verwenden. Dadurch wird der asynchrone Datenfluss zwischen Datenbanken auf AG 1 und AG 2 gestartet. Der globale Primärserver nimmt Schreibvorgänge vor, sendet Daten synchron an das sekundäre Replikat auf AG 1 und sendet Daten asynchron an den Forwarder auf AG 2. Der Forwarder auf AG 2 sendet Daten synchron an das sekundäre Replikat auf AG 2. | DBA, Entwickler | ### Überwachen Sie den asynchronen Datenfluss zwischen AG 1 und AG 2 | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | DMVs Verwendungs- und SQL Server-Protokolle. | Überwachen Sie den Status des Datenflusses zwischen zwei Verfügbarkeitsgruppen mithilfe dynamischer Verwaltungsansichten (DMVs) und SQL Server-Protokollen. DMVs zu den für die Überwachung von Interesse sind, gehören `sys.dm_hadr_availability_replica_states` und`sys.dm_hadr_automatic_seeding`.Den Status der Weiterleitungssynchronisierung finden Sie im SQL Server-Protokoll auf der Weiterleitung anhand des *synchronisierten Status*. | DBA, Entwickler | ### Führen Sie Umstellungsaktivitäten für die endgültige Migration durch | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Stoppt den gesamten Datenverkehr zum primären Replikat. | Stoppen Sie den eingehenden Datenverkehr zum primären Replikat in AG 1, sodass keine Schreibaktivitäten in den Datenbanken stattfinden und die Datenbanken für die Migration bereit sind. | Besitzer der App, Entwickler | | Ändern Sie den Verfügbarkeitsmodus der verteilten Verfügbarkeitsgruppe auf AG 1. | Stellen Sie auf dem primären Replikat den Verfügbarkeitsmodus der verteilten Verfügbarkeitsgruppe auf synchron ein. Nachdem Sie den Verfügbarkeitsmodus auf synchron geändert haben, werden die Daten synchron vom primären Replikat in AG 1 an den Forwarder in AG 2 gesendet. | DBA, Entwickler | | Überprüfen Sie die LSNs in beiden Verfügbarkeitsgruppen. | Überprüfen Sie die letzten Protokollsequenznummern (LSNs) sowohl in AG 1 als auch in AG 2. Da im primären Replikat in AG 1 keine Schreibvorgänge stattfinden, werden die Daten synchronisiert, und die letzten Daten sollten LSNs für beide Verfügbarkeitsgruppen übereinstimmen. | DBA, Entwickler | | Aktualisieren Sie AG 1 auf die sekundäre Rolle. | Wenn Sie AG 1 auf die sekundäre Rolle aktualisieren, verliert AG 1 die primäre Replikatrolle und akzeptiert keine Schreibvorgänge, und der Datenfluss zwischen zwei Verfügbarkeitsgruppen wird gestoppt. | DBA, Entwickler | ### Führen Sie einen Failover zur zweiten Verfügbarkeitsgruppe durch | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Manuelles Failover zu AG 2. | Ändern Sie auf dem Forwarder in AG 2 die Distributed Availability Group, um Datenverlust zu verhindern. Da Sie bereits überprüft und bestätigt haben, dass die letzten LSNs auf AG 1 und AG 2 übereinstimmen, ist Datenverlust kein Problem.Wenn Sie Datenverlust auf dem Forwarder in AG 2 zulassen, ändern sich die Rollen von AG 1 und AG 2:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-sql-server-to-aws-using-distributed-availability-groups.html) | DBA, Entwickler | | Ändern Sie den Verfügbarkeitsmodus der verteilten Verfügbarkeitsgruppe auf AG 2. | Ändern Sie auf dem primären Replikat in AG 2 den Verfügbarkeitsmodus in asynchron.Dadurch wird die Datenbewegung von AG 2 nach AG 1 von synchron zu asynchron geändert. Dieser Schritt ist erforderlich, um Netzwerklatenz zwischen AG 2 und AG 1 zu vermeiden, falls vorhanden, und beeinträchtigt nicht die Leistung der Datenbank. | DBA, Entwickler | | Beginnen Sie mit dem Senden von Datenverkehr an das neue primäre Replikat. | Aktualisieren Sie die Verbindungszeichenfolge, sodass der Listener-URL-Endpunkt auf AG 2 für das Senden von Datenverkehr an die Datenbanken verwendet wird.AG 2 akzeptiert jetzt Schreibvorgänge und sendet Daten an den Forwarder in AG 1 sowie das Senden von Daten an sein eigenes sekundäres Replikat in AG 2. Daten werden asynchron von AG 2 zu AG 1 übertragen. | Besitzer der App, Entwickler | ### Führen Sie Aktivitäten nach der Umstellung durch | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Löschen Sie die verteilte Verfügbarkeitsgruppe auf AG 2. | Überwachen Sie die Migration für den geplanten Zeitraum. Löschen Sie dann die verteilte Verfügbarkeitsgruppe auf AG 2, um die Einrichtung verteilter Verfügbarkeitsgruppen zwischen AG 2 und AG 1 zu entfernen. Dadurch wird die Konfiguration der verteilten Verfügbarkeitsgruppe entfernt und der Datenfluss von AG 2 zu AG 1 wird gestoppt. Derzeit ist AG 2 auf AWS hochverfügbar, mit einem primären Replikat, das Schreibvorgänge akzeptiert, und einem sekundären Replikat in derselben Verfügbarkeitsgruppe. | DBA, Entwickler | | Nehmen Sie die lokalen Server außer Betrieb. | Nehmen Sie die lokalen Server in WSFC 1 außer Betrieb, die Teil von AG 1 sind. | Systemadministrator, Administrator SysOps | ## Zugehörige Ressourcen + [Verteilte Verfügbarkeitsgruppen](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-sql-server/distributed-groups.html) + [SQL-Dokumente: Verteilte Verfügbarkeitsgruppen](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/distributed-availability-groups?view=sql-server-ver15) + [SQL Docs: AlwaysOn-Verfügbarkeitsgruppen: eine Hochverfügbarkeits- und Disaster-Recovery-Lösung](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/always-on-availability-groups-sql-server?view=sql-server-ver15) # Migrieren Sie eine relationale Datenbank zu MongoDB Atlas am AWS *Battulga Purevragchaa und Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Zusammenfassung Dieses Muster beschreibt die Schritte für die Migration von einer relationalen Datenbank wie SQL Server, MySQL oder PostgreSQL zu MongoDB Atlas in der. AWS Cloud Es verwendet [MongoDB Relational Migrator](https://www.mongodb.com/products/relational-migrator), um die Datenmigration von relationalen Datenbanken zu MongoDB Atlas zu beschleunigen. Das Muster ist Teil des Leitfadens [Migration zu MongoDB Atlas AWS auf](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) der AWS Prescriptive Guidance-Website. Es enthält die Implementierungsschritte für eines der Migrationsszenarien, die in diesem Leitfaden erörtert werden. Weitere Migrationsszenarien finden Sie in den folgenden Mustern auf der AWS Prescriptive Guidance-Website: + [Migrieren Sie eine selbst gehostete MongoDB-Umgebung zu MongoDB Atlas am AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) + [Streamen Sie Daten von IBM Db2, SAP, Sybase und anderen Datenbanken nach MongoDB Atlas auf AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/stream-data-from-ibm-db2-to-mongodb-atlas.html) Das Muster ist für [Partner und AWS Benutzer von AWS System Integrator (SI)](https://aws.amazon.com/managed-services/partners/) vorgesehen. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Eine relationale Quelldatenbank (Oracle Database, SQL Server, PostgreSQL, MySQL, SAP/Sybase ASE und andere) für die Migration zu MongoDB Atlas. + Vertrautheit mit relationalen Datenbanken, MongoDB Atlas und. AWS-Services Dieses Muster erklärt einige der Migrationsschritte auf allgemeiner Ebene. Zusätzliche Details werden in future Versionen hinzugefügt. **Produktversionen** + MongoDB Version 5.0 oder höher ## Architektur Das folgende Diagramm zeigt die Migration von einer Datenbank mit einem relationalen Datenbankmanagementsystem (RDBMS) zu MongoDB Atlas am. AWS ![\[Architektur für die Migration von RDBMS zu MongoDB Atlas auf AWS.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/4e3ea0f1-21e8-4641-a9ee-732355f20baf/images/8eacf3ec-f480-4912-9002-6a50800fe9bf.png) Informationen zu MongoDB Atlas-Referenzarchitekturen, die verschiedene Nutzungsszenarien unterstützen, finden Sie unter [Migration zu MongoDB Atlas AWS auf](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) der AWS Prescriptive Guidance-Website. ## Tools + [MongoDB Atlas](https://www.mongodb.com/atlas) ist ein vollständig verwalteter Database-as-a-Service (DBaaS) für die Bereitstellung und Verwaltung von MongoDB-Datenbanken in der Cloud. + [MongoDB Relational Migrator](https://www.mongodb.com/products/relational-migrator) bietet einen reibungslosen Übergang von Daten von herkömmlichen relationalen Datenbanken zu MongoDB. Es hilft bei der Automatisierung des Konvertierungsprozesses und wandelt das strukturierte Datenmodell relationaler Datenbanken in das von MongoDB bereitgestellte flexible Dokumentformat um. Der Relational Migrator bewahrt die Datenintegrität und die Beziehungen, um die Migration zu vereinfachen. Organizations können die Vorteile der Skalierbarkeit, Leistung und Vielseitigkeit, die MongoDB bietet, nutzen und gleichzeitig die Vertrautheit mit ihren vorhandenen Daten beibehalten. ## Best Practices Bewährte Methoden für die Verwendung von MongoDB auf AWS finden Sie in den Beiträgen im [AWS Partner Network-Blog](https://aws.amazon.com/blogs/apn/tag/mongodb-atlas/). ## Epen ### Entdeckung und Bewertung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Ermitteln Sie die Parameter und die Größe der relationalen Datenbank. | Schätzen Sie die Größe des Arbeitssets, indem Sie die Empfehlungen von Relational Migrator und die Informationen aus dem gesamten `db.stats()` Indexraum verwenden. Gehen Sie davon aus, dass auf einen Prozentsatz Ihres Datenspeichers häufig zugegriffen wird. Diese Aufgabe sollte ungefähr eine Woche dauern. Weitere Informationen und Beispiele für diese und die anderen Geschichten in diesem Epos finden Sie im Abschnitt [Verwandte Ressourcen](#migrate-relational-database-to-mongodb-atlas-resources). | App-Besitzer, DBA | | Schätzen Sie die Anforderungen an die Netzwerkbandbreite. | Um Ihre Netzwerkbandbreitenanforderungen zu schätzen, multiplizieren Sie die durchschnittliche Dokumentengröße mit der Anzahl der pro Sekunde bereitgestellten Dokumente. Berücksichtigen Sie den maximalen Datenverkehr, den jeder Knoten in Ihrem Cluster als Grundlage tragen kann. Um die Downstream-Datenübertragungsraten von Ihrem Cluster zu den Client-Anwendungen zu berechnen, verwenden Sie die Summe aller Dokumente, die über einen bestimmten Zeitraum zurückgegeben wurden. Wenn Ihre Anwendungen von sekundären Knoten lesen, teilen Sie diese Gesamtzahl der Dokumente durch die Anzahl der Knoten, die Lesevorgänge ausführen können. Verwenden Sie den `db.stats().avgObjSize` Befehl, um die durchschnittliche Dokumentgröße für eine Datenbank zu ermitteln. Diese Aufgabe dauert in der Regel einen Tag. | DBA | | Wählen Sie die Atlas-Stufe aus. | Folgen Sie den Anweisungen in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/sizing-tier-selection/), um die richtige Atlas-Clusterstufe auszuwählen. | DBA | | Plan für die Umstellung. | Plan für die Umstellung der Anwendung. | DBA, Besitzer der App | ### Richten Sie eine neue MongoDB Atlas-Umgebung ein auf AWS | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie einen neuen MongoDB Atlas-Cluster auf AWS. | Wählen Sie in MongoDB Atlas die Option **Build a Cluster** aus. Wählen ** AWS Sie im Dialogfeld „Neuen Cluster erstellen**“ den Cloud-Anbieter aus. | DBA | | Wählen Sie AWS-Regionen eine globale Clusterkonfiguration aus. | Wählen Sie aus der Liste der AWS-Regionen für Ihren Atlas-Cluster verfügbaren aus. Konfigurieren Sie bei Bedarf globale Cluster. | DBA | | Wählen Sie die Clusterebene aus. | Wählen Sie Ihre bevorzugte Clusterstufe aus. Ihre Tierauswahl bestimmt Faktoren wie Arbeitsspeicher, Speicher und IOPS-Spezifikation. | DBA | | Konfigurieren Sie zusätzliche Cluster-Einstellungen. | Konfigurieren Sie zusätzliche Clustereinstellungen wie MongoDB-Version, Sicherungs- und Verschlüsselungsoptionen. Weitere Informationen zu diesen Optionen finden Sie im Abschnitt [Verwandte Ressourcen](#migrate-relational-database-to-mongodb-atlas-resources). | DBA | ### Konfigurieren Sie Sicherheit und Compliance | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Konfigurieren Sie die Zugriffsliste. | Um eine Verbindung zum Atlas-Cluster herzustellen, müssen Sie der Zugriffsliste des Projekts einen Eintrag hinzufügen. Atlas verwendet TLS/SSL , um die Verbindungen zur Virtual Private Cloud (VPC) für Ihre Datenbank zu verschlüsseln. Informationen zur Einrichtung der Zugriffsliste für das Projekt und weitere Informationen zu den Geschichten in diesem Epos finden Sie im Abschnitt [Verwandte Ressourcen](#migrate-relational-database-to-mongodb-atlas-resources). | DBA | | Authentifizieren und autorisieren Sie Benutzer. | Sie müssen die Datenbankbenutzer, die auf die MongoDB Atlas-Cluster zugreifen, erstellen und authentifizieren. Um auf Cluster in einem Projekt zugreifen zu können, müssen Benutzer zu diesem Projekt gehören, und sie können mehreren Projekten angehören. | DBA | | Erstellen Sie benutzerdefinierte Rollen. | (Optional) Atlas unterstützt die Erstellung benutzerdefinierter Rollen in Fällen, in denen die integrierten Benutzerberechtigungen für die Atlas-Datenbank nicht den gewünschten Berechtigungssatz abdecken. | DBA | | Richten Sie VPC-Peering ein. | (Optional) Atlas unterstützt [VPC-Peering](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) mit anderen VPCs . AWS | AWS-Administrator | | Richten Sie einen AWS PrivateLink Endpunkt ein. | (Optional) Sie können private Endpunkte einrichten, AWS indem Sie AWS PrivateLink Weitere Informationen finden Sie in der [Amazon VPC-Dokumentation](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html). | AWS-Administrator | | Aktivieren Sie die Zwei-Faktor-Authentifizierung. | (Optional) Atlas unterstützt die Zwei-Faktor-Authentifizierung (2FA), damit Benutzer den Zugriff auf ihre Atlas-Konten kontrollieren können. | AWS-Administrator | | Richten Sie die Benutzerauthentifizierung und -autorisierung mit LDAP ein. | (Optional) Atlas unterstützt die Benutzerauthentifizierung und -autorisierung mit dem Lightweight Directory Access Protocol (LDAP). | DBA | | Richten Sie Unified AWS Access ein. | (Optional) Einige Atlas-Funktionen, darunter Atlas Data Lake und Verschlüsselung im Ruhezustand mithilfe der Kundenschlüsselverwaltung, verwenden AWS Identity and Access Management (IAM-) Rollen für die Authentifizierung. | AWS-Administrator | | Richten Sie die Verschlüsselung im Ruhezustand ein mit AWS KMS. | (Optional) Atlas unterstützt die Verwendung von AWS Key Management Service (AWS KMS) zur Verschlüsselung von Speicher-Engines und Backups von Cloud-Anbietern. | AWS-Administrator | | Richten Sie eine clientseitige Verschlüsselung auf Feldebene ein. | (Optional) Atlas unterstützt die clientseitige Verschlüsselung auf Feldebene, einschließlich der automatischen Verschlüsselung von Feldern. | AWS-Administrator | ### Daten migrieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Fügen Sie MongoDB Relational Migrator zur Zugriffsliste hinzu. | Fügen Sie den Relational Migrator der Zugriffsliste für Ihre Quelldatenbank hinzu. Dies hilft dabei, die Quellumgebung auf die Verbindung mit dem Atlas-Zielcluster vorzubereiten. | DBA | | Beurteilen Sie die relationalen Datenbankobjekte. | Starten Sie MongoDB Relational Migrator und stellen Sie eine Verbindung zu Ihrer relationalen Datenbank her. Starten Sie die Bewertung. | DBA | | Akzeptieren Sie die Migrationsmuster oder ändern Sie sie je nach Ihren Geschäftsanforderungen. | Akzeptieren Sie entweder die vom Relational Migrator auf der Grundlage der anfänglichen Bewertung und der Leistungsparameter empfohlenen Datenbankmuster, oder ändern Sie sie entsprechend Ihren Geschäftsanforderungen. | DBA | | Starten Sie Ihren Zielreplikatsatz in MongoDB Atlas. | Starten Sie Ihren Zielreplikatsatz in MongoDB Atlas. Wählen Sie in Relational Migrator die Option **Ich bin** bereit zur Migration aus. | DBA | ### Betriebsintegration konfigurieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Connect zum MongoDB Atlas-Cluster her. | Stellen Sie sicher, dass die MongoDB Atlas-Clusterkonnektivität wie erwartet funktioniert. | Besitzer der App | | Interagieren Sie mit Clusterdaten. | Überprüfen Sie die Clusterdaten. | DBA | | Überwachen Sie Ihre Cluster. | Stellen Sie sicher, dass Ihre Cluster korrekt eingerichtet sind. | DBA | | Clusterdaten sichern und wiederherstellen. | Planen Sie Backups für Clusterdaten in regelmäßigen Abständen. | DBA | ## Zugehörige Ressourcen Alle folgenden Links führen, sofern nicht anders angegeben, zu Webseiten in der MongoDB-Dokumentation. **Leitfaden zur Migration** + [Migration zu MongoDB Atlas on AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) (AWS Prescriptive Guidance) **Entdeckung und Bewertung** + [Arbeitsspeicher](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Beispiel zur Größenbestimmung mit Atlas-Beispieldatensätzen](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Beispiel zur Größenbestimmung für mobile Anwendungen](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Netzwerkverkehr](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Automatische Cluster-Skalierung](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Vorlage für die Größenbestimmung von Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Konfiguration von Sicherheit und Compliance** + [Einträge in der IP-Zugriffsliste konfigurieren](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Datenbankbenutzer konfigurieren](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Konfigurieren Sie den Zugriff auf die Atlas-Benutzeroberfläche](https://docs.atlas.mongodb.com/organizations-projects/) + [Konfigurieren Sie benutzerdefinierte Datenbankrollen](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Datenbankbenutzer konfigurieren](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Richten Sie eine Netzwerk-Peering-Verbindung ein](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Erfahren Sie mehr über private Endpunkte in Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Verwalten Sie Ihre Multi-Faktor-Authentifizierungsoptionen](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Richten Sie die Benutzerauthentifizierung und -autorisierung mit LDAP ein](https://docs.atlas.mongodb.com/security-ldaps/) + [Atlas Data Lake](https://docs.mongodb.com/datalake/) + [Verschlüsselung im Ruhezustand mithilfe von Customer Key Management](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Methoden zur Übernahme einer Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (IAM-Dokumentation) + [Clientseitige Verschlüsselung auf Feldebene](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Automatische Verschlüsselung](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [MongoDB Atlas Sicherheitskontrollen](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [MongoDB-Vertrauenszentrum](https://www.mongodb.com/cloud/trust) + [Konfigurieren Sie Sicherheitsfunktionen für Cluster](https://docs.atlas.mongodb.com/setup-cluster-security/) **Einrichtung einer neuen MongoDB Atlas-Umgebung auf **AWS**** + [Cloud-Anbieter und Regionen](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Globale Cluster verwalten](https://docs.atlas.mongodb.com/global-clusters/) + [Wählen Sie die Clusterebene](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Konfigurieren Sie zusätzliche Einstellungen](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Fangen Sie mit Atlas an](https://docs.atlas.mongodb.com/getting-started/) + [Konfigurieren Sie den Zugriff auf die Atlas-Benutzeroberfläche](https://docs.atlas.mongodb.com/organizations-projects/) **Daten migrieren** + [Daten migrieren oder importieren](https://www.mongodb.com/docs/atlas/import/) **Cluster überwachen** + [Überwachen Sie Ihre Cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integrieren von Abläufen** + [Stellen Sie eine Connect zu einem Cluster her](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interagieren Sie mit Ihren Daten](https://docs.atlas.mongodb.com/data-explorer/) + [Überwachen Sie Ihre Cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Daten sichern, wiederherstellen und archivieren](https://docs.atlas.mongodb.com/backup-restore-cluster/) # Migrieren Sie eine selbst gehostete MongoDB-Umgebung zu MongoDB Atlas am AWS *Battulga Purevragchaa und Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Zusammenfassung Dieses Muster beschreibt die Schritte für die Migration von einer selbstverwalteten MongoDB-Umgebung (einschließlich MongoDB Community Server, Enterprise Server, Enterprise Advanced, mLab oder einem beliebigen verwalteten MongoDB-Cluster) zu MongoDB Atlas in der. AWS Cloud Es verwendet den [Atlas Live Migration Service](https://www.mongodb.com/cloud/atlas/migrate), um die Datenmigration von MongoDB zu MongoDB Atlas zu beschleunigen. Das Muster ist Teil des Leitfadens [Migration zu MongoDB Atlas AWS auf](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) der AWS Prescriptive Guidance-Website. Es enthält die Implementierungsschritte für eines der Migrationsszenarien, die in diesem Leitfaden erörtert werden. Weitere Migrationsszenarien finden Sie in den folgenden Mustern auf der AWS Prescriptive Guidance-Website: + [Migrieren Sie eine relationale Datenbank zu MongoDB Atlas am AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-relational-database-to-mongodb-atlas.html) + [Streamen Sie Daten von IBM Db2, SAP, Sybase und anderen Datenbanken nach MongoDB Atlas auf AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/stream-data-from-ibm-db2-to-mongodb-atlas.html) Das Muster ist für Partner und Benutzer von [AWS Systems Integrator (SI)](https://aws.amazon.com/managed-services/partners/) vorgesehen. AWS ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Eine MongoDB Enterprise Advanced-, Community Server- oder andere selbstverwaltete MongoDB-Umgebung für die Migration zu MongoDB Atlas. + Vertrautheit mit MongoDB, MongoDB Atlas und. AWS-Services Dieses Muster erklärt einige der Migrationsschritte auf allgemeiner Ebene. Zusätzliche Details werden in future Versionen hinzugefügt. **Produktversionen** + MongoDB Version 6.0.13 oder höher ## Architektur Das folgende Diagramm zeigt den Atlas Live Migration Service, der verwendet wird, um Daten aus einer MongoDB Enterprise Advanced-Datenbank und einer MongoDB Community-Datenbank zu MongoDB Atlas on zu migrieren. AWS Verwenden Sie diesen Service, wenn Sie große, komplexe Datenbanken mit minimalen Ausfallzeiten und kontinuierlicher Datensynchronisierung auf MongoDB Atlas migrieren müssen. Dieses Muster verwendet den Atlas Live Migration Service. ![\[Migrieren Sie Daten mit dem MongoDB Atlas Live Migration Service.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/52cdb923-64ff-4ee2-b129-93b9a139e24b/images/372134c4-ba47-4e48-bd0d-8b43017773b8.png) Das folgende Diagramm zeigt den MongoDB-Spiegeldienst (`mongomirror`), mit dem Sie auch Daten aus einer MongoDB Enterprise Advanced-Datenbank und einer MongoDB-Community-Datenbank AWS über eine sichere Verbindung zu MongoDB Atlas migrieren können. [AWS PrivateLink](https://aws.amazon.com/privatelink/) Wird `mongomirror` für die laufende Datenreplikation zwischen MongoDB vor Ort und MongoDB Atlas verwendet. Dieses Tool ist ideal für Disaster Recovery oder phasenweise Migrationen, fällt aber nicht in den Anwendungsbereich dieses Musters. ![\[Migrieren von Daten mit dem Mongomirror-Tool.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/52cdb923-64ff-4ee2-b129-93b9a139e24b/images/53488a9b-2210-4b3d-b517-b618c1e0182c.png) Weitere MongoDB Atlas-Referenzarchitekturen, die verschiedene Nutzungsszenarien unterstützen, finden Sie unter [Migration zu MongoDB Atlas AWS auf](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) der AWS Prescriptive Guidance-Website. ## Tools + [MongoDB Atlas](https://www.mongodb.com/atlas) ist ein vollständig verwalteter Database-as-a-Service (DBaaS) für die Bereitstellung und Verwaltung von MongoDB-Datenbanken in der Cloud. + [Atlas Live Migration Service](https://www.mongodb.com/cloud/atlas/migrate) ist ein kostenloses MongoDB-Hilfsprogramm, das bei der Migration von Datenbanken zu Atlas hilft. Dieser Dienst hält die Quelldatenbank bis zur Übernahme mit der Zieldatenbank synchron. Wenn Sie bereit sind, die Übertragung vorzunehmen, beenden Sie Ihre Anwendungsinstanzen, verweisen sie auf den Atlas-Ziel-Cluster und starten sie neu. Um auf diesen Service zuzugreifen, wählen Sie **Datenbankoptionen** aus Ihrem MongoDB Atlas-Cluster. + [mongomirror](https://www.mongodb.com/docs/atlas/import/mongomirror/) ist ein Tool zur manuellen Migration von Daten aus einem vorhandenen MongoDB-Replikatsatz zu einem MongoDB-Atlas-Replikatsatz. `mongomirror`erfordert nicht, dass Sie Ihren vorhandenen Replikatsatz oder Ihre Anwendungen herunterfahren, importiert keine Benutzer- oder Rollendaten und kopiert auch nicht die Konfigurationsdatenbank. Sie können es `mongomirror` von der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/import/mongomirror/#download-mongomirror) herunterladen. ## Best Practices Bewährte Methoden für die Verwendung von MongoDB auf AWS finden Sie in den Beiträgen im [AWS Partner Network-Blog](https://aws.amazon.com/blogs/apn/tag/mongodb-atlas/). ## Epen ### Entdeckung und Bewertung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Ermitteln Sie die Clustergröße. | Schätzen Sie die Größe des Arbeitssets, indem Sie die Informationen `db.stats()` für den gesamten Indexraum verwenden. Gehen Sie davon aus, dass auf einen Prozentsatz Ihres Datenspeichers häufig zugegriffen wird. Oder Sie können Ihren Speicherbedarf auf der Grundlage Ihrer eigenen Annahmen abschätzen. Diese Aufgabe sollte ungefähr eine Woche dauern. Weitere Informationen und Beispiele für diese und die anderen Geschichten in diesem Epos finden Sie im Abschnitt [Verwandte Ressourcen](#migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud-resources). | DBA, App-Besitzer | | Schätzen Sie die Anforderungen an die Netzwerkbandbreite. | Um Ihre Netzwerkbandbreitenanforderungen zu schätzen, multiplizieren Sie die durchschnittliche Dokumentengröße mit der Anzahl der pro Sekunde bereitgestellten Dokumente. Berücksichtigen Sie den maximalen Datenverkehr, den jeder Knoten in Ihrem Cluster als Grundlage tragen kann. Um die Downstream-Datenübertragungsraten von Ihrem Cluster zu den Client-Anwendungen zu berechnen, verwenden Sie die Summe aller Dokumente, die über einen bestimmten Zeitraum zurückgegeben wurden. Wenn Ihre Anwendungen von sekundären Knoten lesen, teilen Sie diese Gesamtzahl der Dokumente durch die Anzahl der Knoten, die Lesevorgänge ausführen können. Verwenden Sie den `db.stats().avgObjSize` Befehl, um die durchschnittliche Dokumentgröße für eine Datenbank zu ermitteln. Diese Aufgabe dauert in der Regel einen Tag. | DBA | | Wählen Sie die Atlas-Stufe aus. | Folgen Sie den Anweisungen in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/sizing-tier-selection/), um die richtige Atlas-Clusterstufe auszuwählen. | DBA | | Plan für die Umstellung. | Plan für die Umstellung der Anwendung. | DBA, Besitzer der App | ### Richten Sie eine neue MongoDB Atlas-Umgebung auf AWS ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie einen neuen MongoDB Atlas-Cluster auf AWS. | Melden Sie sich bei Atlas an und öffnen Sie die **Übersichtsseite** für Ihr Projekt. Wählen Sie die Schaltfläche **Erstellen**, um einen Cluster zu erstellen. Weitere Informationen finden Sie in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/). | DBA | | Wählen Sie AWS-Regionen eine globale Clusterkonfiguration aus. | Wählen Sie aus der Liste der AWS-Regionen für Ihren Atlas-Cluster verfügbaren aus. Konfigurieren Sie bei Bedarf globale Cluster. Weitere Informationen finden Sie in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/#select-your-preferred-region.). | DBA | | Wählen Sie die Clusterebene aus. | Wählen Sie Ihre bevorzugte Clusterstufe aus. Ihre Tierauswahl bestimmt Faktoren wie Arbeitsspeicher, Speicher und IOPS-Spezifikation. | DBA | | Konfigurieren Sie zusätzliche Cluster-Einstellungen. | Konfigurieren Sie zusätzliche Clustereinstellungen wie MongoDB-Version, Sicherungs- und Verschlüsselungsoptionen. Weitere Informationen zu diesen Optionen finden Sie im Abschnitt [Verwandte Ressourcen](#migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud-resources). | DBA | ### Konfigurieren Sie Sicherheit und Compliance | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Benutzer authentifizieren und autorisieren. | Sie müssen die Datenbankbenutzer, die auf die MongoDB Atlas-Cluster zugreifen, erstellen und authentifizieren. Um auf Cluster in einem Projekt zugreifen zu können, müssen Benutzer zu diesem Projekt gehören, und sie können mehreren Projekten angehören. Atlas unterstützt auch die Authentifizierung auf Basis von AWS Identity and Access Management (IAM). Weitere Informationen finden Sie in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/security/aws-iam-authentication/#set-up-authentication-with-aws-iam). | DBA | | Erstellen Sie benutzerdefinierte Rollen. | (Optional) Atlas unterstützt die Erstellung benutzerdefinierter Rollen in Fällen, in denen die integrierten Benutzerberechtigungen für die Atlas-Datenbank nicht den gewünschten Berechtigungssatz abdecken. | DBA | | Richten Sie VPC-Peering ein. | (Optional) Atlas unterstützt [Virtual Private Cloud (VPC) -Peering](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) mit anderen VPCs . AWS | AWS-Administrator | | Richten Sie einen AWS PrivateLink Endpunkt ein. | (Optional) Sie können private Endpunkte einrichten, AWS indem Sie AWS PrivateLink Weitere Informationen finden Sie in der [Amazon VPC-Dokumentation](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html). | AWS-Administrator | | Aktivieren Sie die Zwei-Faktor-Authentifizierung. | (Optional) Atlas unterstützt die Zwei-Faktor-Authentifizierung (2FA), damit Benutzer den Zugriff auf ihre Atlas-Konten kontrollieren können. | AWS-Administrator | | Richten Sie die Benutzerauthentifizierung und -autorisierung mit LDAP ein. | (Optional) Atlas unterstützt die Benutzerauthentifizierung und -autorisierung mit dem Lightweight Directory Access Protocol (LDAP). | AWS-Administrator | | Richten Sie AWS einen einheitlichen Zugriff ein. | (Optional) Einige Atlas-Funktionen, darunter Atlas Data Lake und Verschlüsselung im Ruhezustand mithilfe der Kundenschlüsselverwaltung, verwenden IAM-Rollen für die Authentifizierung. | AWS-Administrator | | Richten Sie die Verschlüsselung im Ruhezustand ein mit AWS KMS. | (Optional) Atlas unterstützt die Verwendung von AWS Key Management Service (AWS KMS) zur Verschlüsselung von Speicher-Engines und Backups von Cloud-Anbietern. | AWS-Administrator | | Richten Sie eine clientseitige Verschlüsselung auf Feldebene ein. | (Optional) Atlas unterstützt die clientseitige Verschlüsselung auf Feldebene, einschließlich der automatischen Verschlüsselung von Feldern. | AWS-Administrator | ### Daten migrieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Wählen Sie Ihren Zielreplikatsatz in MongoDB Atlas aus. | Navigieren Sie zum Atlas-Ziel-Cluster und klicken Sie auf die Schaltfläche mit den Auslassungspunkten (...). In der Clusterliste wird diese Schaltfläche unter dem Clusternamen angezeigt. In den Clusterdetails wird die Schaltfläche rechts neben den Schaltflächen **Connect** und **Konfiguration** angezeigt. Weitere Informationen finden Sie in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/import/c2c-pull-live-migration/#procedure). | DBA | | Fügen Sie den Atlas Live Migration Service zur Zugriffsliste hinzu. | Fügen Sie den Atlas Live Migration Service zur Zugriffsliste in Ihrem AWS Quellcluster hinzu. Dies hilft dabei, die Quellumgebung auf die Verbindung mit dem Atlas-Ziel-Cluster vorzubereiten. | DBA | | Führen Sie die Migration mit dem Atlas Live Migration Service durch. | Wählen Sie **Migration starten**. Wenn die Schaltfläche „**Für die Übernahme vorbereiten**“ grün wird, führen Sie die Übernahme durch. Überprüfen Sie die Leistungskennzahlen des Atlas-Clusters. Erwägen Sie, die Datenbankverbindung in allen Anwendungsebenen so zu aktualisieren, dass sie auf die neue Datenbank verweist. | DBA | ### Betriebsintegration konfigurieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Connect zum MongoDB Atlas-Cluster her. | Stellen Sie sicher, dass die MongoDB Atlas-Cluster-Konnektivität wie erwartet funktioniert. | Besitzer der App | | Interagieren Sie mit Clusterdaten. | Testen Sie die Clusterdaten. | DBA | | Überwachen Sie Ihre Cluster. | Stellen Sie sicher, dass Ihre Cluster korrekt eingerichtet sind. | DBA | | Clusterdaten sichern und wiederherstellen. | Planen Sie Backups für Clusterdaten in regelmäßigen Abständen. | DBA | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | Fehler: Die angegebene Quelle konnte nicht erreicht werden | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) | | Fehler: Hostname konnte nicht aufgelöst werden | Für den angegebenen Hostnamen wurde keine IP-Adresse gefunden. Bestätigen Sie, dass der angegebene Hostname korrekt und öffentlich zugänglich ist. | | Irgendein anderer Fehler | Wenn Sie auf andere Fehler stoßen, finden Sie weitere Informationen unter [Problembehandlung bei Live-Migration (Pull)](https://www.mongodb.com/docs/atlas/import/live-import-troubleshooting/) in der MongoDB-Dokumentation. | ## Zugehörige Ressourcen Alle folgenden Links führen, sofern nicht anders angegeben, zu Webseiten in der MongoDB-Dokumentation. **Leitfaden zur Migration** + [Migration zu MongoDB Atlas on AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) (AWS Prescriptive Guidance) **Migration älterer Versionen** + [Migration älterer Versionen von MongoDB](https://www.mongodb.com/docs/atlas/legacy-migration/) **Entdeckung und Bewertung** + [Arbeitsspeicher](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Beispiel zur Größenbestimmung mit Atlas-Beispieldatensätzen](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Beispiel zur Größenbestimmung für mobile Anwendungen](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Netzwerkverkehr](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Automatische Cluster-Skalierung](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Vorlage für die Größenbestimmung von Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Konfiguration von Sicherheit und Compliance** + [Einträge in der IP-Zugriffsliste konfigurieren](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Datenbankbenutzer konfigurieren](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Konfigurieren Sie den Zugriff auf die Atlas-Benutzeroberfläche](https://docs.atlas.mongodb.com/organizations-projects/) + [Konfigurieren Sie benutzerdefinierte Datenbankrollen](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Datenbankbenutzer konfigurieren](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Richten Sie eine Netzwerk-Peering-Verbindung ein](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Erfahren Sie mehr über private Endpunkte in Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Verwalten Sie Ihre Multi-Faktor-Authentifizierungsoptionen](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Richten Sie die Benutzerauthentifizierung und -autorisierung mit LDAP ein](https://docs.atlas.mongodb.com/security-ldaps/) + [Atlas Data Lake](https://docs.mongodb.com/datalake/) + [Verschlüsselung im Ruhezustand mithilfe von Customer Key Management](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Methoden zur Übernahme einer Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (IAM-Dokumentation) + [Clientseitige Verschlüsselung auf Feldebene](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Automatische Verschlüsselung](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [MongoDB Atlas Sicherheitskontrollen](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [MongoDB-Vertrauenszentrum](https://www.mongodb.com/cloud/trust) + [Konfigurieren Sie Sicherheitsfunktionen für Cluster](https://docs.atlas.mongodb.com/setup-cluster-security/) **Einrichtung einer neuen MongoDB Atlas-Umgebung auf **AWS**** + [Cloud-Anbieter und Regionen](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Globale Cluster verwalten](https://docs.atlas.mongodb.com/global-clusters/) + [Wählen Sie die Clusterebene](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Konfigurieren Sie zusätzliche Einstellungen](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Fangen Sie mit Atlas an](https://docs.atlas.mongodb.com/getting-started/) + [Konfigurieren Sie den Zugriff auf die Atlas-Benutzeroberfläche](https://docs.atlas.mongodb.com/organizations-projects/) **Daten migrieren** + [Daten migrieren oder importieren](https://www.mongodb.com/docs/atlas/import/) **Cluster überwachen** + [Überwachen Sie Ihre Cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integrieren von Abläufen** + [Mit einem Cluster verbinden](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interagieren Sie mit Ihren Daten](https://docs.atlas.mongodb.com/data-explorer/) + [Überwachen Sie Ihre Cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Daten sichern, wiederherstellen und archivieren](https://docs.atlas.mongodb.com/backup-restore-cluster/) **Training** + [Live-Migration mit MongoDB Atlas](https://learn.mongodb.com/courses/live-migration-with-mongodb-atlas) ## Zusätzliche Informationen Weitere Informationen finden Sie in den folgenden Themen in der MongoDB-Dokumentation: + Um Daten auf eine serverlose Instanz zu verschieben, [verwenden Sie Compass, um Daten zu exportieren und zu importieren](https://www.mongodb.com/docs/compass/current/import-export/), oder migrieren Sie Daten mit selbstverwalteten Tools. Weitere Informationen finden Sie unter Einschränkungen für [serverlose Instances](https://www.mongodb.com/docs/atlas/reference/serverless-instance-limitations/). + Informationen zum Laden von Daten in einen neuen Cluster in Atlas finden Sie unter [Daten in Atlas laden](https://www.mongodb.com/docs/atlas/sample-data/#std-label-sample-data). + Informationen zum Erstellen einer Kopie Ihres Clusters zu Testzwecken finden Sie unter [Sicherungsmethoden für eine selbstverwaltete Bereitstellung](https://www.mongodb.com/docs/manual/core/backups/). + Wenn die Anwendung, die Sie migrieren möchten, eine nahezu ununterbrochene Verfügbarkeit benötigt, wenden Sie sich an den [MongoDB-Support und teilen Sie uns Ihre Verfügbarkeitsanforderungen](https://www.mongodb.com/docs/atlas/support/#std-label-request-support) und die Clusterkonfiguration mit. + [Weitere Informationen finden Sie unter Daten migrieren oder importieren.](https://www.mongodb.com/docs/atlas/import/) # Migrieren Sie eine Oracle-Datenbank mit AWS DMS zu Amazon DynamoDB *Rambabu Karnena, Amazon Web Services* ## Zusammenfassung Dieses Muster führt Sie durch die Schritte zur Migration einer Oracle-Datenbank zu [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) mithilfe des AWS Database Migration Service ([AWS](https://aws.amazon.com/dms/) DMS). Es deckt drei Arten von Quelldatenbanken ab: + Lokale Oracle-Datenbanken + Oracle-Datenbanken auf Amazon Elastic Compute Cloud ([Amazon EC2](https://aws.amazon.com/ec2/)) + Amazon Relational Database Service ([Amazon RDS](https://aws.amazon.com/rds/)) für Oracle-DB-Instances In diesem Machbarkeitsnachweis konzentriert sich dieses Muster auf die Migration von einer Amazon RDS for Oracle DB-Instance. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto + Eine Anwendung, die eine Verbindung zu einer Amazon RDS for Oracle Oracle-Datenbank herstellt + Eine in der Amazon RDS for Oracle Oracle-Quelldatenbank erstellte Tabelle mit einem Primärschlüssel und Beispieldaten **Einschränkungen** + Oracle-Datenbankobjekte wie Prozeduren, Funktionen, Pakete und Trigger werden für die Migration nicht berücksichtigt, da Amazon DynamoDB diese Datenbankobjekte nicht unterstützt. **Produktversionen** + Dieses Muster gilt für alle Editionen und Versionen von Oracle-Datenbanken, die von AWS DMS unterstützt werden. Weitere Informationen finden Sie unter Verwenden einer [Oracle-Datenbank als Quelle für AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) und Verwenden einer [Amazon DynamoDB DynamoDB-Datenbank als Ziel für](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.DynamoDB.html) AWS DMS. Wir empfehlen Ihnen, die neuesten Versionen von AWS DMS zu verwenden, um die umfassendste Versions- und Funktionsunterstützung zu erhalten. ## Architektur **Quelltechnologie-Stack** + Amazon RDS for Oracle Oracle-DB-Instances, Oracle auf Amazon EC2 oder lokale Oracle-Datenbanken **Zieltechnologie-Stack** + Amazon DynamoDB **AWS-Datenmigrationsarchitektur** ![\[Daten werden von Oracle DB zu AWS DMS zu Amazon DynamoDB verschoben.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/463fc7d4-ec8d-473b-8c7f-1df31800ee03/images/180e7340-3887-455d-a591-b5850e22770a.png) ## Tools + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) unterstützt Sie bei der Migration von Datenspeichern in die AWS-Cloud oder zwischen Kombinationen von Cloud- und lokalen Setups. + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) ist ein vollständig verwalteter NoSQL-Datenbank-Service, der schnelle und planbare Leistung mit nahtloser Skalierbarkeit bereitstellt. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Datenbank in der AWS-Cloud. Dieses Muster verwendet Amazon RDS for Oracle. ## Epen ### Planen Sie die Migration | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine VPC. | Erstellen Sie in Ihrem AWS-Konto eine Virtual Private Cloud (VPC) und ein privates Subnetz. | Systemadministrator | | Erstellen Sie Sicherheitsgruppen und Listen zur Netzwerkzugriffskontrolle. | Weitere Informationen finden Sie in der [AWS-Dokumentation](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html). | Systemadministrator | | Konfigurieren und starten Sie die Amazon RDS for Oracle DB-Instance. | Weitere Informationen finden Sie in der [AWS-Dokumentation](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html). | DBA, Systemadministrator | ### Daten migrieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine IAM-Rolle für den Zugriff auf DynamoDB. | Erstellen Sie in der AWS Identity and Access Management (IAM) -Konsole die Rolle, fügen Sie die Richtlinie `AmazonDynamoDBFullAccess to it` hinzu und wählen Sie AWS DMS als Service aus. | Systemadministrator | | Erstellen Sie eine AWS DMS-Replikationsinstanz für die Migration. | Die Replikationsinstanz sollte sich in derselben Availability Zone und VPC wie die Quelldatenbank befinden. | Systemadministrator | | Erstellen Sie Quell- und Zielendpunkte in AWS DMS. | Um den Quelldatenbank-Endpunkt zu erstellen, haben Sie zwei Möglichkeiten:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html)Um den Zieldatenbank-Endpunkt zu erstellen, wählen Sie die Rolle Amazon Resource Name (ARN) aus der vorherigen Aufgabe für den Zugriff auf DynamoDB aus. | Systemadministrator | | Erstellen Sie eine AWS-DMS-Aufgabe, um die Oracle-Quelldatenbanktabellen in DynamoDB zu laden. | Wählen Sie die Namen der Quell- und Zielendpunkte sowie die Replikationsinstanz aus den vorherigen Schritten aus. Der Typ kann Volllast sein. Wählen Sie das Oracle-Schema und geben Sie**%** an, um alle Tabellen auszuwählen. | Systemadministrator | | Überprüfen Sie die Tabellen in DynamoDB. | Um die Migrationsergebnisse anzuzeigen, wählen Sie im linken Navigationsbereich der DynamoDB-Konsole **Tabellen** aus. | DBA | ### Migrieren Sie die Anwendung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Ändern Sie den Anwendungscode. | Um eine Verbindung zu DynamoDB herzustellen und Daten von DynamoDB abzurufen, aktualisieren Sie den Anwendungscode. | App-Besitzer, DBA, Systemadministrator | ### Überschneiden | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Stellen Sie die Anwendungsclients so ein, dass sie DynamoDB verwenden. | | DBA, App-Besitzer, Systemadministrator | ### Schließen Sie das Projekt | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Fahren Sie die AWS-Ressourcen herunter. | Zum Beispiel das Herunterfahren der Amazon RDS for Oracle-Instance, DynamoDB und der AWS DMS-Replikationsinstanz. | DBA, Systemadministrator | | Sammeln Sie Kennzahlen. | Zu den Kennzahlen gehören die Zeit für die Migration, der prozentuale Anteil manueller Arbeit und der vom Tool ausgeführten Arbeit sowie Kosteneinsparungen. | DBA, App-Besitzer, Systemadministrator | ## Zugehörige Ressourcen + [AWS Database Migration Service und Amazon DynamoDB: Was Sie wissen müssen](https://aws.amazon.com/blogs/database/aws-database-migration-service-and-amazon-dynamodb-what-you-need-to-know/) (Blogbeitrag) + [Verwenden einer Oracle-Datenbank als Quelle für AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html) + [Verwenden einer Amazon DynamoDB DynamoDB-Datenbank als Ziel für den AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.DynamoDB.html) + [Bewährte Methoden für die Migration von RDBMS zu Amazon DynamoDB](https://docs.aws.amazon.com/whitepapers/latest/best-practices-for-migrating-from-rdbms-to-dynamodb/welcome.html) (Whitepaper) # Migrieren Sie mithilfe von AWS DMS von Oracle 8i oder 9i zu Amazon RDS for Oracle SharePlex *Ramu Jagini, Amazon Web Services* ## Zusammenfassung Dieses Muster beschreibt, wie eine lokale Oracle 8i- oder 9i-Datenbank zu einer Amazon Relational Database Service (Amazon RDS) für Oracle-Datenbank migriert wird. Sie können dieses Muster verwenden, um Ihre Migration mit reduzierten Ausfallzeiten abzuschließen, indem Sie Quest SharePlex für die synchrone Replikation verwenden. Sie müssen für Ihre Migration eine Oracle-Datenbankzwischeninstanz verwenden, da der AWS Database Migration Service (AWS DMS) Oracle 8i oder 9i nicht als Quellumgebung unterstützt. Sie können [SharePlex 7.6.3](https://www.quest.com/community/shareplex/f/forum/20700/where-can-download-7-6-3-or-support-9i-shareplex) verwenden, um von früheren Oracle-Datenbankversionen auf spätere Oracle-Datenbankversionen zu replizieren. Die Oracle-Zwischeninstanz ist als Ziel für SharePlex 7.6.3 kompatibel und wird als Quelle für AWS DMS oder neuere Versionen von unterstützt. SharePlex Diese Unterstützung ermöglicht die Weiterreplikation von Daten in die Zielumgebung von Amazon RDS for Oracle. Beachten Sie, dass sich mehrere veraltete Datentypen und Funktionen auf eine Migration von Oracle 8i oder 9i zur neuesten Version von Oracle Database auswirken können. Um diese Auswirkungen zu minimieren, verwendet dieses Muster Oracle 11.2.0.4 als Datenbankzwischenversion, um den Schemacode vor der Migration zur Amazon RDS for Oracle Oracle-Zielumgebung zu optimieren. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto + Eine Oracle 8i- oder 9i-Quelldatenbank in einer lokalen Umgebung + [Oracle Database 12c Version 2](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/index.html) (12CR2) für das Staging auf Amazon Elastic Compute Cloud (Amazon) EC2 + Quest SharePlex 7.6.3 (kommerzielle Qualität) **Einschränkungen** + [Einschränkungen von RDS für Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Oracle.Concepts.limitations.html) **Produktversionen** + Oracle 8i oder 9i für die Quelldatenbank + Oracle 12 CR2 für die Staging-Datenbank (muss mit der Version von Amazon RDS for Oracle übereinstimmen) + Oracle 12 CR2 oder höher für die Zieldatenbank (Amazon RDS for Oracle) ## Architektur **Quelltechnologie-Stack** + Oracle 8i- oder 9i-Datenbank + SharePlex **Zieltechnologie-Stack** + Amazon RDS für Oracle **Migrationsarchitektur** Das folgende Diagramm zeigt, wie eine Oracle 8i- oder 9i-Datenbank von einer lokalen Umgebung zu einer Amazon RDS for Oracle DB-Instance in der AWS-Cloud migriert wird. ![\[Workflow für die Migration einer lokalen Oracle-Datenbank zu Amazon RDS auf AWS.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/6e07d586-fd74-4f3d-8e81-79dd55c445c3/images/36e1a5ff-908b-4cb7-96f7-997eb105f1d6.png) Das Diagramm zeigt den folgenden Workflow: 1. Aktivieren Sie die Oracle-Quelldatenbank mit Archivprotokollmodus, erzwungener Protokollierung und zusätzlicher Protokollierung. 1. [Stellen Sie die Oracle-Staging-Datenbank mithilfe von Recovery Manager (RMAN) point-in-time Recovery und FLASHBACK\$1SCN aus der Oracle-Quelldatenbank wieder her.](https://docs.oracle.com/database/121/SUTIL/GUID-D408B112-1A81-4F68-BEFF-7403A9588DDB.htm#SUTIL849) 1. Konfigurieren Sie SharePlex das Lesen von Redo-Logs aus der Oracle-Quelldatenbank mithilfe von (wird in RMAN verwendet). `FLASHBACK_SCN` 1. Starten Sie die SharePlex Replikation, um Daten aus der Oracle-Quelldatenbank mit der Oracle-Staging-Datenbank zu synchronisieren. 1. Stellen Sie die Amazon RDS for Oracle Oracle-Zieldatenbank mithilfe von EXPDP und IMPDP mit wieder her. `FLASHBACK_SCN` 1. Konfigurieren Sie AWS DMS und seine Quellaufgaben als Oracle-Staging-Datenbank und Amazon RDS for Oracle als Zieldatenbank, indem Sie `FLASHBACK_SCN` (wird in EXPDP verwendet) verwenden. 1. Starten Sie AWS DMS-Aufgaben, um Daten aus der Oracle-Staging-Datenbank mit der Oracle-Zieldatenbank zu synchronisieren. ## Tools + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Datenbank in der AWS-Cloud. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) unterstützt Sie bei der Migration von Datenspeichern in die AWS-Cloud oder zwischen Kombinationen von Cloud- und lokalen Setups. + [Quest SharePlex](https://support.quest.com/shareplex/11.0/technical-documents) ist ein Oracle-to-Oracle Datenreplikationstool zum Verschieben von Daten mit minimalen Ausfallzeiten und ohne Datenverlust. + [Recovery Manager (RMAN)](https://docs.oracle.com/cd/E11882_01/backup.112/e10642/rcmquick.htm) ist ein Oracle Database-Client, der Sicherungs- und Wiederherstellungsaufgaben für Ihre Datenbanken ausführt. Er vereinfacht das Sichern, Wiederherstellen und Wiederherstellen von Datenbankdateien erheblich. + Mit [Data Pump Export](https://docs.oracle.com/cd/E11882_01/server.112/e22490/dp_export.htm#SUTIL823) können Sie Daten und Metadaten in eine Reihe von Betriebssystemdateien hochladen, die als Dump-Dateisatz bezeichnet werden. Der Dump-Dateisatz kann nur mit dem [Data Pump Import Utility oder dem Paket [DBMS\$1DATAPUMP](https://docs.oracle.com/database/121/ARPLS/d_datpmp.htm#ARPLS356)](https://docs.oracle.com/cd/E11882_01/server.112/e22490/dp_import.htm#SUTIL300) importiert werden. ## Epen ### Einrichtung SharePlex und Oracle-Staging-Datenbank auf Amazon EC2 | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine EC2 Instanz. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html) | Oracle-Verwaltung | | Bereiten Sie die Staging-Datenbank vor. | Bereiten Sie die Oracle-Staging-Datenbank für die Wiederherstellung als Upgrade auf Oracle 12 vor, CR2 indem Sie das RMAN-Backup aus der Oracle 8i- oder 9i-Datenbankquellumgebung übernehmen.Weitere Informationen finden Sie in der Oracle-Dokumentation im [Oracle 9i Recovery Manager User's Guide](https://docs.oracle.com/cd/B10500_01/server.920/a96566/toc.htm) [und im Database Backup and Recovery User's Guide](https://docs.oracle.com/database/121/BRADV/rcmcomre.htm#BRADV8005). | Oracle-Verwaltung | | Konfigurieren SharePlex. | Konfigurieren Sie die SharePlex Quelle als lokale Oracle 8i- oder 9i-Datenbank und konfigurieren Sie das Ziel als die auf Amazon gehostete Oracle CR2 12-Staging-Datenbank. EC2 | SharePlex, Oracle-Verwaltung | ### Richten Sie Amazon RDS for Oracle als Ihre Zielumgebung ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Oracle-DB-Instance. | Erstellen Sie eine Amazon RDS for Oracle Oracle-Datenbank und verbinden Sie dann Oracle 12 CR2 mit der Datenbank.Weitere Informationen finden Sie in der Amazon RDS-Dokumentation unter [Eine Oracle-DB-Instance erstellen und eine Verbindung zu einer Datenbank auf einer Oracle-DB-Instance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.Oracle.html) herstellen. | DBA | | Stellen Sie Amazon RDS for Oracle aus der Staging-Datenbank wieder her. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html)Weitere Informationen finden Sie unter [54 DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/21/arpls/DBMS_DATAPUMP.html#GUID-AEA7ED80-DB4A-4A70-B199-592287206348) in der Oracle-Dokumentation. | DBA | ### AWS DMS einrichten | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie Endpunkte für die Datenbanken. | Erstellen Sie einen Quellendpunkt für die Oracle-Staging-Datenbank und einen Zielendpunkt für die Amazon RDS for Oracle Oracle-Datenbank.Weitere Informationen finden Sie unter [Wie erstelle ich Quell- oder Zielendpunkte mit AWS DMS](https://aws.amazon.com/premiumsupport/knowledge-center/create-source-target-endpoints-aws-dms/)? im AWS Knowledge Center. | DBA | | Erstellen Sie eine Replikationsinstanz. | Verwenden Sie AWS DMS, um eine Replikationsinstanz für die Oracle-Staging-Datenbank zur Amazon RDS for Oracle Oracle-Datenbank zu starten.Weitere Informationen finden Sie unter [Wie erstelle ich eine AWS DMS-Replikationsinstanz](https://aws.amazon.com/premiumsupport/knowledge-center/create-aws-dms-replication-instance/)? im AWS Knowledge Center. | DBA | | Erstellen und starten Sie Replikationsaufgaben. | Erstellen Sie AWS DMS-Replikationsaufgaben für Change Data Capture (CDC) mithilfe `FLASHBACK_SCN` von EXPDP (da die volle Last bereits über EXPDP erfolgt ist).Weitere Informationen finden Sie in der AWS DMS-Dokumentation unter [Aufgabe erstellen](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.Creating.html). | DBA | ### Wechseln Sie zu Amazon RDS for Oracle | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Stoppen Sie die Arbeitslast der Anwendung. | Stoppen Sie die Anwendungsserver und ihre Anwendungen während des geplanten Umstellungsfensters. | App-Entwickler, DBA | | Überprüfen Sie die Synchronisierung der lokalen Oracle-Staging-Datenbank mit der Instanz. EC2 | Stellen Sie sicher, dass alle Nachrichten für Replikationsaufgaben von der SharePlex Replikationsinstanz in die Oracle-Staging-Datenbank auf Amazon gesendet wurden, EC2 indem Sie einige Log-Switches in der lokalen Quelldatenbank durchführen.Weitere Informationen finden Sie unter [6.4.2 Eine Protokolldatei wechseln](https://docs.oracle.com/database/121/ADMQS/GUID-E30B4C65-2AC7-4A44-A58C-D3C121EB152F.htm#ADMQS12075) in der Oracle-Dokumentation. | DBA | | Validieren Sie die Synchronisierung der Oracle-Staging-Datenbank mit der Amazon RDS for Oracle Oracle-Datenbank. | Vergewissern Sie sich, dass alle Ihre AWS DMS-Aufgaben keine Verzögerung und keine Fehler aufweisen, und überprüfen Sie dann den Validierungsstatus der Aufgaben. | DBA | | Stoppen Sie die Replikation von SharePlex und Amazon RDS. | Wenn SharePlex sowohl die als auch die AWS DMS-Replikation keine Fehler anzeigen, beenden Sie beide Replizierungen. | DBA | | Ordnen Sie die Anwendung Amazon RDS neu zu. | Teilen Sie die Amazon RDS for Oracle Oracle-Endpunktdetails mit dem Anwendungsserver und seinen Anwendungen und starten Sie dann die Anwendung, um den Geschäftsbetrieb wieder aufzunehmen. | App-Entwickler, DBA | ### Testen Sie die AWS-Zielumgebung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Testen Sie die Oracle-Staging-Datenbankumgebung auf AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html) | SharePlex, Oracle-Verwaltung | | Testen Sie die Amazon RDS-Umgebung. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.html)Weitere Informationen finden Sie unter [Amazon RDS for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html) in der Amazon RDS-Dokumentation. | Oracle-Verwaltung | ## Zugehörige Ressourcen + [Migrieren Sie mit Zuversicht](https://aws.amazon.com/cloud-migration/) + [Amazon EC2](https://aws.amazon.com/ec2/) + [Amazon RDS für Oracle](https://aws.amazon.com/rds/oracle/) + [AWS Database Migration Service](https://aws.amazon.com/dms/) + [Debuggen Ihrer AWS DMS-Migrationen: Was tun, wenn etwas schief geht (Teil 1)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-1/) + [Debuggen Ihrer AWS DMS-Migrationen: Was tun, wenn etwas schief geht (Teil 2)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-2/) + [Debuggen Ihrer AWS DMS-Migrationen: Was tun, wenn etwas schief geht? (Teil 3)](https://aws.amazon.com/blogs/database/debugging-your-aws-dms-migrations-what-to-do-when-things-go-wrong-part-3/) + [SharePlex für Datenbankreplikation](https://aws.amazon.com/marketplace/pp/B07943W4MJ) + [SharePlex: Datenbankreplikation für jede Umgebung](https://www.youtube.com/watch?v=ygS_ouUaNus) # Migrieren Sie eine lokale MySQL-Datenbank zu Amazon EC2 *Lorenzo Mota, Amazon Web Services* ## Zusammenfassung Dieses Muster bietet Anleitungen für die Migration einer lokalen MySQL-Datenbank zu einer MySQL-Datenbank auf einer Amazon Elastic Compute Cloud (Amazon EC2) -Instance. Das Muster beschreibt die Verwendung von AWS Database Migration Service (AWS DMS) oder nativen MySQL-Tools wie **mysqldump für die Migration**. Es konzentriert sich auf die vollständige Datenbankmigration zu einer MySQL-DB-Instance. Das Muster richtet sich in erster Linie an Lösungsarchitekten. DBAs Es kann in kleinen oder großen Projekten, in einer Test- oder Endmigrationsphase verwendet werden. Wir empfehlen, dass Sie mindestens einen Testzyklus ausführen, bevor Sie dieses Muster in einer Produktionsumgebung verwenden. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto + Eine MySQL-Quelldatenbank in einem lokalen Rechenzentrum **Produktversionen** + MySQL Version 5.5 und höher + Ein Zielbetriebssystem, das von Amazon EC2 unterstützt wird; siehe [Amazon](https://aws.amazon.com/ec2/faqs/) EC2 FAQs ## Architektur **Quelltechnologie-Stack** + Eine lokale MySQL-Datenbank **Zieltechnologie-Stack** + Eine MySQL-Datenbank-Instance auf Amazon EC2 **AWS-Datenmigrationsmethoden** + AWS DMS + [Native MySQL-Tools wie [mysqldump](https://dev.mysql.com/doc/refman/en/mysqldump.html) oder Tools von Drittanbietern wie Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) **Zielarchitektur** Das folgende Diagramm zeigt die Amazon EC2 EC2-Zielimplementierung nach der Umstellung. ![\[Eine MySQL-DB-Instance auf Amazon EC2 mit Replikation auf eine Standby-MySQL-DB-Instance.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/34cab6f9-9107-4c3b-98ec-a6d7fa9f298a.png) **AWS-Datenmigrationsarchitektur** *Verwenden von AWS DMS:* Das folgende Diagramm veranschaulicht den Datenmigrationsablauf, der auf dem AWS DMS Senden vollständiger und inkrementeller Änderungen an die MySQL-Zieldatenbank bis zur Übernahme basiert. Die Netzwerkverbindung von lokal zu AWS hängt von den Anforderungen des SQL-Clients ab und fällt nicht in den Anwendungsbereich dieses Musters. ![\[Verwenden von AWS DMS zum Senden von Daten an eine MySQL-Zieldatenbank auf Amazon EC2.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/c906c45d-fac5-4bb9-b8c8-55e2f9f05fd8.png) *Verwendung anderer MySQL-Tools:* Das folgende Diagramm veranschaulicht den Datenmigrationsablauf, der auf der Verwendung von MySQL-Tools zum Generieren von Export-Dumpdateien aus der lokalen Datenbank basiert. Diese Dateien werden in Amazon Simple Storage Service (Amazon S3) verschoben und vor der Übernahme in die MySQL-Zieldatenbank importiert. Die Netzwerkverbindung von lokal zu AWS hängt von den Anforderungen des SQL-Clients ab und liegt außerhalb des Geltungsbereichs dieses Musters. ![\[Verwendung nativer MySQL-Tools zum Senden von Daten an eine MySQL-Zieldatenbank auf Amazon EC2.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/d22b3e25-4d3b-4bd7-ad07-501748d67752/images/18e88877-7879-4a99-b985-25c56bf7c35f.png) Hinweise: + Abhängig von den Überlegungen zu Ausfallzeiten und der Größe der Datenbank für die endgültige Umstellung können Sie ein anderes CDC-Tool (Change Data Capture) verwenden AWS DMS , um die Umstellungszeit zu minimieren. Wenn Sie ein CDC-Tool wie verwenden AWS DMS, können Sie innerhalb von Minuten zur Zieldatenbank migrieren. + Eine Offline-Strategie mit **mysqldump** kann ausreichen, wenn die Größe der Datenbank und die Netzwerklatenz ein kurzes Umstellungsfenster zulassen. (Wir empfehlen, Tests durchzuführen, um eine ungefähre Zeit zu erhalten.) + In der Regel AWS DMS erfordert eine durchgehende CDC-Strategie mehr Überwachung und Komplexität als eine Offline-Option. ## Tools **AWS Dienste** + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) unterstützt mehrere Quell- und Zieldatenbanken. Hinweise zu MySQL-Quell- und Zieldatenbanken, die von unterstützt werden AWS DMS, finden Sie [unter Verwenden einer MySQL-kompatiblen Datenbank als Quelle für AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.MySQL.html) und [Verwenden einer MySQL-kompatiblen](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.MySQL.html) Datenbank als Ziel für. AWS DMS Wenn Ihre Quelldatenbank von nicht unterstützt wird AWS DMS, müssen Sie eine andere Methode für die Migration Ihrer Daten wählen. **Andere Tools** + [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) ist ein MySQL-Hilfsprogramm, das zu Sicherungs- oder Migrationszwecken eine Dump-Datei aus einer MySQL-Datenbank erstellt. + [Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) ist ein Open-Source-Hilfsprogramm zur Durchführung blockierungsfreier Backups auf MySQL-Datenbanken. ## Epen ### Planen Sie die Migration | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Validieren Sie die Datenbankversionen. | Überprüfen Sie die Versionen der Quell- und Zieldatenbanken. Informationen zu den von AWS DMS unterstützten MySQL-Versionen finden Sie AWS DMS in der AWS DMS Dokumentation unter [Sources for AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.Sources.html) [und Targets for](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.Targets.html). | DBA | | Identifizieren Sie das Zielbetriebssystem. | Ermitteln Sie die Version des Zielbetriebssystems. Eine Liste der von Amazon EC2 unterstützten Zielbetriebssysteme finden Sie unter [Amazon FAQs EC2](https://aws.amazon.com/ec2/faqs/). | DBA, Systemadministrator | | Identifizieren Sie die Hardwareanforderungen. | Ermitteln Sie die Hardwareanforderungen für die [Zielserverinstanz](https://aws.amazon.com/rds/instance-types/) auf der Grundlage der MySQL-Kompatibilitätsliste und der Kapazitätsanforderungen. | DBA, Systemadministrator | | Identifizieren Sie die Speicheranforderungen. | Ermitteln Sie den Speichertyp und die Kapazität für die Zieldatenbank. | DBA, Systemadministrator | | Identifizieren Sie die Netzwerkanforderungen. | Ermitteln Sie die Netzwerkanforderungen wie Latenz und Bandbreite. | DBA, Systemadministrator | | Wählen Sie den Typ der Zielinstanz. | Wählen Sie den [Zielinstanztyp](https://aws.amazon.com/rds/instance-types/) auf der Grundlage von Kapazität, Speicherfunktionen und Netzwerkfunktionen aus. | DBA, Systemadministrator | | Identifizieren Sie die Sicherheitsanforderungen. | Ermitteln Sie die Sicherheitsanforderungen für den Netzwerk- oder Hostzugriff für die Quell- und Zieldatenbanken. | DBA, Systemadministrator | | Identifizieren Sie Benutzer. | Ermitteln Sie die Liste der Betriebssystembenutzer für die MySQL-Softwareinstallation. Weitere Informationen finden Sie in der [MySQL-Dokumentation](https://dev.mysql.com/doc/mysql-security-excerpt/en/access-control.html). | DBA, Systemadministrator | | Legen Sie eine Backup-Strategie fest. | | DBA | | Ermitteln Sie die Verfügbarkeitsanforderungen. | | DBA | | Identifizieren Sie die Strategie für die Anwendungsmigration oder den Umstieg. | | DBA, Systemadministrator | ### Konfigurieren Sie die Infrastruktur | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine virtuelle private Cloud (VPC) und Subnetze. | Konfigurieren Sie Routentabellen, Internet-Gateways, NAT-Gateways und Subnetze. Weitere Informationen finden Sie unter [VPC-Konfigurationsoptionen](https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc-options.html) in der Amazon VPC-Dokumentation. | Systemadministrator | | Erstellen Sie Sicherheitsgruppen und Netzwerkzugriffskontrolllisten (ACLs). | Konfigurieren Sie IPs je nach Ihren Anforderungen Ports (Standard für MySQL ist 3306) und CIDR-Bereiche oder spezifische. | Systemadministrator | | Konfigurieren und starten Sie eine EC2-Instanz. | Anweisungen finden Sie unter [Starten einer EC2-Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/LaunchingAndUsingInstances.html) in der Amazon EC2 EC2-Dokumentation. | Systemadministrator | ### Installieren Sie die MySQL-Software | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie Benutzer und Gruppen. | Erstellen Sie die Betriebssystembenutzer und -gruppen, die Zugriff auf den Server und die Datenbank benötigen. Weitere Informationen finden Sie unter [ Access Control and Account Management](https://dev.mysql.com/doc/refman/en/access-control.html) in der MySQL-Dokumentation. | DBA, Systemadministrator | | Laden Sie MySQL herunter. | Laden Sie die MySQL-Software herunter. Anweisungen und Binärdateien finden Sie unter [Installation von MySQL](https://dev.mysql.com/doc/refman/en/installing.html) in der MySQL-Dokumentation. | DBA, Systemadministrator | | Installieren Sie MySQL auf der EC2-Instanz und konfigurieren Sie den Server. | Connect zu Ihrer EC2-Instance her und installieren Sie die MySQL-Software. Weitere Informationen finden Sie unter [Connect to your EC2-Instance in der Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect.html) EC2-Dokumentation. | DBA, Systemadministrator | ### Daten migrieren — Option 1 | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Migrieren Sie Daten mit nativen MySQL- oder Drittanbieter-Tools. | Diese Option verwendet native MySQL-Tools oder Tools von Drittanbietern, um Datenbankobjekte und Daten zu migrieren. Anweisungen finden Sie in der Dokumentation für [mysqldump](https://dev.mysql.com/doc/refman/en/mysqldump.html) oder [Percona XtraBackup](https://docs.percona.com/percona-xtrabackup/2.4/index.html) (für die physische Migration). Weitere Informationen zur Verwendung dieser Tools finden Sie im AWS Blogbeitrag [Migrationsoptionen für MySQL zu Amazon RDS for MySQL oder Amazon Aurora MySQL](https://aws.amazon.com/blogs/database/migration-options-for-mysql-to-amazon-rds-for-mysql-or-amazon-aurora-mysql/). | DBA | ### Daten migrieren — Option 2 | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Migrieren Sie Daten mit AWS DMS. | Weitere Informationen finden Sie AWS DMS in [der AWS DMS Dokumentation unter Ansicht auf hoher Ebene von](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Introduction.HighLevelView.html). | DBA | ### Bereite dich auf die Umstellung vor | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Sammeln Sie die Anzahl der Objekte. | Sammeln Sie Objektzahlen aus der Quelldatenbank und neuen Zieldatenbanken. Korrigieren Sie alle Unstimmigkeiten in der Zieldatenbank. | DBA | | Überprüfen Sie die Abhängigkeiten. | Stellen Sie sicher, dass Abhängigkeiten (Links) zu und von anderen Datenbanken weiterhin gültig sind und ordnungsgemäß funktionieren. | DBA | | Testen. | Wenn es sich um einen Testzyklus handelt, führen Sie Abfragetests durch, sammeln Sie Messwerte und beheben Sie alle Probleme. | DBA | ### Überschneiden | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Kunden bewegen. | Stellen Sie die Anwendungsclients auf die neue Infrastruktur um. | DBA, App-Besitzer, Systemadministrator | | Bieten Sie Unterstützung an. | Bieten Sie Unterstützung bei Funktionstests von Anwendungen. | DBA | ### Schließt das Projekt | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Ressourcen herunterfahren. | Fahren Sie die AWS DMS Replikationsinstanz und andere temporäre AWS Ressourcen herunter. | DBA, Systemadministrator | | Dokumente überprüfen und projizieren. | Überprüfen und validieren Sie die Projektdokumente. | DBA, App-Besitzer, Systemadministrator | | Sammeln Sie Metriken. | Erfassen Sie Kennzahlen wie die Zeit bis zur Migration, den Prozentsatz manueller Änderungen im Vergleich zu toolgestützten Änderungen und Kosteneinsparungen. | DBA, App-Besitzer, Systemadministrator | | Schließt das Projekt ab. | Schließen Sie das Migrationsprojekt ab und geben Sie Feedback. | DBA, App-Besitzer, Systemadministrator | | Quelldatenbank außer Betrieb nehmen. | Nehmen Sie die lokale MySQL-Datenbank außer Betrieb. | DBA, Systemadministrator | ## Zugehörige Ressourcen **Referenzen** + [Amazon EC2 EC2-Dokumentation](https://docs.aws.amazon.com/ec2/) + [AWS DMS Dokumentation](https://docs.aws.amazon.com/dms/) + [Amazon EC2 – Preise](https://aws.amazon.com/ec2/pricing/) + [AWS DMS Step-by-Step Anleitungen](https://docs.aws.amazon.com/dms/latest/sbs/DMS-SBS-Welcome.html) + [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) + [Percona XtraBackup](https://www.percona.com/mysql/software/percona-xtrabackup) **Anleitungen und Videos** + [Erste Schritte mit AWS DMS](https://aws.amazon.com/dms/getting-started/) + [Einführung in Amazon EC2 — Elastic Cloud Server und Hosting mit AWS](https://www.youtube.com/watch?v=TsRBftzZsQo) (Video) # Überwachen Sie Amazon Aurora auf Instances ohne Verschlüsselung *Mansi Suratwala, Amazon Web Services* ## Zusammenfassung Dieses Muster stellt eine Amazon Web Services (AWS) CloudFormation -Vorlage bereit, die Sie einsetzen können, um automatische Benachrichtigungen einzurichten, wenn eine Amazon Aurora Aurora-Instance ohne aktivierte Verschlüsselung erstellt wird. Aurora ist eine vollständig verwaltete, mit MySQL und PostgreSQL kompatible relationale Datenbank-Engine. Bei manchen Workloads kann Aurora einen bis zu fünfmal höheren Durchsatz als MySQL und einen bis zu dreimal höheren Durchsatz als PostgreSQL liefern, ohne dass die meisten Ihrer bestehenden Anwendungen geändert werden müssen. Die CloudFormation Vorlage erstellt ein Amazon CloudWatch Events-Ereignis und eine AWS-Lambda-Funktion. Das Ereignis verwendet AWS CloudTrail , um die Erstellung einer Aurora-Instance oder die Wiederherstellung einer vorhandenen Instance zu einem bestimmten Zeitpunkt zu überwachen. Das Cloudwatch Events-Ereignis initiiert die Lambda-Funktion, die überprüft, ob die Verschlüsselung aktiviert ist. Wenn die Verschlüsselung nicht aktiviert ist, sendet die Lambda-Funktion eine Amazon Simple Notification Service (Amazon SNS) -Benachrichtigung, die Sie über den Verstoß informiert. ## Voraussetzungen und Einschränkungen **Voraussetzungen****** + Ein aktives AWS-Konto **Einschränkungen** + Diese Servicesteuerung funktioniert nur mit Amazon Aurora Aurora-Instances. Andere Amazon Relational Database Service (Amazon RDS) -Instances werden nicht unterstützt. + Die CloudFormation Vorlage darf nur für `RestoreDBClusterToPointInTim` **E `CreateDBInstance`**** und E** bereitgestellt werden. **Produktversionen** + PostgreSQL-Versionen, die in Amazon Aurora unterstützt werden + MySQL-Versionen, die in Amazon Aurora unterstützt werden ## Architektur **Zieltechnologie-Stack** + Amazon Aurora + AWS CloudTrail + Amazon CloudWatch + AWS Lambda + Amazon Simple Storage Service (Amazon-S3) + Amazon SNS **Zielarchitektur** ![\[Aurora-Start ohne Verschlüsselung CloudTrail, Aufrufen von CloudWatch Ereignissen, Lambda und einer SNS-Nachricht.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/de1528b8-a5a4-4c66-8ab3-7d9863572cbc/images/7dcab41a-d805-4bb0-99d1-1dcef37c4e55.png) **Automatisierung und Skalierung** Sie können die CloudFormation Vorlage mehrfach für verschiedene Regionen und Konten verwenden. Sie müssen sie in jeder Region oder jedem Konto nur einmal ausführen. ## Tools **Tools** + [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) — Amazon Aurora ist eine vollständig verwaltete relationale Datenbank-Engine, die mit MySQL und PostgreSQL kompatibel ist. + [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) — AWS CloudTrail unterstützt Sie bei der Verwaltung der Unternehmensführung, der Einhaltung von Vorschriften sowie der Betriebs- und Risikoprüfung Ihres AWS-Kontos. Aktionen, die von einem Benutzer, einer Rolle oder einem AWS-Service ausgeführt werden, werden als Ereignisse in aufgezeichnet CloudTrail. + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) — Amazon CloudWatch Events liefert einen near-real-time Stream von Systemereignissen, die Änderungen an AWS-Ressourcen beschreiben. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) — AWS Lambda ist ein Rechenservice, der die Ausführung von Code unterstützt, ohne Server bereitzustellen oder zu verwalten. Lambda führt Ihren Code nur bei Bedarf aus und skaliert automatisch – von einigen Anforderungen pro Tag bis zu Tausenden pro Sekunde. + [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/gsg/GetStartedWithS3.html) — Amazon Simple Storage Service (Amazon S3) ist ein hoch skalierbarer Objektspeicherservice, den Sie für eine Vielzahl von Speicherlösungen verwenden können, darunter Websites, mobile Anwendungen, Backups und Data Lakes. + [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) — Amazon Simple Notification Service (Amazon SNS) ist ein verwalteter Service, der die Nachrichtenzustellung über Lambda, HTTP, E-Mail, mobile Push-Benachrichtigungen und mobile Textnachrichten (SMS) ermöglicht. **Code** Eine ZIP-Datei des Projekts ist als Anhang verfügbar. ## Epen ### Erstellen Sie den S3-Bucket für das Lambda-Skript | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Definieren Sie den S3-Bucket. | Öffnen Sie die Amazon S3 S3-Konsole und wählen oder erstellen Sie einen S3-Bucket. Dieser S3-Bucket hostet die Lambda-Code-.zip-Datei. Ihr S3-Bucket muss sich in derselben Region wie Aurora befinden. Der S3-Bucket-Name darf keine führenden Schrägstriche enthalten. | Cloud-Architekt | ### Laden Sie den Lambda-Code in den S3-Bucket hoch | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Laden Sie den Lambda-Code hoch. | Laden Sie die Lambda-Code-ZIP-Datei, die im Abschnitt *Anlagen* bereitgestellt wird, in den von Ihnen definierten S3-Bucket hoch. | Cloud-Architekt | ### Stellen Sie die CloudFormation Vorlage bereit | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Stellen Sie die CloudFormation Vorlage bereit. | Stellen Sie auf der CloudFormation Konsole die `RDS_Aurora_Encryption_At_Rest.yml` CloudFormation Vorlage bereit, die als Anlage zu diesem Muster bereitgestellt wird. Geben Sie im nächsten Epos Werte für die Vorlagenparameter an. | Cloud-Architekt | ### Vervollständigen Sie die Parameter in der CloudFormation Vorlage | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Geben Sie den S3-Bucket-Namen an. | Geben Sie den Namen des S3-Buckets ein, den Sie im ersten Epic erstellt oder ausgewählt haben. | Cloud-Architekt | | Geben Sie den S3-Schlüssel an. | Geben Sie den Speicherort der Lambda-Code-ZIP-Datei in Ihrem S3-Bucket an, ohne vorangestellte Schrägstriche (z. B.). `
(sidadm $> python systemReplicationStatus.py
sudo yum install -y awslogs| AWS allgemein | | Bearbeiten Sie die Agenten-Konfigurationsdateien. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | AWS allgemein | | Starten Sie den CloudWatch Agenten. | Verwenden Sie den folgenden Befehl, um den Agenten zu starten.
$ sudo service awslogsd startNachdem Sie den Agenten gestartet haben, können Sie die Protokollgruppe in der CloudWatch Konsole anzeigen. Der Protokollstream wird den Inhalt der Datei enthalten. | AWS allgemein | ### Schritt 6: Erstellen Sie Metrikfilter für die Protokollgruppe | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie metrische Filter für die Schlüsselwörter ABEND und STOPPED. | Wenn Sie Metrikfilter für die Protokollgruppe erstellen, wird jedes Mal, wenn die Filter im Fehlerprotokoll identifiziert werden, ein Alarm ausgelöst und eine E-Mail-Benachrichtigung gesendet, die auf der Amazon SNS SNS-Konfiguration basiert.So erstellen Sie Metrikfilter:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | CloudWatch | ### Schritt 7. Einrichten von Amazon SNS | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie ein SNS-Thema. | In diesem Schritt konfigurieren Sie Amazon SNS so, dass Alarme für die metrischen Filter erstellt werden.So erstellen Sie ein SNS-Thema:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html) | Amazon SNS | | Erstellen Sie ein Abonnement. | Um ein Abonnement für das Thema zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)Amazon SNS öffnet Ihren Webbrowser und zeigt eine Abonnementbestätigung mit Ihrer Abonnement-ID an. | Amazon SNS | ### Schritt 8. Erstellen Sie einen Alarm, um Benachrichtigungen für die Metrikfilter zu senden | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie einen Alarm für das SNS-Thema. | So erstellen Sie einen Alarm auf der Grundlage eines Metrikfilters für Protokollgruppen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)Nach diesen Schritten erhalten Sie jedes Mal, wenn diese Muster in der GoldenGate Fehlerprotokolldatei (`ggserr.log`), die Sie überwachen, erkannt werden, eine E-Mail-Benachrichtigung. | CloudWatch | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | Der Protokollstream aus dem GoldenGate Fehlerprotokoll fließt nicht hinein CloudWatch. | Überprüfen Sie die `/etc/awslogs/awslogs.conf` Datei, um den Dateinamen, den Namen der Protokollgruppe und das date/time Format zu überprüfen. Sie müssen das Format angeben date/time , das dem Datumsformat entspricht`ggserror.log`. Andernfalls fließt der Protokollstream nicht in CloudWatch. | ## Zugehörige Ressourcen + [ CloudWatch Amazon-Dokumentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) + [Erfassung von Metriken und Protokollen mit dem CloudWatch Agenten](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) + [Amazon SNS SNS-Dokumentation](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) # Replatform Oracle Database Enterprise Edition auf Standard Edition 2 auf Amazon RDS for Oracle *Lanre (Lan-Ray) showunmi und Tarun Chawla, Amazon Web Services* ## Zusammenfassung Oracle Database Enterprise Edition (EE) ist in vielen Unternehmen eine beliebte Wahl für die Ausführung von Anwendungen. In einigen Fällen verwenden Anwendungen jedoch nur wenige oder gar keine Funktionen von Oracle Database EE, sodass es an Rechtfertigungen für enorme Lizenzkosten mangelt. Sie können Kosteneinsparungen erzielen, indem Sie solche Datenbanken bei der Migration zu Amazon RDS auf Oracle Database Standard Edition 2 (SE2) herabstufen. Dieses Muster beschreibt, wie ein Downgrade von Oracle Database EE auf Oracle Database durchgeführt wird, SE2 wenn von einer lokalen Umgebung zu [Amazon RDS for](https://aws.amazon.com/rds/oracle/) Oracle migriert wird. Die in diesem Muster beschriebenen Schritte gelten auch, wenn Ihre EE-Oracle-Datenbank bereits auf Amazon RDS oder auf einer [Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) (Amazon EC2) -Instance läuft. Weitere Informationen finden Sie im AWS Prescriptive Guidance Guide zur [Evaluierung des Downgrades von Oracle-Datenbanken auf Standard Edition 2](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/welcome.html) auf AWS. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto + Oracle Database Enterprise Edition + Ein Client-Tool, wie [Oracle SQL Developer](https://www.oracle.com/database/sqldeveloper/) oder SQL\$1Plus, zum Herstellen einer Verbindung mit SQL-Befehlen und zum Ausführen von SQL-Befehlen in einer Oracle-Datenbank + Datenbankbenutzer für die Durchführung der Bewertung, z. B. einer der folgenden Benutzer: + Benutzer mit ausreichenden [Rechten](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Source.Oracle.html#CHAP_Source.Oracle.Permissions) für die Ausführung der [AWS Schema Conversion Tool (AWS SCT) -Bewertung](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) + Benutzer mit ausreichenden Rechten, um SQL-Abfragen in Oracle-Datenbank-Wörterbuchtabellen auszuführen + Datenbankbenutzer für die Durchführung der Datenbankmigration, z. B. einer der folgenden Benutzer: + Benutzer mit ausreichenden [Rechten](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html#CHAP_Source.Oracle.Self-Managed) für die Ausführung von [AWS Database Migration Service (AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)) + Benutzer mit ausreichenden [Rechten für den Export und Import von Oracle Data Pump](https://docs.oracle.com/database/121/SUTIL/GUID-8B6975D3-3BEC-4584-B416-280125EEC57E.htm#SUTIL807) + Benutzer mit ausreichenden [Rechten zum Ausführen von Oracle GoldenGate](https://docs.oracle.com/goldengate/1212/gg-winux/GIORA/user_assignment.htm#GIORA546) **Einschränkungen** + Amazon RDS for Oracle hat eine maximale Datenbankgröße. Weitere Informationen finden Sie unter [Amazon-RDS-DB-Instance Speicher](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Storage.html). **Produktversionen** Die in diesem Dokument beschriebene allgemeine Logik gilt für Oracle-Versionen ab 9i. Unterstützte Versionen von selbstverwalteten Datenbanken und Datenbanken von Amazon RDS for Oracle finden Sie in der [AWS DMS-Dokumentation](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.Oracle.html). Um die Funktionsnutzung in Fällen zu identifizieren, in denen AWS SCT nicht unterstützt wird, führen Sie SQL-Abfragen in der Quelldatenbank aus. Verwenden Sie die Oracle [Export- und Import-Dienstprogramme, um von früheren Versionen von Oracle zu migrieren, in denen AWS DMS und Oracle](https://docs.oracle.com/cd/B19306_01/server.102/b14215/exp_imp.htm) Data Pump nicht unterstützt werden. Eine aktuelle Liste der unterstützten Versionen und Editionen finden Sie in der AWS-Dokumentation unter [Oracle on Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Oracle.html). Einzelheiten zu Preisen und unterstützten Instance-Klassen finden Sie unter [Amazon RDS für Oracle – Preise](https://aws.amazon.com/rds/oracle/pricing/). ## Architektur **Quelltechnologie-Stack** + Oracle Database Enterprise Edition läuft vor Ort oder auf Amazon EC2 **Zieltechnologie-Stack mit nativen Oracle-Tools** + Amazon RDS for Oracle mit Oracle-Datenbank SE2 ![\[Dreistufiger Prozess für die Migration von der lokalen Oracle-DB zu Amazon RDS.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/a1b28050-9bab-4de6-b2a9-b97b3e5070bd/images/bf765c5b-4b12-4a8c-b27c-c5e0bd605dd1.png) 1. Exportieren Sie Daten mithilfe von Oracle Data Pump. 1. Kopieren Sie Dumpdateien über einen Datenbank-Link nach Amazon RDS. 1. Importieren Sie Dump-Dateien mithilfe von Oracle Data Pump in Amazon RDS. **Zieltechnologie-Stack mit AWS DMS** + Amazon RDS for Oracle mit Oracle-Datenbank SE2 + AWS DMS ![\[Vierstufiger Prozess für die Migration von der lokalen Oracle-DB zu Amazon RDS mithilfe von AWS DMS.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/a1b28050-9bab-4de6-b2a9-b97b3e5070bd/images/fef4eced-1acb-4303-baaa-5c1c29650935.png) 1. Exportieren Sie Daten mithilfe von Oracle Data Pump mit FLASHBACK\$1SCN. 1. Kopieren Sie Dumpdateien über einen Datenbank-Link nach Amazon RDS. 1. Importieren Sie Dump-Dateien mithilfe von Oracle Data Pump in Amazon RDS. 1. Verwenden Sie AWS DMS [Change Data Capture (CDC](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Task.CDC.html)). ## Tools **AWS-Services** + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) unterstützt Sie bei der Migration von Datenspeichern in die AWS-Cloud oder zwischen Kombinationen von Cloud- und lokalen Setups. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Datenbank in der AWS-Cloud. Dieses Muster verwendet Amazon RDS for Oracle. + [AWS SCT****](https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html) bietet eine projektbasierte Benutzeroberfläche, mit der Sie das Datenbankschema Ihrer Oracle-Quelldatenbank automatisch bewerten, konvertieren und in ein mit Amazon RDS for Oracle kompatibles Format kopieren können. Mit AWS SCT können Sie potenzielle Kosteneinsparungen analysieren, die durch die Änderung Ihres Lizenztyps von Enterprise auf Standard Edition von Oracle erzielt werden können. Der Abschnitt **Lizenzbewertung und Cloud-Support** des AWS SCT-Berichts enthält detaillierte Informationen zu den verwendeten Oracle-Funktionen, sodass Sie bei der Migration zu Amazon RDS for Oracle eine fundierte Entscheidung treffen können. **Andere Tools** + Native Oracle-Import- und Exportprogramme unterstützen das Verschieben von Oracle-Daten in und aus Oracle-Datenbanken. Oracle bietet zwei Arten von Dienstprogrammen für den Datenbankimport und -export: [Original Export und Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/exp_imp.htm) (für frühere Versionen) und [Oracle Data Pump Export and Import](https://docs.oracle.com/cd/B19306_01/server.102/b14215/part_dp.htm#CEGJCCHC) (verfügbar in Oracle Database 10g, Version 1 und höher). + [Oracle GoldenGate](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.OracleGoldenGate.html) bietet Funktionen zur Replikation in Echtzeit, sodass Sie Ihre Zieldatenbank nach einem ersten Ladevorgang synchronisieren können. Diese Option kann dazu beitragen, die Ausfallzeiten von Anwendungen während der Inbetriebnahme zu reduzieren. ## Epen ### Machen Sie vor der Migration eine Bewertung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Überprüfen Sie die Datenbankanforderungen für Ihre Anwendungen. | Stellen Sie sicher, dass Ihre Anwendungen für die Ausführung auf Oracle Database zertifiziert sind SE2. Erkundigen Sie sich direkt beim Softwareanbieter, Entwickler oder in der Anwendungsdokumentation. | App-Entwickler, DBA, App-Besitzer | | Untersuchen Sie die Verwendung von EE-Funktionen direkt in der Datenbank. | Gehen Sie wie folgt vor, um die Nutzung der EE-Funktion zu ermitteln:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.html) | App-Besitzer, DBA, App-Entwickler | | Identifizieren Sie die Verwendung von EE-Funktionen für betriebliche Aktivitäten. | Datenbank- oder Anwendungsadministratoren verlassen sich bei betrieblichen Aktivitäten manchmal auf reine EE-Funktionen. Zu den häufigsten Beispielen gehören Online-Wartungsaktivitäten (Indexneuerstellung, Tabellenverschiebung) und die Verwendung von Parallelität durch Batch-Jobs.Diese Abhängigkeiten können verringert werden, indem Sie Ihre Betriebsabläufe nach Möglichkeit ändern. Identifizieren Sie die Verwendung dieser Funktionen und treffen Sie eine Entscheidung auf der Grundlage der Kosten im Vergleich zu den Vorteilen.Verwenden Sie die Tabelle zum [Vergleich von Oracle Database EE und SE2 Funktionen](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/compare-features.html) als Leitfaden, um die Funktionen zu identifizieren, die in Oracle Database verfügbar sind SE2. | App-Entwickler, DBA, App-Besitzer | | Überprüfen Sie die Workload-Muster der EE Oracle-Datenbank. | Oracle Database beschränkt die Nutzung SE2 automatisch auf maximal 16 CPU-Threads zu einem beliebigen Zeitpunkt.Wenn Ihre Oracle EE-Datenbank für die Verwendung des Oracle Diagnostic Pack lizenziert ist, verwenden Sie das Tool Automatic Workload Repository (AWR) oder DBA\$1HIST\$1\$1-Views, um die Workload-Muster der Datenbank zu analysieren und festzustellen, ob sich die maximale Grenze von 16 CPU-Threads negativ auf die Service Levels auswirkt, wenn Sie auf. SE2Stellen Sie sicher, dass Ihre Bewertung Perioden mit hoher Aktivität abdeckt, wie z. B. die Verarbeitung am Ende eines Tages, eines Monats oder eines Jahres. | App-Besitzer, DBA, App-Entwickler | ### Bereiten Sie die Zielinfrastruktur auf AWS vor | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Stellen Sie die Netzwerkinfrastruktur bereit und konfigurieren Sie sie. | Erstellen Sie eine [Virtual Private Cloud (VPC) und Subnetze](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html), [Sicherheitsgruppen](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) und [Netzwerkzugriffskontrolllisten](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html). | AWS-Administrator, Cloud-Architekt, Netzwerkadministrator, DevOps Ingenieur | | Stellen Sie die Amazon RDS for Oracle SE2 Oracle-Datenbank bereit. | Stellen Sie die [Amazon RDS for Oracle SE2 Oracle-Zieldatenbank](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.Oracle.html) bereit, um die Leistungs-, Verfügbarkeits- und Sicherheitsanforderungen Ihrer Anwendungen zu erfüllen. Wir empfehlen eine Multi-AZ-Konfiguration für Produktionsworkloads. Um die Migrationsleistung zu verbessern, können Sie die [Aktivierung von Multi-AZ](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/create-multi-az-db-cluster.html) jedoch bis nach der Datenmigration verschieben. | Cloud-Administrator, Cloud-Architekt, DBA, DevOps Ingenieur, AWS-Administrator | | Passen Sie die Amazon RDS-Umgebung an. | Konfigurieren Sie benutzerdefinierte [Parameter](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) und [Optionen](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithOptionGroups.html) und aktivieren Sie zusätzliche [Überwachung](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/MonitoringOverview.html). Weitere Informationen finden Sie unter [Bewährte Methoden für die Migration zu Amazon RDS for Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html). | AWS-Administrator, AWS-Systemadministrator, Cloud-Administrator, DBA, Cloud-Architekt | ### Führen Sie den Migrationstestlauf und die Anwendungstests durch | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Migrieren Sie die Daten (Probelauf). | Migrieren Sie Daten von der Oracle EE-Quelldatenbank zur Amazon RDS for Oracle SE2 Oracle-Datenbank-Instance mit dem Ansatz, der für Ihre spezifische Umgebung am besten geeignet ist. Wählen Sie eine Migrationsstrategie aus, die auf Faktoren wie Größe, Komplexität und verfügbarem Ausfallzeitfenster basiert. Verwenden Sie eine oder eine Kombination der folgenden Optionen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.html) | DBA | | Validieren Sie die Zieldatenbank. | Führen Sie nach der Migration eine Validierung von Datenbankspeicher- und Codeobjekten durch. Überprüfen Sie die Migrationsprotokolle und beheben Sie alle identifizierten Probleme. Weitere Informationen finden Sie im Leitfaden [Migration von Oracle-Datenbanken in die AWS-Cloud](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html#post-import). | DBA | | Testen Sie die Anwendungen. | Anwendungs- und Datenbankadministratoren sollten gegebenenfalls Funktions-, Leistungs- und Betriebstests durchführen. Weitere Informationen finden Sie unter [Bewährte Methoden für die Migration zu Amazon RDS for Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/best-practices.html#test-migration).Lassen Sie sich abschließend von den Beteiligten die Zustimmung zu den Testergebnissen einholen. | App-Entwickler, App-Besitzer, DBA, Migrationsingenieur, Migrationsleiter | ### Überschneiden | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Daten aus Oracle Database EE aktualisieren. | Wählen Sie einen Ansatz zur Datenaktualisierung, der auf den Anforderungen an die Anwendungsverfügbarkeit basiert. Weitere Informationen finden Sie in den Migrationsmethoden unter [Strategien für die Migration von Oracle-Datenbanken zu AWS](https://docs.aws.amazon.com/whitepapers/latest/strategies-migrating-oracle-db-to-aws/data-migration-methods.html).Beispielsweise können Sie fast keine Ausfallzeiten erreichen, indem Sie Tools wie Oracle GoldenGate oder AWS DMS mit laufender Replikation verwenden. Wenn das Ausfallzeitfenster dies zulässt, können Sie die endgültige Datenübernahme mithilfe von Offline-Methoden wie Oracle Data Pump oder Original Export-Import durchführen. | App-Besitzer, Leiter der Umstellung, DBA, Migrationsingenieur, Migrationsleiter | | Verweisen Sie Anwendungen auf die Zieldatenbankinstanz. | Aktualisieren Sie die Verbindungsparameter in Anwendungen und anderen Clients so, dass sie auf die Amazon RDS for Oracle SE2 Oracle-Datenbank verweisen. | App-Entwickler, App-Besitzer, Migrationsingenieur, Migrationsleiter, Cutover-Leiter | | Führen Sie Aktivitäten nach der Migration durch. | Führen Sie Aufgaben nach der Datenmigration durch, z. B. die Aktivierung von Multi-AZ, Datenvalidierung und andere Prüfungen. | DBA, Migrationsingenieur | | Führen Sie eine Überwachung nach der Umstellung durch. | Verwenden Sie Tools wie [Amazon CloudWatch und Amazon](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/monitoring-cloudwatch.html) [RDS Performance Insights](https://aws.amazon.com/rds/performance-insights/), um die Amazon RDS for Oracle SE2 Oracle-Datenbank zu überwachen. | App-Entwickler, App-Besitzer, AWS-Administrator, DBA, Migrationsingenieur | ## Zugehörige Ressourcen **AWS Prescriptive Guidance** + [Migration von Oracle-Datenbanken in die AWS-Cloud](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/welcome.html) (Anleitung) + [Evaluieren Sie das Downgrade von Oracle-Datenbanken auf Standard Edition 2 auf AWS (Leitfaden](https://docs.aws.amazon.com/prescriptive-guidance/latest/evaluate-downgrading-oracle-edition/welcome.html)) + [Migrieren Sie eine lokale Oracle-Datenbank zu Amazon RDS for Oracle](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.html?did=pg_card&trk=pg_card) (Muster) + [Migrieren Sie eine On-Premises-Oracle-Datenbank zu Amazon RDS für Oracle mit Oracle Data Pump](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.html?did=pg_card&trk=pg_card) (Muster) **Blog-Posts** + [Migration von Oracle-Datenbanken mit AWS DMS nahezu ohne Ausfallzeiten](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/) + [Analyse des Leistungsmanagements in Oracle SE mit Amazon RDS for Oracle](https://aws.amazon.com/blogs/database/analyzing-performance-management-in-oracle-se-using-amazon-rds-for-oracle/) + [Verwaltung Ihres SQL-Plans in Oracle SE mit Amazon RDS for Oracle](https://aws.amazon.com/blogs/database/managing-your-sql-plan-in-oracle-se-with-amazon-rds-for-oracle/) + [Implementierung der Tabellenpartitionierung in Oracle Standard Edition: Teil 1](https://aws.amazon.com/blogs/database/implementing-table-partitioning-in-oracle-standard-edition-part-1/) # Replizieren Sie Mainframe-Datenbanken mithilfe von Precisely Connect nach AWS *Lucio Pereira, Sayantan Giri und Balaji Mohan, Amazon Web Services* ## Zusammenfassung Dieses Muster beschreibt die Schritte zur Replikation von Daten aus Mainframe-Datenbanken in Amazon-Datenspeicher nahezu in Echtzeit mithilfe von Precisely Connect. Es implementiert eine ereignisbasierte Architektur mit Amazon Managed Streaming for Apache Kafka (Amazon MSK) und benutzerdefinierten Datenbank-Konnektoren in der Cloud, um Skalierbarkeit, Belastbarkeit und Leistung zu verbessern. Precisely Connect ist ein Replikationstool, das Daten von älteren Mainframe-Systemen erfasst und in Cloud-Umgebungen integriert. Daten werden durch Change Data Capture (CDC) von Mainframes auf AWS repliziert, wobei Nachrichtenflüsse nahezu in Echtzeit mit heterogenen Datenpipelines mit niedriger Latenz und hohem Durchsatz verwendet werden. Dieses Muster deckt auch eine Notfallwiederherstellungsstrategie für belastbare Datenpipelines mit Datenreplikation und Failover-Routing in mehreren Regionen ab. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Eine bestehende Mainframe-Datenbank — z. B. IBM DB2, IBM Information Management System (IMS) oder Virtual Storage Access Method (VSAM) —, die Sie in die AWS-Cloud replizieren möchten + Ein aktives [AWS-Konto](https://aws.amazon.com/account/) + [AWS Direct Connect](https://aws.amazon.com/directconnect/) oder [AWS Virtual Private Network (AWS VPN](https://aws.amazon.com/vpn/)) von Ihrer Unternehmensumgebung zu AWS + Eine [virtuelle private Cloud](https://aws.amazon.com/vpc/) mit einem Subnetz, das über Ihre Legacy-Plattform erreichbar ist ## Architektur **Quelltechnologie-Stack** Eine Mainframe-Umgebung, die mindestens eine der folgenden Datenbanken umfasst: + IBM IMS-Datenbank + DB2 IBM-Datenbank + VSAM-Dateien **Zieltechnologie-Stack** + Amazon MSK + Amazon Elastic Kubernetes Service (Amazon EKS) und Amazon EKS Anywhere + Docker + Eine relationale AWS-Datenbank oder NoSQL-Datenbank wie die folgende: + Amazon DynamoDB + Amazon Relational Database Service (Amazon RDS) für Oracle, Amazon RDS for PostgreSQL oder Amazon Aurora + Amazon ElastiCache für Redis + Amazon Keyspaces (für Apache Cassandra) **Zielarchitektur** *Replizieren von Mainframe-Daten in AWS-Datenbanken* Das folgende Diagramm veranschaulicht die Replikation von Mainframe-Daten in eine AWS-Datenbank wie DynamoDB, Amazon RDS, Amazon oder Amazon ElastiCache Keyspaces. Die Replikation erfolgt nahezu in Echtzeit, indem Sie Precisely Capture and Publisher in Ihrer lokalen Mainframe-Umgebung, Precisely Dispatcher auf Amazon EKS Anywhere in Ihrer lokalen verteilten Umgebung und Precisely Apply Engine und Datenbank-Konnektoren in der AWS-Cloud verwenden. ![\[Replizieren von Mainframe-Daten in AWS-Datenbanken\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/777dd7da-48ed-4510-b8fa-9041be042671.png) Das Diagramm zeigt den folgenden Workflow: 1. Precisiely Capture ruft Mainframe-Daten aus CDC-Protokollen ab und verwaltet die Daten im internen Transientenspeicher. 1. Precisely Publisher überwacht Änderungen im internen Datenspeicher und sendet CDC-Datensätze über eine Verbindung an Precisely Dispatcher. TCP/IP 1. Precisely Dispatcher empfängt die CDC-Datensätze von Publisher und sendet sie an Amazon MSK. Der Dispatcher erstellt Kafka-Schlüssel auf der Grundlage der Benutzerkonfiguration und mehrerer Worker-Tasks, um Daten parallel zu übertragen. Der Dispatcher sendet eine Bestätigung an Publisher zurück, wenn Datensätze in Amazon MSK gespeichert wurden. 1. Amazon MSK speichert die CDC-Aufzeichnungen in der Cloud-Umgebung. Die Partitionsgröße der Themen hängt von den Durchsatzanforderungen Ihres Transaktionsverarbeitungssystems (TPS) ab. Der Kafka-Schlüssel ist für die weitere Transformation und die Reihenfolge der Transaktionen erforderlich. 1. Die Precisely Apply Engine hört sich die CDC-Datensätze von Amazon MSK an und transformiert die Daten (z. B. durch Filtern oder Zuordnen) basierend auf den Anforderungen der Zieldatenbank. Sie können den Precisely SQD-Skripts benutzerdefinierte Logik hinzufügen. (SQD ist die eigene Sprache von Precisely.) Die Precisely Apply Engine wandelt jeden CDC-Datensatz in das Apache Avro- oder JSON-Format um und verteilt ihn je nach Ihren Anforderungen an verschiedene Themen. 1. Die Ziel-Kafka-Themen enthalten CDC-Datensätze in mehreren Themen, die auf der Zieldatenbank basieren, und Kafka erleichtert die Transaktionsreihenfolge auf der Grundlage des definierten Kafka-Schlüssels. Die Partitionsschlüssel sind auf die entsprechenden Partitionen abgestimmt, um einen sequentiellen Prozess zu unterstützen. 1. Datenbank-Connectors (maßgeschneiderte Java-Anwendungen) hören die CDC-Datensätze von Amazon MSK ab und speichern sie in der Zieldatenbank. 1. Sie können eine Zieldatenbank entsprechend Ihren Anforderungen auswählen. Dieses Muster unterstützt sowohl NoSQL- als auch relationale Datenbanken. *Wiederherstellung nach einem Notfall* Geschäftskontinuität ist der Schlüssel zum Erfolg Ihres Unternehmens. Die AWS-Cloud bietet Funktionen für Hochverfügbarkeit (HA) und Disaster Recovery (DR) und unterstützt die Failover- und Fallback-Pläne Ihres Unternehmens. Dieses Muster folgt einer active/passive DR-Strategie und bietet umfassende Leitlinien für die Implementierung einer DR-Strategie, die Ihren RTO- und RPO-Anforderungen entspricht. Das folgende Diagramm veranschaulicht den DR-Workflow. ![\[Disaster Recovery-Workflow für die Replikation von Mainframe-Daten auf AWS\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/9cccba7a-7a25-411e-829f-7cd5a7a20ab4.png) Das Diagramm zeigt Folgendes: 1. Ein halbautomatisches Failover ist erforderlich, falls in AWS-Region 1 ein Fehler auftritt. Im Falle eines Fehlers in Region 1 muss das System Routing-Änderungen einleiten, um den Precisely Dispatcher mit Region 2 zu verbinden. 1. Amazon MSK repliziert Daten durch Spiegelung zwischen Regionen. Aus diesem Grund muss der Amazon MSK-Cluster in Region 2 während eines Failovers als primärer Leader befördert werden. 1. Die Precisely Apply Engine und die Datenbank-Konnektoren sind zustandslose Anwendungen, die in jeder Region funktionieren können. 1. Die Datenbanksynchronisierung hängt von der Zieldatenbank ab. DynamoDB kann beispielsweise globale Tabellen und globale ElastiCache Datenspeicher verwenden. *Verarbeitung mit niedriger Latenz und hohem Durchsatz durch Datenbankkonnektoren* Datenbankkonnektoren sind wichtige Komponenten dieses Musters. Connectors verfolgen einen Listener-basierten Ansatz, um Daten von Amazon MSK zu sammeln und Transaktionen durch Verarbeitung mit hohem Durchsatz und niedriger Latenz für unternehmenskritische Anwendungen (Stufen 0 und 1) an die Datenbank zu senden. Das folgende Diagramm veranschaulicht diesen Prozess. ![\[Verwenden von Datenbank-Konnektoren zur Replikation von Mainframe-Daten auf AWS\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/17ac53b7-86d5-4a8c-a55f-56b6338a1af3/images/79479634-becb-4212-bbfc-1a3b17ae1bed.png) Dieses Muster unterstützt die Entwicklung einer maßgeschneiderten Anwendung mit Single-Thread-Nutzung über eine Multithread-Verarbeitungs-Engine. 1. Der Haupt-Thread des Connectors verwendet CDC-Datensätze von Amazon MSK und sendet sie zur Verarbeitung an den Thread-Pool. 1. Threads aus dem Thread-Pool verarbeiten CDC-Datensätze und senden sie an die Zieldatenbank. 1. Wenn alle Threads ausgelastet sind, werden die CDC-Einträge von der Thread-Warteschlange in der Warteschleife gehalten. 1. Der Haupt-Thread wartet darauf, dass alle Datensätze aus der Thread-Warteschlange gelöscht werden, und überträgt Offsets in Amazon MSK. 1. Die untergeordneten Threads behandeln Fehler. Wenn bei der Verarbeitung Fehler auftreten, werden die fehlgeschlagenen Nachrichten an das Thema DLQ (Dead Letter Queue) gesendet. 1. Die untergeordneten Threads initiieren bedingte Aktualisierungen (siehe [Bedingungsausdrücke](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html) in der DynamoDB-Dokumentation) auf der Grundlage des Mainframe-Zeitstempels, um Duplikate oder out-of-order Aktualisierungen in der Datenbank zu vermeiden. Informationen zur Implementierung einer Kafka-Consumer-Anwendung mit [Multithreading-Funktionen finden Sie im Blogbeitrag Multi-Threading Message Consumption with the Apache Kafka Consumer auf der Confluent-Website](https://www.confluent.io/blog/kafka-consumer-multi-threaded-messaging/). ## Tools **AWS-Services** + [Amazon Managed Streaming for Apache Kafka (Amazon MSK)](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) ist ein vollständig verwalteter Service, der Sie beim Erstellen und Ausführen von Anwendungen unterstützt, die Apache Kafka zur Verarbeitung von Streaming-Daten verwenden. + [Amazon Elastic Kubernetes Service (Amazon EKS)](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) hilft Ihnen, Kubernetes auf AWS auszuführen, ohne Ihre eigene Kubernetes-Steuerebene oder Knoten installieren oder verwalten zu müssen. + [Amazon EKS Anywhere](https://anywhere.eks.amazonaws.com/docs/) unterstützt Sie bei der Bereitstellung, Verwendung und Verwaltung von Kubernetes-Clustern, die in Ihren eigenen Rechenzentren ausgeführt werden. + [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) ist ein vollständig verwalteter NoSQL-Datenbank-Service, der schnelle und planbare Leistung mit nahtloser Skalierbarkeit bereitstellt. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Datenbank in der AWS-Cloud. + [Amazon ElastiCache](https://docs.aws.amazon.com/elasticache/) unterstützt Sie bei der Einrichtung, Verwaltung und Skalierung verteilter In-Memory-Cache-Umgebungen in der AWS-Cloud. + [Amazon Keyspaces (für Apache Cassandra)](https://docs.aws.amazon.com/keyspaces/latest/devguide/what-is-keyspaces.html) ist ein verwalteter Datenbankservice, der Sie bei der Migration, Ausführung und Skalierung Ihrer Cassandra-Workloads in der AWS-Cloud unterstützt. **Andere Tools** + [Precisely Connect](https://www.precisely.com/product/precisely-connect/connect) integriert Daten aus älteren Mainframe-Systemen wie VSAM-Datensätzen oder IBM Mainframe-Datenbanken in Cloud- und Datenplattformen der nächsten Generation. ## Best Practices + Finden Sie die beste Kombination aus Kafka-Partitionen und Multithread-Konnektoren, um ein optimales Verhältnis von Leistung und Kosten zu erzielen. Mehrere Precisely Capture- und Dispatcher-Instanzen können aufgrund des höheren MIPS-Verbrauchs (Millionen Befehle pro Sekunde) die Kosten in die Höhe treiben. + Vermeiden Sie es, den Datenbankkonnektoren Datenmanipulations- und Transformationslogik hinzuzufügen. Verwenden Sie zu diesem Zweck die Precisely Apply Engine, die Verarbeitungszeiten in Mikrosekunden angibt. + Erstellen Sie in Datenbank-Konnektoren regelmäßige Anfragen oder Integritätsprüfungen an die Datenbank (*Heartbeats*), um die Verbindung häufig aufzuwärmen und die Latenz zu reduzieren. + Implementieren Sie die Threadpool-Validierungslogik, um die ausstehenden Aufgaben in der Thread-Warteschlange zu verstehen und warten Sie, bis alle Threads abgeschlossen sind, bevor Sie die nächste Kafka-Abfrage durchführen. Auf diese Weise können Datenverluste vermieden werden, wenn ein Knoten, ein Container oder ein Prozess abstürzt. + Stellen Sie Latenzmetriken über Integritätsendpunkte zur Verfügung, um die Beobachtbarkeit mithilfe von Dashboards und Nachverfolgungsmechanismen zu verbessern. ## Epen ### Bereiten Sie die Quellumgebung vor (vor Ort) | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Richten Sie den Mainframe-Prozess (Batch- oder Online-Utility) ein, um den CDC-Prozess von Mainframe-Datenbanken aus zu starten. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Mainframe-Ingenieur | | Aktivieren Sie die Logstreams der Mainframe-Datenbank. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Spezialist für Mainframe-Datenbanken | | Verwenden Sie die Capture-Komponente, um CDC-Datensätze zu erfassen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Mainframe-Ingenieur, Precisely Connect SME | | Konfigurieren Sie die Publisher-Komponente so, dass sie die Capture-Komponente abhört. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Mainframe-Ingenieur, Precisely Connect SME | | Stellen Sie Amazon EKS Anywhere in der lokalen verteilten Umgebung bereit. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps Ingenieur | | Stellen Sie die Dispatcher-Komponente in der verteilten Umgebung bereit und konfigurieren Sie sie, um die Themen in der AWS-Cloud zu veröffentlichen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps Ingenieur, Precisely Connect SME | ### Bereiten Sie die Zielumgebung vor (AWS) | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Stellen Sie einen Amazon EKS-Cluster in der angegebenen AWS-Region bereit. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps Ingenieur, Netzwerkadministrator | | Stellen Sie einen MSK-Cluster bereit und konfigurieren Sie die entsprechenden Kafka-Themen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps Ingenieur, Netzwerkadministrator | | Konfigurieren Sie die Apply Engine-Komponente so, dass sie sich die replizierten Kafka-Themen anhört. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Precisiely Connect SME | | Stellen Sie DB-Instances in der AWS-Cloud bereit. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Dateningenieur, DevOps Ingenieur | | Konfigurieren und implementieren Sie Datenbank-Konnektoren, um sich die von der Apply Engine veröffentlichten Themen anzuhören. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | App-Entwickler, Cloud-Architekt, Dateningenieur | ### Richten Sie Geschäftskontinuität und Disaster Recovery ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Definieren Sie Ziele für die Notfallwiederherstellung für Ihre Geschäftsanwendungen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Cloud-Architekt, Dateningenieur, App-Besitzer | | Entwerfen Sie Strategien für die Notfallwiederherstellung auf der Grundlage eines definierten RTO/RPO. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | Cloud-Architekt, Dateningenieur | | Stellen Sie Disaster Recovery-Cluster und Konfigurationen bereit. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | DevOps Ingenieur, Netzwerkadministrator, Cloud-Architekt | | Testen Sie die CDC-Pipeline für die Notfallwiederherstellung. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/replicate-mainframe-databases-to-aws-by-using-precisely-connect.html) | App-Besitzer, Dateningenieur, Cloud-Architekt | ## Zugehörige Ressourcen **AWS-Ressourcen** + [Amazon-DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) + [Bedingungsausdrücke mit Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html) + [Amazon EKS](https://docs.aws.amazon.com/eks/index.html) + [Amazon EKS Anywhere](https://anywhere.eks.amazonaws.com/docs/) + [Amazon ElasticCache](https://docs.aws.amazon.com/elasticache/index.html) + [Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/?icmpid=docs_homepage_databases) + [Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html) + [Amazon RDS und Amazon Aurora](https://docs.aws.amazon.com/rds/index.html) + [Amazon VPC](https://docs.aws.amazon.com/vpc/index.html) **Ressourcen präzise Connect** + [Precisiely Connect im Überblick](https://www.precisely.com/product/precisely-connect/connect) + [Datenerfassung ändern mit Precisely Connect](https://help.precisely.com/r/Connect-CDC-SQData/4.1/en-US/Connect-CDC-SQData-Installation/Connect-CDC-SQData-Architecture) **Konfluente Ressourcen** + [Nachrichtenverarbeitung in mehreren Threads mit dem Apache Kafka Consumer](https://www.confluent.io/blog/kafka-consumer-multi-threaded-messaging/) # Planen Sie Jobs für Amazon RDS for PostgreSQL und Aurora PostgreSQL mithilfe von Lambda und Secrets Manager *Yaser Raja, Amazon Web Services* ## Zusammenfassung Für lokale Datenbanken und Datenbanken, die auf Amazon Elastic Compute Cloud (Amazon EC2) -Instances gehostet werden, verwenden Datenbankadministratoren häufig das **Cron-Hilfsprogramm**, um Jobs zu planen. **Beispielsweise kann ein Job für die Datenextraktion oder ein Job für das Löschen von Daten einfach mit Cron geplant werden.** Für diese Jobs sind die Datenbankanmeldedaten in der Regel entweder fest codiert oder in einer Eigenschaftendatei gespeichert. **Wenn Sie jedoch zu Amazon Relational Database Service (Amazon RDS) oder Amazon Aurora PostgreSQL-Compatible Edition migrieren, verlieren Sie die Möglichkeit, sich bei der Host-Instance anzumelden, um Cron-Jobs zu planen.** Dieses Muster beschreibt, wie Jobs für Amazon RDS for PostgreSQL AWS Lambda - und AWS Secrets Manager Aurora PostgreSQL-kompatible Datenbanken nach der Migration verwendet und geplant werden. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktiver AWS-Konto + Eine Amazon RDS for PostgreSQL- oder Aurora PostgreSQL-kompatible Datenbank **Einschränkungen** + Ein Job muss innerhalb von 15 Minuten abgeschlossen sein. Dies ist das Timeout-Limit für Lambda-Funktionen. [Weitere Grenzwerte finden Sie in der AWS Lambda Dokumentation.](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) + Der Jobcode muss in einer [von Lambda unterstützten Sprache](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html) geschrieben sein. ## Architektur **Quelltechnologie-Stack** Dieser Stack enthält Jobs, die in Sprachen wie Bash, Python und Java geschrieben wurden. Datenbankanmeldedaten werden in der Eigenschaftendatei gespeichert, und der Job wird mithilfe von **Linux-Cron** geplant. **Zieltechnologie-Stack** Dieser Stack hat eine Lambda-Funktion, die die in Secrets Manager gespeicherten Anmeldeinformationen verwendet, um eine Verbindung zur Datenbank herzustellen und die Aktivität auszuführen. Die Lambda-Funktion wird im geplanten Intervall mithilfe von Amazon CloudWatch Events initiiert. **Zielarchitektur** ![\[CloudWatch Ereignis, das eine Lambda-Funktion startet, die Jobs für die RDS-DB-Instance plant.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/8e0d1c90-0599-4909-a800-26a89b87f686/images/61f9ca34-9157-4565-96ba-5234d389ac2a.png) ## Tools + [Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html) bietet einen Stream von Systemereignissen, die Änderungen an AWS Ressourcen beschreiben, nahezu in Echtzeit. Mithilfe einfacher Regeln, die Sie schnell einrichten können, können Sie Ereignisse zuordnen und sie an eine oder mehrere Zielfunktionen oder Streams weiterleiten. CloudWatch Events erkennt betriebliche Änderungen, sobald sie eintreten. Es reagiert auf diese betrieblichen Änderungen und ergreift bei Bedarf Korrekturmaßnahmen, indem es Nachrichten sendet, um auf die Umgebung zu reagieren, Funktionen aktiviert, Änderungen vornimmt und Statusinformationen erfasst. **Sie können CloudWatch Ereignisse auch verwenden, um mithilfe von **Cron** - oder Rate-Ausdrücken automatisierte Aktionen zu planen, die zu bestimmten Zeiten von selbst initiiert werden.** + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Datenverarbeitungsservice, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Lambda führt Ihren Code nur bei Bedarf aus und skaliert automatisch – von einigen Anforderungen pro Tag bis zu Tausenden pro Sekunde. Sie zahlen nur für die Rechenzeit, die Sie verbrauchen. Es fallen keine Gebühren an, wenn Ihr Code nicht ausgeführt wird. Mit Lambda können Sie Code für praktisch jede Art von Anwendung oder Backend-Service ohne Verwaltungsaufwand ausführen. Lambda führt Ihren Code auf einer hochverfügbaren Recheninfrastruktur aus und verwaltet alle Rechenressourcen, einschließlich Server- und Betriebssystemwartung, Kapazitätsbereitstellung und automatische Skalierung, Codeüberwachung und Protokollierung. Sie müssen lediglich Ihren Code in einer der [Sprachen bereitstellen, die Lambda unterstützt](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)hilft Ihnen dabei, Geheimnisse für den Zugriff auf Ihre Anwendungen, Dienste und IT-Ressourcen zu schützen. Sie können Datenbankanmeldedaten, API-Schlüssel und andere Geheimnisse während ihres gesamten Lebenszyklus problemlos rotieren, verwalten und abrufen. Benutzer und Anwendungen rufen Geheimnisse ab, indem sie Secrets Manager aufrufen. Dadurch entfällt die Notwendigkeit APIs, vertrauliche Informationen im Klartext fest zu codieren. Secrets Manager bietet geheime Rotation mit integrierter Integration für Amazon RDS, Amazon Redshift und Amazon DocumentDB. Der Service ist auf andere Arten von Geheimnissen erweiterbar, einschließlich API-Schlüsseln und Tokens. OAuth Secrets Manager ermöglicht es Ihnen, den Zugriff auf geheime Daten mithilfe detaillierter Berechtigungen zu kontrollieren und die Rotation von Geheimnissen zentral für Ressourcen in den AWS Cloud Diensten von Drittanbietern und vor Ort zu überwachen. ## Epen ### Speichern Sie Datenbankanmeldedaten in Secrets Manager | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie einen Datenbankbenutzer für die Lambda-Funktion. | Es empfiehlt sich, separate Datenbankbenutzer für verschiedene Teile Ihrer Anwendung zu verwenden. Wenn für Ihre Cron-Jobs bereits ein separater Datenbankbenutzer existiert, verwenden Sie diesen. Andernfalls erstellen Sie einen neuen Datenbankbenutzer. Weitere Informationen finden Sie unter [PostgreSQL-Benutzer und -Rollen verwalten](https://aws.amazon.com/blogs/database/managing-postgresql-users-and-roles/) (AWS Blogbeitrag). | DBA | | Speichern Sie Datenbankanmeldedaten als geheim in Secrets Manager. | Folgen Sie den Anweisungen unter [Create a database secret (Secrets](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_database_secret.html) Manager-Dokumentation). | DBA, DevOps | ### Verfassen Sie den Code für die Lambda-Funktion | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Wählen Sie eine von Lambda unterstützte Programmiersprache. | Eine Liste der unterstützten Sprachen finden Sie unter [Lambda-Laufzeiten](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html) (Lambda-Dokumentation). | Developer | | Schreiben Sie die Logik zum Abrufen der Datenbankanmeldedaten von Secrets Manager. | Beispielcode finden Sie unter [So stellen Sie Datenbankanmeldedaten sicher für Lambda-Funktionen bereit, indem Sie AWS Secrets Manager(AWS Blogbeitrag) verwenden](https://aws.amazon.com/blogs/security/how-to-securely-provide-database-credentials-to-lambda-functions-by-using-aws-secrets-manager/). | Developer | | Schreiben Sie die Logik zur Ausführung der geplanten Datenbankaktivität. | Migrieren Sie Ihren vorhandenen Code für den Scheduling-Job, den Sie vor Ort verwenden, auf die Lambda-Funktion. Weitere Informationen finden Sie unter [Deployment von Lambda-Funktionen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-deploy-functions.html) (Lambda-Dokumentation). | Developer | ### Stellen Sie den Code bereit und erstellen Sie die Lambda-Funktion | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie das Lambda-Funktionsbereitstellungspaket. | Dieses Paket enthält den Code und seine Abhängigkeiten. Weitere Informationen finden Sie unter [Bereitstellungspakete](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) (Lambda-Dokumentation). | Developer | | So erstellen Sie die Lambda-Funktion: | Wählen Sie in der Lambda-Konsole **Create function** aus, geben Sie einen Funktionsnamen ein, wählen Sie die Laufzeitumgebung aus und wählen Sie dann **Create function** aus. | DevOps | | Laden Sie das Bereitstellungspaket hoch. | Wählen Sie die Lambda-Funktion aus, die Sie erstellt haben, um ihre Konfiguration zu öffnen. Sie können Ihren Code direkt in den Codebereich schreiben oder Ihr Bereitstellungspaket hochladen. Um Ihr Paket hochzuladen, gehen Sie zum Abschnitt **Funktionscode**, wählen Sie den **Eintragstyp Code** aus, um eine ZIP-Datei hochzuladen, und wählen Sie dann das Paket aus. | DevOps | | Konfigurieren Sie die Lambda-Funktion gemäß Ihren Anforderungen. | Sie können beispielsweise den **Timeout-Parameter** auf die Dauer festlegen, die Ihre Lambda-Funktion voraussichtlich dauern wird. Weitere Informationen finden Sie unter [Konfiguration von Funktionsoptionen](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-common.html) (Lambda-Dokumentation). | DevOps | | Legen Sie die Berechtigungen für die Lambda-Funktionsrolle für den Zugriff auf Secrets Manager fest. | Anweisungen finden Sie unter [Verwenden von Geheimnissen in AWS Lambda Funktionen](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets_lambda.html) (Secrets Manager Manager-Dokumentation). | DevOps | | Testen Sie die Lambda-Funktion. | Initiieren Sie die Lambda-Funktion manuell, um sicherzustellen, dass sie wie erwartet funktioniert. | DevOps | ### Planen Sie die Lambda-Funktion mithilfe von Ereignissen CloudWatch | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Regel, damit die Lambda-Funktion nach einem Zeitplan ausgeführt wird. | Planen Sie die Lambda-Funktion mithilfe von CloudWatch Events. Anweisungen finden Sie unter [Lambda-Funktionen mithilfe von CloudWatch Ereignissen planen (CloudWatch Events-Tutorial](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/RunLambdaSchedule.html)). | DevOps | ## Zugehörige Ressourcen + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) + [Erste Schritte mit Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) + [Eine CloudWatch Ereignisregel erstellen, die bei einem Ereignis ausgelöst wird](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-Rule.html) + [AWS Lambda Beschränkungen](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) + [Fragen Sie Ihre AWS Datenbank von Ihrer serverlosen Anwendung](https://aws.amazon.com/blogs/database/query-your-aws-database-from-your-serverless-application/) aus ab (Blogbeitrag) # Senden Sie Benachrichtigungen für eine Amazon RDS for SQL Server Server-Datenbank-Instance mithilfe eines lokalen SMTP-Servers und Datenbank-E-Mail *Nishad Mankar, Amazon Web Services* ## Zusammenfassung [Datenbank-E-Mail](https://learn.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail?view=sql-server-ver16) (Microsoft-Dokumentation) sendet E-Mail-Nachrichten, wie Benachrichtigungen oder Warnungen, aus einer Microsoft SQL Server-Datenbank mithilfe eines SMTP-Servers (Simple Mail Transfer Protocol). Die Dokumentation zu Amazon Relational Database Service (Amazon RDS) für Microsoft SQL Server enthält Anweisungen zur Verwendung von Amazon Simple Email Service (Amazon SES) als SMTP-Server für Datenbank-Mail. Weitere Informationen finden Sie unter [Using Database Mail on Amazon RDS für SQL Server (Verwenden von Database Mail auf Amazon RDS für SQL Server)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html). Als alternative Konfiguration erklärt dieses Muster, wie Database Mail so konfiguriert wird, dass E-Mails von einer Amazon RDS for SQL Server Server-Datenbank-Instance (DB) gesendet werden, indem ein lokaler SMTP-Server als Mail-Server verwendet wird. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktives AWS-Konto + Eine Amazon RDS-DB-Instance, auf der eine Standard- oder Enterprise Edition von SQL Server ausgeführt wird + Die IP-Adresse oder der Hostname des lokalen SMTP-Servers + Eine [Sicherheitsgruppenregel](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html#working-with-security-group-rules) für eingehenden Datenverkehr, die Verbindungen mit der Amazon RDS for SQL Server-DB-Instance von der IP-Adresse des SMTP-Servers aus ermöglicht + Eine Verbindung, z. B. eine [AWS Direct Connect Connect-Verbindung](https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html), zwischen Ihrem lokalen Netzwerk und der Virtual Private Cloud (VPC), die die Amazon RDS-DB-Instance enthält **Einschränkungen** + Express-Editionen von SQL Server werden nicht unterstützt. + Weitere Informationen zu Einschränkungen finden Sie unter [Einschränkungen](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.FeatureSupport.Limits) bei der *Verwendung von Datenbank-Mail auf Amazon RDS for SQL Server* in der Amazon RDS-Dokumentation. **Produktversionen** + Standard- und Enterprise-Editionen der [SQL Server-Versionen, die in RDS unterstützt werden](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html#SQLServer.Concepts.General.VersionSupport) ## Architektur **Zieltechnologie-Stack** + Amazon RDS for SQL Server Server-Datenbank-Instance + Amazon Route 53 53-Weiterleitungsregel + Datenbank-E-Mail + Lokaler SMTP-Server + Microsoft SQL Server Management Studio (SSMS) **Zielarchitektur** Die folgende Abbildung zeigt die Zielarchitektur für dieses Muster. Wenn ein Ereignis oder eine Aktion eintritt, die eine Benachrichtigung oder Warnung bezüglich der Datenbank-Instance auslöst, verwendet Amazon RDS for SQL Server Database Mail, um eine E-Mail-Benachrichtigung zu senden. Database Mail verwendet den lokalen SMTP-Server, um die E-Mail zu senden. ![\[Amazon RDS for SQL Server verwendet einen lokalen SMTP-Server, um E-Mail-Benachrichtigungen an Benutzer zu senden.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/e5599724-43cf-4fe1-8c5a-8fca1a424993/images/47efb12f-3505-4a60-ac43-194a176e71c8.png) ## Tools **AWS-Services** + [Amazon Relational Database Service (Amazon RDS) für Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SQLServer.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen SQL Server-Datenbank in der AWS-Cloud. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) ist ein hochverfügbarer und skalierbarer DNS-Web-Service. **Andere Tools** + [Datenbank-E-Mail](https://learn.microsoft.com/en-us/sql/relational-databases/database-mail/database-mail) ist ein Tool, das E-Mail-Nachrichten, wie Benachrichtigungen und Warnungen, von der SQL Server Database Engine (Datenbankmodul) an Benutzer sendet. + [Microsoft SQL Server Management Studio (SSMS)](https://docs.microsoft.com/en-us/sql/ssms/sql-server-management-studio-ssms) ist ein Tool für die Verwaltung von SQL Server, einschließlich des Zugriffs auf, der Konfiguration und der Verwaltung von SQL Server-Komponenten. In diesem Muster verwenden Sie SSMS, um die SQL-Befehle auszuführen, um Database Mail auf einer Amazon RDS for SQL Server-DB-Instance einzurichten. ## Epen ### Aktivieren Sie die Netzwerkkonnektivität mit dem lokalen SMTP-Server | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Entfernen Sie Multi-AZ aus der RDS-DB-Instance. | Wenn Sie eine Multi-Zone-RDS-DB-Instance verwenden, konvertieren Sie die Multi-AZ-Instance in eine Single-AZ-Instance. Wenn Sie mit der Konfiguration von Database Mail fertig sind, konvertieren Sie die DB-Instance wieder in eine Multi-AZ-Bereitstellung. Die Database Mail-Konfiguration funktioniert dann sowohl im primären als auch im sekundären Knoten. Anweisungen finden Sie unter [Multi-AZ aus einer Microsoft SQL Server-DB-Instance entfernen](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerMultiAZ.html#USER_SQLServerMultiAZ.Removing). | DBA | | Erstellen Sie eine Zulassungsliste für den Amazon RDS-Endpunkt oder die IP-Adresse auf dem lokalen SMTP-Server. | Der SMTP-Server befindet sich außerhalb des AWS-Netzwerks. Erstellen Sie auf dem lokalen SMTP-Server eine Zulassungsliste, die es dem Server ermöglicht, mit dem ausgehenden Endpunkt oder der IP-Adresse für die Amazon RDS-Instance oder die Amazon Elastic Compute Cloud (Amazon EC2) -Instance zu kommunizieren, die auf Amazon RDS gehostet wird. Dieses Verfahren ist von Organisation zu Organisation unterschiedlich. Weitere Informationen zum DB-Instance-Endpunkt [finden Sie unter Finden des DB-Instance-Endpunkts und der Portnummer](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html#sqlserver-endpoint). | DBA | | Entfernen Sie die Einschränkungen für Port 25. | Standardmäßig schränkt AWS Port 25 für EC2 Instances ein. Gehen Sie wie folgt vor, um die Beschränkung auf Port 25 aufzuheben:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html) | Allgemeines AWS | | Fügen Sie eine Route 53 53-Regel hinzu, um DNS-Abfragen für den SMTP-Server aufzulösen. | Verwenden Sie Route 53, um DNS-Abfragen zwischen Ihren AWS-Ressourcen und dem lokalen SMTP-Server zu lösen. Sie müssen eine Regel erstellen, die die DNS-Abfragen an die SMTP-Serverdomäne weiterleitet, z. B. `example.com` Anweisungen finden Sie in der Route 53 53-Dokumentation unter [Erstellen von Weiterleitungsregeln](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-rules-managing.html#resolver-rules-managing-creating-rules). | Netzwerkadministrator | ### Datenbank-E-Mail auf der Amazon RDS for SQL Server-DB-Instance einrichten | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Datenbank-E-Mail aktivieren. | Erstellen Sie eine Parametergruppe für Datenbank-E-Mail, legen Sie den `database mail xps` Parameter auf fest`1`, und ordnen Sie dann die Datenbank-E-Mail-Parametergruppe der Ziel-RDS-DB-Instance zu. Anweisungen finden Sie unter [Enabling Database Mail](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html#SQLServer.DBMail.Enable) in der Amazon RDS-Dokumentation. Fahren Sie in dieser Anleitung nicht mit dem Abschnitt *Konfiguration von Datenbank-Mail* fort. Die Konfiguration für den lokalen SMTP-Server unterscheidet sich von der von Amazon SES. | DBA | | Stellen Sie eine Verbindung mit der DB-Instance her. | Verwenden Sie von einem Bastion-Host aus Microsoft SQL Server Management Studio (SSMS), um eine Verbindung zur Amazon RDS for SQL Server Server-Datenbank-Instance herzustellen. Anweisungen finden Sie unter [Verbindung zu einer DB-Instance herstellen, auf der die Microsoft SQL Server-Datenbank-Engine ausgeführt wird](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html). Falls Sie auf Fehler stoßen, finden Sie im Abschnitt [Verwandte Ressourcen](#send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail-resources) die Hinweise zur Fehlerbehebung bei Verbindungen. | DBA | | Erstellen Sie das Profil. | Geben Sie in SSMS die folgende SQL-Anweisung ein, um das Datenbank-E-Mail-Profil zu erstellen. Ersetzen Sie die folgenden Werte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Weitere Informationen zu dieser gespeicherten Prozedur und ihren Argumenten finden Sie in der Microsoft-Dokumentation unter [sysmail\$1add\$1profile\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql).
EXECUTE msdb.dbo.sysmail_add_profile_sp| DBA | | Fügen Sie dem Profil Principals hinzu. | Geben Sie die folgende SQL-Anweisung ein, um dem Datenbank-E-Mail-Profil öffentliche oder private Prinzipale hinzuzufügen. Ein *Prinzipal* ist eine Entität, die SQL Server-Ressourcen anfordern kann. Ersetzen Sie die folgenden Werte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Weitere Informationen zu dieser gespeicherten Prozedur und ihren Argumenten finden Sie in der Microsoft-Dokumentation unter [sysmail\$1add\$1principalprofile\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-principalprofile-sp-transact-sql).
@profile_name = 'SQL Alerts profile',
@description = 'Profile used for sending outgoing notifications using OM SMTP Server.';
EXECUTE msdb.dbo.sysmail_add_principalprofile_sp| DBA | | Erstellen Sie das Konto. | Geben Sie die folgende SQL-Anweisung ein, um das Datenbank-E-Mail-Konto zu erstellen. Ersetzen Sie die folgenden Werte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Weitere Informationen zu dieser gespeicherten Prozedur und ihren Argumenten finden Sie in der Microsoft-Dokumentation unter [sysmail\$1add\$1account\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql).
@profile_name = 'SQL Alerts profile',
@principal_name = 'public',
@is_default = 1 ;
EXECUTE msdb.dbo.sysmail_add_account_sp| DBA | | Fügen Sie das Konto dem Profil hinzu. | Geben Sie die folgende SQL-Anweisung ein, um das Datenbank-E-Mail-Konto zum Datenbank-E-Mail-Profil hinzuzufügen. Ersetzen Sie die folgenden Werte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.html)Weitere Informationen zu dieser gespeicherten Prozedur und ihren Argumenten finden Sie in der Microsoft-Dokumentation unter [sysmail\$1add\$1profileaccount\$1sp](https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql).
@account_name = 'SQL Alerts account',
@description = 'Database Mail account for sending outgoing notifications.',
@email_address = 'xyz@example.com',
@display_name = 'xyz@example.com',
@mailserver_name = 'test_smtp.example.com',
@port = 25,
@enable_ssl = 1,
@username = 'SMTP-username',
@password = 'SMTP-password';
EXECUTE msdb.dbo.sysmail_add_profileaccount_sp| DBA | | (Optional) Fügen Sie Multi-AZ zur RDS-DB-Instance hinzu. | Wenn Sie Multi-AZ mit Datenbankspiegelung (DBM) oder AlwaysOn-Verfügbarkeitsgruppen (AGs) hinzufügen möchten, lesen Sie die Anweisungen unter [Hinzufügen von Multi-AZ zu einer Microsoft SQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_SQLServerMultiAZ.html#USER_SQLServerMultiAZ.Adding) Server-DB-Instance. | DBA | ## Zugehörige Ressourcen + [Verwenden von Database Mail auf Amazon RDS for SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html) (Amazon RDS-Dokumentation) + [Arbeiten mit Dateianhängen](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.DBMail.html#SQLServer.DBMail.MAZ) (Amazon RDS-Dokumentation) + [Problembehandlung bei Verbindungen zu Ihrer SQL Server-DB-Instance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToMicrosoftSQLServerInstance.html#USER_ConnectToMicrosoftSQLServerInstance.Troubleshooting) (Amazon RDS-Dokumentation) + [Es kann keine Verbindung zur Amazon RDS-DB-Instance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Troubleshooting.html#CHAP_Troubleshooting.Connecting) hergestellt werden (Amazon RDS-Dokumentation) # Disaster Recovery für SAP auf IBM Db2 auf AWS einrichten *Ambarish Satarkar und Debasis Sahoo, Amazon Web Services* ## Zusammenfassung Dieses Muster beschreibt die Schritte zur Einrichtung eines Disaster Recovery-Systems (DR) für SAP-Workloads mit IBM Db2 als Datenbankplattform, das in der Amazon Web Services (AWS) Cloud ausgeführt wird. Ziel ist die Bereitstellung einer kostengünstigen Lösung zur Gewährleistung der Geschäftskontinuität im Falle eines Ausfalls. Das Muster verwendet den [Pilotlampenansatz](https://aws.amazon.com/blogs/architecture/disaster-recovery-dr-architecture-on-aws-part-iii-pilot-light-and-warm-standby/). Durch die Implementierung von Pilot Light DR auf AWS können Sie Ausfallzeiten reduzieren und die Geschäftskontinuität aufrechterhalten. Der Pilot-Light-Ansatz konzentriert sich auf die Einrichtung einer minimalen DR-Umgebung in AWS, einschließlich eines SAP-Systems und einer Standby-Db2-Datenbank, die mit der Produktionsumgebung synchronisiert ist. Diese Lösung ist skalierbar. Sie können sie nach Bedarf auf eine umfassende Notfallwiederherstellungsumgebung erweitern. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Eine SAP-Instance, die auf einer Amazon Elastic Compute Cloud (Amazon EC2) -Instance läuft + Eine IBM Db2-Datenbank + Ein Betriebssystem, das von der SAP Product Availability Matrix (PAM) unterstützt wird + Verschiedene physische Datenbank-Hostnamen für Produktions- und Standby-Datenbank-Hosts + Ein Amazon Simple Storage Service (Amazon S3) -Bucket in jeder AWS-Region mit aktivierter [regionsübergreifender Replikation (CRR](https://docs.aws.amazon.com/AmazonS3/latest/userguide/replication.html)) **Produktversionen** + IBM Db2-Datenbank Version 11.5.7 oder höher ## Architektur **Zieltechnologie-Stack** + Amazon EC2 + Amazon Simple Storage Service (Amazon-S3) + Amazon Virtual Private Cloud (VPC-Peering) + Amazon Route 53 + IBM Db2 Disaster Recovery (HADR) mit hoher Verfügbarkeit **Zielarchitektur** Diese Architektur implementiert eine DR-Lösung für SAP-Workloads mit Db2 als Datenbankplattform. Die Produktionsdatenbank wird in AWS-Region 1 bereitgestellt und eine Standby-Datenbank wird in einer zweiten Region bereitgestellt. Die Standby-Datenbank wird als DR-System bezeichnet. Db2-Datenbank unterstützt mehrere Standby-Datenbanken (bis zu drei). Es verwendet Db2 HADR für die Einrichtung der DR-Datenbank und die Automatisierung des Protokollversands zwischen der Produktions- und der Standby-Datenbank. Im Notfall, bei dem Region 1 nicht verfügbar ist, übernimmt die Standby-Datenbank in der DR-Region die Rolle der Produktionsdatenbank. SAP-Anwendungsserver können im Voraus oder mithilfe von [AWS Elastic Disaster Recovery](https://aws.amazon.com/disaster-recovery/) oder einem Amazon Machine Image (AMI) erstellt werden, um die RTO-Anforderungen (Recovery Time Objective) zu erfüllen. Dieses Muster verwendet ein AMI. Db2 HADR implementiert ein Produktions-Standby-Setup, bei dem die Produktion als primärer Server fungiert und alle Benutzer mit ihm verbunden sind. Alle Transaktionen werden in Protokolldateien geschrieben, die mithilfe von TCP/IP auf den Standby-Server übertragen werden. Der Standby-Server aktualisiert seine lokale Datenbank, indem er die übertragenen Protokolldatensätze weiterleitet. Dadurch wird sichergestellt, dass die Datenbank mit dem Produktionsserver synchron bleibt. VPC-Peering wird verwendet, damit Instances in der Produktionsregion und der DR-Region miteinander kommunizieren können. Amazon Route 53 leitet Endbenutzer zu Internetanwendungen weiter. ![\[Db2 auf AWS mit regionsübergreifender Replikation\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/06edfa4c-0827-4d05-95cf-2d2651e74323/images/e77c1e4e-36f3-4af4-89d0-8eec72348f0a.png) 1. [Erstellen Sie ein AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami) des Anwendungsservers in Region 1 und [kopieren Sie das AMI](https://repost.aws/knowledge-center/copy-ami-region) in Region 2. Verwenden Sie das AMI, um im Notfall Server in Region 2 zu starten. 1. Richten Sie die Db2-HADR-Replikation zwischen der Produktionsdatenbank (in Region 1) und der Standby-Datenbank (in Region 2) ein. 1. Ändern Sie im EC2 Notfall den Instanztyp so, dass er der Produktionsinstanz entspricht. 1. In Region 1 `LOGARCHMETH1` ist auf eingestellt`db2remote: S3 path`. 1. In Region 2 `LOGARCHMETH1` ist auf gesetzt`db2remote: S3 path`. 1. Die regionsübergreifende Replikation wird zwischen den S3-Buckets durchgeführt. ## Tools **AWS-Services** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/ec2/) bietet skalierbare Rechenkapazität in der AWS-Cloud. Sie können so viele virtuelle Server wie nötig nutzen und sie schnell nach oben oder unten skalieren. + [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) ist ein hochverfügbarer und skalierbarer DNS-Web-Service. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) hilft Ihnen, AWS-Ressourcen in einem von Ihnen definierten virtuellen Netzwerk zu starten. Dieses virtuelle Netzwerk ähnelt einem herkömmlichen Netzwerk, das Sie in Ihrem eigenen Rechenzentrum betreiben würden, mit den Vorteilen der skalierbaren Infrastruktur von AWS. Dieses Muster verwendet [VPC-Peering](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html). ## Best Practices + Das Netzwerk spielt eine Schlüsselrolle bei der Entscheidung über den HADR-Replikationsmodus. Für DR in allen AWS-Regionen empfehlen wir, den Modus Db2 HADR ASYNC oder SUPERASYNC zu verwenden. + [Weitere Informationen zu den Replikationsmodi für Db2 HADR finden Sie in der IBM-Dokumentation.](https://ibm.github.io/db2-hadr-wiki/hadrSyncMode.html#Description_of_the_Modes) + Sie können die AWS-Managementkonsole oder die AWS-Befehlszeilenschnittstelle (AWS CLI) verwenden, um [ein neues AMI Ihres vorhandenen SAP-Systems zu erstellen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIs.html#creating-an-ami). Anschließend können Sie das AMI verwenden, um Ihr vorhandenes SAP-System wiederherzustellen oder einen Clone zu erstellen. + [AWS Systems Manager Automation](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation.html) kann Sie bei den allgemeinen Wartungs- und Bereitstellungsaufgaben von EC2 Instances und anderen AWS-Ressourcen unterstützen. + AWS bietet mehrere native Services zur Überwachung und Verwaltung Ihrer Infrastruktur und Anwendungen auf AWS. Dienste wie Amazon CloudWatch und AWS CloudTrail können verwendet werden, um Ihre zugrunde liegende Infrastruktur bzw. API-Operationen zu überwachen. Weitere Informationen finden Sie unter [SAP on AWS — IBM Db2 HADR with](https://docs.aws.amazon.com/sap/latest/sap-AnyDB/sap-ibm-pacemaker.html) Pacemaker. ## Epen ### Bereite die Umgebung vor | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Überprüfen Sie das System und die Protokolle. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | AWS-Administrator, SAP-Basisadministrator | ### Richten Sie die Server und die Replikation ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie die SAP- und Datenbankserver. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html)Der Status „Rollforward ausstehend“ ist standardmäßig festgelegt, nachdem die vollständige Sicherung wiederhergestellt wurde. Der Status „Rollforward ausstehend“ gibt an, dass die Datenbank gerade wiederhergestellt wird und dass möglicherweise einige Änderungen übernommen werden müssen. Weitere Informationen finden Sie in der [IBM-Dokumentation](https://www.ibm.com/docs/en/db2/11.5?topic=commands-rollforward-database). | SAP-Basisadministrator | | Überprüfen Sie die Konfiguration. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | AWS-Administrator, SAP-Basisadministrator | | Richten Sie die Replikation von der Produktions-Datenbank zur DR-DB ein (im ASYNC-Modus). | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | SAP-Basisadministrator | ### Testen Sie DR-Failover-Aufgaben | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Planen Sie die Ausfallzeiten des Produktionsbetriebs für den DR-Test ein. | Stellen Sie sicher, dass Sie die erforderlichen Betriebsausfälle in der Produktionsumgebung einplanen, um das DR-Failover-Szenario zu testen. | SAP-Basisadministrator | | Erstellen Sie einen Testbenutzer. | Erstellen Sie einen Testbenutzer (oder beliebige Teständerungen), der auf dem DR-Host validiert werden kann, um die Protokollreplikation nach einem DR-Failover zu bestätigen. | SAP-Basisadministrator | | Stoppen Sie auf der Konsole die EC2 Produktionsinstanzen. | In diesem Schritt wird ein unsachgemäßes Herunterfahren eingeleitet, um ein Katastrophenszenario nachzuahmen. | AWS-Systemadministrator | | Skalieren Sie die EC2 DR-Instance entsprechend den Anforderungen. | Ändern Sie auf der EC2 Konsole den Instance-Typ in der DR-Region.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | SAP-Basis-Administrator | | Übernahme einleiten. | Initiieren Sie vom DR-System (`host2`) aus den Übernahmeprozess und rufen Sie die DR-Datenbank als primäre Datenbank auf.
@profile_name = 'SQL Alerts profile',
@account_name = 'SQL Alerts account',
@sequence_number = 1;
db2 takeover hadr on databaseOptional können Sie die folgenden Parameter festlegen, um die Speicherzuweisung der Datenbank automatisch an den Instance-Typ anzupassen. Der `INSTANCE_MEMORY` Wert kann auf der Grundlage des dedizierten Speicherbereichs festgelegt werden, der der Db2-Datenbank zugewiesen werden soll.by force
db2 update db cfg forÜberprüfen Sie die Änderung mithilfe der folgenden Befehle.using INSTANCE_MEMORY IMMEDIATE;
db2 get db cfg for| grep -i DATABASE_MEMORY AUTOMATIC IMMEDIATE;
db2 update db cfg forusing self_tuning_mem ON IMMEDIATE;
db2 get db cfg for| SAP-Basisadministrator | | Starten Sie den Anwendungsserver für SAP in der DR-Region. | [Starten Sie mithilfe des AMI, das Sie aus dem Produktionssystem erstellt haben, einen neuen zusätzlichen Anwendungsserver](https://aws.amazon.com/premiumsupport/knowledge-center/launch-instance-custom-ami/) in der DR-Region. | SAP-Basisadministrator | | Führen Sie eine Validierung durch, bevor Sie die SAP-Anwendung starten. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | AWS-Administrator, SAP-Basisadministrator | | Starten Sie die SAP-Anwendung auf dem DR-System. | Starten Sie die SAP-Anwendung auf dem DR-System mithilfe von `| grep -i MEMORY
db2 get db cfg for| grep -i self_tuning_mem
sapconrol -nr XX -function StartService| SAP-Basisadministrator | | Führen Sie die SAP-Validierung durch. | Dies wird als DR-Test durchgeführt, um Beweise zu liefern oder um den Erfolg der Datenreplikation in die DR-Region zu überprüfen. | Testingenieur | ### Führen Sie DR-Failback-Aufgaben aus | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Starten Sie die Produktions-SAP- und Datenbankserver. | Starten Sie auf der Konsole die EC2 Instanzen, die SAP und die Datenbank im Produktionssystem hosten. | SAP-Basisadministrator | | Starten Sie die Produktionsdatenbank und richten Sie HADR ein. | Melden Sie sich beim Produktionssystem (`host1`) an und stellen Sie mithilfe des folgenden Befehls sicher, dass sich die Datenbank im Wiederherstellungsmodus befindet.
sapconrol -nr XX -function StartSystem
sapconrol -nr YY -function StartService
sapconrol -nr YY -function StartSystem
db2startStellen Sie sicher, dass der HADR-Status lautet`connected`. Der Replikationsstatus sollte sein. `peer`
db2 start HADR on db P3V as standby
db2 connect to
db2pd -dWenn die Datenbank nicht inkonsistent ist und sich nicht im `connected` `peer` Status N befindet, sind möglicherweise eine Sicherung und Wiederherstellung erforderlich, um die Datenbank mit der aktuell aktiven Datenbank (`host2`in der DR-Region) zu synchronisieren (aktiviert). `host1` Stellen Sie in diesem Fall das DB-Backup aus der Datenbank in der `host2` DR-Region auf die Datenbank in der `host1` Produktionsregion wieder her. | SAP-Basisadministrator | | Führen Sie ein Failback der Datenbank auf die Produktionsregion durch. | In einem normalen business-as-usual Szenario wird dieser Schritt während einer geplanten Ausfallzeit ausgeführt. Anwendungen, die auf dem DR-System ausgeführt werden, werden gestoppt, und für die Datenbank wird ein Failback in die Produktionsregion (Region 1) durchgeführt, um den Betrieb von der Produktionsregion aus wieder aufzunehmen.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | SAP-Basisadministrator | | Führen Sie eine Validierung durch, bevor Sie die SAP-Anwendung starten. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | AWS-Administrator, SAP-Basisadministrator | | Starten Sie die SAP-Anwendung. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | SAP-Basisadministrator | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | Wichtige Protokolldateien und Befehle zur Behebung von Problemen im Zusammenhang mit HADR | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.html) | | SAP-Hinweis zur Behebung von HADR-Problemen auf Db2 UDB | Weitere Informationen finden Sie im [SAP-Hinweis 1154013 - DB6: DB-Probleme](https://service.sap.com/sap/support/notes/1154013) in der HADR-Umgebung. (Sie benötigen Anmeldeinformationen für das SAP-Portal, um auf diesen Hinweis zugreifen zu können.) | ## Zugehörige Ressourcen + [Ansätze zur Notfallwiederherstellung für Db2-Datenbanken auf AWS](https://aws.amazon.com/blogs/architecture/disaster-recovery-approaches-for-db2-databases-on-aws/) (Blogbeitrag) + [SAP on AWS — IBM Db2 HADR mit Pacemaker](https://docs.aws.amazon.com/sap/latest/sap-AnyDB/sap-ibm-pacemaker.html) + [Schrittweises Verfahren zum Einrichten der HADR-Replikation zwischen Datenbanken DB2 ](https://www.ibm.com/support/pages/step-step-procedure-set-hadr-replication-between-db2-databases) + [Db2 HADR Wiki](https://ibm.github.io/db2-hadr-wiki/index.html) ## Zusätzliche Informationen Mit diesem Muster können Sie ein Disaster-Recovery-System für ein SAP-System einrichten, das auf der Db2-Datenbank läuft. In einer Notfallsituation sollte das Geschäft in der Lage sein, die von Ihnen definierten Anforderungen an das Recovery Time Objective (RTO) und das Recovery Point Objective (RPO) einzuhalten: + **RTO** ist die maximal zulässige Verzögerung zwischen der Betriebsunterbrechung und der Wiederherstellung des Dienstes. Damit wird festgelegt, was als akzeptables Zeitfenster gilt, wenn der Service nicht verfügbar ist. + **RPO** ist die maximal zulässige Zeitspanne seit dem letzten Datenwiederherstellungspunkt. Damit wird festgelegt, was als akzeptabler Datenverlust zwischen dem letzten Wiederherstellungspunkt und der Serviceunterbrechung gilt. FAQs Weitere Informationen zu HADR finden Sie im [SAP-Hinweis \$11612105 - DB6: Häufig gestellte Fragen zu Db2 High Availability Disaster Recovery (](https://launchpad.support.sap.com/#/notes/1612105)HADR). (Sie benötigen Zugangsdaten für das SAP-Portal, um auf diesen Hinweis zugreifen zu können.) # Richten Sie mithilfe von Terraform eine CI/CD Pipeline für die Datenbankmigration ein *Dr. Rahul Sharad Gaikwad, Ashish Bhatt, Aniket Dekate, Ruchika Modi, Tamilselvan P, Nadeem Rahaman, Aarti Rajput und Naveen Suthar, Amazon Web Services* ## Zusammenfassung Bei diesem Muster geht es darum, eine CI/CD-Pipeline (Continuous Integration and Continuous Deployment) einzurichten, um Datenbankmigrationen zuverlässig und automatisiert zu verwalten. Es behandelt den Prozess der Bereitstellung der erforderlichen Infrastruktur, der Migration von Daten und der Anpassung von Schemaänderungen mithilfe von Terraform, einem Infrastructure-as-Code-Tool (IaC). Insbesondere richtet das Muster eine CI/CD Pipeline für die Migration einer lokalen Microsoft SQL Server-Datenbank zu Amazon Relational Database Service (Amazon RDS) ein. AWS Sie können dieses Muster auch verwenden, um eine SQL Server-Datenbank, die sich auf einer virtuellen Maschine (VM) oder in einer anderen Cloud-Umgebung befindet, zu Amazon RDS zu migrieren. Dieses Muster befasst sich mit den folgenden Herausforderungen im Zusammenhang mit der Datenbankverwaltung und -bereitstellung: + Manuelle Datenbankbereitstellungen sind zeitaufwändig, fehleranfällig und nicht einheitlich in allen Umgebungen. + Die Koordination von Infrastrukturbereitstellung, Datenmigrationen und Schemaänderungen kann komplex und schwierig zu verwalten sein. + Die Sicherstellung der Datenintegrität und die Minimierung von Ausfallzeiten bei Datenbankaktualisierungen sind für Produktionssysteme von entscheidender Bedeutung. Dieses Muster bietet die folgenden Vorteile: + Optimiert den Prozess der Aktualisierung und Bereitstellung von Datenbankänderungen durch die Implementierung einer CI/CD Pipeline für Datenbankmigrationen. Dadurch wird das Fehlerrisiko reduziert, die Konsistenz in allen Umgebungen gewährleistet und Ausfallzeiten minimiert. + Trägt zur Verbesserung der Zuverlässigkeit, Effizienz und Zusammenarbeit bei. Ermöglicht eine schnellere Markteinführung und geringere Ausfallzeiten bei Datenbankaktualisierungen. + Unterstützt Sie bei der Einführung moderner DevOps Methoden für das Datenbankmanagement, was zu mehr Agilität, Zuverlässigkeit und Effizienz Ihrer Softwarebereitstellungsprozesse führt. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein aktiver AWS-Konto + [Terraform 0.12 oder höher ist auf Ihrem lokalen Computer installiert (Anweisungen finden Sie in der Terraform-Dokumentation)](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli) + [Terraform AWS Provider Version 3.0.0 oder höher von HashiCorp (siehe das Repository für diesen Anbieter) GitHub ](https://github.com/hashicorp/terraform-provider-aws) + IAM-Richtlinie AWS Identity and Access Management (Least Privilege) (siehe den Blogbeitrag [Techniken zum Schreiben von IAM-Richtlinien mit den geringsten](https://aws.amazon.com/blogs/security/techniques-for-writing-least-privilege-iam-policies/) Rechten) ## Architektur Dieses Muster implementiert die folgende Architektur, die die komplette Infrastruktur für den Datenbankmigrationsprozess bereitstellt. ![\[CI/CD-Pipeline-Architektur für die Migration einer lokalen SQL Server-Datenbank zu Amazon RDS auf AWS.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/87845d9f-8e6e-4c51-b9ee-9e7833671d05/images/a1e95458-419a-4de9-85ef-b17d8340700a.png) In dieser Architektur: + Die Quelldatenbank ist eine SQL Server-Datenbank, die sich vor Ort, auf einer virtuellen Maschine (VM) befindet oder von einem anderen Cloud-Anbieter gehostet wird. Das Diagramm geht davon aus, dass sich die Quelldatenbank in einem lokalen Rechenzentrum befindet. + Das lokale Rechenzentrum und ich AWS sind über ein VPN oder AWS Direct Connect eine Verbindung verbunden. Dies ermöglicht eine sichere Kommunikation zwischen der Quelldatenbank und der AWS Infrastruktur. + Die Zieldatenbank ist eine Amazon RDS-Datenbank, die mithilfe einer Datenbankbereitstellungspipeline in der Virtual Private Cloud (VPC AWS ) gehostet wird. + AWS Database Migration Service (AWS DMS) repliziert Ihre lokale Datenbank auf. AWS Es wird verwendet, um die Replikation der Quelldatenbank in die Zieldatenbank zu konfigurieren. Das folgende Diagramm zeigt die Infrastruktur, die mit verschiedenen Ebenen des Datenbankmigrationsprozesses eingerichtet wurde, der die Bereitstellung, AWS DMS Einrichtung und Validierung umfasst. ![\[CI/CD-Pipeline-Details des Migrationsprozesses von der lokalen Infrastruktur zu AWS.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/87845d9f-8e6e-4c51-b9ee-9e7833671d05/images/3aca17e5-6fd7-4317-b578-ab5e485c6efb.png) In diesem Prozess: + Die Validierungspipeline validiert alle Prüfungen. Die integrierte Pipeline geht zum nächsten Schritt über, wenn alle erforderlichen Validierungen abgeschlossen sind. + Die DB-Bereitstellungspipeline besteht aus verschiedenen AWS CodeBuild Phasen, in denen Terraform-Aktionen für den bereitgestellten Terraform-Code für die Datenbank ausgeführt werden. Wenn diese Schritte abgeschlossen sind, werden Ressourcen im Ziel bereitgestellt. AWS-Konto + Die AWS DMS Pipeline besteht aus verschiedenen CodeBuild Phasen, in denen Tests durchgeführt und anschließend die AWS DMS Infrastruktur für die Durchführung der Migration mithilfe von IaC bereitgestellt wird. ## Tools **AWS-Services und Tools** + [AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)ist ein vollständig verwalteter Dienst für kontinuierliche Integration, der Quellcode kompiliert, Tests durchführt und ready-to-deploy Softwarepakete produziert. + [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)ist ein vollständig verwalteter Continuous Delivery-Service, der Sie bei der Automatisierung Ihrer Release-Pipelines für schnelle und zuverlässige Anwendungs- und Infrastrukturupdates unterstützt. + [Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) unterstützt Sie bei der Einrichtung, dem Betrieb und der Skalierung einer relationalen Datenbank in der. AWS Cloud + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein Objektspeicherservice, der Skalierbarkeit, Datenverfügbarkeit, Sicherheit und Leistung bietet. + [AWS Database Migration Service (AWS DMS)](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) unterstützt Sie bei der Migration von Datenspeichern in die AWS Cloud oder zwischen Kombinationen von Cloud- und lokalen Konfigurationen. **Andere Dienste** + [Terraform](https://www.terraform.io/) ist ein IaC-Tool von HashiCorp , mit dem Sie Cloud- und lokale Ressourcen erstellen und verwalten können. **Code-Repository** Der Code für dieses Muster ist im GitHub [Database Migration DevOps Framework unter Verwendung des Terraform-Beispiel-Repositorys](https://github.com/aws-samples/aws-terraform-db-migration-framework-samples) verfügbar. ## Best Practices + Implementieren Sie automatisierte Tests für Ihre Datenbankmigration, um die Richtigkeit von Schemaänderungen und die Datenintegrität zu überprüfen. Dazu gehören Komponententests, Integrationstests und end-to-end Tests. + Implementieren Sie eine robuste Sicherungs- und Wiederherstellungsstrategie für Ihre Datenbanken, insbesondere vor der Migration. Dies gewährleistet die Datenintegrität und bietet eine Ausweichoption im Falle von Ausfällen. + Implementieren Sie eine robuste Rollback-Strategie, um Datenbankänderungen rückgängig zu machen, falls während der Migration Fehler oder Probleme auftreten. Dies könnte ein Rollback zu einem früheren Datenbankstatus oder das Zurücksetzen einzelner Migrationsskripten beinhalten. + Richten Sie Überwachungs- und Protokollierungsmechanismen ein, um den Fortschritt und den Status von Datenbankmigrationen zu verfolgen. Auf diese Weise können Sie Probleme schnell identifizieren und lösen. ## Epen ### Richten Sie Ihre lokale Workstation ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Richte Git auf deiner lokalen Workstation ein und konfiguriere es. | Installieren und konfigurieren Sie Git auf Ihrer lokalen Workstation, indem Sie den Anweisungen in der [Git-Dokumentation](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) folgen. | DevOps Ingenieur | | Erstellen Sie einen Projektordner und fügen Sie die Dateien aus dem GitHub Repository hinzu. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps Ingenieur | ### Stellen Sie die Zielarchitektur bereit | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Aktualisieren Sie die erforderlichen Parameter. | In der `ssm-parameters.sh` Datei werden alle erforderlichen AWS Systems Manager Parameter gespeichert. Sie können diese Parameter mit den benutzerdefinierten Werten für Ihr Projekt konfigurieren.Öffnen Sie die `ssm-parameters.sh` Datei in dem `setup/db-ssm-params` Ordner auf Ihrer lokalen Workstation und legen Sie diese Parameter fest, bevor Sie die CI/CD Pipeline ausführen. | DevOps Ingenieur | | Initialisieren Sie die Terraform-Konfiguration. | Geben Sie im `db-cicd-integration` Ordner den folgenden Befehl ein, um Ihr Arbeitsverzeichnis zu initialisieren, das die Terraform-Konfigurationsdateien enthält:-hadr
terraform init| DevOps Ingenieur | | Sehen Sie sich eine Vorschau des Terraform-Plans an. | Geben Sie den folgenden Befehl ein, um einen Terraform-Plan zu erstellen:
terraform plan -var-file="terraform.sample"Terraform wertet die Konfigurationsdateien aus, um den Zielstatus für die deklarierten Ressourcen zu ermitteln. Anschließend wird der Zielstatus mit dem aktuellen Status verglichen und ein Plan erstellt. | DevOps Ingenieur | | Überprüfen Sie den Plan. | Überprüfen Sie den Plan und stellen Sie sicher, dass er die erforderliche Architektur in Ihrem Ziel AWS-Konto konfiguriert. | DevOps Ingenieur | | Stellen Sie die Lösung bereit. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps Ingenieur | ### Überprüfen der Bereitstellung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Validieren Sie die Bereitstellung. | Überprüfen Sie den Status der `db-cicd-integration` Pipeline, um sicherzustellen, dass die Datenbankmigration abgeschlossen ist.1. Melden Sie sich bei der an AWS-Managementkonsole, und öffnen Sie dann die [AWS CodePipeline Konsole](https://console.aws.amazon.com/codesuite/codepipeline/home).2. Wählen Sie im Navigationsbereich **Pipelines** aus.3. Wählen Sie die `db-cicd-integration` Pipeline aus.4. Stellen Sie sicher, dass die Pipeline-Ausführung erfolgreich abgeschlossen wurde. | DevOps Ingenieur | ### Reinigen Sie die Infrastruktur nach dem Gebrauch | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Säubere die Infrastruktur. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/set-up-ci-cd-pipeline-for-db-migration-with-terraform.html) | DevOps Ingenieur | ## Zugehörige Ressourcen **AWS Dokumentation** + [Erste Schritte mit einem Terraform-Produkt](https://docs.aws.amazon.com/servicecatalog/latest/adminguide/getstarted-Terraform.html) **Terraform-Dokumentation** + [Terraform-Installation](https://learn.hashicorp.com/tutorials/terraform/install-cli) + [Terraform-Backend-Konfiguration](https://developer.hashicorp.com/terraform/language/backend) + [Terraform Provider-Dokumentation AWS](https://registry.terraform.io/providers/hashicorp/aws/latest/docs) # Richten Sie einen Microsoft SQL Server-Failover-Cluster auf Amazon ein, der FSx für Windows File Server EC2 verwendet wird *Sweta Krishna und Ramesh Babu Donti, Amazon Web Services* ## Zusammenfassung Die Microsoft SQL Server Standard Edition mit einer Failoverclusterinstanz (FCI) kann eine kostengünstigere Alternative zu SQL Server Enterprise darstellen. Die Einrichtung von SQL FCI erfordert gemeinsamen Dateispeicher zwischen Knoten, und [Amazon FSx for Windows File Server](https://aws.amazon.com/fsx/windows/) bietet vollständig verwalteten Speicher, der automatisch synchron über Availability Zones hinweg repliziert wird. Amazon FSx reduziert die Speicherkosten, indem es die integrierte Datendeduplizierung für allgemeine Dateifreigaben verwendet, wodurch die Wartung von Drittanbieterlösungen überflüssig wird. Amazon unterstützt FSx außerdem Folgendes: + Zahlen Sie nur für das, was Sie tatsächlich nutzen, ohne Vorabgebühren oder Verpflichtungen. + Richten Sie FCI manuell FSx als gemeinsam genutzten Speicher ein. + Verwenden Sie FSx es als Zeuge für die Dateifreigabe für Ihren SQL-Cluster. + Amazon FSx für Windows File Server unterstützt Server Message Block (SMB) 3.0 für kontinuierlich verfügbare Dateifreigaben und eignet sich daher für SQL Server FCI-Bereitstellungen. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Aktiv. [AWS-Konto](https://aws.amazon.com/account/) + Berechtigungen zum Erstellen und Verwalten von Amazon Virtual Private Cloud (Amazon VPC) -Ressourcen, Amazon Elastic Compute Cloud (Amazon EC2) -Instanzen, Sicherheitsgruppen und AWS Identity and Access Management (IAM) -Rollen. + AWS Managed Microsoft AD oder Ihr eigenes lokales Active Directory. + Ein Active Directory-Domänenbenutzer mit der [erforderlichen Berechtigung](https://learn.microsoft.com/en-us/windows-server/failover-clustering/configure-failover-cluster-accounts) zum Einrichten eines Failoverclusters. + Sicherheitsgruppenregeln für SQL Server FCI- und [Microsoft Active Directory-Ports](https://docs.aws.amazon.com/whitepapers/latest/access-workspaces-with-access-cards/ip-address-and-port-requirements.html) für sichere Hybridkonnektivität. + Ein [Dienstkonto](https://learn.microsoft.com/en-us/sql/database-engine/configure-windows/configure-windows-service-accounts-and-permissions?view=sql-server-ver16#sql-server-failover-cluster-instance) in Active Directory für SQL Server, das mit entsprechenden Berechtigungen für alle SQL-Knoten konfiguriert ist. + Amazon FSx für Windows File Server in einem Failover-Cluster. + Binärdateien für die SQL Server-Installation. **Einschränkungen** + Einige AWS-Services sind nicht in allen AWS-Regionen verfügbar. Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie [AWS-Services unter Nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie auf der [Seite Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus. **Produktversionen** + Amazon EC2 für Windows Server 2012 R2 oder höher + Amazon FSx für Windows File Server mit allen aktuellen Windows Server-Versionen + Amazon FSx für NetApp ONTAP als Alternative für gemeinsam genutzten Speicher + SQL Server 2012/2016/2019/2022 ## Architektur **Technologie-Stack** + Amazon EC2 + Amazon FSx für Windows-Dateiserver + Amazon VPC + AWS Directory Service + AWS Systems Manager + IAM **Zielarchitektur** Das folgende Diagramm zeigt die allgemeine Architektur von Microsoft SQL Server FCI auf Amazon EC2 unter Verwendung von Amazon FSx for Windows File Server. ![\[Architekturdiagramm für Microsoft Server FCI auf Amazon EC2 unter Verwendung von Amazon FSx für Windows File Server.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/208bf64a-8fef-4019-944a-723372450885/images/ba0c9169-9536-41c3-ae8e-7264dcc3e1ad.png) **Netzwerk-Infrastruktur** + Amazon VPC bietet einen Netzwerkcontainer, der sich über drei Availability Zones erstreckt. + Private Subnetze stellen isolierte Subnetze in jeder Availability Zones für die Bereitstellung von Ressourcen bereit. **Rechenschicht** + Amazon EC2 enthält einen SQL Server-Clusterknoten 1, der in Availability Zone 1 als Teil des Windows Server Failover Clusters (WSFC) bereitgestellt wird. + Amazon EC2 enthält einen SQL Server-Clusterknoten 2, der in Availability Zone 2 als Teil des WSFC bereitgestellt wird. + Der WSFC-Cluster verbindet beide SQL Server-Knoten, um eine Failover-Fähigkeit zu gewährleisten. **Speicherebene für Amazon FSx für Windows File Server** ** FSx Multi-AZ-Bereitstellung (erstreckt sich über die Availability Zones 1 und 2)** + Ein primäres FSx Dateisystem in Availability Zone 1 hostet aktive SQL Server-Daten und Protokolldateien. + Ein sekundäres FSx Dateisystem in Availability Zone 2 bietet automatische Failover-Funktionen. + Eine gemeinsam genutzte SMB-Dateifreigabe (\$1\$1 fsx.domain\$1 sqlshare), auf die beide Clusterknoten für SQL Server-Datenbanken zugreifen können. **Single-AZ-Bereitstellung FSx (in) AZ3** + Amazon FSx File Server Witness in Availability Zone 3 dient als Cluster-Quorum-Zeuge. + Der File Share Witness (`\\fsx.domain\witness`) hält das Cluster-Quorum aufrecht und verhindert Split-Brain-Szenarien. **Verzeichnisdienste** + AWS Managed Microsoft AD stellt Windows-Authentifizierungs- und Domänendienste bereit, die für die Clusterfunktionalität erforderlich sind. **Funktionen für hohe Verfügbarkeit** + Multi-AZ-Komponenten bieten Fehlertoleranz in allen Availability Zones. + FSx Der Standby-Dateiserver ermöglicht ein automatisches Failover, falls der Primärserver ausfällt. + File Share Witness bietet Cluster-Quorummanagement in Availability Zone 3, um den ordnungsgemäßen Betrieb des Clusters bei Ausfällen sicherzustellen. + Domain ist AWS Managed Microsoft AD für eine nahtlose Windows-Authentifizierung integriert. ## Tools **AWS-Services** + [Amazon Elastic Compute Cloud (Amazon EC2)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) bietet skalierbare Rechenkapazität in der AWS Cloud. Sie können so viele virtuelle Server wie nötig nutzen und sie schnell nach oben oder unten skalieren. + [Amazon FSx](https://docs.aws.amazon.com/fsx/?id=docs_gateway) bietet Dateisysteme, die branchenübliche Konnektivitätsprotokolle unterstützen und eine hohe Verfügbarkeit und Replikation in allen Bereichen AWS-Regionen bieten. + [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) hilft Ihnen dabei, AWS Ressourcen in einem von Ihnen definierten virtuellen Netzwerk bereitzustellen. Dieses virtuelle Netzwerk entspricht einem herkömmlichen Netzwerk, wie Sie es in Ihrem Rechenzentrum betreiben würden, mit den Vorteilen der Verwendung der skalierbaren Infrastruktur von AWS. + [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)ermöglicht Ihren verzeichnissensitiven Workloads und AWS Ressourcen die Verwendung von Microsoft Active Directory in der. AWS Cloud + [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) hilft Ihnen dabei, den Zugriff auf Ihre AWS Ressourcen sicher zu verwalten, indem kontrolliert wird, wer authentifiziert und autorisiert ist, diese zu verwenden. + [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html)hilft Ihnen bei der Verwaltung Ihrer Anwendungen und Infrastruktur, die in der ausgeführt werden. AWS Cloud Es vereinfacht das Anwendungs- und Ressourcenmanagement, verkürzt die Zeit für die Erkennung und Lösung betrieblicher Probleme und hilft Ihnen, Ihre AWS Ressourcen sicher und in großem Umfang zu verwalten. ## Best Practices + Platzieren Sie Datenbank-Instances in privaten Subnetzen, um zu verhindern, dass sie öffentlich über das Internet zugänglich sind, und ermöglichen Sie ihnen gleichzeitig, sich mit ihnen zu verbinden AWS-Services und Updates durchzuführen. + Allgemeine bewährte Methoden finden Sie unter [Bewährte Methoden für die Bereitstellung von Microsoft SQL Server auf Amazon EC2](https://docs.aws.amazon.com/prescriptive-guidance/latest/sql-server-ec2-best-practices/welcome.html). + Informationen PowerShell zur Verwaltung Ihres Amazon FSx for Windows Dateiservers finden Sie unter [Verwaltung von FSx Windows-Dateisystemen](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/administering-file-systems.html). ## Epen ### EC2 Amazon-Knoten für SQL Server erstellen und konfigurieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Fügen Sie Namen und Tags hinzu. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Wählen Sie ein Windows-AMI. | Wählen Sie ein Amazon Machine Image (AMI) für Windows, das Ihren SQL Server-Anforderungen entspricht. | DBA | | Auswahl von Instance-Typen | Wählen Sie einen EC2 Amazon-Instance-Typ aus, der Ihren Anforderungen entspricht. | DBA | | Verwenden Sie ein key pair. | Sie können ein key pair verwenden, um eine sichere Verbindung zu Ihrer Instance herzustellen. Stellen Sie sicher, dass Sie Zugriff auf das ausgewählte key pair haben, bevor Sie die Instance starten. | DBA | | Konfigurieren von Netzwerkeinstellungen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Konfigurieren Sie erweiterte Netzwerkeinstellungen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Speicher konfigurieren. | Konfigurieren Sie den erforderlichen Gesamtspeicher und wählen Sie den erforderlichen Speichertyp aus. | DBA | | Konfigurieren Sie erweiterte Details und starten Sie die Instanz. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Erstellen Sie Knoten 2. | Wiederholen Sie diese Schritte, um Knoten 2 zu erstellen und zu konfigurieren. | DBA | ### Installieren und konfigurieren Sie den Windows Server-Failovercluster auf den Knoten 1 und 2 | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Melden Sie sich bei Knoten 1 an. | Melden Sie sich als Administrator bei der EC2 Windows-Amazon-Instance an. | DBA | | Installieren Sie die FCI-Funktionen auf Knoten 1. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html)
Install-WindowsFeature -Name Failover-Clustering -IncludeManagementTools[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Melden Sie sich bei Knoten 2 an. | Melden Sie sich als Administrator bei der EC2 Windows-Amazon-Instance an. | DBA | | Installieren Sie die FCI-Funktionen auf Knoten 2. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html)
Install-WindowsFeature -Name Failover-Clustering -IncludeManagementTools[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Fügen Sie dem Cluster Knoten hinzu. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Bringen Sie den Cluster online. | Um den Cluster online zu schalten, aktualisieren Sie die statischen IP-Adressen beider Knoten:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Validieren Sie den Cluster. | Navigieren Sie zum **Failover-Cluster-Manager** und stellen Sie sicher, dass die Cluster-Kernressourcen online sind. | DBA | ### Installieren Sie SQL Server auf den Knoten 1 und 2 | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Loggen Sie sich auf dem Server ein. | Melden Sie sich als Administrator bei der EC2 Amazon-Instance an. | DBA | | Hängen Sie die SQL-Binärdateien ein. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | | | Fügen Sie Knoten 2 zum Failovercluster hinzu. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | ### Amazon FSx File Share Witness konfigurieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Konfigurieren Sie die Quorum-Einstellungen. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/microsoft-sql-failover-cluster-on-amazon-ec2.html) | DBA | | Rufen Sie DNS-Details ab. | Wählen Sie in der FSx Amazon-Konsole **Managed AD** und dann **Attach** aus. Das DNS sollte das folgende Format haben: `\\example.example.net\share` | DBA | | Konfigurieren Sie den File Share Witness. | Wählen Sie den ** FSx Amazon-Dateifreigabepfad** und dann **Fertig stellen**. | DBA | ## Zugehörige Ressourcen **AWS Ressourcen** + [Amazon FSx für Windows-Dateiserver](https://www.youtube.com/watch?v=IMDWTIShlyI) (Video) + [Tiefer Einblick in Amazon FSx für Windows File Server](https://www.youtube.com/watch?v=_x_Geur93oc) (Video) + [So stellen Sie einen SQL Server-Failover-Cluster mit Amazon EBS Multi-Attach auf Windows Server bereit (Blogbeitrag](https://aws.amazon.com/blogs/modernizing-with-aws/how-to-deploy-a-sql-server-failover-cluster-with-amazon-ebs-multi-attach-on-windows-server/))AWS + [Vereinfachen Sie Ihre Hochverfügbarkeitsbereitstellungen von Microsoft SQL Server mit Amazon FSx for Windows File Server](https://aws.amazon.com/blogs/storage/simplify-your-microsoft-sql-server-high-availability-deployments-using-amazon-fsx-for-windows-file-server/) (AWS Blogbeitrag) + [Hochverfügbarkeitsbereitstellungen von SQL Server mit Amazon FSx for NetApp ONTAP](https://aws.amazon.com/blogs/modernizing-with-aws/sql-server-high-availability-amazon-fsx-for-netapp-ontap/) (AWS Blogbeitrag) + [ FSx Für Windows File Server mit Microsoft SQL Server verwenden](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/sql-server.html) + [Was ist FSx für Windows File Server?](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) **Sonstige Ressourcen** + [Erstellen Sie einen Failovercluster](https://learn.microsoft.com/en-us/windows-server/failover-clustering/create-failover-cluster?pivots=windows-admin-center) ## Zusätzliche Informationen **Den File Share Witness konfigurieren** Stellen Sie sicher, dass Sie von beiden Knoten aus mit dem Dateisystem verbunden sind, indem Sie Regeln in der FSx Amazon-Sicherheitsgruppe hinzufügen, die eingehende Verbindungen zulassen. Der SMB-Port sollte zugelassen werden. Wenn der DNS-Name beispielsweise lautet`\\example.example.com\share`, verwenden Sie`\\example.example.com\share`. Verwenden Sie denselben Wert für den Dateifreigabezeugen im AlwaysOn-Verfügbarkeitscluster. Gehen Sie wie folgt vor, um den File Share Witness zu konfigurieren: 1. Verwenden Sie RDP, um eine Verbindung zu Ihrer EC2 Amazon-Instance herzustellen. 1. Navigieren Sie zum **Failover-Cluster-Manager**. 1. Öffnen Sie das Kontextmenü (Rechtsklick) und wählen Sie **Weitere Aktionen** aus. 1. Wählen Sie **Cluster-Quorum-Einstellungen konfigurieren** aus. 1. Wählen Sie **Weiter** aus. 1. Wählen Sie **Quorum-Konfiguration** und konfigurieren Sie einen File Share Witness. 1. Geben Sie den DNS-Namen an. 1. Überprüfen Sie die Zusammenfassung und wählen Sie dann **Fertig stellen**. Der File Share Witness sollte im Bereich **Cluster-Kernressourcen** online sein. # Richten Sie eine HA/DR Architektur für Oracle E-Business Suite auf Amazon RDS Custom mit einer aktiven Standby-Datenbank ein *Simon Cunningham, Jaydeep Nandy und Nitin Saxena, Amazon Web Services* ## Zusammenfassung Dieses Muster beschreibt, wie Sie Ihre Oracle E-Business-Lösung auf Amazon Relational Database Service (Amazon RDS) Custom für Hochverfügbarkeit (HA) und Disaster Recovery (DR) aufbauen können, indem Sie eine Amazon RDS Custom Read Replica-Datenbank in einer anderen Amazon Web Services (AWS) Availability Zone einrichten und sie in eine aktive Standby-Datenbank konvertieren. Die Erstellung der Amazon RDS Custom Read Replica erfolgt vollständig automatisiert über die AWS-Managementkonsole. In diesem Muster werden die Schritte zum Hinzufügen zusätzlicher Anwendungsebenen und gemeinsam genutzter Dateisysteme, die auch Teil einer HA/DR Architektur sein können, nicht behandelt. *Weitere Informationen zu diesen Themen finden Sie in den folgenden Oracle Support Notes: 1375769.1, 1375670.1 und 1383621.1 (Abschnitt 5, Erweiterte Cloning-Optionen).* (Für den Zugriff ist ein [Oracle Support-Konto](https://support.oracle.com/portal/) erforderlich.) Informationen zur Migration des E-Business Suite-Systems zu einer einstufigen Single-AZ-Architektur auf Amazon Web Services (AWS) finden Sie im Muster [Oracle E-Business Suite to Amazon RDS Custom migrieren](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html). Die Oracle E-Business Suite ist eine ERP-Lösung (Enterprise Resource Planning) zur Automatisierung unternehmensweiter Prozesse wie Finanzen, Personalwesen, Lieferketten und Fertigung. Sie hat eine dreistufige Architektur: Client, Anwendung und Datenbank. Bisher mussten Sie Ihre E-Business Suite-Datenbank auf einer selbst verwalteten [Amazon Elastic Compute Cloud (Amazon EC2) -Instance ausführen,](https://aws.amazon.com/ec2/) aber jetzt können Sie von [Amazon RDS](https://aws.amazon.com/rds/custom/) Custom profitieren. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Eine bestehende E-Business Suite-Installation auf Amazon RDS Custom; siehe Muster [Oracle E-Business Suite zu Amazon RDS Custom migrieren](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) + *Wenn Sie die Read Replica auf schreibgeschützt umstellen und damit Reporting in den Standby-Modus verlagern möchten, benötigen Sie eine [Oracle Active Data Guard-Datenbanklizenz](https://www.oracle.com/corporate/pricing/) (siehe Preisliste für Oracle Technology Commercial)* **Einschränkungen** + Einschränkungen und nicht unterstützte Konfigurationen für [Oracle-Datenbanken auf Amazon RDS Custom](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.limits) + Einschränkungen im Zusammenhang mit [Amazon RDS Custom for Oracle Read Replicas](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html#custom-rr.limitations) **Produktversionen** Informationen zu Oracle-Datenbankversionen und Instance-Klassen, die von Amazon RDS Custom unterstützt werden, finden Sie unter [Anforderungen und Einschränkungen für Amazon RDS Custom for Oracle](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html). ## Architektur Das folgende Diagramm zeigt eine repräsentative Architektur für E-Business Suite auf AWS, die mehrere Availability Zones und Anwendungsebenen in einem active/passive Setup umfasst. Die Datenbank verwendet eine Amazon RDS Custom DB-Instance und eine Amazon RDS Custom Read Replica. Die Read Replica verwendet Active Data Guard, um in eine andere Availability Zone zu replizieren. Sie können die Read Replica auch verwenden, um den Lesetraffic auf die Primärdatenbank auszulagern und zu Berichtszwecken. ![\[Multi-AZ-Architektur für Oracle E-Business Suite auf AWS\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/a17947e8-56b1-4d92-91df-096c02ff4c19/images/ffdaa2d4-123b-44a0-8d52-b1352a4eee44.png) Weitere Informationen finden Sie unter [Arbeiten mit Read Replicas für Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html) in der Amazon RDS-Dokumentation. Die Amazon RDS Custom Read Replica wird standardmäßig so erstellt, wie sie bereitgestellt wird. [Wenn Sie jedoch einige Ihrer schreibgeschützten Workloads in die Standby-Datenbank auslagern möchten, um die Belastung Ihrer Primärdatenbank zu reduzieren, können Sie den Modus der bereitgestellten Replikate manuell in schreibgeschützt ändern, indem Sie die Schritte im Abschnitt Epics befolgen.](#set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database-epics) Ein typischer Anwendungsfall hierfür wäre, Ihre Berichte von der Standby-Datenbank aus auszuführen. Für die Umstellung auf schreibgeschützt ist eine aktive Standby-Datenbanklizenz erforderlich. Wenn Sie eine Read Replica auf AWS erstellen, verwendet das System unter dem Deckmantel den Oracle Data Guard Broker. Diese Konfiguration wird automatisch generiert und im Modus „Maximale Leistung“ wie folgt eingerichtet: ``` DGMGRL> show configuration Configuration - rds_dg Protection Mode: MaxPerformance Members: vis_a - Primary database vis_b - Physical standby database Fast-Start Failover: DISABLED Configuration Status: SUCCESS (status updated 58 seconds ago) ``` ## Tools **AWS-Services** + [Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/working-with-custom-oracle.html) ist ein verwalteter Datenbankservice für ältere, benutzerdefinierte und verpackte Anwendungen, die Zugriff auf das zugrunde liegende Betriebssystem und die Datenbankumgebung benötigen. Er automatisiert Aufgaben und Operationen der Datenbankverwaltung und ermöglicht es Ihnen als Datenbankadministrator gleichzeitig, auf Ihre Datenbankumgebung und Ihr Betriebssystem zuzugreifen und diese anzupassen. **Andere Tools** + Oracle Data Guard ist ein Tool, mit dem Sie Oracle-Standby-Datenbanken erstellen und verwalten können. Dieses Muster verwendet Oracle Data Guard, um eine aktive Standby-Datenbank auf Amazon RDS Custom einzurichten. ## Epen ### Erstellen eines Lesereplikats | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Read Replica der Amazon RDS Custom DB-Instance. | Um eine Read Replica zu erstellen, folgen Sie den Anweisungen in der [Amazon RDS-Dokumentation](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReadRepl.html#USER_ReadRepl.Create) und verwenden Sie die Amazon RDS Custom DB-Instance, die Sie erstellt haben (siehe Abschnitt [Voraussetzungen](#set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database-prereqs)), als Quelldatenbank.Standardmäßig wird die Amazon RDS Custom Read Replica als physisches Standby erstellt und befindet sich im gemounteten Zustand. Dies dient dazu, die Einhaltung der Oracle Active Data Guard-Lizenz sicherzustellen. Folgen Sie den nächsten Schritten, um die Read Replica in den Nur-Lese-Modus zu konvertieren. | DBA | ### Ändern Sie die Read Replica in eine schreibgeschützte aktive Standby-Version | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Connect zur Amazon RDS Custom Read Replica her. | Verwenden Sie die folgenden Befehle, um Ihre physische Standby-Datenbank in eine aktive Standby-Datenbank zu konvertieren. Für diese Befehle ist eine aktive Oracle-Standby-Lizenz erforderlich. Um eine Lizenz zu erhalten, wenden Sie sich an Ihren Oracle-Vertreter.
$ sudo su - rdsdb| DBA | | Starten Sie die Medienwiederherstellung mit Log Apply in Echtzeit. | Verwenden Sie die folgenden Befehle, um die Funktion zum Einspielen von Protokollen in Echtzeit zu aktivieren. Diese konvertieren und validieren die Standby-Datenbank (Read Replica) als aktive Standby-Datenbank, sodass Sie eine Verbindung herstellen und schreibgeschützte Abfragen ausführen können.
-bash-4.2$ sql
SQL> select process,status,sequence# from v$managed_standby;
PROCESS STATUS SEQUENCE#
--------- ------------ ----------
ARCH CLOSING 3956
ARCH CONNECTED 0
ARCH CLOSING 3955
ARCH CLOSING 3957
RFS IDLE 0
RFS IDLE 3958
MRP0 APPLYING_LOG 3958
SQL> select name, database_role, open_mode from v$database;
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY MOUNTED
SQL> alter database recover managed standby database cancel;
Database altered.
Open the standby database
SQL> alter database open;
Database altered.
SQL> select name, database_role, open_mode from v$database;
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY READ ONLY
SQL> alter database recover managed standby database using current logfile disconnect from session;| DBA | | Überprüfen Sie den Datenbankstatus. | Verwenden Sie den folgenden Befehl, um den Status der Datenbank zu überprüfen.
Database altered
SQL> select name, database_role, open_mode from v$database;| DBA | | Aktivieren Sie den Redo-Apply-Modus. | Verwenden Sie den folgenden Befehl, um den Redo Apply-Modus zu überprüfen.
NAME DATABASE_ROLE OPEN_MODE
--------- ---------------- --------------------
VIS PHYSICAL STANDBY READ ONLY WITH APPLY
SQL> select process,status,sequence# from v$managed_standby;| DBA | ## Zugehörige Ressourcen + [Migrieren Sie die Oracle E-Business Suite zu Amazon RDS Custom](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-oracle-e-business-suite-to-amazon-rds-custom.html) (AWS Prescriptive Guidance) + [Arbeiten mit Amazon RDS Custom](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-custom.html) (Amazon RDS-Dokumentation) + [Arbeiten mit Read Replicas für Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html) (Amazon RDS-Dokumentation) + [Amazon RDS Custom for Oracle — Neue Kontrollfunktionen in der Datenbankumgebung](https://aws.amazon.com/blogs/aws/amazon-rds-custom-for-oracle-new-control-capabilities-in-database-environment/) (AWS-News-Blog) + [Migration der Oracle E-Business Suite auf AWS (AWS-Whitepaper](https://d1.awsstatic.com/whitepapers/migrate-oracle-e-business-suite.pdf)) + [Architektur der Oracle E-Business Suite auf AWS (AWS-Whitepaper](https://docs.aws.amazon.com/whitepapers/latest/overview-oracle-e-business-suite/oracle-e-business-suite-architecture-on-aws.html)) # Streamen Sie Daten von IBM Db2, SAP, Sybase und anderen Datenbanken nach MongoDB Atlas auf AWS *Battulga Purevragchaa und Igor Alekseev, Amazon Web Services* *Babu Srinivasan, MongoDB* ## Zusammenfassung Dieses Muster beschreibt die Schritte zur Migration von Daten aus IBM Db2 und anderen Datenbanken wie Mainframe-Datenbanken und Sybase zu MongoDB Atlas auf dem. AWS Cloud Es hilft [AWS Glue](https://aws.amazon.com/glue/), die Datenmigration zu MongoDB Atlas zu beschleunigen. Das Muster ist Teil des Leitfadens [Migration zu MongoDB Atlas AWS auf](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) der AWS Prescriptive Guidance-Website. Es enthält die Implementierungsschritte für eines der Migrationsszenarien, die in diesem Leitfaden erörtert werden. Weitere Migrationsszenarien finden Sie in den folgenden Mustern auf der AWS Prescriptive Guidance-Website: + [Migrieren Sie eine selbst gehostete MongoDB-Umgebung zu MongoDB Atlas am AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-self-hosted-mongodb-environment-to-mongodb-atlas-on-the-aws-cloud.html) + [Migrieren Sie relationale Datenbanken zu MongoDB Atlas auf AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-relational-database-to-mongodb-atlas.html) Das Muster ist für [AWS Managed Services Services-Partner](https://aws.amazon.com/managed-services/partners/) und AWS Benutzer vorgesehen. ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Eine Quelldatenbank wie SAP, Sybase, IBM Db2 und andere für die Migration zu MongoDB Atlas. + Vertrautheit mit Datenbanken wie SAP, Sybase, IBM Db2, MongoDB Atlas und. AWS-Services **Produktversionen** + MongoDB Version 5.0 oder höher. ## Architektur Das folgende Diagramm veranschaulicht das Laden und Streamen von Batch-Daten mithilfe AWS Glue Studio von Amazon Kinesis Data Streams und MongoDB Atlas. Diese Referenzarchitektur verwendet, AWS Glue Studio um ETL-Pipelines (Extrahieren, Transformieren und Laden) zu erstellen, um Daten zu MongoDB Atlas zu migrieren. An AWS-Glue-Crawler lässt sich in MongoDB Atlas integrieren, um die Datenverwaltung zu erleichtern. Die Daten können entweder im Batch portiert oder mithilfe von Amazon Kinesis Data Streams nach MongoDB Atlas gestreamt werden. **Batch-Daten laden** ![\[Migrieren Sie Daten im Batch-Modus zu MongoDB Atlas.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/805a376f-35f4-44cc-b4b0-8bf4d95c1e5d/images/68d87202-95ba-4e2a-9b3b-27dd6db6165e.png) Weitere Informationen zur Batch-Datenmigration finden Sie im AWS Blogbeitrag [Compose your ETL jobs for MongoDB Atlas with AWS Glue](https://aws.amazon.com/blogs/big-data/compose-your-etl-jobs-for-mongodb-atlas-with-aws-glue/). **Datenstreaming** ![\[Migrieren Sie Daten im Datenstreaming-Modus zu MongoDB Atlas.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/805a376f-35f4-44cc-b4b0-8bf4d95c1e5d/images/b007a116-f463-418f-9721-647d80177e3b.png) Informationen zu MongoDB Atlas-Referenzarchitekturen, die verschiedene Nutzungsszenarien unterstützen, finden Sie unter [Migration zu MongoDB Atlas AWS auf](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/architecture.html) der AWS Prescriptive Guidance-Website. ## Tools ● [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html)ist ein vollständig verwalteter ETL-Service. Er hilft Ihnen dabei, Daten zuverlässig zu kategorisieren, zu bereinigen, anzureichern und zwischen Datenspeichern und Datenströmen zu verschieben. ● [Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/) hilft Ihnen dabei, große Datenströme in Echtzeit zu sammeln und zu verarbeiten. ● [MongoDB Atlas](https://www.mongodb.com/atlas) ist ein vollständig verwalteter Database-as-a-Service (DBaaS) für die Bereitstellung und Verwaltung von MongoDB-Datenbanken in der Cloud. ## Best Practices Richtlinien finden Sie im [Best Practices Guide for MongoDB](https://github.com/mongodb-partners/mongodb_atlas_as_aws_bedrock_knowledge_base/blob/main/data/MongoDB_Best_Practices_Guide.pdf) im MongoDB-Repository GitHub . ## Epen ### Entdeckung und Bewertung | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Ermitteln Sie die Clustergröße. | Schätzen Sie die Größe des Arbeitssets, indem Sie die Informationen `db.stats()` für den gesamten Indexraum verwenden. Gehen Sie davon aus, dass auf einen Prozentsatz Ihres Datenspeichers häufig zugegriffen wird. Oder Sie können Ihren Speicherbedarf auf der Grundlage Ihrer Annahmen abschätzen. Diese Aufgabe sollte ungefähr eine Woche dauern. Weitere Informationen und Beispiele für diese und die anderen Geschichten in diesem Epos finden Sie unter den Links im Abschnitt [Verwandte Ressourcen](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | MongoDB DBA, Anwendungsarchitekt | | Schätzen Sie die Anforderungen an die Netzwerkbandbreite. | Um Ihre Netzwerkbandbreitenanforderungen zu schätzen, multiplizieren Sie die durchschnittliche Dokumentengröße mit der Anzahl der pro Sekunde bereitgestellten Dokumente. Berücksichtigen Sie den maximalen Datenverkehr, den jeder Knoten in Ihrem Cluster als Grundlage tragen kann. Um die Downstream-Datenübertragungsraten von Ihrem Cluster zu den Client-Anwendungen zu berechnen, verwenden Sie die Summe aller Dokumente, die über einen bestimmten Zeitraum zurückgegeben wurden. Wenn Ihre Anwendungen von sekundären Knoten lesen, dividieren Sie diese Gesamtzahl der Dokumente durch die Anzahl der Knoten, die Lesevorgänge ausführen können. Verwenden Sie den `db.stats().avgObjSize` Befehl, um die durchschnittliche Dokumentgröße für eine Datenbank zu ermitteln. Diese Aufgabe dauert in der Regel einen Tag. | MongoDB DBA | | Wählen Sie die Atlas-Stufe aus. | Folgen Sie den Anweisungen in der [MongoDB-Dokumentation](https://www.mongodb.com/docs/atlas/manage-clusters/), um die richtige Atlas-Clusterstufe auszuwählen. | MongoDB DBA | | Plan für die Umstellung. | Plan für die Umstellung der Anwendung. | MongoDB DBA, Anwendungsarchitekt | ### Richten Sie eine neue MongoDB Atlas-Umgebung auf AWS ein | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie einen neuen MongoDB Atlas-Cluster auf AWS. | Wählen Sie in MongoDB Atlas **Build a Cluster** und dann AWS als Cloud-Anbieter aus. | MongoDB DBA | | Wählen Sie AWS-Regionen eine globale Clusterkonfiguration aus. | Wählen Sie aus der Liste der AWS-Regionen für Ihren Atlas-Cluster verfügbaren aus. Konfigurieren Sie bei Bedarf globale Cluster. | MongoDB DBA | | Wählen Sie die Clusterebene aus. | Wählen Sie Ihre bevorzugte Clusterstufe aus. Ihre Tierauswahl bestimmt Faktoren wie Arbeitsspeicher, Speicher und IOPS-Spezifikation. | MongoDB DBA | | Konfigurieren Sie zusätzliche Cluster-Einstellungen. | Konfigurieren Sie zusätzliche Clustereinstellungen wie MongoDB-Version, Sicherungs- und Verschlüsselungsoptionen. Weitere Informationen zu diesen Optionen finden Sie im Abschnitt [Verwandte Ressourcen](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | MongoDB DBA | ### Konfigurieren Sie Sicherheit und Compliance | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Konfigurieren Sie die Zugriffsliste. | Um eine Verbindung zum Atlas-Cluster herzustellen, müssen Sie der [Zugriffsliste des Projekts](https://www.mongodb.com/docs/atlas/setup-cluster-security/#configure-security-features-for-clusters) einen Eintrag hinzufügen. Atlas verwendet Transport Layer Security (TLS)/Secure Sockets Layer (SSL), um die Verbindungen zur Virtual Private Cloud (VPC) für Ihre Datenbank zu verschlüsseln. Um die Zugriffsliste für das Projekt einzurichten und weitere Informationen zu den Geschichten in diesem Epos zu erhalten, klicken Sie auf die Links im Abschnitt [Verwandte Ressourcen](#stream-data-from-ibm-db2-to-mongodb-atlas-resources). | MongoDB DBA | | Authentifizieren und autorisieren Sie Benutzer. | Sie müssen die Datenbankbenutzer, die auf die MongoDB Atlas-Cluster zugreifen, erstellen und authentifizieren. Um auf die Cluster in einem Projekt zugreifen zu können, müssen Benutzer zu diesem Projekt gehören, und sie können mehreren Projekten angehören. Sie können die Autorisierung auch mit AWS Identity and Access Management (IAM) aktivieren. Weitere Informationen finden Sie unter [Authentifizierung mit IAM einrichten](https://www.mongodb.com/docs/atlas/security/aws-iam-authentication/#set-up-authentication-with-aws-iam) in der MongoDB-Dokumentation. | MongoDB DBA | | Erstellen Sie benutzerdefinierte Rollen. | (Optional) Atlas unterstützt die Erstellung [benutzerdefinierter Rollen](https://www.mongodb.com/docs/atlas/reference/custom-role-actions/), wenn die integrierten Atlas-Datenbank-Benutzerrechte Ihre gewünschten Rechte nicht abdecken. | MongoDB DBA | | Richten Sie VPC-Peering ein. | (Optional) Atlas unterstützt [VPC-Peering](https://www.mongodb.com/docs/atlas/security-vpc-peering/#set-up-a-network-peering-connection) mit anderen AWS. VPCs | MongoDB DBA | | Richten Sie einen Endpunkt ein AWS PrivateLink . | (Optional) Sie können private Endpunkte einrichten, AWS indem Sie [AWS PrivateLink](https://www.mongodb.com/docs/atlas/security-private-endpoint/) | MongoDB DBA | | Aktivieren Sie die Zwei-Faktor-Authentifizierung. | (Optional) Atlas unterstützt die Zwei-Faktor-Authentifizierung (2FA), damit Benutzer den Zugriff auf ihre Atlas-Konten kontrollieren können. | MongoDB DBA | | Richten Sie die Benutzerauthentifizierung und -autorisierung mit LDAP ein. | (Optional) Atlas unterstützt die Benutzerauthentifizierung und -autorisierung mit dem Lightweight Directory Access Protocol (LDAP). | MongoDB DBA | | Richten Sie einheitlichen AWS Zugriff ein. | (Optional) Einige Atlas-Funktionen, darunter Atlas Data Lake und Verschlüsselung im Ruhezustand mithilfe der Kundenschlüsselverwaltung, verwenden IAM-Rollen für die Authentifizierung. | MongoDB DBA | | Richten Sie die Verschlüsselung im Ruhezustand ein, indem Sie AWS KMS | (Optional) Atlas unterstützt die Verwendung von AWS Key Management Service (AWS KMS) zur Verschlüsselung von Speicher-Engines und Backups von Cloud-Anbietern. | MongoDB DBA | | Richten Sie CSFLE ein. | (Optional) Atlas unterstützt die [clientseitige Verschlüsselung auf Feldebene (CSFLE), einschließlich der automatischen Verschlüsselung](https://www.mongodb.com/docs/upcoming/core/csfle/#client-side-field-level-encryption) von Feldern. | MongoDB DBA | ### Daten migrieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Starten Sie Ihren Zielreplikatsatz in MongoDB Atlas. | Starten Sie Ihren Zielreplikatsatz in MongoDB Atlas. Wählen Sie im Atlas Live Migration Service die Option **Ich bin bereit zur** Migration aus. | MongoDB DBA | | Stellen Sie die Verbindung AWS Glue mit MongoDB Atlas her. | Verwenden Sie an AWS-Glue-Crawler , um eine Verbindung AWS Glue mit MongoDB Atlas (Zieldatenbank) herzustellen. Dieser Schritt hilft, die Zielumgebung auf die Migration vorzubereiten. Weitere Informationen finden Sie in der [AWS Glue -Dokumentation](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html). | MongoDB DBA | | Stellen Sie die Verbindung von AWS Glue mit der Quelldatenbank oder dem Quellstream her. | Dies hilft, die Zielumgebung auf die Migration vorzubereiten. | MongoDB DBA | | Richten Sie die Datentransformation ein. | Konfigurieren Sie die Transformationslogik, um die Daten vom strukturierten Legacy-Schema zum flexiblen Schema von MongoDB zu migrieren. | MongoDB DBA | | Migrieren Sie die Daten. | Planen Sie die Migration in AWS Glue Studio. | MongoDB DBA | ### Konfigurieren Sie die betriebliche Integration | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Connect zum Cluster her. | Connect zum MongoDB Atlas-Cluster her. | App-Developer | | Interagieren Sie mit Daten. | Interagieren Sie mit Clusterdaten. | App-Developer | | Überwachen Sie die Cluster. | Überwachen Sie Ihre MongoDB Atlas-Cluster. | MongoDB DBA | | Daten sichern und wiederherstellen. | Clusterdaten sichern und wiederherstellen. | MongoDB DBA | ## Fehlerbehebung | Problem | Lösung | | --- | --- | | Wenn Sie auf Probleme stoßen | Weitere Informationen finden Sie unter [Problembehandlung](https://github.com/mongodb/mongodbatlas-cloudformation-resources/tree/master#troubleshooting) im MongoDB Atlas CloudFormation Resources Repository. | ## Zugehörige Ressourcen Alle folgenden Links führen, sofern nicht anders angegeben, zu Webseiten in der MongoDB-Dokumentation. **Leitfaden zur Migration** + [Migration zu MongoDB Atlas on AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-mongodb-atlas/) (AWS Prescriptive Guidance) **Entdeckung und Bewertung** + [Arbeitsspeicher](https://docs.atlas.mongodb.com/sizing-tier-selection/#memory) + [Beispiel zur Größenbestimmung mit Atlas-Beispieldatensätzen](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--the-service-sample-data-sets) + [Beispiel zur Größenbestimmung für mobile Anwendungen](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#example--mobile-app) + [Netzwerkverkehr](https://docs.atlas.mongodb.com/sizing-tier-selection/#network-traffic) + [Automatische Cluster-Skalierung](https://www.mongodb.com/docs/atlas/sizing-tier-selection/#cluster-auto-scaling) + [Vorlage für die Größenbestimmung von Atlas](https://view.highspot.com/viewer/5f438f47a4dfa042e97130c5) **Konfiguration von Sicherheit und Compliance** + [Einträge in der IP-Zugriffsliste konfigurieren](https://docs.atlas.mongodb.com/security/ip-access-list/) + [Datenbankbenutzer konfigurieren](https://docs.atlas.mongodb.com/security-add-mongodb-users/) + [Konfigurieren Sie den Zugriff auf die Atlas-Benutzeroberfläche](https://docs.atlas.mongodb.com/organizations-projects/) + [Konfigurieren Sie benutzerdefinierte Datenbankrollen](https://docs.atlas.mongodb.com/security-add-mongodb-roles) + [Datenbankbenutzer konfigurieren](https://docs.atlas.mongodb.com/security-add-mongodb-users/#atlas-user-privileges) + [Richten Sie eine Netzwerk-Peering-Verbindung ein](https://docs.atlas.mongodb.com/security-vpc-peering/) + [Erfahren Sie mehr über private Endpunkte in Atlas](https://docs.atlas.mongodb.com/security-private-endpoint/) + [Verwalten Sie Ihre Multi-Faktor-Authentifizierungsoptionen](https://docs.atlas.mongodb.com/security-two-factor-authentication/) + [Richten Sie die Benutzerauthentifizierung und -autorisierung mit LDAP ein](https://docs.atlas.mongodb.com/security-ldaps/) + [Atlas Data Lake](https://docs.mongodb.com/datalake/) + [Verschlüsselung im Ruhezustand mithilfe von Customer Key Management](https://docs.atlas.mongodb.com/security-kms-encryption/) + [Methoden zur Übernahme einer Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) (IAM-Dokumentation) + [Clientseitige Verschlüsselung auf Feldebene](https://docs.mongodb.com/manual/core/security-client-side-encryption) + [Automatische Verschlüsselung](https://docs.mongodb.com/manual/core/security-automatic-client-side-encryption) + [MongoDB Atlas Sicherheitskontrollen](https://webassets.mongodb.com/_com_assets/cms/MongoDB_Atlas_Security_Controls-v7k3rbhi3p.pdf) + [MongoDB-Vertrauenszentrum](https://www.mongodb.com/cloud/trust) + [Konfigurieren Sie Sicherheitsfunktionen für Cluster](https://docs.atlas.mongodb.com/setup-cluster-security/) **Einrichtung einer neuen MongoDB Atlas-Umgebung auf **AWS**** + [Cloud-Anbieter und Regionen](https://docs.atlas.mongodb.com/cloud-providers-regions/) + [Globale Cluster verwalten](https://docs.atlas.mongodb.com/global-clusters/) + [Wählen Sie die Clusterebene](https://www.mongodb.com/docs/atlas/manage-clusters/#select-cluster-tier) + [Konfigurieren Sie zusätzliche Einstellungen](https://docs.atlas.mongodb.com/cluster-additional-settings/) + [Fangen Sie mit Atlas an](https://docs.atlas.mongodb.com/getting-started/) + [Konfigurieren Sie den Zugriff auf die Atlas-Benutzeroberfläche](https://docs.atlas.mongodb.com/organizations-projects/) **Daten migrieren** + [Daten migrieren oder importieren](https://www.mongodb.com/docs/atlas/import/) **Cluster überwachen** + [Überwachen Sie Ihre Cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) **Integrieren von Abläufen** + [Mit einem Cluster verbinden](https://docs.atlas.mongodb.com/connect-to-cluster/) + [Interagieren Sie mit Ihren Daten](https://docs.atlas.mongodb.com/data-explorer/) + [Überwachen Sie Ihre Cluster](https://docs.atlas.mongodb.com/monitoring-alerts/) + [Daten sichern, wiederherstellen und archivieren](https://docs.atlas.mongodb.com/backup-restore-cluster/) **GitHub Repositorium** + [Streamen Sie Daten in MongoDB Atlas mit AWS Glue](https://github.com/mongodb-partners/Stream_Data_into_MongoDB_AWS_Glue?tab=readme-ov-file#troubleshooting) # Rollen für eine PeopleSoft Oracle-Anwendung auf Amazon RDS Custom for Oracle wechseln *Sampath Kathirvel, Amazon Web Services* ## Zusammenfassung Um die [Oracle PeopleSoft](https://www.oracle.com/applications/peoplesoft/) Enterprise Resource Planning (ERP) -Lösung auf Amazon Web Services (AWS) auszuführen, können Sie [Amazon Relational Database Service (Amazon RDS)](https://aws.amazon.com/rds/) oder [Amazon RDS Custom for Oracle](https://aws.amazon.com/rds/custom/) verwenden, das ältere, benutzerdefinierte und verpackte Anwendungen unterstützt, die Zugriff auf das zugrunde liegende Betriebssystem (OS) und die Datenbankumgebung benötigen. Wichtige Faktoren, die bei der Planung einer Migration zu berücksichtigen sind, finden Sie unter [Strategien zur Oracle-Datenbankmigration](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-oracle-database/strategies.html) in AWS Prescriptive Guidance. Dieses Muster konzentriert sich auf die Schritte zur Durchführung eines Oracle Data Guard-Switchovers oder Rollenübergangs für eine PeopleSoft Anwendungsdatenbank, die auf Amazon RDS Custom als Primärdatenbank mit einer Read Replica-Datenbank läuft. Das Muster umfasst Schritte zur Konfiguration des [Fast-Start-Failovers](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/using-data-guard-broker-to-manage-switchovers-failovers.html#GUID-D26D79F2-0093-4C0E-98CD-224A5C8CBFA4) (FSFO). Während dieses Vorgangs funktionieren die Datenbanken in der Oracle Data Guard-Konfiguration weiterhin in ihren neuen Rollen. Typische Anwendungsfälle für Oracle Data Guard Switchover sind Notfallwiederherstellungsübungen (DR), geplante Wartungsaktivitäten an Datenbanken und fortlaufende Patches zum Einspielen von [Standby-First-Patches](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/upgrading-patching-downgrading-oracle-data-guard-configuration.html#GUID-A5226768-DB6B-4714-BB9A-0A3EF17A01C8). Weitere Informationen finden Sie im Blogbeitrag [Reduzieren Sie die Ausfallzeiten beim Datenbank-Patching in Amazon RDS Custom](https://aws.amazon.com/blogs/database/reduce-database-patching-downtime-in-amazon-rds-custom-for-oracle-using-oracle-data-guard-standby-first-patch-apply/). ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Abschluss von [Add HA to Oracle PeopleSoft on Amazon RDS Custom mithilfe eines Read Replica-Musters](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/add-ha-to-oracle-peoplesoft-on-amazon-rds-custom-by-using-a-read-replica.html). **Einschränkungen** + Einschränkungen und nicht unterstützte Konfigurationen für [RDS Custom for Oracle](https://docs.amazonaws.cn/en_us/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.limits) + Einschränkungen im Zusammenhang mit [Amazon RDS Custom for Oracle Read Replicas](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-rr.html#custom-rr.limitations) **Produktversionen** + Informationen zu Oracle-Datenbankversionen, die von Amazon RDS Custom unterstützt werden, finden Sie unter [RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.html#Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.ora). + Informationen zu Oracle-Datenbankinstanzklassen, die von Amazon RDS Custom unterstützt werden, finden Sie unter [DB-Instance-Klassenunterstützung für RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-reqs-limits.html#custom-reqs-limits.instances). ## Architektur **Technologie-Stack** + Amazon RDS Custom für Oracle **Zielarchitektur** Das folgende Diagramm zeigt eine Amazon RDS Custom DB-Instance und eine Amazon RDS Custom Read Replica. Oracle Data Guard ermöglicht den Rollenwechsel während des Failovers für DR ![\[Oracle Data Guard-Switchover für eine primäre benutzerdefinierte RDS-DB-Instance mit einer Read Replica-Datenbank.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/da3b011c-1668-4de4-9079-0982888a74b4/images/4e2a2f3b-b5bd-44b7-9b5a-13a663ee3be6.png) Eine repräsentative Architektur mit Oracle PeopleSoft auf AWS finden Sie unter [Eine hochverfügbare PeopleSoft Architektur auf AWS einrichten](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/set-up-a-highly-available-peoplesoft-architecture-on-aws.html). ## Tools **AWS-Services** + [Amazon RDS Custom for Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/working-with-custom-oracle.html) ist ein verwalteter Datenbankservice für ältere, benutzerdefinierte und verpackte Anwendungen, die Zugriff auf das zugrunde liegende Betriebssystem und die Datenbankumgebung benötigen. + [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) hilft Ihnen dabei, hartcodierte Anmeldeinformationen in Ihrem Code, einschließlich Passwörter, durch einen API-Aufruf an Secrets Manager zu ersetzen, um das Geheimnis programmgesteuert abzurufen. In diesem Muster rufen Sie die Datenbankbenutzerkennwörter aus Secrets Manager für `RDS_DATAGUARD` mit dem geheimen Namen ab`do-not-delete-rds-custom-+<
PROCESS STATUS SEQUENCE#
--------- ------------ ----------
ARCH CLOSING 3956
ARCH CONNECTED 0
ARCH CLOSING 3955
ARCH CLOSING 3957
RFS IDLE 0
RFS IDLE 3958
MRP0 APPLYING_LOG 3958
SQL> select open_mode from v$database;
OPEN_MODE
--------------------
READ ONLY WITH APPLY
-bash-4.2$ dgmgrl RDS_DATAGUARD@RDS_CUSTOM_ORCL_A**CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Mon Nov 28 20:55:50 2022
Version 19.10.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "ORCL_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 59 seconds ago)
DGMGRL>
CDB-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_A| DBA | | Überprüfen Sie die Instanzrolle. | Öffnen Sie die AWS-Managementkonsole und navigieren Sie zur Amazon RDS-Konsole. Überprüfen Sie im Abschnitt **Replikation** der Datenbank auf der Registerkarte **Konnektivität und Sicherheit** die Instance-Rolle für die Primärinstanz und das Replikat.Die primäre Rolle sollte mit der primären Oracle Data Guard-Datenbank übereinstimmen, und die Replikatrolle sollte mit der physischen Standby-Datenbank von Oracle Data Guard übereinstimmen. | Cloud-Administrator, DBA | | Führen Sie den Switchover durch. | Um den Switchover durchzuführen, stellen Sie vom primären Knoten `DGMGRL` aus eine Verbindung zu her.**Nicht-CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 18 06:13:07 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 52 seconds ago)
DGMGRL>
DGMGRL> switchover to orcl_d;**CDB**
Performing switchover NOW, please wait...
Operation requires a connection to database "orcl_d"
Connecting ...
Connected to "ORCL_D"
Connected as SYSDG.
New primary database "orcl_d" is opening...
Operation requires start up of instance "ORCL" on database "orcl_a"
Starting instance "ORCL"...
Connected to an idle instance.
ORACLE instance started.
Connected to "ORCL_A"
Database mounted.
Database opened.
Connected to "ORCL_A"
Switchover succeeded, new primary is "orcl_d"
DGMGRL>
DGMGRL> switchover to rdscdb_b| DBA | | Überprüfen Sie die Oracle Data Guard-Verbindung. | Überprüfen Sie nach dem Switchover die Oracle Data Guard-Verbindung vom primären Knoten zu`DGMGRL`.**Nicht-CDB**
Performing switchover NOW, please wait...
New primary database "rdscdb_b" is opening...
Operation requires start up of instance "RDSCDB" on database "rdscdb_a"
Starting instance "RDSCDB"...
Connected to an idle instance.
ORACLE instance started.
Connected to "RDSCDB_A"
Database mounted.
Database opened.
Connected to "RDSCDB_A"
Switchover succeeded, new primary is "rdscdb_b"
DGMGRL> show configuration;**CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
orcl_a - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 60 seconds ago)
DGMGRL>
DGMGRL> show configuration lag;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
orcl_a - Physical standby database
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 44 seconds ago)
DGMGRL>
DGMGRL> show configuration| DBA | | Überprüfen Sie die Instance-Rolle auf der Amazon RDS-Konsole. | Nachdem Sie den Rollenwechsel durchgeführt haben, zeigt die Amazon RDS-Konsole die neuen Rollen im Abschnitt **Replikation** auf der Registerkarte **Konnektivität und Sicherheit** unter **Datenbanken** an. Es kann einige Minuten dauern, bis der **Replikationsstatus** von „leer“ auf „**Replizierend**“ aktualisiert wird. | DBA | ### FSFO konfigurieren | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Setzen Sie den Switchover zurück. | Stellen Sie den Switchover wieder auf den Primärknoten zurück. | DBA | | Installieren und starten Sie den Observer. | Ein Observer-Prozess ist eine `DGMGRL` Client-Komponente, die normalerweise auf einem anderen Computer als die Primär- und Standby-Datenbank ausgeführt wird. Die ORACLE HOME-Installation für den Observer kann eine Oracle Client Administrator-Installation sein, oder Sie können entweder Oracle Database Enterprise Edition oder Personal Edition installieren. Weitere Informationen zur Observer-Installation für Ihre Datenbank-Version finden Sie unter [Observer installieren und starten](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/using-data-guard-broker-to-manage-switchovers-failovers.html#GUID-11EF3897-8FCA-4A54-B63B-E8C1668AE21B). Um Hochverfügbarkeit für den Observer-Prozess zu konfigurieren, sollten Sie wie folgt vorgehen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/transition-roles-for-an-oracle-peoplesoft-application-on-amazon-rds-custom-for-oracle.html)Für Oracle 12c Release 2 und höher können Sie bis zu drei Observer einsetzen. Ein Beobachter ist der primäre Beobachter, und die anderen sind Ersatzbeobachter. Wenn der primäre Beobachter ausfällt, übernimmt einer der Ersatzbeobachter die primäre Rolle. | DBA | | Stellen Sie vom Observer-Host aus eine Connect zu DGMGRL her. | Der Observer-Host ist mit `tnsnames.ora` Einträgen für die Primär- und Standby-Datenbankkonnektivität konfiguriert. Sie können FSFO mit dem Schutzmodus für maximale Leistung aktivieren, solange der Datenverlust innerhalb der [FastStartFailoverLagLimit](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/oracle-data-guard-broker-properties.html)Konfiguration liegt (Wert in Sekunden). Sie müssen jedoch den Schutzmodus für maximale Verfügbarkeit verwenden, um Datenverlust zu vermeiden (RPO=0).**Nicht-CDB**
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_b - Primary database
rdscdb_a - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 52 seconds ago)
DGMGRL>
DGMGRL> show configuration lag
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_b - Primary database
rdscdb_a - Physical standby database
Transport Lag: 0 seconds (computed 0 seconds ago)
Apply Lag: 0 seconds (computed 0 seconds ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 53 seconds ago)
DGMGRL>
DGMGRL> show configuration;**CDB**
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 58 seconds ago)
DGMGRL> show configuration lag
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - Physical standby database
Transport Lag: 0 seconds (computed 1 second ago)
Apply Lag: 0 seconds (computed 1 second ago)
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 5 seconds ago)
DGMGRL>
-bash-4.2$ dgmgrl C##RDS_DATAGUARD@RDS_CUSTOM_RDSCDB_A| DBA | | Ändern Sie die Standby-Datenbank als Failover-Ziel. | Stellen Sie entweder vom Primärknoten oder vom Beobachterknoten eine Connect zu einer Standby-Datenbank her. (Obwohl Ihre Konfiguration mehrere Standby-Datenbanken enthalten könnte, müssen Sie zu diesem Zeitpunkt nur eine Verbindung herstellen.)**Nicht-CDB**
DGMGRL for Linux: Release 19.0.0.0.0 - Production on Wed Jan 18 06:55:09 2023
Version 19.16.0.0.0
Copyright (c) 1982, 2019, Oracle and/or its affiliates. All rights reserved.
Welcome to DGMGRL, type "help" for information.
Password:
Connected to "RDSCDB_A"
Connected as SYSDG.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - Physical standby database
Fast-Start Failover: Disabled
Configuration Status:
SUCCESS (status updated 18 seconds ago)
DGMGRL>
DGMGRL> edit database orcl_a set property FastStartFailoverTarget='orcl_d';**CDB**
Property "faststartfailovertarget" updated
DGMGRL> edit database orcl_d set property FastStartFailoverTarget='orcl_a';
Property "faststartfailovertarget" updated
DGMGRL> show database orcl_a FastStartFailoverTarget;
FastStartFailoverTarget = 'orcl_d'
DGMGRL> show database orcl_d FastStartFailoverTarget;
FastStartFailoverTarget = 'orcl_a'
DGMGRL>
DGMGRL> edit database orcl_a set property FastStartFailoverTarget='rdscdb_b';| DBA | | Konfigurieren Sie FastStartFailoverThreshold die Verbindung zu DGMGRL. | Der Standardwert in Oracle 19c ist 30 Sekunden und der Mindestwert ist 6 Sekunden. Ein niedrigerer Wert kann das Recovery Time Objective (RTO) während des Failovers möglicherweise verkürzen. Ein höherer Wert trägt dazu bei, die Wahrscheinlichkeit unnötiger vorübergehender Failoverfehler in der Primärdatenbank zu verringern.Das RDS Custom for Oracle Automation Framework überwacht den Zustand der Datenbank und führt alle paar Sekunden Korrekturmaßnahmen durch. Daher empfehlen wir die Einstellung FastStartFailoverThreshold auf einen Wert von mehr als 10 Sekunden. Im folgenden Beispiel wird der Schwellenwert auf 35 Sekunden konfiguriert.**Kein CBD oder CDB**
Object "orcl_a" was not found
DGMGRL> edit database rdscdb_a set property FastStartFailoverTarget='rdscdb_b';
Property "faststartfailovertarget" updated
DGMGRL> edit database rdscdb_b set property FastStartFailoverTarget='rdscdb_a';
Property "faststartfailovertarget" updated
DGMGRL> show database rdscdb_a FastStartFailoverTarget;
FastStartFailoverTarget = 'rdscdb_b'
DGMGRL> show database rdscdb_b FastStartFailoverTarget;
FastStartFailoverTarget = 'rdscdb_a'
DGMGRL>
DGMGRL> edit configuration set property FastStartFailoverThreshold=35;| DBA | | Aktivieren Sie FSFO, indem Sie vom Primär- oder Beobachterknoten aus eine Verbindung zu DGMGRL herstellen. | Wenn für die Datenbank [Flashback Database nicht aktiviert ist, wird die Warnmeldung](https://docs.oracle.com/en/database/oracle/oracle-database/19/rcmrf/FLASHBACK-DATABASE.html#GUID-584AC79A-40C5-45CA-8C63-DED3BE3A4511) angezeigt. `ORA-16827` Die optionale Flashback-Datenbank hilft dabei, ausgefallene Primärdatenbanken automatisch bis zu einem Zeitpunkt vor dem Failover wiederherzustellen, wenn die [FastStartFailoverAutoReinstate](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/oracle-data-guard-broker-properties.html#GUID-824E97C0-EEB0-4E1B-BD4A-F5AE282CEA28)Konfigurationseigenschaft auf gesetzt ist `TRUE` (was die Standardeinstellung ist).**Nicht-CDB**
Property "faststartfailoverthreshold" updated
DGMGRL> show configuration FastStartFailoverThreshold;
FastStartFailoverThreshold = '35'
DGMGRL>
DGMGRL> enable fast_start failover;**CDB**
Warning: ORA-16827: Flashback Database is disabled
Enabled in Zero Data Loss Mode.
DGMGRL>
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
Warning: ORA-16819: fast-start failover observer not started
orcl_d - (*) Physical standby database
Warning: ORA-16819: fast-start failover observer not started
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 29 seconds ago)
DGMGRL>
DGMGRL> enable fast_start failover;| DBA | | Starten Sie den Observer für die FSFO-Überwachung und überprüfen Sie den Status. | Sie können den Observer vor oder nach der Aktivierung von FSFO starten. Wenn FSFO bereits aktiviert ist, beginnt der Observer sofort mit der Überwachung des Status und der Verbindungen zu den primären und Ziel-Standby-Datenbanken. Wenn FSFO nicht aktiviert ist, beginnt der Observer erst mit der Überwachung, nachdem FSFO aktiviert wurde.Wenn Sie den Observer starten, wird die primäre DB-Konfiguration ohne Fehlermeldungen angezeigt, wie der vorherige Befehl zeigt. `show configuration`**Nicht-CDB**
Warning: ORA-16827: Flashback Database is disabled
Enabled in Zero Data Loss Mode.
DGMGRL> show configuration;
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
Warning: ORA-16819: fast-start failover observer not started
rdscdb_b - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 11 seconds ago)
DGMGRL>
DGMGRL> start observer;**CDB**
[W000 2022-12-01T06:16:51.271+00:00] FSFO target standby is orcl_d
Observer 'ip-10-0-1-89' started
[W000 2022-12-01T06:16:51.352+00:00] Observer trace level is set to USER
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_a - Primary database
orcl_d - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
SUCCESS (status updated 56 seconds ago)
DGMGRL>
DGMGRL> show observer
Configuration - rds_dg
Primary: orcl_a
Active Target: orcl_d
Observer "ip-10-0-1-89" - Master
Host Name: ip-10-0-1-89
Last Ping to Primary: 1 second ago
Last Ping to Target: 1 second ago
DGMGRL>
DGMGRL> start observer;| DBA | | Überprüfen Sie den Failover. | In diesem Szenario kann ein Failover-Test durchgeführt werden, indem die primäre EC2 Instanz manuell gestoppt wird. Bevor Sie die EC2 Instance beenden, verwenden Sie den `tail` Befehl, um die Observer-Protokolldatei auf der Grundlage Ihrer Konfiguration zu überwachen. Wird verwendet`DGMGRL`, um sich `orcl_d` mit dem Benutzer `RDS_DATAGUARD` bei der Standby-Datenbank anzumelden und den Status von Oracle Data Guard zu überprüfen. Es sollte zeigen, dass es `orcl_d` sich um die neue Primärdatenbank handelt.In diesem Failover-Testszenario `orcl_d` handelt es sich um die Nicht-CDB-Datenbank.Vor dem Failover wurde die Flashback-Datenbank aktiviert. `orcl_a` Nachdem die frühere Primärdatenbank wieder online ist und ihren `MOUNT` Status aktiviert hat, nimmt der Observer sie wieder in eine neue Standby-Datenbank auf. Die wiederhergestellte Datenbank dient als FSFO-Ziel für die neue Primärdatenbank. Sie können die Details in Observer-Protokollen überprüfen.
Succeeded in opening the observer file "/home/oracle/fsfo_ip-10-0-1-56.dat".
[W000 2023-01-18T07:31:32.589+00:00] FSFO target standby is rdscdb_b
Observer 'ip-10-0-1-56' started
The observer log file is '/home/oracle/observer_ip-10-0-1-56.log'.
DGMGRL> show configuration
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
rdscdb_a - Primary database
rdscdb_b - (*) Physical standby database
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
SUCCESS (status updated 12 seconds ago)
DGMGRL>
DGMGRL> show observer;
Configuration - rds_dg
Primary: rdscdb_a
Active Target: rdscdb_b
Observer "ip-10-0-1-56" - Master
Host Name: ip-10-0-1-56
Last Ping to Primary: 1 second ago
Last Ping to Target: 2 seconds ago
DGMGRL>
DGMGRL> show configurationIm Folgenden sehen Sie ein Beispiel für die Ausgabe in`observer.log`.
Configuration - rds_dg
Protection Mode: MaxAvailability
Members:
orcl_d - Primary database
Warning: ORA-16824: multiple warnings, including fast-start failover-related warnings, detected for the database
orcl_a - (*) Physical standby database (disabled)
ORA-16661: the standby database needs to be reinstated
Fast-Start Failover: Enabled in Zero Data Loss Mode
Configuration Status:
WARNING (status updated 25 seconds ago)
DGMGRL>
$ tail -f /tmp/observer.log| DBA | ### Konfigurieren Sie die Konnektivität zwischen der Oracle Peoplesoft-Anwendung und der Datenbank | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen und starten Sie den Dienst in der Primärdatenbank. | Sie können Änderungen der Anwendungskonfiguration während eines Rollenwechsels vermeiden, indem Sie einen TNS-Eintrag verwenden, der sowohl den primären als auch den Standby-Datenbank-Endpunkt in der Konfiguration enthält. Sie können zwei rollenbasierte Datenbankdienste definieren, um sowohl read/write Workloads als auch schreibgeschützte Workloads zu unterstützen. Im folgenden Beispiel `orcl_rw` ist der read/write Dienst in der Primärdatenbank aktiv. `orcl_ro`ist der schreibgeschützte Dienst und ist in der Standby-Datenbank aktiv, die im schreibgeschützten Modus geöffnet wurde.
Unable to connect to database using rds_custom_orcl_a
[W000 2023-01-18T07:50:32.589+00:00] Primary database cannot be reached.
[W000 2023-01-18T07:50:32.589+00:00] Fast-Start Failover threshold has expired.
[W000 2023-01-18T07:50:32.590+00:00] Try to connect to the standby.
[W000 2023-01-18T07:50:32.590+00:00] Making a last connection attempt to primary database before proceeding with Fast-Start Failover.
[W000 2023-01-18T07:50:32.591+00:00] Check if the standby is ready for failover.
[S002 2023-01-18T07:50:32.591+00:00] Fast-Start Failover started...
2023-01-18T07:50:32.591+00:00
Initiating Fast-Start Failover to database "orcl_d"...
[S002 2023-01-18T07:50:32.592+00:00] Initiating Fast-start Failover.
Performing failover NOW, please wait...
Failover succeeded, new primary is "orcl_d"
2023-01-18T07:55:32.101+00:00
[S002 2023-01-18T07:55:32.591+00:00] Fast-Start Failover finished...
[W000 2023-01-18T07:55:32.591+00:00] Failover succeeded. Restart pinging.
[W000 2023-01-18T07:55:32.603+00:00] Primary database has changed to orcl_d.
[W000 2023-01-18T07:55:33.618+00:00] Try to connect to the primary.
[W000 2023-01-18T07:55:33.622+00:00] Try to connect to the primary rds_custom_orcl_d.
[W000 2023-01-18T07:55:33.634+00:00] The standby orcl_a needs to be reinstated
[W000 2023-01-18T07:55:33.654+00:00] Try to connect to the new standby orcl_a.
[W000 2023-01-18T07:55:33.654+00:00] Connection to the primary restored!
[W000 2023-01-18T07:55:35.654+00:00] Disconnecting from database rds_custom_orcl_d.
[W000 2023-01-18T07:55:57.701+00:00] Try to connect to the new standby orcl_a.
ORA-12170: TNS:Connect timeout occurred
SQL> select name,open_mode from v$database;| DBA | | Starten Sie den Dienst in der Standby-Datenbank. | Verwenden Sie den folgenden Code, um den Dienst in der schreibgeschützten Standby-Datenbank zu starten.
NAME OPEN_MODE
--------- --------------------
ORCL READ WRITE
SQL> exec dbms_service.create_service('orcl_rw','orcl_rw');
PL/SQL procedure successfully completed.
SQL> exec dbms_service.create_service('orcl_ro','orcl_ro');
PL/SQL procedure successfully completed.
SQL> exec dbms_service.start_service('orcl_rw');
PL/SQL procedure successfully completed.
SQL>
SQL> select name,open_mode from v$database;| DBA | | Automatisieren Sie den Start des Dienstes, wenn die primäre Datenbank neu gestartet wird. | Verwenden Sie den folgenden Code, um den Dienst beim Neustart automatisch in der Primärdatenbank zu starten.
NAME OPEN_MODE
--------- --------------------
ORCL READ ONLY WITH APPLY
SQL> exec dbms_service.start_service('orcl_ro');
PL/SQL procedure successfully completed.
SQL>
SQL> CREATE OR REPLACE TRIGGER TrgDgServices after startup on database| DBA | | Konfigurieren Sie eine Verbindung zwischen den Datenbanken read/write und schreibgeschützten Datenbanken. | Sie können das folgende Anwendungskonfigurationsbeispiel für die und schreibgeschützte Verbindung verwenden. read/write
DECLARE
db_role VARCHAR(30);
db_open_mode VARCHAR(30);
BEGIN
SELECT DATABASE_ROLE, OPEN_MODE INTO db_role, db_open_mode FROM V$DATABASE;
IF db_role = 'PRIMARY' THEN
DBMS_SERV 2 ICE.START_SERVICE('orcl_rw');
END IF;
IF db_role = 'PHYSICAL STANDBY' AND db_open_mode LIKE 'READ ONLY%' THEN
DBMS_SERVICE.START_SERVICE('orcl_ro');
END IF;
END;
/
Trigger created.
SQL>
ORCL_RW = (DESCRIPTION =| DBA | ## Zugehörige Ressourcen + [Aktivierung von Hochverfügbarkeit mit Data Guard auf Amazon RDS Custom for Oracle](https://d1.awsstatic.com/whitepapers/enabling-high-availability-with-data-guard-on-amazon-rds-custom-for-oracle.pdf) (AWS-Technischer Leitfaden) + [Konfiguration von Amazon RDS als PeopleSoft Oracle-Datenbank](https://d1.awsstatic.com/whitepapers/configuring-amazon-rds-as-peoplesoft-database.pdf) (AWS-Whitepaper) + [Handbuch zu Oracle Data Guard Broker](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/index.html) (Oracle-Referenzdokumentation) + [Konzepte und Verwaltung von Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/index.html) (Oracle-Referenzdokumentation) + [Spezifische FAN- und FCF-Konfigurationsanforderungen für Oracle Data Guard](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/using-data-guard-broker-to-manage-switchovers-failovers.html#GUID-DFFDAA2B-A889-49AD-AB85-747D73FF0FF5) (Oracle-Referenzdokumentation) # Daten aus einem Amazon Redshift Redshift-Cluster kontenübergreifend nach Amazon S3 entladen *Andrew Kamel, Amazon Web Services* ## Zusammenfassung Wenn Sie Anwendungen testen, ist es hilfreich, Produktionsdaten in Ihrer Testumgebung zu haben. Mithilfe von Produktionsdaten können Sie die Anwendung, die Sie entwickeln, genauer einschätzen. Dieses Muster extrahiert Daten aus einem Amazon Redshift Redshift-Cluster in einer Produktionsumgebung in einen Amazon Simple Storage Service (Amazon S3) -Bucket in einer Entwicklungsumgebung auf Amazon Web Services (AWS). Das Muster führt Schritt für Schritt die Einrichtung von DEV- und PROD-Konten durch, einschließlich der folgenden Schritte: + Erforderliche -Ressourcen + AWS Identity and Access Management (IAM) -Rollen + Netzwerkanpassungen an Subnetzen, Sicherheitsgruppen und der Virtual Private Cloud (VPC) zur Unterstützung der Amazon Redshift Redshift-Verbindung + Eine AWS Lambda Beispielfunktion mit einer Python-Laufzeit zum Testen der Architektur Um Zugriff auf den Amazon Redshift Redshift-Cluster AWS Secrets Manager zu gewähren, speichert das Muster die entsprechenden Anmeldeinformationen. Der Vorteil besteht darin, dass Sie über alle erforderlichen Informationen verfügen, um eine direkte Verbindung zum Amazon Redshift Redshift-Cluster herzustellen, ohne wissen zu müssen, wo sich der Amazon Redshift Redshift-Cluster befindet. Darüber hinaus können Sie die [Verwendung des Geheimnisses überwachen](https://docs.aws.amazon.com/secretsmanager/latest/userguide/monitoring.html). Das in Secrets Manager gespeicherte Geheimnis umfasst den Host, den Datenbanknamen, den Port und die entsprechenden Anmeldeinformationen des Amazon Redshift Redshift-Clusters. Informationen zu Sicherheitsaspekten bei der Verwendung dieses Musters finden Sie im Abschnitt [Bewährte Methoden](#unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3-best-practices). ## Voraussetzungen und Einschränkungen **Voraussetzungen** + Ein [Amazon Redshift Redshift-Cluster, der im PROD-Konto ausgeführt wird](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html) + Ein [S3-Bucket, der im DEV-Konto erstellt wurde](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) + [VPC-Peering](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) zwischen den DEV- und PROD-Konten mit entsprechend angepassten [Routentabellen](https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-routing.html) + [DNS-Hostnamen und DNS-Auflösung](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html) sind für beide Peering-Verbindungen aktiviert VPCs **Einschränkungen** + Abhängig von der Datenmenge, die Sie abfragen möchten, kann es bei der Lambda-Funktion zu einem Timeout kommen. Wenn Ihre Ausführung länger als das maximale Lambda-Timeout (15 Minuten) dauert, verwenden Sie einen asynchronen Ansatz für Ihren Lambda-Code. Das Codebeispiel für dieses Muster verwendet die [psycopg2-Bibliothek](https://github.com/psycopg/psycopg2) für Python, die derzeit keine asynchrone Verarbeitung unterstützt. + Einige AWS-Services sind nicht in allen verfügbar. AWS-Regionen Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie [AWS-Services unter Nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie auf der Seite [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus. ## Architektur Das folgende Diagramm zeigt die Zielarchitektur mit DEV- und PROD-Konten. ![\[Die Lambda-VPC im DEV-Konto und die Amazon Redshift Redshift-VPC im PROD-Konto.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/fa4d01df-483d-4454-9711-b391ebbe4629.png) Das Diagramm zeigt den folgenden Workflow: 1. Die Lambda-Funktion im DEV-Konto übernimmt die IAM-Rolle, die für den Zugriff auf die Amazon Redshift Redshift-Anmeldeinformationen in Secrets Manager im PROD-Konto erforderlich ist. Die Lambda-Funktion ruft dann das Amazon Redshift Redshift-Clustergeheimnis ab. 1. Die Lambda-Funktion im DEV-Konto verwendet die Informationen, um über das Peered-Konto eine Verbindung zum Amazon Redshift Redshift-Cluster im PROD-Konto herzustellen. VPCs Die Lambda-Funktion sendet dann einen Entladebefehl, um den Amazon Redshift Redshift-Cluster im PROD-Konto abzufragen. 1. Der Amazon Redshift Redshift-Cluster im PROD-Konto übernimmt die entsprechende IAM-Rolle für den Zugriff auf den S3-Bucket im DEV-Konto. Der Amazon Redshift Redshift-Cluster entlädt die abgefragten Daten in den S3-Bucket im DEV-Konto. **Daten von Amazon Redshift abfragen** Das folgende Diagramm zeigt die Rollen, die zum Abrufen der Amazon Redshift Redshift-Anmeldeinformationen und zum Herstellen einer Verbindung mit dem Amazon Redshift Redshift-Cluster verwendet werden. Der Workflow wird durch die Lambda-Funktion initiiert. ![\[Der dreistufige Prozess zur kontenübergreifenden Übernahme von Rollen.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/ab25b72c-773c-4d58-9012-4a3755c181ff.png) Das Diagramm zeigt den folgenden Workflow: 1. Das Konto `CrossAccount-SM-Read-Role` im DEV setzt das Konto `SM-Read-Role` im PROD voraus. 1. Die `SM-Read-Role` Rolle verwendet die angehängte Richtlinie, um das Geheimnis aus Secrets Manager abzurufen. 1. Die Anmeldeinformationen werden für den Zugriff auf den Amazon Redshift Redshift-Cluster verwendet. **Daten auf Amazon S3 hochladen** Das folgende Diagramm zeigt den kontoübergreifenden Lese- und Schreibvorgang für das Extrahieren von Daten und deren Upload auf Amazon S3. Der Workflow wird durch die Lambda-Funktion initiiert. Das Muster [verkettet IAM-Rollen in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html#authorizing-redshift-service-chaining-roles). Der Befehl unload, der vom Amazon Redshift Redshift-Cluster kommt`CrossAccount-S3-Write-Role`, geht von und dann von. `S3-Write-Role` Durch diese Rollenverkettung erhält Amazon Redshift Zugriff auf Amazon S3. ![\[Die Rollen, die Anmeldeinformationen abrufen, auf Amazon Redshift zugreifen und Daten auf Amazon S3 hochladen.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/5c83c617-3a85-4aea-a7a7-930f406d1cef/images/d2982fc6-1d12-4f9d-9493-a99ce691d693.png) Der Workflow umfasst die folgenden Schritte: 1. Das Konto „`CrossAccount-SM-Read-Role`Im DEV“ setzt das Konto „`SM-Read-Role`Im PROD“ voraus. 1. Der `SM-Read-Role` ruft die Amazon Redshift Redshift-Anmeldeinformationen von Secrets Manager ab. 1. Die Lambda-Funktion stellt eine Verbindung zum Amazon Redshift Redshift-Cluster her und sendet eine Abfrage. 1. Der Amazon Redshift Redshift-Cluster geht davon aus. `CrossAccount-S3-Write-Role` 1. Das `CrossAccount-S3-Write-Role` geht davon aus, dass das `S3-Write-Role` im DEV-Konto ist. 1. Die Abfrageergebnisse werden in den S3-Bucket im DEV-Konto entladen. ## Tools **AWS-Services** + [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) hilft Ihnen dabei, kryptografische Schlüssel zu erstellen und zu kontrollieren, um Ihre Daten zu schützen. + [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Datenverarbeitungsservice, mit dem Sie Code ausführen können, ohne dass Sie Server bereitstellen oder verwalten müssen. Es führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen. + [Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html) ist ein verwalteter Data-Warehouse-Service im Petabyte-Bereich in der AWS-Cloud. + Mit [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) können Sie fest codierte Anmeldeinformationen im Code (einschließlich Passwörter) durch einen API-Aufruf an Secrets Manager ersetzen und das Geheimnis programmgesteuert abrufen. + [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt. **Code-Repository** Der Code für dieses Muster ist im GitHub [unload-redshift-to-s3-Python-Repository](https://github.com/aws-samples/unload-redshift-to-s3-python/) verfügbar. ## Best Practices **Haftungsausschluss zur Sicherheit** Bevor Sie diese Lösung implementieren, sollten Sie die folgenden wichtigen Sicherheitsempfehlungen berücksichtigen: + Denken Sie daran, dass die Verbindung von Entwicklungs- und Produktionskonten den Umfang erhöhen und die allgemeine Sicherheitslage verringern kann. Wir empfehlen, diese Lösung nur vorübergehend einzusetzen, den erforderlichen Teil der Daten zu extrahieren und dann die bereitgestellten Ressourcen sofort zu vernichten. Um die Ressourcen zu löschen, sollten Sie die Lambda-Funktion löschen, alle für diese Lösung erstellten IAM-Rollen und -Richtlinien entfernen und jeglichen Netzwerkzugriff widerrufen, der zwischen den Konten gewährt wurde. + Konsultieren Sie Ihre Sicherheits- und Compliance-Teams, bevor Sie Daten aus der Produktions- in die Entwicklungsumgebung kopieren. Persönlich identifizierbare Informationen (PII), geschützte Gesundheitsinformationen (PHI) und andere vertrauliche oder regulierte Daten sollten generell nicht auf diese Weise kopiert werden. Kopieren Sie nur öffentlich zugängliche, nicht vertrauliche Informationen (z. B. öffentliche Bestandsdaten aus einem Shop-Frontend). Erwägen Sie die Tokenisierung oder Anonymisierung von Daten oder die Generierung synthetischer Testdaten, anstatt nach Möglichkeit Produktionsdaten zu verwenden. Eines der [AWS Sicherheitsprinzipien](https://docs.aws.amazon.com/en_us/wellarchitected/2022-03-31/framework/sec-design.html) besteht darin, Menschen von Daten fernzuhalten. Mit anderen Worten, Entwickler sollten keine Operationen im Produktionskonto ausführen. + Beschränken Sie den Zugriff auf die Lambda-Funktion im Entwicklungskonto, da sie Daten aus dem Amazon Redshift Redshift-Cluster in der Produktionsumgebung lesen kann. + Um eine Unterbrechung der Produktionsumgebung zu vermeiden, sollten Sie die folgenden Empfehlungen umsetzen: + Verwenden Sie ein separates, dediziertes Entwicklungskonto für Test- und Entwicklungsaktivitäten. + Implementieren Sie strenge Netzwerkzugriffskontrollen und beschränken Sie den Datenverkehr zwischen Konten auf das Notwendige. + Überwachen und prüfen Sie den Zugriff auf die Produktionsumgebung und die Datenquellen. + Implementieren Sie Zugriffskontrollen mit den geringsten Rechten für alle beteiligten Ressourcen und Dienste. + Überprüfen Sie regelmäßig Anmeldeinformationen wie AWS Secrets Manager geheime Daten und IAM-Rollenzugriffsschlüssel und wechseln Sie diese ab. + Informationen zu den in diesem Artikel verwendeten Diensten finden Sie in der folgenden Sicherheitsdokumentation: + [AWS Lambda Sicherheit](https://docs.aws.amazon.com/lambda/latest/dg/lambda-security.html) + [Amazon Redshift Redshift-Sicherheit](https://docs.aws.amazon.com/redshift/latest/mgmt/iam-redshift-user-mgmt.html) + [Amazon S3 S3-Sicherheit](https://docs.aws.amazon.com/AmazonS3/latest/userguide/security.html) + [AWS Secrets Manager Sicherheit](https://docs.aws.amazon.com/secretsmanager/latest/userguide/security.html) + [Bewährte IAM-Sicherheitsmethoden](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) Sicherheit hat beim Zugriff auf Produktionsdaten und Ressourcen oberste Priorität. Halten Sie sich stets an bewährte Verfahren, implementieren Sie Zugriffskontrollen mit geringsten Rechten und überprüfen und aktualisieren Sie Ihre Sicherheitsmaßnahmen regelmäßig. ## Epen ### Daten von Amazon Redshift abfragen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie ein Geheimnis für den Amazon Redshift Redshift-Cluster. | Gehen Sie wie folgt vor, um das Geheimnis für den Amazon Redshift Redshift-Cluster zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | | Erstellen Sie eine Rolle für den Zugriff auf Secrets Manager. | Gehen Sie wie folgt vor, um die Rolle zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | ### Daten aus Amazon S3 uploaden | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Erstellen Sie eine Rolle für den Zugriff auf den S3-Bucket. | Gehen Sie wie folgt vor, um die Rolle für den Zugriff auf den S3-Bucket zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | | Erstellen Sie die Amazon Redshift Redshift-Rolle. | Gehen Sie wie folgt vor, um die Amazon Redshift Redshift-Rolle zu erstellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | ### Stellen Sie die Lambda-Funktion bereit | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Stellen Sie die Lambda-Funktion bereit. | Gehen Sie wie folgt vor, um eine Lambda-Funktion in der Peering-VPC bereitzustellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | ### Testen Sie die Architektur | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Importieren Sie die erforderlichen Ressourcen. | Führen Sie die folgenden Befehle aus, um die erforderlichen Ressourcen zu importieren:
(CONNECT_TIMEOUT= 120)(RETRY_COUNT=20)(RETRY_DELAY=3)(TRANSPORT_CONNECT_TIMEOUT=3)
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST=devpsftdb.******.us-west-2.rds.amazonaws.com)(PORT=1521))
(ADDRESS = (PROTOCOL = TCP)(HOST=psftread.******.us-west-2.rds.amazonaws.com)(PORT=1521))
)
(CONNECT_DATA=(SERVICE_NAME = orcl_rw))
)
ORCL_RO = (DESCRIPTION =
(CONNECT_TIMEOUT= 120)(RETRY_COUNT=20)(RETRY_DELAY=3)(TRANSPORT_CONNECT_TIMEOUT=3)
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST=devpsftdb.******.us-west-2.rds.amazonaws.com)(PORT=1521))
(ADDRESS = (PROTOCOL = TCP)(HOST=psftread.******.us-west-2.rds.amazonaws.com)(PORT=1521))
)
(CONNECT_DATA=(SERVICE_NAME = orcl_ro))
)
import ast| App-Developer | | Führen Sie die Lambda-Handler-Funktion aus. | Die Lambda-Funktion verwendet AWS -Security-Token-Service (AWS STS) für den kontoübergreifenden Zugriff und die temporäre Verwaltung von Anmeldeinformationen. Die Funktion verwendet den AssumeRole API-Vorgang, um vorübergehend die Berechtigungen der IAM-Rolle zu übernehmen. `sm_read_role`Verwenden Sie den folgenden Beispielcode, um die Lambda-Funktion auszuführen:
import boto3
import psycopg2
import base64
from botocore.exceptions import ClientError
def lambda_handler(event, context):| App-Developer | | Hol dir das Geheimnis. | Verwenden Sie den folgenden Beispielcode, um das Amazon Redshift Redshift-Secret abzurufen:
sts_client = boto3.client('sts')
# Secrets Manager Configurations
secret_name = "redshift_creds"
sm_region = "eu-west-1"
sm_read_role = "arn:aws:iam::PROD_ACCOUNT_NUMBER:role/SM-Read-Role"
# S3 Bucket Configurations
s3_bucket_path = "s3://mybucket/"
s3_bucket_region = "eu-west-1"
s3_write_role = "arn:aws:iam::DEV_ACCOUNT_NUMBER:role/S3-Write-Role"
# Redshift Configurations
sql_query = "select * from category"
redshift_db = "dev"
redshift_s3_write_role = "arn:aws:iam::PROD_ACCOUNT_NUMBER:role/CrossAccount-S3-Write-Role"
chained_s3_write_role = "%s,%s" % (redshift_s3_write_role, s3_write_role)
assumed_role_object = sts_client.assume_role(
RoleArn=sm_read_role,
RoleSessionName="CrossAccountRoleAssumption",
ExternalId="YOUR_EXTERNAL_ID",
)
credentials = assumed_role_object['Credentials']
secret_dict = ast.literal_eval(get_secret(credentials, secret_name, sm_region))
execute_query(secret_dict, sql_query, s3_bucket_path, chained_s3_write_role, s3_bucket_region, redshift_db)
return {
'statusCode': 200
}
def get_secret(credentials, secret_name, sm_region):| App-Developer | | Führen Sie den Befehl unload aus. | Verwenden Sie den folgenden Beispielcode, um die Daten in den S3-Bucket zu entladen.
# Create a Secrets Manager client
session = boto3.session.Session()
sm_client = session.client(
service_name='secretsmanager',
aws_access_key_id=credentials['AccessKeyId'],
aws_secret_access_key=credentials['SecretAccessKey'],
aws_session_token=credentials['SessionToken'],
region_name=sm_region
)
try:
get_secret_value_response = sm_client.get_secret_value(
SecretId=secret_name
)
except ClientError as e:
print(e)
raise e
else:
if 'SecretString' in get_secret_value_response:
return get_secret_value_response['SecretString']
else:
return base64.b64decode(get_secret_value_response['SecretBinary'])
def execute_query(secret_dict, sql_query, s3_bucket_path, chained_s3_write_role, s3_bucket_region, redshift_db):| App-Developer | ### Bereinigen | Aufgabe | Description | Erforderliche Fähigkeiten | | --- | --- | --- | | Löschen Sie die Lambda-Funktion. | Um ungeplante Kosten zu vermeiden, entfernen Sie die Ressourcen und die Verbindung zwischen den Konten DEV und PROD.Gehen Sie wie folgt vor, um die Lambda-Funktion zu entfernen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | | Entfernen Sie die IAM-Rollen und -Richtlinien. | Entfernen Sie die IAM-Rollen und -Richtlinien aus den DEV- und PROD-Konten.Gehen Sie im DEV-Konto wie folgt vor:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html)Gehen Sie im PROD-Konto wie folgt vor:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | | Löschen Sie das Geheimnis in Secrets Manager. | Gehen Sie wie folgt vor, um das Geheimnis zu löschen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | | Entfernen Sie VPC-Peering- und Sicherheitsgruppenregeln. | Gehen Sie wie folgt vor, um VPC-Peering- und Sicherheitsgruppenregeln zu entfernen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | | Daten aus dem S3-Bucket entfernen. | Gehen Sie wie folgt vor, um die Daten aus Amazon S3 zu entfernen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | | AWS KMS Schlüssel aufräumen. | Wenn Sie benutzerdefinierte AWS KMS Schlüssel für die Verschlüsselung erstellt haben, gehen Sie wie folgt vor:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | | Überprüfen und löschen Sie CloudWatch Amazon-Protokolle. | Gehen Sie wie folgt vor, um die CloudWatch Protokolle zu löschen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.html) | DevOps Ingenieur | ## Zugehörige Ressourcen + [ CloudWatch Amazon-Dokumentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) + [IAM-Dokumentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) + [Lambda-Dokumentation](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) + [Amazon Redshift Redshift-Dokumentation](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html) + [Amazon S3 S3-Dokumentation](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) + [AWS Secrets Manager Dokumentation](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) + [AWS Sicherheitsprinzipien](https://docs.aws.amazon.com/en_us/wellarchitected/2022-03-31/framework/sec-design.html) ## Zusätzliche Informationen Nachdem Sie die Daten von Amazon Redshift nach Amazon S3 entladen haben, können Sie sie mit Amazon Athena analysieren. [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) ist ein Big-Data-Abfrageservice, der nützlich ist, wenn Sie auf große Datenmengen zugreifen müssen. Sie können Athena verwenden, ohne Server oder Datenbanken bereitstellen zu müssen. Athena unterstützt komplexe Abfragen, und Sie können es für verschiedene Objekte ausführen. Wie bei den meisten AWS-Services Fällen besteht der Hauptvorteil der Verwendung von Athena darin, dass es eine große Flexibilität bei der Ausführung von Abfragen ohne zusätzliche Komplexität bietet. Wenn Sie Athena verwenden, können Sie verschiedene Datentypen wie CSV und JSON in Amazon S3 abfragen, ohne den Datentyp zu ändern. Sie können Daten aus verschiedenen Quellen abfragen, auch aus externen AWS Quellen. Athena reduziert die Komplexität, da Sie keine Server verwalten müssen. Athena liest Daten direkt aus Amazon S3, ohne die Daten zu laden oder zu ändern, bevor Sie die Abfrage ausführen. # Datenbankmigrationsmuster nach Workload **Topics** + [IBM](databases-database-migration-patterns-by-workload-ibm-pattern-list.md) + [Microsoft](databases-database-migration-patterns-by-workload-microsoft-pattern-list.md) + [N/A](databases-database-migration-patterns-by-workload-notapplicable-pattern-list.md) + [Open-Source](databases-database-migration-patterns-by-workload-open-source-pattern-list.md) + [Oracle](databases-database-migration-patterns-by-workload-oracle-pattern-list.md) + [SAP](databases-database-migration-patterns-by-workload-sap-pattern-list.md) # IBM **Topics** + [Migrieren Sie mithilfe von AWS DMS eine Db2-Datenbank von Amazon EC2 zu Aurora MySQL-kompatibel](migrate-a-db2-database-from-amazon-ec2-to-aurora-mysql-compatible-by-using-aws-dms.md) + [Migrieren Sie Db2 for LUW zu Amazon, EC2 indem Sie den Protokollversand verwenden, um die Ausfallzeit zu reduzieren](migrate-db2-for-luw-to-amazon-ec2-by-using-log-shipping-to-reduce-outage-time.md) + [Migrieren Sie Db2 for LUW zu Amazon EC2 mit hochverfügbarer Disaster Recovery](migrate-db2-for-luw-to-amazon-ec2-with-high-availability-disaster-recovery.md) + [Migrieren Sie mithilfe von AWS DMS und AWS SCT von IBM Db2 auf Amazon EC2 zu Aurora PostgreSQL-kompatibel](migrate-from-ibm-db2-on-amazon-ec2-to-aurora-postgresql-compatible-using-aws-dms-and-aws-sct.md) + [Migrieren Sie von IBM WebSphere Application Server zu Apache Tomcat auf Amazon EC2](migrate-from-ibm-websphere-application-server-to-apache-tomcat-on-amazon-ec2.md) + [Streamen Sie Daten von IBM Db2, SAP, Sybase und anderen Datenbanken nach MongoDB Atlas auf AWS](stream-data-from-ibm-db2-to-mongodb-atlas.md) # Microsoft **Topics** + [Beschleunigen Sie die Erkennung und Migration von Microsoft-Workloads zu AWS](accelerate-the-discovery-and-migration-of-microsoft-workloads-to-aws.md) + [Greifen Sie von Microsoft SQL Server auf Amazon EC2 mithilfe von Verbindungsservern auf lokale Microsoft SQL Server-Tabellen zu](access-on-premises-microsoft-sql-server-tables-from-microsoft-sql-server-on-amazon-ec2-using-linked-servers.md) + [Beurteilen Sie die Abfrageleistung für die Migration von SQL Server-Datenbanken zu MongoDB Atlas auf AWS](assess-query-performance-for-migrating-sql-server-databases-to-mongodb-atlas-on-aws.md) + [Automatisieren Sie Datenbankaufgaben in der SQL Server Express Edition, die auf Amazon ausgeführt wird, EC2 mithilfe eines AWS Lambda Taskplaners](automate-database-tasks-in-sql-server-express-edition-running-on-amazon-ec2.md) + [Ändern Sie Python- und Perl-Anwendungen, um die Datenbankmigration von Microsoft SQL Server zur Amazon Aurora PostgreSQL-Compatible Edition zu unterstützen](change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.md) + [Konfigurieren Sie das schreibgeschützte Routing in einer Always-On-Verfügbarkeitsgruppe in SQL Server auf AWS](configure-read-only-routing-in-an-always-on-availability-group-in-sql-server-on-aws.md) + [Konfigurieren Sie die Windows-Authentifizierung für Amazon RDS for Microsoft SQL Server mit AWS Managed Microsoft AD](configure-windows-authentication-for-amazon-rds-using-microsoft-ad.md) + [Erstellen Sie CloudFormation AWS-Vorlagen für AWS DMS-Aufgaben mit Microsoft Excel und Python](create-aws-cloudformation-templates-for-aws-dms-tasks-using-microsoft-excel-and-python.md) + [Stellen Sie mithilfe von Terraform SQL Server-Failover-Cluster-Instances auf Amazon EC2 und Amazon FSx bereit](deploy-sql-server-failover-cluster-instances-on-amazon-ec2-and-amazon-fsx.md) + [Exportieren Sie eine Microsoft SQL Server-Datenbank mithilfe von AWS DMS nach Amazon S3](export-a-microsoft-sql-server-database-to-amazon-s3-by-using-aws-dms.md) + [Exportieren Sie Amazon RDS for SQL Server-Tabellen mithilfe von AWS DMS in einen S3-Bucket](export-amazon-rds-for-sql-server-tables-to-an-s3-bucket-by-using-aws-dms.md) + [Implementieren Sie SHA1 Hashing für PII-Daten bei der Migration von SQL Server zu PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md) + [EC2 Windows-Instances in ein AWS Managed Services Services-Konto aufnehmen und migrieren](ingest-and-migrate-ec2-windows-instances-into-an-aws-managed-services-account.md) + [Richten Sie einen Microsoft SQL Server-Failover-Cluster auf Amazon ein, der FSx für Windows File Server EC2 verwendet wird](microsoft-sql-failover-cluster-on-amazon-ec2.md) + [Migrieren Sie eine Messaging-Warteschlange von Microsoft Azure Service Bus zu Amazon SQS](migrate-a-messaging-queue-from-microsoft-azure-service-bus-to-amazon-sqs.md) + [Migrieren Sie mithilfe von AWS DMS eine Microsoft SQL Server-Datenbank von Amazon EC2 zu Amazon DocumentDB](migrate-a-microsoft-sql-server-database-from-amazon-ec2-to-amazon-documentdb-by-using-aws-dms.md) + [Migrieren Sie eine Microsoft SQL Server-Datenbank mithilfe von AWS DMS und AWS SCT zu Aurora MySQL](migrate-a-microsoft-sql-server-database-to-aurora-mysql-by-using-aws-dms-and-aws-sct.md) + [Migrieren Sie eine.NET-Anwendung von Microsoft Azure App Service zu AWS Elastic Beanstalk](migrate-a-net-application-from-microsoft-azure-app-service-to-aws-elastic-beanstalk.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank zu Amazon EC2](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-ec2.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank zu Amazon RDS for SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank mithilfe von Verbindungsservern zu Amazon RDS for SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-linked-servers.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank mit systemeigenen Sicherungs- und Wiederherstellungsmethoden zu Amazon RDS for SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-native-backup-and-restore-methods.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank mit AWS DMS zu Amazon Redshift](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-dms.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank mithilfe von AWS SCT-Datenextraktionsagenten zu Amazon Redshift](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank zu Microsoft SQL Server auf Amazon EC2 unter Linux](migrate-an-on-premises-microsoft-sql-server-database-to-microsoft-sql-server-on-amazon-ec2-running-linux.md) + [Migrieren Sie Daten mithilfe von Rclone von Microsoft Azure Blob zu Amazon S3](migrate-data-from-microsoft-azure-blob-to-amazon-s3-by-using-rclone.md) + [Migrieren Sie IIS-gehostete Anwendungen mithilfe EC2 von appcmd.exe zu Amazon](migrate-iis-hosted-applications-to-amazon-ec2-by-using-appcmd.md) + [Migrieren Sie die Microsoft SQL Server Always On-Verfügbarkeitsgruppe mithilfe von AWS Application Migration Service](migrate-microsoft-sql-server-always-on-group-using-mgn.md) + [Migrieren Sie EC2 mithilfe des Application Migration Service eine lokale Microsoft SQL Server-Datenbank zu Amazon](migrate-microsoft-sql-server-to-amazon-ec2-using-aws-mgn.md) + [Migrieren Sie eine relationale Datenbank zu MongoDB Atlas am AWS](migrate-relational-database-to-mongodb-atlas.md) + [Migrieren Sie SQL Server mithilfe verteilter Verfügbarkeitsgruppen zu AWS](migrate-sql-server-to-aws-using-distributed-availability-groups.md) + [Migrieren Sie Windows-SSL-Zertifikate mithilfe von ACM zu einem Application Load Balancer](migrate-windows-ssl-certificates-to-an-application-load-balancer-using-acm.md) + [Rehosten Sie lokale Workloads in der AWS-Cloud: Migrationscheckliste](rehost-on-premises-workloads-in-the-aws-cloud-migration-checklist.md) + [Verbindungsfehler nach der Migration von Microsoft SQL Server zur AWS-Cloud beheben](resolve-connection-errors-after-migrating-microsoft-sql-server-to-the-aws-cloud.md) + [Senden Sie Benachrichtigungen für eine Amazon RDS for SQL Server Server-Datenbank-Instance mithilfe eines lokalen SMTP-Servers und Datenbank-E-Mail](send-notifications-for-an-amazon-rds-for-sql-server-database-instance-by-using-an-on-premises-smtp-server-and-database-mail.md) + [Richten Sie mithilfe von Terraform eine CI/CD Pipeline für die Datenbankmigration ein](set-up-ci-cd-pipeline-for-db-migration-with-terraform.md) + [Richten Sie mithilfe von Amazon eine Multi-AZ-Infrastruktur für einen SQL Server Always On FCI ein FSx](set-up-multi-az-infrastructure-for-a-sql-server-always-on-fci-by-using-amazon-fsx.md) # N/A **Topics** + [Erstellen Sie einen Genehmigungsprozess für Firewallanfragen während einer Rehost-Migration zu AWS](create-an-approval-process-for-firewall-requests-during-a-rehost-migration-to-aws.md) + [Verschlüsseln Sie eine bestehende Amazon RDS for PostgreSQL PostgreSQL-DB-Instance](encrypt-an-existing-amazon-rds-for-postgresql-db-instance.md) + [Schätzung der Speicherkosten für eine Amazon DynamoDB-Tabelle](estimate-storage-costs-for-an-amazon-dynamodb-table.md) + [Implementieren Sie regionsübergreifende Notfallwiederherstellung mit AWS DMS und Amazon Aurora](implement-cross-region-disaster-recovery-with-aws-dms-and-amazon-aurora.md) # Open-Source **Topics** + [Automatisches Generieren eines PynamoDB-Modells und CRUD-Funktionen für Amazon DynamoDB mithilfe einer Python-Anwendung](automatically-generate-a-pynamodb-model-and-crud-functions-for-amazon-dynamodb-by-using-a-python-application.md) + [Stellen Sie eine Connect über einen SSH-Tunnel in pgAdmin her](connect-by-using-an-ssh-tunnel-in-pgadmin.md) + [Anwendungsbenutzer und Rollen in Aurora PostgreSQL-kompatibel erstellen](create-application-users-and-roles-in-aurora-postgresql-compatible.md) + [Aktivieren Sie verschlüsselte Verbindungen für PostgreSQL-DB-Instances in Amazon RDS](enable-encrypted-connections-for-postgresql-db-instances-in-amazon-rds.md) + [Migrieren Sie Amazon RDS for Oracle zu Amazon RDS for PostgreSQL mit AWS SCT und unter Verwendung von und AWS DMS AWS CLI CloudFormation](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-with-aws-sct-and-aws-dms-using-aws-cli-and-aws-cloudformation.md) + [Migrieren Sie eine lokale MariaDB-Datenbank mit nativen Tools zu Amazon RDS for MariaDB](migrate-an-on-premises-mariadb-database-to-amazon-rds-for-mariadb-using-native-tools.md) + [Migrieren Sie eine lokale MySQL-Datenbank zu Amazon EC2](migrate-an-on-premises-mysql-database-to-amazon-ec2.md) + [Migrieren Sie eine lokale MySQL-Datenbank zu Amazon RDS for MySQL](migrate-an-on-premises-mysql-database-to-amazon-rds-for-mysql.md) + [Migrieren Sie eine lokale MySQL-Datenbank zu Aurora MySQL](migrate-an-on-premises-mysql-database-to-aurora-mysql.md) + [Migrieren Sie eine lokale PostgreSQL-Datenbank zu Aurora PostgreSQL](migrate-an-on-premises-postgresql-database-to-aurora-postgresql.md) + [Migrieren Sie eine Couchbase Server-Datenbank zu Amazon EC2](migrate-couchbase-server-ec2.md) + [Migrieren Sie EC2 mit Auto Scaling von IBM WebSphere Application Server zu Apache Tomcat auf Amazon](migrate-from-ibm-websphere-application-server-to-apache-tomcat-on-amazon-ec2-with-auto-scaling.md) + [Migrieren Sie mithilfe von AWS DMS von Oracle 8i oder 9i zu Amazon RDS for Oracle SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-oracle-using-shareplex-and-aws-dms.md) + [Migrieren Sie mit pglogical von PostgreSQL auf Amazon EC2 zu Amazon RDS for PostgreSQL](migrate-from-postgresql-on-amazon-ec2-to-amazon-rds-for-postgresql-using-pglogical.md) + [Migrieren Sie lokale Java-Anwendungen mithilfe von AWS App2Container zu AWS](migrate-on-premises-java-applications-to-aws-using-aws-app2container.md) + [Migrieren Sie lokale MySQL-Datenbanken mit Percona XtraBackup, Amazon EFS und Amazon S3 zu Aurora MySQL](migrate-on-premises-mysql-databases-to-aurora-mysql-using-percona-xtrabackup-amazon-efs-and-amazon-s3.md) + [Migrieren Sie externe Oracle-Tabellen zu Amazon Aurora PostgreSQL-kompatibel](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Migrieren Sie Oracle-Funktionen und -Prozeduren mit mehr als 100 Argumenten nach PostgreSQL](migrate-oracle-functions-and-procedures-that-have-more-than-100-arguments-to-postgresql.md) + [Migrieren Sie Redis-Workloads zu Redis Enterprise Cloud auf AWS](migrate-redis-workloads-to-redis-enterprise-cloud-on-aws.md) + [Überwachen Sie Amazon Aurora auf Instances ohne Verschlüsselung](monitor-amazon-aurora-for-instances-without-encryption.md) + [Starten Sie den AWS Replication Agent SELinux nach dem Neustart eines RHEL-Quellservers automatisch neu, ohne ihn zu deaktivieren](restart-the-aws-replication-agent-automatically-without-disabling-selinux-after-rebooting-a-rhel-source-server.md) + [Planen Sie Jobs für Amazon RDS for PostgreSQL und Aurora PostgreSQL mithilfe von Lambda und Secrets Manager](schedule-jobs-for-amazon-rds-for-postgresql-and-aurora-postgresql-by-using-lambda-and-secrets-manager.md) + [Transportieren Sie PostgreSQL-Datenbanken zwischen zwei Amazon RDS-DB-Instances mithilfe von pg\$1transport](transport-postgresql-databases-between-two-amazon-rds-db-instances-using-pg-transport.md) + [Daten aus einem Amazon Redshift Redshift-Cluster kontenübergreifend nach Amazon S3 entladen](unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.md) # Oracle **Topics** + [Fügen Sie HA mithilfe einer Read Replica zu Oracle PeopleSoft auf Amazon RDS Custom hinzu](add-ha-to-oracle-peoplesoft-on-amazon-rds-custom-by-using-a-read-replica.md) + [JSON-Oracle-Abfragen in PostgreSQL-Datenbank-SQL konvertieren](convert-json-oracle-queries-into-postgresql-database-sql.md) + [Konvertiert VARCHAR2 (1) den Datentyp für Oracle in den booleschen Datentyp für Amazon Aurora PostgreSQL](convert-varchar2-1-data-type-for-oracle-to-boolean-data-type-for-amazon-aurora-postgresql.md) + [Emulieren Sie Oracle DR mithilfe einer PostgreSQL-kompatiblen globalen Aurora-Datenbank](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Emulieren Sie PL/SQL assoziative Oracle-Arrays in Amazon Aurora PostgreSQL und Amazon RDS for PostgreSQL](emulate-oracle-plsql-associative-arrays-in-aurora-and-rds-postgresql.md) + [Schätzen Sie die Größe der Amazon RDS-Engine für eine Oracle-Datenbank mithilfe von AWR-Berichten](estimate-the-amazon-rds-engine-size-for-an-oracle-database-by-using-awr-reports.md) + [Behandeln Sie anonyme Blöcke in dynamischen SQL-Anweisungen in Aurora PostgreSQL](handle-anonymous-blocks-in-dynamic-sql-statements-in-aurora-postgresql.md) + [Schrittweise Migration von Amazon RDS for Oracle zu Amazon RDS for PostgreSQL mithilfe von Oracle SQL Developer und AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Laden Sie BLOB-Dateien mithilfe der Dateikodierung in Aurora PostgreSQL-kompatibel in TEXT](load-blob-files-into-text-by-using-file-encoding-in-aurora-postgresql-compatible.md) + [Migrieren Sie Amazon RDS for Oracle zu Amazon RDS for PostgreSQL im SSL-Modus mithilfe von AWS DMS](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-in-ssl-mode-by-using-aws-dms.md) + [Migrieren Sie eine Amazon RDS for Oracle Oracle-Datenbank zu einer anderen AWS-Konto und AWS-Region verwenden Sie sie AWS DMS für die laufende Replikation](migrate-an-amazon-rds-for-oracle-database-to-another-aws-account-and-aws-region-using-aws-dms-for-ongoing-replication.md) + [Migrieren Sie eine lokale Oracle-Datenbank mithilfe EC2 von Oracle Data Pump zu Amazon](migrate-an-on-premises-oracle-database-to-amazon-ec2-by-using-oracle-data-pump.md) + [Migrieren Sie eine lokale Oracle-Datenbank mit Logstash zu Amazon OpenSearch Service](migrate-an-on-premises-oracle-database-to-amazon-opensearch-service-using-logstash.md) + [Migrieren Sie eine lokale Oracle-Datenbank mit AWS DMS und AWS SCT zu Amazon RDS for MySQL](migrate-an-on-premises-oracle-database-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migrieren Sie eine lokale Oracle-Datenbank zu Amazon RDS for Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.md) + [Migrieren Sie eine lokale Oracle-Datenbank zu Amazon RDS for Oracle, indem Sie den direkten Oracle Data Pump-Import über einen Datenbank-Link verwenden](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-by-using-direct-oracle-data-pump-import-over-a-database-link.md) + [Migrieren Sie eine lokale Oracle-Datenbank mit Oracle Data Pump zu Amazon RDS for Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.md) + [Migrieren Sie eine lokale Oracle-Datenbank mithilfe eines Oracle-Bystanders und AWS DMS zu Amazon RDS for PostgreSQL](migrate-an-on-premises-oracle-database-to-amazon-rds-for-postgresql-by-using-an-oracle-bystander-and-aws-dms.md) + [Migrieren Sie eine lokale Oracle-Datenbank zu Oracle auf Amazon EC2](migrate-an-on-premises-oracle-database-to-oracle-on-amazon-ec2.md) + [Migrieren Sie mithilfe von AWS DMS und AWS SCT eine Oracle-Datenbank von Amazon EC2 zu Amazon RDS for MariaDB](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-mariadb-using-aws-dms-and-aws-sct.md) + [Migrieren Sie mithilfe von AWS DMS eine Oracle-Datenbank von Amazon EC2 zu Amazon RDS for Oracle](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-oracle-using-aws-dms.md) + [Migrieren Sie eine Oracle-Datenbank mit AWS DMS zu Amazon DynamoDB](migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.md) + [Migrieren Sie eine Oracle-Datenbank mithilfe von GoldenGate Oracle-Flatfile-Adaptern zu Amazon RDS for Oracle](migrate-an-oracle-database-to-amazon-rds-for-oracle-by-using-oracle-goldengate-flat-file-adapters.md) + [Migrieren Sie eine Oracle-Datenbank mit AWS DMS und AWS SCT zu Amazon Redshift](migrate-an-oracle-database-to-amazon-redshift-using-aws-dms-and-aws-sct.md) + [Migrieren Sie eine Oracle-Datenbank mit AWS DMS und AWS SCT zu Aurora PostgreSQL](migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.md) + [Migrieren Sie eine Oracle JD EnterpriseOne Edwards-Datenbank mithilfe von Oracle Data Pump und AWS DMS zu AWS](migrate-an-oracle-jd-edwards-enterpriseone-database-to-aws-by-using-oracle-data-pump-and-aws-dms.md) + [Migrieren Sie eine partitionierte Oracle-Tabelle mithilfe von AWS DMS zu PostgreSQL](migrate-an-oracle-partitioned-table-to-postgresql-by-using-aws-dms.md) + [Migrieren Sie eine PeopleSoft Oracle-Datenbank mithilfe von AWS DMS zu AWS](migrate-an-oracle-peoplesoft-database-to-aws-by-using-aws-dms.md) + [Migrieren Sie Daten von einer lokalen Oracle-Datenbank zu Aurora PostgreSQL](migrate-data-from-an-on-premises-oracle-database-to-aurora-postgresql.md) + [Migrieren Sie von Amazon RDS for Oracle zu Amazon RDS for MySQL](migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-mysql.md) + [Migrieren Sie mithilfe von Materialized Views und AWS DMS von Oracle 8i oder 9i zu Amazon RDS for PostgreSQL](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-materialized-views-and-aws-dms.md) + [Migrieren Sie mithilfe von AWS DMS von Oracle 8i oder 9i zu Amazon RDS for PostgreSQL SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-shareplex-and-aws-dms.md) + [Migrieren Sie mithilfe von Oracle von Oracle Database zu Amazon RDS for PostgreSQL GoldenGate](migrate-from-oracle-database-to-amazon-rds-for-postgresql-by-using-oracle-goldengate.md) + [Migrieren Sie mithilfe von AWS DMS und AWS SCT von Oracle auf Amazon EC2 zu Amazon RDS for MySQL](migrate-from-oracle-on-amazon-ec2-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migrieren Sie von Oracle WebLogic zu Apache Tomcat (ToMEE) auf Amazon ECS](migrate-from-oracle-weblogic-to-apache-tomcat-tomee-on-amazon-ecs.md) + [Migrieren Sie funktionsbasierte Indizes von Oracle nach PostgreSQL](migrate-function-based-indexes-from-oracle-to-postgresql.md) + [Migrieren Sie Legacy-Anwendungen von Oracle Pro\$1C zu ECPG](migrate-legacy-applications-from-oracle-pro-c-to-ecpg.md) + [Migrieren Sie Oracle CLOB-Werte in einzelne Zeilen in PostgreSQL auf AWS](migrate-oracle-clob-values-to-individual-rows-in-postgresql-on-aws.md) + [Migrieren Sie Oracle-Datenbank-Fehlercodes in eine Amazon Aurora PostgreSQL-kompatible Datenbank](migrate-oracle-database-error-codes-to-an-amazon-aurora-postgresql-compatible-database.md) + [Migrieren Sie native Oracle-Funktionen mithilfe von Erweiterungen zu PostgreSQL](migrate-oracle-native-functions-to-postgresql-using-extensions.md) + [Migrieren Sie Oracle PeopleSoft zu Amazon RDS Custom](migrate-oracle-peoplesoft-to-amazon-rds-custom.md) + [Migrieren Sie die Oracle ROWID-Funktionalität zu PostgreSQL auf AWS](migrate-oracle-rowid-functionality-to-postgresql-on-aws.md) + [Migrieren Sie Oracle SERIALLY\$1REUSABLE Pragma-Pakete nach PostgreSQL](migrate-oracle-serially-reusable-pragma-packages-into-postgresql.md) + [Migrieren Sie virtuell generierte Spalten von Oracle nach PostgreSQL](migrate-virtual-generated-columns-from-oracle-to-postgresql.md) + [Überwachen Sie GoldenGate Oracle-Protokolle mithilfe von Amazon CloudWatch](monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.md) + [Analysieren Sie Objektabhängigkeiten für partielle Datenbankmigrationen von Oracle nach PostgreSQL](multilevel-object-analysis-for-database-migration-from-oracle-to-postgresql.md) + [Replatform Oracle Database Enterprise Edition auf Standard Edition 2 auf Amazon RDS for Oracle](replatform-oracle-database-enterprise-edition-to-standard-edition-2-on-amazon-rds-for-oracle.md) + [Richten Sie eine HA/DR Architektur für Oracle E-Business Suite auf Amazon RDS Custom mit einer aktiven Standby-Datenbank ein](set-up-an-ha-dr-architecture-for-oracle-e-business-suite-on-amazon-rds-custom-with-an-active-standby-database.md) + [Richten Sie die Oracle UTL\$1FILE-Funktionalität auf Aurora PostgreSQL-Compatible ein](set-up-oracle-utl_file-functionality-on-aurora-postgresql-compatible.md) + [Rollen für eine PeopleSoft Oracle-Anwendung auf Amazon RDS Custom for Oracle wechseln](transition-roles-for-an-oracle-peoplesoft-application-on-amazon-rds-custom-for-oracle.md) + [Datenbankobjekte nach der Migration von Oracle zu Amazon Aurora PostgreSQL validieren](validate-database-objects-after-migrating-from-oracle-to-amazon-aurora-postgresql.md) # SAP **Topics** + [Automatisches Backup von SAP HANA-Datenbanken mit Systems Manager und EventBridge](automatically-back-up-sap-hana-databases-using-systems-manager-and-eventbridge.md) + [Migrieren Sie mithilfe von AWS DMS von SAP ASE zu Amazon RDS for SQL Server](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Migrieren Sie SAP ASE auf Amazon EC2 zu Amazon Aurora PostgreSQL-kompatibel mit AWS SCT und AWS DMS](migrate-sap-ase-on-amazon-ec2-to-amazon-aurora-postgresql-compatible-using-aws-sct-and-aws-dms.md) + [Migrieren Sie SAP HANA zu AWS mithilfe von SAP HSR mit demselben Hostnamen](migrate-sap-hana-to-aws-using-sap-hsr-with-the-same-hostname.md) + [Disaster Recovery für SAP auf IBM Db2 auf AWS einrichten](set-up-disaster-recovery-for-sap-on-ibm-db2-on-aws.md) # Mehr Muster **Topics** + [Greifen Sie von einem Amazon EKS-Container aus auf eine Amazon Neptune-Datenbank zu](access-amazon-neptune-database-from-amazon-eks-container.md) + [Mit Athena auf Amazon DynamoDB-Tabellen zugreifen, diese abfragen und verbinden](access-query-and-join-amazon-dynamodb-tables-using-athena.md) + [Erlauben Sie EC2 Instances den Schreibzugriff auf S3-Buckets in AMS-Konten](allow-ec2-instances-write-access-to-s3-buckets-in-ams-accounts.md) + [Analysieren und visualisieren Sie verschachtelte JSON-Daten mit Amazon Athena und Amazon Quick Sight](analyze-and-visualize-nested-json-data-with-amazon-athena-and-amazon-quicksight.md) + [Automatisieren Sie Backups für Amazon RDS for PostgreSQL PostgreSQL-DB-Instances mithilfe von AWS Batch](automate-backups-for-amazon-rds-for-postgresql-db-instances-by-using-aws-batch.md) + [Automatisches Archivieren von Elementen in Amazon S3 mithilfe von DynamoDB TTL](automatically-archive-items-to-amazon-s3-using-dynamodb-ttl.md) + [Automatically remediate unencrypted Amazon RDS DB instances and clusters](automatically-remediate-unencrypted-amazon-rds-db-instances-and-clusters.md) + [Automatisches Stoppen und Starten einer Amazon RDS-DB-Instance mithilfe von AWS Systems Manager Maintenance Windows](automatically-stop-and-start-an-amazon-rds-db-instance-using-aws-systems-manager-maintenance-windows.md) + [Erstellen Sie eine AWS landing zone, die MongoDB Atlas enthält](build-aws-landing-zone-that-includes-mongodb-atlas.md) + [Erstellen Sie COBOL Db2-Programme mit und AWS Mainframe Modernization AWS CodeBuild](build-cobol-db2-programs-mainframe-modernization-codebuild.md) + [Bauen Sie mit Amazon ein Datennetz für Unternehmen auf DataZone AWS CDK, und AWS CloudFormation](build-enterprise-data-mesh-amazon-data-zone.md) + [Ändern Sie Python- und Perl-Anwendungen, um die Datenbankmigration von Microsoft SQL Server zur Amazon Aurora PostgreSQL-Compatible Edition zu unterstützen](change-python-and-perl-applications-to-support-database-migration-from-microsoft-sql-server-to-amazon-aurora-postgresql-compatible-edition.md) + [EBCDIC-Daten mithilfe von Python in ASCII auf AWS konvertieren und entpacken](convert-and-unpack-ebcdic-data-to-ascii-on-aws-by-using-python.md) + [Konvertieren Sie die temporale Funktion Teradata NORMALIZE in Amazon Redshift SQL](convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql.md) + [Konvertieren Sie die Teradata RESET WHEN-Funktion in Amazon Redshift SQL](convert-the-teradata-reset-when-feature-to-amazon-redshift-sql.md) + [Konvertiert VARCHAR2 (1) den Datentyp für Oracle in den booleschen Datentyp für Amazon Aurora PostgreSQL](convert-varchar2-1-data-type-for-oracle-to-boolean-data-type-for-amazon-aurora-postgresql.md) + [Anwendungsbenutzer und Rollen in Aurora PostgreSQL-kompatibel erstellen](create-application-users-and-roles-in-aurora-postgresql-compatible.md) + [Erstellen Sie CloudFormation AWS-Vorlagen für AWS DMS-Aufgaben mit Microsoft Excel und Python](create-aws-cloudformation-templates-for-aws-dms-tasks-using-microsoft-excel-and-python.md) + [Stellen Sie DynamoDB-Datensätze mithilfe von Kinesis Data Streams und Firehose an Amazon S3 bereit mit AWS CDK](deliver-dynamodb-records-to-amazon-s3-using-kinesis-data-streams-and-amazon-data-firehose-with-aws-cdk.md) + [Stellen Sie einen Cassandra-Cluster auf Amazon EC2 mit Private Static bereit, um ein IPs Rebalancing zu vermeiden](deploy-a-cassandra-cluster-on-amazon-ec2-with-private-static-ips-to-avoid-rebalancing.md) + [Stellen Sie mithilfe von Terraform einen CockroachDB-Cluster in Amazon EKS bereit](deploy-cockroachdb-on-eks-using-terraform.md) + [Entwickeln Sie mithilfe von RAG und Prompting fortschrittliche, auf KI basierende Chat-Assistenten ReAct](develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.md) + [Emulieren Sie Oracle DR mithilfe einer PostgreSQL-kompatiblen globalen Aurora-Datenbank](emulate-oracle-dr-by-using-a-postgresql-compatible-aurora-global-database.md) + [Aktivieren DB2 Sie die Protokollarchivierung direkt in Amazon S3 in einer IBM Db2-Datenbank](enable-db2-logarchive-directly-to-amazon-s3-in-ibm-db2-database.md) + [Aktivieren Sie die transparente Datenverschlüsselung in Amazon RDS for SQL Server](enable-transparent-data-encryption-in-amazon-rds-for-sql-server.md) + [Exportieren Sie eine Microsoft SQL Server-Datenbank mithilfe von AWS DMS nach Amazon S3](export-a-microsoft-sql-server-database-to-amazon-s3-by-using-aws-dms.md) + [Implementieren Sie SHA1 Hashing für PII-Daten bei der Migration von SQL Server zu PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md) + [Schrittweise Migration von Amazon RDS for Oracle zu Amazon RDS for PostgreSQL mithilfe von Oracle SQL Developer und AWS SCT](incrementally-migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-using-oracle-sql-developer-and-aws-sct.md) + [Laden Sie BLOB-Dateien mithilfe der Dateikodierung in Aurora PostgreSQL-kompatibel in TEXT](load-blob-files-into-text-by-using-file-encoding-in-aurora-postgresql-compatible.md) + [Anmeldeinformationen mit AWS Secrets Manager verwalten](manage-credentials-using-aws-secrets-manager.md) + [Migrieren Sie mithilfe von AWS DMS eine Db2-Datenbank von Amazon EC2 zu Aurora MySQL-kompatibel](migrate-a-db2-database-from-amazon-ec2-to-aurora-mysql-compatible-by-using-aws-dms.md) + [Migrieren Sie mithilfe von AWS DMS eine Microsoft SQL Server-Datenbank von Amazon EC2 zu Amazon DocumentDB](migrate-a-microsoft-sql-server-database-from-amazon-ec2-to-amazon-documentdb-by-using-aws-dms.md) + [Migrieren Sie eine Microsoft SQL Server-Datenbank mithilfe von AWS DMS und AWS SCT zu Aurora MySQL](migrate-a-microsoft-sql-server-database-to-aurora-mysql-by-using-aws-dms-and-aws-sct.md) + [Migrieren Sie Amazon RDS for Oracle zu Amazon RDS for PostgreSQL im SSL-Modus mithilfe von AWS DMS](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-in-ssl-mode-by-using-aws-dms.md) + [Migrieren Sie Amazon RDS for Oracle zu Amazon RDS for PostgreSQL mit AWS SCT und unter Verwendung von und AWS DMS AWS CLI CloudFormation](migrate-amazon-rds-for-oracle-to-amazon-rds-for-postgresql-with-aws-sct-and-aws-dms-using-aws-cli-and-aws-cloudformation.md) + [Migrieren Sie eine Amazon RDS-DB-Instance zu einer anderen VPC oder einem anderen Konto](migrate-an-amazon-rds-db-instance-to-another-vpc-or-account.md) + [Migrieren Sie eine Amazon RDS for Oracle Oracle-Datenbank zu einer anderen AWS-Konto und AWS-Region verwenden Sie sie AWS DMS für die laufende Replikation](migrate-an-amazon-rds-for-oracle-database-to-another-aws-account-and-aws-region-using-aws-dms-for-ongoing-replication.md) + [Migrieren Sie einen Amazon Redshift Redshift-Cluster in eine AWS-Region in China](migrate-an-amazon-redshift-cluster-to-an-aws-region-in-china.md) + [Migrieren Sie eine lokale MariaDB-Datenbank mit nativen Tools zu Amazon RDS for MariaDB](migrate-an-on-premises-mariadb-database-to-amazon-rds-for-mariadb-using-native-tools.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank zu Amazon EC2](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-ec2.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank zu Amazon RDS for SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank mithilfe von Verbindungsservern zu Amazon RDS for SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-linked-servers.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank mit systemeigenen Sicherungs- und Wiederherstellungsmethoden zu Amazon RDS for SQL Server](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-rds-for-sql-server-using-native-backup-and-restore-methods.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank mit AWS DMS zu Amazon Redshift](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-dms.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank mithilfe von AWS SCT-Datenextraktionsagenten zu Amazon Redshift](migrate-an-on-premises-microsoft-sql-server-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.md) + [Migrieren Sie eine lokale Microsoft SQL Server-Datenbank zu Microsoft SQL Server auf Amazon EC2 unter Linux](migrate-an-on-premises-microsoft-sql-server-database-to-microsoft-sql-server-on-amazon-ec2-running-linux.md) + [Migrieren Sie eine lokale MySQL-Datenbank zu Amazon RDS for MySQL](migrate-an-on-premises-mysql-database-to-amazon-rds-for-mysql.md) + [Migrieren Sie eine lokale MySQL-Datenbank zu Aurora MySQL](migrate-an-on-premises-mysql-database-to-aurora-mysql.md) + [Migrieren Sie eine lokale Oracle-Datenbank mithilfe EC2 von Oracle Data Pump zu Amazon](migrate-an-on-premises-oracle-database-to-amazon-ec2-by-using-oracle-data-pump.md) + [Migrieren Sie eine lokale Oracle-Datenbank mit Logstash zu Amazon OpenSearch Service](migrate-an-on-premises-oracle-database-to-amazon-opensearch-service-using-logstash.md) + [Migrieren Sie eine lokale Oracle-Datenbank mit AWS DMS und AWS SCT zu Amazon RDS for MySQL](migrate-an-on-premises-oracle-database-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migrieren Sie eine lokale Oracle-Datenbank zu Amazon RDS for Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle.md) + [Migrieren Sie eine lokale Oracle-Datenbank zu Amazon RDS for Oracle, indem Sie den direkten Oracle Data Pump-Import über einen Datenbank-Link verwenden](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-by-using-direct-oracle-data-pump-import-over-a-database-link.md) + [Migrieren Sie eine lokale Oracle-Datenbank mit Oracle Data Pump zu Amazon RDS for Oracle](migrate-an-on-premises-oracle-database-to-amazon-rds-for-oracle-using-oracle-data-pump.md) + [Migrieren Sie eine lokale Oracle-Datenbank mithilfe eines Oracle-Bystanders und AWS DMS zu Amazon RDS for PostgreSQL](migrate-an-on-premises-oracle-database-to-amazon-rds-for-postgresql-by-using-an-oracle-bystander-and-aws-dms.md) + [Migrieren Sie eine lokale Oracle-Datenbank zu Oracle auf Amazon EC2](migrate-an-on-premises-oracle-database-to-oracle-on-amazon-ec2.md) + [Migrieren Sie eine lokale PostgreSQL-Datenbank zu Aurora PostgreSQL](migrate-an-on-premises-postgresql-database-to-aurora-postgresql.md) + [Migrieren Sie eine lokale ThoughtSpot Falcon-Datenbank zu Amazon Redshift](migrate-an-on-premises-thoughtspot-falcon-database-to-amazon-redshift.md) + [Migrieren Sie mithilfe von AWS DMS und AWS SCT eine Oracle-Datenbank von Amazon EC2 zu Amazon RDS for MariaDB](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-mariadb-using-aws-dms-and-aws-sct.md) + [Migrieren Sie mithilfe von AWS DMS eine Oracle-Datenbank von Amazon EC2 zu Amazon RDS for Oracle](migrate-an-oracle-database-from-amazon-ec2-to-amazon-rds-for-oracle-using-aws-dms.md) + [Migrieren Sie eine Oracle-Datenbank mithilfe von GoldenGate Oracle-Flatfile-Adaptern zu Amazon RDS for Oracle](migrate-an-oracle-database-to-amazon-rds-for-oracle-by-using-oracle-goldengate-flat-file-adapters.md) + [Migrieren Sie eine Oracle-Datenbank mit AWS DMS und AWS SCT zu Amazon Redshift](migrate-an-oracle-database-to-amazon-redshift-using-aws-dms-and-aws-sct.md) + [Migrieren Sie eine Oracle-Datenbank mit AWS DMS und AWS SCT zu Aurora PostgreSQL](migrate-an-oracle-database-to-aurora-postgresql-using-aws-dms-and-aws-sct.md) + [Migrieren Sie eine Oracle JD EnterpriseOne Edwards-Datenbank mithilfe von Oracle Data Pump und AWS DMS zu AWS](migrate-an-oracle-jd-edwards-enterpriseone-database-to-aws-by-using-oracle-data-pump-and-aws-dms.md) + [Migrieren Sie eine partitionierte Oracle-Tabelle mithilfe von AWS DMS zu PostgreSQL](migrate-an-oracle-partitioned-table-to-postgresql-by-using-aws-dms.md) + [Migrieren Sie eine PeopleSoft Oracle-Datenbank mithilfe von AWS DMS zu AWS](migrate-an-oracle-peoplesoft-database-to-aws-by-using-aws-dms.md) + [Migrieren Sie eine Couchbase Server-Datenbank zu Amazon EC2](migrate-couchbase-server-ec2.md) + [Migrieren Sie Daten von einer lokalen Oracle-Datenbank zu Aurora PostgreSQL](migrate-data-from-an-on-premises-oracle-database-to-aurora-postgresql.md) + [Migrieren Sie Daten mithilfe AWS Cloud von Starburst auf](migrate-data-to-the-aws-cloud-by-using-starburst.md) + [Migrieren Sie Db2 for LUW zu Amazon, EC2 indem Sie den Protokollversand verwenden, um die Ausfallzeit zu reduzieren](migrate-db2-for-luw-to-amazon-ec2-by-using-log-shipping-to-reduce-outage-time.md) + [Migrieren Sie Db2 for LUW zu Amazon EC2 mit hochverfügbarer Disaster Recovery](migrate-db2-for-luw-to-amazon-ec2-with-high-availability-disaster-recovery.md) + [Migrieren Sie von Amazon RDS for Oracle zu Amazon RDS for MySQL](migrate-from-amazon-rds-for-oracle-to-amazon-rds-for-mysql.md) + [Migrieren Sie von Couchbase Server zu Couchbase Capella auf AWS](migrate-from-couchbase-server-to-couchbase-capella-on-aws.md) + [Migrieren Sie mithilfe von AWS DMS und AWS SCT von IBM Db2 auf Amazon EC2 zu Aurora PostgreSQL-kompatibel](migrate-from-ibm-db2-on-amazon-ec2-to-aurora-postgresql-compatible-using-aws-dms-and-aws-sct.md) + [Migrieren Sie mithilfe von Materialized Views und AWS DMS von Oracle 8i oder 9i zu Amazon RDS for PostgreSQL](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-materialized-views-and-aws-dms.md) + [Migrieren Sie mithilfe von AWS DMS von Oracle 8i oder 9i zu Amazon RDS for PostgreSQL SharePlex](migrate-from-oracle-8i-or-9i-to-amazon-rds-for-postgresql-using-shareplex-and-aws-dms.md) + [Migrieren Sie mithilfe von Oracle von Oracle Database zu Amazon RDS for PostgreSQL GoldenGate](migrate-from-oracle-database-to-amazon-rds-for-postgresql-by-using-oracle-goldengate.md) + [Migrieren Sie mithilfe von AWS DMS und AWS SCT von Oracle auf Amazon EC2 zu Amazon RDS for MySQL](migrate-from-oracle-on-amazon-ec2-to-amazon-rds-for-mysql-using-aws-dms-and-aws-sct.md) + [Migrieren Sie mit pglogical von PostgreSQL auf Amazon EC2 zu Amazon RDS for PostgreSQL](migrate-from-postgresql-on-amazon-ec2-to-amazon-rds-for-postgresql-using-pglogical.md) + [Migrieren Sie mithilfe von AWS DMS von SAP ASE zu Amazon RDS for SQL Server](migrate-from-sap-ase-to-amazon-rds-for-sql-server-using-aws-dms.md) + [Migrieren Sie funktionsbasierte Indizes von Oracle nach PostgreSQL](migrate-function-based-indexes-from-oracle-to-postgresql.md) + [Migrieren Sie Legacy-Anwendungen von Oracle Pro\$1C zu ECPG](migrate-legacy-applications-from-oracle-pro-c-to-ecpg.md) + [Migrieren Sie EC2 mithilfe des Application Migration Service eine lokale Microsoft SQL Server-Datenbank zu Amazon](migrate-microsoft-sql-server-to-amazon-ec2-using-aws-mgn.md) + [Migrieren Sie lokale Cloudera-Workloads zur Cloudera Data Platform auf AWS](migrate-on-premises-cloudera-workloads-to-cloudera-data-platform-on-aws.md) + [Migrieren Sie lokale MySQL-Datenbanken mit Percona XtraBackup, Amazon EFS und Amazon S3 zu Aurora MySQL](migrate-on-premises-mysql-databases-to-aurora-mysql-using-percona-xtrabackup-amazon-efs-and-amazon-s3.md) + [Migrieren Sie Oracle Business Intelligence 12c von lokalen Servern zur AWS-Cloud](migrate-oracle-business-intelligence-12c-to-the-aws-cloud-from-on-premises-servers.md) + [Migrieren Sie Oracle CLOB-Werte in einzelne Zeilen in PostgreSQL auf AWS](migrate-oracle-clob-values-to-individual-rows-in-postgresql-on-aws.md) + [Migrieren Sie Oracle-Datenbank-Fehlercodes in eine Amazon Aurora PostgreSQL-kompatible Datenbank](migrate-oracle-database-error-codes-to-an-amazon-aurora-postgresql-compatible-database.md) + [Migrieren Sie externe Oracle-Tabellen zu Amazon Aurora PostgreSQL-kompatibel](migrate-oracle-external-tables-to-amazon-aurora-postgresql-compatible.md) + [Migrieren Sie native Oracle-Funktionen mithilfe von Erweiterungen zu PostgreSQL](migrate-oracle-native-functions-to-postgresql-using-extensions.md) + [Migrieren Sie Oracle PeopleSoft zu Amazon RDS Custom](migrate-oracle-peoplesoft-to-amazon-rds-custom.md) + [Migrieren Sie die Oracle ROWID-Funktionalität zu PostgreSQL auf AWS](migrate-oracle-rowid-functionality-to-postgresql-on-aws.md) + [Migrieren Sie Oracle SERIALLY\$1REUSABLE Pragma-Pakete nach PostgreSQL](migrate-oracle-serially-reusable-pragma-packages-into-postgresql.md) + [Migrieren Sie SAP ASE auf Amazon EC2 zu Amazon Aurora PostgreSQL-kompatibel mit AWS SCT und AWS DMS](migrate-sap-ase-on-amazon-ec2-to-amazon-aurora-postgresql-compatible-using-aws-sct-and-aws-dms.md) + [Migrieren Sie virtuell generierte Spalten von Oracle nach PostgreSQL](migrate-virtual-generated-columns-from-oracle-to-postgresql.md) + [Richten Sie einen nutzbaren Mindestdatenraum für die gemeinsame Nutzung von Daten zwischen Organisationen ein](minimum-viable-data-space-share-data-organizations.md) + [Überwachen Sie ElastiCache Amazon-Cluster auf Verschlüsselung im Ruhezustand](monitor-amazon-elasticache-clusters-for-at-rest-encryption.md) + [Abfragen von Amazon DynamoDB-Tabellen mit SQL mithilfe von Amazon Athena](query-amazon-dynamodb-tables-sql-amazon-athena.md) + [Sicherer und optimierter Benutzerzugriff in einer Db2-Verbunddatenbank auf AWS mithilfe vertrauenswürdiger Kontexte](secure-and-streamline-user-access-in-a-db2-federation-database-on-aws-by-using-trusted-contexts.md) + [Richten Sie eine hochverfügbare PeopleSoft Architektur auf AWS ein](set-up-a-highly-available-peoplesoft-architecture-on-aws.md) + [Richten Sie die Oracle UTL\$1FILE-Funktionalität auf Aurora PostgreSQL-Compatible ein](set-up-oracle-utl_file-functionality-on-aurora-postgresql-compatible.md) + [Optimieren Sie PostgreSQL-Bereitstellungen auf Amazon EKS mithilfe von PGO](streamline-postgresql-deployments-amazon-eks-pgo.md) + [Übertragung umfangreicher z/OS Db2-Daten in CSV-Dateien nach Amazon S3](transfer-large-scale-db2-z-os-data-to-amazon-s3-in-csv-files.md) + [Transportieren Sie PostgreSQL-Datenbanken zwischen zwei Amazon RDS-DB-Instances mithilfe von pg\$1transport](transport-postgresql-databases-between-two-amazon-rds-db-instances-using-pg-transport.md) + [Datenbankobjekte nach der Migration von Oracle zu Amazon Aurora PostgreSQL validieren](validate-database-objects-after-migrating-from-oracle-to-amazon-aurora-postgresql.md)
conn_string = "dbname='%s' port='%s' user='%s' password='%s' host='%s'" \
% (redshift_db,
secret_dict["port"],
secret_dict["username"],
secret_dict["password"],
secret_dict["host"])
con = psycopg2.connect(conn_string)
unload_command = "UNLOAD ('{}') TO '{}' IAM_ROLE '{}' DELIMITER '|' REGION '{}';" \
.format(sql_query,
s3_bucket_path + str(datetime.datetime.now()) + ".csv",
chained_s3_write_role,
s3_bucket_region)
# Opening a cursor and run query
cur = con.cursor()
cur.execute(unload_command)
print(cur.fetchone())
cur.close()
con.close()