Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Null-ETL-Integrationen von Amazon RDS
Es handelt sich um eine vollständig verwaltete Lösung, die Transaktionsdaten in Ihrem Analyseziel verfügbar macht, nachdem diese in eine RDS-Datenbank geschrieben wurden. *Extract, Transform,* *Load* (ETL) bezeichnet die Kombination von Daten aus mehreren Quellen in einem großen, zentralen Data Warehouse.
Eine Null-ETL-Integration macht die Daten in Ihrer RDS-Datenbank in Amazon Redshift oder einem Amazon SageMaker AI -Lakehouse nahezu in Echtzeit verfügbar. Sobald sich diese Daten im Ziel-Data Warehouse oder Data Lake befinden, können Sie Ihre Analyse-, ML- und KI-Workloads mithilfe der integrierten Funktionen wie maschinelles Lernen, materialisierte Ansichten, Datenaustausch, Verbundzugriff auf mehrere Datenspeicher und Data Lakes sowie Integrationen mit Amazon SageMaker AI, Quick und anderen unterstützen. AWS-Services
Um eine Null-ETL-Integration zu erstellen, geben Sie eine RDS-Datenbank als *Quelle* und ein unterstütztes Data Warehouse oder Lakehouse als *Ziel* an. Bei der Integration werden Daten aus der Quelldatenbank in das Ziel-Data-Warehouse oder -Lakehouse repliziert.
Das folgende Diagramm veranschaulicht diese Funktion für die Null-ETL-Integration mit Amazon Redshift:
![\[Eine Null-ETL-Integration\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/zero-etl-integrations.png)
Das folgende Diagramm veranschaulicht diese Funktion für die Null-ETL-Integration mit einem Amazon SageMaker AI -Lakehouse:
![\[Eine Zero-ETL-Integration mit einem Lakehouse Amazon SageMaker AI\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/zero-etl-rds-lakehouse.png)
Die Integration überwacht den Zustand der Datenpipeline und behebt nach Möglichkeit Probleme. Sie können Integrationen aus mehreren RDS-Datenbanken in ein einziges Ziel-Data-Warehouse oder -Lakehouse erstellen und dadurch Erkenntnisse aus mehreren Anwendungen gewinnen.
**Topics**
+ [Vorteile](#zero-etl.benefits)
+ [Die wichtigsten Konzepte](#zero-etl.concepts)
+ [Einschränkungen](#zero-etl.reqs-lims)
+ [Kontingente](#zero-etl.quotas)
+ [Unterstützte Regionen](#zero-etl.regions)
+ [Erste Schritte mit Null-ETL-Integrationen von Amazon RDS](zero-etl.setting-up.md)
+ [Erstellen von Null-ETL-Integrationen von Amazon RDS mit Amazon Redshift](zero-etl.creating.md)
+ [Erstellen von Null-ETL-Integrationen von Amazon RDS mit einem Amazon SageMaker-Lakehouse](zero-etl.creating-smlh.md)
+ [Datenfilterung für Null-ETL-Integrationen für Amazon RDS](zero-etl.filtering.md)
+ [Hinzufügen von Daten zu einer RDS-Quelldatenbank und Abfragen der Daten](zero-etl.querying.md)
+ [Anzeigen und Überwachen von Null-ETL-Integrationen von Amazon RDS](zero-etl.describingmonitoring.md)
+ [Ändern der Null-ETL-Integrationen von Amazon RDS](zero-etl.modifying.md)
+ [Löschen von Null-ETL-Integrationen von Amazon RDS](zero-etl.deleting.md)
+ [Fehlerbehebung bei Null-ETL-Integrationen von Amazon RDS](zero-etl.troubleshooting.md)
## Vorteile
Null-ETL-Integrationen von RDS bieten die folgenden Vorteile:
+ Sie helfen Ihnen dabei, ganzheitliche Erkenntnisse aus mehreren Datenquellen zu gewinnen.
+ Eliminieren Sie die Erfordernis zur Erstellung und Verwaltung komplexer Daten-Pipelines, die Extract, Transform, Load (ETL)-Operationen ausführen. Null-ETL-Integrationen beseitigen die Herausforderungen, die mit dem Aufbau und der Verwaltung von Pipelines einhergehen, indem sie diese für Sie bereitstellen und verwalten.
+ Sie reduzieren den Betriebsaufwand und die Kosten, sodass Sie sich ganz auf die Verbesserung Ihrer Anwendungen konzentrieren können.
+ Sie ermöglichen die Nutzung der Analyse- und ML-Funktionen des Ziels zum Gewinnen von Erkenntnissen aus Transaktions- und anderen Daten, um effektiv auf (zeit-)kritische Ereignisse reagieren zu können.
## Die wichtigsten Konzepte
Wenn Sie mit Null-ETL-Integrationen beginnen, sollten Sie die folgenden Konzepte berücksichtigen:
**Integration**
Eine vollständig verwaltete Daten-Pipeline, die automatisch Transaktionsdaten und Schemata aus einer RDS-Datenbank in ein Data Warehouse oder einen Katalog repliziert.
**Quelldatenbank**
Die RDS-Datenbank, von wo aus die Daten repliziert werden. Sie können eine Single-AZ- oder Multi-AZ-DB-Instance oder einen Multi-AZ-DB-Cluster (nur für RDS für MySQL) angeben.
**Target**
Das Data Warehouse oder Lakehouse, in das die Daten repliziert werden. Es gibt zwei Arten von Data Warehouse: ein [bereitgestelltes Cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html)-Data-Warehouse und ein [Serverless](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-workgroup-namespace.html)-Data-Warehouse. Ein bereitgestelltes Cluster-Data-Warehouse ist eine Sammlung von Datenverarbeitungsressourcen, den sogenannten Knoten, die zu einer Gruppe, einem sogenannten *Cluster*, zusammengefasst werden. Ein Serverless-Data-Warehouse besteht aus einer Arbeitsgruppe, die Datenverarbeitungsressourcen speichert, und einem Namespace, in dem die Datenbankobjekte und Benutzer gespeichert sind. In beiden Data Warehouses wird eine Analyse-Engine ausgeführt und beide enthalten eine oder mehrere Datenbanken.
Ein Ziel-Lakehouse besteht aus Katalogen, Datenbanken, Tabellen und Ansichten. Weitere Informationen zur Lakehouse-Architektur finden Sie unter [https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/lakehouse-components.html](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/lakehouse-components.html) im *Amazon SageMaker AI Unified Studio-Benutzerhandbuch*.
Mehrere Quelldatenbanken können in dasselbe Ziel schreiben.
Weitere Informationen finden Sie unter [Architektur des Data-Warehouse-Systems](https://docs.aws.amazon.com/redshift/latest/dg/c_high_level_system_architecture.html) im *Entwicklerhandbuch zu Amazon Redshift*.
## Einschränkungen
Die folgenden Einschränkungen gelten für Null-ETL-Integrationen von RDS.
**Topics**
+ [Allgemeine Einschränkungen](#zero-etl.reqs-lims-general)
+ [Einschränkungen von RDS für MySQL](#zero-etl.reqs-lims-mysql)
+ [Einschränkungen bei RDS für PostgreSQL](#zero-etl.reqs-lims-rds-postgres)
+ [Beschränkungen von RDS für Oracle](#zero-etl.reqs-lims-oracle)
+ [Einschränkungen für Amazon Redshift](#zero-etl.reqs-lims-redshift)
+ [Amazon SageMaker AI Lakehouse-Einschränkungen](#zero-etl.reqs-lims-sagemaker-)
### Allgemeine Einschränkungen
+ Die Quelldatenbank muss sich in derselben Region befinden wie das Ziel.
+ Sie können eine Datenbank nicht umbenennen, wenn das Element über bestehende Integrationen verfügt.
+ Sie können nicht mehrere Integrationen zwischen derselben Quell- und Zieldatenbank erstellen.
+ Sie können eine Datenbank mit bestehenden Integrationen nicht löschen. Sie müssen zuerst alle zugehörigen Integrationen löschen.
+ Wenn Sie die Quelldatenbank anhalten, werden die letzten Transaktionen möglicherweise erst dann in das Ziel repliziert, wenn Sie die Datenbank fortsetzen.
+ Sie können eine Integration nicht löschen, wenn die Quelldatenbank angehalten ist.
+ Wenn die Datenbank die Quelle einer Blau/Grün-Bereitstellung ist, können die blaue und die grüne Umgebung während der Umstellung keine vorhandenen Null-ETL-Integrationen haben. Sie müssen zuerst die Integration löschen und umstellen. Anschließend erstellen Sie die Integration neu.
+ Sie können keine Integration für eine Quelldatenbank erstellen, für die aktiv eine andere Integration erstellt wird.
+ Wenn Sie zum ersten Mal eine Integration erstellen oder wenn eine Tabelle erneut synchronisiert wird, kann das Seeding von Daten von der Quelle zum Ziel je nach Größe der Quelldatenbank 20 bis 25 Minuten oder länger dauern. Diese Verzögerung kann zu einer erhöhten Replikatverzögerung führen.
+ Einige Datentypen werden nicht unterstützt. Weitere Informationen finden Sie unter [Datentypunterschiede zwischen RDS und Amazon Redshift-Datenbanken](zero-etl.querying.md#zero-etl.data-type-mapping).
+ Systemtabellen, temporäre Tabellen und Ansichten werden nicht in Ziel-Warehouses repliziert.
+ Das Ausführen von DDL-Befehlen (z. B. `ALTER TABLE`) für eine Quelltabelle kann eine erneute Synchronisierung der Tabelle auslösen, wobei die Tabelle während der erneuten Synchronisierung nicht mehr abgefragt werden kann. Weitere Informationen finden Sie unter [Eine oder mehrere meiner Amazon-Redshift-Tabellen erfordern eine erneute Synchronisation](zero-etl.troubleshooting.md#zero-etl.troubleshooting.resync).
### Einschränkungen von RDS für MySQL
+ In Ihrer Quelldatenbank muss eine unterstützte Version von RDS für MySQL ausgeführt werden. Eine Liste der unterstützten Versionen finden Sie unter [Unterstützte Regionen und DB-Engines für Amazon-RDS-Null-ETL-Integrationen](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
+ Zero-ETL-Integrationen werden nicht sowohl auf der primären Instance als auch auf einer Read Replica-Instance in derselben Region unterstützt. AWS
+ Null-ETL-Integrationen benötigen die MySQL-Binärprotokollierung (Binlog), um laufende Datenänderungen zu erfassen. Verwenden Sie keine Binlog-basierte Datenfilterung, da dies zu Dateninkonsistenzen zwischen der Quell- und der Zieldatenbank führen kann.
+ Null-ETL-Integrationen werden nur für Datenbanken unterstützt, die für die Verwendung der InnoDB-Speicher-Engine konfiguriert sind.
+ Fremdschlüsselverweise mit vordefinierten Tabellenaktualisierungen werden nicht unterstützt. Insbesondere werden `ON DELETE`- und `ON UPDATE`-Regeln mit `CASCADE`-, `SET NULL`- und `SET DEFAULT`-Aktionen nicht unterstützt. Der Versuch, eine Tabelle mit solchen Verweisen in einer anderen Tabelle zu erstellen oder zu aktualisieren, führt zu einem Fehlschlag der Tabelle.
+ Sie können keine Integration für eine Quelldatenbank erstellen, die Magnetspeicher verwendet.
### Einschränkungen bei RDS für PostgreSQL
+ Die Quelldatenbank muss eine Instance von RDS für PostgreSQL mit Version 15.7\$1, 16.3\$1 oder 17.1\$1 sein. Frühere Versionen werden nicht unterstützt.
+ Zero-ETL-Integrationen von RDS für PostgreSQL unterstützen keine Multi-AZ-DB-Cluster als Quelldatenbanken.
+ Sie können keine Null-ETL-Integration aus einer Lesereplikat-Instance von RDS für PostgreSQL erstellen.
+ Nicht protokollierte PostgreSQL-Tabellen und materialisierte Ansichten werden nicht in Amazon Redshift repliziert.
+ Die Replikation bestimmter PostgreSQL-Datentypen wie [Geometriedatentypen](https://www.postgresql.org/docs/current/datatype-geometric.html) und Daten mit mehr als 64 KB wird aufgrund von Einschränkungen in Amazon Redshift nicht unterstützt. Weitere Informationen zu den Datentypunterschieden zwischen RDS für PostgreSQL und Amazon Redshift finden Sie unter [RDS für PostgreSQL](zero-etl.querying.md#zero-etl.data-type-mapping-postgres) im Abschnitt **Datentypunterschiede**.
+ Sie können kein [Hauptversion-Upgrade](USER_UpgradeDBInstance.PostgreSQL.md) für die Quell-Instance von RDS für PostgreSQL durchführen, solange sie über eine aktive Null-ETL-Integration verfügt. Um die Quell-Instance zu aktualisieren, müssen Sie zunächst alle vorhandenen Null-ETL-Integrationen löschen. Nachdem das Hauptversion-Upgrade abgeschlossen ist, können Sie die Null-ETL-Integrationen erneut erstellen.
+ Wenn Sie [deklarative Partitionierungstransaktionen](https://www.postgresql.org/docs/current/ddl-partitioning.html#DDL-PARTITIONING-DECLARATIVE) auf der Quell-DB-Instance durchführen, gehen alle betroffenen Tabellen in den Status „failed“ über und sind nicht mehr abrufbar.
### Beschränkungen von RDS für Oracle
+ Bei der Quelldatenbank muss es sich um eine Instance von RDS für Oracle handeln, auf der Version 19c Enterprise Edition oder Standard Edition 2, Versionsupdate vom Juli 2019 oder später ausgeführt wird. Frühere Versionen werden nicht unterstützt.
+ Sie können keine Null-ETL-Integration aus einer Lesereplikat-Instance von RDS für Oracle erstellen.
+ Sie können eine [Tenant-Datenbank](Oracle.Concepts.CDBs.md) nicht umbenennen, wenn in dieser Tenant-Datenbank eine Null-ETL-Integration vorhanden ist.
+ Eine Tenant-Datenbank kann nur eine Null-ETL-Integration haben.
+ RDS für Oracle und Amazon Redshift weisen einige Datentypunterschiede auf. Weitere Informationen finden Sie unter [RDS für Oracle](zero-etl.querying.md#zero-etl.data-type-mapping-oracle) im Abschnitt **Unterschiede zwischen Datentypen**.
### Einschränkungen für Amazon Redshift
Eine Liste der Einschränkungen von Amazon Redshift im Zusammenhang mit Null-ETL-Integrationen finden Sie unter [Überlegungen bei der Verwendung von Null-ETL-Integrationen mit Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl.reqs-lims.html) im *Amazon-Redshift-Managementleitfaden*.
### Amazon SageMaker AI Lakehouse-Einschränkungen
Im Folgenden finden Sie eine Einschränkung für Amazon SageMaker AI Lakehouse Zero-ETL-Integrationen.
+ Katalognamen sind auf von 64 Zeichen beschränkt.
## Kontingente
Für Ihr Konto gelten die folgenden Kontingente in Bezug auf Null-ETL-Integrationen von RDS. Jedes Kontingent gilt pro Region, sofern nicht anders angegeben.
| Name | Standard | Description |
| --- | --- | --- |
| Integrationen | 100 | Die Gesamtzahl der Integrationen innerhalb eines AWS-Konto. |
| Integrationen pro Ziel | 50 | Die Anzahl der Integrationen, die Daten an ein einzelnes Ziel-Data-Warehouse oder -Lakehouse senden. |
| Integrationen pro Quell-Instance | 5 | Die Anzahl der Integrationen, die Daten von einer einzelnen DB-Instance senden. |
Darüber hinaus legt das Ziel-Warehouse bestimmte Einschränkungen für die Anzahl der zulässigen Tabellen in jeder DB-Instance oder jedem Cluster-Knoten fest. Weitere Informationen finden Sie unter [ Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Amazon-Redshift-Managementleitfaden*.
## Unterstützte Regionen
RDS Zero-ETL-Integrationen sind in einer Teilmenge von verfügbar. AWS-Regionen Eine Liste der unterstützten -Regionen finden Sie unter [Unterstützte Regionen und DB-Engines für Amazon-RDS-Null-ETL-Integrationen](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
# Erste Schritte mit Null-ETL-Integrationen von Amazon RDS
Bevor Sie eine Null-ETL-Integration erstellen, konfigurieren Sie Ihre RDS-Datenbank und Ihr Data Warehouse mit den erforderlichen Parametern und Berechtigungen. Während der Einrichtung führen Sie die folgenden Schritte aus:
1. [Erstellen einer benutzerdefinierten DB--Parametergruppe.](#zero-etl.parameters)
1. [Erstellen Sie eine Quelldatenbank](#zero-etl.create-cluster).
1. [Erstellen Sie ein Ziel-Data Warehouse für Amazon Redshift](#zero-etl-setting-up.data-warehouse) oder [Erstellen Sie ein Ziel-Amazon SageMaker Lakehouse](#zero-etl-setting-up.sagemaker).
Wenn Sie diese Aufgaben abgeschlossen haben, fahren Sie mit [Erstellen von Null-ETL-Integrationen von Amazon RDS mit Amazon Redshift](zero-etl.creating.md) oder [Erstellen von Null-ETL-Integrationen von Amazon RDS mit einem Amazon SageMaker-Lakehouse](zero-etl.creating-smlh.md) fort.
**Tipp**
Sie können RDS diese Einrichtungsschritte für Sie ausführen lassen, während Sie die Integration erstellen, anstatt sie manuell durchzuführen. Um sofort mit der Erstellung einer Integration zu beginnen, siehe [Erstellen von Null-ETL-Integrationen von Amazon RDS mit Amazon Redshift](zero-etl.creating.md).
In Schritt 3 können Sie je nach Ihren Anforderungen entweder ein Ziel-Data-Warehouse (Schritt 3a) oder ein Ziel-Lakehouse (Schritt 3b) erstellen:
+ Entscheiden Sie sich für ein Data Warehouse, wenn Sie herkömmliche Data-Warehousing-Funktionen mit SQL-basierten Analysen benötigen.
+ Entscheiden Sie sich für Amazon SageMaker Lakehouse, wenn Sie Funktionen für maschinelles Lernen benötigen und Lakehouse-Funktionen für Data-Science- und ML-Workflows verwenden möchten.
## Schritt 1: Erstellen einer benutzerdefinierten DB--Parametergruppe
Null-ETL-Integrationen von Amazon RDS erfordern bestimmte Werte für die DB-Parameter, die die Datenreplikation steuern. Die konkreten Parameter hängen von Ihrer Quell-DB-Engine ab. Um diese Parameter zu konfigurieren, müssen Sie zunächst eine benutzerdefinierte DB-Parametergruppe erstellen und sie dann mit der Quelldatenbank verknüpfen. Konfigurieren Sie die folgenden Parameterwerte je nach Ihrer Quell-DB-Engine. Anleitungen zum Erstellen einer Parametergruppe finden Sie unter [DB-Parametergruppen für DB-Instances von Amazon RDS](USER_WorkingWithDBInstanceParamGroups.md). Wir empfehlen, alle Parameterwerte innerhalb derselben Anfrage zu konfigurieren, um Abhängigkeitsprobleme zu vermeiden.
**RDS für MySQL**
+ `binlog_format=ROW`
+ `binlog_row_image=full`
Stellen Sie außerdem sicher, dass der `binlog_row_value_options`-Parameter *nicht* auf `PARTIAL_JSON` gesetzt ist. Wenn die Quelldatenbank ein Multi-AZ-DB-Cluster ist, stellen Sie sicher, dass der Parameter `binlog_transaction_compression` *nicht* auf `ON` festgelegt ist.
Einige dieser Parameter (z. B. `binlog_format`) sind dynamisch, was bedeutet, dass Sie Änderungen am Parameter vornehmen können, ohne einen Neustart auszulösen. Dies bedeutet, dass einige bestehende Sitzungen möglicherweise weiterhin den alten Wert des Parameters verwenden. Um zu verhindern, dass dies zu Problemen bei der Erstellung einer Null-ETL-Integration führt, aktivieren Sie das [Leistungsschema](USER_PerfInsights.EnableMySQL.md). Das Leistungsschema stellt sicher, dass Null-ETL-Vorabprüfungen ausgeführt werden, mit deren Hilfe fehlende Parameter frühzeitig im Prozess erkannt werden können.
**RDS für PostgreSQL**:
+ `rds.logical_replication = 1`
+ `rds.replica_identity_full = 1`
+ `session_replication_role = origin`
+ `wal_sender_timeout ≥ 20000 or = 0`
+ `max_wal_senders ≥ 20`
+ `max_replication_slots ≥ 20`
Bei mehreren PostgreSQL-Integrationen wird pro Integration ein logischer Replikationsslot verwendet. Überprüfen Sie die Parameter `max_replication_slots` und `max_wal_senders` je nach Nutzung.
Für eine effiziente Datensynchronisierung in Null-ETL-Integrationen legen Sie `rds.replica_identity_full` in Ihrer Quell-DB-Instance fest. Dadurch wird die Datenbank angewiesen, während der `UPDATE`- und `DELETE`-Operationen [vollständige Zeilendaten](https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-REPLICA-IDENTITY) im Write-Ahead-Protokoll (WAL) zu protokollieren, nicht nur Primärschlüsselinformationen. Null-ETL benötigt vollständige Zeilendaten, auch wenn für alle replizierten Tabellen Primärschlüssel erforderlich sind. Um festzustellen, welche Daten bei Abfragen sichtbar sind, verwendet Amazon Redshift eine spezielle Anti-Join-Strategie, um Ihre Daten zur Nachverfolgung von Löschvorgängen mit einer internen Tabelle zu vergleichen. Durch das Protokollieren vollständiger Zeilenbilder kann Amazon Redshift diese Anti-Joins effizient durchführen. Ohne vollständige Zeilendaten müsste Amazon Redshift zusätzliche Suchvorgänge durchführen, was die Leistung bei Vorgängen mit hohem Durchsatz in der von Amazon Redshift verwendeten Spalten-Engine beeinträchtigen könnte.
**Wichtig**
Wenn Sie die Replikatidentität so einrichten, dass ganze Zeilen protokolliert werden, [erhöht sich Ihr WAL-Volumen](https://www.postgresql.org/docs/current/runtime-config-wal.html#GUC-WAL-LEVEL), was zu einer höheren Schreibverstärkung und I/O -nutzung führen kann, insbesondere bei breiten Tabellen oder häufigen Aktualisierungen. Um auf diese Auswirkungen vorbereitet zu sein, sollten Sie Ihre Speicherkapazität und I/O Anforderungen planen, Ihr WAL-Wachstum überwachen und die Verzögerung bei der Replikation bei schreibintensiven Workloads verfolgen.
**RDS für Oracle**
Bei RDS für Oracle sind keine Parameteränderungen erforderlich.
## Schritt 2: Wählen oder Erstellen einer Quelldatenbank
Nachdem Sie eine benutzerdefinierte DB-Parametergruppe erstellt haben, wählen oder erstellen Sie eine DB-Instance von RDS für MySQL . Diese Datenbank dient als Quelle der Datenreplikation in das Ziel-Data-Warehouse. Anleitungen zum Erstellen einer DB-Instance mit Single-AZ oder Multi-AZ finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md). Anweisungen zum Erstellen eines Multi-AZ-DB-Clusters (nur RDS für MySQL) finden Sie unter[Erstellen eines Multi-AZ-DB-Clusters für Amazon RDS](create-multi-az-db-cluster.md).
In der Datenbank muss eine unterstützte DB-Engine-Version ausgeführt werden. Eine Liste der unterstützten Versionen finden Sie unter [Unterstützte Regionen und DB-Engines für Amazon-RDS-Null-ETL-Integrationen](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
Wenn Sie die Datenbank erstellen, ändern Sie unter **Zusätzliche Konfiguration** die Standard-**DB--Parametergruppe** in die benutzerdefinierte Parametergruppe, die Sie im vorherigen Schritt erstellt haben.
**Anmerkung**
Wenn Sie die Parametergruppe mit der Datenbank verknüpfen, *nachdem* die Datenbank bereits erstellt wurde, müssen Sie die Datenbank neu starten, damit die Änderungen angewendet werden, bevor Sie eine Null-ETL-Integration erstellen können. Anleitungen finden Sie unter [Eine DB-Instance DB-Cluster neu starten](USER_RebootInstance.md) oder [Neustarten von Multi-AZ-DB-Clustern und Reader-DB-Instances für Amazon RDS](multi-az-db-clusters-concepts-rebooting.md).
Stellen Sie außerdem sicher, dass automatisierte Backups in der Datenbank aktiviert sind. Weitere Informationen finden Sie unter [Aktivieren von automatisierten Backups](USER_WorkingWithAutomatedBackups.Enabling.md).
## Schritt 3a: Erstellen eines Ziel-Data-Warehouse
Nachdem Sie die Quelldatenbank erstellt haben, müssen Sie ein Ziel-Data-Warehouse erstellen und konfigurieren. Das Data Warehouse muss die folgenden Anforderungen erfüllen:
+ Verwendung eines RA3 Knotentyps mit mindestens zwei Knoten oder Redshift Serverless.
+ Es muss verschlüsselt sein (bei Verwendung eines bereitgestellten Clusters). Weitere Informationen finden Sie unter [Datenbankverschlüsselung in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
Anweisungen zum Erstellen eines Data Warehouse finden Sie unter [Erstellen eines Clusters](https://docs.aws.amazon.com/redshift/latest/mgmt/create-cluster) für bereitgestellte Cluster oder [Erstellen einer Arbeitsgruppe mit einem Namespace](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-console-workgroups-create-workgroup-wizard.html) für Redshift Serverless.
### Aktivieren Sie die Berücksichtigung von Groß- und Kleinschreibung im Data Warehouse
Damit die Integration erfolgreich ist, muss der Parameter für die Berücksichtigung von Groß- und Kleinschreibung ([https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html)) für das Data Warehouse aktiviert sein. Standardmäßig ist die Berücksichtigung von Groß- und Kleinschreibung auf allen bereitgestellten Clustern und Redshift-Serverless-Arbeitsgruppen deaktiviert.
Um die Berücksichtigung von Groß- und Kleinschreibung zu aktivieren, führen Sie je nach Data-Warehouse-Typ die folgenden Schritte aus:
+ **Bereitgestellter Cluster** – Um die Berücksichtigung von Groß- und Kleinschreibung in einem bereitgestellten Cluster zu aktivieren, erstellen Sie eine benutzerdefinierte Parametergruppe mit aktiviertem `enable_case_sensitive_identifier`-Parameter. Ordnen Sie diese Parametergruppe dann dem Cluster zu. Anweisungen finden Sie unter [Verwalten von Parametergruppen mit der Konsole](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-parameter-groups-console.html) oder [Konfigurieren von Parameterwerten mit der AWS CLI](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html#configure-parameters-using-the-clil).
**Anmerkung**
Denken Sie daran, den Cluster neu zu starten, nachdem Sie ihm die benutzerdefinierte Parametergruppe zugeordnet haben.
+ **Serverless-Arbeitsgruppe** – Um die Berücksichtigung von Groß- und Kleinschreibung in einer Redshift-Serverless-Arbeitsgruppe zu aktivieren, müssen Sie die AWS CLI verwenden. Die Amazon-Redshift-Konsole unterstützt derzeit nicht das Ändern von Redshift-Serverless-Parameterwerten. Senden Sie die folgende [update-workgroup](https://docs.aws.amazon.com/cli/latest/reference/redshift-serverless/update-workgroup.html)-Anfrage:
```
aws redshift-serverless update-workgroup \
--workgroup-name target-workgroup \
--config-parameters parameterKey=enable_case_sensitive_identifier,parameterValue=true
```
Sie müssen eine Arbeitsgruppe nicht neu starten, nachdem Sie ihre Parameterwerte geändert haben.
### Konfigurieren der Autorisierung für das Data Warehouse
Nachdem Sie ein Data Warehouse erstellt haben, müssen Sie die RDS-Quelldatenbank als autorisierte Integrationsquelle konfigurieren. Anleitungen finden Sie unter [Konfigurieren der Autorisierung für Ihr Amazon-Redshift-Data-Warehouse](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam).
## Richten Sie eine Integration mit dem ein AWS SDKs
Anstatt jede Ressource manuell einzurichten, können Sie das folgende Python-Skript ausführen, um die erforderlichen Ressourcen automatisch einzurichten. Das Codebeispiel verwendet das [AWS SDK für Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html), um eine DB-Instance von RDS für MySQL und ein Ziel-Data-Warehouse zu erstellen, jeweils mit den erforderlichen Parameterwerten. Dann wird abgewartet, bis die Datenbanken verfügbar sind, bevor eine Null-ETL-Integration zwischen ihnen erstellt wird. Sie können verschiedene Funktionen auskommentieren, je nachdem, welche Ressourcen Sie einrichten müssen.
Führen Sie die folgenden Befehle aus, um die erforderlichen Abhängigkeiten zu installieren:
```
pip install boto3
pip install time
```
Innerhalb des Skripts können Sie optional die Namen der Quell-, Ziel- und Parametergruppen ändern. Die letzte Funktion erstellt eine Integration namens `my-integration` nach der Einrichtung der Ressourcen.
### Python-Codebeispiel
```
import boto3
import time
# Build the client using the default credential configuration.
# You can use the CLI and run 'aws configure' to set access key, secret
# key, and default Region.
rds = boto3.client('rds')
redshift = boto3.client('redshift')
sts = boto3.client('sts')
source_db_name = 'my-source-db' # A name for the source database
source_param_group_name = 'my-source-param-group' # A name for the source parameter group
target_cluster_name = 'my-target-cluster' # A name for the target cluster
target_param_group_name = 'my-target-param-group' # A name for the target parameter group
def create_source_db(*args):
"""Creates a source RDS for MySQL DB instance"""
response = rds.create_db_parameter_group(
DBParameterGroupName=source_param_group_name,
DBParameterGroupFamily='mysql8.0',
Description='RDS for MySQL zero-ETL integrations'
)
print('Created source parameter group: ' + response['DBParameterGroup']['DBParameterGroupName'])
response = rds.modify_db_parameter_group(
DBParameterGroupName=source_param_group_name,
Parameters=[
{
'ParameterName': 'binlog_format',
'ParameterValue': 'ROW',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'binlog_row_image',
'ParameterValue': 'full',
'ApplyMethod': 'pending-reboot'
}
]
)
print('Modified source parameter group: ' + response['DBParameterGroupName'])
response = rds.create_db_instance(
DBInstanceIdentifier=source_db_name,
DBParameterGroupName=source_param_group_name,
Engine='mysql',
EngineVersion='8.0.32',
DBName='mydb',
DBInstanceClass='db.m5.large',
AllocatedStorage=15,
MasterUsername='username',
MasterUserPassword='Password01**'
)
print('Creating source database: ' + response['DBInstance']['DBInstanceIdentifier'])
source_arn = (response['DBInstance']['DBInstanceArn'])
create_target_cluster(target_cluster_name, source_arn, target_param_group_name)
return(response)
def create_target_cluster(target_cluster_name, source_arn, target_param_group_name):
"""Creates a target Redshift cluster"""
response = redshift.create_cluster_parameter_group(
ParameterGroupName=target_param_group_name,
ParameterGroupFamily='redshift-1.0',
Description='RDS for MySQL zero-ETL integrations'
)
print('Created target parameter group: ' + response['ClusterParameterGroup']['ParameterGroupName'])
response = redshift.modify_cluster_parameter_group(
ParameterGroupName=target_param_group_name,
Parameters=[
{
'ParameterName': 'enable_case_sensitive_identifier',
'ParameterValue': 'true'
}
]
)
print('Modified target parameter group: ' + response['ParameterGroupName'])
response = redshift.create_cluster(
ClusterIdentifier=target_cluster_name,
NodeType='ra3.4xlarge',
NumberOfNodes=2,
Encrypted=True,
MasterUsername='username',
MasterUserPassword='Password01**',
ClusterParameterGroupName=target_param_group_name
)
print('Creating target cluster: ' + response['Cluster']['ClusterIdentifier'])
# Retrieve the target cluster ARN
response = redshift.describe_clusters(
ClusterIdentifier=target_cluster_name
)
target_arn = response['Clusters'][0]['ClusterNamespaceArn']
# Retrieve the current user's account ID
response = sts.get_caller_identity()
account_id = response['Account']
# Create a resource policy granting access to source database and account ID
response = redshift.put_resource_policy(
ResourceArn=target_arn,
Policy='''
{
\"Version\":\"2012-10-17\",
\"Statement\":[
{\"Effect\":\"Allow\",
\"Principal\":{
\"Service\":\"redshift.amazonaws.com\"
},
\"Action\":[\"redshift:AuthorizeInboundIntegration\"],
\"Condition\":{
\"StringEquals\":{
\"aws:SourceArn\":\"%s\"}
}
},
{\"Effect\":\"Allow\",
\"Principal\":{
\"AWS\":\"arn:aws:iam::%s:root\"},
\"Action\":\"redshift:CreateInboundIntegration\"}
]
}
''' % (source_arn, account_id)
)
return(response)
def wait_for_db_availability(*args):
"""Waits for both databases to be available"""
print('Waiting for source and target to be available...')
response = rds.describe_db_instances(
DBInstanceIdentifier=source_db_name
)
source_status = response['DBInstances'][0]['DBInstanceStatus']
source_arn = response['DBInstances'][0]['DBInstanceArn']
response = redshift.describe_clusters(
ClusterIdentifier=target_cluster_name
)
target_status = response['Clusters'][0]['ClusterStatus']
target_arn = response['Clusters'][0]['ClusterNamespaceArn']
# Every 60 seconds, check whether the databases are available
if source_status != 'available' or target_status != 'available':
time.sleep(60)
response = wait_for_db_availability(
source_db_name, target_cluster_name)
else:
print('Databases available. Ready to create zero-ETL integration.')
create_integration(source_arn, target_arn)
return
def create_integration(source_arn, target_arn):
"""Creates a zero-ETL integration using the source and target databases"""
response = rds.create_integration(
SourceArn=source_arn,
TargetArn=target_arn,
IntegrationName='my-integration'
)
print('Creating integration: ' + response['IntegrationName'])
def main():
"""main function"""
create_source_db(source_db_name, source_param_group_name)
wait_for_db_availability(source_db_name, target_cluster_name)
if __name__ == "__main__":
main()
```
## Schritt 3b: Erstellen Sie einen AWS Glue Katalog für die Amazon SageMaker Lakehouse Zero-ETL-Integration
Wenn Sie eine Zero-ETL-Integration mit einem Amazon SageMaker Lakehouse erstellen, müssen Sie einen AWS Glue verwalteten Katalog in erstellen. AWS Lake Formation Der Zielkatalog muss ein von Amazon Redshift verwalteter Katalog sein. Um einen von Amazon Redshift verwalteten Katalog zu erstellen, erstellen Sie zunächst die serviceverknüpfte Rolle `AWSServiceRoleForRedshift`. Fügen Sie in der Lake-Formation-Konsole `AWSServiceRoleForRedshift` als Administrator mit Leseberechtigung hinzu.
Weitere Informationen zu den oben genannten Aufgaben finden Sie in den folgenden Themen.
+ Informationen zum Erstellen eines von Amazon Redshift verwalteten Katalogs finden Sie unter [Creating an Amazon Redshift managed catalog in the AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/create-rms-catalog.html) im *AWS Lake Formation -Entwicklerhandbuch*.
+ Informationen zur serviceverknüpften Rolle für Amazon Redshift finden Sie unter [Verwenden serviceverknüpfter Rollen für Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/using-service-linked-roles.html) im *Amazon-Redshift-Verwaltungshandbuch*.
+ Informationen zu Leseberechtigungen für Administratoren für Lake Formation finden Sie unter [Lake Formation personas and IAM permissions reference](https://docs.aws.amazon.com/lake-formation/latest/dg/permissions-reference.html) im *AWS Lake Formation -Entwicklerhandbuch*.
### Konfigurieren Sie die Berechtigungen für den Zielkatalog AWS Glue
Bevor Sie einen Zielkatalog für die Zero-ETL-Integration erstellen, müssen Sie die Lake Formation Formation-Zielerstellungsrolle und die AWS Glue Datenübertragungsrolle erstellen. Verwenden Sie die Lake-Formation-Zielerstellungsrolle, um den Zielkatalog zu erstellen. Geben Sie bei der Erstellung des Zielkatalogs die Glue-Datenübertragungsrolle in das Feld **IAM-Rolle** im **Abschnitt „Zugriff von Engines“** ein.
#### Lake-Formation-Zielerstellungsrolle
Die Zielerstellungsrolle muss ein Lake-Formation-Administrator sein. Sie erfordert die folgenden Berechtigungen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "lakeformation:RegisterResource",
"Resource": "*"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"s3:PutEncryptionConfiguration",
"iam:PassRole",
"glue:CreateCatalog",
"glue:GetCatalog",
"s3:PutBucketTagging",
"s3:PutLifecycleConfiguration",
"s3:PutBucketPolicy",
"s3:CreateBucket",
"redshift-serverless:CreateNamespace",
"s3:DeleteBucket",
"s3:PutBucketVersioning",
"redshift-serverless:CreateWorkgroup"
],
"Resource": [
"arn:aws:glue:*:111122223333:catalog",
"arn:aws:glue:*:111122223333:catalog/*",
"arn:aws:s3:::*",
"arn:aws:redshift-serverless:*:111122223333:workgroup/*",
"arn:aws:redshift-serverless:*:111122223333:namespace/*",
"arn:aws:iam::111122223333:role/GlueDataCatalogDataTransferRole"
]
}
]
}
```
------
Die Zielerstellungsrolle muss die folgende Vertrauensstellung aufweisen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:user/Username"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
#### Glue-Datenübertragungsrolle
Die Glue-Datenübertragungsrolle ist für MySQL-Katalogoperationen erforderlich und muss über die folgenden Berechtigungen verfügen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataTransferRolePolicy",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"glue:GetCatalog",
"glue:GetDatabase"
],
"Resource": [
"*"
]
}
]
}
```
------
Die Glue-Datenübertragungsrolle muss die folgende Vertrauensstellung aufweisen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"redshift.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
## Nächste Schritte
Mit einem für die Quell-RDS-Datenbank und entweder einem Amazon Redshift Redshift-Ziel-Data Warehouse oder Amazon SageMaker Lakehouse können Sie eine Zero-ETL-Integration erstellen und Daten replizieren. Detaillierte Anweisungen finden Sie unter [Erstellen von Null-ETL-Integrationen von Amazon RDS mit Amazon Redshift](zero-etl.creating.md).
# Erstellen von Null-ETL-Integrationen von Amazon RDS mit Amazon Redshift
Wenn Sie eine Null-ETL-Integration von Amazon RDS erstellen, geben Sie die Quelldatenbank und das Ziel-Data-Warehouse von Amazon Redshift an. Sie können auch die Verschlüsselungseinstellungen anpassen und Tags hinzufügen. Amazon RDS erstellt eine Integration zwischen der Quell-Datenbank und dem jeweiligen Ziel. Sobald die Integration aktiv ist, werden alle Daten, die Sie in die Quelldatenbank einfügen, in das konfigurierte Amazon-Redshift-Ziel repliziert.
## Voraussetzungen
Bevor Sie eine Null-ETL-Integration, müssen Sie eine Quelldatenbank und ein Ziel-Data-Warehouse von Amazon Redshift erstellen. Außerdem müssen Sie die Replikation in das Data Warehouse zulassen, indem Sie die Datenbank als autorisierte Integrationsquelle hinzufügen.
Anleitungen zum Ausführen der einzelnen Schritte finden Sie unter [Erste Schritte mit Null-ETL-Integrationen von Amazon RDS](zero-etl.setting-up.md).
## Erforderliche Berechtigungen
Bestimmte IAM-Berechtigungen sind erforderlich, um eine Null-ETL-Integration zu erstellen. Sie benötigen mindestens die Berechtigungen, um die folgenden Aktionen durchführen zu können:
+ Erstellen Sie Null-ETL-Integrationen für die Quell-RDS-Datenbank.
+ Anzeigen und Löschen aller Null-ETL-Integrationen.
+ Erstellen eingehender Integrationen in das Ziel-Data-Warehouse.
Die folgende Beispielrichtlinie zeigt die [die geringsten Berechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege), die zum Erstellen und Verwalten von Integrationen erforderlich sind. Möglicherweise benötigen Sie nicht genau diese Berechtigungen, wenn Ihr Benutzer oder Ihre Rolle über umfassendere Berechtigungen verfügt, z. B. über eine von `AdministratorAccess` verwaltete Richtlinie.
**Anmerkung**
Redshift Amazon Resource Names (ARNs) haben das folgende Format. Beachten Sie die Verwendung eines Schrägstrichs `(/`) anstelle eines Doppelpunkts (`:`) vor der Serverless-Namespace-UUID.
Bereitgestellter Cluster – `arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid`
Serverless – `arn:aws:redshift-serverless:{region}:{account-id}:namespace/namespace-uuid`
### Beispielrichtlinie für Redshift-Ziel
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CreateIntegration",
"Effect": "Allow",
"Action": [
"rds:CreateIntegration"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:db:source-db",
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "DescribeIntegrationDetails",
"Effect": "Allow",
"Action": [
"rds:DescribeIntegrations"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "ChangeIntegrationDetails",
"Effect": "Allow",
"Action": [
"rds:DeleteIntegration",
"rds:ModifyIntegration"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "AllowRedShiftIntegration",
"Effect": "Allow",
"Action": [
"redshift:CreateInboundIntegration"
],
"Resource": [
"arn:aws:redshift:us-east-1:123456789012:namespace:namespace-uuid"
]
}
]
}
```
------
### Auswählen eines Ziel-Data-Warehouse in einem anderen Konto
Wenn Sie ein Amazon Redshift Redshift-Ziel-Data Warehouse angeben möchten, das sich in einem anderen befindet AWS-Konto, müssen Sie eine Rolle erstellen, die es Benutzern des aktuellen Kontos ermöglicht, auf Ressourcen im Zielkonto zuzugreifen. Weitere Informationen finden Sie unter Gewähren des [Zugriffs für einen IAM-Benutzer in einem anderen AWS-Konto , dem Sie gehören](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
Die Rolle muss über die folgenden Berechtigungen verfügen, die es dem Benutzer ermöglichen, verfügbare von Amazon Redshift bereitgestellte Cluster und Redshift-Serverless-Namespaces im Zielkonto einzusehen.
#### Erforderliche Berechtigungen und Vertrauensrichtlinie
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"redshift:DescribeClusters",
"redshift-serverless:ListNamespaces"
],
"Resource":[
"*"
]
}
]
}
```
------
Die Rolle muss über die folgende Vertrauensrichtlinie verfügen, die die Zielkonto-ID angibt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Anleitungen zum Erstellen der Rolle finden Sie unter [Erstellen einer Rolle mit benutzerdefinierten Vertrauensrichtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Erstellen von Null-ETL-Integrationen
Sie können eine Zero-ETL-Integration mithilfe der AWS-Managementkonsole, der oder der AWS CLI RDS-API erstellen.
**Wichtig**
Null-ETL-Integrationen unterstützen keine Aktualisierungs- oder Resynchronisierungsvorgänge. Wenn Sie nach der Erstellung auf Probleme mit einer Integration stoßen, müssen Sie die Integration löschen und eine neue erstellen.
Standardmäßig löscht RDS für MySQL binäre Protokolldateien sofort. Da Null-ETL-Integrationen auf Binärprotokolle angewiesen sind, um Daten von der Quelle zum Ziel zu replizieren, muss der Aufbewahrungszeitraum für die Quelldatenbank mindestens eine Stunde betragen. Sobald Sie eine Integration erstellen, überprüft Amazon RDS den Aufbewahrungszeitraum für die binäre Protokolldatei für die ausgewählte Quelldatenbank. Wenn der aktuelle Wert 0 Stunden beträgt, ändert Amazon RDS ihn automatisch in 1 Stunde. Andernfalls bleibt der Wert gleich.
### RDS-Konsole
**So erstellen Sie eine Null-ETL-Integration**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im linken Navigationsbereich **Null-ETL-Integrationen** aus.
1. Wählen Sie **Null-ETL-Integration erstellen** aus.
1. Geben Sie für **Integrationskennung** einen Namen für die Integration ein. Der Name kann bis zu 63 alphanumerische Zeichen umfassen und Bindestriche enthalten.
**Wichtig**
Katalognamen sind auf von 64 Zeichen beschränkt. Stellen Sie sicher, dass die Integrations-ID diese Anforderung erfüllt, wenn sie als Katalogname verwendet werden soll.
1. Wählen Sie **Weiter** aus.
1. Wählen Sie als **Quelle** des Ursprungs der Daten die RDS-Datenbank aus.
**Anmerkung**
RDS benachrichtigt Sie, wenn die DB--Parameter nicht korrekt konfiguriert sind. Wenn Sie diese Nachricht erhalten, können Sie entweder **Reparieren** wählen oder eine manuelle Konfiguration vornehmen. Anleitungen zur manuellen Behebung finden Sie unter [Schritt 1: Erstellen einer benutzerdefinierten DB--Parametergruppe](zero-etl.setting-up.md#zero-etl.parameters).
Das Ändern der DB--Parameter erfordert einen Neustart. Bevor Sie die Integration erstellen können, müssen der Neustart abgeschlossen und die neuen Parameterwerte erfolgreich auf die Datenbank angewendet werden.
1. Sobald die Quelldatenbank erfolgreich konfiguriert wurde, wählen Sie **Weiter** aus.
1. Gehen Sie bei **Ziel** wie folgt vor:
1. (Optional) Um ein anderes AWS-Konto für das Amazon Redshift Redshift-Ziel zu verwenden, wählen Sie Anderes **Konto angeben** aus. Geben Sie dann den Namen einer IAM-Rolle mit Berechtigungen zur Anzeige Ihrer Data Warehouses ein. Anleitungen zum Erstellen der IAM-Rolle finden Sie unter [Auswählen eines Ziel-Data-Warehouse in einem anderen Konto](#zero-etl.create-permissions-cross-account).
1. Wählen Sie für **Amazon Redshift Data Warehouse** das Ziel für replizierte Daten aus der Quelldatenbank aus. Sie können einen bereitgestellten Amazon-Redshift-*Cluster* oder einen Redshift-Serverless-*Namespace* als Ziel auswählen.
**Anmerkung**
RDS benachrichtigt Sie, wenn die Ressourcenrichtlinie oder die Einstellungen zur Berücksichtigung der Groß- und Kleinschreibung für das angegebene Data Warehouse nicht korrekt konfiguriert sind. Wenn Sie diese Nachricht erhalten, können Sie entweder **Reparieren** wählen oder eine manuelle Konfiguration vornehmen. Anweisungen zur manuellen Behebung finden Sie unter [Aktivieren der Groß- und Kleinschreibung für Ihr Data Warehouse](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity) und [Konfigurieren der Autorisierung für Ihr Data Warehouse](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam) im *Amazon Redshift Management Guide*.
Das Ändern der Groß- und Kleinschreibung für einen *bereitgestellten* Redshift-Cluster erfordert einen Neustart. Bevor Sie die Integration erstellen können, muss der Neustart abgeschlossen und der neue Parameterwert erfolgreich auf den Cluster angewendet werden.
Wenn sich Ihre gewählte Quelle und Ihr Ziel in verschiedenen AWS-Konten befinden, kann Amazon RDS diese Einstellungen nicht für Sie korrigieren. Sie müssen zu dem anderen Konto navigieren und diese manuell in Amazon Redshift korrigieren.
1. Sobald Ihr Ziel-Data Warehouse korrekt konfiguriert ist, wählen Sie **Weiter**.
1. (Optional) Fügen Sie unter **Tags** ein oder mehrere Tags zu der Integration hinzu. Weitere Informationen finden Sie unter [Taggen von Amazon RDS-Ressourcen](USER_Tagging.md).
1. Geben Sie für **Verschlüsselung** an, wie Ihre Integration verschlüsselt werden soll. Standardmäßig verschlüsselt RDS alle Integrationen mit einem. AWS-eigener Schlüssel Um stattdessen einen vom Kunden verwalteten Schlüssel auszuwählen, aktivieren Sie die Option **Verschlüsselungseinstellungen anpassen** und wählen Sie einen KMS-Schlüssel aus, der für die Verschlüsselung verwendet werden soll. Weitere Informationen finden Sie unter [Verschlüsseln von Amazon RDS-Ressourcen](Overview.Encryption.md).
Fügen Sie optional einen Verschlüsselungskontext hinzu. Weitere Informationen finden Sie unter [Verschlüsselungskontext](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) im *AWS Key Management Service -Entwicklerhandbuch*.
**Anmerkung**
Amazon RDS fügt zusätzlich zu den von Ihnen hinzugefügten Paaren die folgenden Verschlüsselungskontextpaare hinzu:
`aws:redshift:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `Redshift`
Dadurch wird die Gesamtzahl der Paare, die Sie hinzufügen können, von 8 auf 6 reduziert, was zur Gesamtzeichenbegrenzung der Erteilungsbeschränkung beiträgt. Weitere Informationen finden Sie unter [Verwenden von Erteilungsbeschränkungen](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints) im *Entwicklerhandbuch für AWS Key Management Service *.
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie Ihre Integrationseinstellungen und wählen Sie **Null-ETL-Integration erstellen** aus.
Wenn die Erstellung fehlschlägt, finden Sie Informationen zur Fehlerbehebung unter [Ich kann keine Null-ETL-Integration erstellen](zero-etl.troubleshooting.md#zero-etl.troubleshooting.creation).
Der Status der Integration lautet während der Erstellung `Creating`. Das Ziel-Data-Warehouse von Amazon Redshift hat den Status `Modifying`. Während dieser Zeit können Sie das Data Warehouse nicht abfragen und keine Konfigurationsänderungen daran vornehmen.
Wenn die Integration erfolgreich erstellt wurde, ändern sich sowohl der Status der Integration als auch der Status des Ziel-Data-Warehouse von Amazon Redshift in `Active`.
### AWS CLI
Um eine Zero-ETL-Integration mit dem zu erstellen AWS CLI, verwenden Sie den Befehl [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) mit den folgenden Optionen:
**Anmerkung**
Denken Sie daran, dass Katalognamen auf 19 Zeichen beschränkt sind. Wählen Sie Ihren Integrationsnamen entsprechend aus, wenn er als Katalogname verwendet werden soll.
+ `--integration-name` – Geben Sie einen Namen für die Integration an.
+ `--source-arn` – Geben Sie als Quelle für die Integration den ARN der RDS-Datenbank an.
+ `--target-arn` – Geben Sie den ARN des Amazon Redshift Data Warehouse an, das das Ziel für die Integration sein soll.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-integration \
--integration-name my-integration \
--source-arn arn:aws:rds:{region}:{account-id}:my-db \
--target-arn arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid
```
Für Windows:
```
aws rds create-integration ^
--integration-name my-integration ^
--source-arn arn:aws:rds:{region}:{account-id}:my-db ^
--target-arn arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid
```
### RDS-API
Verwenden Sie die [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html)-Operation mit den folgenden Parametern, um mithilfe der Amazon-RDS-API eine Null-ETL-Integration zu erstellen:
**Anmerkung**
Katalognamen sind auf 19 Zeichen beschränkt. Stellen Sie sicher, dass Ihr IntegrationName Parameter diese Anforderung erfüllt, wenn er als Katalogname verwendet werden soll.
+ `IntegrationName` – Geben Sie einen Namen für die Integration an.
+ `SourceArn` – Geben Sie als Quelle für die Integration den ARN der RDS-Datenbank an.
+ `TargetArn` – Geben Sie den ARN des Amazon Redshift Data Warehouse an, das das Ziel für die Integration sein soll.
## Verschlüsseln von Integrationen mit einem vom Kunden verwalteten Schlüssel
Wenn Sie AWS-eigener Schlüssel beim Erstellen einer Integration einen benutzerdefinierten KMS-Schlüssel anstelle eines angeben, muss die Schlüsselrichtlinie dem Amazon Redshift Redshift-Serviceprinzipal Zugriff auf die `CreateGrant` Aktion gewähren. Darüber hinaus muss es dem aktuellen Benutzer die Ausführung der Aktionen `DescribeKey` und `CreateGrant` ermöglicht werden.
Die folgende Beispielrichtlinie demonstriert, wie die erforderlichen Berechtigungen in der Schlüsselrichtlinie bereitgestellt werden. Sie enthält Kontextschlüssel, um den Umfang der Berechtigungen weiter zu reduzieren.
### Beispiel für eine Schlüsselrichtlinie
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Key policy",
"Statement": [
{
"Sid": "Enables IAM user permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "Allows the Redshift service principal to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"Service": "redshift.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "Allows the current user or role to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}",
"kms:ViaService": "rds.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "Allows the current uer or role to retrieve information about a KMS key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:DescribeKey",
"Resource": "*"
}
]
}
```
------
Weitere Informationen finden Sie unter [Erstellen einer Schlüsselrichtlinie](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) im *AWS Key Management Service -Entwicklerhandbuch*.
## Nächste Schritte
Nachdem Sie erfolgreich eine Null-ETL-Integration erstellt haben, müssen Sie eine Zieldatenbank in Ihrem Amazon-Redshift-Zielcluster oder Ihrer Zielarbeitsgruppe erstellen. Anschließend können Sie damit beginnen, Daten zur RDS-Quelldatenbank hinzuzufügen und in Amazon Redshift abzufragen. Anleitungen finden Sie unter [Erstellen von Zieldatenbanken in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html).
# Erstellen von Null-ETL-Integrationen von Amazon RDS mit einem Amazon SageMaker-Lakehouse
Wenn Sie eine Amazon RDS Zero-ETL-Integration mit einem Amazon SageMaker Lakehouse erstellen, geben Sie den der Quell-RDS-Datenbank und den verwalteten AWS Glue Zielkatalog an. Sie können auch die Verschlüsselungseinstellungen anpassen und Tags hinzufügen. Amazon RDS erstellt eine Integration zwischen der Quell-Datenbank und dem jeweiligen Ziel. Sobald die Integration aktiv ist, werden alle Daten, die Sie in die Quell-DB-Instance einfügen, in das konfigurierte Ziel repliziert.
## Voraussetzungen
Bevor Sie eine Zero-ETL-Integration mit einem Amazon SageMaker Lakehouse erstellen, müssen Sie einen erstellen. AWS Glue Außerdem müssen Sie die Replikation in den Katalog zulassen, indem Sie die Datenbank als autorisierte Integrationsquelle hinzufügen.
Anleitungen zum Ausführen der einzelnen Schritte finden Sie unter [Erste Schritte mit Null-ETL-Integrationen von Amazon RDS](zero-etl.setting-up.md).
## Erforderliche Berechtigungen
Bestimmte IAM-Berechtigungen sind erforderlich, um eine Null-ETL-Integration mit einem Amazon SageMaker-Lakehouse zu erstellen. Sie benötigen mindestens die Berechtigungen, um die folgenden Aktionen durchführen zu können:
+ Erstellen Sie Null-ETL-Integrationen für die Quell-RDS-Datenbank.
+ Anzeigen und Löschen aller Null-ETL-Integrationen.
+ Erstellen Sie eingehende Integrationen in den verwalteten Zielkatalog. AWS Glue
+ Greifen Sie auf Amazon S3 S3-Buckets zu, die vom AWS Glue verwalteten Katalog verwendet werden.
+ Verwenden Sie AWS KMS Schlüssel für die Verschlüsselung, wenn eine benutzerdefinierte Verschlüsselung konfiguriert ist.
+ Registrieren Sie Ressourcen bei Lake Formation.
+ Fügen Sie dem AWS Glue verwalteten Katalog eine Ressourcenrichtlinie hinzu, um eingehende Integrationen zu autorisieren.
Die folgende Beispielrichtlinie zeigt die [geringsten Berechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege), die zum Erstellen und Verwalten von Integrationen in ein Amazon SageMaker-Lakehouse erforderlich sind. Möglicherweise benötigen Sie nicht genau diese Berechtigungen, wenn Ihr Benutzer oder Ihre Rolle über umfassendere Berechtigungen verfügt, z. B. über eine von `AdministratorAccess` verwaltete Richtlinie.
Darüber hinaus müssen Sie eine Ressourcenrichtlinie für den AWS Glue verwalteten Zielkatalog konfigurieren, um eingehende Integrationen zu autorisieren. Verwenden Sie den folgenden AWS CLI Befehl, um die Ressourcenrichtlinie anzuwenden.
### AWS CLI Beispielbefehl zur Autorisierung eingehender Integrationen im Zielkatalog
```
aws glue put-resource-policy \
--policy-in-json '{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": [
"glue:AuthorizeInboundIntegration"
],
"Resource": ["arn:aws:glue:region:account_id:catalog/catalog_name"],
"Condition": {
"StringEquals": {
"aws:SourceArn": "arn:aws:rds:region:account_id:db:source_name"
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "account_id"
},
"Action": ["glue:CreateInboundIntegration"],
"Resource": ["arn:aws:glue:region:account_id:catalog/catalog_name"]
}
]
}' \
--region region
```
**Anmerkung**
Amazon Resource Names (ARNs) für den Glue-Katalog haben das folgende Format:
Glue-Katalog – `arn:aws:glue:{region}:{account-id}:catalog/catalog-name`
### Auswahl eines AWS Glue verwalteten Zielkatalogs in einem anderen Konto
Wenn Sie einen AWS Glue verwalteten Zielkatalog angeben möchten, der sich in einem anderen AWS-Konto befindet, müssen Sie eine Rolle erstellen, die es Benutzern im aktuellen Konto ermöglicht, auf Ressourcen im Zielkonto zuzugreifen. Weitere Informationen finden Sie unter Gewähren [des Zugriffs für einen IAM-Benutzer in einem anderen AWS-Konto , dem Sie gehören.](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html)
Die Rolle muss über die folgenden Berechtigungen verfügen, die es dem Benutzer ermöglichen, die verfügbaren AWS Glue Kataloge im Zielkonto einzusehen.
#### Erforderliche Berechtigungen und Vertrauensrichtlinie
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"glue:GetCatalog"
],
"Resource":[
"*"
]
}
]
}
```
------
Die Rolle muss über die folgende Vertrauensrichtlinie verfügen, die die Zielkonto-ID angibt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"AWS": "arn:aws:iam::111122223333:root"
},
"Action":"sts:AssumeRole"
}
]
}
```
------
Anleitungen zum Erstellen der Rolle finden Sie unter [Erstellen einer Rolle mit benutzerdefinierten Vertrauensrichtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Erstellen von Null-ETL-Integrationen mit einem Amazon SageMaker-Lakehouse
Sie können eine Zero-ETL-Integration mit einem Amazon SageMaker Lakehouse mithilfe der AWS-Managementkonsole, der oder der AWS CLI RDS-API erstellen.
**Wichtig**
Null-ETL-Integrationen mit einem Amazon SageMaker Lakehouse unterstützen keine Aktualisierungs- oder Resynchronisierungsvorgänge. Wenn Sie nach der Erstellung auf Probleme mit einer Integration stoßen, müssen Sie die Integration löschen und eine neue erstellen.
Standardmäßig löscht RDS für MySQL binäre Protokolldateien sofort. Da Null-ETL-Integrationen auf Binärprotokolle angewiesen sind, um Daten von der Quelle zum Ziel zu replizieren, muss der Aufbewahrungszeitraum für die Quelldatenbank mindestens eine Stunde betragen. Sobald Sie eine Integration erstellen, überprüft Amazon RDS den Aufbewahrungszeitraum für die binäre Protokolldatei für die ausgewählte Quelldatenbank. Wenn der aktuelle Wert 0 Stunden beträgt, ändert Amazon RDS ihn automatisch in 1 Stunde. Andernfalls bleibt der Wert gleich.
### RDS-Konsole
**So erstellen Sie eine Null-ETL-Integration mit einem Amazon SageMaker Lakehouse**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im linken Navigationsbereich **Null-ETL-Integrationen** aus.
1. Wählen Sie **Null-ETL-Integration erstellen** aus.
1. Geben Sie für **Integrationskennung** einen Namen für die Integration ein. Der Name kann bis zu 63 alphanumerische Zeichen umfassen und Bindestriche enthalten.
1. Wählen Sie **Weiter** aus.
1. Wählen Sie als **Quelle** des Ursprungs der Daten die RDS-Datenbank aus.
**Anmerkung**
RDS benachrichtigt Sie, wenn die DB--Parameter nicht korrekt konfiguriert sind. Wenn Sie diese Nachricht erhalten, können Sie entweder **Reparieren** wählen oder eine manuelle Konfiguration vornehmen. Anleitungen zur manuellen Behebung finden Sie unter [Schritt 1: Erstellen einer benutzerdefinierten DB--Parametergruppe](zero-etl.setting-up.md#zero-etl.parameters).
Das Ändern der DB--Parameter erfordert einen Neustart. Bevor Sie die Integration erstellen können, müssen der Neustart abgeschlossen und die neuen Parameterwerte erfolgreich auf die Datenbank angewendet werden.
1. Sobald die Quelldatenbank erfolgreich konfiguriert wurde, wählen Sie **Weiter** aus.
1. Gehen Sie bei **Ziel** wie folgt vor:
1. (Optional) Um ein anderes AWS-Konto für das Amazon SageMaker Lakehouse-Ziel zu verwenden, wählen Sie Anderes **Konto angeben** aus. Geben Sie dann den ARN einer IAM-Rolle mit Berechtigungen zum Anzeigen Ihrer AWS Glue Kataloge ein. Anleitungen zum Erstellen der IAM-Rolle finden Sie unter [Auswahl eines AWS Glue verwalteten Zielkatalogs in einem anderen Konto](#zero-etl.create-permissions-cross-account-smlh).
1. Wählen Sie für **AWS Glue -Katalog** das Ziel für replizierte Daten aus der Quell-Datenbank aus. Sie haben die Möglichkeit einen vorhandenen verwalteten AWS Glue -Katalog als Ziel zu verwenden.
1. Die Ziel-IAM-Rolle muss über Beschreibungsberechtigungen für den Zielkatalog sowie über die folgenden Berechtigungen verfügen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "glue:GetCatalog",
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog/*",
"arn:aws:glue:us-east-1:111122223333:catalog"
]
}
]
}
```
------
Die Ziel-IAM-Rolle muss über die folgende Vertrauensstellung aufweisen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Sie müssen der Ziel-IAM-Rolle Beschreibungsberechtigungen für den AWS Glue verwalteten Zielkatalog mit der Lake Formation-Administratorrolle gewähren, die in [Schritt 3b: Erstellen Sie einen AWS Glue Katalog für die Amazon SageMaker Lakehouse Zero-ETL-Integration](zero-etl.setting-up.md#zero-etl-setting-up.sagemaker) erstellt wurde.
**Anmerkung**
RDS benachrichtigt Sie, wenn die Ressourcenrichtlinien oder die Konfigurationseinstellungen für den angegebenen AWS Glue verwalteten Katalog nicht korrekt konfiguriert sind. Wenn Sie diese Nachricht erhalten, können Sie entweder **Reparieren** wählen oder eine manuelle Konfiguration vornehmen.
Wenn sich Ihre gewählte Quelle und Ihr Ziel in verschiedenen AWS-Konten befinden, kann Amazon RDS diese Einstellungen nicht für Sie korrigieren. Sie müssen zu dem anderen Konto navigieren und sie manuell in SageMaker Unified Studio korrigieren.
1. Sobald Ihr AWS Glue verwalteter Zielkatalog korrekt konfiguriert ist, wählen Sie **Weiter**.
1. (Optional) Fügen Sie unter **Tags** ein oder mehrere Tags zu der Integration hinzu. Weitere Informationen finden Sie unter [Taggen von Amazon RDS-Ressourcen](USER_Tagging.md).
1. Geben Sie für **Verschlüsselung** an, wie Ihre Integration verschlüsselt werden soll. Standardmäßig verschlüsselt RDS alle Integrationen mit einem. AWS-eigener Schlüssel Um stattdessen einen vom Kunden verwalteten Schlüssel auszuwählen, aktivieren Sie die Option **Verschlüsselungseinstellungen anpassen** und wählen Sie einen KMS-Schlüssel aus, der für die Verschlüsselung verwendet werden soll. Weitere Informationen finden Sie unter [Verschlüsseln von Amazon RDS-Ressourcen](Overview.Encryption.md).
Fügen Sie optional einen Verschlüsselungskontext hinzu. Weitere Informationen finden Sie unter [Verschlüsselungskontext](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) im *AWS Key Management Service -Entwicklerhandbuch*.
**Anmerkung**
Amazon RDS fügt zusätzlich zu den von Ihnen hinzugefügten Paaren die folgenden Verschlüsselungskontextpaare hinzu:
`aws:glue:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `glue`
Dadurch wird die Gesamtzahl der Paare, die Sie hinzufügen können, von 8 auf 6 reduziert, was zur Gesamtzeichenbegrenzung der Erteilungsbeschränkung beiträgt. Weitere Informationen finden Sie unter [Verwenden von Erteilungsbeschränkungen](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints) im *Entwicklerhandbuch für AWS Key Management Service *.
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie Ihre Integrationseinstellungen und wählen Sie **Null-ETL-Integration erstellen** aus.
Wenn die Erstellung fehlschlägt, finden Sie Informationen zur Fehlerbehebung unter [Fehlerbehebung bei Null-ETL-Integrationen von Amazon RDS](zero-etl.troubleshooting.md).
Der Status der Integration lautet während der Erstellung `Creating`. Das Ziel-Lakehouse von Amazon SageMaker hat den Status `Modifying`. Während dieser Zeit können Sie den Katalog weder abfragen noch Konfigurationsänderungen daran vornehmen.
Wenn die Integration erfolgreich erstellt wurde, ändern sich sowohl der Status der Integration als auch der Status des Ziel-Lakehouse von Amazon SageMaker in `Active`.
### AWS CLI
Um einen AWS Glue verwalteten Zielkatalog für die Zero-ETL-Integration mit dem vorzubereiten AWS CLI, müssen Sie zunächst den [create-integration-resource-property](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html)Befehl mit den folgenden Optionen verwenden:
+ `--resource-arn`— Geben Sie den ARN des AWS Glue verwalteten Katalogs an, der das Ziel für die Integration sein soll.
+ `--target-processing-properties`— Geben Sie den ARN der IAM-Rolle an, um auf den AWS Glue verwalteten Zielkatalog zuzugreifen
```
aws glue create-integration-resource-property --region us-east-1
--resource-arn arn:aws:glue:region:account_id:catalog/catalog_name \
--target-processing-properties '{"RoleArn" : "arn:aws:iam::account_id:role/TargetIamRole"}'
```
Um mithilfe von eine Zero-ETL-Integration mit einem Amazon SageMaker Lakehouse zu erstellen AWS CLI, verwenden Sie den Befehl [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) mit den folgenden Optionen:
+ `--integration-name` – Geben Sie einen Namen für die Integration an.
+ `--source-arn` – Geben Sie als Quelle für die Integration den ARN der RDS-Datenbank an.
+ `--target-arn`— Geben Sie den ARN des AWS Glue verwalteten Katalogs an, der das Ziel für die Integration sein soll.
**Example**
Für Linux, macOS oder Unix:
```
aws rds create-integration \
--integration-name my-sagemaker-integration \
--source-arn arn:aws:rds:{region}:{account-id}:cluster:my-db \
--target-arn arn:aws:glue:{region}:{account-id}:catalog/catalog-name
```
Für Windows:
```
aws rds create-integration ^
--integration-name my-sagemaker-integration ^
--source-arn arn:aws:rds:{region}:{account-id}:cluster:my-db ^
--target-arn arn:aws:glue:{region}:{account-id}:catalog/catalog-name
```
### RDS-API
Verwenden Sie den [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html)-Vorgang mit den folgenden Parametern, um eine Null-ETL-Integration mit Amazon SageMaker über die Amazon-RDS-API zu erstellen:
**Anmerkung**
Katalognamen sind auf 19 Zeichen beschränkt. Stellen Sie sicher, dass Ihr IntegrationName Parameter diese Anforderung erfüllt, wenn er als Katalogname verwendet werden soll.
+ `IntegrationName` – Geben Sie einen Namen für die Integration an.
+ `SourceArn` – Geben Sie als Quelle für die Integration den ARN der RDS-Datenbank an.
+ `TargetArn`— Geben Sie den ARN des AWS Glue verwalteten Katalogs an, der das Ziel für die Integration sein soll.
## Verschlüsseln von Integrationen mit einem vom Kunden verwalteten Schlüssel
Wenn Sie AWS-eigener Schlüssel beim Erstellen einer Integration mit einen benutzerdefinierten KMS-Schlüssel und nicht einen angebenAmazon SageMaker, muss die Schlüsselrichtlinie dem SageMaker Unified Studio Dienstprinzipal Zugriff auf die `CreateGrant` Aktion gewähren. Darüber hinaus muss es dem aktuellen Benutzer die Ausführung der Aktionen `DescribeKey` und `CreateGrant` ermöglicht werden.
Die folgende Beispielrichtlinie demonstriert, wie die erforderlichen Berechtigungen in der Schlüsselrichtlinie bereitgestellt werden. Sie enthält Kontextschlüssel, um den Umfang der Berechtigungen weiter zu reduzieren.
### Beispiel für eine Schlüsselrichtlinie
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Key policy",
"Statement": [
{
"Sid": "EnablesIAMUserPermissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "GlueServicePrincipalAddGrant",
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}":"{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "AllowsCurrentUserRoleAddGrantKMSKey",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}":"{context-value}",
"kms:ViaService": "rds.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "AllowsCurrentUserRoleRetrieveKMSKeyInformation",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:DescribeKey",
"Resource": "*"
}
]
}
```
------
Weitere Informationen finden Sie unter [Erstellen einer Schlüsselrichtlinie](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) im *AWS Key Management Service -Entwicklerhandbuch*.
## Nächste Schritte
Nachdem Sie erfolgreich eine Null-ETL-Integration mit Amazon SageMaker erstellt haben, können Sie damit beginnen, der Quell-RDS-Datenbank Daten hinzuzufügen und in Ihrem Amazon SageMaker-Lakehouse abzufragen. Die Daten werden automatisch repliziert und für Analysen und Machine Learning zur Verfügung gestellt.
# Datenfilterung für Null-ETL-Integrationen für Amazon RDS
Null-ETL-Integrationen von Amazon RDS unterstützen die Datenfilterung, mit der Sie steuern können, welche Daten aus Ihrer Quelle, also der Amazon-RDS-Quelldatenbank, in Ihr Ziel-Data-Warehouse repliziert werden. Anstatt die gesamte Datenbank zu replizieren, können Sie einen oder mehrere Filter anwenden, um bestimmte Tabellen ein- oder auszuschließen. Auf diese Weise können Sie die Speicher- und Abfrageleistung optimieren, da nur relevante Daten übertragen werden. Derzeit ist die Filterung auf Datenbank- und Tabellenebene beschränkt. Das Filtern auf Spalten- und Zeilenebene wird nicht unterstützt.
Die Datenfilterung kann nützlich sein, wenn Sie:
+ bestimmte Tabellen aus zwei oder mehr verschiedenen Quell-Datenbanken verknüpfen möchten und nicht alle Daten aus den jeweiligen Datenbanken benötigen;
+ Kosten sparen möchten, indem Sie Analysen nur mit einer Teilmenge von Tabellen und nicht mit einer ganzen Flotte von Datenbanken durchführen;
+ vertrauliche Informationen wie Telefonnummern, Adressen oder Kreditkarteninformationen aus bestimmten Tabellen herausfiltern möchten.
Sie können Datenfilter zu einer Zero-ETL-Integration hinzufügen AWS-Managementkonsole, indem Sie die AWS Command Line Interface (AWS CLI) oder die Amazon RDS-API verwenden.
Wenn die Integration einen bereitgestellten Cluster als Ziel hat, muss sich der Cluster auf [Patch 180](https://docs.aws.amazon.com/redshift/latest/mgmt/cluster-versions.html#cluster-version-180) oder höher befinden, um die Datenfilterung verwenden zu können.
**Topics**
+ [Format eines Datenfilters](#zero-etl.filtering-format)
+ [Filterlogik](#zero-etl.filtering-evaluate)
+ [Rangfolge der Filter](#zero-etl.filtering-precedence)
+ [Beispiele für RDS für MySQL](#zero-etl.filtering-examples-mysql)
+ [Beispiele für RDS für PostgreSQL](#zero-etl.filtering-examples-postgres)
+ [Beispiele für RDS für Oracle](#zero-etl.filtering-examples-oracle)
+ [Hinzufügen von Datenfiltern zu einer Integration](#zero-etl.add-filter)
+ [Entfernen von Datenfiltern aus einer Integration](#zero-etl.remove-filter)
## Format eines Datenfilters
Sie können mehrere Filter für eine einzelne Integration definieren. Jeder Filter schließt alle vorhandenen und künftigen Datenbanktabellen, die einem der Muster im Filterausdruck entsprechen, entweder ein oder aus. Null-ETL-Integrationen von Amazon RDS verwenden die [Maxwell-Filtersyntax](https://maxwells-daemon.io/filtering/) für die Datenfilterung.
Jeder Filter enthält die folgenden Elemente:
| Element | Description |
| --- | --- |
| Filtertyp | Der Filtertyp `Include` schließt alle Tabellen, die einem der Muster im Filterausdruck entsprechen, *ein*. Der Filtertyp `Exclude` schließt alle Tabellen, die einem der Muster entsprechen, *aus*. |
| Filterausdruck | Eine kommagetrennte Liste von Mustern. Ausdrücke müssen die [Maxwell-Filtersyntax](https://maxwells-daemon.io/filtering/) verwenden. |
| Muster | Ein Filtermuster im Format `database.table` für RDS für MySQL oder `database.schema.table` für RDS für PostgreSQL. Sie können Literalnamen angeben oder reguläre Ausdrücke definieren. Für RDS für MySQL werden reguläre Ausdrücke sowohl im Datenbank- als auch im Tabellennamen unterstützt. Für RDS für PostgreSQL werden reguläre Ausdrücke nur im Schema- und Tabellennamen unterstützt, nicht im Datenbanknamen. Sie können keine Filter oder Zugriffsverweigerungslisten auf Spaltenebene einbeziehen. Eine einzelne Integration kann insgesamt maximal 99 Muster haben. In der Konsole können Sie Muster innerhalb eines einzelnen Filterausdrucks eingeben oder sie auf mehrere Ausdrücke verteilen. Ein einzelnes Muster darf maximal 256 Zeichen lang sein. |
**Wichtig**
Wenn Sie eine Quelldatenbank von RDS für PostgreSQL auswählen, müssen Sie mindestens ein Datenfiltermuster angeben. Das Muster muss mindestens eine einzelne Datenbank (`database-name.*.*`) für die Replikation in das Ziel-Data-Warehouse enthalten.
Die folgende Abbildung zeigt die Struktur der Datenfilter für RDS für MySQL in der Konsole:
![\[Datenfilterung für eine Null-ETL-Integration\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/zero-etl-filter.png)
**Wichtig**
Geben Sie in Ihren Filtermustern keine persönlich identifizierenden, vertraulichen oder sensiblen Informationen an.
### Datenfilter im AWS CLI
Wenn Sie den verwenden AWS CLI , um einen Datenfilter hinzuzufügen, unterscheidet sich die Syntax geringfügig von der der Konsole. Sie müssen jedem Muster einzeln einen Filtertyp (`Include` oder `Exclude`) zuweisen, sodass Sie nicht mehrere Muster unter einem Filtertyp gruppieren können.
In der Konsole können Sie beispielsweise die folgenden durch Kommas getrennten Muster unter einer einzigen `Include`-Anweisung gruppieren:
**RDS für MySQL**
```
mydb.mytable, mydb./table_\d+/
```
**RDS für PostgreSQL**
```
mydb.myschema.mytable, mydb.myschema./table_\d+/
```
Wenn Sie den verwenden AWS CLI, muss derselbe Datenfilter jedoch das folgende Format haben:
**RDS für MySQL**
```
'include: mydb.mytable, include: mydb./table_\d+/'
```
**RDS für PostgreSQL**
```
'include: mydb.myschema.mytable, include: mydb.myschema./table_\d+/'
```
## Filterlogik
Wenn Sie in Ihrer Integration keine Datenfilter angeben, geht Amazon RDS vom Standardfilter `include:*.*` aus, der alle Tabellen in das Ziel-Data-Warehouse repliziert. Wenn Sie jedoch mindestens einen Filter hinzufügen, wechselt die Standardlogik zu `exclude:*.*`, wodurch standardmäßig alle Tabellen ausgeschlossen werden. Auf diese Weise können Sie explizit definieren, welche Datenbanken und Tabellen in die Replikation einbezogen werden sollen.
Sie definieren beispielsweise folgenden Filter:
```
'include: db.table1, include: db.table2'
```
Amazon RDS bewertet den Filter wie folgt:
```
'exclude:*.*, include: db.table1, include: db.table2'
```
Daher repliziert Amazon RDS nur `table1` und `table2` von der angegebenen Datenbank `db` in das Ziel-Data-Warehouse.
## Rangfolge der Filter
Amazon RDS wertet Datenfilter in der von Ihnen angegebenen Reihenfolge aus. In der AWS-Managementkonsole verarbeitet er Filterausdrücke von links nach rechts und von oben nach unten. Ein zweiter Filter oder ein individuelles Muster, das dem ersten folgt, kann ihn/es überschreiben.
Wenn der erste Filter beispielsweise `Include books.stephenking` lautet, schließt er nur die Tabelle `stephenking`aus der Datenbank `books` ein. Wenn Sie jedoch einen zweiten Filter `Exclude books.*` hinzufügen, überschreibt dieser den ersten Filter. Dadurch wird verhindert, dass Tabellen aus dem Index `books` in das Ziel-Data-Warehouse repliziert werden.
Wenn Sie mindestens einen Filter angeben, geht die Logik standardmäßig zunächst von `exclude:*.*` aus, wodurch automatisch alle Tabellen von der Replikation *ausgeschlossen* werden. Als bewährte Methode empfiehlt es sich, Filter von allgemein nach spezifisch zu definieren. Beginnen Sie mit einer oder mehreren `Include`-Anweisungen, um die zu replizierenden Daten anzugeben, und fügen Sie dann `Exclude`-Filter hinzu, um bestimmte Tabellen selektiv zu entfernen.
Das gleiche Prinzip gilt für Filter, die Sie mit der AWS CLI definieren. Amazon RDS wertet diese Filtermuster in der Reihenfolge aus, in der Sie sie angeben, sodass ein Muster möglicherweise ein Muster überschreibt, das Sie zuvor angegeben haben.
## Beispiele für RDS für MySQL
Die folgenden Beispiele zeigen, wie die Datenfilterung für Null-ETL-Integrationen in Beispielen für RDS für MySQL funktioniert:
+ Alle Datenbanken und alle Tabellen einschließen:
```
'include: *.*'
```
+ Alle Tabellen in der Datenbank `books` einschließen:
```
'include: books.*'
```
+ Alle Tabellen mit dem Namen `mystery` ausschließen:
```
'include: *.*, exclude: *.mystery'
```
+ Zwei bestimmte Tabellen in der Datenbank `books` einschließen:
```
'include: books.stephen_king, include: books.carolyn_keene'
```
+ Alle Tabellen in der Datenbank `books` einschließen, außer denen, die die Teilzeichenfolge `mystery` enthalten:
```
'include: books.*, exclude: books./.*mystery.*/'
```
+ Alle Tabellen in der Datenbank `books` einschließen, außer denen, die mit `mystery` beginnen:
```
'include: books.*, exclude: books./mystery.*/'
```
+ Alle Tabellen in der Datenbank `books` einschließen, außer denen, die mit `mystery` enden:
```
'include: books.*, exclude: books./.*mystery/'
```
+ Alle Tabellen in der Datenbank `books` einschließen, die mit `table_` beginnen, außer der, die den Namen `table_stephen_king` trägt. Zum Beispiel würde `table_movies` oder `table_books` repliziert werden, `table_stephen_king` aber nicht.
```
'include: books./table_.*/, exclude: books.table_stephen_king'
```
## Beispiele für RDS für PostgreSQL
Die folgenden Beispiele zeigen, wie die Datenfilterung für Null-ETL-Integrationen für RDS für PostgreSQL funktioniert:
+ Alle Tabellen in der Datenbank `books` einschließen:
```
'include: books.*.*'
```
+ Alle Tabellen mit dem Namen `mystery` in der Datenbank `books` ausschließen:
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Eine Tabelle in der Datenbank `books` im Schema `mystery` und eine Tabelle in der Datenbank `employee` im Schema `finance` einschließen:
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Alle Tabellen in der Datenbank `books` und im Schema `science_fiction` einschließen, außer denen, die die Teilzeichenfolge `king` enthalten:
```
'include: books.science_fiction.*, exclude: books.*./.*king.*/
```
+ Alle Tabellen in der Datenbank `books` einschließen, außer denen, deren Schemaname mit `sci` beginnt:
```
'include: books.*.*, exclude: books./sci.*/.*'
```
+ Alle Tabellen in der Datenbank `books` einschließen, außer denen im Schema `mystery`, die mit `king` enden:
```
'include: books.*.*, exclude: books.mystery./.*king/'
```
+ Alle Tabellen in der Datenbank `books` einschließen, die mit `table_` beginnen, außer der, die den Namen `table_stephen_king` trägt. Zum Beispiel werden `table_movies` im Schema `fiction` und `table_books` im Schema `mystery` repliziert, `table_stephen_king` jedoch in keinem Schema:
```
'include: books.*./table_.*/, exclude: books.*.table_stephen_king'
```
## Beispiele für RDS für Oracle
Die folgenden Beispiele zeigen, wie die Datenfilterung für Null-ETL-Integrationen für RDS für Oracle funktioniert:
+ Alle Tabellen in der Datenbank „books“ einschließen:
```
'include: books.*.*'
```
+ Alle Tabellen mit dem Namen „mystery“ in der Datenbank „books“ ausschließen:
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Eine Tabelle in der Datenbank „books“ im Schema „mystery“ und eine Tabelle in der Datenbank „employee“ im Schema „finance“ einschließen:
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Alle Tabellen im Schema „mystery“ in der Datenbank „books“ einschließen:
```
'include: books.mystery.*'
```
### Überlegungen zur Groß-/Kleinschreibung
Oracle Database und Amazon Redshift behandeln die Groß-/Kleinschreibung von Objektnamen unterschiedlich, was sich sowohl auf die Datenfilterkonfiguration als auch auf Zielabfragen auswirkt. Beachten Sie Folgendes:
+ Oracle Database speichert Datenbank-, Schema- und Objektnamen in Großbuchstaben, sofern sie nicht ausdrücklich in der `CREATE`-Anweisung zitiert werden. Wenn Sie beispielsweise `mytable` (ohne Anführungszeichen) erstellen, speichert das Oracle-Datenwörterbuch den Tabellennamen als `MYTABLE`. Wenn Sie den Objektnamen in Anführungszeichen setzen, behält das Datenwörterbuch die Groß-/Kleinschreibung bei.
+ Null-ETL-Datenfilter unterscheiden zwischen Groß- und Kleinschreibung und müssen genau der Groß- und Kleinschreibung von Objektnamen entsprechen, wie sie im Oracle-Datenwörterbuch vorkommen.
+ Amazon-Redshift-Abfragen verwenden standardmäßig Objektnamen in Kleinbuchstaben, sofern sie nicht ausdrücklich in Anführungszeichen gesetzt werden. Die Abfrage von `MYTABLE` (ohne Anführungszeichen) sucht beispielsweise nach `mytable`.
Beachten Sie die Unterschiede bei der Groß- und Kleinschreibung, wenn Sie den Amazon-Redshift-Filter erstellen und die Daten abfragen.
#### Erstellen einer Integration in Großbuchstaben
Wenn Sie eine Tabelle erstellen, ohne den Namen in doppelten Anführungszeichen anzugeben, speichert die Oracle-Datenbank den Namen in Großbuchstaben im Datenwörterbuch. Sie können beispielsweise `MYTABLE` mit einer der folgenden SQL-Anweisungen erstellen.
```
CREATE TABLE REINVENT.MYTABLE (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE reinvent.mytable (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE REinvent.MyTable (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE reINVENT.MYtabLE (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Da Sie den Tabellennamen in den vorherigen Anweisungen nicht in Anführungszeichen gesetzt haben, speichert die Oracle-Datenbank den Objektnamen in Großbuchstaben als `MYTABLE`.
Um diese Tabelle auf Amazon Redshift zu replizieren, müssen Sie den Namen in Großbuchstaben in Ihrem Datenfilter des Befehls `create-integration` angeben. Der Name des Null-ETL-Filters und der Name des Oracle-Datenwörterbuchs müssen übereinstimmen.
```
aws rds create-integration \
--integration-name upperIntegration \
--data-filter "include: ORCL.REINVENT.MYTABLE" \
...
```
Standardmäßig speichert Amazon Redshift Daten in Kleinbuchstaben. Um `MYTABLE` in der replizierten Datenbank in Amazon Redshift abzufragen, müssen Sie den in Großbuchstaben geschriebenen Namen `MYTABLE` in Anführungszeichen setzen, damit er der Groß-/Kleinschreibung im Oracle-Datenwörterbuch entspricht.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
```
Die folgenden Abfragen verwenden den Anführungszeichenmechanismus nicht. Sie alle geben einen Fehler zurück, weil sie nach einer Amazon-Redshift-Tabelle mit dem Namen `mytable` suchen, die den Standardnamen in Kleinbuchstaben verwendet, die Tabelle heißt im Oracle-Datenwörterbuch jedoch `MYTABLE`.
```
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
SELECT * FROM targetdb1."REINVENT".mytable;
```
Die folgenden Abfragen verwenden den Anführungszeichenmechanismus, um einen Namen mit gemischter Groß- und Kleinschreibung anzugeben. Die Abfragen geben alle einen Fehler zurück, weil sie nach einer Amazon-Redshift-Tabelle suchen, die nicht den Namen `MYTABLE` trägt.
```
SELECT * FROM targetdb1."REINVENT"."MYtablE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."mytable";
```
#### Erstellen einer Integration in Kleinbuchstaben
Im folgenden alternativen Beispiel verwenden Sie doppelte Anführungszeichen, um den Tabellennamen im Oracle-Datenwörterbuch in Kleinbuchstaben zu speichern. Sie erstellen `mytable` wie folgt.
```
CREATE TABLE REINVENT."mytable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Die Oracle-Datenbank speichert den Tabellennamen `mytable` in Kleinbuchstaben. Um diese Tabelle auf Amazon Redshift zu replizieren, müssen Sie den Namen `mytable` in Kleinbuchstaben in Ihrem Null-ETL-Datenfilter angeben.
```
aws rds create-integration \
--integration-name lowerIntegration \
--data-filter "include: ORCL.REINVENT.mytable" \
...
```
Wenn Sie diese Tabelle in der replizierten Datenbank in Amazon Redshift abfragen, können Sie den Namen `mytable` in Kleinbuchstaben angeben. Die Abfrage ist erfolgreich, weil sie nach einer Tabelle mit dem Namen `mytable` sucht, der dem Tabellennamen im Oracle-Datenwörterbuch entspricht.
```
SELECT * FROM targetdb1."REINVENT".mytable;
```
Da Amazon Redshift standardmäßig Objektnamen in Kleinbuchstaben verwendet, können auch die folgenden Abfragen `mytable` erfolgreich finden.
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
```
Die folgenden Abfragen verwenden den Anführungszeichenmechanismus für den Objektnamen. Sie alle geben einen Fehler zurück, weil sie nach einer Amazon-Redshift-Tabelle suchen, deren Name sich von `mytable` unterscheidet.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."MYtablE";
```
#### Erstellen einer Tabelle mit gemischter Groß- und Kleinbuchschreibung
Im folgenden Beispiel verwenden Sie doppelte Anführungszeichen, um den Tabellennamen im Oracle-Datenwörterbuch in Kleinbuchstaben zu speichern. Sie erstellen `MyTable` wie folgt.
```
CREATE TABLE REINVENT."MyTable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Die Oracle-Datenbank speichert diesen Tabellennamen als `MyTable` mit gemischter Groß- und Kleinschreibung. Um diese Tabelle auf Amazon Redshift zu replizieren, müssen Sie den Namen in gemischter Groß- und Kleinschreibung im Datenfilter angeben.
```
aws rds create-integration \
--integration-name mixedIntegration \
--data-filter "include: ORCL.REINVENT.MyTable" \
...
```
Wenn Sie diese Tabelle in der replizierten Datenbank in Amazon Redshift abfragen, müssen Sie den Namen `MyTable` in gemischter Groß- und Kleinschreibung angeben.
```
SELECT * FROM targetdb1."REINVENT"."MyTable";
```
Da Amazon Redshift standardmäßig Objektnamen in Kleinbuchstaben verwendet, finden die folgenden Abfragen das Objekt nicht, da sie nach dem Namen `mytable` in Kleinbuchstaben suchen.
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".mytable;
```
**Anmerkung**
Sie können keine regulären Ausdrücke im Filterwert für Datenbanknamen, Schema oder Tabellennamen in Integrationen von RDS für Oracle verwenden.
## Hinzufügen von Datenfiltern zu einer Integration
Sie können die Datenfilterung mithilfe der AWS-Managementkonsole AWS CLI, der oder der Amazon RDS-API konfigurieren.
**Wichtig**
Wenn Sie einen Filter hinzufügen, nachdem Sie eine Integration erstellt haben, behandelt Amazon RDS ihn so, als ob er schon immer existiert hätte. Alle Daten im Ziel-Data-Warehouse, die nicht den neuen Filterkriterien entsprechen, werden entfernt und alle betroffenen Tabellen erneut synchronisiert.
### RDS-Konsole
**So fügen Sie Datenfilter zur einer Null-ETL-Integration hinzu**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im linken Navigationsbereich **Null-ETL-Integrationen** aus. Wählen Sie die Integration aus, zu der Sie Datenfilter hinzufügen möchten, und klicken Sie dann auf **Ändern**.
1. Fügen Sie unter **Quelle** eine oder mehrere `Include`- und `Exclude`-Anweisungen hinzu.
Die folgende Abbildung zeigt ein Beispiel für Datenfilter für eine MySQL-Integration:
![\[Datenfilter für eine Null-ETL-Integration in der RDS-Konsole\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/zero-etl-filter-data.png)
1. Wenn Sie mit den Änderungen zufrieden sind, wählen Sie **Weiter** und **Änderungen speichern**.
### AWS CLI
Rufen Sie den Befehl [modify-integration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-integration.html) auf, um einer Zero-ETL-Integration mithilfe von Datenfilter hinzuzufügen. AWS CLI Geben Sie den Parameter `--data-filter` zusätzlich zur Integrations-ID mit einer kommagetrennten Liste von `Include`- und `Exclude`-Maxwell-Filtern an.
**Example**
Im folgenden Beispiel werden Filtermuster zu `my-integration` hinzugefügt.
Für Linux, macOS oder Unix:
```
aws rds modify-integration \
--integration-identifier my-integration \
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
Für Windows:
```
aws rds modify-integration ^
--integration-identifier my-integration ^
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
### RDS-API
Rufen Sie den Vorgang auf, um eine Zero-ETL-Integration mithilfe der RDS-API zu ändern. [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html) Geben Sie die Integrations-ID an und stellen Sie eine kommagetrennte Liste der Filtermuster bereit.
## Entfernen von Datenfiltern aus einer Integration
Wenn Sie einen Datenfilter aus einer Integration entfernen, wertet Amazon RDS die verbleibenden Filter neu aus, als ob der entfernte Filter nie existiert hätte. Anschließend repliziert es alle zuvor ausgeschlossenen Daten, die jetzt die Kriterien erfüllen, in das Ziel-Data-Warehouse. Dadurch wird eine erneute Synchronisierung aller betroffenen Tabellen ausgelöst.
# Hinzufügen von Daten zu einer RDS-Quelldatenbank und Abfragen der Daten
Zum Erstellen einer Null-ETL-Integration, die Daten von Amazon RDS in Amazon Redshift repliziert, müssen Sie eine Datenbank im Ziel erstellen.
Stellen Sie für Verbindungen mit Amazon Redshift zunächst eine Verbindung mit Ihrem Amazon-Redshift-Cluster oder Ihrer Arbeitsgruppe her und erstellen Sie eine Datenbank mit einem Verweis auf Ihre Integrations-ID. Anschließend können Sie Daten zur RDS-Quelldatenbank hinzufügen und diese in Amazon Redshift oder Amazon SageMaker replizieren.
**Topics**
+ [Erstellen einer Zieldatenbank](#zero-etl.create-db)
+ [Hinzufügen von Daten zur Quelldatenbank](#zero-etl.add-data-rds)
+ [Abfragen Ihrer Amazon-RDS-Daten in Amazon Redshift](#zero-etl.query-data-redshift)
+ [Datentypunterschiede zwischen RDS und Amazon Redshift-Datenbanken](#zero-etl.data-type-mapping)
+ [DDL-Vorgänge für RDS für PostgreSQL](#zero-etl.ddl-postgres)
## Erstellen einer Zieldatenbank
Bevor Sie nach der Erstellung einer Integration mit der Replikation von Daten in Amazon Redshift beginnen können, müssen Sie in Ihrem Ziel-Data-Warehouse eine Datenbank erstellen. Diese Datenbank muss einen Verweis auf die Integrations-ID enthalten. Sie können die Amazon-Redshift-Konsole oder Query Editor v2 verwenden, um die Datenbank zu erstellen.
Anleitungen zum Erstellen einer Zieldatenbank finden Sie unter [Erstellen einer Zieldatenbank in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
## Hinzufügen von Daten zur Quelldatenbank
Nachdem Sie Ihre Integration konfiguriert haben, können Sie die RDS-Quelldatenbank mit Daten füllen, die Sie in Ihr Data Warehouse replizieren möchten.
**Anmerkung**
Es gibt Unterschiede zwischen den Datentypen in Amazon RDS und dem Ziel-Analyse-Warehouse. Eine Tabelle mit Datentypzuordnungen finden Sie unter [Datentypunterschiede zwischen RDS und Amazon Redshift-Datenbanken](#zero-etl.data-type-mapping).
Stellen Sie zunächst mit dem MySQL-Client Ihrer Wahl eine Verbindung zur Quelldatenbank her. Anleitungen finden Sie unter [Herstellen einer Verbindung mit Ihrer MySQL-DB-Instance](USER_ConnectToInstance.md).
Erstellen Sie dann eine Tabelle und fügen Sie eine Zeile mit Beispieldaten ein.
**Wichtig**
Stellen Sie sicher, dass die Tabelle über einen Primärschlüssel verfügt. Andernfalls kann sie nicht in das Ziel-Data-Warehouse repliziert werden.
**RDS für MySQL**
Im folgenden Beispiel wird das [Dienstprogramm MySQL Workbench](https://dev.mysql.com/downloads/workbench/) verwendet.
```
CREATE DATABASE my_db;
USE my_db;
CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
**RDS für PostgreSQL**
Das folgende Beispiel verwendet das interaktive PostgreSQL-Terminal `[psql](https://www.postgresql.org/docs/current/app-psql.html)`. Wenn Sie eine Verbindung zur Datenbank herstellen, schließen Sie den Datenbanknamen ein, den Sie replizieren möchten.
```
psql -h mydatabase.123456789012.us-east-2.rds.amazonaws.com -p 5432 -U username -d named_db;
named_db=> CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
named_db=> INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
**RDS für Oracle**
Im folgenden Beispiel wird SQL\$1Plus verwendet, um eine Verbindung mit Ihrer Datenbank von RDS für Oracle herzustellen.
```
sqlplus 'user_name@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=dns_name)(PORT=port))(CONNECT_DATA=(SID=database_name)))'
SQL> CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
SQL> INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
## Abfragen Ihrer Amazon-RDS-Daten in Amazon Redshift
Nachdem Sie Daten zur RDS-Datenbank hinzugefügt haben, werden sie in die Zieldatenbank repliziert und können abgefragt werden.
**So fragen Sie die replizierten Daten ab**
1. Navigieren Sie zur Amazon Redshift-Konsole und wählen Sie im linken Navigationsbereich die Option **Query Editor v2** aus.
1. Stellen Sie eine Verbindung mit Ihrem Cluster oder Ihrer Arbeitsgruppe her und wählen Sie Ihre aus der Integration erstellte Datenbank im Dropdown-Menü aus (**destination\$1database** in diesem Beispiel). Anleitungen zum Erstellen einer Zieldatenbank finden Sie unter [Erstellen einer Zieldatenbank in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
1. Verwenden Sie eine SELECT-Anweisung, um Ihre Daten abzufragen. In diesem Beispiel können Sie den folgenden Befehl ausführen, um alle Daten aus der Tabelle auszuwählen, die Sie in der RDS-Quelldatenbank erstellt haben:
```
SELECT * from my_db."books_table";
```
![\[Führen Sie eine SELECT-Anweisung im Abfrage-Editor aus. Das Ergebnis ist eine einzelne Zeile mit Beispieldaten, die zur Amazon-RDS-Datenbank hinzugefügt wurden.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/zero-etl-redshift-editor.png)
+ `my_db` ist der Name des RDS-Datenbankschemas.
+ `books_table` ist der Name der RDS-Tabelle.
Sie können die Daten auch mit einem Befehlszeilen-Client abfragen. Beispiel:
```
destination_database=# select * from my_db."books_table";
ID | Title | Author | Copyright | Genre | txn_seq | txn_id
----+–------------+---------------+-------------+------------------------+----------+--------+
1 | The Shining | Stephen King | 1977 | Supernatural fiction | 2 | 12192
```
**Anmerkung**
Um zwischen Groß- und Kleinschreibung zu unterscheiden, verwenden Sie doppelte Anführungszeichen (" ") für Schema-, Tabellen- und Spaltennamen. Weitere Informationen finden Sie unter [enable\$1case\$1sensitive\$1identifier](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html).
## Datentypunterschiede zwischen RDS und Amazon Redshift-Datenbanken
Die folgenden Tabellen zeigen die Zuordnungen der Datentypen von RDS für MySQL, RDS für PostgreSQL und RDS für Oracle zu den entsprechenden Zieldatentypen. *Amazon RDS unterstützt derzeit nur diese Datentypen für Null-ETL-Integrationen.*
Wenn eine Tabelle in der Quelldatenbank einen nicht unterstützten Datentyp enthält, wird die Tabelle nicht synchronisiert und kann vom Ziel nicht genutzt werden. Das Streaming von der Quelle zum Ziel wird fortgesetzt, aber die Tabelle mit dem nicht unterstützten Datentyp ist nicht verfügbar. Um die Tabelle zu reparieren und im Ziel verfügbar zu machen, müssen Sie die grundlegende Änderung manuell rückgängig machen und dann die Integration aktualisieren, indem Sie `[ALTER DATABASE...INTEGRATION REFRESH](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html)` ausführen.
**Anmerkung**
Null-ETL-Integrationen mit einem Amazon SageMaker-Lakehouse können nicht aktualisiert werden. Löschen Sie stattdessen die Integration und erstellen Sie sie erneut.
**Topics**
+ [RDS für MySQL](#zero-etl.data-type-mapping-mysql)
+ [RDS für PostgreSQL](#zero-etl.data-type-mapping-postgres)
+ [RDS für Oracle](#zero-etl.data-type-mapping-oracle)
### RDS für MySQL
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS für PostgreSQL
Null-ETL-Integrationen für RDS für PostgreSQL unterstützen keine benutzerdefinierten Datentypen oder Datentypen, die durch Erweiterungen erstellt wurden.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS für Oracle
**Nicht unterstützte Datentypen**
Die folgenden Datentypen von RDS für Oracle werden von Amazon Redshift nicht unterstützt:
+ `ANYDATA`
+ `BFILE`
+ `REF`
+ `ROWID`
+ `UROWID`
+ `VARRAY`
+ `SDO_GEOMETRY`
+ Benutzerdefinierte Datentypen
**Unterschiede zwischen den Datentypen**
Die folgende Tabelle zeigt die Unterschiede zwischen den Datentypen, die sich auf eine Null-ETL-Integration auswirken, wenn RDS für Oracle die Quelle und Amazon Redshift das Ziel ist.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
## DDL-Vorgänge für RDS für PostgreSQL
Amazon Redshift wird von PostgreSQL abgeleitet und hat daher aufgrund der gemeinsamen PostgreSQL-Architektur mehrere Features mit RDS für PostgreSQL gemeinsam. Null-ETL-Integrationen nutzen diese Ähnlichkeiten, um die Datenreplikation von RDS für PostgreSQL in Amazon Redshift zu optimieren, indem sie Datenbanken nach Namen zuordnen und die Datenbank, das Schema und die Tabellenstruktur gemeinsam nutzen.
Beachten Sie bei der Verwaltung von Null-ETL-Integrationen von RDS für PostgreSQL die folgenden Punkte:
+ Die Isolation wird auf Datenbankebene verwaltet.
+ Die Replikation erfolgt auf Datenbankebene.
+ Datenbanken von RDS für PostgreSQL werden Amazon-Redshift-Datenbanken nach Namen zugeordnet, wobei Daten in die entsprechende umbenannte Redshift-Datenbank fließen, wenn das Original umbenannt wird.
Trotz ihrer Ähnlichkeiten weisen Amazon Redshift und RDS für PostgreSQL wesentliche Unterschiede auf. In den folgenden Abschnitten werden die Systemantworten von Amazon Redshift für gängige DDL-Vorgänge beschrieben.
**Topics**
+ [Datenbankvorgänge](#zero-etl.ddl-postgres-database)
+ [Schemavorgänge](#zero-etl.ddl-postgres-schema)
+ [Tabellenoperationen](#zero-etl.ddl-postgres-table)
### Datenbankvorgänge
Die folgende Tabelle zeigt die Systemantworten für Datenbank-DDL-Vorgänge.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Schemavorgänge
Die folgende Tabelle zeigt die Systemantworten für Schema-DDL-Vorgänge.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Tabellenoperationen
Die folgende Tabelle zeigt die Systemantworten auf Tabellen-DDL-Vorgänge.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
# Anzeigen und Überwachen von Null-ETL-Integrationen von Amazon RDS
Sie können die Details einer Null-ETL-Integration von Amazon RDS anzeigen, um die zugehörigen Konfigurationsinformationen und den aktuellen Status einzusehen. Sie können außerdem den Status Ihrer Integration überwachen, indem Sie bestimmte Systemansichten in Amazon Redshift abfragen. Darüber hinaus veröffentlicht Amazon Redshift bestimmte integrationsbezogene Metriken auf Amazon CloudWatch, die Sie in der Amazon Redshift Redshift-Konsole einsehen können.
**Topics**
+ [Anzeigen von Integrationen](#zero-etl.describing)
+ [Überwachen von Integrationen mithilfe von Systemtabellen für Amazon Redshift](#zero-etl.monitoring)
+ [Überwachung von Integrationen mit Amazon EventBridge für Amazon Redshift](#zero-etl.eventbridge)
## Anzeigen von Integrationen
Sie können Amazon RDS Zero-ETL-Integrationen mithilfe der AWS-Managementkonsole, der oder der AWS CLI RDS-API anzeigen.
### Konsole
**So zeigen Sie die Details einer Null-ETL-Integration an**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im linken Navigationsbereich **Null-ETL-Integrationen** aus.
1. Wählen Sie eine Integration aus, um weitere Details dazu anzuzeigen, z. B. die Quelldatenbank und das Ziel-Data-Warehouse.
![\[Details zu einer Null-ETL-Integration\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/zero-etl-integration-view.png)
Eine Integration kann folgende Status aufweisen:
+ `Creating` – Die Integration wird erstellt.
+ `Active` – Die Integration sendet Transaktionsdaten an das Ziel-Data-Warehouse.
+ `Syncing` – Bei der Integration ist ein behebbarer Fehler aufgetreten und die Daten werden erneut gesendet. Betroffene Tabellen sind erst für Abfragen verfügbar, wenn die erneute Synchronisierung abgeschlossen ist.
+ `Needs attention` – Bei der Integration ist ein Ereignis oder ein Fehler aufgetreten, für dessen Behebung ein manuelles Eingreifen erforderlich ist. Befolgen Sie zur Behebung des Problems die Anweisungen in der Fehlermeldung auf der Seite mit den Integrationsdetails.
+ `Failed` – Bei der Integration ist ein nicht behebbares Ereignis oder ein Fehler aufgetreten, der nicht behoben werden kann. Sie müssen die Integration löschen und erneut erstellen.
+ `Deleting` – Die Integration wird gelöscht.
### AWS CLI
Um alle Zero-ETL-Integrationen im aktuellen Konto mit dem anzuzeigen AWS CLI, verwenden Sie den Befehl [describe-integrations](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-integrations.html) und geben Sie die Option an. `--integration-identifier`
**Example**
Für Linux, macOS oder Unix:
```
aws rds describe-integrations \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Für Windows:
```
aws rds describe-integrations ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
### RDS-API
Um die Null-ETL-Integration mithilfe der Amazon-RDS-API anzuzeigen, verwenden Sie die Operation [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html) mit dem Parameter `IntegrationIdentifier`.
## Überwachen von Integrationen mithilfe von Systemtabellen für Amazon Redshift
Amazon Redshift verfügt über Systemtabellen und Ansichten, die Informationen zur Funktionsweise des Systems enthalten. Sie können diese Systemtabellen und Ansichten genauso abfragen wie andere Datenbanktabellen. Weitere Informationen zu Systemtabellen und Ansichten in Amazon Redshift finden Sie in der [Referenz zu Systemtabellen und Ansichten](https://docs.aws.amazon.com//redshift/latest/dg/cm_chap_system-tables.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
Sie können die folgenden Systemansichten und Tabellen abfragen, um Informationen zu Ihren Null-ETL-Integrationen von in abzurufen:
+ [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html) – Stellt Konfigurationsdetails für Ihre Integrationen bereit.
+ [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html) – Beschreibt den Status jeder Tabelle innerhalb einer Integration.
+ [SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_STATE_CHANGE.html) – Zeigt Protokolle zur Statusänderung von Tabellen für eine Integration an.
+ [SYS\$1INTEGRATION\$1ACTIVITY](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_ACTIVITY.html) – Stellt Informationen zu abgeschlossenen Integrationsausführungen bereit.
Alle integrationsbezogenen CloudWatch Amazon-Metriken stammen von Amazon Redshift. Weitere Informationen finden Sie unter [Metriken für Null-ETL-Integrationen](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.monitoring.html) im *Amazon-Redshift-Verwaltungshandbuch*. Derzeit veröffentlicht Amazon RDS keine Integrationsmetriken für CloudWatch.
## Überwachung von Integrationen mit Amazon EventBridge für Amazon Redshift
Amazon Redshift sendet integrationsbezogene Ereignisse an Amazon. EventBridge Eine Liste der Ereignisse und der entsprechenden Ereignisse finden Sie unter [Benachrichtigungen über Zero-ETL-Integrationsereignisse mit Amazon EventBridge im Amazon](https://docs.aws.amazon.com/redshift/latest/mgmt/integration-event-notifications) *Redshift* Management Guide. IDs
# Ändern der Null-ETL-Integrationen von Amazon RDS
Sie können nur den Namen, die Beschreibung und die Datenfilteroptionen für eine Null-ETL-Integration in einem unterstützten Data Warehouse ändern. Den zur Verschlüsselung der Integration verwendeten AWS KMS-Schlüssel oder die Quell- oder Zieldatenbanken können Sie nicht ändern.
Wenn Sie einer vorhandenen Integration einen Datenfilter hinzufügen, wertet Amazon RDS den Filter neu aus, als ob er schon immer existiert hätte. Es entfernt alle Daten, die sich derzeit im Ziel-Data-Warehouse befinden und nicht den neuen Filterkriterien entsprechen. Wenn Sie einen Datenfilter aus einer Integration *entfernen*, werden alle Daten, die zuvor nicht den Filterkriterien entsprachen (dies jetzt aber tun), in das Ziel-Data-Warehouse repliziert. Weitere Informationen finden Sie unter [Datenfilterung für Null-ETL-Integrationen für Amazon RDS](zero-etl.filtering.md).
Sie können eine Null-ETL-Integration mit der AWS-Managementkonsole, der AWS CLI oder der Amazon-RDS-API erstellen.
## RDS-Konsole
**So ändern Sie eine Null-ETL-Integration**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Null-ETL-Integrationen** und dann die Integration aus, die Sie ändern möchten.
1. Wählen Sie **Ändern** und nehmen Sie Änderungen an allen verfügbaren Einstellungen vor.
1. Nachdem Sie die gewünschten Änderungen vorgenommen haben, klicken Sie auf **Ändern**.
## AWS CLI
Um eine Null-ETL-Integration mithilfe der AWS CLI zu ändern, rufen Sie den Befehl [modify-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-integration.html) auf. Geben Sie zusammen mit der `--integration-identifier` eine der folgenden Optionen an:
+ `--integration-name` – Geben Sie einen neuen Namen für die Integration an.
+ `--description` – Geben Sie eine neue Beschreibung für die Integration an.
+ `--data-filter` – Geben Sie Datenfilteroptionen für die Integration an. Weitere Informationen finden Sie unter [Datenfilterung für Null-ETL-Integrationen für Amazon RDS](zero-etl.filtering.md).
**Example**
Die folgende Anfrage ändert eine bestehende Integration.
Für Linux, macOS oder Unix:
```
aws rds modify-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 \
--integration-name my-renamed-integration
```
Für Windows:
```
aws rds modify-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 ^
--integration-name my-renamed-integration
```
## RDS-API
Rufen Sie die Operation [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html) auf, um eine Null-ETL-Integration mithilfe der RDS-API zu ändern. Geben Sie die Integrations-ID und die Parameter an, die geändert werden sollen.
# Löschen von Null-ETL-Integrationen von Amazon RDS
Wenn Sie eine Null-ETL-Integration löschen, entfernt Amazon RDS sie aus der Quelldatenbank. Ihre Transaktionsdaten werden nicht aus Amazon RDS oder dem Analytikziel gelöscht, Amazon RDS sendet jedoch keine neuen Daten an Amazon Redshift oder Amazon SageMaker.
Sie können eine Integration nur löschen, wenn sie den Status `Active`, `Failed`, `Syncing` oder `Needs attention` hat.
Sie können Null-ETL-Integrationen mithilfe der AWS-Managementkonsole, der AWS CLI oder der RDS-API löschen.
## Konsole
**So löschen Sie eine Null-ETL-Integration**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im linken Navigationsbereich **Null-ETL-Integrationen** aus.
1. Wählen Sie die Null-ETL-Integration aus, die Sie löschen möchten.
1. Klicken Sie auf **Aktionen**, **Löschen** und bestätigen Sie den Löschvorgang.
## AWS CLI
Verwenden Sie zum Löschen einer Null-ETL-Integration den Befehl [delete-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-integration.html) und geben Sie die Option `--integration-identifier` an.
**Example**
Für Linux, macOS oder Unix:
```
aws rds delete-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Für Windows:
```
aws rds delete-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
## RDS-API
Verwenden Sie zum Löschen einer Null-ETL-Integration mithilfe der Amazon-RDS-API die Operation [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html) mit dem Parameter `IntegrationIdentifier`.
# Fehlerbehebung bei Null-ETL-Integrationen von Amazon RDS
Sie können den Status einer Null-ETL-Integration überprüfen, indem Sie die Systemtabelle [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html) im Analyseziel abfragen. Wenn die Spalte `state` den Wert `ErrorState` aufweist, bedeutet das, dass ein Fehler vorliegt. Weitere Informationen finden Sie unter [Überwachen von Integrationen mithilfe von Systemtabellen für Amazon Redshift](zero-etl.describingmonitoring.md#zero-etl.monitoring).
Verwenden Sie die folgenden Informationen, um häufig auftretende Probleme bei Null-ETL-Integrationen von Amazon RDS zu beheben.
**Wichtig**
Resynchronisierungs- und Aktualisierungsvorgänge sind für Null-ETL-Integrationen mit einem Amazon SageMaker AI -Lakehouse nicht verfügbar. Wenn Probleme mit einer Integration auftreten, müssen Sie die Integration löschen und eine neue Integration erstellen. Sie können eine bestehende Integration nicht aktualisieren oder erneut synchronisieren.
**Topics**
+ [Ich kann keine Null-ETL-Integration erstellen](#zero-etl.troubleshooting.creation)
+ [Meine Integration steckt im Status `Syncing` fest](#zero-etl.troubleshooting.syncing)
+ [Meine Tabellen werden nicht in Amazon Redshift repliziert](#zero-etl.troubleshooting.primarykey)
+ [Eine oder mehrere meiner Amazon-Redshift-Tabellen erfordern eine erneute Synchronisation](#zero-etl.troubleshooting.resync)
+ [Fehlgeschlagene Integrationsprobleme für Amazon SageMaker AI Lakehouse Zero-ETL-Integrationen](#zero-etl.troubleshooting.integration-issues)
## Ich kann keine Null-ETL-Integration erstellen
Wenn Sie keine Null-ETL-Integration erstellen können, stellen Sie Folgendes für Ihre Quelldatenbank sicher:
+ In Ihrer Quelldatenbank muss eine unterstützte DB-Engine-Version ausgeführt werden. Eine Liste der unterstützten Versionen finden Sie unter [Unterstützte Regionen und DB-Engines für Amazon-RDS-Null-ETL-Integrationen](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
+ Sie haben die DB-Parameter korrekt konfiguriert. Wenn die erforderlichen Parameter falsch festgelegt oder nicht mit der Datenbank verknüpft sind, schlägt die Erstellung fehl. Siehe [Schritt 1: Erstellen einer benutzerdefinierten DB--Parametergruppe](zero-etl.setting-up.md#zero-etl.parameters).
Stellen Sie außerdem Folgendes für Ihr Ziel-Data-Warehouse sicher:
+ Die Unterscheidung zwischen Groß- und Kleinschreibung ist aktiviert. Siehe [Aktivieren der Unterscheidung zwischen Groß- und Kleinschreibung für Ihr Data Warehouse](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity).
+ Sie haben den richtigen autorisierten Prinzipal und die richtige Integrationsquelle hinzugefügt. Weitere Informationen finden Sie unter [Konfigurieren der Autorisierung für Ihr Amazon Redshift Data Warehouse](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam).
+ Das Data Warehouse ist verschlüsselt (wenn es sich um einen bereitgestellten Cluster handelt). Weitere Informationen finden Sie unter [Verschlüsselung von Amazon-Redshift-Datenbanken](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
## Meine Integration steckt im Status `Syncing` fest
Ihre Integration zeigt möglicherweise konsistent den Status `Syncing` an, wenn Sie den Wert eines erforderlichen DB-Parameters ändern.
Um dieses Problem zu beheben, überprüfen Sie die Werte der Parameter in der Parametergruppe, die mit der Quelldatenbank verknüpft ist, und stellen Sie sicher, dass sie den erforderlichen Werten entsprechen. Weitere Informationen finden Sie unter [Schritt 1: Erstellen einer benutzerdefinierten DB--Parametergruppe](zero-etl.setting-up.md#zero-etl.parameters).
Wenn Sie Parameter ändern, stellen Sie sicher, dass Sie die Datenbank neu starten, damit die Änderungen übernommen werden.
## Meine Tabellen werden nicht in Amazon Redshift repliziert
Wenn Sie eine oder mehrere Tabellen in Amazon Redshift nicht sehen, können Sie den folgenden Befehl ausführen, um sie erneut zu synchronisieren:
```
ALTER DATABASE dbname INTEGRATION REFRESH TABLES table1, table2;
```
Weitere Informationen finden Sie unter [ALTER DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html) in der SQL-Referenz zu Amazon Redshift.
Ihre Daten werden möglicherweise nicht repliziert, da eine oder mehrere Quelltabellen nicht über einen Primärschlüssel verfügen. Das Überwachungs-Dashboard in Amazon Redshift zeigt den Status dieser Tabellen als `Failed` an und der Status der gesamten Null-ETL-Integration wird in `Needs attention` geändert. Um dieses Problem zu lösen, können Sie einen vorhandenen Schlüssel in Ihrer Tabelle identifizieren, der zu einem Primärschlüssel werden kann, oder Sie können einen synthetischen Primärschlüssel hinzufügen. Ausführliche Lösungen finden in [Handle tables without primary keys while creating Amazon Aurora MySQL or Amazon RDS für MySQL zero-ETL integrations with Amazon Redshift](https://aws.amazon.com/blogs/database/handle-tables-without-primary-keys-while-creating-amazon-aurora-mysql-or-amazon-rds-for-mysql-zero-etl-integrations-with-amazon-redshift/).
## Eine oder mehrere meiner Amazon-Redshift-Tabellen erfordern eine erneute Synchronisation
Wenn Sie bestimmte Befehle auf Ihrer Quelldatenbank ausführen, müssen Ihre Tabellen möglicherweise erneut synchronisiert werden. In diesen Fällen zeigt die Systemansicht [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html) für `table_state` den Wert `ResyncRequired` an. Dies bedeutet, dass die Integration die Daten für diese spezifische Tabelle vollständig neu von MySQL in Amazon Redshift laden muss.
Wenn die Tabelle mit der erneuten Synchronisation beginnt, wechselt sie in den Status `Syncing`. Sie müssen keine manuellen Maßnahmen ergreifen, um eine Tabelle erneut zu synchronisieren. Während die Tabellendaten erneut synchronisiert werden, können Sie in Amazon Redshift nicht darauf zugreifen.
Im Folgenden finden Sie einige Beispieloperationen, mit denen eine Tabelle in den Status `ResyncRequired` versetzt werden kann, sowie mögliche Alternativen, die Sie in Betracht ziehen sollten.
| Operation | Beispiel | Alternative |
| --- | --- | --- |
| Hinzufügen einer Spalte an einer bestimmten Position | ALTER TABLE table_name
ADD COLUMN column_name INTEGER
NOT NULL first;
| Amazon Redshift unterstützt nicht das Hinzufügen von Spalten an bestimmten Positionen mithilfe der Schlüsselwörter first oder after. Wenn die Reihenfolge der Spalten in der Zieltabelle nicht wichtig ist, fügen Sie die Spalte mit einem einfacheren Befehl am Ende der Tabelle hinzu:ALTER TABLE table_name
ADD COLUMN column_name column_type;
|
| Hinzufügen einer Zeitstempelspalte mit dem Standardwert CURRENT\$1TIMESTAMP | ALTER TABLE table_name
ADD COLUMN column_name TIMESTAMP
NOT NULL DEFAULT CURRENT_TIMESTAMP;
| Der Wert CURRENT\$1TIMESTAMP für vorhandene Tabellenzeilen wird von RDS für MySQL berechnet und kann in Amazon Redshift ohne vollständige erneute Synchronisation der Tabellendaten nicht simuliert werden. Wenn möglich, ändern Sie den Standardwert in eine Literalkonstante wie `2023-01-01 00:00:15`, um Latenzen bei der Tabellenverfügbarkeit zu vermeiden. |
| Ausführen mehrerer Spaltenoperationen innerhalb eines einzigen Befehls | ALTER TABLE table_name
ADD COLUMN column_1,
RENAME COLUMN column_2 TO column_3;
| Überlegen Sie, ob Sie den Befehl in zwei separate Operationen, ADD und RENAME, aufteilen sollten, die keine erneute Synchronisation erfordern. |
## Fehlgeschlagene Integrationsprobleme für Amazon SageMaker AI Lakehouse Zero-ETL-Integrationen
Wenn Sie Probleme mit einer bestehenden Zero-ETL-Integration mit einem Amazon SageMaker AI Lakehouse haben, besteht die einzige Lösung darin, die Integration zu löschen und eine neue zu erstellen. Im Gegensatz zu anderen AWS Diensten unterstützen Zero-ETL-Integrationen keine Aktualisierungs- oder Resynchronisierungsvorgänge.
So lösen Sie Integrationsprobleme:
1. Löschen Sie die problematische Null-ETL-Integration mithilfe der Konsole, CLI oder API.
1. Stellen Sie sicher, dass die Konfiguration der Quelldatenbank und des Ziel-Data-Warehouse korrekt ist.
1. Erstellen Sie eine neue Null-ETL-Integration mit derselben oder einer aktualisierten Konfiguration.
Dieser Prozess führt zu einer vollständigen Neuinitialisierung der Daten-Pipeline, was je nach Größe Ihrer Quelldatenbank einige Zeit in Anspruch nehmen kann.