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. # Laden von Daten in Amazon Neptune Es gibt verschiedene Möglichkeiten, Diagrammdaten in Amazon Neptune zu laden: + Wenn Sie nur eine relativ kleine Datenmenge laden müssen, können Sie Abfragen wie `INSERT` SPARQL-Anweisungen oder Gremlin `mergeV` and `mergeE` Steps verwenden. OpenCypher enthält auch UND-Klauseln. `CREATE` `MERGE` + Sie können [Neptune-Massen-Loader](bulk-load.md) dazu nutzen, große Datenmengen aus externen Dateien zu laden. Der Bulk-Loader-Befehl ist schneller und hat weniger Overhead als die Abfragesprache-Befehle. Er ist für große Datensätze optimiert und unterstützt sowohl Resource Description Framework (RDF)-Daten als auch Gremlin-Daten. + [Sie können AWS Database Migration Service (AWS DMS) verwenden, um Daten aus anderen Datenspeichern zu importieren (siehe, und Benutzerhandbuch). [Wird verwendet AWS Database Migration Service , um Daten aus einem anderen Datenspeicher in Amazon Neptune zu laden](dms-neptune.md)AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/) + Für kleinere Datensätze in einer oder mehreren Amazon S3-Dateien können Sie abfragebasierte Ladefunktionen verwenden, um Daten direkt in Ihren Abfragen zu lesen und zu verarbeiten. Weitere Details finden Sie unter [Daten mithilfe von Abfragen in Amazon Neptune laden](load-data-via-query.md). **Topics** + [Verwenden des Amazon Neptune Bulk Loaders zur Datenaufnahme](bulk-load.md) + [Wird verwendet AWS Database Migration Service , um Daten aus einem anderen Datenspeicher in Amazon Neptune zu laden](dms-neptune.md) + [Daten mithilfe von Abfragen in Amazon Neptune laden](load-data-via-query.md) # Verwenden des Amazon Neptune Bulk Loaders zur Datenaufnahme Amazone Neptune stellt den Befehl `Loader` bereit, um Daten aus externen Dateien direkt in einen Neptune-DB-Cluster zu laden. Sie können diesen Befehl verwenden, statt eine große Anzahl von `INSERT`-Anweisungen, `addV`- und `addE`-Schritten oder anderen API-Aufrufen auszuführen. Der Neptune-Befehl **Loader** ist schneller, hat einen geringeren Overhead, ist für große Datensätze optimiert und unterstützt sowohl Gremlin-Daten als auch Resource-Description-Framework (RDF)-Daten, die von SPARQL verwendet werden. Die folgende Abbildung zeigt eine Übersicht über den Ladevorgang: ![\[Diagramm mit den grundlegenden Schritten zum Laden von Daten in Neptune\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/load-diagram.png) Im Folgenden sind die Schritte des Ladevorgangs aufgeführt: 1. Kopieren Sie die Datendateien in einen Amazon-Simple-Storage-Service-Bucket (Amazon-S3-Bucket). 1. Erstellen Sie eine IAM-Rolle mit Lese- und Auflistungszugriff auf den Bucket. 1. Erstellen Sie einen Amazon-S3-VPC-Endpunkt. 1. Starten Sie den Neptune-Loader, indem Sie eine HTTP-Anforderung an die Neptune-DB-Instance senden. 1. Die Neptune-DB-Instance nimmt die IAM-Rolle an, um die Daten aus dem Bucket zu laden. **Anmerkung** Sie können verschlüsselte Daten aus Amazon S3 laden, wenn sie mit dem Amazon-S3-Modus `SSE-S3` oder `SSE-KMS` verschlüsselt wurden, vorausgesetzt, dass die für das Massenladen verwendete Rolle Zugriff auf das Amazon-S3-Objekt hat (im Fall von SSE-KMS auch Zugriff auf `kms:decrypt`). Neptune kann dann Ihre Anmeldeinformationen vortäuschen und `s3:getObject`-Aufrufe in Ihrem Namen ausgeben. Allerdings unterstützt Neptune zurzeit nicht das Laden von Daten, die mit dem Modus `SSE-C` verschlüsselt wurden. Die folgenden Abschnitte stellen Anweisungen für die Vorbereitung von Daten und das Laden von Daten in Neptune bereit. **Topics** + [Voraussetzungen: IAM-Rolle und Amazon-S3-Zugriff](bulk-load-tutorial-IAM.md) + [Ladedatenformate](bulk-load-tutorial-format.md) + [Beispiel: Laden von Daten in eine Neptune-DB-Instance](bulk-load-data.md) + [Optimieren einer Amazon-Neptune-Massenladung](bulk-load-optimize.md) + [Neptune-Loader-Referenz](load-api-reference.md) # Voraussetzungen: IAM-Rolle und Amazon-S3-Zugriff Das Laden von Daten aus einem Amazon Simple Storage Service (Amazon S3) -Bucket erfordert eine AWS Identity and Access Management (IAM) -Rolle, die Zugriff auf den Bucket hat. Amazon Neptune nimmt diese Rolle an, um die Daten zu laden. **Anmerkung** Sie können verschlüsselte Daten aus Amazon S3 laden, wenn sie mit dem Amazon-S3-Modus `SSE-S3` verschlüsselt wurden. In diesem Fall kann Neptune Ihre Anmeldeinformationen vortäuschen und `s3:getObject`-Aufrufe in Ihrem Namen ausgeben. Sie können auch verschlüsselte Daten aus Amazon S3 laden, die mit dem Modus `SSE-KMS` verschlüsselt wurden, wenn Ihre IAM-Rolle die notwendigen Berechtigungen für den Zugriff auf AWS KMS besitzt. Ohne die entsprechenden AWS KMS Berechtigungen schlägt der Massenladevorgang fehl und es wird eine `LOAD_FAILED` Antwort zurückgegeben. Neptune unterstützt zurzeit nicht das Laden von Amazon-S3-Daten, die mit dem Modus `SSE-C` verschlüsselt wurden. Die folgenden Abschnitte zeigen, wie Sie mit einer verwalteten IAM-Richtlinie eine IAM-Rolle für den Zugriff auf Amazon-S3-Ressourcen erstellen und die Rolle anschließend Ihrem Neptune-Cluster hinzufügen. **Topics** + [Erstellen einer IAM-Rolle, um Amazon Neptune den Zugriff auf Amazon-S3-Ressourcen zu erlauben](bulk-load-tutorial-IAM-CreateRole.md) + [Hinzufügen der IAM-Rolle zu einem Amazon-Neptune-Cluster](bulk-load-tutorial-IAM-add-role-cluster.md) + [Erstellen des Amazon-S3-VPC-Endpunkts](bulk-load-tutorial-vpc.md) + [Verketten von IAM-Rollen in Amazon Neptune](bulk-load-tutorial-chain-roles.md) **Anmerkung** Diese Anleitung erfordert den Zugriff auf die IAM-Konsole und Berechtigungen für die Verwaltung von IAM-Rollen und -Richtlinien. Weitere Informationen finden Sie unter [Berechtigungen für das Arbeiten in der AWS Management Console](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html#Credentials-Permissions-overview-console) im *IAM-Benutzerhandbuch*. Die Amazon-Neptune-Konsole erfordert die folgenden IAM-Berechtigungen, um die Rolle dem Neptune-Cluster anfügen zu können: ``` iam:GetAccountSummary on resource: * iam:ListAccountAliases on resource: * iam:PassRole on resource: * with iam:PassedToService restricted to rds.amazonaws.com ``` # Erstellen einer IAM-Rolle, um Amazon Neptune den Zugriff auf Amazon-S3-Ressourcen zu erlauben Sie können mit der verwalteten IAM-Richtlinie `AmazonS3ReadOnlyAccess` eine neue IAM-Rolle erstellen, die Amazon Neptune den Zugriff auf Amazon-S3-Ressourcen ermöglicht. **Erstellen einer neuen IAM-Rolle, die Neptune den Zugriff auf Amazon S3 ermöglicht** 1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole. 1. Wählen Sie im Navigationsbereich **Rollen** aus. 1. Wählen Sie **Create role** (Rolle erstellen) aus. 1. Wählen Sie in **AWS -Service** die Option **S3** aus. 1. Wählen Sie **Weiter: Berechtigungen** aus. 1. Verwenden Sie das Filterfeld, um nach dem Begriff **S3** zu filtern, und aktivieren Sie das Kästchen neben **ReadOnlyAccessAmazonS3**. **Anmerkung** Diese Richtlinie erteilt `s3:Get*`- und `s3:List*`-Berechtigungen für alle Buckets. Mit später ausgeführten Schritten wird der Zugriff auf die Rolle mithilfe der Vertrauensrichtlinie beschränkt. Der Loader benötigt lediglich `s3:Get*`- und `s3:List*`-Berechtigungen für den Bucket, aus dem Sie Daten laden. Daher können Sie diese Berechtigungen auch nach Amazon-S3-Ressource einschränken. Wenn Ihr S3-Bucket verschlüsselt ist, müssen Sie `kms:Decrypt`-Berechtigungen hinzufügen. 1. Wählen Sie **Weiter: Prüfen** aus. 1. Legen Sie in **Rollenname** einen Namen für Ihre IAM-Rolle fest, zum Beispiel: `NeptuneLoadFromS3`. Sie können auch einen optionalen Wert für **Rollenbeschreibung** hinzufügen, z. B. „Ermöglicht Neptune den Zugriff auf Amazon-S3-Ressourcen in Ihrem Namen“. 1. Wählen Sie **Rolle erstellen** aus. 1. Wählen Sie im Navigationsbereich **Rollen** aus. 1. Geben Sie im Feld **Search (Suchen)** den Namen der von Ihnen erstellten Rolle ein und wählen Sie die Rolle aus, wenn sie in der Liste erscheint. 1. Klicken Sie auf der Registerkarte **Trust Relationships (Vertrauensstellungen)** auf **Edit Trust Relationship (Vertrauensstellung bearbeiten)**. 1. Fügen Sie die folgende Vertrauensrichtlinie in das Textfeld ein. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": [ "rds.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Wählen Sie **Update trust policy (Vertrauensrichtlinie aktualisieren)** aus. 1. Führen Sie die Schritte unter [Hinzufügen der IAM-Rolle zu einem Amazon-Neptune-Cluster](bulk-load-tutorial-IAM-add-role-cluster.md) aus. # Hinzufügen der IAM-Rolle zu einem Amazon-Neptune-Cluster Verwenden Sie die Konsole, um die IAM-Rolle zu einem Amazon-Neptune-Cluster hinzuzufügen. So können alle Neptune-DB-Instances im Cluster die Rolle annehmen und Daten aus Amazon S3 laden. **Anmerkung** Die Amazon-Neptune-Konsole erfordert die folgenden IAM-Berechtigungen, um die Rolle dem Neptune-Cluster anfügen zu können: ``` iam:GetAccountSummary on resource: * iam:ListAccountAliases on resource: * iam:PassRole on resource: * with iam:PassedToService restricted to rds.amazonaws.com ``` **Hinzufügen einer IAM-Rolle zu einem Amazon-Neptune-Cluster** 1. [Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon Neptune Neptune-Konsole zu Hausehttps://console.aws.amazon.com/neptune/.](https://console.aws.amazon.com/neptune/home) 1. Wählen Sie im Navigationsbereich **Datenbanken** aus. 1. Wählen Sie die Cluster-ID für den Cluster, den Sie ändern möchten. 1. Wählen Sie die Registerkarte **Konnektivität und Sicherheit**. 1. Wählen Sie im Abschnitt IAM-Rollen die Rolle aus, die Sie im vorherigen Abschnitt erstellt haben. 1. Wählen Sie **Rolle hinzufügen** aus. 1. Warten Sie, bis die IAM-Rolle für den Cluster zugänglich ist, bevor Sie sie verwenden. # Erstellen des Amazon-S3-VPC-Endpunkts Der Neptune-Loader erfordert einen VPC-Endpunkt des Typs Gateway für Amazon S3. **So richten Sie den Zugriff für Amazon S3 ein** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. Wählen Sie im Navigationsbereich **Endpunkte** aus. 1. Klicken Sie auf **Endpunkt erstellen**. 1. Wählen Sie den **Servicenamen** `com.amazonaws.region.s3` für den Endpunkt vom Typ Gateway aus. **Anmerkung** Wenn die Region hier nicht korrekt ist, stellen Sie sicher, dass die Konsolenregion richtig ist. 1. Wählen Sie die VPC aus, die Ihre Neptune-DB-Instance enthält (sie wird in der Neptune-Konsole für Ihre DB-Instance aufgelistet). 1. Aktivieren Sie das Kontrollkästchen neben den Routing-Tabellen, die den Subnetzen Ihres Clusters zugeordnet sind. Wenn Sie nur eine Routing-Tabelle vorliegen haben, müssen Sie das entsprechende Kontrollkästchen aktivieren. 1. Klicken Sie auf **Endpunkt erstellen**. Informationen zum Erstellen von Endpunkten finden Sie unter [VPC-Endpunkte](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html#create-vpc-endpoint) im *Amazon-VPC-Benutzerhandbuch*. Informationen zu den Einschränkungen für VPC-Endpunkte finden Sie unter [VPC-Endpunkte für Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html). **Nächste Schritte** Nachdem Sie nun Zugriff auf den Amazon-S3-Bucket gewährt haben, können Sie das Laden von Daten vorbereiten. Informationen zu unterstützten Formaten finden Sie unter [Ladedatenformate](bulk-load-tutorial-format.md) # Verketten von IAM-Rollen in Amazon Neptune **Wichtig** Das in [Engine-Version 1.2.1.0.R3](engine-releases-1.2.1.0.R3.md) eingeführte neue kontoübergreifende Massenlade-Feature, das die Vorteile der IAM-Rollen-Verkettung nutzt, kann in einigen Fällen zu einer Verschlechterung der Massenlade-Leistung führen. Daher wurden Upgrades auf Engine-Versionen, die dieses Feature unterstützen, vorübergehend ausgesetzt, bis dieses Problem behoben ist. Wenn Sie Ihrem Cluster eine Rolle anfügen, kann Ihr Cluster diese Rolle annehmen, um auf in Amazon S3 gespeicherte Daten zuzugreifen. Wenn diese Rolle nicht auf alle benötigten Ressourcen zugreifen kann, können Sie ab [Engine-Version 1.2.1.0.R3](engine-releases-1.2.1.0.R3.md) eine oder mehrere zusätzliche Rollen verketten, die Ihr Cluster annehmen kann, um Zugriff auf andere Ressourcen zu erhalten. Jede Rolle in der Kette nimmt die nächste Rolle in der Kette an, bis Ihr Cluster die Rolle am Ende der Kette angenommen hat. Zum Verketten von Rollen richten Sie eine Vertrauensstellung zwischen den Rollen ein. Um beispielsweise `RoleB` mit `RoleA` zu verketten, muss `RoleA` eine Berechtigungsrichtlinie für die Annahme von `RoleB` besitzen. `RoleB` muss eine Vertrauensrichtlinie besitzen, die die Übergabe der Berechtigungen zurück an `RoleA` ermöglicht. Weitere Informationen finden Sie unter [Verwenden von IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html). Die erste Rolle in einer Kette muss eine dem Cluster angefügte Rolle sein, die Daten lädt. Die erste und jede folgende Rolle, die die folgende Rolle in der Kette annimmt, muss Folgendes besitzen: + Eine Richtlinie, die eine spezifische Aussage zum `Allow`-Effekt auf die Aktion `sts:AssumeRole` enthält. + Der Amazon-Ressourcenname (ARN) der nächsten Rolle in einem `Resource`-Element **Anmerkung** Der Amazon S3 S3-Ziel-Bucket muss sich in derselben AWS Region wie der Cluster befinden. ## Kontoübergreifender Zugriff mithilfe von Rollen Sie können einen kontoübergreifenden Zugriff gewähren, indem Sie eine oder mehrere Rollen verketten, die zu einem anderen Konto gehören. Wenn Ihr Cluster vorübergehend eine Rolle annimmt, die zu einem anderen Konto gehört, kann er Zugriff auf die Ressourcen in diesem Konto erhalten. Angenommen, **Konto A** möchte auf Daten in einem Amazon-S3-Bucket zugreifen, der zu **Konto B** gehört: + **Konto A** erstellt eine benannte AWS Servicerolle für Neptune `RoleA` und ordnet sie einem Cluster zu. + **Konto B** erstellt eine Rolle mit dem Namen `RoleB`, die zum Zugriff auf die Daten in einem Bucket in **Konto B** berechtigt ist. + **Konto A** fügt eine Berechtigungsrichtlinie an `RoleA` an, um `RoleB` anzunehmen. + **Konto B** fügt eine Vertrauensrichtlinie an `RoleB` an, um die Rückgabe der Berechtigungen an `RoleA` zu ermöglichen. + Um auf die Daten im Bucket von **Konto B** zuzugreifen, führt **Konto A** einen Loader-Befehl mit dem Parameter `iamRoleArn` aus, der `RoleA` und `RoleB` verkettet. Für die Dauer der Loader-Operation nimmt `RoleA` vorübergehend `RoleB` an, um auf den Amazon-S3-Bucket in **Konto B** zuzugreifen. ![\[Diagramm, das den kontoübergreifenden Zugriff mithilfe verketteter Rollen zeigt\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/cross-account-bulk-load.png) Beispielsweise würde `RoleA` eine Vertrauensrichtlinie besitzen, die eine Vertrauensstellung mit Neptune einrichtet: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "rds.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ `RoleA` würde auch eine Berechtigungsrichtlinie besitzen, die die Annahme von `RoleB` im Besitz von **Konto B** ermöglicht: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "Stmt1487639602000", "Effect": "Allow", "Action": [ "sts:AssumeRole" ], "Resource": "arn:aws:iam::111122223333:role/RoleB" } ] } ``` ------ Umgekehrt würde `RoleB` eine Vertrauensrichtlinie für die Einrichtung einer Vertrauensstellung mit `RoleA` besitzen: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "sts:AssumeRole", "Principal": { "AWS": "arn:aws:iam::111122223333:role/RoleA" } } ] } ``` ------ `RoleB` würde auch eine Berechtigung für den Zugriff auf Daten in dem Amazon-S3-Bucket benötigen, der sich in **Konto B** befindet. ## Einen AWS -Security-Token-Service (STS-) VPC-Endpunkt erstellen Der Neptune-Loader benötigt einen AWS STS VPC-Endpunkt für die Verkettung von IAM-Rollen für den privaten Zugriff über AWS STS APIs private IP-Adressen. Sie können auf sichere und skalierbare Weise eine direkte Verbindung von einer Amazon-VPC zu AWS STS einem VPC-Endpunkt herstellen. Wenn Sie einen Schnittstellen-VPC-Endpunkt verwenden, wird die Sicherheitslage verbessert, da Sie keine Firewalls für den ausgehenden Datenverkehr öffnen müssen. Sie erhalten außerdem die übrigen Vorteile der Verwendung von Amazon-VPC-Endpunkten. Bei Verwendung eines VPC-Endpunkts wird der Datenverkehr AWS STS nicht über das Internet übertragen und verlässt niemals das Amazon-Netzwerk. Ihre VPC ist sicher verbunden, AWS STS ohne dass Verfügbarkeitsrisiken oder Bandbreitenbeschränkungen für Ihren Netzwerkverkehr auftreten. Weitere Informationen finden Sie unter [Verwenden von AWS STS -Schnittstellen-VPC-Endpunkten](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_sts_vpce.html). **Um den Zugriff für AWS -Security-Token-Service (STS) einzurichten** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. Wählen Sie im Navigationsbereich **Endpunkte** aus. 1. Klicken Sie auf **Endpunkt erstellen**. 1. Wählen Sie den **Servicenamen** aus: `com.amazonaws.region.sts` für den Endpunkt vom Typ Schnittstelle. 1. Wählen Sie die **VPC** aus, die Ihre Neptune-DB-Instance und EC2-Instance enthält. 1. Aktivieren Sie das Kontrollkästchen neben dem Subnetz, in dem sich Ihre EC2-Instance befindet. Sie können nicht mehrere Subnetze aus derselben Availability Zone auswählen. 1. Wählen Sie für IP address type (IP-Adressentyp) eine der folgenden Optionen aus: + **IPv4**— Weisen Sie Ihren Endpunkt-Netzwerkschnittstellen IPv4 Adressen zu. Diese Option wird nur unterstützt, wenn alle ausgewählten Subnetze IPv4 Adressbereiche haben. + **IPv6**— Weisen Sie Ihren Endpunkt-Netzwerkschnittstellen IPv6 Adressen zu. Diese Option wird nur unterstützt, wenn es sich bei allen ausgewählten Subnetzen um reine IPv6 Subnetze handelt. + **Dualstack — Weisen Sie Ihren** Endpunkt-Netzwerkschnittstellen IPv4 sowohl IPv6 Adressen als auch Adressen zu. Diese Option wird nur unterstützt, wenn alle ausgewählten Subnetze IPv4 sowohl IPv6 als auch Adressbereiche haben. 1. Wählen Sie für **Sicherheitsgruppen** die Sicherheitsgruppen aus, die den Endpunkt-Netzwerkschnittstellen für den VPC-Endpunkt zugeordnet werden sollen. Sie müssten alle Sicherheitsgruppen auswählen, die Ihrer Neptune-DB-Instance und EC2-Instance angefügt sind. 1. Wählen Sie für **Policy** (Richtlinie) **Full access** (Vollzugriff), um alle Operationen aller Prinzipale auf allen Ressourcen über den VPC-Endpunkt zuzulassen. Wählen Sie andernfalls **Custom** (Benutzerdefiniert), um eine VPC-Endpunktrichtlinie anzufügen, die die Berechtigungen steuert, die Prinzipale zum Ausführen von Aktionen für Ressourcen über den VPC-Endpunkt haben. Diese Option ist nur verfügbar, wenn der Service VPC-Endpunktrichtlinien unterstützt. Weitere Informationen finden Sie unter [Endpunktrichtlinien](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html). 1. (*Optional*) Sie fügen ein Tag hinzu, indem Sie **Neuen Tag hinzufügen** auswählen und Schlüssel und Wert für das Tag eingeben. 1. Wählen Sie **Endpunkt erstellen** aus. Informationen zum Erstellen von Endpunkten finden Sie unter [VPC-Endpunkte](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) im Amazon-VPC-Benutzerhandbuch. Bitte beachten Sie, dass Amazon-STS-VPC-Endpunkte eine Voraussetzung für die Verkettung von IAM-Rollen sind. Nachdem Sie nun Zugriff auf den AWS STS Endpunkt gewährt haben, können Sie sich darauf vorbereiten, Daten zu laden. Weitere Informationen zu unterstützten Formaten finden Sie unter [Ladedatenformate](bulk-load-tutorial-format.md). ## Verkettung von Rollen innerhalb eines Loader-Befehls Sie können die Rollenverkettung angeben, wenn Sie einen Loader-Befehl ausführen, indem Sie eine durch Kommas getrennte Rollenliste ARNs in den Parameter aufnehmen. `iamRoleArn` Obwohl Sie in der Regel nur zwei Rollen in einer Kette benötigen, ist es durchaus möglich, drei oder mehr Rollen zu verketten. Dieser Loader-Befehl verkettet beispielsweise drei Rollen: ``` curl -X POST https://localhost:8182/loader \ -H 'Content-Type: application/json' \ -d '{ "source" : "s3://(the target bucket name)/(the target date file name)", "iamRoleArn" : "arn:aws:iam::(Account A ID):role/(RoleA),arn:aws:iam::(Account B ID):role/(RoleB),arn:aws:iam::(Account C ID):role/(RoleC)", "format" : "csv", "region" : "us-east-1" }' ``` # Ladedatenformate Die Amazon Neptune–`Load`API unterstützt das Laden von Daten in verschiedenen Formaten. **Eigenschaftsdiagramm-Ladeformate** Daten, die in einem der folgenden Eigenschaftsdiagrammformate geladen wurden, können anschließend mit Gremlin und openCypher abgefragt werden: + [Gremlin-Ladedatenformat](bulk-load-tutorial-format-gremlin.md) (`csv`): CSV-Format (durch Komma getrennte Werte). + [openCypher-Datenladeformat](bulk-load-tutorial-format-opencypher.md) (`opencypher`): CSV-Format (durch Komma getrennte Werte). **RDF-Ladeformate** Zum Laden von Resource-Description-Framework (RDF)-Daten, die Sie mit SPARQL abfragen, können Sie eines der folgenden Standardformate (wie vom World Wide Web Consortium (W3C) definiert) verwenden: + N-Triples (`ntriples`) aus der Spezifikation unter [https://www.w3.org/TR/n-triples/](https://www.w3.org/TR/n-triples/). + N-Quads (`nquads`) aus der Spezifikation unter [https://www.w3.org/TR/n-quads/](https://www.w3.org/TR/n-quads/). + RDF/XML (`rdfxml`) aus der Spezifikation unter [https://www.w3.org/TR/rdf-syntax-grammar/](https://www.w3.org/TR/rdf-syntax-grammar/). + Turtle (`turtle`) aus der Spezifikation unter [https://www.w3.org/TR/turtle/](https://www.w3.org/TR/turtle/). **Ladedaten müssen UTF-8-Kodierung verwenden** **Wichtig** Alle Ladedaten müssen im UTF-8-Format kodiert sein. Wenn eine Datei nicht im UTF-8-Format kodiert ist, versucht Neptune trotzdem, sie als UTF-8-Datei zu laden. Für N-Quads- und N-Triples-Daten mit Unicode-Zeichen werden `\uxxxxx`-Escape-Sequenzen unterstützt. Neptune unterstützt jedoch keine Normalisierung. Wenn ein Wert vorhanden ist, der normalisiert werden muss, stimmt er bei der Abfrage nicht überein. byte-to-byte Weitere Informationen über die Normalisierung finden Sie auf der Seite [Normalization](https://unicode.org/faq/normalization.html) unter [Unicode.org](https://unicode.org). Wenn Ihre Daten kein unterstütztes Format aufweisen, müssen Sie diese vor dem Laden konvertieren. Ein Tool zur Konvertierung von GraphML in das Neptune CSV-Format ist im [Graph ML2 CSV-Projekt](https://github.com/awslabs/amazon-neptune-tools/blob/master/graphml2csv/README.md) unter verfügbar. [GitHub](https://github.com/) ## Komprimierungsunterstützung für Ladedatendateien Neptune unterstützt die Komprimierung einzelner Dateien in den Formaten `gzip` oder `bzip2`. Die komprimierte Datei muss die Erweiterungen `.gz` oder `.bz2` aufweisen und es muss sich um eine einzelne Textdatei im UTF-8-Format handeln. Es können mehrere Dateien geladen werden. Bei jeder Datei muss es sich jedoch um eine getrennte `.gz`-, `.bz2`- oder unkomprimierte Textdatei handeln. Archivdateien mit Erweiterungen wie `.tar`, `.tar.gz` und `.tgz` werden nicht unterstützt. In den folgenden Abschnitten werden die Formate ausführlich beschrieben. **Topics** + [Komprimierungsunterstützung für Ladedatendateien](#bulk-load-tutorial-format-compression) + [Gremlin-Ladedatenformat](bulk-load-tutorial-format-gremlin.md) + [Ladeformat für openCypher-Daten](bulk-load-tutorial-format-opencypher.md) + [RDF-Formate zum Laden von Daten](bulk-load-tutorial-format-rdf.md) # Gremlin-Ladedatenformat Um Apache TinkerPop Gremlin-Daten im CSV-Format zu laden, müssen Sie die Scheitelpunkte und Kanten in separaten Dateien angeben. Der Loader kann in einem einzigen Ladeauftrag aus mehreren Vertex-Dateien und mehreren Edge-Dateien laden. Für jeden Ladebefehl muss sich der Satz der Dateien, die geladen werden sollen, im selben Ordner im Amazon-S3-Bucket befinden. Sie geben den Ordnernamen für den Parameter `source` an. Die Dateinamen und -erweiterungen sind nicht wichtig. Das Amazon-Neptune-CSV-Format entspricht der CSV-Spezifikation RFC 4180. Weitere Informationen finden Sie unter [Common Format and MIME Type for CSV Files](https://tools.ietf.org/html/rfc4180) auf der Internet Engineering Task Force (IETF)-Website. **Anmerkung** Alle Dateien müssen im UTF-8-Format kodiert sein. Jede Datei verfügt über eine durch Komma getrennte Kopfzeile. Die Kopfzeile besteht aus System- und Eigenschaftenspalten-Headern. ## Systemspalten-Header Die erforderlichen und zulässigen Systemspalten-Header sind für Knoten- und Kantendateien unterschiedlich. Jede Systemspalte kann nur einmal in einem Header enthalten sein. Bei den Bezeichnungen muss die Groß- und Kleinschreibung beachtet werden. **Knoten-Header** + `~id` – **Erforderlich** Eine ID für den Knoten. + `~label` Eine Bezeichnung für den Knoten. Es sind mehrere Bezeichnungswerte zulässig, getrennt durch Semikolon (`;`). Falls nicht vorhanden, `~label` wird eine TinkerPop Bezeichnung mit dem Wert bereitgestellt`vertex`, da jeder Scheitelpunkt mindestens eine Bezeichnung haben muss. **Kanten-Header** + `~id` – **Erforderlich** Eine ID für die Kante. + `~from` – **Erforderlich** Die Knoten-ID des *von*-Knotens. + `~to` – **Erforderlich** Die Knoten-ID des *nach*-Knotens. + `~label` Eine Bezeichnung für die Kante. Kanten können immer nur eine Bezeichnung enthalten. Wenn nicht vorhanden, `~label` wird TinkerPop eine Bezeichnung mit dem Wert bereitgestellt`edge`, da jede Kante eine Bezeichnung haben muss. ## Eigenschaftenspalten-Header Sie können eine Spalte (`:`) für eine Eigenschaft angeben, indem Sie die folgende Syntax verwenden. Bei den Typnamen muss die Groß- und Kleinschreibung nicht berücksichtigt werden. Ein Doppelpunkt muss mit einem vorangestellten umgekehrten Schrägstrich maskiert werden, wenn er im Namen einer Eigenschaft erscheint: `\:`. ``` propertyname:type ``` **Anmerkung** Leerzeichen, Kommas, Zeilenumbrüche und Zeilenumbrüche sind in den Spaltenüberschriften nicht zulässig, sodass Eigenschaftsnamen diese Zeichen nicht enthalten dürfen. Sie können eine Spalte für einen Array-Typ festlegen, indem Sie dem Typ `[]` hinzufügen: ``` propertyname:type[] ``` **Anmerkung** Edge-Eigenschaften können nur einen einzelnen Wert haben und verursachen einen Fehler, wenn ein Array-Typ oder ein zweiter Wert angegeben ist. Das folgende Beispiel zeigt den Spalten-Header für eine Eigenschaft mit dem Namen `age` des Typs `Int`. ``` age:Int ``` Für jede Zeile in der Datei ist eine Ganzzahl in dieser Position erforderlich oder sie muss leer sein. Zeichenfolgen-Arrays sind zulässig. Zeichenfolgen in einem Array dürfen jedoch kein Semikolon (`;`) enthalten, es sei denn, es wird mit einem umgekehrten Schrägstrich maskiert (wie hier: `\;`). **Angeben der Kardinalität einer Spalte** Die Spaltenüberschrift kann verwendet werden, um die *Kardinalität* für die durch die Spalte identifizierte Eigenschaft anzugeben. Auf diese Weise kann der Massen-Loader die Kardinalität ähnlich wie Gremlin-Abfragen berücksichtigen. Sie geben die Kardinalität einer Spalte wie folgt an: ``` propertyname:type(cardinality) ``` Der *cardinality* Wert kann entweder oder sein. `single` `set` Als Standardwert wird `set` angenommen, Dies bedeutet, dass die Spalte mehrere Werte akzeptieren kann. Bei Edge-Dateien ist die Kardinalität immer einzeln und die Angabe einer anderen Kardinalität bewirkt, dass der Loader eine Ausnahme auslöst. Wenn die Kardinalität `single` lautet, gibt der Loader einen Fehler aus, wenn beim Laden eines Wertes bereits ein vorheriger Wert vorhanden ist oder wenn mehrere Werte geladen werden. Dieses Verhalten kann überschrieben werden, sodass ein vorhandener Wert ersetzt wird, wenn ein neuer Wert unter Verwendung des Flags `updateSingleCardinalityProperties` geladen wird. Siehe [Loader-Befehl](load-api-reference-load.md). Es ist möglich, die Kardinalitätseinstellung mit einem Array-Typ zu vewenden, obwohl dies im Allgemeinen nicht erforderlich ist. Dies sind die möglichen Kombinationen: + `name:type`   –   Die Kardinalität ist `set` und der Inhalt ist einwertig. + `name:type[]`   –   Die Kardinalität ist `set` und der Inhalt ist mehrwertig. + `name:type(single)`   –   Die Kardinalität ist `single` und der Inhalt ist einwertig. + `name:type(set)`   –   Die Kardinalität ist `set`, was dem Standardwert entspricht, und der Inhalt ist einwertig. + `name:type(set)[]`   –   Die Kardinalität ist `set` und der Inhalt ist mehrwertig. + `name:type(single)[]`   –   Dies ist widersprüchlich und führt zu einem Fehler. Im folgenden Abschnitt werden alle verfügbaren Gremlin-Datentypen aufgeführt. ## Gremlin-Datentypen Dies ist eine Liste der zulässigen Eigenschaftstypen mit einer Beschreibung des jeweiligen Typs. **Bool (oder Boolesch)** Gibt ein boolesches Feld an. Zulässige Werte: `false`, `true` **Anmerkung** Jeder andere Wert als `true` wird als „false“ behandelt. **Ganzzahltypen** Werte außerhalb der definierten Bereiche verursachen einen Fehler. | | | Typ | Bereich | | --- |--- | | Byte | -128 bis \$1127 | | Short | -32768 bis \$132767 | | Int | -2^31 bis 2^31-1 | | Long | -2^63 bis 2^63-1 | **Dezimalzahltypen** Unterstützt sowohl die Dezimalschreibweise als auch die wissenschaftliche Notation. Außerdem können Symbole wie (\$1/-), Infinity oder NaN verwendet werden. INF wird nicht unterstützt. | | | Typ | Bereich | | --- |--- | | Gleitkommazahl | 32-Bit IEEE 754-Gleitkommawert | | Double | 64-Bit IEEE 754-Gleitkommawert | Zu lange Gleitkommazahlen und Double-Werte werden geladen und auf den nächsten Wert für 24-Bit- (Gleitkommazahl) und 53-Bit-Genauigkeit (Double) gerundet. Ein in der Mitte liegender Wert wird für die letzte verbleibende Stelle auf Bit-Ebene auf 0 gerundet. **Zeichenfolge** Anführungszeichen sind optional. Kommas, Zeilenumbruch- und Wagenrücklaufzeichen werden automatisch mit Escape-Zeichen markiert, wenn sie in einer Zeichenfolge enthalten sind, die von doppelten Anführungszeichen (`"`) umschlossen ist. *Beispiel*: `"Hello, World"` Um Anführungszeichen in einer in Anführungszeichen gesetzte Zeichenfolge aufzunehmen, können Sie das Anführungszeichen mit Escape-Zeichen markieren, indem Sie zwei in einer Zeile verwenden: *Beispiel:* `"Hello ""World"""` Zeichenfolgen-Arrays sind zulässig. Zeichenfolgen in einem Array dürfen jedoch kein Semikolon (`;`) enthalten, es sei denn, es wird mit einem umgekehrten Schrägstrich maskiert (wie hier: `\;`). Wenn Sie Zeichenfolgen in einem Array in Anführungszeichen setzen möchten, müssen Sie das gesamte Array mit einem Satz Anführungszeichen versehen. *Beispiel*: `"String one; String 2; String 3"` **Date** Java-Datum im ISO 8601-Format. Unterstützt die folgenden Formate:`yyyy-MM-dd`,`yyyy-MM-ddTHH:mm`,`yyyy-MM-ddTHH:mm:ss`,`yyyy-MM-ddTHH:mm:ssZ`. Die Werte werden in Epochenzeit umgewandelt und gespeichert. **DateTime** Java-Datum im ISO 8601-Format. Unterstützt die folgenden Formate:`yyyy-MM-dd`,, `yyyy-MM-ddTHH:mm``yyyy-MM-ddTHH:mm:ss`,`yyyy-MM-ddTHH:mm:ssZ`. Die Werte werden in Epochenzeit umgewandelt und gespeichert. ## Gremlin-Zeilenformat **Trennzeichen** Felder in einer Zeile werden durch ein Komma getrennt. Die Datensätze werden durch einen Zeilenumbruch oder einen Zeilenumbruch gefolgt von einem Wagenrücklauf getrennt. **Leere Felder** Leere Felder sind für nicht erforderliche Spalten zulässig (z. B. benutzerdefinierte Eigenschaften). Ein leeres Feld erfordert dennoch ein Komma als Trennzeichen. Leere Felder in erforderlichen Spalten führen zu einem Analysefehler. Leere Zeichenkettenwerte werden als leerer Zeichenkettenwert für das Feld interpretiert, nicht als leeres Feld. Das Beispiel im nächsten Abschnitt enthält in jedem Beispielknoten ein leeres Feld. **Scheitelpunkt IDs** `~id`-Werte müssen für alle Knoten in allen Knotendateien eindeutig sein. Mehrere Knotenzeilen mit identischen `~id`-Werten werden auf einen einzigen Knoten im Graph angewendet. Eine leere Zeichenfolge (`""`) ist eine gültige ID, und der Scheitelpunkt wird mit einer leeren Zeichenfolge als ID erstellt. **Kante IDs** Darüber hinaus müssen `~id`-Werte für alle Kanten in allen Kantendateien eindeutig sein. Mehrere Kantenzeilen mit identischen `~id`-Werten werden auf die einzige Kante im Graph angewendet. Eine leere Zeichenfolge (`""`) ist eine gültige ID, und die Kante wird mit einer leeren Zeichenfolge als ID erstellt. **Labels** Bei Labels wird zwischen Groß- und Kleinschreibung unterschieden und sie dürfen nicht leer sein. Ein Wert von `""` führt zu einem Fehler. **Zeichenfolgenwerte** Anführungszeichen sind optional. Kommas, Zeilenumbruch- und Wagenrücklaufzeichen werden automatisch mit Escape-Zeichen markiert, wenn sie in einer Zeichenfolge enthalten sind, die von doppelten Anführungszeichen (`"`) umschlossen ist. Leere Zeichenkettenwerte `("")` werden als leerer Zeichenkettenwert für das Feld interpretiert, nicht als leeres Feld. ## CSV-Formatspezifikation Das Neptune-CSV-Format entspricht der CSV-Spezifikation RFC 4180, einschließlich der folgenden Anforderungen. + Es werden sowohl Unix- als auch Windows-Zeilenenden unterstützt (\$1n oder \$1r\$1n). + Jedes Feld kann mit (doppelten) Anführungszeichen versehen werden. + Felder, die einen Zeilenumbruch, doppelte Anführungszeichen oder Kommas enthalten, müssen in Anführungszeichen gesetzt werden. (Andernfalls wird der Ladevorgang sofort abgebrochen.) + Eine doppeltes Anführungszeichen (`"`) in einem Feld muss durch zwei (doppelte) Anführungszeichen dargestellt werden. Beispiel: Eine Zeichenfolge `Hello "World"` muss als `"Hello ""World"""` in den Daten dargestellt werden. + Umgebende Leerzeichen zwischen Trennzeichen werden ignoriert. Wenn eine Zeile als vorhanden ist`value1, value2`, werden sie als `"value1"` und gespeichert`"value2"`. + Alle anderen Escapezeichen werden unverändert gespeichert. Zum Beispiel wird `"data1\tdata2"` als `"data1\tdata2"` gespeichert. Es sind keine weiteren Escapezeichen erforderlich, solange diese Zeichen in Anführungszeichen gesetzt sind. + Leere Felder sind zulässig. Ein leeres Feld wird als leerer Wert interpretiert. + Mehrere Werte für ein Feld werden mit einem Semikolon (`;`) zwischen den Werten angegeben. Weitere Informationen finden Sie unter [Common Format and MIME Type for CSV Files](https://tools.ietf.org/html/rfc4180) auf der Internet Engineering Task Force (IETF)-Website. ## Gremlin-Beispiel Das folgende Diagramm zeigt ein Beispiel für zwei Scheitelpunkte und eine Kante aus dem TinkerPop Modern Graph. ![\[Diagramm mit zwei Vertices und einem Edge enthält Markos Alter 29 und die LOP-Software (sprachorientierte Programmierungssoftware) mit der Sprache Java\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/tiny-modern-graph.png) Die folgende Abbildung zeigt das Diagramm im Neptune-CSV-Ladeformat. Knotendatei: ``` ~id,name:String,age:Int,lang:String,interests:String[],~label v1,"marko",29,,"sailing;graphs",person v2,"lop",,"java",,software ``` Tabellarische Ansicht der Knotendatei: | | | | | | | | --- |--- |--- |--- |--- |--- | | \$1id | name:String | age:Int | lang:String | Interessen: Zeichenfolge [] | \$1label | | v1 | "marko" | 29 | | ["Segeln“, „Graphen"] | Person | | v2 | "lop" | | "java" | | software | Kantendatei: ``` ~id,~from,~to,~label,weight:Double e1,v1,v2,created,0.4 ``` Tabellarische Ansicht der Kantendatei: | | | | | | | --- |--- |--- |--- |--- | | \$1id | \$1from | \$1auf | \$1label | weight:Double | | e1 | v1 | v2 | created | 0.4 | **Nächste Schritte** Da Sie jetzt über ausführlichere Kenntnisse von Ladeformaten verfügen, fahren Sie mit [Beispiel: Laden von Daten in eine Neptune-DB-Instance](bulk-load-data.md) fort. # Ladeformat für openCypher-Daten Um openCypher-Daten im openCypher-CSV-Format zu laden, müssen Sie Knoten und Beziehungen in getrennten Dateien angeben. Der Loader kann Daten aus mehreren Knoten- und Beziehungsdateien in einem einzigen Ladeauftrag laden. Für jeden Ladebefehl muss der Satz von Dateien, die geladen werden sollen, dasselbe Pfadpräfix in einem Amazon-Simple-Storage-Service-Bucket aufweisen. Sie geben dieses Präfix im Quellparameter an. Die tatsächlichen Dateinamen und Dateierweiterungen sind nicht wichtig. In Amazon Neptune entspricht das openCypher-CSV-Format der CSV-Spezifikation RFC 4180. Weitere Informationen finden Sie unter [Gemeinsames Format und MIME-Typ für CSV-Dateien](https://tools.ietf.org/html/rfc4180) (https://tools.ietf.org/html/rfc4180) auf der Website der Internet Engineering Task Force (IETF). **Anmerkung** Diese Dateien MÜSSEN im UTF-8-Format kodiert sein. Jede Datei hat eine durch Komma getrennte Überschriftenzeile, die Systemspaltenüberschriften und Eigenschaftsspaltenüberschriften enthält. ## Systemspaltenüberschriften in openCypher-Dateien zum Laden von Daten Jede Systemspalte kann nur einmal in einer Überschrift enthalten sein. Bei allen Systemspaltenüberschriften muss die Groß- und Kleinschreibung beachtet werden. openCypher-Knotenladedateien und Beziehungsladedateien unterscheiden sich hinsichtlich der erforderlichen und zulässigen Systemspaltenüberschriften: ### Systemspaltenüberschriften in Knotendateien + **`:ID`**   –   (Erforderlich) Eine ID für den Knoten. Der Knoten–`:ID`Spaltenüberschrift kann ein optionaler ID-Bereich wie folgt hinzugefügt werden: `:ID(ID Space)`. Ein Beispiel ist `:ID(movies)`. Verwenden Sie beim Laden von Beziehungen, die die Knoten in dieser Datei verbinden, dieselben ID-Leerzeichen in den Spalten der Beziehungsdateien. `:START_ID` and/or `:END_ID` Die Knoten-`:ID`-Spalte kann optional als Eigenschaft im Formular gespeichert werden, `property name:ID`. Ein Beispiel ist `name:ID`. Der Knoten IDs sollte in allen Knotendateien beim aktuellen und beim vorherigen Laden eindeutig sein. Wenn ein ID-Raum verwendet wird, IDs sollte der Knoten in allen Knotendateien, die denselben ID-Raum im aktuellen und vorherigen Ladevorgang verwenden, eindeutig sein. + **`:LABEL`**   –   Eine Bezeichnung für den Knoten. Wenn mehrere Labelwerte für einen einzelnen Knoten verwendet werden, sollte jedes Label durch Semikolons () getrennt werden. `;` ### Systemspaltenüberschriften in Beziehungsdateien + **`:ID`**   –   Eine ID für die Beziehung. Dies ist erforderlich, wenn `userProvidedEdgeIds` wahr ist (Standard), jedoch ungültig, wenn `userProvidedEdgeIds` `false` ist. IDs Die Beziehung sollte in allen Beziehungsdateien beim aktuellen und beim vorherigen Laden eindeutig sein. + **`:START_ID`**   –   (*Erforderlich*) Die Knoten-ID des Knotens, an dem diese Beziehung beginnt. Optional kann der Start-ID-Spalte ein ID-Bereich im Format `:START_ID(ID Space)` zugeordnet werden. Der ID-Bereich der Startknoten-ID sollte mit dem ID-Bereich übereinstimmen, der dem Knoten in dessen Knotendatei zugewiesen ist. + **`:END_ID`**   –   (*Erforderlich*) Die Knoten-ID des Knotens, an dem diese Beziehung endet. Optional kann der End-ID-Spalte ein ID-Bereich im Format `:END_ID(ID Space)` zugeordnet werden. Der ID-Bereich der Endknoten-ID sollte mit dem ID-Bereich übereinstimmen, der dem Knoten in dessen Knotendatei zugewiesen ist. + **`:TYPE`**   –   Ein Typ für die Beziehung. Beziehungen können nur einen einzigen Typ haben. **Anmerkung** [Laden von openCypher-Daten](load-api-reference-load.md#load-api-reference-load-parameters-opencypher)Informationen darüber, wie doppelte Knoten oder Beziehungen beim Massenladen behandelt IDs werden, finden Sie unter. ### Eigenschaftsspaltenüberschriften in openCypher-Dateien zum Laden von Daten Sie können mit einer Eigenschaftsspaltenüberschrift angeben, dass eine Spalte die Werte für eine bestimmte Eigenschaft enthält. Die Überschrift muss das folgende Format haben: ``` propertyname:type ``` Leerzeichen, Kommas, Zeilenumbrüche und Zeilenumbrüche sind in den Spaltenüberschriften nicht zulässig, sodass Eigenschaftsnamen diese Zeichen nicht enthalten dürfen. Dies ist ein Beispiel für die Spaltenüberschrift einer Eigenschaft mit dem Namen `age` und dem Typ `Int`. ``` age:Int ``` Die Spalte mit `age:Int` als Spaltenüberschrift müsste dann in jeder Zeile eine Ganzzahl oder einen leeren Wert enthalten. ## Datentypen in Neptune openCypher-Dateien zum Laden von Daten + **`Bool`** oder **`Boolean`**  –   Ein boolesches Feld. Zulässige Werte sind `true` und `false`. Jeder andere Wert als `true` wird als `false` behandelt. + **`Byte`**   –   Eine ganze Zahl im Bereich von `-128` bis `127`. + **`Short`**   –   Eine ganze Zahl im Bereich von `-32,768` bis `32,767`. + **`Int`**   –   Eine ganze Zahl im Bereich von `-2^31` bis `2^31 - 1`. + **`Long`**   –   Eine ganze Zahl im Bereich von `-2^63` bis `2^63 - 1`. + **`Float`**   –   Eine 32-Bit-Gleitkommazahl nach IEEE 754. Dezimalschreibweise und wissenschaftliche Notation werden unterstützt. `Infinity`, `-Infinity` und `NaN` werden erkannt, `INF` jedoch nicht. Werte mit zu vielen Stellen werden auf den nächsten Wert gerundet. (Ein in der Mitte liegender Wert Wert wird für die letzte Stelle auf Bit-Ebene auf 0 gerundet.) + **`Double`**   –   Eine 64-Bit-Gleitkommazahl nach IEEE 754. Dezimalschreibweise und wissenschaftliche Notation werden unterstützt. `Infinity`, `-Infinity` und `NaN` werden erkannt, `INF` jedoch nicht. Werte mit zu vielen Stellen werden auf den nächsten Wert gerundet. (Ein in der Mitte liegender Wert Wert wird für die letzte Stelle auf Bit-Ebene auf 0 gerundet.) + **`String`**   –   Anführungszeichen sind optional. Kommas, Zeilenumbruchzeichen und Zeilenumschaltzeichen werden automatisch mit Escape-Zeichen markiert, wenn sie in einer von doppelten Anführungszeichen (`"`) umschlossenen Zeichenfolge enthalten sind, z. B. `"Hello, World"`. Sie können Anführungszeichen in einer Zeichenfolge mit Anführungszeichen verwenden, indem Sie zwei in einer Zeile verwenden, z. B. `"Hello ""World"""`. + **`DateTime`**   –   Ein Java-Datum in einem der folgenden ISO-8601-Formate: + `yyyy-MM-dd` + `yyyy-MM-ddTHH:mm` + `yyyy-MM-ddTHH:mm:ss` + `yyyy-MM-ddTHH:mm:ssZ` ### Auto-Cast-Datentypen in Neptune openCypher-Dateien zum Laden von Daten Auto-Cast-Datentypen werden bereitgestellt, um Datentypen zu laden, die Neptune zurzeit nicht nativ unterstützt. Daten in solchen Spalten werden in unveränderter Form als Zeichenfolgen gespeichert, ohne sie anhand des beabsichtigten Formats zu verifizieren. Die folgenden Auto-Cast-Datentypen sind zulässig: + **`Char`**   –   Ein `Char`-Feld. Als Zeichenfolge gespeichert. + **`Date`**, **`LocalDate`** und **`LocalDateTime`**   –   Siehe [Zeitliche Neo4j-Instantwerte](https://neo4j.com/docs/cypher-manual/current/values-and-types/temporal/#cypher-temporal-instants) für eine Beschreibung der Typen `date`, `localdate` und `localdatetime`. Die Werte werden in unveränderter Form als Zeichenfolgen ohne Validierung geladen. + **`Duration`**   –   Siehe das [Neo4j-Dauerformat](https://neo4j.com/docs/cypher-manual/current/values-and-types/temporal/#cypher-temporal-durations). Die Werte werden in unveränderter Form als Zeichenfolgen ohne Validierung geladen. + **Punkt**   –   Ein Punktfeld zum Speichern räumlicher Daten. Siehe [Räumliche Instantwerte](https://neo4j.com/docs/cypher-manual/current/values-and-types/spatial/#spatial-values-spatial-instants). Die Werte werden in unveränderter Form als Zeichenfolgen ohne Validierung geladen. ## Beispiel für das openCypher-Ladeformat Das folgende Diagramm aus dem TinkerPop Modern Graph zeigt ein Beispiel für zwei Knoten und eine Beziehung: ![\[Diagramm zweier Knoten und einer Beziehung zwischen ihnen.\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/tinkerpop-2-nodes-and-relationship.png) Die folgende Abbildung zeigt das Diagramm im normalen Neptune-openCypher-Ladeformat. **Knotendatei:** ``` :ID,name:String,age:Int,lang:String,:LABEL v1,"marko",29,,person v2,"lop",,"java",software ``` **Beziehungsdatei:** ``` :ID,:START_ID,:END_ID,:TYPE,weight:Double e1,v1,v2,created,0.4 ``` Alternativ könnten Sie ID-Bereiche und ID wie folgt als Eigenschaft verwenden: **Erste Knotendatei:** ``` name:ID(person),age:Int,lang:String,:LABEL "marko",29,,person ``` **Zweite Knotendatei:** ``` name:ID(software),age:Int,lang:String,:LABEL "lop",,"java",software ``` **Beziehungsdatei:** ``` :ID,:START_ID(person),:END_ID(software),:TYPE,weight:Double e1,"marko","lop",created,0.4 ``` # RDF-Formate zum Laden von Daten Zum Laden von Resource Description Framework (RDF)-Daten können Sie eines der folgenden Standardformate wie vom World Wide Web Consortium (W3C) angegeben verwenden: + N-Triples (`ntriples`) aus der Spezifikation unter [https://www.w3.org/TR/n-triples/](https://www.w3.org/TR/n-triples/) + N-Quads (`nquads`) aus der Spezifikation unter [https://www.w3.org/TR/n-quads/](https://www.w3.org/TR/n-quads/) + RDF/XML (`rdfxml`) aus der Spezifikation unter [https://www.w3.org/TR/rdf-syntax-grammar/](https://www.w3.org/TR/rdf-syntax-grammar/) + Turtle (`turtle`) aus der Spezifikation unter [https://www.w3.org/TR/turtle/](https://www.w3.org/TR/turtle/) **Wichtig** Alle Dateien müssen im UTF-8-Format kodiert sein. Für N-Quads- und N-Triples-Daten mit Unicode-Zeichen werden `\uxxxxx`-Escape-Sequenzen unterstützt. Neptune unterstützt jedoch keine Normalisierung. Wenn ein Wert vorhanden ist, der normalisiert werden muss, stimmt er byte-to-byte bei der Abfrage nicht überein. Weitere Informationen über die Normalisierung finden Sie auf der Seite [Normalization](https://unicode.org/faq/normalization.html) unter [Unicode.org](https://unicode.org). **Nächste Schritte** Da Sie jetzt über ausführlichere Kenntnisse von Ladeformaten verfügen, fahren Sie mit [Beispiel: Laden von Daten in eine Neptune-DB-Instance](bulk-load-data.md) fort. # Beispiel: Laden von Daten in eine Neptune-DB-Instance Dieses Beispiel zeigt, wie Daten in Amazon Neptune geladen werden. Wenn nicht anders angegeben, müssen Sie diese Schritte über eine Amazon-Elastic-Compute-Cloud-Instance (Amazon-EC2-Instance) in derselben Amazon Virtual Private Cloud (VPC) ausführen, in der sich auch Ihre Neptune-DB-Instance befindet. ## Beispiel für die Voraussetzungen für das Laden von Daten Sie benötigen Folgendes, um starten zu können: + Eine Neptune-DB-Instance. Informationen zum Starten einer Neptune-DB-Instance finden Sie unter [Einen Amazon Neptune Neptune-Cluster erstellen](get-started-create-cluster.md). + Einen Amazon-Simple-Storage-Service-Bucket (Amazon-S3-Bucket) zum Speichern der Datendateien. Sie können einen vorhandenen Bucket verwenden. Wenn Sie nicht über einen S3-Bucket verfügen, finden Sie weitere Informationen unter [Einen Bucket erstellen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) im *[Amazon-S3-Handbuch für die ersten Schritte](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)*. + Die Diagrammdaten, die geladen werden sollen, in einem Format, das vom Neptune-Loader unterstützt wird: Wenn Sie Gremlin verwenden, um Ihr Diagramm abzufragen, kann Neptune Daten im Format a comma-separated-values (`CSV`) laden, wie unter beschrieben. [Gremlin-Ladedatenformat](bulk-load-tutorial-format-gremlin.md) Wenn Sie openCypher verwenden, um Ihr Diagramm abzufragen, kann Neptune auch Daten in einem openCypher-spezifischen `CSV`-Format laden, wie in [Ladeformat für openCypher-Daten](bulk-load-tutorial-format-opencypher.md) beschrieben. Wenn Sie SPARQL verwenden, kann Neptune die Daten in einer Reihe von RDF-Formaten laden, wie in [RDF-Formate zum Laden von Daten](bulk-load-tutorial-format-rdf.md) beschrieben. + Eine IAM-Rolle zur Übernahme durch die Neptune-DB-Instance, die über eine IAM-Richtlinie verfügt, die den Zugriff auf die Datendateien im S3-Bucket erlaubt. Die Richtlinie muss Lese- und Auflistungsberechtigungen erteilen. Informationen zum Erstellen einer Rolle, die über Zugriff auf Amazon S3 verfügt, und zum Verknüpfen dieser Rolle mit einem Neptune-Cluster finden Sie unter [Voraussetzungen: IAM-Rolle und Amazon-S3-Zugriff](bulk-load-tutorial-IAM.md). **Anmerkung** Die Neptune-`Load`-API benötigt nur Lesezugriff auf die Datendateien. Die IAM-Richtlinie muss keinen Schreibzugriff oder Zugriff auf den gesamten Bucket zulassen. + Einen Amazon-S3-VPC-Endpunkt. Weitere Informationen finden Sie im Abschnitt [Erstellen eines Amazon-S3-VPC-Endpunkts](#bulk-load-prereqs-s3). ### Erstellen eines Amazon-S3-VPC-Endpunkts Der Neptune Loader erfordert einen VPC-Endpunkt für Amazon S3. **So richten Sie den Zugriff für Amazon S3 ein** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. Wählen Sie im linken Navigationsbereich die Option **Endpoints** (Endpunkte) aus. 1. Klicken Sie auf **Endpunkt erstellen**. 1. Wählen Sie unter **Service Name (Service-Name)** `com.amazonaws.region.s3` aus. **Anmerkung** Wenn die Region hier nicht korrekt ist, stellen Sie sicher, dass die Konsolenregion richtig ist. 1. Wählen Sie die VPC aus, die Ihre Neptune-DB-Instance enthält. 1. Aktivieren Sie das Kontrollkästchen neben den Routing-Tabellen, die den Subnetzen Ihres Clusters zugeordnet sind. Wenn Sie nur eine Routing-Tabelle vorliegen haben, müssen Sie das entsprechende Kontrollkästchen aktivieren. 1. Klicken Sie auf **Endpunkt erstellen**. Informationen zum Erstellen von Endpunkten finden Sie unter [VPC-Endpunkte](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html#create-vpc-endpoint) im *Amazon-VPC-Benutzerhandbuch*. Informationen zu den Einschränkungen für VPC-Endpunkte finden Sie unter [VPC-Endpunkte für Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html). **Laden von Daten in eine Neptune-DB-Instance** 1. Kopieren Sie die Datendateien in einen Amazon-S3-Bucket. Der S3-Bucket muss sich in derselben AWS Region befinden wie der Cluster, der die Daten lädt. Sie können den folgenden AWS CLI Befehl verwenden, um die Dateien in den Bucket zu kopieren. **Anmerkung** Dieser Befehl muss nicht über die Amazon-EC2-Instance ausgeführt werden. ``` aws s3 cp data-file-name s3://bucket-name/object-key-name ``` **Anmerkung** In Amazon S3 stellt ein **Objektschlüsselname** den gesamten Pfad einer Datei dar, einschließlich des Dateinamens. *Beispiel:* Im Befehl `aws s3 cp datafile.txt s3://examplebucket/mydirectory/datafile.txt` lautet der Objektschlüsselname **`mydirectory/datafile.txt`**. Alternativ können Sie den verwenden, AWS-Managementkonsole um Dateien in den S3-Bucket hochzuladen. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)und wählen Sie einen Bucket aus. Wählen Sie oben links **Hochladen** aus, um Dateien hochzuladen. 1. Geben Sie in einem Befehlszeilenfenster Folgendes ein, um den Neptune-Loader auszuführen. Verwenden Sie dabei die korrekten Werte für den Endpunkt, den Amazon-S3-Pfad, das Format und den IAM-Rollen-ARN. Der Parameter `format` kann einen der folgenden Werte haben: `csv` für Gremlin, `opencypher` für openCypher oder `ntriples`, `nquads`, `turtle` und `rdfxml` für RDF. Informationen zu den anderen Parametern finden Sie unter [Neptune-Loader-Befehl](load-api-reference-load.md). Informationen zum Ermitteln des Hostnamens Ihrer Neptune-DB-Instance finden Sie im Abschnitt [Verbinden mit Amazo-Neptune-Endpunkten](feature-overview-endpoints.md). Der Parameter für die Region muss mit der Region des Clusters und des S3-Buckets übereinstimmen. Amazon Neptune ist in den folgenden AWS Regionen verfügbar: + USA Ost (Nord-Virginia):   `us-east-1` + USA Ost (Ohio):   `us-east-2` + USA West (Nordkalifornien):   `us-west-1` + USA West (Oregon):   `us-west-2` + Kanada (Zentral):   `ca-central-1` + Kanada West (Calgary): `ca-west-1` + Südamerika (São Paulo):   `sa-east-1` + Europa (Stockholm):   `eu-north-1` + Europa (Spanien): `eu-south-2` + Europa (Irland):   `eu-west-1` + Europa (London):   `eu-west-2` + Europa (Paris):   `eu-west-3` + Europa (Frankfurt):   `eu-central-1` + Naher Osten (Bahrain):   `me-south-1` + Naher Osten (VAE):   `me-central-1` + Israel (Tel Aviv):   `il-central-1` + Afrika (Kapstadt):   `af-south-1` + Asien-Pazifik (Hongkong):   `ap-east-1` + Asien-Pazifik (Tokio):   `ap-northeast-1` + Asien-Pazifik (Seoul):   `ap-northeast-2` + Asien-Pazifik (Osaka): `ap-northeast-3` + Asien-Pazifik (Singapur):   `ap-southeast-1` + Asien-Pazifik (Sydney):   `ap-southeast-2` + Asien-Pazifik (Jakarta): `ap-southeast-3` + Asien-Pazifik (Melbourne): `ap-southeast-4` + Asien-Pazifik (Malaysia): `ap-southeast-5` + Asien-Pazifik (Mumbai):   `ap-south-1` + Asien-Pazifik (Hyderabad): `ap-south-2` + China (Peking):   `cn-north-1` + China (Ningxia):   `cn-northwest-1` + AWS GovCloud (US-West): `us-gov-west-1` + AWS GovCloud (US-Ost): `us-gov-east-1` ``` curl -X POST \ -H 'Content-Type: application/json' \ https://your-neptune-endpoint:port/loader -d ' { "source" : "s3://bucket-name/object-key-name", "format" : "format", "iamRoleArn" : "arn:aws:iam::account-id:role/role-name", "region" : "region", "failOnError" : "FALSE", "parallelism" : "MEDIUM", "updateSingleCardinalityProperties" : "FALSE", "queueRequest" : "TRUE", "dependencies" : ["load_A_id", "load_B_id"] }' ``` Informationen zum Erstellen und Zuordnen einer IAM-Rolle zu einem Neptune-Cluster finden Sie unter [Voraussetzungen: IAM-Rolle und Amazon-S3-Zugriff](bulk-load-tutorial-IAM.md). **Anmerkung** Unter [Neptune-Loader-Anforderungsparameter](load-api-reference-load.md#load-api-reference-load-parameters)) finden Sie detaillierte Informationen zu Ladeanforderungsparametern. In Kürze: Der Parameter `source` akzeptiert einen Amazon–S3-URI, der auf eine einzelne Datei oder auf einen Ordner verweist. Wenn Sie einen Ordner angeben, lädt Neptune jede Datendatei in den Ordner. Der Ordner enthält möglicherweise mehrere Eckpunkt- und Kantendateien. Der URI kann in einem der folgenden Formate angegeben sein. `s3://bucket_name/object-key-name` `https://s3.amazonaws.com/bucket_name/object-key-name` `https://s3-us-east-1.amazonaws.com/bucket_name/object-key-name` Der Parameter `format` kann eines der folgenden Formate angeben: Gremlin-CSV-Format (`csv`) für Gremlin-Eigenschaftsdiagramme OpenCypher-CSV-Format (`opencypher`) für openCypher-Eigenschaftsdiagramme N-Triples (`ntriples`)-Format für RDF/SPARQL N-Quads (`nquads`)-Format für RDF/SPARQL RDF/XML (`rdfxml`)-Format für RDF/SPARQL Turtle (`turtle`)-Format für RDF/SPARQL Mit dem optionalen Parameter `parallelism` können Sie die Anzahl der im Massen-Ladevorgang verwendeten Threads einschränken. Mögliche Einstellungen sind `LOW`, `MEDIUM`, `HIGH` oder `OVERSUBSCRIBE`. Wenn `updateSingleCardinalityProperties` auf `"FALSE"` eingestellt ist, gibt der Loader einen Fehler zurück, wenn mehr als ein Wert in einer Quelldatei bereitgestellt wird, die für eine Edge- oder Einzel-Kardinalität-Vertex-Eigenschaft geladen wird. Wenn `queueRequest` auf `"TRUE"` eingestellt wird, hat dies zur Folge, dass die Ladeanforderung in eine Warteschlange gestellt wird, wenn bereits ein Ladeauftrag ausgeführt wird. Mit dem Parameter `dependencies` wird die Ausführung der Ladeanforderung vom erfolgreichen Abschluss eines oder mehrerer Ladeaufträge abhängig gemacht, die bereits in die Warteschlange gestellt wurden. 1. Der Neptune-Loader gibt eine Auftrags-`id` zurück, mit der Sie den Status prüfen oder den Ladevorgang abbrechen können, z. B.: ``` { "status" : "200 OK", "payload" : { "loadId" : "ef478d76-d9da-4d94-8ff1-08d9d4863aa5" } } ``` 1. Geben Sie Folgendes ein, um den Status des Ladevorgangs mit der `loadId` aus **Schritt 3** abzurufen: ``` curl -G 'https://your-neptune-endpoint:port/loader/ef478d76-d9da-4d94-8ff1-08d9d4863aa5' ``` Wenn der Status des Ladevorgangs einen Fehler angibt, können Sie mehr Details zum Status und eine Liste der Fehler anfordern. Weitere Informationen und Beispiele finden Sie unter [Neptune Loader-API Get-Status](load-api-reference-status.md). 1. (Optional) Brechen Sie den `Load`-Auftrag ab. Geben Sie Folgendes ein, um den Befehl `Delete` für den Loader-Auftrag mit der Auftrags-`id` aus **Schritt 3** auszuführen: ``` curl -X DELETE 'https://your-neptune-endpoint:port/loader/ef478d76-d9da-4d94-8ff1-08d9d4863aa5' ``` Der `DELETE`-Befehl gibt den HTTP-Code `200 OK` nach erfolgtem Abbruch zurück. Die Daten aus Dateien des Ladeauftrags, der beendet wurde, werden nicht zurückgesetzt. Die Daten bleiben in der Neptune-DB-Instance. # Optimieren einer Amazon-Neptune-Massenladung Sie können mit den folgenden Strategien die Ladezeit für eine Neptune-Massenladung minimieren: + **Bereinigen der Daten:** + Achten Sie darauf, Ihre Daten vor dem Laden in ein [unterstütztes Datenformat](bulk-load-tutorial-format.md) zu konvertieren. + Entfernen Sie alle Duplikate oder bekannten Fehler. + Reduzieren Sie die Anzahl der eindeutigen Prädikate (wie Eigenschaften von Kanten und Eckpunkten) so weit wie möglich. + **Optimieren der Dateien:** + Wenn Sie große Dateien wie CSV-Dateien aus einem Amazon-S3-Bucket laden, verwaltet der Loader die Gleichzeitigkeit für Sie, indem er diese Dateien in Blöcke aufteilt, die parallel geladen werden können. Die Verwendung einer sehr großen Anzahl sehr kleiner Dateien kann diesen Prozess verlangsamen. + Wenn Sie mehrere Dateien aus einem Amazon S3 S3-Präfix laden, lädt der Loader automatisch zuerst Vertex-Dateien und anschließend Edge-Dateien. Wenn Sie jedoch wissen, dass Sie nur Kantendateien laden, `edgeOnlyLoad` können Sie festlegen, dass der erste Durchlauf, bei dem alle Dateien gescannt werden, um `TRUE` ihren Inhalt (Scheitelpunkte oder Kanten) zu bestimmen, übersprungen wird, sodass alle gefundenen Vertex-Dateien vor allen Edge-Dateien geladen werden. Dies kann die Ladezeit erheblich beschleunigen, insbesondere wenn es sich um viele Edge-Dateien handelt. Falls einige Vertex-Dateien auch im selben Amazon S3 S3-Präfix (`source`Parameter) vorhanden sind, werden sie geladen, jedoch ohne jegliche Sortiergarantie im Vergleich zu anderen Dateien. Wenn einige `from` oder `to` Scheitelpunkte nicht in der Datenbank vorhanden sind, kann es außerdem vorkommen, dass beim Einfügen von Kanten Fehler mit der Meldung gemeldet werden. `FROM_OR_TO_VERTEX_ARE_MISSING` Es hat sich bewährt, Knoten und Kanten in ein separates Amazon S3-Präfix einzufügen. + **Überprüfen der Loader-Einstellungen:** + Wenn Sie während des Ladens keine anderen Operationen ausführen müssen, verwenden Sie den Parameter [`OVERSUBSCRIBE`  `parallelism`](load-api-reference-load.md#load-api-reference-load-syntax). Diese Parametereinstellung bewirkt, dass der Bulk-Loader alle verfügbaren CPU-Ressourcen verwendet, wenn er ausgeführt wird. In der Regel werden 60 bis 70% der CPU-Kapazität benötigt, um den Vorgang so schnell laufen zu lassen, wie es die Einschränkungen zulassen. I/O **Anmerkung** Wenn `parallelism` auf `OVERSUBSCRIBE` oder `HIGH` festgelegt ist (die Standardeinstellung), besteht beim Laden von openCypher-Daten die Gefahr, dass Threads auf eine Race-Bedingung und einen Deadlock treffen, was zum Fehler `LOAD_DATA_DEADLOCK` führt. Legen Sie in diesem Fall `parallelism` auf eine niedrigere Einstellung fest und wiederholen Sie den Ladevorgang. + Wenn Ihr Ladeauftrag mehrere Ladeanforderungen umfasst, verwenden Sie den Parameter `queueRequest`. Wenn Sie `queueRequest` auf `TRUE` festlegen, kann Neptune Ihre Abfragen in eine Warteschlange einstellen. So müssen Sie nicht warten, bis eine Abfrage abgeschlossen ist, bevor Sie eine weitere senden. + Wenn Ihre Ladeanforderungen in eine Warteschlange eingestellt werden, können Sie mit dem Parameter `dependencies` Abhängigkeitsstufen einrichten, sodass der Ausfall eines Auftrags zum Ausfall abhängiger Aufträge führt. Dies kann Inkonsistenzen in den geladenen Daten vermeiden. + Wenn ein Ladeauftrag die Aktualisierung zuvor geladener Werte umfasst, müssen Sie den Parameter `updateSingleCardinalityProperties` auf `TRUE` festlegen. Andernfalls behandelt der Loader den Versuch, einen vorhandenen Wert mit einfacher Kardinalität zu aktualisieren, als Fehler. Bei Gremlin-Daten wird die Kardinalität auch in den Überschriften der Eigenschaftsspalten angegeben (siehe [Eigenschaftenspalten-Header](bulk-load-tutorial-format-gremlin.md#bulk-load-tutorial-format-gremlin-propheaders)). **Anmerkung** Der `updateSingleCardinalityProperties`-Parameter ist für RDF-Daten (Resource Description Framework) nicht verfügbar. + Sie können den Parameter `failOnError` verwenden, um festzulegen, ob Massenladeoperationen fehlschlagen oder fortgesetzt werden sollen, wenn ein Fehler auftritt. Sie können den Parameter `mode` auch verwenden, um sicherzustellen, dass ein Ladeauftrag ab dem Punkt weiter geladen wird, an dem ein früherer Auftrag fehlgeschlagen ist, anstatt bereits geladene Daten erneut zu laden. + **Skalieren**   –   Legen Sie die Sie die Writer-Instance Ihres DB-Clusters vor dem Massenladen auf die maximale Größe fest. Beachten Sie, dass Sie in diesem Fall alle Read-Replica-Instances im DB-Cluster entweder hochskalieren oder entfernen müssen, bis das Laden der Daten abgeschlossen ist. Wenn der Massenladevorgang abgeschlossen ist, müssen Sie die Writer-Instance wieder herunterskalieren. **Wichtig** Wenn es aufgrund von Replikationsverzögerungen während eines Massenladens zu einem Zyklus wiederholter Read-Replica-Neustarts kommt, können Ihre Replikate wahrscheinlich nicht mit dem Writer im DB-Cluster Schritt halten. Sie können die Reader so skalieren, dass sie größer als der Writer sind. Sie können sie auch während des Massenladens vorübergehend entfernen und nach dem Abschluss des Vorgangs erneut erstellen. Weitere Informationen zum Einrichten von Loader-Anforderungsparametern finden Sie unter [Anforderungsparameter](load-api-reference-load.md#load-api-reference-load-parameters). # Neptune-Loader-Referenz In diesem Abschnitt werden die `Loader` APIs für Amazon Neptune beschrieben, die vom HTTP-Endpunkt einer Neptune-DB-Instance aus verfügbar sind. **Anmerkung** Die Liste der Fehler- und Feed-Meldungen, die der Loader im Fehlerfall zurückgibt, finden Sie unter [Neptune Loader-Fehler- und Feed-Nachrichten](loader-message.md). **Contents** + [Neptune-Loader-Befehl](load-api-reference-load.md) + [Neptune-Loader-Anforderungssyntax](load-api-reference-load.md#load-api-reference-load-syntax) + [Neptune-Loader-Anforderungsparameter](load-api-reference-load.md#load-api-reference-load-parameters) + [Besondere Überlegungen beim Laden von openCypher-Daten](load-api-reference-load.md#load-api-reference-load-parameters-opencypher) + [Neptune-Loader-Antwortsyntax](load-api-reference-load.md#load-api-reference-load-return) + [Neptune-Loader-Fehler](load-api-reference-load-errors.md) + [Neptune-Loader-Beispiele](load-api-reference-load-examples.md) + [Neptune Loader-API Get-Status](load-api-reference-status.md) + [Neptune Loader-Anfragen Get-Status](load-api-reference-status-requests.md) + [Syntax der Loader-Anfrage Get-Status](load-api-reference-status-requests.md#load-api-reference-status-request-syntax) + [Neptune Loader-Anforderungsparameter Get-Status](load-api-reference-status-requests.md#load-api-reference-status-parameters) + [Antworten von Neptune Loader Get-Status](load-api-reference-status-response.md) + [JSON-Layout für Neptune Get-Status Loader-Antworten](load-api-reference-status-response.md#load-api-reference-status-response-layout) + [Neptune Loader Get-Status `overallStatus` und `failedFeeds` Antwortobjekte](load-api-reference-status-response.md#load-api-reference-status-response-objects) + [Neptune Loader-Antwortobjekt Get-Status `errors`](load-api-reference-status-response.md#load-api-reference-status-errors) + [Neptune Loader-Antwortobjekt Get-Status `errorLogs`](load-api-reference-status-response.md#load-api-reference-error-logs) + [Neptune Loader-Beispiele Get-Status](load-api-reference-status-examples.md) + [Beispiel für eine Ladestatusanforderung](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request) + [Beispiel für eine loadIds-Anforderung](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request) + [Beispiel für eine Detailstatusanforderung](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request) + [Neptune Loader-Beispiele Get-Status `errorLogs`](load-api-reference-error-logs-examples.md) + [Beispiel für eine Detailstatusantwort bei Fehlern](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors) + [Beispiel für den Fehler `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted) + [Neptune-Loader – Auftrag abbrechen](load-api-reference-cancel.md) + [Anforderungssyntax – Auftrag abbrechen](load-api-reference-cancel.md#load-api-reference-cancel-syntax) + [Anforderungsparameter – Auftrag abbrechen](load-api-reference-cancel.md#load-api-reference-cancel-parameters) + [Antwortsyntax– Auftrag abbrechen](load-api-reference-cancel.md#load-api-reference-cancel-parameters-response) + [Fehler– Auftrag abbrechen](load-api-reference-cancel.md#load-api-reference-cancel-parameters-errors) + [Fehlermeldungen – Auftrag abbrechen](load-api-reference-cancel.md#load-api-reference-cancel-parameters-errors-messages) + [Beispiele   –   Auftrag stornieren](load-api-reference-cancel.md#load-api-reference-cancel-examples) # Neptune-Loader-Befehl Lädt Daten aus einem Amazon-S3-Bucket in eine Neptune-DB-Instance. Zum Laden der Daten müssen Sie eine HTTP-`POST`-Anforderung an den `https://your-neptune-endpoint:port/loader`-Endpunkt senden. Die Parameter für die `loader`-Anforderung können im `POST`-Text oder als URL-kodierte Parameter gesendet werden. **Wichtig** Der MIME-Typ muss `application/json` sein. Der Amazon S3 S3-Bucket muss sich in derselben AWS Region wie der Cluster befinden. **Anmerkung** Sie können verschlüsselte Daten aus Amazon S3 laden, wenn sie mit dem Amazon-S3-Modus `SSE-S3` verschlüsselt wurden. In diesem Fall kann Neptune Ihre Anmeldeinformationen vortäuschen und `s3:getObject`-Aufrufe in Ihrem Namen ausgeben. Sie können auch verschlüsselte Daten aus Amazon S3 laden, die mit dem Modus `SSE-KMS` verschlüsselt wurden, wenn Ihre IAM-Rolle die notwendigen Berechtigungen für den Zugriff auf AWS KMS besitzt. Ohne die entsprechenden AWS KMS Berechtigungen schlägt der Massenladevorgang fehl und es wird eine `LOAD_FAILED` Antwort zurückgegeben. Neptune unterstützt zurzeit nicht das Laden von Amazon-S3-Daten, die mit dem Modus `SSE-C` verschlüsselt wurden. Sie müssen nicht warten, bis ein Ladeauftrag abgeschlossen ist, bevor Sie einen weiteren Ladeauftrag starten. Neptune kann bis zu 64 Auftragsanforderungen gleichzeitig in eine Warteschlange einstellen, wenn ihre `queueRequest`-Parameter auf `"TRUE"` festgelegt sind. Die Reihenfolge der Jobs in der Warteschlange lautet first-in-first-out (FIFO). Wenn Sie nicht möchten, dass ein Ladeauftrag in die Warteschlange eingereiht wird, können Sie seinen Parameter `queueRequest` auf `"FALSE"` (den Standardwert) festlegen, damit der Ladeauftrag fehlschlägt, wenn ein bereits ein anderer Ladeauftrag ausgeführt wird. Sie können mit dem Parameter `dependencies` einen Auftrag in die Warteschlange stellen, der nur ausgeführt werden darf, nachdem bestimmte vorherige Aufträge in der Warteschlange erfolgreich durchgeführt wurden. Wenn Sie so verfahren und einer dieser angegebenen Aufträge fehlschlägt, wird Ihr Auftrag nicht ausgeführt und sein Status wird auf `LOAD_FAILED_BECAUSE_DEPENDENCY_NOT_SATISFIED` gesetzt. ## Neptune-Loader-Anforderungssyntax ``` { "source" : "string", "format" : "string", "iamRoleArn" : "string", "mode": "NEW|RESUME|AUTO", "region" : "us-east-1", "failOnError" : "string", "parallelism" : "string", "parserConfiguration" : { "baseUri" : "http://base-uri-string", "namedGraphUri" : "http://named-graph-string" }, "updateSingleCardinalityProperties" : "string", "queueRequest" : "TRUE", "dependencies" : ["load_A_id", "load_B_id"] } ``` **edgeOnlyLoad Syntax** Für eine `edgeOnlyLoad` wäre die Syntax: ``` { "source" : "string", "format" : "string", "iamRoleArn" : "string", "mode": "NEW|RESUME|AUTO", "region" : "us-east-1", "failOnError" : "string", "parallelism" : "string", "edgeOnlyLoad" : "string", "parserConfiguration" : { "baseUri" : "http://base-uri-string", "namedGraphUri" : "http://named-graph-string" }, "updateSingleCardinalityProperties" : "string", "queueRequest" : "TRUE", "dependencies" : ["load_A_id", "load_B_id"] } ``` ## Neptune-Loader-Anforderungsparameter + **`source`**   –   Ein Amazon-S3-URI. Der Parameter `SOURCE` akzeptiert Amazon-S3-URIs, die eine einzelne Datei, mehrere Dateien, einen Ordner oder mehrere Ordner angeben. Neptune lädt jede Datendatei in den Ordner, der angegeben ist. Der URI kann in einem der folgenden Formate angegeben sein. + `s3://bucket_name/object-key-name` + `https://s3.amazonaws.com/bucket_name/object-key-name` + `https://s3.us-east-1.amazonaws.com/bucket_name/object-key-name` Das `object-key-name` Element der URI entspricht dem [Präfixparameter](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html#API_ListObjects_RequestParameters) in einem Amazon S3 [ListObjects](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html)S3-API-Aufruf. Es gibt alle Objekte im angegebenen Amazon-S3-Bucket an, deren Namen mit diesem Präfix beginnen. Das kann eine einzelne Datei oder ein Ordner oder mehrere and/or Dateiordner sein. Die angegebenen Ordner können mehrere Eckpunkt- und Kantendateien enthalten. Wenn Sie beispielsweise die folgende Ordnerstruktur und die folgenden Dateien in einem Amazon S3 S3-Bucket mit dem Namen haben`bucket-name`: ``` s3://bucket-name/a/bc s3://bucket-name/ab/c s3://bucket-name/ade s3://bucket-name/bcd ``` Wenn der Quellparameter als angegeben ist`s3://bucket-name/a`, werden die ersten drei Dateien geladen. ``` s3://bucket-name/a/bc s3://bucket-name/ab/c s3://bucket-name/ade ``` + **`format`**   –   Das Format der Daten. Weitere Informationen zu Datenformaten für den Neptune-Befehl `Loader` finden Sie unter [Verwenden des Amazon Neptune Bulk Loaders zur Datenaufnahme](bulk-load.md). **Zulässige Werte** + **`csv`** für das [Gremlin-CSV-Datenformat](bulk-load-tutorial-format-gremlin.md). + **`opencypher`** für das [openCypher-CSV-Datenformat](bulk-load-tutorial-format-opencypher.md). + **`ntriples`** für das [N-Triples-RDF-Datenformat](https://www.w3.org/TR/n-triples/). + **`nquads`** für das [N-Quads-RDF-Datenformat](https://www.w3.org/TR/n-quads/). + **`rdfxml`** für das [RDF\$1XML-RDF-Datenformat](https://www.w3.org/TR/rdf-syntax-grammar/). + **`turtle`** für das [Turtle-RDF-Datenformat](https://www.w3.org/TR/turtle/). + **`iamRoleArn`**   –   Der Amazon-Ressourcenname (ARN) für eine IAM-Rolle, die von der Neptune-DB-Instance für den Zugriff auf den S3-Bucket angenommen wird. Informationen zum Erstellen einer Rolle, die über Zugriff auf Amazon S3 verfügt, und zum Verknüpfen dieser Rolle mit einem Neptune-Cluster finden Sie unter [Voraussetzungen: IAM-Rolle und Amazon-S3-Zugriff](bulk-load-tutorial-IAM.md). Ab [Engine-Version 1.2.1.0.R3](engine-releases-1.2.1.0.R3.md) können Sie auch mehrere IAM-Rollen verketten, wenn sich die Neptune-DB-Instance und der Amazon S3 S3-Bucket in unterschiedlichen Konten befinden. AWS `iamRoleArn`Enthält in diesem Fall eine durch Kommas getrennte Liste von Rollen, wie unter beschrieben. ARNs [Verketten von IAM-Rollen in Amazon Neptune](bulk-load-tutorial-chain-roles.md) Beispiel: ``` curl -X POST https://localhost:8182/loader \ -H 'Content-Type: application/json' \ -d '{ "source" : "s3://(the target bucket name)/(the target date file name)", "iamRoleArn" : "arn:aws:iam::(Account A ID):role/(RoleA),arn:aws:iam::(Account B ID):role/(RoleB),arn:aws:iam::(Account C ID):role/(RoleC)", "format" : "csv", "region" : "us-east-1" }' ``` + **`region`**— Der `region` Parameter muss mit der AWS Region des Clusters und des S3-Buckets übereinstimmen. Amazon Neptune ist in den folgenden -Regionen verfügbar: + USA Ost (Nord-Virginia):   `us-east-1` + USA Ost (Ohio):   `us-east-2` + USA West (Nordkalifornien):   `us-west-1` + USA West (Oregon):   `us-west-2` + Kanada (Zentral):   `ca-central-1` + Kanada West (Calgary): `ca-west-1` + Südamerika (São Paulo):   `sa-east-1` + Europa (Stockholm):   `eu-north-1` + Europa (Spanien): `eu-south-2` + Europa (Irland):   `eu-west-1` + Europa (London):   `eu-west-2` + Europa (Paris):   `eu-west-3` + Europa (Frankfurt):   `eu-central-1` + Naher Osten (Bahrain):   `me-south-1` + Naher Osten (VAE):   `me-central-1` + Israel (Tel Aviv):   `il-central-1` + Afrika (Kapstadt):   `af-south-1` + Asien-Pazifik (Hongkong):   `ap-east-1` + Asien-Pazifik (Tokio):   `ap-northeast-1` + Asien-Pazifik (Seoul):   `ap-northeast-2` + Asien-Pazifik (Osaka): `ap-northeast-3` + Asien-Pazifik (Singapur):   `ap-southeast-1` + Asien-Pazifik (Sydney):   `ap-southeast-2` + Asien-Pazifik (Jakarta): `ap-southeast-3` + Asien-Pazifik (Melbourne): `ap-southeast-4` + Asien-Pazifik (Malaysia): `ap-southeast-5` + Asien-Pazifik (Mumbai):   `ap-south-1` + Asien-Pazifik (Hyderabad): `ap-south-2` + China (Peking):   `cn-north-1` + China (Ningxia):   `cn-northwest-1` + AWS GovCloud (US-West): `us-gov-west-1` + AWS GovCloud (US-Ost): `us-gov-east-1` + **`mode`**   –   Der Ladeauftragsmodus. *Zulässige Werte*: `RESUME`, `NEW`, `AUTO`. *Standardwert*: `AUTO` **** + `RESUME`   –   Im Modus RESUME sucht der Loader nach einem vorherigen Ladevorgang aus dieser Quelle. Wenn der Loader einen vorherigen Ladevorgang findet, setzt er diesen Ladeauftrag fort. Wenn kein vorheriger Ladeauftrag gefunden wird, stoppt der Loader. Der Loader vermeidet das erneute Laden von Dateien, die in einem früheren Auftrag erfolgreich geladen wurden. Er versucht nur, fehlgeschlagene Dateien zu verarbeiten. Wenn Sie zuvor geladene Daten aus dem Neptune-Cluster gelöscht haben, werden diese Daten in diesem Modus nicht neu geladen. Wenn ein vorheriger Ladeauftrag alle Dateien aus derselben Quelle erfolgreich geladen hat, wird nichts neu geladen und der Loader gibt eine Erfolgsmeldung zurück. + `NEW`   –   Der Modus NEW erstellt eine neue Ladeanforderung unabhängig von vorherigen Ladevorgängen. Sie können diesen Modus verwenden, um alle Daten aus einer Quelle erneut zu laden, nachdem die zuvor aus Ihrem Neptune-Cluster geladenen Daten abgelegt wurden, oder um neue Daten zu laden, die in derselben Quelle verfügbar sind. + `AUTO`   –   Im Modus AUTO sucht der Loader nach einem vorherigen Ladeauftrag aus derselben Quelle. Wenn er einen Ladeauftrag findet, setzt er diesen Auftrag wie im Modus `RESUME` fort. Wenn der Loader keinen vorherigen Ladeauftrag aus derselben Quelle findet, lädt er wie im Modus `NEW` alle Daten aus der Quelle. + **`edgeOnlyLoad`**— Ein Flag, das die Reihenfolge der Dateiverarbeitung beim Massenladen steuert. *Zulässige Werte*: `"TRUE"`, `"FALSE"`. *Standardwert*: `"FALSE"`. Wenn dieser Parameter auf „FALSE“ gesetzt ist, lädt der Loader automatisch zuerst Vertex-Dateien und danach Edge-Dateien. Dazu werden zunächst alle Dateien gescannt, um deren Inhalt (Scheitelpunkte oder Kanten) zu bestimmen. Wenn dieser Parameter auf „TRUE“ gesetzt ist, überspringt der Loader die anfängliche Scanphase und lädt sofort alle Dateien in der Reihenfolge, in der sie erscheinen. Weitere Informationen finden Sie unter [Bulk Load Optimize](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-optimize.html). + **`failOnError`**   –   Ein Flag für vollständiges Anhalten bei einem Fehler. *Zulässige Werte*: `"TRUE"`, `"FALSE"`. *Standardwert*: `"TRUE"`. Wenn dieser Parameter auf `"FALSE"` gesetzt ist, versucht der Loader, alle Daten am angegebenen Speicherort zu laden, wobei alle Einträge mit Fehlern übersprungen werden. Wenn dieser Parameter auf `"TRUE"` eingestellt ist, stoppt der Loader, sobald ein Fehler auftritt. Bis zu diesem Punkt geladene Daten bleiben bestehen. + **`parallelism`**   –   Dies ist ein optionaler Parameter, der festgelegt werden kann, um die Anzahl der vom Massenladevorgang verwendeten Threads zu reduzieren. *Zulässige Werte*: + `LOW`— Die Anzahl der verwendeten Threads entspricht der Anzahl der verfügbaren v CPUs geteilt durch 8. + `MEDIUM`— Die Anzahl der verwendeten Threads entspricht der Anzahl der verfügbaren v CPUs geteilt durch 2. + `HIGH`— Die Anzahl der verwendeten Threads entspricht der Anzahl der verfügbaren CPUs v. + `OVERSUBSCRIBE`— Die Anzahl der verwendeten Threads ist die Anzahl der verfügbaren v CPUs multipliziert mit 2. Wenn dieser Wert verwendet wird, nimmt der Massen-Loader alle verfügbaren Ressourcen in Anspruch. Das bedeutet jedoch nicht, dass die Einstellung `OVERSUBSCRIBE` zu einer CPU-Auslastung von 100 % führt. Da der Ladevorgang I/O gebunden ist, liegt die höchste zu erwartende CPU-Auslastung im Bereich von 60 bis 70% *Standardwert*: `HIGH` Die Einstellung `parallelism` kann manchmal beim Laden von openCypher-Daten zu einem Deadlock zwischen Threads führen. In diesem Fall gibt Neptune den Fehler `LOAD_DATA_DEADLOCK` zurück. Sie können das Problem im Allgemeinen beheben, indem Sie `parallelism` auf einen niedrigeren Wert festlegen und den Ladebefehl wiederholen. + **`parserConfiguration`**   –   Ein optionales Objekt mit zusätzlichen Parser-Konfigurationswerten. Jeder der untergeordneten Parameter ist ebenfalls optional: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/load-api-reference-load.html) Weitere Informationen finden Sie unter [SPARQL-Standard-Graph und benannte Graphen](feature-sparql-compliance.md#sparql-default-graph). + **`updateSingleCardinalityProperties`**   –   Dies ist ein optionaler Parameter, der steuert, wie der Massen-Loader einen neuen Wert für Eckpunkt- oder Kanteneigenschaften mit einfacher Kardinalität behandelt. Dies wird für das Laden von openCypher-Daten nicht unterstützt (siehe [Laden von openCypher-Daten](#load-api-reference-load-parameters-opencypher)). *Zulässige Werte*: `"TRUE"`, `"FALSE"`. *Standardwert*: `"FALSE"`. Standardmäßig oder wenn `updateSingleCardinalityProperties` explizit als `"FALSE"` festgelegt ist, behandelt der Loader einen neuen Wert als Fehler, da er gegen die Einzel-Kardinalität verstößt. Wenn `updateSingleCardinalityProperties` als `"TRUE"` festgelegt ist, ersetzt der Massen-Loader auf der anderen Seite den vorhandenen Wert durch den neuen. Wenn in den Quelldateien, die geladen werden, mehrere Edge- oder Einzel-Kardinalität-Vertex-Eigenschaftswerte angegeben werden, kann der endgültige Wert am Ende des Massenladevorgangs jeder dieser neuen Werte sein. Der Loader stellt nur sicher, dass der vorhandene Wert durch einen der neuen ersetzt wurde. + **`queueRequest`**   –   Dies ist ein optionaler Flag-Parameter, der angibt, ob die Ladeanforderung in die Warteschlange eingereiht werden kann oder nicht. Sie müssen mit dem nächsten Ladeauftrag nicht warten, bis ein Ladeauftrag abgeschlossen ist, da Neptune bis zu 64 Aufträge gleichzeitig in die Warteschlange einreihen kann, wenn alle `queueRequest`-Parameter auf `"TRUE"` festgelegt sind. Die Reihenfolge der Jobs in der Warteschlange lautet first-in-first-out (FIFO). Wenn der Parameter `queueRequest` ausgelassen oder auf `"FALSE"` festgelegt wird, schlägt die Ladeanforderung fehl, wenn bereits ein anderer Ladeauftrag ausgeführt wird. *Zulässige Werte*: `"TRUE"`, `"FALSE"`. *Standardwert*: `"FALSE"`. + **`dependencies`**   –   Dies ist ein optionaler Parameter, mit dem eine Ladeanforderung in der Warteschlange vom erfolgreichen Abschluss eines oder mehrerer früherer Aufträge in der Warteschlange abhängig gemacht werden kann. Neptune kann bis zu 64 Ladeanforderungen gleichzeitig in die Warteschlange einreihen, wenn die `queueRequest`-Parameter auf `"TRUE"` festgelegt sind. Mit dem Parameter `dependencies` können Sie die Ausführung einer solchen Anforderung in der Warteschlange vom erfolgreichen Abschluss einer oder mehrerer spezifizierter früherer Anforderungen in der Warteschlange abhängig machen. Wenn Ladung `Job-A` und `Job-B` beispielsweise unabhängig voneinander sind, mit Ladung `Job-C` aber erst nach Abschluss von `Job-A` und `Job-B` begonnen werden kann, gehen Sie wie folgt vor: 1. Senden Sie `load-job-A` und `load-job-B` nacheinander in beliebiger Reihenfolge, und speichern Sie ihre Ladekennungen. 1. Senden Sie `load-job-C` mit den Ladekennungen der beiden Aufträge in seinem `dependencies`-Feld: ``` "dependencies" : ["job_A_load_id", "job_B_load_id"] ``` Aufgrund des Parameters `dependencies` startet der Bulk-Loader `Job-C` erst dann, nachdem `Job-A` und `Job-B` erfolgreich abgeschlossen wurden. Wenn einer von ihnen fehlschlägt, wird Job-C nicht ausgeführt und sein Status wird auf `LOAD_FAILED_BECAUSE_DEPENDENCY_NOT_SATISFIED` gesetzt. Auf diese Weise können Sie mehrere Abhängigkeitsebenen einrichten, sodass das Fehlschlagen eines Auftrags dazu führt, dass alle Anforderungen, die direkt oder indirekt davon abhängig sind, abgebrochen werden. + **`userProvidedEdgeIds`**— Dieser Parameter ist nur erforderlich, wenn OpenCypher-Daten geladen werden, die eine Beziehung enthalten. IDs Er muss enthalten und auf den Wert gesetzt werden, `True` wenn OpenCypher-Beziehungen explizit in den Ladedaten angegeben IDs sind (empfohlen). Wenn `userProvidedEdgeIds` fehlt oder auf `True` festgelegt ist, muss in jeder Beziehungsdatei im Ladevorgang die Spalte `:ID` vorhanden sein. Wenn `userProvidedEdgeIds` vorhanden und auf `False` festgelegt ist, dürfen Beziehungsdateien im Ladevorgang die Spalte `:ID` **nicht** enthalten. Stattdessen generiert der Neptune-Loader automatisch eine ID für jede Beziehung. Es ist nützlich, die Beziehung IDs explizit anzugeben, damit der Loader den Ladevorgang fortsetzen kann, nachdem ein Fehler in den CSV-Daten behoben wurde, ohne dass bereits geladene Beziehungen erneut geladen werden müssen. Wenn IDs die Beziehung nicht explizit zugewiesen wurde, kann der Loader einen fehlgeschlagenen Ladevorgang nicht fortsetzen, falls eine Beziehungsdatei korrigiert werden musste, und muss stattdessen alle Beziehungen neu laden. + `accessKey`   –   **[veraltet]** Die Zugriffsschlüssel-ID einer IAM-Rolle mit Zugriff auf den S3-Bucket und Datendateien. Stattdessen wird der Parameter `iamRoleArn` empfohlen. Informationen zum Erstellen einer Rolle, die über Zugriff auf Amazon S3 verfügt, und zum Verknüpfen dieser Rolle mit einem Neptune-Cluster finden Sie unter [Voraussetzungen: IAM-Rolle und Amazon-S3-Zugriff](bulk-load-tutorial-IAM.md). Weitere Informationen finden Sie unter [Zugriffsschlüssel (Zugriffsschlüssel-ID und geheimer Zugriffsschlüssel)](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys). + `secretKey`   –   **[veraltet]** Stattdessen wird der Parameter `iamRoleArn` empfohlen. Informationen zum Erstellen einer Rolle, die über Zugriff auf Amazon S3 verfügt, und zum Verknüpfen dieser Rolle mit einem Neptune-Cluster finden Sie unter [Voraussetzungen: IAM-Rolle und Amazon-S3-Zugriff](bulk-load-tutorial-IAM.md). Weitere Informationen finden Sie unter [Zugriffsschlüssel (Zugriffsschlüssel-ID und geheimer Zugriffsschlüssel)](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys). ### Besondere Überlegungen beim Laden von openCypher-Daten + Beim Laden von openCypher-Daten im CSV-Format muss der Formatparameter auf `opencypher` festgelegt werden. + Der Parameter `updateSingleCardinalityProperties` wird für openCypher-Ladevorgänge nicht unterstützt, da alle openCypher-Eigenschaften eine einfache Kardinalität besitzen. Das openCypher-Ladeformat unterstützt keine Arrays. Wenn ein ID-Wert mehr als einmal vorkommt, wird er als Duplikat oder Einfügefehler behandelt (siehe unten). + Der Neptune-Loader behandelt Duplikate in openCypher-Daten wie folgt: + Wenn der Loader mehrere Zeilen mit derselben Knoten-ID findet, werden sie entsprechend der folgenden Regel zusammengeführt: + Alle Bezeichnungen in den Zeilen werden dem Knoten hinzugefügt. + Für jede Eigenschaft wird nur einer der Eigenschaftswerte geladen. Die Auswahl des Werts, der geladen wird, ist nicht deterministisch. + Wenn der Loader mehrere Zeilen mit derselben Beziehungs-ID findet, wird nur eine dieser Zeilen geladen. Die Auswahl der Zeile, die geladen wird, ist nicht deterministisch. + Der Loader aktualisiert niemals die Eigenschaftswerte vorhandener Knoten oder Beziehungen in der Datenbank, wenn er Ladedaten mit der ID der vorhandenen Knoten oder Beziehungen findet. Es werden jedoch Knotenbezeichnungen und -eigenschaften geladen, die in vorhandenen Knoten oder Beziehungen nicht vorhanden sind. + Sie müssen zwar keine Zuweisungen IDs zu Beziehungen vornehmen, dies ist jedoch in der Regel eine gute Idee (siehe den `userProvidedEdgeIds` Parameter oben). Ohne explizite Beziehung IDs muss der Loader im Falle eines Fehlers in einer Beziehungsdatei alle Beziehungen neu laden, anstatt den Ladevorgang an der Stelle fortzusetzen, an der er fehlgeschlagen ist. Wenn die Ladedaten keine explizite Beziehung enthalten IDs, hat der Loader außerdem keine Möglichkeit, doppelte Beziehungen zu erkennen. Dies ist ein Beispiel für einen openCypher-Ladebefehl: ``` curl -X POST https://your-neptune-endpoint:port/loader \ -H 'Content-Type: application/json' \ -d ' { "source" : "s3://bucket-name/object-key-name", "format" : "opencypher", "userProvidedEdgeIds": "TRUE", "iamRoleArn" : "arn:aws:iam::account-id:role/role-name", "region" : "region", "failOnError" : "FALSE", "parallelism" : "MEDIUM", }' ``` Die Loader-Antwort ist dieselbe wie normal. Beispiel: ``` { "status" : "200 OK", "payload" : { "loadId" : "guid_as_string" } } ``` ## Neptune-Loader-Antwortsyntax ``` { "status" : "200 OK", "payload" : { "loadId" : "guid_as_string" } } ``` **200 OK** Bei einem erfolgreich gestarteten Ladeauftrag wird ein `200`-Code zurückgegeben. # Neptune-Loader-Fehler Wenn ein Fehler auftritt, wird ein JSON-Objekt im `BODY` der Antwort zurückgegeben. Das `message`-Objekt enthält eine Beschreibung des Fehlers. **Fehlerkategorien** + `Error 400`   –   Syntaxfehler geben den HTTP-Fehler `400` (ungültige Anforderung) zurück. Die Nachricht beschreibt den Fehler. + `Error 500`   –   Eine gültige Anforderung, die nicht verarbeitet werden kann, gibt den internen HTTP-Serverfehler `500` zurück. Die Nachricht beschreibt den Fehler. Im Folgenden sind mögliche Fehlermeldungen des Loaders mit einer Beschreibung des jeweiligen Fehlers aufgeführt. **Loader-Fehlermeldungen** + `Couldn't find the AWS credential for iam_role_arn`  (HTTP 400) Die Anmeldeinformationen wurden nicht gefunden. Überprüfen Sie die angegebenen Anmeldeinformationen anhand der IAM-Konsole oder der AWS CLI Ausgabe. Stellen Sie sicher, dass Sie die in `iamRoleArn` angegebene IAM-Rolle zum Cluster hinzugefügt haben. + `S3 bucket not found for source`  (HTTP 400) Der S3-Bucket ist nicht vorhanden. Überprüfen Sie den Namen des Buckets. + `The source source-uri does not exist/not reachable`  (HTTP 400) Es wurden keine übereinstimmenden Dateien im S3-Bucket gefunden. + `Unable to connect to S3 endpoint. Provided source = source-uri and region = aws-region`  (HTTP 500) Verbindung zu Amazon S3 kann nicht hergestellt werden. Die Region muss mit der Cluster-Region übereinstimmen. Stellen Sie sicher, dass Sie über einen VPC-Endpunkt verfügen. Informationen zum Erstellen eines VPC-Endpunkts finden Sie unter [Erstellen eines Amazon-S3-VPC-Endpunkts](bulk-load-data.md#bulk-load-prereqs-s3). + `Bucket is not in provided Region (aws-region)`  (HTTP 400) Der Bucket muss sich in derselben AWS Region wie Ihre Neptune-DB-Instance befinden. + `Unable to perform S3 list operation`  (HTTP 400) Der IAM-Benutzer oder die angegebene Rolle verfügt nicht über `List`-Berechtigungen für den Bucket oder Ordner. Prüfen Sie die Richtlinie oder die Zugriffskontrollliste (ACL) für den Bucket. + `Start new load operation not permitted on a read replica instance`  (HTTP 405) Das Laden ist ein Schreibvorgang. Versuchen Sie erneut, den Cluster-Endpunkt zu laden. read/write + `Failed to start load because of unknown error from S3`  (HTTP 500) Amazon S3 hat einen unbekannten Fehler zurückgegeben. Wenden Sie sich an [AWS Support](https://aws.amazon.com/premiumsupport/). + `Invalid S3 access key`  (HTTP 400) Der Zugriffsschlüssel ist ungültig. Prüfen Sie die angegebenen Anmeldeinformationen. + `Invalid S3 secret key`  (HTTP 400) Der geheime Schlüssel ist ungültig. Prüfen Sie die angegebenen Anmeldeinformationen. + `Max concurrent load limit breached`  (HTTP 400) Wenn eine Ladeanforderung ohne `"queueRequest" : "TRUE"` gesendet wird und derzeit ein Ladeauftrag ausgeführt wird, schlägt die Anforderung mit diesem Fehler fehl. + `Failed to start new load for the source "source name". Max load task queue size limit breached. Limit is 64`  (HTTP 400) Neptune unterstützt Warteschlangen mit bis zu 64 Loader-Aufträgen gleichzeitig. Wenn eine zusätzliche Ladeanforderung an eine Warteschlange mit bereits 64 Aufträgen gesendet wird, schlägt die Anforderung mit dieser Meldung fehl. # Neptune-Loader-Beispiele Dieses Beispiel zeigt, wie der Neptune-Loader verwendet wird, um Daten im Gremlin CSV-Format in eine Neptune-Graphdatenbank zu laden. Die Anfrage wird als HTTP-POST-Anfrage an den Neptune-Loader-Endpunkt gesendet, und der Anforderungstext enthält die erforderlichen Parameter, um die Datenquelle, das Format, die IAM-Rolle und andere Konfigurationsoptionen anzugeben. Die Antwort enthält die Lade-ID, mit der der Fortschritt des Datenladevorgangs verfolgt werden kann. **Example Anforderung** Im Folgenden ist eine Anforderung dargestellt, die über HTTP POST mit dem `curl`-Befehl gesendet wird. Dabei wird eine Datei im Neptune-CSV-Format geladen. Weitere Informationen finden Sie unter [Gremlin-Ladedatenformat](bulk-load-tutorial-format-gremlin.md). ``` curl -X POST \ -H 'Content-Type: application/json' \ https://your-neptune-endpoint:port/loader -d ' { "source" : "s3://bucket-name/object-key-name", "format" : "csv", "iamRoleArn" : "ARN for the IAM role you are using", "region" : "region", "failOnError" : "FALSE", "parallelism" : "MEDIUM", "updateSingleCardinalityProperties" : "FALSE", "queueRequest" : "FALSE" }' ``` **Example Antwort** ``` { "status" : "200 OK", "payload" : { "loadId" : "ef478d76-d9da-4d94-8ff1-08d9d4863aa5" } } ``` # Neptune Loader-API Get-Status Ruft den Status eines `loader`-Auftrags ab. Zum Abrufen des Ladestatus müssen Sie eine HTTP-`GET`-Anforderung an den `https://your-neptune-endpoint:port/loader`-Endpunkt senden. Zum Abrufen des Status für eine bestimmte Ladeanforderung müssen Sie die `loadId` als URL-Parameter einschließen oder die `loadId` dem URL-Pfad voranstellen. Neptune verfolgt nur die letzten 1.024 Massenladeaufgaben und speichert pro Auftrag nur die letzten 10 000 Fehlerdetails. Die Liste der Fehler- und Feed-Meldungen, die der Loader im Fehlerfall zurückgibt, finden Sie unter [Neptune Loader-Fehler- und Feed-Nachrichten](loader-message.md). **Contents** + [Neptune Loader-Anfragen Get-Status](load-api-reference-status-requests.md) + [Syntax der Loader-Anfrage Get-Status](load-api-reference-status-requests.md#load-api-reference-status-request-syntax) + [Neptune Loader-Anforderungsparameter Get-Status](load-api-reference-status-requests.md#load-api-reference-status-parameters) + [Antworten von Neptune Loader Get-Status](load-api-reference-status-response.md) + [JSON-Layout für Neptune Get-Status Loader-Antworten](load-api-reference-status-response.md#load-api-reference-status-response-layout) + [Neptune Loader Get-Status `overallStatus` und `failedFeeds` Antwortobjekte](load-api-reference-status-response.md#load-api-reference-status-response-objects) + [Neptune Loader-Antwortobjekt Get-Status `errors`](load-api-reference-status-response.md#load-api-reference-status-errors) + [Neptune Loader-Antwortobjekt Get-Status `errorLogs`](load-api-reference-status-response.md#load-api-reference-error-logs) + [Neptune Loader-Beispiele Get-Status](load-api-reference-status-examples.md) + [Beispiel für eine Ladestatusanforderung](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request) + [Beispiel für eine loadIds-Anforderung](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request) + [Beispiel für eine Detailstatusanforderung](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request) + [Neptune Loader-Beispiele Get-Status `errorLogs`](load-api-reference-error-logs-examples.md) + [Beispiel für eine Detailstatusantwort bei Fehlern](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors) + [Beispiel für den Fehler `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted) # Neptune Loader-Anfragen Get-Status ## Syntax der Loader-Anfrage Get-Status ``` GET https://your-neptune-endpoint:port/loader?loadId=loadId ``` ``` GET https://your-neptune-endpoint:port/loader/loadId ``` ``` GET https://your-neptune-endpoint:port/loader ``` ## Neptune Loader-Anforderungsparameter Get-Status + **`loadId`**   –   Die ID des Ladeauftrags. Wenn Sie keinen Wert angeben`loadId`, wird eine Ladeliste IDs zurückgegeben. + **`details`**   –   Fügt über den Gesamtstatus hinausgehende Details hinzu. *Zulässige Werte*: `TRUE`, `FALSE`. *Standardwert*: `FALSE`. + **`errors`**   –   Fügt die Liste der Fehler ein. *Zulässige Werte*: `TRUE`, `FALSE`. *Standardwert*: `FALSE`. Die Fehlerliste ist segmentiert. Die Parameter `page` und `errorsPerPage` erlauben Ihnen das seitenweise Durchlaufen aller Fehler. + **`page`**   –   Die Fehlerseitenzahl. Dieser Wert ist nur gültig, wenn der `errors`-Parameter auf `TRUE` eingestellt ist. *Zulässige Werte*: Positive Ganzzahlen. *Standardwert*: 1. + **`errorsPerPage`**   –   Die Anzahl der Fehler pro Seite. Dieser Wert ist nur gültig, wenn der `errors`-Parameter auf `TRUE` eingestellt ist. *Zulässige Werte*: Positive Ganzzahlen. *Standardwert*: 10. + **`limit`**   –   Die Anzahl der Lade-IDs, die aufgelistet werden sollen. Nur gültig, wenn eine Ladeliste angefordert wird, IDs indem eine `GET` Anfrage ohne `loadId` Angabe gesendet wird. *Zulässige Werte*: Positive Ganzzahlen von 1 bis 100. *Standardwert*: 100. + **`includeQueuedLoads`**— Ein optionaler Parameter, der verwendet werden kann, um das Laden IDs von Ladeanforderungen in der Warteschlange auszuschließen, wenn eine Ladeliste angefordert IDs wird. Standardmäßig `LOAD_IN_QUEUE` sind die Ladevorgänge IDs aller Ladejobs mit Status in einer solchen Liste enthalten. Sie werden vor dem Laden IDs anderer Jobs angezeigt, sortiert nach dem Zeitpunkt, zu dem sie der Warteschlange hinzugefügt wurden, vom letzten zum frühesten. *Zulässige Werte*: `TRUE`, `FALSE`. *Standardwert*: `TRUE`. # Antworten von Neptune Loader Get-Status Die folgende Beispielantwort der Get-Status Neptune-API beschreibt die Gesamtstruktur der Antwort, erklärt die verschiedenen Felder und ihre Datentypen sowie die Fehlerbehandlung und die Fehlerprotokolldetails. ## JSON-Layout für Neptune Get-Status Loader-Antworten Das allgemeine Layout einer Loader-Status-Antwort sieht wie folgt aus: ``` { "status" : "200 OK", "payload" : { "feedCount" : [ { "LOAD_FAILED" : number } ], "overallStatus" : { "fullUri" : "s3://bucket/key", "runNumber" : number, "retryNumber" : number, "status" : "string", "totalTimeSpent" : number, "startTime" : number, "totalRecords" : number, "totalDuplicates" : number, "parsingErrors" : number, "datatypeMismatchErrors" : number, "insertErrors" : number, }, "failedFeeds" : [ { "fullUri" : "s3://bucket/key", "runNumber" : number, "retryNumber" : number, "status" : "string", "totalTimeSpent" : number, "startTime" : number, "totalRecords" : number, "totalDuplicates" : number, "parsingErrors" : number, "datatypeMismatchErrors" : number, "insertErrors" : number, } ], "errors" : { "startIndex" : number, "endIndex" : number, "loadId" : "string, "errorLogs" : [ ] } } } ``` ## Neptune Loader Get-Status `overallStatus` und `failedFeeds` Antwortobjekte Die möglichen Antworten, die für jeden fehlgeschlagenen Feed zurückgegeben werden, einschließlich Fehlerbeschreibungen, sind die gleichen wie für das Objekt `overallStatus` in einer `Get-Status`-Antwort. Die folgenden Felder werden im Objekt `overallStatus` für alle Ladevorgänge und im Objekt `failedFeeds` für jeden fehlgeschlagenen Feed angegeben: + **`fullUri` **  –   Der URI der Datei/der Dateien, die geladen werden soll(en). *Typ:* *Zeichenfolge* *Format*: `s3://bucket/key`. + **`runNumber`**   –   Die Zahl der Ausführungen dieses Ladevorgangs oder Feeds. Diese wird um eins erhöht, wenn der Ladevorgang neu gestartet wird. *Typ:* *unsigned long*. + **`retryNumber`**   –   Die Zahl der Wiederholungen dieses Ladevorgangs oder Feeds. Diese wird um eins erhöht, wenn der Loader einen Feed oder Ladevorgang automatisch wiederholt. *Typ:* *unsigned long*. + **`status`**   –   Der zurückgegebene Status des Ladevorgangs oder Feeds. `LOAD_COMPLETED` gibt einen erfolgreichen Ladevorgang ohne Probleme an. Eine Liste weiterer Ladestatusmeldungen finden Sie unter [Neptune Loader-Fehler- und Feed-Nachrichten](loader-message.md). *Typ:* *Zeichenfolge*. + **`totalTimeSpent`**   –   Die Zeit in Sekunden, die für das Analysieren und Einfügen von Daten für den Ladevorgang oder Feed verbraucht wurde. Dabei wird nicht die Zeit für das Abrufen der Liste der Quelldateien berücksichtigt. *Typ:* *unsigned long*. + **`totalRecords`**   –   Die Gesamtzahl der Datensätze, die geladen wurden oder deren Laden versucht wurde. *Typ:* *unsigned long*. Beachten Sie, dass sich die Zahl der Datensätze beim Laden aus einer CSV-Datei nicht auf die Anzahl der geladenen Zeilen bezieht, sondern auf die Anzahl der einzelnen Datensätze in diesen Zeilen. Betrachten Sie beispielsweise eine winzige CSV-Datei wie diese: ``` ~id,~label,name,team 'P-1','Player','Stokes','England' ``` Neptune würde annehmen, dass diese Datei 3 Datensätze enthält: ``` P-1 label Player P-1 name Stokes P-1 team England ``` + **`totalDuplicates`**   –   Die Anzahl der gefundenen duplizierten Datensätze. *Typ:* *unsigned long*. Wie im Fall von `totalRecords` enthält dieser Wert die Anzahl der einzelnen duplizierten Datensätze in einer CSV-Datei, nicht die Anzahl der duplizierten Zeilen. Betrachten Sie beispielsweise diese kleine CSV-Datei: ``` ~id,~label,name,team P-2,Player,Kohli,India P-2,Player,Kohli,India ``` Der nach dem Laden zurückgegebene Status würde wie folgt aussehen und insgesamt 6 Datensätze melden, von denen 3 Duplikate sind: ``` { "status": "200 OK", "payload": { "feedCount": [ { "LOAD_COMPLETED": 1 } ], "overallStatus": { "fullUri": "(the URI of the CSV file)", "runNumber": 1, "retryNumber": 0, "status": "LOAD_COMPLETED", "totalTimeSpent": 3, "startTime": 1662131463, "totalRecords": 6, "totalDuplicates": 3, "parsingErrors": 0, "datatypeMismatchErrors": 0, "insertErrors": 0 } } } ``` Bei openCypher-Ladevorgängen wird ein Duplikat gezählt, wenn: + Der Loader erkennt, dass eine Zeile in einer Knotendatei eine ID ohne ID-Bereich hat, die mit einem anderen ID-Wert ohne ID-Bereich identisch ist, entweder in einer anderen Zeile oder als Teil eines vorhandenen Knotens. + Der Loader erkennt, dass eine Zeile in einer Knotendatei eine ID mit ID-Bereich hat, die mit einem anderen ID-Wert mit ID-Bereich identisch ist, entweder in einer anderen Zeile oder als Teil eines vorhandenen Knotens. Siehe [Besondere Überlegungen beim Laden von openCypher-Daten](load-api-reference-load.md#load-api-reference-load-parameters-opencypher). + **`parsingErrors`**   –   Die Anzahl der aufgetretenen Analysefehler. *Typ:* *unsigned long*. + **`datatypeMismatchErrors`**   –   Die Anzahl der Datensätze mit einem Datentyp, der nicht mit den angegebenen Daten übereinstimmt. *Typ:* *unsigned long*. + **`insertErrors`**   –   Die Anzahl der Datensätze, die aufgrund von Fehlern nicht eingefügt werden konnten. *Typ:* *unsigned long*. ## Neptune Loader-Antwortobjekt Get-Status `errors` Fehler lassen sich in die folgenden Kategorien einteilen: + **`Error 400`**   –   Eine ungültige `loadId` gibt den HTTP-Fehler `400` für ungültige Anforderungen zurück. Die Nachricht beschreibt den Fehler. + **`Error 500`**   –   Eine gültige Anforderung, die nicht verarbeitet werden kann, gibt den internen HTTP-Serverfehler `500` zurück. Die Nachricht beschreibt den Fehler. Die Liste der Fehler- und Feed-Meldungen, die der Loader im Fehlerfall zurückgibt, finden Sie unter [Neptune Loader-Fehler- und Feed-Nachrichten](loader-message.md). Wenn ein Fehler auftritt, wird das JSON-Objekt `errors` im `BODY` der Antwort mit den folgenden Feldern zurückgegeben: + **`startIndex`**   –   Der Index des ersten enthaltenen Fehlers. *Typ:* *unsigned long*. + **`endIndex`**   –   Der Index des letzten enthaltenen Fehlers. *Typ:* *unsigned long*. + **`loadId`**   –   Die ID des Ladeauftrags. Sie können diese ID verwenden, um die Fehler für den Ladevorgang zu drucken, indem Sie den `errors`-Parameter auf `TRUE` festlegen. *Typ:* *Zeichenfolge*. + **`errorLogs`**   –   Eine Liste der Fehler. *Typ:* *Liste*. ## Neptune Loader-Antwortobjekt Get-Status `errorLogs` Das Objekt `errorLogs` unter `errors` der Get-Status-Antwort des Loaders enthält ein Objekt, das jeden Fehler anhand der folgenden Felder beschreibt: + **`errorCode`**   –   Identifiziert die Art des Fehlers. Dabei kann es sich um einen der folgenden Werte handeln: + `PARSING_ERROR` + `S3_ACCESS_DENIED_ERROR` + `FROM_OR_TO_VERTEX_ARE_MISSING` + `ID_ASSIGNED_TO_MULTIPLE_EDGES` + `SINGLE_CARDINALITY_VIOLATION` + `FILE_MODIFICATION_OR_DELETION_ERROR` + `OUT_OF_MEMORY_ERROR` + `INTERNAL_ERROR` (wird zurückgegeben, wenn der Massen-Loader die Art des Fehlers nicht bestimmen kann). + **`errorMessage`**   –   Eine Meldung mit einer Beschreibung des Fehlers. Dabei kann es sich um eine generische Meldung handeln, die mit dem Fehlercode verknüpft ist, oder um eine spezifische Meldung mit Details, beispielsweise zu einem fehlenden from/to Eckpunkt oder zu einem Analysefehler. + **`fileName`**   –   Der Name des Feeds. + **`recordNum`**   –   Bei einem Analysefehler ist dies die Nummer des Datensatzes in der Datensatzdatei, der nicht analysiert werden konnte. Sie ist auf Null festgelegt, wenn die Datensatznummer nicht auf den Fehler zutrifft oder wenn sie nicht bestimmt werden konnte. Beispielsweise würde der Massen-Loader einen Analysefehler generieren, wenn er in einer RDF-`nquads`-Datei eine fehlerhafte Zeile wie die folgende finden würde: ``` |http://base#predicate> . ``` Wie Sie sehen können, sollte dem zweiten `http` in der Zeile oben eher ein  `<`  als ein  `|`  vorangestellt werden. Das resultierende Fehlerobjekt unter `errorLogs` in einer Statusantwort würde wie folgt aussehen: ``` { "errorCode" : "PARSING_ERROR", "errorMessage" : "Expected '<', found: |", "fileName" : "s3://bucket/key", "recordNum" : 12345 }, ``` # Neptune Loader-Beispiele Get-Status Die folgenden Beispiele zeigen die Verwendung der Get-Status-API des Neptune-Loaders, mit der Sie Informationen über den Status Ihrer Datenladungen in die Amazon Neptune Neptune-Graphdatenbank abrufen können. Diese Beispiele decken drei Hauptszenarien ab: Abrufen des Status einer bestimmten Ladung, Auflisten der verfügbaren Last und Abrufen detaillierter IDs Statusinformationen für eine bestimmte Last. ## Beispiel für eine Ladestatusanforderung Dies ist eine Anforderung, die über HTTP `GET` mit dem Befehl `curl` gesendet wird. ``` curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)' ``` **Example Antwort** ``` { "status" : "200 OK", "payload" : { "feedCount" : [ { "LOAD_FAILED" : 1 } ], "overallStatus" : { "datatypeMismatchErrors" : 0, "fullUri" : "s3://bucket/key", "insertErrors" : 0, "parsingErrors" : 5, "retryNumber" : 0, "runNumber" : 1, "status" : "LOAD_FAILED", "totalDuplicates" : 0, "totalRecords" : 5, "totalTimeSpent" : 3.0 } } } ``` ## Beispiel für eine loadIds-Anforderung Dies ist eine Anforderung, die über HTTP `GET` mit dem Befehl `curl` gesendet wird. ``` curl -X GET 'https://your-neptune-endpoint:port/loader?limit=3' ``` **Example Antwort** ``` { "status" : "200 OK", "payload" : { "loadIds" : [ "a2c0ce44-a44b-4517-8cd4-1dc144a8e5b5", "09683a01-6f37-4774-bb1b-5620d87f1931", "58085eb8-ceb4-4029-a3dc-3840969826b9" ] } } ``` ## Beispiel für eine Detailstatusanforderung Dies ist eine Anforderung, die über HTTP `GET` mit dem Befehl `curl` gesendet wird. ``` curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)?details=true' ``` **Example Antwort** ``` { "status" : "200 OK", "payload" : { "failedFeeds" : [ { "datatypeMismatchErrors" : 0, "fullUri" : "s3://bucket/key", "insertErrors" : 0, "parsingErrors" : 5, "retryNumber" : 0, "runNumber" : 1, "status" : "LOAD_FAILED", "totalDuplicates" : 0, "totalRecords" : 5, "totalTimeSpent" : 3.0 } ], "feedCount" : [ { "LOAD_FAILED" : 1 } ], "overallStatus" : { "datatypeMismatchErrors" : 0, "fullUri" : "s3://bucket/key", "insertErrors" : 0, "parsingErrors" : 5, "retryNumber" : 0, "runNumber" : 1, "status" : "LOAD_FAILED", "totalDuplicates" : 0, "totalRecords" : 5, "totalTimeSpent" : 3.0 } } } ``` # Neptune Loader-Beispiele Get-Status `errorLogs` Die folgenden Beispiele zeigen die detaillierte Statusantwort des Neptune-Loaders, wenn beim Laden der Daten Fehler aufgetreten sind. Die Beispiele veranschaulichen die Struktur der Antwort, einschließlich Informationen über fehlgeschlagene Feeds, den Gesamtstatus und detaillierte Fehlerprotokolle. ## Beispiel für eine Detailstatusantwort bei Fehlern Dies ist eine Anforderung, die über HTTP `GET` mit `curl` gesendet wird: ``` curl -X GET 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802?details=true&errors=true&page=1&errorsPerPage=3' ``` **Example Beispiel für eine Detailantwort bei Fehlern** Dies ist ein Beispiel für die Antwort, die Sie möglicherweise für die Abfrage oben erhalten, wobei das Objekt `errorLogs` die aufgetretenen Ladefehler auflistet: ``` { "status" : "200 OK", "payload" : { "failedFeeds" : [ { "datatypeMismatchErrors" : 0, "fullUri" : "s3://bucket/key", "insertErrors" : 0, "parsingErrors" : 5, "retryNumber" : 0, "runNumber" : 1, "status" : "LOAD_FAILED", "totalDuplicates" : 0, "totalRecords" : 5, "totalTimeSpent" : 3.0 } ], "feedCount" : [ { "LOAD_FAILED" : 1 } ], "overallStatus" : { "datatypeMismatchErrors" : 0, "fullUri" : "s3://bucket/key", "insertErrors" : 0, "parsingErrors" : 5, "retryNumber" : 0, "runNumber" : 1, "status" : "LOAD_FAILED", "totalDuplicates" : 0, "totalRecords" : 5, "totalTimeSpent" : 3.0 }, "errors" : { "endIndex" : 3, "errorLogs" : [ { "errorCode" : "PARSING_ERROR", "errorMessage" : "Expected '<', found: |", "fileName" : "s3://bucket/key", "recordNum" : 1 }, { "errorCode" : "PARSING_ERROR", "errorMessage" : "Expected '<', found: |", "fileName" : "s3://bucket/key", "recordNum" : 2 }, { "errorCode" : "PARSING_ERROR", "errorMessage" : "Expected '<', found: |", "fileName" : "s3://bucket/key", "recordNum" : 3 } ], "loadId" : "0a237328-afd5-4574-a0bc-c29ce5f54802", "startIndex" : 1 } } } ``` ## Beispiel für den Fehler `Data prefetch task interrupted` Wenn Sie den Status `LOAD_FAILED` erhalten und anschließend detailliertere Informationen anfordern, kann als Fehler `PARSING_ERROR` mit der Meldung `Data prefetch task interrupted` zurückgegeben werden: ``` "errorLogs" : [ { "errorCode" : "PARSING_ERROR", "errorMessage" : "Data prefetch task interrupted: Data prefetch task for 11467 failed", "fileName" : "s3://amzn-s3-demo-bucket/some-source-file", "recordNum" : 0 } ] ``` Dieser Fehler tritt bei einer temporären Unterbrechung des Datenladevorgangs auf, die in der Regel nicht durch Ihre Anforderung oder Ihre Daten verursacht wurde. Er kann in der Regel behoben werden, indem Sie einfach die Massen-Upload-Anforderung wiederholen. Wenn Sie Standardeinstellungen verwenden, nämlich `"mode":"AUTO"` und `"failOnError":"TRUE"`, überspringt der Loader Dateien, die er bereits erfolgreich geladen hat und fährt mit dem Laden von Dateien fort, die noch nicht geladen wurden, als die Unterbrechung stattfand. # Neptune-Loader – Auftrag abbrechen Bricht einen Ladeauftrag ab. Zum Abbrechen eines Auftrags müssen Sie eine HTTP-`DELETE`-Anforderung an den `https://your-neptune-endpoint:port/loader`-Endpunkt senden. Die `loadId` kann dem `/loader`-URL-Pfad vorangestellt werden oder als Variable in der URL eingeschlossen werden. ## Anforderungssyntax – Auftrag abbrechen ``` DELETE https://your-neptune-endpoint:port/loader?loadId=loadId ``` ``` DELETE https://your-neptune-endpoint:port/loader/loadId ``` ## Anforderungsparameter – Auftrag abbrechen **loadId** Die ID des Ladeauftrags. ## Antwortsyntax– Auftrag abbrechen ``` no response body ``` **200 OK** Bei erfolgreicher Löschung eines Ladeauftrags wird der Code `200` zurückgegeben. ## Fehler– Auftrag abbrechen Wenn ein Fehler auftritt, wird ein JSON-Objekt im `BODY` der Antwort zurückgegeben. Das `message`-Objekt enthält eine Beschreibung des Fehlers. **Fehlerkategorien** + **`Error 400`**   –   Eine ungültige `loadId` gibt den HTTP-Fehler `400` für ungültige Anforderungen zurück. Die Nachricht beschreibt den Fehler. + **`Error 500`**   –   Eine gültige Anforderung, die nicht verarbeitet werden kann, gibt den internen HTTP-Serverfehler `500` zurück. Die Nachricht beschreibt den Fehler. ## Fehlermeldungen – Auftrag abbrechen Im Folgenden sind mögliche Fehlermeldungen der Abbruch-API mit einer Beschreibung des jeweiligen Fehlers aufgeführt. + `The load with id = load_id does not exist or not active` (HTTP 404)   –   Der Ladevorgang wurde nicht gefunden. Prüfen Sie den Wert des `id`-Parameters. + `Load cancellation is not permitted on a read replica instance.` (HTTP 405)   –   Laden ist ein Schreibvorgang. Versuchen Sie erneut, den read/write Cluster-Endpunkt zu laden. ## Beispiele   –   Auftrag stornieren **Example Anforderung** Dies ist eine Anforderung, die über HTTP `DELETE` mit dem Befehl `curl` gesendet wird. ``` curl -X DELETE 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802' ``` # Wird verwendet AWS Database Migration Service , um Daten aus einem anderen Datenspeicher in Amazon Neptune zu laden AWS Database Migration Service (AWS DMS) kann Daten aus [unterstützten Quelldatenbanken](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.html) schnell und sicher in Neptune laden. Die Quelldatenbank bleibt während der Migration voll betriebsbereit, wodurch die Ausfallzeiten für Anwendungen, die von ihr abhängig sind, minimiert werden. Detaillierte Informationen dazu finden Sie AWS DMS im [AWS Database Migration Service Benutzerhandbuch](https://docs.aws.amazon.com/dms/latest/userguide/) und in der [AWS Database Migration Service API-Referenz](https://docs.aws.amazon.com/dms/latest/APIReference/). In [Verwenden von Neptune als Ziel für AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.Neptune.html) erfahren Sie, wie Sie einen Neptune-Cluster als Ziel für die Migration einrichten können. Dies sind einige Voraussetzungen für den Import von Daten in Neptune mit AWS DMS: + Sie müssen ein AWS DMS Tabellenzuordnungsobjekt erstellen, um zu definieren, wie Daten aus der Quelldatenbank extrahiert werden sollen (weitere Informationen finden Sie unter [Angabe der Tabellenauswahl und der Transformationen durch Tabellenzuordnung mithilfe von JSON](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.html#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation) im AWS DMS Benutzerhandbuch). Dieses Tabellenzuweisungs-Konfigurationsobjekt gibt an, welche Tabellen in welcher Reihenfolge gelesen werden sollen und wie ihre Spalten benannt werden. Es kann auch die zu kopierenden Zeilen filtern und einfache Werttransformationen bereitstellen, wie zum Beispiel das Konvertieren in Kleinbuchstaben oder Rundungen. + Sie müssen eine `GraphMappingConfig` in Neptune erstellen, um anzugeben, wie die aus der Quelldatenbank extrahierten Daten in Neptune geladen werden sollen. Für RDF-Daten (mit SPARQL abgefragt) wird `GraphMappingConfig` in der Standard-Zuweisungssprache [R2RM](https://www.w3.org/TR/r2rml/) von W3 geschrieben. Bei Eigenschaftsdiagrammdaten (abgefragt mit Gremlin) handelt es sich bei `GraphMappingConfig` um ein JSON-Objekt, das unter [GraphMappingConfig Layout für Eigenschaftsdiagramme/Gremlin-Daten](dms-neptune-graph-mapping.md#dms-neptune-graph-mapping-gremlin) beschrieben wird. + Sie müssen verwenden AWS DMS , um eine Replikationsinstanz in derselben VPC wie Ihr Neptune-DB-Cluster zu erstellen, um die Datenübertragung zu vermitteln. + Außerdem benötigen Sie einen Amazon–S3-Bucket als Zwischenspeicher für die Bereitstellung der Migrationsdaten. # Einen Neptune erschaffen GraphMappingConfig Die von Ihnen erstellte `GraphMappingConfig` gibt an, wie aus einem Quelldatenspeicher extrahierte Daten in einen Neptune-DB-Cluster geladen werden sollen. Das Format ist davon abhängig, ob sie zum Laden von RDF-Daten oder zum Laden von Eigenschaftsdiagrammdaten verwendet wird. Für RDF-Daten können Sie die W3-Sprache [R2RML](https://www.w3.org/TR/r2rml/) verwenden, um relationale Daten zu RDF zuzuordnen. Wenn Sie Eigenschaftsdiagrammdaten laden, die mit Gremlin abgefragt werden sollen, erstellen Sie ein JSON-Objekt für `GraphMappingConfig`. ## GraphMappingConfig Layout für Daten RDF/SPARQL Wenn Sie RDF-Daten laden, die mit SPARQL abgefragt werden sollen, schreiben Sie die `GraphMappingConfig` in [R2RML](https://www.w3.org/TR/r2rml/). `R2RML` ist eine Standard-W3-Sprache für die Zuweisung relationaler Daten zu RDF. Hier ist ein Beispiel: ``` @prefix rr: . @prefix ex: . <#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 Folgenden ein weiteres Beispiel: ``` @prefix rr: . @prefix ex: . @prefix foaf: . @prefix xsd: . <#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" ] ] . ``` Die W3-Empfehlung unter [R2RML: RDB to RDF Mapping Language](https://www.w3.org/TR/r2rml/) enthält Details zu dieser Sprache. ## GraphMappingConfig Layout für Eigenschaftsdiagramme/Gremlin-Daten Ein vergleichbarer `GraphMappingConfig` für Eigenschaftsdiagrammdaten ist ein JSON-Objekt, das eine Zuweisungsregel für jede aus den Quelldaten generierte Diagrammentität bereitstellt. 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)" } ] } ] } ] } ``` Beachten Sie, dass das Vorhandensein einer Vertex-Beschriftung impliziert, dass die Vertex hier erstellt wird, während ihre Abwesenheit impliziert, dass die Vertex von einer anderen Quelle erstellt wird und diese Definition nur Vertexeigenschaften hinzufügt. Hier ist eine Beispielregel für einen Mitarbeiterdatensatz: ``` { "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" } ] } ] } ] } ``` # Erstellen einer AWS DMS Replikationsaufgabe mit Neptune als Ziel Nach der Erstellung der Konfigurationen für die Tabellen- und Diagrammzuordnung verwenden Sie den folgenden Prozess, um Daten aus dem Quellspeicher in Neptune zu laden. Weitere Informationen zu dem AWS DMS fraglichen Problem finden Sie APIs in der Dokumentation. ## Erstellen Sie eine AWS DMS Replikationsinstanz Erstellen Sie eine AWS DMS Replikationsinstanz in der VPC, in der Ihr Neptune-DB-Cluster läuft (siehe [Arbeiten mit einer AWS DMS-Replikationsinstanz](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html) und [CreateReplicationInstance](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationInstance.html)im AWS DMS Benutzerhandbuch). Dazu können Sie einen AWS CLI Befehl wie den folgenden verwenden: ``` aws dms create-replication-instance \ --replication-instance-identifier (the replication instance identifier) \ --replication-instance-class (the size and capacity of the instance, like 'dms.t2.medium') \ --allocated-storage (the number of gigabytes to allocate for the instance initially) \ --engine-version (the DMS engine version that the instance should use) \ --vpc-security-group-ids (the security group to be used with the instance) ``` ## Erstellen Sie einen AWS DMS Endpunkt für die Quelldatenbank Der nächste Schritt besteht darin, einen AWS DMS Endpunkt für Ihren Quelldatenspeicher zu erstellen. Sie können die AWS DMS [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)API AWS CLI wie folgt verwenden: ``` aws dms create-endpoint \ --endpoint-identifier (source endpoint identifier) \ --endpoint-type source \ --engine-name (name of source database engine) \ --username (user name for database login) \ --password (password for login) \ --server-name (name of the server) \ --port (port number) \ --database-name (database name) ``` ## Richten Sie einen Amazon S3 S3-Bucket für Neptune ein, der für das Staging-Daten verwendet werden soll Wenn Sie keinen Amazon-S3-Bucket haben, den Sie für Staging-Daten verwenden können, erstellen Sie einen Bucket wie in [Erstellen eines Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) im Handbuch für die ersten Schritte mit Amazon S3 oder in [Wie erstelle ich einen S3-Bucket?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html) im Konsolen-Benutzerhandbuch beschrieben. Sie müssen eine IAM-Richtlinie erstellen, die `GetObject`, `PutObject`, `DeleteObject` und `ListObject` Berechtigungen für den Bucket gewährt, wenn noch nicht geschehen. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "ListObjectsInBucket", "Effect": "Allow", "Action": [ "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket" ] }, { "Sid": "AllObjectActions", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:PutObject", "s3:DeleteObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/*" ] } ] } ``` ------ Wenn für Ihren Neptune-DB-Cluster die IAM-Authentifizierung aktiviert ist, müssen Sie außerdem die folgende Richtlinie einschließen: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": "neptune-db:*", "Resource": "arn:aws:neptune-db:us-east-1:111122223333:cluster-resource-id/*" } ] } ``` ------ Erstellen Sie eine IAM-Rolle als Vertrauensdokument, an das Sie die Richtlinie anfügen können: ------ #### [ JSON ] **** ``` { "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" } ] } ``` ------ Nachdem Sie der Rolle die Richtlinie angefügt haben, fügen Sie die Rolle Ihrem Neptune-DB-Cluster an. Dadurch kann AWS DMS der Bucket für das Staging der geladenen Daten verwendet werden. ## Erstellen Sie einen Amazon S3 S3-Endpunkt in der Neptune VPC Erstellen Sie jetzt einen VPC-Gateway-Endpunkt für Ihren Amazon-S3-Zwischen-Bucket in der VPC, in der sich Ihr Neptune-Cluster befindet. Sie können AWS CLI dazu das AWS-Managementkonsole oder das verwenden, wie unter [Einen Gateway-Endpunkt erstellen](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-gateway.html#create-gateway-endpoint) beschrieben. ## Erstellen Sie einen AWS DMS Zielendpunkt für Neptune Erstellen Sie einen AWS DMS Endpunkt für Ihren Neptune-DB-Zielcluster. Sie können die AWS DMS [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)API mit dem folgenden `NeptuneSettings` Parameter verwenden: ``` aws dms create-endpoint \ --endpoint-identifier (target endpoint identifier) \ --endpoint-type target \ --engine-name neptune \ --server-name (name of the server) \ --port (port number) \ --neptune-settings '{ \ "ServiceAccessRoleArn": "(ARN of the service access role)", \ "S3BucketName": "(name of S3 bucket to use for staging files when migrating)", \ "S3BucketFolder": "(name of the folder to use in that S3 bucket)", \ "ErrorRetryDuration": (number of milliseconds to wait between bulk-load retries), \ "MaxRetryCount": (the maximum number of times to retry a failing bulk-load job), \ "MaxFileSize": (maximum file size, in bytes, of the staging files written to S3), \ "IamAuthEnabled": (set to true if IAM authentication is enabled on the Neptune cluster) }' ``` Das in seinem `NeptuneSettings` Parameter an die AWS DMS `CreateEndpoint` API übergebene JSON-Objekt hat die folgenden Felder: **** + **`ServiceAccessRoleArn`**   –   *(erforderlich)* Der ARN einer IAM-Rolle, die einen detaillierten Zugriff auf den S3-Bucket ermöglicht, der für die Migration der Daten zu Neptune verwendet wird. Diese Rolle sollte auch Berechtigungen für den Zugriff auf Ihren Neptune-DB-Cluster haben, wenn die IAM-Autorisierung für ihn aktiviert ist. + **`S3BucketName`**   –   *(erforderlich)* Für eine Volllast-Migration konvertiert die Replikations-Instance alle RDS-Daten in CSV- und Quad-Dateien und lädt sie zu diesem S3-Staging-Bucket und anschließend per Massenladevorgang zu Neptune hoch. + **`S3BucketFolder`**   –   *(erforderlich)* Der Ordner, der im S3-Staging-Bucket verwendet werden soll. + **`ErrorRetryDuration`**   –   *(optional)* Die Anzahl der Millisekunden, die nach dem Fehlschlag einer Neptune-Anforderung gewartet werden muss, bevor sie wiederholt werden kann. Der Standardwert ist 250. + **`MaxRetryCount`**— *(optional)* Die maximale Anzahl von Wiederholungsanfragen, die nach einem wiederholten Fehler gestellt werden AWS DMS sollten. Der Standardwert ist 5. + **`MaxFileSize`**   –   *(optional)* Die maximale Größe in Byte für jede Staging-Datei, die während der Migration in S3 gespeichert wurde. Der Standardwert ist 1.048.576 KB (1 GB) + **`IsIAMAuthEnabled`** *  *(optional)`true` Auf festgelegt, wenn IAM-Authentifizierung für den Neptune-DB-Cluster aktiviert ist, andernfalls auf `false`. Der Standardwert ist `false`. ## Testen Sie die Verbindungen zu den neuen Endpunkten Sie können die Verbindung zu jedem dieser neuen Endpunkte mithilfe der AWS DMS [TestConnection](https://docs.aws.amazon.com/dms/latest/APIReference/API_TestConnection.html)API wie folgt testen: ``` aws dms test-connection \ --replication-instance-arn (the ARN of the replication instance) \ --endpoint-arn (the ARN of the endpoint you are testing) ``` ## Erstellen Sie eine AWS DMS Replikationsaufgabe Nachdem Sie die vorherigen Schritte erfolgreich abgeschlossen haben, erstellen Sie eine Replikationsaufgabe für die Migration von Daten aus Ihrem Quelldatenspeicher nach Neptune, indem Sie die AWS DMS [CreateReplicationTask](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationTask.html.html)API wie folgt verwenden: ``` aws dms create-replication-task \ --replication-task-identifier (name for the replication task) \ --source-endpoint-arn (ARN of the source endpoint) \ --target-endpoint-arn (ARN of the target endpoint) \ --replication-instance-arn (ARN of the replication instance) \ --migration-type full-load \ --table-mappings (table-mapping JSON object or URI like 'file:///tmp/table-mappings,json') \ --task-data (a GraphMappingConfig object or URI like 'file:///tmp/graph-mapping-config.json') ``` Der Parameter `TaskData` stellt die [GraphMappingConfig](dms-neptune-graph-mapping.md) bereit, die angibt, wie die kopierten Daten in Neptune gespeichert werden sollen. ## Starten Sie die Replikationsaufgabe AWS DMS Jetzt können Sie die Replikationsaufgabe starten: ``` aws dms start-replication-task --replication-task-arn (ARN of the replication task started in the previous step) --start-replication-task-type start-replication ``` # Daten mithilfe von Abfragen in Amazon Neptune laden Neptune unterstützt das direkte Schreiben von Daten über Abfragesprachenoperationen. Sie können Standard-Schreiboperationen wie `CREATE` und `MERGE` in OpenCypher, `INSERT` SPARQL oder Gremlin verwenden, um Daten `mergeE()` in `mergeV()` Ihrem Diagramm hinzuzufügen oder zu ändern. Diese Operationen eignen sich für inkrementelle Aktualisierungen und transaktionale Schreibvorgänge. Verwenden Sie zum Laden von Daten aus Amazon S3 den [Verwenden des Amazon Neptune Bulk Loaders zur Datenaufnahme](bulk-load.md) für große Datensätze, die eine optimierte Leistung erfordern. Für kleinere Datensätze in einer oder mehreren Amazon S3-Dateien können Sie abfragebasierte Ladefunktionen verwenden, um Daten direkt in Ihren Abfragen zu lesen und zu verarbeiten. Die folgenden abfragebasierten Ladefunktionen sind verfügbar: ## OpenCypher: neptune.read () Die `neptune.read()` Funktion liest CSV- oder Parquet-Dateien aus Amazon S3 innerhalb einer `CALL` Unterabfrage, sodass Sie Daten zur Abfragezeit verarbeiten und laden können. ``` CALL neptune.read({ source: "s3://bucket/data.csv", format: "csv" }) YIELD row CREATE (n:Person {id: row.id, name: row.name}) ``` Eine vollständige Dokumentation finden Sie unter[neptune.read ()](access-graph-opencypher-21-extensions-s3-read.md). ## SPARQL: LADEN und ENTLADEN `LOAD`SPARQL-Operationen importieren RDF-Daten von einer URI in ein benanntes Diagramm. `UNLOAD`exportiert Daten aus einem Diagramm nach Amazon S3. ``` LOAD INTO GRAPH ``` Eine vollständige Dokumentation finden Sie unter[Verwenden von SPARQL UPDATE LOAD zum Importieren von Daten in Neptune](sparql-api-reference-update-load.md). ## Gremlin: io () -Schritt Sie können Gremlins `g.io(URL).read()` Step auch verwenden, um Datendateien in [GraphML (einem XML-Format), [GraphSon](https://tinkerpop.apache.org/docs/current/dev/io/#graphson)](https://tinkerpop.apache.org/docs/current/dev/io/#graphml) (einem JSON-Format) und anderen Formaten einzulesen. ``` g.io("s3://bucket/data.graphml").read().iterate() ``` [Einzelheiten finden Sie in der DokumentationTinkerPop.](https://tinkerpop.apache.org/docs/current/reference/#io-step)