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. # 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.