

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.

# Verwendung von Amazon Kinesis Data Streams als Ziel für AWS Database Migration Service
<a name="CHAP_Target.Kinesis"></a>

Sie können AWS DMS es verwenden, um Daten in einen Amazon Kinesis Kinesis-Datenstream zu migrieren. Amazon-Kinesis-Datenströme sind Teil des Service Amazon Kinesis Data Streams. Sie können Kinesis-Datenströme zum Erfassen und Verarbeiten großer Ströme von Datensätzen in Echtzeit nutzen.

Ein Kinesis-Datenstrom besteht aus Shards. *Shards* sind eindeutig identifizierbare Sequenzen von Datensätzen in einem Stream. Weitere Informationen zu Shards in Amazon Kinesis Data Streams finden Sie unter [Shard](https://docs.aws.amazon.com/streams/latest/dev/key-concepts.html#shard) im *Amazon-Kinesis-Data-Streams-Entwicklerhandbuch*.

AWS Database Migration Service veröffentlicht Datensätze mithilfe von JSON in einem Kinesis-Datenstream. Während der Konvertierung serialisiert AWS DMS jeden Datensatz aus der Quelldatenbank in ein Attributwertpaar im JSON-Format oder in ein JSON\$1UNFORMATTED-Nachrichtenformat. Ein JSON\$1UNFORMATTED-Nachrichtenformat ist eine einzeilige JSON-Zeichenfolge mit neuem Zeilenbegrenzer. Es ermöglicht Amazon Data Firehose, Kinesis-Daten an ein Amazon S3 S3-Ziel zu senden und sie dann mit verschiedenen Abfrage-Engines, einschließlich Amazon Athena, abzufragen.

Sie verwenden die Objektzuweisung zum Migrieren Ihrer Daten von einer unterstützten Datenquelle zu einem Ziel-Stream. Mit der Objektzuweisung bestimmen Sie, wie die Datensätze im Stream zu strukturieren sind. Außerdem definieren Sie einen Partitionsschlüssel für jede Tabelle, die Kinesis Data Streams zum Gruppieren der Daten in Shards verwendet. 

AWS DMS legt auch mehrere Kinesis Data Streams Streams-Parameterwerte fest. Die Kosten für die Erstellung der Tabelle sind abhängig von der Datenmenge und der Anzahl der zu migrierenden Tabellen.

**Anmerkung**  
Die Option **SSL-Modus** auf der AWS DMS Konsole oder API gilt nicht für einige Datenstreaming- und NoSQL-Dienste wie Kinesis und DynamoDB. **Sie sind standardmäßig sicher, sodass AWS DMS angezeigt wird, dass die Einstellung für den SSL-Modus auf „Keine“ gesetzt ist (SSL-Modus=Keine).** Sie müssen keine zusätzliche Konfiguration für Ihren Endpunkt angeben, um SSL verwenden zu können. Wenn Sie beispielsweise Kinesis als Zielendpunkt verwenden, ist dies standardmäßig sicher. Alle API-Aufrufe an Kinesis verwenden SSL, sodass keine zusätzliche SSL-Option am AWS DMS Endpunkt erforderlich ist. Mithilfe des HTTPS-Protokolls, das AWS DMS standardmäßig verwendet, wenn eine Verbindung zu einem Kinesis-Datenstrom hergestellt wird, können Sie Daten sicher über SSL-Endpunkte einfügen und abrufen.

**Kinesis-Data-Streams-Endpunkteinstellungen**

Wenn Sie Kinesis Data Streams Streams-Zielendpunkte verwenden, können Sie Transaktions- und Kontrolldetails mithilfe der `KinesisSettings` Option in der AWS DMS API abrufen. 

Sie können die Verbindungseinstellungen auf eine der folgenden Weisen festlegen:
+ In der AWS DMS Konsole mithilfe der Endpunkteinstellungen.
+ In der CLI mit der `kinesis-settings` Option des [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)Befehls.

Verwenden Sie in der CLI die folgenden Anforderungsparameter der Option `kinesis-settings`:
**Anmerkung**  
Unterstützung für die Endpunkteinstellung `IncludeNullAndEmpty` ist in AWS DMS -Version 3.4.1 und höher verfügbar. Unterstützung für die anderen folgenden Endpunkteinstellungen für Kinesis Data Streams Streams-Ziele ist jedoch in AWS DMS verfügbar. 
+ `MessageFormat` – Das Ausgabeformat für die Datensätze, die auf dem Endpunkt erstellt wurden. Das Nachrichtenformat ist `JSON` (Standard) oder `JSON_UNFORMATTED` (eine einzelne Zeile ohne Tabulator).
+ `IncludeControlDetails` – Zeigt detaillierte Steuerungsinformationen für Tabellendefinition, Spaltendefinition und Tabellen- und Spaltenänderungen in der Kinesis-Nachrichtenausgabe an. Der Standardwert ist `false`.
+ `IncludeNullAndEmpty` – Schließt NULL-Spalten und leere Spalten in das Ziel ein. Der Standardwert ist `false`.
+ `IncludePartitionValue` – Zeigt den Partitionswert innerhalb der Kinesis-Nachrichtenausgabe an, es sei denn, der Partitionstyp ist `schema-table-type`. Der Standardwert ist `false`.
+ `IncludeTableAlterOperations` – Enthält alle DDL-Operationen (DDL = Data Definition Language), die die Tabelle in den Steuerungsdaten ändern, wie etwa `rename-table`, `drop-table`, `add-column`, `drop-column` und `rename-column`. Der Standardwert ist `false`.
+ `IncludeTransactionDetails` – Stellt detaillierte Transaktionsinformationen aus der Quelldatenbank bereit. Diese Informationen beinhalten einen Durchführungszeitstempel, eine Protokollposition sowie Werte für `transaction_id`, `previous_transaction_id` und `transaction_record_id ` (den Datensatzoffset innerhalb einer Transaktion). Der Standardwert ist `false`.
+ `PartitionIncludeSchemaTable` – Fügt Schema- und Tabellennamen zu Partitionswerten als Präfix hinzu, wenn der Partitionstyp `primary-key-type` ist. Dadurch wird die Datenverteilung zwischen Kinesis-Shards erhöht. Angenommen, ein `SysBench`-Schema hat Tausende von Tabellen und jede davon hat nur einen begrenzten Bereich für einen Primärschlüssel. In diesem Fall wird derselbe Primärschlüssel von Tausenden von Tabellen an denselben Shard gesendet, was zu einer Drosselung führt. Der Standardwert ist `false`.
+ `UseLargeIntegerValue`— Verwenden Sie bis zu 18-stellige Ganzzahlen, anstatt Ganzzahlen in Doppelzahlen umzuwandeln. Diese Option ist ab AWS DMS Version 3.5.4 verfügbar. Der Standardwert lautet „false“.

Das folgende Beispiel zeigt die Option `kinesis-settings` mit einem Beispielbefehl `create-endpoint`, der über die AWS CLI ausgegeben wird.

```
aws dms \
  create-endpoint \
    --region <aws-region> \
    --endpoint-identifier <user-endpoint-identifier> \
    --endpoint-type target \
    --engine-name kinesis \
    --kinesis-settings ServiceAccessRoleArn=arn:aws:iam::<account-id>:role/<kinesis-role-name>,StreamArn=arn:aws:kinesis:<aws-region>:<account-id>:stream/<stream-name>,MessageFormat=json-unformatted,
IncludeControlDetails=true,IncludeTransactionDetails=true,IncludePartitionValue=true,PartitionIncludeSchemaTable=true,
IncludeTableAlterOperations=true
```

**Aufgabeneinstellungen für vollständige Multithread-Ladevorgänge**

 AWS DMS Unterstützt eine Multithread-Volllast auf eine Kinesis Data Streams Streams-Ziel-Instance, um die Übertragungsgeschwindigkeit zu erhöhen. DMS unterstützt Multithreading u. a. mithilfe der folgenden Aufgabeneinstellungen:
+ `MaxFullLoadSubTasks` – Geben Sie diese Option an, um die maximale Anzahl von Quelltabellen festzulegen, die parallel geladen werden sollen. DMS lädt jede Tabelle in die entsprechende Kinesis-Zieltabelle mithilfe einer dedizierten Unteraufgabe. Der Standardwert beträgt 8; der Maximalwert beträgt 49.
+ `ParallelLoadThreads`— Verwenden Sie diese Option, um die Anzahl der Threads anzugeben, die AWS DMS verwendet werden, um jede Tabelle in ihre Kinesis-Zieltabelle zu laden. Der Höchstwert für ein Kinesis-Data-Streams-Ziel ist 32. Sie können eine Erhöhung dieses Höchstwerts anfordern.
+ `ParallelLoadBufferSize` – Verwenden Sie diese Option, um die maximale Anzahl der Datensätze anzugeben, die in dem Puffer gespeichert werden sollen, den die parallelen Lade-Threads zum Laden von Daten in das Kinesis-Ziel verwenden. Der Standardwert lautet 50. Die maximale Wert ist 1.000. Verwenden Sie diese Einstellung mit `ParallelLoadThreads`; `ParallelLoadBufferSize` ist nur gültig, wenn es mehr als einen Thread gibt.
+ `ParallelLoadQueuesPerThread` – Verwenden Sie diese Option, um die Anzahl der Warteschlangen anzugeben, auf die jeder gleichzeitige Thread zugreift, um Datensätze aus Warteschlangen zu entfernen und eine Stapellast für das Ziel zu generieren. Der Standardwert ist 1. Für Kinesis-Ziele mit verschiedenen Nutzlastgrößen beträgt der gültige Bereich jedoch 5–512 Warteschlangen pro Thread.

**Aufgabeneinstellungen für Multithreaded CDC-Ladevorgänge**

Sie können die Leistung der Änderungsdatenerfassung (Change Data Capture, CDC) für Echtzeitdaten-Streaming-Zielendpunkte wie Kinesis mithilfe von Aufgabeneinstellungen verbessern, die das Verhalten des API–Aufrufs `PutRecords` ändern. Dazu können Sie die Anzahl der gleichzeitigen Threads, der Warteschlangen pro Thread und die Anzahl der Datensätze angeben, die in einem Puffer unter Verwendung von `ParallelApply*`-Aufgabeneinstellungen gespeichert werden sollen. Beispiel: Sie möchten eine CDC-Last durchführen und 128 Threads parallel anwenden. Außerdem möchten Sie auf 64 Warteschlangen pro Thread zugreifen, wobei 50 Datensätze pro Puffer gespeichert sind. 

 AWS DMS Unterstützt die folgenden Task-Einstellungen, um die CDC-Leistung zu verbessern:
+ `ParallelApplyThreads`— Gibt die Anzahl der gleichzeitigen Threads an, die während eines CDC-Ladevorgangs AWS DMS verwendet werden, um Datensätze an einen Kinesis-Zielendpunkt zu übertragen. Der Standardwert ist Null (0) und der maximale Wert ist 32.
+ `ParallelApplyBufferSize` – Gibt die maximale Anzahl von Datensätzen an, die in jeder Pufferwarteschlange für gleichzeitige Threads gespeichert werden sollen, um sie während einer CDC-Last an einen Kinesis-Zielendpunkt zu übertragen. Der Standardwert ist 100 und der maximale Wert 1 000. Verwenden Sie diese Option, wenn `ParallelApplyThreads` mehrere Threads angibt. 
+ `ParallelApplyQueuesPerThread` – Gibt die Anzahl der Warteschlangen an, auf die jeder Thread zugreift, um Datensätze aus Warteschlangen zu entfernen und während des CDC eine Stapellast für einen Kinesis-Endpunkt zu generieren. Der Standardwert ist 1 und der maximale Wert 512.

Wenn Sie `ParallelApply*`-Aufgabeneinstellungen verwenden, ist der `primary-key` der Tabelle der `partition-key-type`-Standardwert, nicht `schema-name.table-name`.

## Verwenden eines Vorher-Abbilds zum Anzeigen von Originalwerten von CDC-Zeilen für einen Kinesis-Datenstrom als Ziel
<a name="CHAP_Target.Kinesis.BeforeImage"></a>

Wenn Sie CDC-Aktualisierungen in ein Data-Streaming-Ziel wie Kinesis schreiben, können Sie die ursprünglichen Werte einer Quelldatenbankzeile vor der Änderung durch eine Aktualisierung anzeigen. Um dies zu ermöglichen, AWS DMS füllt es ein *Vorher-Image* der Aktualisierungsereignisse auf der Grundlage von Daten aus, die von der Quelldatenbank-Engine bereitgestellt werden. 

Verschiedene Quelldatenbank-Engines liefern unterschiedliche Mengen an Informationen für ein Vorher-Abbild: 
+ Oracle stellt für Spalten nur dann Aktualisierungen bereit, wenn sie sich ändern. 
+ PostgreSQL stellt nur Daten für Spalten bereit, die Teil des Primärschlüssels sind (geändert oder nicht). Um Daten für alle Spalten (geändert oder nicht) bereitzustellen, müssen Sie `FULL` statt `DEFAULT` für `REPLICA_IDENTITY` festlegen. Beachten Sie, dass Sie die Einstellung `REPLICA_IDENTITY` für jede Tabelle sorgfältig auswählen sollten. Wenn Sie für `REPLICA_IDENTITY` `FULL` festlegen, werden alle Spaltenwerte kontinuierlich in das Write-Ahead Logging (WAL) geschrieben. Dies kann bei Tabellen, die häufig aktualisiert werden, zu Leistungs- oder Ressourcenproblemen führen.
+ MySQL stellt generell Daten für alle Spalten außer für BLOB- und CLOB-Datentypen bereit (geändert oder nicht).

Verwenden Sie entweder die `BeforeImageSettings`-Aufgabeneinstellung oder den `add-before-image-columns`-Parameter, um die Erstellung von Vorher-Abbildern zum Hinzufügen von Originalwerten aus der Quelldatenbank zur AWS DMS -Ausgabe zu aktivieren. Dieser Parameter wendet eine Spalten-Transformationsregel an. 

`BeforeImageSettings` fügt jeder Aktualisierungsoperation ein neues JSON-Attribut mit Werten hinzu, die aus dem Quelldatenbanksystem erfasst werden, wie nachfolgend gezeigt.

```
"BeforeImageSettings": {
    "EnableBeforeImage": boolean,
    "FieldName": string,  
    "ColumnFilter": pk-only (default) / non-lob / all (but only one)
}
```

**Anmerkung**  
Gilt nur für `BeforeImageSettings` AWS DMS Aufgaben, die eine CDC-Komponente enthalten, z. B. Volllast- und CDC-Aufgaben (bei denen vorhandene Daten migriert und laufende Änderungen repliziert werden), oder für reine CDC-Aufgaben (bei denen nur Datenänderungen repliziert werden). Wenden Sie `BeforeImageSettings` nicht auf Nur-Volllast-Aufgaben an.

Für `BeforeImageSettings`-Optionen gilt Folgendes:
+ Legen Sie die `EnableBeforeImage`-Option vor dem Imaging auf `true` fest. Der Standardwert ist `false`. 
+ Verwenden Sie die `FieldName`-Option, um dem neuen JSON-Attribut einen Namen zuzuweisen. Wann `EnableBeforeImage` `true` ist, ist `FieldName` erforderlich und darf nicht leer sein.
+ Die `ColumnFilter`-Option gibt eine Spalte an, die vor dem Imaging hinzugefügt werden soll. Wenn Sie nur Spalten hinzufügen möchten, die Teil der Primärschlüssel der Tabelle sind, verwenden Sie den Standardwert `pk-only`. Wenn Sie eine Spalte hinzufügen möchten, die einen Vorher-Abbild-Wert hat, verwenden Sie `all`. Beachten Sie, dass das Vorher-Abbild keine Spalten mit LOB-Datentypen wie CLOB oder BLOB enthält.

  ```
  "BeforeImageSettings": {
      "EnableBeforeImage": true,
      "FieldName": "before-image",
      "ColumnFilter": "pk-only"
    }
  ```

**Anmerkung**  
Amazon-S3-Ziele unterstützen `BeforeImageSettings` nicht. Verwenden Sie für S3-Ziele nur die `add-before-image-columns`-Transformationsregel, die vor de- Imaging während des CDC-Vorgangs ausgeführt werden soll.

### Verwenden einer Vorher-Abbild-Transformationsregel
<a name="CHAP_Target.Kinesis.BeforeImage.Transform-Rule"></a>

Alternativ zu den Aufgabeneinstellungen können Sie den `add-before-image-columns`-Parameter verwenden, der eine Spalten-Transformationsregel anwendet. Mit diesem Parameter können Sie das Vorher-Abbild während des CDC-Vorgangs auf Data-Streaming-Zielen wie Kinesis aktivieren. 

Wenn Sie `add-before-image-columns` in einer Transformationsregel verwenden, können Sie eine feinere Steuerung der Ergebnisse für das Vorher-Abbild anwenden. Mit Transformationsregeln können Sie einen Objekt-Locator verwenden, der Ihnen die Kontrolle über die für die Regel ausgewählten Tabellen gibt. Außerdem können Sie Transformationsregeln miteinander verketten, wodurch verschiedene Regeln auf verschiedene Tabellen angewendet werden können. Anschließend können Sie die erzeugten Spalten mithilfe anderer Regeln bearbeiten. 

**Anmerkung**  
Verwenden Sie den `add-before-image-columns`-Parameter nicht zusammen mit der `BeforeImageSettings`-Aufgabeneinstellung innerhalb derselben Aufgabe. Verwenden Sie stattdessen entweder den Parameter oder die Einstellung, aber nicht beide, für eine einzelne Aufgabe.

Ein `transformation`-Regeltyp mit dem `add-before-image-columns`-Parameter für eine Spalte muss einen `before-image-def`-Abschnitt bereitstellen. Es folgt ein Beispiel.

```
    {
      "rule-type": "transformation",
      …
      "rule-target": "column",
      "rule-action": "add-before-image-columns",
      "before-image-def":{
        "column-filter": one-of  (pk-only / non-lob / all),
        "column-prefix": string,
        "column-suffix": string,
      }
    }
```

Der Wert von `column-prefix` wird einem Spaltennamen vorangestellt, und der Standardwert von `column-prefix` ist `BI_`. Der Wert von `column-suffix` wird an den Spaltennamen angehängt, und der Standardwert ist leer. Setzen Sie nicht `column-prefix` und `column-suffix` auf leere Zeichenfolgen.

Wählen Sie einen Wert für `column-filter`. Wenn Sie nur Spalten hinzufügen möchten, die Teil der Primärschlüssel der Tabelle sind, wählen Sie `pk-only` . Wählen Sie `non-lob`, um nur Spalten hinzuzufügen, die nicht vom LOB-Typ sind. Oder lassen`all` Sie eine Spalte hinzufügen, die einen Vorher-Abbild-Wert hat.

### Beispiel für eine Vorher-Abbild-Transformationsregel
<a name="CHAP_Target.Kinesis.BeforeImage.Example"></a>

Die Transformationsregel im folgenden Beispiel fügt eine neue Spalte mit dem Namen `BI_emp_no` auf dem Ziel hinzu. Eine Anweisung wie `UPDATE employees SET emp_no = 3 WHERE emp_no = 1;` füllt daher das `BI_emp_no` Feld mit 1. Wenn Sie CDC-Aktualisierungen für Amazon-S3-Ziele schreiben, ermöglicht die `BI_emp_no`-Spalte, zu erkennen, welche ursprüngliche Zeile aktualisiert wurde.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "1",
      "object-locator": {
        "schema-name": "%",
        "table-name": "%"
      },
      "rule-action": "include"
    },
    {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "%",
        "table-name": "employees"
      },
      "rule-action": "add-before-image-columns",
      "before-image-def": {
        "column-prefix": "BI_",
        "column-suffix": "",
        "column-filter": "pk-only"
      }
    }
  ]
}
```

Weitere Informationen zur Verwendung der `add-before-image-columns`-Regelaktion finden Sie unter [Transformationsregeln und Aktionen](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md).

## Voraussetzungen für die Verwendung eines Kinesis-Datenstroms als Ziel für AWS Database Migration Service
<a name="CHAP_Target.Kinesis.Prerequisites"></a>

### IAM-Rolle für die Verwendung eines Kinesis-Datenstroms als Ziel für AWS Database Migration Service
<a name="CHAP_Target.Kinesis.Prerequisites.IAM"></a>

Bevor Sie einen Kinesis-Datenstream als Ziel für einrichten, stellen Sie sicher AWS DMS, dass Sie eine IAM-Rolle erstellen. Diese Rolle muss es ermöglichen AWS DMS , Zugriff auf die Kinesis-Datenströme zu übernehmen und zu gewähren, in die migriert werden. In der folgenden IAM-Richtlinie sind die Mindestzugriffsberechtigungen dargestellt.

------
#### [ JSON ]

****  

```
{
   "Version":"2012-10-17",		 	 	 
   "Statement": [
   {
     "Sid": "1",
     "Effect": "Allow",
     "Principal": {
        "Service": "dms.amazonaws.com"
     },
   "Action": "sts:AssumeRole"
   }
]
}
```

------

Die Rolle, die Sie für die Migration zu einem Kinesis-Datenstrom verwenden, muss über die folgenden Berechtigungen verfügen.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "kinesis:DescribeStream",
        "kinesis:PutRecord",
        "kinesis:PutRecords"
      ],
      "Resource": "*"
    }
  ]
}
```

------

### Zugreifen auf einen Kinesis-Datenstream als Ziel für AWS Database Migration Service
<a name="CHAP_Target.Kinesis.Prerequisites.Access"></a>

In AWS DMS Version 3.4.7 und höher müssen Sie einen der folgenden Schritte ausführen, um eine Verbindung zu einem Kinesis-Endpunkt herzustellen:
+ Konfigurieren von DMS für die Verwendung von VPC-Endpunkten. Informationen zur Konfiguration von VPC-Endpunkten finden Sie in [Konfiguration von VPC-Endpunkten für AWS DMS](CHAP_VPC_Endpoints.md).
+ Konfigurieren Sie DMS so, dass es öffentliche Routen verwendet, d. h. Ihre Replikations-Instance öffentlich zugänglich macht. Informationen zu Replikations-Instances finden Sie unter [Öffentliche und private Replikations-Instances](CHAP_ReplicationInstance.PublicPrivate.md).

## Einschränkungen bei der Verwendung von Kinesis Data Streams als Ziel für AWS Database Migration Service
<a name="CHAP_Target.Kinesis.Limitations"></a>

Bei der Verwendung von Kinesis Data Streams als Ziel gelten die folgenden Einschränkungen:
+ AWS DMS veröffentlicht jedes Update eines einzelnen Datensatzes in der Quelldatenbank als einen Datensatz in einem bestimmten Kinesis-Datenstrom, unabhängig von den Transaktionen. Sie können jedoch Transaktionsdetails für jeden Datensatz hinzufügen, indem Sie relevante Parameter der `KinesisSettings`-API verwenden.
+ Der vollständige LOB-Modus wird nicht unterstützt.
+ Die maximale unterstützte LOB-Größe beträgt 1 MB.
+ Kinesis Data Streams unterstützt keine Deduplizierung. Anwendungen, die Daten aus einem Stream aufnehmen, müssen doppelte Datensätze verarbeiten können. Weitere Informationen finden Sie unter [Umgang mit doppelten Datensätzen](https://docs.aws.amazon.com/streams/latest/dev/kinesis-record-processor-duplicates.html) im *Amazon-Kinesis-Data-Streams-Entwicklerhandbuch*.
+ AWS DMS unterstützt die folgenden vier Formen für Partitionsschlüssel:
  + `SchemaName.TableName`: Eine Kombination des Schema- und Tabellennamens.
  + `${AttributeName}`: Der Wert in einem der Felder in der JSON-Datei oder der Primärschlüssel der Tabelle in der Quelldatenbank.
  + `transaction-id`: Die CDC-Transaktions-ID. Alle Datensätze innerhalb derselben Transaktion gehen auf dieselbe Partition.
  + `constant`: Ein fester Literalwert für jeden Datensatz, unabhängig von Tabelle oder Daten. Alle Datensätze werden an denselben Partitionsschlüsselwert „constant“ gesendet, wodurch eine strikte globale Reihenfolge in allen Tabellen gewährleistet ist.

  ```
  {
      "rule-type": "object-mapping",
      "rule-id": "2",
      "rule-name": "PartitionKeyTypeExample",
      "rule-action": "map-record-to-document",
      "object-locator": {
          "schema-name": "onprem",
          "table-name": "it_system"
      },
      "mapping-parameters": {
          "partition-key-type": "transaction-id | constant | attribute-name | schema-table"
      }
  }
  ```
+ Weitere Informationen zum Verschlüsseln Ihrer Daten im Ruhezustand in Kinesis Data Streams finden Sie unter [Datenschutz in Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/server-side-encryption.html.html) im *AWS Key Management Service -Entwicklerhandbuch*. 
+ Die `IncludeTransactionDetails` Endpunkteinstellung wird nur unterstützt, wenn der Quellendpunkt Oracle, SQL Server, PostgreSQL oder MySQL ist. Bei anderen Quellendpunkttypen sind Transaktionsdetails nicht enthalten.
+ `BatchApply` wird für einen Kinesis-Endpunkt nicht unterstützt. Die Verwendung von Batch Apply (z. B. die `BatchApplyEnabled` Zielmetadaten-Aufgabeneinstellung) für ein Kinesis-Ziel führt zu Aufgabenfehlern und Datenverlust. Nicht aktivieren`BatchApply`, wenn Kinesis als Zielendpunkt verwendet wird.
+ Kinesis-Ziele werden nur für einen Kinesis-Datenstream im selben AWS Konto und in derselben AWS-Region Replikationsinstanz unterstützt.
+ Bei der Migration von einer MySQL-Quelle enthalten die BeforeImage Daten keine CLOB- und BLOB-Datentypen. Weitere Informationen finden Sie unter [Verwenden eines Vorher-Abbilds zum Anzeigen von Originalwerten von CDC-Zeilen für einen Kinesis-Datenstrom als Ziel](#CHAP_Target.Kinesis.BeforeImage).
+ AWS DMS unterstützt nicht die Migration von Werten mit einem `BigInt` Datentyp mit mehr als 16 Ziffern. Um diese Einschränkung zu umgehen, können Sie die folgende Transformationsregel verwenden, um die `BigInt`-Spalte in eine Zeichenfolge zu konvertieren. Informationen zu Transformationsregeln finden Sie unter [Transformationsregeln und Aktionen](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md).

  ```
  {
      "rule-type": "transformation",
      "rule-id": "id",
      "rule-name": "name",
      "rule-target": "column",
      "object-locator": {
          "schema-name": "valid object-mapping rule action",
          "table-name": "",
          "column-name": ""
      },
      "rule-action": "change-data-type",
      "data-type": {
          "type": "string",
          "length": 20
      }
  }
  ```
+ Wenn mehrere DML-Operationen innerhalb einer einzigen Transaktion eine LOB-Spalte (Large Object) in der Quelldatenbank ändern, behält die Zieldatenbank nur den letzten LOB-Wert der letzten Operation in dieser Transaktion bei. Die LOB-Zwischenwerte, die durch frühere Operationen in derselben Transaktion festgelegt wurden, werden überschrieben, was zu potenziellem Datenverlust oder Inkonsistenzen führen kann. Dieses Verhalten ist darauf zurückzuführen, wie LOB-Daten während der Replikation verarbeitet werden.
+ AWS DMS unterstützt keine Quelldaten mit eingebetteten `'\0'` Zeichen, wenn Kinesis als Zielendpunkt verwendet wird. Daten, die eingebettete `'\0'` Zeichen enthalten, werden beim ersten `'\0'` Zeichen gekürzt.

## Verwenden der Objektzuweisung zum Migrieren von Daten zu einem Kinesis-Datenstrom
<a name="CHAP_Target.Kinesis.ObjectMapping"></a>

AWS DMS verwendet Tabellenzuordnungsregeln, um Daten von der Quelle dem Kinesis-Zieldatenstrom zuzuordnen. Um Daten einem Ziel-Stream zuzuweisen , verwenden Sie eine Art von Tabellenzuweisungsregel, die als Objektzuweisung bezeichnet wird. Durch die Objektzuweisung legen Sie fest, wie Datensätze in der Quelle den im Kinesis-Datenstrom veröffentlichten Datensätzen zugewiesen werden. 

Kinesis-Datenströme verfügen bis auf einen Partitionsschlüssel über keine voreingestellte Struktur. In einer Objektzuweisungsregel sind die möglichen Werte eines `partition-key-type` für Datensätze `schema-table`, `transaction-id`, `primary-key`, `constant` und `attribute-name`.

Um eine Objektzuweisungsregel zu erstellen, legen Sie `rule-type` als `object-mapping` fest. Diese Regel gibt an, welchen Objektzuweisungstyp Sie verwenden möchten. 

Die Struktur für die Regel lautet wie folgt.

```
{
    "rules": [
        {
            "rule-type": "object-mapping",
            "rule-id": "id",
            "rule-name": "name",
            "rule-action": "valid object-mapping rule action",
            "object-locator": {
                "schema-name": "case-sensitive schema name",
                "table-name": ""
            }
        }
    ]
}
```

AWS DMS unterstützt derzeit `map-record-to-record` und `map-record-to-document` als einzig gültige Werte für den Parameter. `rule-action` Diese Einstellungen wirken sich auf Werte aus, die nicht in der `exclude-columns`-Attributliste ausgeschlossen sind. Die `map-record-to-document` Werte `map-record-to-record` und geben an, wie diese Datensätze standardmäßig AWS DMS behandelt werden. Diese Werte wirken sich in keiner Weise auf die Attributzuweisungen aus. 

Verwenden Sie `map-record-to-record` beim Migrieren aus einer relationalen Datenbank zu einem Kinesis-Datenstrom. Dieser Regeltyp verwendet den `taskResourceId.schemaName.tableName`-Wert aus der relationalen Datenbank als Partitionsschlüssel im Kinesis-Datenstrom und erstellt ein Attribut für jede Spalte in der Quelldatenbank. 

Beachten Sie bei Verwendung von `map-record-to-record` Folgendes:
+ Diese Einstellung wirkt sich nur auf Spalten aus, die durch die `exclude-columns`-Liste ausgeschlossen wurden.
+  AWS DMS Erstellt für jede dieser Spalten ein entsprechendes Attribut im Zielthema.
+ AWS DMS erstellt dieses entsprechende Attribut unabhängig davon, ob die Quellspalte in einer Attributzuordnung verwendet wird. 

Verwenden Sie `map-record-to-document`, um Quellspalten in ein einziges, flaches Dokument im entsprechenden Ziel-Stream unter Verwendung des Attributnamens „\$1doc“ einzufügen. AWS DMS platziert die Daten in einer einzigen, flachen Zuweisung in der Quelle mit dem Namen „`_doc`“. Diese Platzierung gilt für jede Spalte der Quelltabelle, die nicht in der `exclude-columns`-Attributliste aufgeführt ist.

Eine Möglichkeit, `map-record-to-record` zu verstehen, besteht darin, sich die praktische Anwendung zu veranschaulichen. In diesem Beispiel wird davon ausgegangen, dass Sie mit einer Tabellenzeile einer relationalen Datenbank beginnen, die die folgende Struktur aufweist und die folgenden Daten enthält.


| FirstName | LastName | StoreId | HomeAddress | HomePhone | WorkAddress | WorkPhone | DateofBirth | 
| --- | --- | --- | --- | --- | --- | --- | --- | 
| Randy | Marsh | 5 | 221B Baker Street | 1234567890 | 31 Spooner Street, Quahog  | 9876543210 | 02/29/1988 | 

Um diese Informationen von einem Schema mit dem Namen `Test` zu einem Kinesis-Datenstrom zu migrieren, erstellen Sie Regeln zur Zuordnung der Daten zu dem Zieldatenstrom. Die folgende Regel veranschaulicht die Zuweisung. 

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "rule-action": "include",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            }
        },
        {
            "rule-type": "object-mapping",
            "rule-id": "2",
            "rule-name": "DefaultMapToKinesis",
            "rule-action": "map-record-to-record",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "Customers"
            }
        }
    ]
}
```

Im Folgenden ist das resultierende Datensatzformat im Kinesis-Datenstrom dargestellt: 
+ StreamName: XXX
+ PartitionKey: Test.Customers //schmaname.tableName
+ Data: //Die folgende JSON-Meldung

  ```
    {
       "FirstName": "Randy",
       "LastName": "Marsh",
       "StoreId":  "5",
       "HomeAddress": "221B Baker Street",
       "HomePhone": "1234567890",
       "WorkAddress": "31 Spooner Street, Quahog",
       "WorkPhone": "9876543210",
       "DateOfBirth": "02/29/1988"
    }
  ```

Nehmen wir jedoch an, dass Sie dieselben Regeln verwenden, den `rule-action`-Parameter jedoch in `map-record-to-document` ändern und bestimmte Spalten ausschließen. Die folgende Regel veranschaulicht die Zuweisung.

```
{
	"rules": [
	   {
			"rule-type": "selection",
			"rule-id": "1",
			"rule-name": "1",
			"rule-action": "include",
			"object-locator": {
				"schema-name": "Test",
				"table-name": "%"
			}
		},
		{
			"rule-type": "object-mapping",
			"rule-id": "2",
			"rule-name": "DefaultMapToKinesis",
			"rule-action": "map-record-to-document",
			"object-locator": {
				"schema-name": "Test",
				"table-name": "Customers"
			},
			"mapping-parameters": {
				"exclude-columns": [
					"homeaddress",
					"homephone",
					"workaddress",
					"workphone"
				]
			}
		}
	]
}
```

In diesem Fall werden die nicht im `exclude-columns`-Parameter aufgeführten Spalten `FirstName`, `LastName`, `StoreId` und `DateOfBirth` zu `_doc` zugeordnet. Im Folgenden ist das resultierende Datensatzformat dargestellt. 

```
       {
            "data":{
                "_doc":{
                    "FirstName": "Randy",
                    "LastName": "Marsh",
                    "StoreId":  "5",
                    "DateOfBirth": "02/29/1988"
                }
            }
        }
```

### Umstrukturieren von Daten mit Attributzuweisung
<a name="CHAP_Target.Kinesis.AttributeMapping"></a>

Sie können die Daten während der Migration zu einem Kinesis-Datenstrom mithilfe einer Attributzuordnung umstrukturieren. So möchten Sie zum Beispiel vielleicht mehrere Felder in der Quelle in einem einzigen Feld im Ziel vereinen. Die folgenden Attributzuordnung veranschaulicht, wie die Daten umstrukturiert werden.

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "rule-action": "include",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            }
        },
        {
            "rule-type": "object-mapping",
            "rule-id": "2",
            "rule-name": "TransformToKinesis",
            "rule-action": "map-record-to-record",
            "target-table-name": "CustomerData",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "Customers"
            },
            "mapping-parameters": {
                "partition-key-type": "attribute-name",
                "partition-key-name": "CustomerName",
                "exclude-columns": [
                    "firstname",
                    "lastname",
                    "homeaddress",
                    "homephone",
                    "workaddress",
                    "workphone"
                ],
                "attribute-mappings": [
                    {
                        "target-attribute-name": "CustomerName",
                        "attribute-type": "scalar",
                        "attribute-sub-type": "string",
                        "value": "${lastname}, ${firstname}"
                    },
                    {
                        "target-attribute-name": "ContactDetails",
                        "attribute-type": "document",
                        "attribute-sub-type": "json",
                        "value": {
                            "Home": {
                                "Address": "${homeaddress}",
                                "Phone": "${homephone}"
                            },
                            "Work": {
                                "Address": "${workaddress}",
                                "Phone": "${workphone}"
                            }
                        }
                    }
                ]
            }
        }
    ]
}
```

Um einen konstanten Wert für festzulegen, geben `"partition-key-type: "constant"` Sie an`partition-key`, dass dadurch der Partitionswert auf gesetzt wird. `constant` So könnten Sie auf diese Weise beispielsweise erzwingen, dass alle Daten in einem einzigen Shard gespeichert werden. Die folgende Darstellung veranschaulicht dieses Konzept. 

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "object-mapping",
            "rule-id": "2",
            "rule-name": "TransformToKinesis",
            "rule-action": "map-record-to-document",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "Customer"
            },
            "mapping-parameters": {
                "partition-key-type": "constant",
                "exclude-columns": [
                    "FirstName",
                    "LastName",
                    "HomeAddress",
                    "HomePhone",
                    "WorkAddress",
                    "WorkPhone"
                ],
                "attribute-mappings": [
                    {
                        "target-attribute-name": "CustomerName",
                        "attribute-type": "scalar",
                        "attribute-sub-type": "string",
                        "value": "${FirstName},${LastName}"

                    },
                    {
                        "target-attribute-name": "ContactDetails",
                        "attribute-type": "scalar",
                        "attribute-sub-type": "string",
                        "value": {
                            "Home": {
                                "Address": "${HomeAddress}",
                                "Phone": "${HomePhone}"
                            },
                            "Work": {
                                "Address": "${WorkAddress}",
                                "Phone": "${WorkPhone}"
                            }
                        }
                    },
                    {
                        "target-attribute-name": "DateOfBirth",
                        "attribute-type": "scalar",
                        "attribute-sub-type": "string",
                        "value": "${DateOfBirth}"
                    }
                ]
            }
        }
    ]
}
```

**Anmerkung**  
Der `partition-key`-Wert für einen Steuerungsdatensatz, der für eine spezifische Tabelle bestimmt ist, lautet `TaskId.SchemaName.TableName`. Der `partition-key`-Wert für einen Steuerungsdatensatz, der für eine spezifische Aufgabe bestimmt ist, ist die `TaskId` des betreffenden Datensatzes. Wenn Sie einen `partition-key`-Wert in der Objektzuweisung angeben, hat dies keine Auswirkungen auf den `partition-key` für einen Steuerungsdatensatz.  
 Wann `attribute-name` in einer Tabellenzuordnungsregel auf festgelegt `partition-key-type` ist, müssen Sie angeben`partition-key-name`, was entweder auf eine Spalte aus der Quelltabelle oder auf eine in der Zuordnung definierte benutzerdefinierte Spalte verweisen muss. Zusätzlich `attribute-mappings` muss definiert werden, wie Quellspalten dem Ziel-Kinesis Stream zugeordnet werden.

### Nachrichtenformat für Kinesis-Datenströme
<a name="CHAP_Target.Kinesis.Messageformat"></a>

Die JSON-Ausgabe ist einfach eine Liste von Schlüssel-Wert-Paaren. Ein JSON\$1UNFORMATTED-Nachrichtenformat ist eine einzeilige JSON-Zeichenfolge mit neuem Zeilenbegrenzer.

AWS DMS stellt die folgenden reservierten Felder bereit, um die Nutzung der Daten aus den Kinesis Data Streams zu vereinfachen: 

**RecordType**  
Der Datensatztyp kann entweder für Daten oder zur Steuerung bestimmt sein. *Datensätze für Daten*repräsentieren die tatsächlichen Zeilen in der Quelle. *Steuerungsdatensätze* sind für wichtige Ereignisse im Stream bestimmt, z. B. einen Neustart der Aufgabe.

**Operation**  
Mögliche Operationen für Datensätze sind `load`, `insert`, `update` oder `delete`.  
Mögliche Operationen für Steuerungsdatensätze sind `create-table`, `rename-table`, `drop-table`, `change-columns`, `add-column`, `drop-column`, `rename-column` oder `column-type-change`.

**SchemaName**  
Das Quellschema für den Datensatz. Dieses Feld kann für einen Steuerungsdatensatz leer sein.

**TableName**  
Die Quelltabelle für den Datensatz. Dieses Feld kann für einen Steuerungsdatensatz leer sein.

**Zeitstempel**  
Der Zeitstempel für den Zeitpunkt, an dem die JSON-Nachricht erstellt wurde. Das Feld ist mit dem ISO-8601-Format formatiert.