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 Neptune als Ziel für AWS Database Migration Service

Amazon Neptune ist ein schneller, zuverlässiger, vollständig verwalteter Graph-Datenbankservice, mit dem es ganz einfach ist, Anwendungen zu erstellen und auszuführen, die mit stark verbundenen Datensätzen arbeiten. Den Kern von Neptune bildet eine speziell entwickelte, hochleistungsfähige Graphdatenbank-Engine. Diese Engine ist für die Speicherung von Milliarden von Beziehungen und die Abfrage des Graphen mit einer Latenzzeit von Millisekunden optimiert. Neptune unterstützt die gängigen Graph-Abfragesprachen Apache TinkerPop Gremlin und W3C SPARQL. Weitere Informationen zu Amazon Neptune finden Sie unter Was ist Amazon Neptune? im Amazon-Neptune-Benutzerhandbuch.

Ohne eine Graphdatenbank wie Neptune modellieren Sie wahrscheinlich hoch verbundene Daten in einer relationalen Datenbank. Da die Daten über potenziell dynamische Verbindungen verfügen, müssen Anwendungen, die solche Datenquellen verwenden, verbundene Datenabfragen in SQL modellieren. Dieser Ansatz erfordert, dass Sie einen zusätzlichen Layer schreiben, um Graph-Abfragen in SQL zu konvertieren. Außerdem haben relationale Datenbanken eine Schemastarrheit. Änderungen am Schema an modelländernden Verbindungen erfordern Ausfallzeiten und zusätzliche Wartung der Abfragekonvertierung, um das neue Schema zu unterstützen. Die Abfrageleistung ist auch eine weitere große Einschränkung, die beim Entwerfen Ihrer Anwendungen berücksichtigt werden muss.

Graph-Datenbanken können solche Situationen erheblich vereinfachen. Frei von einem Schema, einem Rich Graph Query Layer (Gremlin oder SPARQL) und Indizes, die für Graph-Abfragen optimiert sind, erhöhen die Flexibilität und Leistung. Die Graphdatenbank von Amazon Neptune verfügt auch über Enterprise-Features wie Verschlüsselung im Ruhezustand, eine sichere Autorisierungsebene, Standardsicherungen, Multi-AZ-Unterstützung, Unterstützung für Lesereplikate und mehr.

Mit AWS DMS können Sie relationale Daten migrieren, die einen stark verbundenen Graphen von einem DMS-Quellendpunkt für jede unterstützte SQL-Datenbank auf einen Neptune-Zielendpunkt modellieren.

Weitere Informationen finden Sie im Folgenden.

Übersicht über die Migration zu Amazon Neptune als Ziel

Bevor Sie mit der Migration zu einem Neptune-Ziel beginnen, erstellen Sie die folgenden Ressourcen in Ihrem AWS-Konto:

Nachdem Sie über diese Ressourcen verfügen, sind die Einrichtung und das Starten einer Migration zu einem Neptune-Ziel ähnlich wie bei einer Volllastmigration unter Verwendung der Konsole oder der DMS-API. Eine Migration zu einem Neptune-Ziel erfordert jedoch einige spezifische Schritte.

Angeben von Endpunkteinstellungen für Amazon Neptune als Ziel

Um einen Zielendpunkt zu erstellen oder zu ändern, können Sie die Konsole oder die CreateEndpoint- oder ModifyEndpoint-API-Vorgänge verwenden.

Geben Sie für ein Neptune-Ziel in der AWS DMS-Konsole Endpunktspezifische Einstellungen auf der Konsolenseite Endpunkt erstellen oder Endpunkt ändern an. Geben Sie für CreateEndpoint und ModifyEndpoint Anforderungsparameter für die NeptuneSettings-Option an. Das folgende Beispiel zeigt, wie dies über die Befehlszeilenschnittstelle (CLI) möglich ist.

dms create-endpoint --endpoint-identifier my-neptune-target-endpoint
--endpoint-type target --engine-name neptune 
--server-name my-neptune-db.cluster-cspckvklbvgf.us-east-1.neptune.amazonaws.com 
--port 8192
--neptune-settings 
     '{"ServiceAccessRoleArn":"arn:aws:iam::123456789012:role/myNeptuneRole",
       "S3BucketName":"my-bucket",
       "S3BucketFolder":"my-bucket-folder",
       "ErrorRetryDuration":57,
       "MaxFileSize":100, 
       "MaxRetryCount": 10, 
       "IAMAuthEnabled":false}‘

Hier gibt die CLI-Option --server-name den Servernamen für den Neptune-Cluster-Writer-Endpunkt an. Sie können auch den Servernamen für einen Neptune-Writer-Instance-Endpunkt angeben.

Die --neptune-settings-Option fordert Parameter wie folgt an:

Erstellen einer IAM-Servicerolle für den Zugriff auf Amazon Neptune als Ziel

Um auf Neptune als Ziel zuzugreifen, erstellen Sie mithilfe von IAM eine Dienstrolle. Fügen Sie dieser Rolle abhängig von Ihrer Neptune-Endpunktkonfiguration einige oder alle folgenden IAM-Richtlinien- und Vertrauensdokumente an. Wenn Sie den Neptune-Endpunkt erstellen, geben Sie den ARN dieser Servicerolle an. Auf diese Weise können AWS DMS und Amazon Neptune Berechtigungen für den Zugriff auf Neptune und den zugehörigen Amazon-S3-Bucket übernehmen.

Wenn Sie in Ihrer Neptune-Endpunktkonfiguration den Parameter IAMAuthEnabled in NeptuneSettings auf truefestlegen, fügen Sie Ihrer Servicerolle eine IAM-Richtlinie wie die folgende hinzu. Wenn Sie IAMAuthEnabled auf false festlegen, können Sie diese Richtlinie ignorieren.

// Policy to access Neptune

    {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Sid": "VisualEditor0",
                "Effect": "Allow",
                "Action": "neptune-db:*",
                "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-CLG7H7FHK54AZGHEH6MNS55JKM/*"
            }
        ]
    }

Die vorangehende IAM-Richtlinie ermöglicht vollen Zugriff auf den von Resource angegebenen Neptune-Ziel-Cluster.

Fügen Sie Ihrer Dienstrolle eine IAM-Richtlinie wie die folgende an. Diese Richtlinie ermöglicht es DMS, migrierte Diagrammdaten vorübergehend im S3-Bucket zu speichern, den Sie für den Massenladevorgang in die Neptune-Zieldatenbank erstellt haben.

//Policy to access S3 bucket

{
	"Version": "2012-10-17",
	"Statement": [{
			"Sid": "ListObjectsInBucket0",
			"Effect": "Allow",
			"Action": "s3:ListBucket",
			"Resource": [
				"arn:aws:s3:::my-bucket"
			]
		},
		{
			"Sid": "AllObjectActions",
			"Effect": "Allow",
			"Action": ["s3:GetObject",
				"s3:PutObject",
				"s3:DeleteObject"
			],

			"Resource": [
				"arn:aws:s3:::my-bucket/"
			]
		},
		{
			"Sid": "ListObjectsInBucket1",
			"Effect": "Allow",
			"Action": "s3:ListBucket",
			"Resource": [
				"arn:aws:s3:::my-bucket",
				"arn:aws:s3:::my-bucket/"
			]
		}
	]
}

Die vorangehende IAM-Richtlinie ermöglicht es Ihrem Konto, den Inhalt des S3-Buckets (arn:aws:s3:::my-bucket) abzufragen, der für Ihr Neptune-Ziel erstellt wurde. Außerdem kann Ihr Konto vollständig mit dem Inhalt aller Bucket-Dateien und Ordner arbeiten (arn:aws:s3:::my-bucket/).

Bearbeiten Sie die Vertrauensbeziehung und fügen Sie Ihrer Servicerolle die folgende IAM-Rolle an, damit AWS DMS und der Amazon-Neptune-Datenbankservice die Rolle übernehmen können.

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

Weitere Informationen zum Angeben dieser Servicerolle für den Neptune-Zielendpunkt finden Sie unter Angeben von Endpunkteinstellungen für Amazon Neptune als Ziel.

Angeben von Graph-Zuordnungsregeln mit Gremlin und R2RML für Amazon Neptune als Ziel

Die von Ihnen erstellten Graph-Zuordnungsregeln geben an, wie Daten, die aus einer relationalen SQL-Datenbankquelle extrahiert werden, in ein Neptune-Datenbank-Cluster-Ziel geladen werden. Das Format dieser Zuweisungsregeln unterscheidet sich je nachdem, ob die Regeln zum Laden von Eigenschaftsdiagrammdaten mit Apache TinkerPop Gremlin oder RDF(Resource Description Framework)-Daten mit R2RML dienen. Im Folgenden finden Sie Informationen zu diesen Formaten und wo Sie mehr darüber erfahren können.

Sie können diese Zuordnungsregeln angeben, wenn Sie die Migrationsaufgabe mithilfe der Konsole oder der DMS-API erstellen.

Geben Sie mithilfe der Graph-Zuordnungsregeln auf der Seite Datenbankmigration erstellen diese Zuordnungsregeln an. In Graph-Zuordnungsregeln können Sie die Zuordnungsregeln direkt mit dem bereitgestellten Editor eingeben und bearbeiten. Sie können auch nach einer Datei suchen, die die Zuordnungsregeln im entsprechenden Graph-Zuordnungsformat enthält.

Geben Sie mithilfe der API diese Optionen über den TaskData-Anforderungsparameter des CreateReplicationTask-API-Aufrufs an. Legen Sie TaskData auf den Pfad einer Datei fest, die die Zuordnungsregeln im entsprechenden Graph-Zuordnungsformat enthält.

Graph-Zuordnungsregeln zum Generieren von Eigenschafts-Graph-Daten mit Gremlin

Verwenden Sie Gremlin zum Generieren der Eigenschafts-Graph-Daten an, geben Sie ein JSON-Objekt mit einer Zuordnungsregel für jede Graph-Entität ein, die aus Quelldaten generiert werden soll. Das Format dieses JSON-Objekts ist speziell für einen Masseladevorgang von Amazon Neptune definiert. Die folgende Vorlage zeigt, wie die einzelnen Regeln in diesem Objekt aussehen:

{
    "rules": [
        {
            "rule_id": "(an identifier for this rule)",
            "rule_name": "(a name for this rule)",
            "table_name": "(the name of the table or view being loaded)",
            "vertex_definitions": [
                {
                    "vertex_id_template": "{col1}",
                    "vertex_label": "(the vertex to create)",
                    "vertex_definition_id": "(an identifier for this vertex)",
                    "vertex_properties": [
                        {
                            "property_name": "(name of the property)",
                            "property_value_template": "{col2} or text",
                            "property_value_type": "(data type of the property)"
                        }
                    ]
                }
            ]
        },
        {
            "rule_id": "(an identifier for this rule)",
            "rule_name": "(a name for this rule)",
            "table_name": "(the name of the table or view being loaded)",
            "edge_definitions": [
                {
                    "from_vertex": {
                        "vertex_id_template": "{col1}",
                        "vertex_definition_id": "(an identifier for the vertex referenced above)"
                    },
                    "to_vertex": {
                        "vertex_id_template": "{col3}",
                        "vertex_definition_id": "(an identifier for the vertex referenced above)"
                    },
                    "edge_id_template": {
                        "label": "(the edge label to add)",
                        "template": "{col1}_{col3}"
                    },
                    "edge_properties":[
                        {
                            "property_name": "(the property to add)",
                            "property_value_template": "{col4} or text",
                            "property_value_type": "(data type like String, int, double)"
                        }
                    ]
                }
            ]
        }
    ]
}
 

Das Vorhandensein eines Vertex-Labels bedeutet, dass der Knoten hier erstellt wird. Seine Abwesenheit bedeutet, dass der Knoten von einer anderen Quelle erstellt wird, und diese Definition fügt nur Knoteneigenschaften hinzu. Geben Sie so viele Knoten- und Grenzdefinitionen an, wie erforderlich, um die Zuordnungen für die gesamte relationale Datenbankquelle anzugeben.

Es folgt eine Beispielregel für eine employee-Tabelle.

{
    "rules": [
        {
            "rule_id": "1",
            "rule_name": "vertex_mapping_rule_from_nodes",
            "table_name": "nodes",
            "vertex_definitions": [
                {
                    "vertex_id_template": "{emp_id}",
                    "vertex_label": "employee",
                    "vertex_definition_id": "1",
                    "vertex_properties": [
                        {
                            "property_name": "name",
                            "property_value_template": "{emp_name}",
                            "property_value_type": "String"
                        }
                    ]
                }
            ]
        },
        {
            "rule_id": "2",
            "rule_name": "edge_mapping_rule_from_emp",
            "table_name": "nodes",
            "edge_definitions": [
                {
                    "from_vertex": {
                        "vertex_id_template": "{emp_id}",
                        "vertex_definition_id": "1"
                    },
                    "to_vertex": {
                        "vertex_id_template": "{mgr_id}",
                        "vertex_definition_id": "1"
                    },
                    "edge_id_template": {
                        "label": "reportsTo",
                        "template": "{emp_id}_{mgr_id}"
                    },
                    "edge_properties":[
                        {
                            "property_name": "team",
                            "property_value_template": "{team}",
                            "property_value_type": "String"
                        }
                    ]
                }
            ]
        }
    ]
}
 

Hier ordnen die Knoten- und Grenzdefinitionen eine Meldebeziehung von einem employee-Knoten mit Mitarbeiter-ID (EmpID) und einem employee-Knoten mit einer Manager-ID (managerId) zu.

Weitere Informationen zum Erstellen von Graph-Zuordnungsregeln mit Gremlin JSON finden Sie unter Gremlin-Format zum Laden von Daten im Amazon-Neptune-Benutzerhandbuch.

Graph-Zuordnungsregeln zum Generieren von RDF/SPARQL-Daten

Wenn Sie RDF-Daten laden, die mit SPARQL abgefragt werden sollen, schreiben Sie die Graph-Zuordnungsregeln in R2RML. R2RML ist eine Standard-W3C-Sprache für die Zuordnung relationaler Daten zu RDF. In einer R2RML-Datei gibt eine Dreifach-Zuordnung (z  B. <#TriplesMap1> folgend) eine Regel an, um jede Zeile einer logischen Tabelle in null oder mehr RDF-Triple zu übersetzen. Eine Betreffzuordnung (z. B. eine beliebige rr:subjectMap folgend) gibt eine Regel zum Generieren der Betreffe der RDF-Triple an, die von einer Tripel-Zuordnung generiert werden. Eine -Prädikat-Objekt-Zuordnung (z. B. eine beliebige rr:predicateObjectMap folgend) ist eine Funktion, die ein oder mehrere Prädikat-Objekt-Paare für jede logische Tabellenzeile einer logischen Tabelle erstellt.

Ein einfaches Beispiel für eine nodes-Tabelle folgt.

@prefix rr: <http://www.w3.org/ns/r2rml#>.
@prefix ex: <http://example.com/ns#>.

<#TriplesMap1>
    rr:logicalTable [ rr:tableName "nodes" ];
    rr:subjectMap [
        rr:template "http://data.example.com/employee/{id}";
        rr:class ex:Employee;
    ];
    rr:predicateObjectMap [
        rr:predicate ex:name;
        rr:objectMap [ rr:column "label" ];
    ]

Im vorherigen Beispiel definiert die Zuordnung Graph-Knoten, die aus einer Tabelle mit Mitarbeitern zugeordnet sind.

Ein weiteres einfaches Beispiel für eine Student-Tabelle folgt.

@prefix rr: <http://www.w3.org/ns/r2rml#>.
@prefix ex: <http://example.com/#>.
@prefix foaf: <http://xmlns.com/foaf/0.1/>.
@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.

<#TriplesMap2>
    rr:logicalTable [ rr:tableName "Student" ];
    rr:subjectMap   [ rr:template "http://example.com/{ID}{Name}";
                      rr:class foaf:Person ];
    rr:predicateObjectMap [
        rr:predicate ex:id ;
        rr:objectMap  [ rr:column "ID";
                        rr:datatype xsd:integer ]
    ];
    rr:predicateObjectMap [
        rr:predicate foaf:name ;
        rr:objectMap  [ rr:column "Name" ]
    ].

Im vorherigen Beispiel definiert die Zuordnung Graph-Knoten, die Freund-eines-Freundes-Beziehungen zwischen Personen in einer Student-Tabelle zuordnen.

Weitere Informationen zum Erstellen von Graph-Zuordnungsregeln mit SPARQL R2RML finden Sie in der W3C-Spezifikation R2RML: RDB to RDF Mapping Language.

Datentypen für die Migration von Gremlin und R2RML zu Amazon Neptune als Ziel

AWS DMS führt eine Datentypzuordnung von Ihrem SQL-Quellendpunkt zu Ihrem Neptune-Ziel auf zwei Arten durch. Welche Art Sie verwenden, hängt vom Graph-Zuordnungsformat ab, das Sie zum Laden der Neptune-Datenbank verwenden:

Weitere Informationen zu diesen beiden Graph-Zuordnungsformaten finden Sie unter Angeben von Graph-Zuordnungsregeln mit Gremlin und R2RML für Amazon Neptune als Ziel.

Nachfolgend finden Sie Beschreibungen der Datentypzuordnungen für jedes Format.

Datentypzuordnungen von SQL-Quelle auf Gremlin-Ziel

Die folgende Tabelle zeigt die Datentypzuordnungen von einer SQL-Quelle auf ein Gremlin-formatiertes Ziel.

AWS DMS ordnet einen beliebigen nicht aufgelisteten SQL-Quelldatentyp einem Gremlin-String zu.

Weitere Informationen zu den Gremlin-Datentypen zum Laden von Neptune finden Sie unter Gremlin-Datentypen im Neptune-Benutzerhandbuch.

SQL-Quell-zu-R2RML-Zieldatentyp-Zuordnungen (RDF)

Die folgende Tabelle zeigt die Datentypzuordnungen von einer SQL-Quelle zu einem R2RML-formatierten Ziel.

Bei allen aufgelisteten RDF-Datentypen wird zwischen Groß- und Kleinschreibung unterschieden, mit Ausnahme des RDF-Literal. AWS DMS ordnet jeden nicht aufgelisteten SQL-Quelldatentyp einem RDF-Literal zu.

Ein RDF-Literal ist eine von einer Vielzahl von wörtlichen lexikalischen Formen und Datentypen. Weitere Informationen finden Sie unter RDF-Literale in der W3C-Spezifikation Resource Description Framework (RDF): Konzepte und abstrakte Syntax.

Weitere Informationen zu den RDF-Datentypen zum Laden von Neptune und zu ihren Zuordnungen zu SQL-Quelldatentypen finden Sie unter Datentypkonvertierungen in der W3C-Spezifikation R2RML: RDB to RDF Mapping Language.

Einschränkungen bei der Verwendung von Amazon Neptune als Ziel

Bei der Verwendung von Neptune als Ziel gelten die folgenden Einschränkungen: