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.

Verwenden von Amazon Kinesis Data Streams als Ziel für AWS Database Migration Service

Sie können verwenden AWS DMS , um Daten in einen Amazon Kinesis Data Stream 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 im Amazon-Kinesis-Data-Streams-Entwicklerhandbuch.

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

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.

Wenn Tabellen auf einem Kinesis-Data-Streams-Zielendpunkt AWS DMS erstellt, werden so viele Tabellen wie im Quelldatenbankendpunkt erstellt. legt AWS DMS auch mehrere Parameterwerte für Kinesis Data Streams fest. Die Kosten für die Erstellung der Tabelle sind abhängig von der Datenmenge und der Anzahl der zu migrierenden Tabellen.

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

aws dms create-endpoint --endpoint-identifier=$target_name --engine-name kinesis --endpoint-type target
--region us-east-1 --kinesis-settings ServiceAccessRoleArn=arn:aws:iam::333333333333:role/dms-kinesis-role,
StreamArn=arn:aws:kinesis:us-east-1:333333333333:stream/dms-kinesis-target-doc,MessageFormat=json-unformatted,
IncludeControlDetails=true,IncludeTransactionDetails=true,IncludePartitionValue=true,PartitionIncludeSchemaTable=true,
IncludeTableAlterOperations=true

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

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 ein Vorher-Image von Aktualisierungsereignissen basierend auf Daten aus, die von der Quelldatenbank-Engine bereitgestellt werden.

Verschiedene Quelldatenbank-Engines liefern unterschiedliche Mengen an Informationen für ein Vorher-Abbild:

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)
}
        

Für BeforeImageSettings-Optionen gilt Folgendes:

Verwenden einer Vorher-Abbild-Transformationsregel

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.

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 lassenall Sie eine Spalte hinzufügen, die einen Vorher-Abbild-Wert hat.

Beispiel für eine Vorher-Abbild-Transformationsregel

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.

Voraussetzungen für die Verwendung eines Kinesis-Datenstroms als Ziel für AWS Database Migration Service

IAM-Rolle für die Verwendung eines Kinesis-Datenstroms als Ziel für AWS Database Migration Service

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

{
   "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.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "kinesis:DescribeStream",
                "kinesis:PutRecord",
                "kinesis:PutRecords"
            ],
            "Resource": "arn:aws:kinesis:region:accountID:stream/streamName"
        }
    ]
}

Zugreifen auf einen Kinesis-Datenstrom als Ziel für AWS Database Migration Service

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:

Einschränkungen bei der Verwendung von Kinesis Data Streams als Ziel für AWS Database Migration Service

Bei der Verwendung von Kinesis Data Streams als Ziel gelten die folgenden Einschränkungen:

Verwenden der Objektzuweisung zum Migrieren von Daten zu einem Kinesis-Datenstrom

AWS DMS verwendet Tabellenzuordnungsregeln, um Daten aus 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 einzige gültige Werte für den -rule-actionParameter. 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 verarbeitet. 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:

Verwenden Sie map-record-to-document, um Quellspalten in ein einziges, flaches Dokument im entsprechenden Ziel-Stream unter Verwendung des Attributnamens „_doc“ 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.

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:

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

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 partition-key festzulegen, geben Sie einen partition-key-Wert an. 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": "1",
            "rule-name": "TransformToKinesis",
            "rule-action": "map-record-to-document",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "Customer"
            },
            "mapping-parameters": {
                "partition-key": {
                    "value": "ConstantPartitionKey"
                },
                "exclude-columns": [
                    "FirstName",
                    "LastName",
                    "HomeAddress",
                    "HomePhone",
                    "WorkAddress",
                    "WorkPhone"
                ],
                "attribute-mappings": [
                    {
                        "attribute-name": "CustomerName",
                        "value": "${FirstName},${LastName}"
                    },
                    {
                        "attribute-name": "ContactDetails",
                        "value": {
                            "Home": {
                                "Address": "${HomeAddress}",
                                "Phone": "${HomePhone}"
                            },
                            "Work": {
                                "Address": "${WorkAddress}",
                                "Phone": "${WorkPhone}"
                            }
                        }
                    },
                    {
                        "attribute-name": "DateOfBirth",
                        "value": "${DateOfBirth}"
                    }
                ]
            }
        }
    ]
}

Nachrichtenformat für Kinesis-Datenströme

Die JSON-Ausgabe ist einfach eine Liste von Schlüssel-Wert-Paaren. Ein JSON_UNFORMATTED-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 erleichtern: