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