Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Documentazione di riferimento dello strumento di caricamento Neptune
Questa sezione descrive i prodotti `Loader` APIs per Amazon Neptune disponibili dall'endpoint HTTP di un'istanza DB Neptune.
**Nota**
Vedi [Messaggi di feed e di errore dello strumento di caricamento Neptune](loader-message.md) per un elenco dei messaggi di errore e di feed restituiti dallo strumento di caricamento in caso di errori.
**Contents**
+ [Comando dello strumento di caricamento Neptune](load-api-reference-load.md)
+ [Sintassi della richiesta dello strumento di caricamento Neptune](load-api-reference-load.md#load-api-reference-load-syntax)
+ [Parametri della richiesta dello dello strumento di caricamento Neptune](load-api-reference-load.md#load-api-reference-load-parameters)
+ [Considerazioni speciali per il caricamento dei dati openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher)
+ [Sintassi della risposta dello strumento di caricamento Neptune](load-api-reference-load.md#load-api-reference-load-return)
+ [Errori dello strumento di caricamento Neptune](load-api-reference-load-errors.md)
+ [Esempi di strumento di caricamento Neptune](load-api-reference-load-examples.md)
+ [API Neptune Loader Get-Status](load-api-reference-status.md)
+ [Richieste Neptune Loader Get-Status](load-api-reference-status-requests.md)
+ [Sintassi della richiesta Loader Get-Status](load-api-reference-status-requests.md#load-api-reference-status-request-syntax)
+ [Parametri della richiesta di Get-Status Neptune Loader](load-api-reference-status-requests.md#load-api-reference-status-parameters)
+ [Risposte del Neptune Loader Get-Status](load-api-reference-status-response.md)
+ [Layout JSON di Neptune Loader Get-Status Response](load-api-reference-status-response.md#load-api-reference-status-response-layout)
+ [Neptune Loader Get-Status `overallStatus` e oggetti di risposta `failedFeeds`](load-api-reference-status-response.md#load-api-reference-status-response-objects)
+ [Oggetto di risposta Get-Status `errors` Neptune Loader](load-api-reference-status-response.md#load-api-reference-status-errors)
+ [Oggetto di risposta Get-Status `errorLogs` Neptune Loader](load-api-reference-status-response.md#load-api-reference-error-logs)
+ [Esempi di Neptune Loader Get-Status](load-api-reference-status-examples.md)
+ [Esempio di richiesta dello stato di caricamento](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request)
+ [Esempio di richiesta di loadIds](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request)
+ [Esempio di richiesta dello stato dettagliato](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request)
+ [Esempi di Neptune Loader Get-Status `errorLogs`](load-api-reference-error-logs-examples.md)
+ [Esempio di risposta di stato dettagliata in caso di errori](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors)
+ [Esempio di un errore `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted)
+ [Annullamento di un processo dello strumento di caricamento Neptune](load-api-reference-cancel.md)
+ [Sintassi della richiesta di annullamento di un processo](load-api-reference-cancel.md#load-api-reference-cancel-syntax)
+ [Parametri della richiesta del processo di annullamento](load-api-reference-cancel.md#load-api-reference-cancel-parameters)
+ [Sintassi della risposta del processo di annullamento](load-api-reference-cancel.md#load-api-reference-cancel-parameters-response)
+ [Errori del processo di annullamento](load-api-reference-cancel.md#load-api-reference-cancel-parameters-errors)
+ [Messaggi di errore del processo di annullamento](load-api-reference-cancel.md#load-api-reference-cancel-parameters-errors-messages)
+ [Esempi del processo di annullamento](load-api-reference-cancel.md#load-api-reference-cancel-examples)
# Comando dello strumento di caricamento Neptune
Carica i dati da un bucket Amazon S3 in un'istanza database Neptune.
Per caricare i dati è necessario inviare una richiesta HTTP `POST` all'endpoint `https://your-neptune-endpoint:port/loader`. I parametri per la richiesta `loader` possono essere inviati nel corpo `POST` corpo o come parametri di codifica URL.
**Importante**
Il tipo MIME deve essere `application/json`.
Il bucket Amazon S3 deve trovarsi nella stessa AWS regione del cluster.
**Nota**
È possibile caricare i dati crittografati da Amazon S3 se sono stati crittografati utilizzando la modalità `SSE-S3` di Amazon S3. In questo caso, Neptune è in grado di impersonare le credenziali dell'utente e di effettuare chiamate a `s3:getObject` per conto dell'utente.
È possibile anche caricare i dati crittografati da Amazon S3 che sono stati crittografati utilizzando la modalità `SSE-KMS`, purché il ruolo IAM includa le autorizzazioni necessarie per accedere a AWS KMS. Senza AWS KMS le autorizzazioni appropriate, l'operazione di caricamento in blocco non riesce e restituisce una risposta. `LOAD_FAILED`
Neptune non supporta attualmente il caricamento di dati Amazon S3 crittografati utilizzando la modalità `SSE-C`.
Non è necessario attendere il completamento di un processo di caricamento prima di iniziarne un altro. Neptune può accodare fino a 64 richieste di processo alla volta, a condizione che i relativi parametri `queueRequest` siano tutti impostati su `"TRUE"`. L'ordine di coda dei lavori sarà first-in-first-out (FIFO). Se invece non si desidera che un processo di caricamento sia messo in coda, è possibile impostare il relativo parametro `queueRequest` su `"FALSE"` (valore predefinito), in modo che il caricamento abbia esito negativo se ne è già in corso un altro.
È possibile utilizzare il parametro `dependencies` per accodare un'attività che deve essere eseguita solo dopo che le attività precedenti specificate nella coda sono state completate correttamente. Se si esegue questa operazione e uno qualsiasi di queste attività specificate non riesce, l'attività non verrà eseguita e il relativo stato verrà impostato su `LOAD_FAILED_BECAUSE_DEPENDENCY_NOT_SATISFIED`.
## Sintassi della richiesta dello strumento di caricamento Neptune
```
{
"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 Sintassi**
Per un`edgeOnlyLoad`, la sintassi sarebbe:
```
{
"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"]
}
```
## Parametri della richiesta dello dello strumento di caricamento Neptune
+ **`source`**: URI Amazon S3.
Il parametro `SOURCE` accetta un URI Amazon S3 che identifica un singolo file, più file, una cartella o più cartelle. Neptune carica ogni file di dati in qualsiasi cartella specificata.
l'URI può essere in uno dei seguenti formati.
+ `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`
L'`object-key-name`elemento dell'URI è equivalente al parametro [prefix](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html#API_ListObjects_RequestParameters) in una chiamata API Amazon [ListObjects](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html)S3. Identifica tutti gli oggetti nel bucket Amazon S3 specificato i cui nomi iniziano con il prefisso specificato. Può trattarsi di un singolo file o cartella o di più cartelle di file and/or .
La cartella o le cartelle specificate possono contenere più file di vertici e più file di archi.
Ad esempio, se avevi la seguente struttura di cartelle e i seguenti file in un bucket Amazon S3 denominato: `bucket-name`
```
s3://bucket-name/a/bc
s3://bucket-name/ab/c
s3://bucket-name/ade
s3://bucket-name/bcd
```
Se il parametro source è specificato come`s3://bucket-name/a`, verranno caricati i primi tre file.
```
s3://bucket-name/a/bc
s3://bucket-name/ab/c
s3://bucket-name/ade
```
+ **`format`**: formato dei dati. Per ulteriori informazioni sui formati di dati per il comando Neptune `Loader`, vedi [Utilizzo del bulk loader Amazon Neptune per importare dati](bulk-load.md).
**Valori consentiti**
+ **`csv`** per il [formato dei dati CSV Gremlin](bulk-load-tutorial-format-gremlin.md).
+ **`opencypher`** per il [formato dei dati CSV openCypher](bulk-load-tutorial-format-opencypher.md).
+ **`ntriples`** per il [formato dei dati N-Triples RDF](https://www.w3.org/TR/n-triples/).
+ **`nquads`** per il [formato dei dati N-Quads RDF](https://www.w3.org/TR/n-quads/).
+ **`rdfxml`** per il [formato dei dati RDF\$1XML RDF](https://www.w3.org/TR/rdf-syntax-grammar/).
+ **`turtle`** per il [formato dei dati Turtle RDF](https://www.w3.org/TR/turtle/).
+ **`iamRoleArn`**: nome della risorsa Amazon (ARN) per un ruolo IAM che deve essere assunto dall'istanza database Neptune per l'accesso al bucket S3. Per informazioni su come creare un ruolo che abbia accesso ad Amazon S3 e su come associarlo a un cluster Neptune, vedi [Prerequisiti: ruolo IAM e accesso ad Amazon S3](bulk-load-tutorial-IAM.md).
A partire dalla [versione 1.2.1.0.R3 del motore](engine-releases-1.2.1.0.R3.md), puoi anche concatenare più ruoli IAM se l'istanza DB Neptune e il bucket Amazon S3 si trovano in account diversi. AWS In questo caso, `iamRoleArn` contiene un elenco di ruoli separati da virgole, come descritto in. ARNs [Concatenazione di ruoli IAM in Amazon Neptune](bulk-load-tutorial-chain-roles.md) Esempio:
```
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`**— Il `region` parametro deve corrispondere alla AWS regione del cluster e al bucket S3.
Amazon Neptune è disponibile nelle seguenti regioni :
+ Stati Uniti orientali (Virginia settentrionale): `us-east-1`
+ Stati Uniti orientali (Ohio): `us-east-2`
+ Stati Uniti occidentali (California settentrionale): `us-west-1`
+ Stati Uniti occidentali (Oregon): `us-west-2`
+ Canada (Centrale): `ca-central-1`
+ Canada occidentale (Calgary): `ca-west-1`
+ Sud America (San Paolo): `sa-east-1`
+ Europa (Stoccolma): `eu-north-1`
+ Europa (Spagna): `eu-south-2`
+ Europa (Irlanda): `eu-west-1`
+ Europa (Londra): `eu-west-2`
+ Europa (Parigi): `eu-west-3`
+ Europa (Francoforte): `eu-central-1`
+ Medio Oriente (Bahrein): `me-south-1`
+ Medio Oriente (Emirati Arabi Uniti): `me-central-1`
+ Israele (Tel Aviv): `il-central-1`
+ Africa (Città del Capo): `af-south-1`
+ Asia Pacifico (Hong Kong): `ap-east-1`
+ Asia Pacifico (Tokyo): `ap-northeast-1`
+ Asia Pacifico (Seoul): `ap-northeast-2`
+ Asia Pacifico (Osaka): `ap-northeast-3`
+ Asia Pacifico (Singapore): `ap-southeast-1`
+ Asia Pacifico (Sydney): `ap-southeast-2`
+ Asia Pacifico (Giacarta): `ap-southeast-3`
+ Asia Pacifico (Melbourne): `ap-southeast-4`
+ Asia Pacifico (Malesia): `ap-southeast-5`
+ Asia Pacifico (Mumbai): `ap-south-1`
+ Asia Pacifico (Hyderabad): `ap-south-2`
+ Cina (Pechino): `cn-north-1`
+ Cina (Ningxia): `cn-northwest-1`
+ AWS GovCloud (Stati Uniti occidentali): `us-gov-west-1`
+ AWS GovCloud (Stati Uniti orientali): `us-gov-east-1`
+ **`mode`**: modalità del processo di caricamento.
*Valori consentiti*: `RESUME`, `NEW`, `AUTO`.
*Valore predefinito*: `AUTO`
****
+ `RESUME`: in modalità RESUME, lo strumento di caricamento cerca un caricamento precedente da questa origine e, se ne trova uno, riprende l'attività di caricamento. Se non viene trovata alcuna attività di caricamento precedente, il loader si arresta.
Il loader evita di ricaricare i file caricati correttamente in un'attività precedente. Tenta di elaborare solo i file non caricati. Se sono stati eliminati i dati caricati in precedenza dal cluster Neptune, tali dati non vengono ricaricati in questa modalità. Se un processo di caricamento precedente ha caricato correttamente tutti i file dalla stessa origine, nulla viene ricaricato e lo strumento di caricamento restituisce un risultato positivo.
+ `NEW`: in modalità NEW viene creata una nuova richiesta di caricamento, indipendentemente da eventuali caricamenti precedenti. Questa modalità può essere utilizzata per ricaricare tutti i dati provenienti da un'origine dopo che sono stati eliminati dati caricati precedentemente dal cluster Neptune o per caricare nuovi dati disponibili nella stessa origine.
+ `AUTO`: in modalità AUTO, lo strumento di caricamento cerca un'attività di caricamento precedente dalla stessa origine e, se ne trova una, riprende tale attività, proprio come in modalità `RESUME`.
Se il loader non trova un'attività di caricamento precedente dalla stessa origine, carica tutti i dati dall'origine, proprio come in modalità `NEW`.
+ **`edgeOnlyLoad`**— Un flag che controlla l'ordine di elaborazione dei file durante il caricamento in blocco.
*Valori consentiti:* `"TRUE"`, `"FALSE"`.
*Valore predefinito*: `"FALSE"`.
Quando questo parametro è impostato su «FALSE», il loader carica automaticamente prima i file di vertici, poi i file edge. A tale scopo, esegue prima la scansione di tutti i file per determinarne il contenuto (vertici o bordi). Quando questo parametro è impostato su «TRUE», il loader salta la fase di scansione iniziale e carica immediatamente tutti i file nell'ordine in cui appaiono. Per ulteriori informazioni, consulta [Bulk](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-optimize.html) Load Optimize.
+ **`failOnError`**: un flag per attivare un arresto completo in caso di errore.
*Valori consentiti:* `"TRUE"`, `"FALSE"`.
*Valore predefinito*: `"TRUE"`.
Quando questo parametro è impostato su `"FALSE"`, il loader tenta di caricare tutti i dati nella posizione specificata, saltando eventuali voci con errori.
Quando questo parametro è impostato su `"TRUE"`, il loader si arresta non appena rileva un errore. I dati caricati fino a quel punto persistono.
+ **`parallelism`**: si tratta di un parametro facoltativo che può essere impostato per ridurre il numero di thread utilizzati dal processo di caricamento in blocco.
*Valori consentiti*:
+ `LOW`— Il numero di thread utilizzati è il numero di v disponibili CPUs diviso per 8.
+ `MEDIUM`— Il numero di thread utilizzati è il numero di v disponibili CPUs diviso per 2.
+ `HIGH`— Il numero di thread utilizzati è uguale al numero di v disponibili. CPUs
+ `OVERSUBSCRIBE`— Il numero di thread utilizzati è il numero di v disponibili CPUs moltiplicato per 2. Se viene utilizzato questo valore, il bulk loader occupa tutte le risorse disponibili.
Ciò non significa, tuttavia, che l'impostazione `OVERSUBSCRIBE` comporti un utilizzo della CPU al 100%. Poiché l'operazione di caricamento è I/O limitata, l'utilizzo massimo della CPU previsto è compreso tra il 60% e il 70%.
*Valore predefinito*: `HIGH`
L'impostazione `parallelism` a volte può causare un deadlock tra i thread durante il caricamento dei dati openCypher. Quando ciò accade, Neptune restituisce l'errore `LOAD_DATA_DEADLOCK`. Di solito è possibile risolvere il problema impostando `parallelism` su un valore inferiore e riprovando il comando di caricamento.
+ **`parserConfiguration`**: un oggetto opzionale con valori di configurazione del parser aggiuntivi. Ciascuno dei parametri figlio è anche facoltativo:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/load-api-reference-load.html)
Per ulteriori informazioni, consulta [Grafo predefinito SPARQL e grafi denominati](feature-sparql-compliance.md#sparql-default-graph).
+ **`updateSingleCardinalityProperties`**: è un parametro facoltativo che controlla il modo in cui lo strumento di caricamento in blocco tratta un nuovo valore per le proprietà di vertici o archi a cardinalità singola. Non è supportato per il caricamento di dati openCypher (vedi [Caricamento di dati openCypher](#load-api-reference-load-parameters-opencypher)).
*Valori consentiti:* `"TRUE"`, `"FALSE"`.
*Valore predefinito*: `"FALSE"`.
Come impostazione predefinita o quando `updateSingleCardinalityProperties` è impostato esplicitamente su `"FALSE"`, il loader considera un nuovo valore come un errore, perché viola la cardinalità singola.
Quando `updateSingleCardinalityProperties` è impostato invece su `"TRUE"`, il bulk loader sostituisce il valore esistente con quello nuovo. Se valori di proprietà multipli edge o vertice a cardinalità singola vengono forniti nei file di origine caricati, il valore finale alla fine del caricamento in blocco potrebbe essere uno qualsiasi di questi nuovi valori. Il loader garantisce solo che il valore esistente è stato sostituito da uno di quelli nuovi.
+ **`queueRequest`**: si tratta di un parametro flag opzionale che indica se la richiesta di caricamento può essere accodata o meno.
Non è necessario attendere il completamento di un processo di caricamento prima di emettere quello successivo, perché Neptune può accodare fino a 64 processi alla volta, a condizione che i relativi parametri `queueRequest` siano tutti impostati su `"TRUE"`. L'ordine di coda dei lavori sarà first-in-first-out (FIFO).
Se il parametro `queueRequest` viene omesso o impostato su `"FALSE"`, la richiesta di caricamento avrà esito negativo se un'altra attività di caricamento è già in esecuzione.
*Valori consentiti:* `"TRUE"`, `"FALSE"`.
*Valore predefinito*: `"FALSE"`.
+ **`dependencies`**: si tratta di un parametro facoltativo che può rendere subordinata una richiesta di caricamento in coda al completamento di uno o più processi precedenti nella coda.
Neptune può accodare fino a 64 richieste di caricamento alla volta, se i relativi parametri `queueRequest` sono impostati su `"TRUE"`. Il parametro `dependencies` consente di rendere l'esecuzione di tale richiesta in coda dipendente dal completamento corretto di una o più richieste precedenti specificate nella coda.
Ad esempio, se `Job-A` e `Job-B` del caricamento sono indipendenti l'una dall'altra, ma `Job-C` richiede che `Job-A` e `Job-B` siano completate prima del suo avvio, procedere come segue:
1. Inviare `load-job-A` e `load-job-B` una dopo l'altra in qualsiasi ordine e salvare i loro id di caricamento.
1. Inviare `load-job-C` con gli id di caricamento delle due attività nel campo `dependencies`:
```
"dependencies" : ["job_A_load_id", "job_B_load_id"]
```
A causa del parametro `dependencies`, il bulk loader non avvia `Job-C` fino a quando `Job-A` e `Job-B` non sono state completate correttamente. Se una di queste attività non riesce, l'attività non verrà eseguita e il suo stato sarà impostato su `LOAD_FAILED_BECAUSE_DEPENDENCY_NOT_SATISFIED`.
È possibile impostare più livelli di dipendenza in questo modo, in modo che l'errore di un'attività causi l'annullamento di tutte le richieste direttamente o indirettamente dipendenti da essa.
+ **`userProvidedEdgeIds`**— Questo parametro è richiesto solo quando si caricano dati OpenCypher che contengono una relazione. IDs Deve essere incluso e impostato su `True` quando la relazione IDs OpenCypher viene fornita esplicitamente nei dati di caricamento (consigliato).
Se `userProvidedEdgeIds` è assente o è impostato su `True`, in ogni file delle relazioni all'interno del caricamento deve esistere una colonna `:ID`.
Se `userProvidedEdgeIds` è presente ed è impostato su `False`, i file delle relazioni all'interno del caricamento **non devono** contenere una colonna `:ID`. Lo strumento di caricamento Neptune genera automaticamente un ID per ogni relazione.
È utile fornire una relazione in modo IDs esplicito in modo che il caricatore possa riprendere il caricamento dopo la correzione dell'errore nei dati CSV, senza dover ricaricare le relazioni che sono già state caricate. Se la relazione IDs non è stata assegnata in modo esplicito, il loader non può riprendere un caricamento non riuscito se è stato necessario correggere un file di relazione e deve invece ricaricare tutte le relazioni.
+ `accessKey`: **[obsoleto]** ID chiave di accesso di un ruolo IAM con accesso al bucket S3 e ai file di dati.
Il parametro `iamRoleArn` è invece consigliato. Per informazioni su come creare un ruolo che abbia accesso ad Amazon S3 e su come associarlo a un cluster Neptune, vedi [Prerequisiti: ruolo IAM e accesso ad Amazon S3](bulk-load-tutorial-IAM.md).
Per ulteriori informazioni, consulta l'argomento relativo alle [chiavi di accesso (ID chiave di accesso e chiave di accesso segreta)](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys).
+ `secretKey`: **[obsoleto]** il parametro `iamRoleArn` è invece consigliato. Per informazioni su come creare un ruolo che abbia accesso ad Amazon S3 e su come associarlo a un cluster Neptune, vedi [Prerequisiti: ruolo IAM e accesso ad Amazon S3](bulk-load-tutorial-IAM.md).
Per ulteriori informazioni, consulta l'argomento relativo alle [chiavi di accesso (ID chiave di accesso e chiave di accesso segreta)](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys).
### Considerazioni speciali per il caricamento dei dati openCypher
+ Quando si caricano dati openCypher in formato CSV, il parametro format deve essere impostato su `opencypher`.
+ Il parametro `updateSingleCardinalityProperties` non è supportato per i caricamenti openCypher perché tutte le proprietà openCypher hanno cardinalità singola. Il formato di caricamento openCypher non supporta gli array e se un valore ID appare più di una volta, viene considerato un duplicato o un errore di inserimento (vedi sotto).
+ Lo strumento di caricamento Neptune gestisce i duplicati che incontra nei dati openCypher come segue:
+ Se lo strumento di caricamento incontra più righe con lo stesso ID nodo, queste vengono unite utilizzando la seguente regola:
+ Tutte le etichette nelle righe vengono aggiunte al nodo.
+ Per ogni proprietà, viene caricato solo uno dei valori della proprietà. La selezione di quello da caricare non è deterministica.
+ Se lo strumento di caricamento incontra più righe con lo stesso ID relazione, ne viene caricata solo una. La selezione di quella da caricare non è deterministica.
+ Lo strumento di caricamento non aggiorna mai i valori delle proprietà di un nodo o di una relazione esistente nel database se incontra dati di caricamento con l'ID del nodo o della relazione esistente. Tuttavia, carica le etichette e le proprietà dei nodi che non sono presenti nel nodo o nella relazione esistente.
+ Sebbene non sia necessario eseguire assegnazioni IDs alle relazioni, di solito è una buona idea (vedi il parametro sopra riportato). `userProvidedEdgeIds` Senza una relazione esplicita IDs, il caricatore deve ricaricare tutte le relazioni in caso di errore in un file di relazione, anziché riprendere il caricamento dal punto in cui non era riuscito.
Inoltre, se i dati di caricamento non contengono una relazione esplicita IDs, il loader non ha modo di rilevare relazioni duplicate.
Di seguito è illustrato un esempio di un comando di caricamento openCypher:
```
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",
}'
```
La risposta strumento di caricamento è la stessa del normale. Esempio:
```
{
"status" : "200 OK",
"payload" : {
"loadId" : "guid_as_string"
}
}
```
## Sintassi della risposta dello strumento di caricamento Neptune
```
{
"status" : "200 OK",
"payload" : {
"loadId" : "guid_as_string"
}
}
```
**200 OK**
Il processo di caricamento avviato correttamente restituisce il codice `200`.
# Errori dello strumento di caricamento Neptune
Se si verifica un errore, viene restituito un oggetto JSON nel `BODY` della risposta. L'oggetto `message` contiene una descrizione dell'errore.
**Categorie di errore**
+ `Error 400`: gli errori di sintassi restituiscono un errore di richiesta non valida HTTP `400`. Il messaggio descrive l'errore.
+ `Error 500`: una richiesta valida che non può essere elaborata restituisce un errore interno del server HTTP `500`. Il messaggio descrive l'errore.
Di seguito sono riportati i possibili messaggi di errore dello strumento di caricamento con la relativa descrizione.
**Messaggi di errore dello strumento di caricamento**
+ `Couldn't find the AWS credential for iam_role_arn` (HTTP 400)
Non è stato possibile trovare le credenziali. Verifica le credenziali fornite sulla console o sull'output IAM. AWS CLI Assicurarsi di avere aggiunto il ruolo IAM specificato in `iamRoleArn` al cluster.
+ `S3 bucket not found for source` (HTTP 400)
Il bucket S3 non esiste. Verifica il nome del bucket.
+ `The source source-uri does not exist/not reachable` (HTTP 400)
Non sono stati trovati file corrispondenti nel bucket S3.
+ `Unable to connect to S3 endpoint. Provided source = source-uri and region = aws-region` (HTTP 500)
Non è stato possibile connettersi ad Amazon S3. La regione deve corrispondere alla regione del cluster. Verifica di disporre di un endpoint VPC. Per informazioni su come creare un endpoint VPC, vedi [Creazione di un endpoint VPC Amazon S3](bulk-load-data.md#bulk-load-prereqs-s3).
+ `Bucket is not in provided Region (aws-region)` (HTTP 400)
Il bucket deve trovarsi nella stessa AWS regione dell'istanza DB di Neptune.
+ `Unable to perform S3 list operation` (HTTP 400)
L'utente o il ruolo IAM fornito non dispone di autorizzazioni `List` per il bucket o la cartella. Verifica la policy o la lista di controllo accessi (ACL) sul bucket.
+ `Start new load operation not permitted on a read replica instance` (HTTP 405)
Il caricamento è un'operazione di scrittura. Riprova a caricare l'endpoint del cluster. read/write
+ `Failed to start load because of unknown error from S3` (HTTP 500)
Amazon S3 ha restituito un errore sconosciuto. Contattare [Supporto AWS](https://aws.amazon.com/premiumsupport/).
+ `Invalid S3 access key` (HTTP 400)
La chiave di accesso non è valida. Controlla le credenziali fornite.
+ `Invalid S3 secret key` (HTTP 400)
La chiave privata non è valida. Controlla le credenziali fornite.
+ `Max concurrent load limit breached` (HTTP 400)
Se una richiesta di caricamento viene inviata senza `"queueRequest" : "TRUE"`, e un'attività di caricamento è attualmente in esecuzione, la richiesta avrà esito negativo con questo errore.
+ `Failed to start new load for the source "source name". Max load task queue size limit breached. Limit is 64` (HTTP 400)
Neptune supporta l'accodamento di un massimo di 64 processi dello strumento di caricamento alla volta. Se una richiesta di caricamento aggiuntiva viene inviata alla coda quando contiene già 64 attività, la richiesta non riesce con questo messaggio.
# Esempi di strumento di caricamento Neptune
Questo esempio dimostra come utilizzare il caricatore Neptune per caricare dati in un database grafico Neptune utilizzando il formato CSV Gremlin. La richiesta viene inviata come richiesta HTTP POST all'endpoint del loader Neptune e il corpo della richiesta contiene i parametri necessari per specificare l'origine dei dati, il formato, il ruolo IAM e altre opzioni di configurazione. La risposta include l'ID di caricamento, che può essere utilizzato per tenere traccia dell'avanzamento del processo di caricamento dei dati.
**Example Richiesta**
Di seguito viene riportata una richiesta inviata tramite HTTP POST mediante il comando `curl`. La richiesta carica un file in formato CSV Neptune. Per ulteriori informazioni, consulta [Formato dati di caricamento Gremlin](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 Risposta**
```
{
"status" : "200 OK",
"payload" : {
"loadId" : "ef478d76-d9da-4d94-8ff1-08d9d4863aa5"
}
}
```
# API Neptune Loader Get-Status
Consente di ottenere lo stato di un processo `loader`.
Per ottenere lo stato di caricamento, è necessario inviare una richiesta HTTP `GET` all'endpoint `https://your-neptune-endpoint:port/loader`. Per ottenere lo stato di una richiesta di caricamento specifica, è necessario includere il valore `loadId` come parametro URL oppure aggiungere `loadId` al percorso URL.
Neptune tiene traccia solo dei 1.024 processi di caricamento in blocco più recenti e memorizza solo gli ultimi 10.000 dettagli di errore per processo.
Vedi [Messaggi di feed e di errore dello strumento di caricamento Neptune](loader-message.md) per un elenco dei messaggi di errore e di feed restituiti dallo strumento di caricamento in caso di errori.
**Contents**
+ [Richieste Neptune Loader Get-Status](load-api-reference-status-requests.md)
+ [Sintassi della richiesta Loader Get-Status](load-api-reference-status-requests.md#load-api-reference-status-request-syntax)
+ [Parametri della richiesta di Get-Status Neptune Loader](load-api-reference-status-requests.md#load-api-reference-status-parameters)
+ [Risposte del Neptune Loader Get-Status](load-api-reference-status-response.md)
+ [Layout JSON di Neptune Loader Get-Status Response](load-api-reference-status-response.md#load-api-reference-status-response-layout)
+ [Neptune Loader Get-Status `overallStatus` e oggetti di risposta `failedFeeds`](load-api-reference-status-response.md#load-api-reference-status-response-objects)
+ [Oggetto di risposta Get-Status `errors` Neptune Loader](load-api-reference-status-response.md#load-api-reference-status-errors)
+ [Oggetto di risposta Get-Status `errorLogs` Neptune Loader](load-api-reference-status-response.md#load-api-reference-error-logs)
+ [Esempi di Neptune Loader Get-Status](load-api-reference-status-examples.md)
+ [Esempio di richiesta dello stato di caricamento](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request)
+ [Esempio di richiesta di loadIds](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request)
+ [Esempio di richiesta dello stato dettagliato](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request)
+ [Esempi di Neptune Loader Get-Status `errorLogs`](load-api-reference-error-logs-examples.md)
+ [Esempio di risposta di stato dettagliata in caso di errori](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors)
+ [Esempio di un errore `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted)
# Richieste Neptune Loader Get-Status
## Sintassi della richiesta Loader 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
```
## Parametri della richiesta di Get-Status Neptune Loader
+ **`loadId`**: ID del processo di caricamento. Se non si specifica a`loadId`, viene restituito un elenco di carichi IDs .
+ **`details`**: include i dettagli aggiuntivi rispetto allo stato generale.
*Valori consentiti:* `TRUE`, `FALSE`.
*Valore predefinito*: `FALSE`.
+ **`errors`**: include l'elenco degli errori.
*Valori consentiti:* `TRUE`, `FALSE`.
*Valore predefinito*: `FALSE`.
L'elenco degli errori è paginato. I parametri `page` ed `errorsPerPage` consentono di esaminare tutti gli errori.
+ **`page`**: numero della pagina dell'errore. È valido solo con il parametro `errors` impostato su `TRUE`.
*Valori consentiti*: interi positivi
*Valore predefinito*: 1
+ **`errorsPerPage`**: numero di errori per ogni pagina. È valido solo con il parametro `errors` impostato su `TRUE`.
*Valori consentiti*: interi positivi
*Valore predefinito*: 10
+ **`limit`**: numero di ID di caricamento da elencare. Valido solo quando si richiede un elenco di carico IDs inviando una `GET` richiesta senza `loadId` specificazioni.
*Valori consentiti*: interi positivi da 1 a 100.
*Valore predefinito*: 100
+ **`includeQueuedLoads`**— Un parametro opzionale che può essere utilizzato per escludere il caricamento IDs delle richieste di carico in coda quando viene richiesto un elenco di carico IDs.
Per impostazione predefinita, il caricamento IDs di tutti i processi di caricamento con stato `LOAD_IN_QUEUE` è incluso in tale elenco. Vengono visualizzati prima del caricamento IDs degli altri lavori, ordinati in base all'ora in cui sono stati aggiunti alla coda dal più recente al meno recente.
*Valori consentiti:* `TRUE`, `FALSE`.
*Valore predefinito*: `TRUE`.
# Risposte del Neptune Loader Get-Status
Il seguente esempio di risposta dell'API Get-Status Neptune descrive la struttura generale della risposta, spiega i vari campi e i relativi tipi di dati, nonché la gestione degli errori e i dettagli del registro degli errori.
## Layout JSON di Neptune Loader Get-Status Response
Il layout generale di una risposta dello stato dello strumento di caricamento è il seguente:
```
{
"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` e oggetti di risposta `failedFeeds`
Le possibili risposte restituite per ogni feed non riuscito, incluse le descrizioni degli errori, sono le stesse dell'oggetto `overallStatus` in una risposta `Get-Status`.
I seguenti campi vengono visualizzati nell'oggetto `overallStatus` per tutti i caricamenti e nell'oggetto `failedFeeds` per ogni feed non riuscito.
+ **`fullUri`**: URI del file o dei file da caricare.
*Tipo*: *stringa*
*Formato*: `s3://bucket/key`.
+ **`runNumber`**: numero di esecuzione di questo caricamento o feed. Aumenta quando il carico viene riavviato.
*Tipo:* *unsigned long*
+ **`retryNumber`**: numero di nuovi tentativi di questo caricamento o feed. Aumenta quando lo strumento di caricamento prova nuovamente a eseguire un feed o un caricamento automaticamente.
*Tipo:* *unsigned long*
+ **`status`**: stato restituito del caricamento o del feed. `LOAD_COMPLETED` indica un caricamento riuscito senza problemi. Per un elenco di altri messaggi sullo stato del caricamento, vedi [Messaggi di feed e di errore dello strumento di caricamento Neptune](loader-message.md).
*Tipo:* *stringa*.
+ **`totalTimeSpent`**: tempo, in secondi, impiegato per analizzare e inserire i dati per il caricamento o il feed. Non è incluso il tempo impiegato per recuperare l'elenco dei file di origine.
*Tipo:* *unsigned long*
+ **`totalRecords`**: totale dei record caricati o che si è provato a caricare.
*Tipo:* *unsigned long*
Tenere presente che quando si carica da un file CSV, il conteggio dei record non si riferisce al numero di righe caricate, ma piuttosto al numero di singoli record in quelle righe. Ad esempio, prendiamo un piccolo file CSV come questo:
```
~id,~label,name,team
'P-1','Player','Stokes','England'
```
Neptune considererà questo file come contenente 3 record, ovvero:
```
P-1 label Player
P-1 name Stokes
P-1 team England
```
+ **`totalDuplicates`**: numero di record duplicati rilevati.
*Tipo:* *unsigned long*
Come nel caso del conteggio `totalRecords`, questo valore contiene il numero di singoli record duplicati in un file CSV, non il numero di righe duplicate. Prendiamo ad esempio questo piccolo file CSV:
```
~id,~label,name,team
P-2,Player,Kohli,India
P-2,Player,Kohli,India
```
Lo stato restituito dopo il caricamento sarà simile al seguente, con un totale di 6 record, di cui 3 duplicati:
```
{
"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
}
}
}
```
Per i caricamenti openCypher, un duplicato viene conteggiato quando:
+ Lo strumento di caricamento rileva che una riga in un file dei nodi ha un ID senza uno spazio ID uguale a un altro valore ID senza uno spazio ID, in un'altra riga o appartenente a un nodo esistente.
+ Lo strumento di caricamento rileva che una riga in un file dei nodi ha un ID con uno spazio ID uguale a un altro valore ID con uno spazio ID, in un'altra riga o appartenente a un nodo esistente.
Per informazioni, consulta [Considerazioni speciali per il caricamento dei dati openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher).
+ **`parsingErrors`**: numero di errori di analisi rilevati.
*Tipo:* *unsigned long*
+ **`datatypeMismatchErrors`**: numero di record il cui tipo di dati non corrisponde ai dati specificati.
*Tipo:* *unsigned long*
+ **`insertErrors`**: numero di record che non è stato possibile inserire a causa di errori.
*Tipo:* *unsigned long*
## Oggetto di risposta Get-Status `errors` Neptune Loader
Gli errori rientrano nelle seguenti categorie:
+ **`Error 400`**: un oggetto `loadId` non valido restituisce un errore di richiesta non valida HTTP `400`. Il messaggio descrive l'errore.
+ **`Error 500`**: una richiesta valida che non può essere elaborata restituisce un errore interno del server HTTP `500`. Il messaggio descrive l'errore.
Vedi [Messaggi di feed e di errore dello strumento di caricamento Neptune](loader-message.md) per un elenco dei messaggi di errore e di feed restituiti dallo strumento di caricamento in caso di errori.
Se si verifica un errore, viene restituito un oggetto JSON `errors` nell'oggetto `BODY` della risposta con i seguenti campi:
+ **`startIndex`**: indice del primo errore incluso.
*Tipo:* *unsigned long*
+ **`endIndex`**: indice dell'ultimo errore incluso.
*Tipo:* *unsigned long*
+ **`loadId`**: ID del caricamento. È possibile usare questo ID per stampare gli errori per il caricamento impostando il parametro `errors` su `TRUE`.
*Tipo:* *stringa*.
+ **`errorLogs`**: elenco degli errori.
*Type:* *elenco*
## Oggetto di risposta Get-Status `errorLogs` Neptune Loader
L'oggetto `errorLogs` contenuto nell'oggetto `errors` della risposta Get-Status dello strumento di caricamento contiene un oggetto che descrive ogni errore utilizzando i seguenti campi:
+ **`errorCode`**: identifica la natura dell'errore.
Può accettare uno dei seguenti valori:
+ `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` (restituito quando lo strumento di caricamento in blocco non è in grado di determinare il tipo di errore).
+ **`errorMessage`**: messaggio che descrive l'errore.
Può trattarsi di un messaggio generico associato al codice di errore o di un messaggio specifico contenente dettagli, ad esempio su un from/to vertice mancante o su un errore di analisi.
+ **`fileName`**: nome del feed.
+ **`recordNum`**: in caso di errore di analisi, questo è il numero di record nel file del record che non è stato possibile analizzare. Viene impostato su zero se il numero di record non è applicabile all'errore o se non è stato possibile determinarlo.
Ad esempio, lo strumento di caricamento in blocco genererà un errore di analisi se rileva una riga in errore come la seguente in un file RDF `nquads`:
```
|http://base#predicate> .
```
Come si può notare, il secondo `http` nella riga precedente dovrebbe essere preceduto da `<` anziché da `|`. L'oggetto di errore risultante in `errorLogs` in una risposta di stato sarà simile al seguente:
```
{
"errorCode" : "PARSING_ERROR",
"errorMessage" : "Expected '<', found: |",
"fileName" : "s3://bucket/key",
"recordNum" : 12345
},
```
# Esempi di Neptune Loader Get-Status
Gli esempi seguenti mostrano l'utilizzo dell'API Get-Status del loader Neptune, che consente di recuperare informazioni sullo stato dei caricamenti di dati nel database grafico di Amazon Neptune. Questi esempi coprono tre scenari principali: recupero dello stato di un carico specifico, elenco del carico disponibile e richiesta di informazioni dettagliate sullo stato per un carico IDs specifico.
## Esempio di richiesta dello stato di caricamento
Di seguito viene riportata una richiesta inviata tramite HTTP `GET` mediante il comando `curl`.
```
curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)'
```
**Example Risposta**
```
{
"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
}
}
}
```
## Esempio di richiesta di loadIds
Di seguito viene riportata una richiesta inviata tramite HTTP `GET` mediante il comando `curl`.
```
curl -X GET 'https://your-neptune-endpoint:port/loader?limit=3'
```
**Example Risposta**
```
{
"status" : "200 OK",
"payload" : {
"loadIds" : [
"a2c0ce44-a44b-4517-8cd4-1dc144a8e5b5",
"09683a01-6f37-4774-bb1b-5620d87f1931",
"58085eb8-ceb4-4029-a3dc-3840969826b9"
]
}
}
```
## Esempio di richiesta dello stato dettagliato
Di seguito viene riportata una richiesta inviata tramite HTTP `GET` mediante il comando `curl`.
```
curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)?details=true'
```
**Example Risposta**
```
{
"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
}
}
}
```
# Esempi di Neptune Loader Get-Status `errorLogs`
Gli esempi seguenti mostrano la risposta dettagliata sullo stato del loader Neptune quando si sono verificati errori durante il processo di caricamento dei dati. Gli esempi illustrano la struttura della risposta, incluse informazioni sui feed non riusciti, sullo stato generale e sui log degli errori dettagliati.
## Esempio di risposta di stato dettagliata in caso di errori
Questa è una richiesta inviata tramite HTTP `GET` utilizzando `curl`:
```
curl -X GET 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802?details=true&errors=true&page=1&errorsPerPage=3'
```
**Example di una risposta dettagliata in caso di errori**
Questo è un esempio della risposta che potresti ottenere dalla query precedente, con un oggetto `errorLogs` che elenca gli errori di caricamento riscontrati:
```
{
"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
}
}
}
```
## Esempio di un errore `Data prefetch task interrupted`
Occasionalmente quando ottieni uno stato `LOAD_FAILED` e richiedi informazioni più dettagliate, l'errore restituito potrebbe essere un `PARSING_ERROR` con un messaggio `Data prefetch task interrupted`, come questo:
```
"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
}
]
```
Questo errore ha luogo quando si è verificata un interruzione temporaneo nel processo di caricamento dei dati che non è stato in genere causata dalla richiesta o dai dati. Di solito può essere risolto semplicemente eseguendo nuovamente la richiesta di caricamento in blocco. Se stai utilizzando impostazioni predefinite, ovvero `"mode":"AUTO"` e `"failOnError":"TRUE"`, il loader salta i file che ha già caricato e riprende il caricamento dei file che non aveva ancora caricato quando si è verificata l'interruzione.
# Annullamento di un processo dello strumento di caricamento Neptune
Annulla un processo di caricamento.
Per annullare un lavoro, è necessario inviare una richiesta HTTP `DELETE` all'endpoint `https://your-neptune-endpoint:port/loader`. Il valore `loadId` può essere aggiunto al percorso URL `/loader` o incluso nell'URL come variabile.
## Sintassi della richiesta di annullamento di un processo
```
DELETE https://your-neptune-endpoint:port/loader?loadId=loadId
```
```
DELETE https://your-neptune-endpoint:port/loader/loadId
```
## Parametri della richiesta del processo di annullamento
**loadId**
L'ID del processo di caricamento.
## Sintassi della risposta del processo di annullamento
```
no response body
```
**200 OK**
Il processo di caricamento eliminato correttamente restituisce il codice `200`.
## Errori del processo di annullamento
Se si verifica un errore, viene restituito un oggetto JSON nel `BODY` della risposta. L'oggetto `message` contiene una descrizione dell'errore.
**Categorie di errore**
+ **`Error 400`**: un oggetto `loadId` non valido restituisce un errore di richiesta non valida HTTP `400`. Il messaggio descrive l'errore.
+ **`Error 500`**: una richiesta valida che non può essere elaborata restituisce un errore interno del server HTTP `500`. Il messaggio descrive l'errore.
## Messaggi di errore del processo di annullamento
Di seguito sono riportati i possibili messaggi di errore dell'API di annullamento con la relativa descrizione.
+ `The load with id = load_id does not exist or not active` (HTTP 404): il caricamento non è stato trovato. Verifica il valore del parametro `id`.
+ `Load cancellation is not permitted on a read replica instance.` (HTTP 405): il caricamento è un'operazione di scrittura. Riprova a caricare l'endpoint del cluster. read/write
## Esempi del processo di annullamento
**Example Richiesta**
Di seguito viene riportata una richiesta inviata tramite HTTP `DELETE` mediante il comando `curl`.
```
curl -X DELETE 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802'
```