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à. # Caricamento di dati in Amazon Neptune Esistono diversi modi per caricare i dati dei grafi in Amazon Neptune: + Se devi caricare solo una quantità relativamente piccola di dati, puoi utilizzare query come le `INSERT` istruzioni SPARQL o Gremlin `mergeV` and `mergeE` steps. OpenCypher include anche clausole e. OpenCypher include anche clausole e. `CREATE` `MERGE` + È possibile trarre vantaggio da [Strumento di caricamento in blocco Neptune](bulk-load.md) per l'acquisizione di grandi quantità di dati che risiedono in file esterni. Il comando dello strumento di caricamento in blocco è più veloce e ha meno overhead rispetto ai comandi del linguaggio query. È ottimizzato per set di dati di grandi dimensioni e supporta sia i dati RDF (Resource Description Framework) che i dati Gremlin. + [È possibile utilizzare AWS Database Migration Service (AWS DMS) per importare dati da altri archivi dati (vedere la Guida per l'utente). [Utilizzo AWS Database Migration Service per caricare dati in Amazon Neptune da un altro data store](dms-neptune.md)AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/) + Per set di dati più piccoli in uno o pochi file Amazon S3, puoi utilizzare funzioni di caricamento basate su query per leggere ed elaborare i dati direttamente all'interno delle tue query. Per ulteriori dettagli, consulta [Caricamento di dati in Amazon Neptune tramite query](load-data-via-query.md). **Topics** + [Utilizzo del bulk loader Amazon Neptune per importare dati](bulk-load.md) + [Utilizzo AWS Database Migration Service per caricare dati in Amazon Neptune da un altro data store](dms-neptune.md) + [Caricamento di dati in Amazon Neptune tramite query](load-data-via-query.md) # Utilizzo del bulk loader Amazon Neptune per importare dati In Amazon Neptune è disponibile un comando `Loader` che consente di caricare dati da file esterni direttamente in un cluster database Neptune. Puoi utilizzare questo comando come alternativa all'esecuzione di un numero elevato di istruzioni `INSERT`, passaggi `addV` e `addE` o altre chiamate API. Il comando **Loader** di Neptune è più rapido, meno oneroso, è ottimizzato per set di dati di grandi dimensioni e supporta sia i dati Gremlin che i dati RDF (Resource Description Framework) utilizzati da SPARQL. Il seguente diagramma mostra una panoramica del processo di caricamento: ![\[Diagramma che illustra le fasi di base necessarie per il caricamento di dati in Neptune.\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/load-diagram.png) Di seguito sono descritte le fasi del processo di caricamento: 1. Copiare i file di dati in un bucket Amazon Simple Storage Service (Amazon S3). 1. Creare un ruolo IAM con accesso al bucket per la lettura e la presentazione di elenchi. 1. Creare un endpoint VPC Amazon S3. 1. Avviare strumento di caricamento Neptune inviando una richiesta tramite HTTP all'istanza database Neptune. 1. L'istanza database Neptune presuppone che il ruolo IAM carichi i dati dal bucket. **Nota** È possibile caricare dati crittografati da Amazon S3 se sono stati crittografati utilizzando la modalità `SSE-S3` o `SSE-KMS` di Amazon S3, a condizione che il ruolo utilizzato per il caricamento in blocco abbia accesso all'oggetto Amazon S3 e anche, nel caso di SSE-KMS, a `kms:decrypt`. Neptune può quindi impersonare le credenziali dell'utente ed effettuare chiamate a `s3:getObject` per conto dell'utente. Tuttavia, attualmente Neptune non supporta il caricamento di dati crittografati utilizzando la modalità `SSE-C`. Nelle seguenti sezioni vengono fornite istruzioni per la preparazione e il caricamento di dati in Neptune. **Topics** + [Prerequisiti: ruolo IAM e accesso ad Amazon S3](bulk-load-tutorial-IAM.md) + [Formati dei dati di caricamento](bulk-load-tutorial-format.md) + [Esempio: caricamento di dati in un'istanza database Neptune](bulk-load-data.md) + [Ottimizzazione di un caricamento in blocco di Amazon Neptune](bulk-load-optimize.md) + [Documentazione di riferimento dello strumento di caricamento Neptune](load-api-reference.md) # Prerequisiti: ruolo IAM e accesso ad Amazon S3 Il caricamento di dati da un bucket Amazon Simple Storage Service (Amazon S3) richiede AWS Identity and Access Management un ruolo (IAM) che abbia accesso al bucket. Tale ruolo viene assunto da Amazon Neptune per caricare i dati. **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`. Le seguenti sezioni mostrano come utilizzare una policy IAM gestita per creare un ruolo IAM per l'accesso alle risorse Amazon S3 e quindi collegare il ruolo al cluster Neptune. **Topics** + [Creazione di un ruolo IAM per consentire ad Amazon Neptune di accedere alle risorse di Amazon S3](bulk-load-tutorial-IAM-CreateRole.md) + [Aggiunta del ruolo IAM a un cluster Amazon Neptune](bulk-load-tutorial-IAM-add-role-cluster.md) + [Creazione dell'endpoint VPC Amazon S3](bulk-load-tutorial-vpc.md) + [Concatenazione di ruoli IAM in Amazon Neptune](bulk-load-tutorial-chain-roles.md) **Nota** Per seguire le istruzioni devi disporre dell'accesso alla console IAM e delle autorizzazioni per gestire ruoli e policy IAM. Per ulteriori informazioni, consulta [Autorizzazioni per lavorare nella console di AWS gestione nella Guida](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html#Credentials-Permissions-overview-console) per l'utente *IAM*. La console di Amazon Neptune richiede che l'utente disponga delle seguenti autorizzazioni IAM per collegare il ruolo al cluster Neptune. ``` iam:GetAccountSummary on resource: * iam:ListAccountAliases on resource: * iam:PassRole on resource: * with iam:PassedToService restricted to rds.amazonaws.com ``` # Creazione di un ruolo IAM per consentire ad Amazon Neptune di accedere alle risorse di Amazon S3 Utilizzare la policy IAM gestita `AmazonS3ReadOnlyAccess` per creare un nuovo ruolo IAM che consenta ad Amazon Neptune di accedere alle risorse di Amazon S3. **Per creare un nuovo ruolo IAM che consenta a Neptune di accedere ad Amazon S3** 1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Nel pannello di navigazione, seleziona **Roles** (Ruoli). 1. Selezionare **Create role (Crea ruolo)**. 1. In **Servizio AWS **, scegli **S3**. 1. Scegli **Successivo: autorizzazioni**. 1. **Utilizza la casella del filtro per filtrare in base al termine **S3** e seleziona la casella accanto ad AmazonS3. ReadOnlyAccess** **Nota** Questa policy concede le autorizzazioni `s3:Get*` e `s3:List*` per tutti i bucket. Le fasi successive limitano l'accesso al ruolo utilizzando la policy di attendibilità. Lo strumento di caricamento richiede solo le autorizzazioni `s3:Get*` e `s3:List*` per il bucket da cui si esegue il caricamento, quindi è possibile limitare queste autorizzazioni anche in base alla risorsa Amazon S3. Se il bucket S3 è crittografato, occorre aggiungere autorizzazioni `kms:Decrypt` 1. Scegli **Prossimo: Rivedi**. 1. Impostare **Nome ruolo** su un nome per il ruolo IAM, ad esempio `NeptuneLoadFromS3`. È anche possibile aggiungere un valore opzionale in **Descrizione ruolo**, ad esempio "Consente a Neptune di accedere alle risorse di Amazon S3 per conto tuo". 1. Selezionare **Crea ruolo**. 1. Nel riquadro di navigazione, seleziona **Ruoli**. 1. Nel campo **Search (Cerca)** digita il nome del ruolo creato e selezionalo quando viene visualizzato nell'elenco. 1. Nella scheda **Trust relationships (Relazioni di trust)** scegli **Edit trust relationship (Modifica relazione di trust)**. 1. Nel campo di testo incollare la seguente policy di attendibilità. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": [ "rds.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` ------ 1. Scegliere **Update trust Policy** (Aggiorna policy di attendibilità). 1. Completa le fasi descritte in [Aggiunta del ruolo IAM a un cluster Amazon Neptune](bulk-load-tutorial-IAM-add-role-cluster.md). # Aggiunta del ruolo IAM a un cluster Amazon Neptune È possibile utilizzare la console per aggiungere il ruolo IAM a un cluster Amazon Neptune. In questo modo qualsiasi istanza database Neptune nel cluster può assumere il ruolo e caricare dati da Amazon S3. **Nota** La console di Amazon Neptune richiede che l'utente disponga delle seguenti autorizzazioni IAM per collegare il ruolo al cluster Neptune. ``` iam:GetAccountSummary on resource: * iam:ListAccountAliases on resource: * iam:PassRole on resource: * with iam:PassedToService restricted to rds.amazonaws.com ``` **Per aggiungere un ruolo IAM a un cluster Amazon Neptune** 1. [Accedi alla console di AWS gestione e apri la console Amazon Neptune da casa. https://console.aws.amazon.com/neptune/](https://console.aws.amazon.com/neptune/home) 1. Nel pannello di navigazione, seleziona **Database**. 1. Scegli l'identificatore del cluster per il cluster che desideri modificare. 1. Scegli la scheda **Connettività e sicurezza**. 1. Nella sezione IAM Roles, scegli il ruolo che hai creato nella sezione precedente. 1. Scegliere **Add role (Aggiungi ruolo)**. 1. Attendi che il ruolo IAM diventi accessibile al cluster prima di utilizzarlo. # Creazione dell'endpoint VPC Amazon S3 Lo strumento di caricamento Neptune richiede un endpoint VPC di tipo Gateway per Amazon S3. **Per configurare l'accesso ad Amazon S3** 1. Accedi Console di gestione AWS e apri la console Amazon VPC all'indirizzo. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. Nel pannello di navigazione, seleziona **Endpoints (Endpoint)**. 1. Scegliere **Create Endpoint** (Crea endpoint). 1. Scegli il **Nome servizio** `com.amazonaws.region.s3` per l'endpoint di tipo Gateway. **Nota** Se la regione indicata qui non è corretta, verifica che lo sia la regione della console. 1. Scegli il VPC che contiene l'istanza database Neptune (è elencato per l'istanza database nella console Neptune). 1. Selezionare la casella di controllo accanto alle tabelle di routing associate alle sottoreti correlate al proprio cluster. Se si dispone di una sola tabella di routing, è necessario selezionare la casella corrispondente. 1. Scegliere **Create Endpoint** (Crea endpoint). Per ulteriori informazioni sulla creazione dell'endpoint, consulta [Endpoint VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html#create-vpc-endpoint) nella *Guida per l'utente di Amazon VPC*. Per informazioni sulle limitazioni degli endpoint VPC, consulta [Endpoint VPC per Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html). **Fasi successive** Ora che hai concesso l'accesso al bucket Amazon S3, puoi prepararti a caricare i dati. Per informazioni sui formati supportati, vedi [Formati dei dati di caricamento](bulk-load-tutorial-format.md). # Concatenazione di ruoli IAM in Amazon Neptune **Importante** La nuova funzionalità di caricamento in blocco multi-account introdotta nel [rilascio del motore 1.2.1.0.R3](engine-releases-1.2.1.0.R3.md), che sfrutta il concatenamento dei ruoli IAM, può in alcuni casi causare un peggioramento delle prestazioni di caricamento in blocco. Di conseguenza, gli aggiornamenti ai rilasci del motore che supportano questa funzionalità sono stati temporaneamente sospesi fino alla risoluzione del problema. Quando si collega un ruolo al cluster, il cluster può assumere tale ruolo per accedere ai dati archiviati in Amazon S3. A partire dal [rilascio del motore 1.2.1.0.R3](engine-releases-1.2.1.0.R3.md), se quel ruolo non ha accesso a tutte le risorse necessarie, è possibile concatenare uno o più ruoli aggiuntivi che il cluster può assumere per accedere ad altre risorse. Ogni ruolo nella catena assume il ruolo successivo nella catena, fino a quando il cluster non assume il ruolo alla fine della catena. Per concatenare i ruoli, è possibile stabilire una relazione di trust tra di essi. Ad esempio, per concatenare `RoleB` a `RoleA`, `RoleA` deve disporre di una policy di autorizzazioni che gli consenta di assumere `RoleB` e `RoleB` deve disporre di una policy di trust che gli consenta di passare le proprie autorizzazioni a `RoleA`. Per ulteriori informazioni, consulta [Utilizzo di ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html). Il primo ruolo di una catena deve essere collegato al cluster che sta caricando i dati. Il primo ruolo e ogni ruolo successivo che assume il ruolo seguente nella catena devono avere: + Una policy che include una dichiarazione specifica con l'effetto `Allow` sull'azione `sts:AssumeRole`. + Il nome della risorsa Amazon (ARN) del ruolo successivo in un elemento `Resource`. **Nota** Il bucket Amazon S3 di destinazione deve trovarsi nella stessa AWS regione del cluster. ## Accesso multi-account tramite ruoli concatenati È possibile concedere l'accesso multi-account concatenando uno o più ruoli che appartengono a un altro account. Quando il cluster assume temporaneamente un ruolo appartenente a un altro account, può accedere alle relative risorse. Supponiamo, ad esempio, che l'**Account A** voglia accedere ai dati in un bucket Amazon S3 che appartiene all'**Account B**: + L'**account A** crea un ruolo AWS di servizio `RoleA` denominato per Neptune e lo collega a un cluster. + L'**Account B** crea un ruolo denominato `RoleB` autorizzato ad accedere ai dati in un bucket dell'**Account B**. + L'**Account A** collega una policy di autorizzazioni a `RoleA` che gli consente di assumere `RoleB`. + L'**Account B** collega una policy di trust a `RoleB` che gli consente di passare le proprie autorizzazioni a `RoleA`. + Per accedere ai dati nel bucket dell'**Account B**, l'**Account A** esegue un comando dello strumento di caricamento con un parametro `iamRoleArn` che concatena `RoleA` e `RoleB`. Per la durata dell'operazione loader, `RoleA` assume temporaneamente il ruolo `RoleB` per accedere al bucket Amazon S3 nell'**Account B**. ![\[Diagramma che illustra l'accesso multi-account tramite ruoli concatenati\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/cross-account-bulk-load.png) Ad esempio, `RoleA` avrà una policy di trust che stabilisce una relazione di trust con Neptune: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "rds.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ `RoleA` avrà anche una policy di autorizzazione che gli consente di assumere il ruolo `RoleB`, che è di proprietà dell'**Account B**: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "Stmt1487639602000", "Effect": "Allow", "Action": [ "sts:AssumeRole" ], "Resource": "arn:aws:iam::111122223333:role/RoleB" } ] } ``` ------ Al contrario, `RoleB` avrà una policy di trust per stabilire una relazione di trust con `RoleA`: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "sts:AssumeRole", "Principal": { "AWS": "arn:aws:iam::111122223333:role/RoleA" } } ] } ``` ------ `RoleB` avrà inoltre bisogno dell'autorizzazione per accedere ai dati nel bucket Amazon S3 situato nell'**Account B**. ## Creazione di un AWS Security Token Service endpoint VPC (STS) Il loader Neptune richiede un AWS STS endpoint VPC per quando si concatenano i ruoli IAM all'accesso privato tramite indirizzi IP privati. AWS STS APIs Puoi connetterti direttamente da un Amazon VPC a AWS STS un endpoint VPC in modo sicuro e scalabile. L'utilizzo di un endpoint VPC dell'interfaccia offre un migliore assetto di sicurezza in quanto non è necessario aprire firewall per il traffico in uscita. Offre inoltre gli altri vantaggi derivanti dall'utilizzo degli endpoint Amazon VPC. Quando si utilizza un endpoint VPC, il traffico verso AWS STS non viene trasmesso su Internet e non esce mai dalla rete Amazon. Il tuo VPC è connesso in modo sicuro AWS STS senza rischi di disponibilità o vincoli di larghezza di banda sul traffico di rete. Per ulteriori informazioni, consulta [Utilizzo di endpoint VPC dell'interfaccia AWS STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_sts_vpce.html). **Per configurare l'accesso per (STS) AWS Security Token Service** 1. Accedi Console di gestione AWS e apri la console Amazon VPC all'indirizzo. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. Nel pannello di navigazione, seleziona **Endpoints (Endpoint)**. 1. Scegliere **Create Endpoint** (Crea endpoint). 1. Scegli il **Nome servizio** `com.amazonaws.region.sts` per l'endpoint di tipo Interfaccia. 1. Scegli il **VPC** che contiene l'istanza database Neptune e l'istanza EC2. 1. Seleziona la casella di controllo accanto alla sottorete in cui è presente l'istanza EC2. Non è possibile selezionare più sottoreti dalla stessa zona di disponibilità. 1. Per IP address type (Tipo di indirizzo IP), seleziona una delle opzioni seguenti: + **IPv4**— Assegna IPv4 indirizzi alle interfacce di rete degli endpoint. Questa opzione è supportata solo se tutte le sottoreti selezionate hanno intervalli di indirizzi. IPv4 + **IPv6**— Assegna IPv6 indirizzi alle interfacce di rete degli endpoint. Questa opzione è supportata solo se tutte le sottoreti selezionate sono sottoreti -only. IPv6 + **Dualstack**: assegna entrambi gli indirizzi alle interfacce di rete degli endpoint. IPv4 IPv6 Questa opzione è supportata solo se tutte le sottoreti selezionate hanno entrambi gli intervalli di indirizzi. IPv4 IPv6 1. Per **Gruppi di sicurezza**, seleziona i gruppi di sicurezza da associare alle interfacce di rete dell'endpoint per l'endpoint VPC. È necessario selezionare tutti i gruppi di sicurezza collegati all'istanza database Neptune e all'istanza EC2. 1. Per **Policy**, seleziona **Full access** (Accesso completo) per consentire tutte le operazioni da parte di tutti i principali su tutte le risorse dell'endpoint VPC. In caso contrario, seleziona **Custom** (Personalizza) per allegare una policy dell'endpoint VPC in grado di verificare le autorizzazioni di cui dispongono i principali per eseguire operazioni sulle risorse dell'endpoint VPC. Questa opzione è disponibile solo se il servizio supporta le policy dell'endpoint VPC. Per ulteriori informazioni, consulta [Policy di endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html). 1. (*Facoltativo*) Per aggiungere un tag, scegli **Aggiungi nuovo tag** e immetti la chiave e il valore del tag desiderati. 1. Seleziona **Crea endpoint**. Per ulteriori informazioni sulla creazione dell'endpoint, consulta [Endpoint VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) nella Guida per l'utente di Amazon VPC. Tieni presente che l'endpoint VPC di Amazon STS è un prerequisito obbligatorio per il concatenamento dei ruoli IAM. Ora che hai concesso l'accesso all' AWS STS endpoint, puoi prepararti a caricare i dati. Per ulteriori informazioni sui formati di dati supportati, consulta [Formati dei dati di caricamento](bulk-load-tutorial-format.md). ## Concatenamento dei ruoli all'interno di un comando dello strumento di caricamento È possibile specificare il concatenamento dei ruoli quando si esegue un comando loader includendo un elenco di ruoli separati da virgole nel parametro. ARNs `iamRoleArn` Sebbene nella maggior parte dei casi sia necessario avere solo due ruoli in una catena, è sicuramente possibile concatenarne tre o più. Ad esempio, questo comando dello strumento di caricamento concatena tre ruoli: ``` 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" }' ``` # Formati dei dati di caricamento L'API Amazon Neptune `Load` supporta il caricamento di dati in una varietà di formati. **Formati di caricamento dei grafi di proprietà** È possibile eseguire query sui dati caricati in uno dei seguenti formati dei grafi di proprietà utilizzando sia Gremlin che openCypher: + [Formato dati di caricamento Gremlin](bulk-load-tutorial-format-gremlin.md) (`csv`): formato di valori separati da virgole (CSV). + [Formato di caricamento dei dati openCypher](bulk-load-tutorial-format-opencypher.md) (`opencypher`): formato di valori separati da virgole (CSV). **Formati di caricamento RDF** Per caricare i dati Resource Descrizione Framework (RDF) sui cui è possibile eseguire query utilizzando SPARQL, puoi utilizzare uno dei seguenti formati standard come specificato dal World Wide Web Consortium (W3C): + N-Triples (`ntriples`) in base alle specifiche all'indirizzo [https://www.w3.org/TR/n-triples/](https://www.w3.org/TR/n-triples/). + N-Quads (`nquads`) in base alle specifiche all'indirizzo [https://www.w3.org/TR/n-quads/](https://www.w3.org/TR/n-quads/). + RDF/XML (`rdfxml`) in base alle specifiche all'indirizzo [https://www.w3.org/TR/rdf-syntax-grammar/](https://www.w3.org/TR/rdf-syntax-grammar/). + Turtle (`turtle`) in base alle specifiche all'indirizzo [https://www.w3.org/TR/turtle/](https://www.w3.org/TR/turtle/). **I dati di caricamento devono utilizzare la codifica UTF-8** **Importante** Tutti i file di dati di caricamento devono essere codificati in formato UTF-8. Se un file non è codificato in formato UTF-8, Neptune prova comunque a caricarlo come UTF-8. Per i dati N-Quads e N-triples che includono caratteri Unicode, sono supportate le sequenze di escape `\uxxxxx`. Tuttavia, Neptune non supporta la normalizzazione. Se è presente un valore che richiede la normalizzazione, non corrisponderà durante l'interrogazione. byte-to-byte Per ulteriori informazioni sulla normalizzazione, vedi la pagina relativa alla [normalizzazione](https://unicode.org/faq/normalization.html) su [Unicode.org](https://unicode.org). Se i dati non sono in un formato supportato, è necessario convertirli prima di caricarli. [Uno strumento per convertire GraphML nel formato CSV di Neptune è disponibile nel progetto Graph CSV su. ML2 [GitHub](https://github.com/)](https://github.com/awslabs/amazon-neptune-tools/blob/master/graphml2csv/README.md) ## Supporto della compressione per i file di dati di caricamento Neptune supporta la compressione di singoli file in formato `gzip` o `bzip2`. Il file compresso deve avere un'estensione `.gz` o `.bz2` e deve essere un singolo file di testo codificato in formato UTF-8. È possibile caricare più file, ma ognuno di essi deve essere un file `.gz`, `.bz2` o di testo non compresso separato. I file di archivio con estensioni come `.tar`, `.tar.gz` e `.tgz` non sono supportati. Nelle seguenti sezioni vengono descritti i formati in modo più dettagliato. **Topics** + [Supporto della compressione per i file di dati di caricamento](#bulk-load-tutorial-format-compression) + [Formato dati di caricamento Gremlin](bulk-load-tutorial-format-gremlin.md) + [Formato di caricamento dei dati openCypher](bulk-load-tutorial-format-opencypher.md) + [Formati dei dati di caricamento RDF](bulk-load-tutorial-format-rdf.md) # Formato dati di caricamento Gremlin Per caricare i dati di Apache TinkerPop Gremlin utilizzando il formato CSV, è necessario specificare i vertici e gli spigoli in file separati. Lo strumento di caricamento è in grado di caricare da più file vertex e da più file edge in un singolo processo di caricamento. Per ciascun comando di caricamento, il set di file da caricare deve trovarsi nella stessa cartella nel bucket Amazon S3 ed è necessario specificare il nome della cartella per il parametro `source`. I nomi file e le relative estensioni non sono importanti. Il formato CSV Amazon Neptune segue la specifica CSV RFC 4180. Per ulteriori informazioni, vedi [Common Format and MIME Type for CSV Files](https://tools.ietf.org/html/rfc4180) nel sito Web Internet Engineering Task Force (IETF). **Nota** Tutti i file devono essere codificati in formato UTF-8. Ogni file ha una riga di intestazione separata da virgola. La riga di intestazione è costituita da intestazioni di colonna di sistema e da intestazioni di colonna delle proprietà. ## Intestazioni di colonna di sistema Le intestazioni di colonna di sistema necessarie e consentite sono diverse per i file di vertice e i file di edge. Ogni colonna di sistema può essere presente una sola volta in un'intestazione. Per tutte le etichette viene fatta distinzione tra maiuscole e minuscole. **Intestazioni vertici** + `~id` - **Campo obbligatorio** Un ID per il vertice. + `~label` Un'etichetta per il vertice. Sono consentiti più valori di etichetta, separati da punto e virgola (`;`). Se non `~label` è presente, TinkerPop fornisce un'etichetta con il valore`vertex`, poiché ogni vertice deve avere almeno un'etichetta. **Intestazioni edge** + `~id` - **Campo obbligatorio** Un ID per l'edge. + `~from` - **Campo obbligatorio** L'ID del vertice *from*. + `~to` - **Campo obbligatorio** L'ID del vertice *to*. + `~label` Un'etichetta per l'edge. Gli edge possono avere solo un'etichetta singola. Se non `~label` è presente, TinkerPop fornisce un'etichetta con il valore`edge`, perché ogni bordo deve avere un'etichetta. ## Intestazioni di colonna delle proprietà È possibile specificare una colonna (`:`) per una proprietà utilizzando la sintassi seguente. Per i nomi dei tipi non viene fatta distinzione tra maiuscole e minuscole. Tenere presente, tuttavia, che se all'interno del nome di una proprietà compaiono i due punti, è necessario che siano preceduti da una barra rovesciata: `\:`. ``` propertyname:type ``` **Nota** Lo spazio, la virgola, il ritorno a destra e i caratteri di nuova riga non sono consentiti nelle intestazioni delle colonne, pertanto i nomi delle proprietà non possono includere questi caratteri. È possibile specificare una colonna per un tipo di matrice aggiungendo `[]` al tipo: ``` propertyname:type[] ``` **Nota** Le proprietà edge possono avere solo un singolo valore e verrà generato un errore se viene specificato un tipo di array o un secondo valore. L'esempio seguente mostra l'intestazione di colonna per una proprietà denominata `age` del tipo `Int`. ``` age:Int ``` Ogni riga del file dovrà avere un valore intero in quella posizione o essere lasciata vuota. Sono consentiti array di stringhe, ma le stringhe in un array non possono includere il carattere punto e virgola (`;`) a meno che non venga preceduto da una barra rovesciata (come in questo caso :`\;`). **Specifica la cardinalità di una colonna** L'intestazione della colonna può essere utilizzata per specificare la *cardinalità* per la proprietà identificata dalla colonna. Ciò permette allo strumento di caricamento in blocco di rispettare la cardinalità allo stesso modo delle query Gremlin. Per specificare la cardinalità di una colonna: ``` propertyname:type(cardinality) ``` Il *cardinality* valore può essere o. `single` `set` L'impostazione predefinita presunta è `set`; ciò significa che la colonna può accettare valori multipli. Nel caso di file edge, la cardinalità è sempre singola e specificare qualsiasi altra cardinalità fa sì che lo strumento di caricamento generi un'eccezione. Se la cardinalità è `single`, lo strumento di caricamento genera un errore se un valore precedente è già presente quando viene caricato un valore oppure se vengono caricati più valori. Questo comportamento può essere sovrascritto in modo che un valore esistente venga sostituito quando un nuovo valore viene caricato usando il flag `updateSingleCardinalityProperties`. Per informazioni, consulta [Comando dello strumento di caricamento](load-api-reference-load.md). È possibile utilizzare una cardinalità impostando un tipo di matrice, anche se non è generalmente necessario. Di seguito sono elencate le combinazioni possibili: + `name:type`: la cardinalità è `set` e il contenuto è a valore singolo. + `name:type[]`: la cardinalità è `set` e il contenuto ha valori multipli. + `name:type(single)`: la cardinalità è `single` e il contenuto è a valore singolo. + `name:type(set)`: la cardinalità è `set`, corrispondente al valore predefinito; il contenuto è a valore singolo. + `name:type(set)[]`: la cardinalità è `set` e il contenuto ha valori multipli. + `name:type(single)[]`: questa combinazione è contraddittoria e provoca un errore. Nella sezione seguente sono elencati tutti i tipi di dati Gremlin disponibili. ## Tipi di dati Gremlin Si tratta di un elenco dei tipi di proprietà consentiti, con una descrizione per ognuno di essi. **Bool (o Booleano)** Indica un campo Booleano. Valori consentiti: `false`, `true` **Nota** Qualsiasi valore diverso da `true` verrà trattato come false. **Tipi Numero intero** I valori al di fuori degli intervalli definiti determinano un errore. | | | Tipo | Intervallo | | --- |--- | | Byte | Da -128 a 127 | | Breve | Da -32768 a 32767 | | Int | Da -2^31 a 2^31-1 | | Lungo | Da -2^63 a 2^63-1 | **Tipi Numero decimale** Supporta la notazione sia decimale sia scientifica. Inoltre, consente simboli come (\$1/-) Infinity o NaN. INF non è supportato. | | | Tipo | Range | | --- |--- | | Float | A virgola mobile a 32 bit IEEE 754 | | Double | A virgola mobile a 64 bit IEEE 754 | I valori float e doppi che sono troppo lunghi vengono caricati e arrotondati al valore più vicino per 24 bit (float) e 53 bit (doppi). Un valore medio viene arrotondato a 0 per le ultime cifre rimanenti a livello di bit. **Stringa** Le virgolette sono facoltative. Per virgole, nuova riga e ritorno a capo viene automaticamente inserito un carattere di escape, se sono inclusi in una stringa racchiusa tra virgolette doppie (`"`). *Esempio*: `"Hello, World"` Per includere le virgolette in una stringa tra virgolette, è possibile inserire il carattere di escape per le virgolette utilizzandone due consecutivi: *Esempio:* `"Hello ""World"""` Sono consentiti array di stringhe, ma le stringhe in un array non possono includere il carattere punto e virgola (`;`) a meno che non venga preceduto da una barra rovesciata (come in questo caso :`\;`). Se desideri racchiudere le stringhe in una matrice con le virgolette, devi racchiudere l'intera matrice con una serie di virgolette. *Esempio*: `"String one; String 2; String 3"` **Data** Data Java i formato ISO-8601. Supporta i seguenti formati:`yyyy-MM-dd`,`yyyy-MM-ddTHH:mm`,`yyyy-MM-ddTHH:mm:ss`,`yyyy-MM-ddTHH:mm:ssZ`. I valori vengono convertiti in ora epocale e memorizzati. **Datetime** Data Java i formato ISO-8601. Supporta i seguenti formati:`yyyy-MM-dd`,, `yyyy-MM-ddTHH:mm``yyyy-MM-ddTHH:mm:ss`,`yyyy-MM-ddTHH:mm:ssZ`. I valori vengono convertiti in ora epocale e memorizzati. ## Formato di riga Gremlin **Delimitatori** I campi in una riga sono separati da una virgola. I record sono separati da una nuova riga o da una nuova riga seguita da un ritorno a capo. **Campi vuoti** I campi vuoti sono consentiti per le colonne non obbligatorie (ad esempio le proprietà definite dall'utente). Un campo vuoto richiede comunque un separatore virgola. I campi vuoti nelle colonne obbligatorie genereranno un errore di analisi. I valori di stringa vuoti vengono interpretati come valori di stringa vuoti per il campo e non come campi vuoti. L'esempio nella sezione successiva presenta un campo vuoto in ciascun vertice. **Vertice IDs** I valori `~id` devono essere univoci per tutti i vertici in ogni file di vertici. A un singolo vertice nel grafo vengono applicate più righe di vertice con valori `~id` identici. La stringa vuota (`""`) è un id valido e il vertice viene creato con una stringa vuota come id. **Spigolo IDs** I valori `~id` devono essere univoci anche per tutti gli edge in ogni file di edge. All'unico edge nel grafo vengono applicate più righe di edge con valori `~id` identici. La stringa vuota (`""`) è un ID valido e il bordo viene creato con una stringa vuota come id. **Etichette** Le etichette distinguono tra maiuscole e minuscole e non possono essere vuote. Un valore di `""` genererà un errore. **Valori delle stringhe** Le virgolette sono facoltative. Per virgole, nuova riga e ritorno a capo viene automaticamente inserito un carattere di escape, se sono inclusi in una stringa racchiusa tra virgolette doppie (`"`). I valori di stringa vuoti `("")` vengono interpretati come un valore di stringa vuoto per il campo e non come un campo vuoto. ## Specifica del formato CSV Il formato CSV Neptune segue le specifiche CSV RFC 4180, inclusi i seguenti requisiti. + Sono supportate le terminazioni di riga di entrambi gli stili, Unix e Windows (\$1 n o\$1r\$1n). + Qualsiasi campo può essere racchiuso tra virgolette (doppie). + I campi contenenti un'interruzione di riga, virgolette doppie o virgole devono essere racchiusi tra virgolette (in caso contrario, il caricamento viene interrotto immediatamente). + Un carattere virgolette doppie (`"`) in un campo deve essere rappresentato da due (doppi) caratteri. Ad esempio, una stringa `Hello "World"` deve essere presente nei dati come `"Hello ""World"""`. + Gli spazi circostanti tra i delimitatori vengono ignorati. Se una riga è presente come`value1, value2`, vengono archiviati come `"value1"` e`"value2"`. + Tutti gli altri caratteri di escape vengono archiviati integralmente. Ad esempio, `"data1\tdata2"` viene archiviato come `"data1\tdata2"`. Se i caratteri sono racchiusi tra virgolette, non sono necessari ulteriori caratteri di escape. + Sono consentiti campi vuoti. Un campo vuoto viene considerato come un valore vuoto. + Per separare più valori per un campo viene utilizzato il punto e virgola (`;`). Per ulteriori informazioni, vedi [Common Format and MIME Type for CSV Files](https://tools.ietf.org/html/rfc4180) nel sito Web Internet Engineering Task Force (IETF). ## Esempio Gremlin Il diagramma seguente mostra un esempio di due vertici e uno spigolo presi dal TinkerPop Modern Graph. ![\[Diagramma che mostra due vertici e un edge, contiene marko age 29 e lop software con lang: java.\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/tiny-modern-graph.png) Di seguito è riportato il grafo nel formato di caricamento CSV Neptune. File del vertice: ``` ~id,name:String,age:Int,lang:String,interests:String[],~label v1,"marko",29,,"sailing;graphs",person v2,"lop",,"java",,software ``` Vista tabulare del file del vertice: | | | | | | | | --- |--- |--- |--- |--- |--- | | \$1id | name:String | age:Int | lang:String | Interessi: string [] | \$1label | | v1 | "marko" | 29 | | ["navigazione», «grafici"] | person | | v2 | "lop" | | "java" | | software | File di edge: ``` ~id,~from,~to,~label,weight:Double e1,v1,v2,created,0.4 ``` Vista tabulare del file di edge: | | | | | | | --- |--- |--- |--- |--- | | \$1id | \$1from | \$1to | \$1label | weight:Double | | e1 | v1 | v2 | creato | 0.4 | **Fasi successive** Ora che hai una maggiore conoscenza dei formati di caricamento, vedi [Esempio: caricamento di dati in un'istanza database Neptune](bulk-load-data.md). # Formato di caricamento dei dati openCypher Per caricare i dati openCypher utilizzando il formato CSV openCypher, è necessario specificare nodi e relazioni in file separati. Lo strumento di caricamento può caricare da più di questi file di nodi e file di relazioni in un unico processo di caricamento. Per ogni comando di caricamento, il set di file da caricare deve avere lo stesso prefisso di percorso in un bucket Amazon Simple Storage Service. Il prefisso viene specificato nel parametro di origine. I nomi e le estensioni effettivi dei file non sono importanti. In Amazon Neptune, il formato CSV openCypher è conforme alla specifica CSV RFC 4180. Per ulteriori informazioni, vedere [Common Format and MIME Type for CSV Files](https://tools.ietf.org/html/rfc4180) (https://tools.ietf.org/html/rfc4180) sul sito Web di Internet Engineering Task Force (IETF). **Nota** Questi file DEVONO essere codificati in formato UTF-8. Ogni file ha una riga di intestazione separata da virgole che contiene sia intestazioni di colonna di sistema che intestazioni di colonna di proprietà. ## Intestazioni di colonna di sistema nei file di caricamento dati openCypher Una determinata colonna di sistema può essere presente una sola volta in ogni file. Tutte le etichette delle intestazioni di colonna di sistema fanno distinzione tra maiuscole e minuscole. Le intestazioni di colonna di sistema obbligatorie e consentite sono diverse per i file di caricamento dei nodi e i file di caricamento delle relazioni openCypher: ### Intestazioni di colonna di sistema nei file dei nodi + **`:ID`**: (obbligatorio) ID per il nodo. È possibile aggiungere uno spazio ID opzionale all'intestazione di colonna `:ID` del nodo in questo modo: `:ID(ID Space)`. Un esempio è `:ID(movies)`. Quando caricate le relazioni che collegano i nodi di questo file, utilizzate gli stessi spazi ID nelle colonne dei file di relazione. `:START_ID` and/or `:END_ID` La colonna `:ID` del nodo può essere facoltativamente archiviata come proprietà nel formato `property name:ID`. Un esempio è `name:ID`. IDs Il nodo deve essere unico per tutti i file di nodi nel caricamento corrente e precedente. Se viene utilizzato uno spazio ID, il nodo IDs deve essere univoco per tutti i file di nodi che utilizzano lo stesso spazio ID nei caricamenti correnti e precedenti. + **`:LABEL`**: etichetta per il nodo. Quando si utilizzano più valori di etichetta per un singolo nodo, ogni etichetta deve essere separata da punto e virgola ()`;`. ### Intestazioni di colonna di sistema nei file delle relazioni + **`:ID`**: ID della relazione. È obbligatorio quando `userProvidedEdgeIds` è true (impostazione predefinita), ma non è valido quando `userProvidedEdgeIds` è `false`. La relazione IDs deve essere unica in tutti i file di relazione nei caricamenti correnti e precedenti. + **`:START_ID`**: (*obbligatorio*) ID del nodo da cui inizia questa relazione. Facoltativamente, è possibile associare uno spazio ID alla colonna ID iniziale nel formato `:START_ID(ID Space)`. Lo spazio ID assegnato all'ID nodo iniziale deve corrispondere allo spazio ID assegnato al nodo nel relativo file dei nodi. + **`:END_ID`**: (*obbligatorio*) ID del nodo in cui termina questa relazione. Facoltativamente, è possibile associare uno spazio ID alla colonna ID finale nel formato `:END_ID(ID Space)`. Lo spazio ID assegnato all'ID nodo finale deve corrispondere allo spazio ID assegnato al nodo nel relativo file dei nodi. + **`:TYPE`**: tipo della relazione. Le relazioni possono avere un solo tipo. **Nota** [Caricamento di dati openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher)Per informazioni su come il nodo o la relazione duplicati IDs vengono gestiti dal processo di caricamento in blocco, vedere. ### Intestazioni di colonna di proprietà nei file di caricamento dati openCypher È possibile specificare che una colonna contenga i valori di una particolare proprietà utilizzando l'intestazione di una colonna di proprietà nel seguente formato: ``` propertyname:type ``` Lo spazio, la virgola, il riepilogo e i caratteri di nuova riga non sono consentiti nelle intestazioni delle colonne, pertanto i nomi delle proprietà non possono includere questi caratteri. Ecco un esempio di intestazione di colonna per una proprietà denominata `age` di tipo `Int`: ``` age:Int ``` La colonna con `age:Int` come intestazione di colonna dovrebbe quindi contenere un numero intero o un valore vuoto in ogni riga. ## Tipi di dati nei file di caricamento dati di Neptune openCypher + **`Bool`** o **`Boolean`**: campo booleano. I valori consentiti sono `true` e `false`. Qualsiasi valore diverso da `true` viene trattato come `false`. + **`Byte`**: numero intero compreso tra `-128` e `127`. + **`Short`**: numero intero compreso tra `-32,768` e `32,767`. + **`Int`**: numero intero compreso tra `-2^31` e `2^31 - 1`. + **`Long`**: numero intero compreso tra `-2^63` e `2^63 - 1`. + **`Float`**: numero in virgola mobile IEEE 754 a 32 bit. Sono supportate sia la notazione decimale che la notazione scientifica. `Infinity`, `-Infinity` e `NaN` sono tutti riconosciuti, mentre `INF` non lo è. I valori che contengono troppe cifre vengono arrotondati al valore più vicino (un valore intermedio viene arrotondato a 0 per l'ultima cifra rimanente a livello di bit). + **`Double`**: numero in virgola mobile IEEE 754 a 64 bit. Sono supportate sia la notazione decimale che la notazione scientifica. `Infinity`, `-Infinity` e `NaN` sono tutti riconosciuti, mentre `INF` non lo è. I valori che contengono troppe cifre vengono arrotondati al valore più vicino (un valore intermedio viene arrotondato a 0 per l'ultima cifra rimanente a livello di bit). + **`String`**: le virgolette sono facoltative. Per i caratteri di virgola, nuova riga e ritorno a capo viene automaticamente inserito un carattere di escape, se sono inclusi in una stringa racchiusa tra virgolette doppie (`"`) come `"Hello, World"`. È possibile includere le virgolette in una stringa tra virgolette usandone due di seguito come `"Hello ""World"""`. + **`DateTime`**: data Java in uno dei seguenti formati ISO-8601: + `yyyy-MM-dd` + `yyyy-MM-ddTHH:mm` + `yyyy-MM-ddTHH:mm:ss` + `yyyy-MM-ddTHH:mm:ssZ` ### Tipi di dati con trasmissione automatica nei file di caricamento dati di Neptune openCypher I tipi di dati con trasmissione automatica vengono forniti per caricare tipi di dati attualmente non supportati in modo nativo da Neptune. I dati in tali colonne vengono archiviati letteralmente come stringhe senza alcuna verifica rispetto ai formati previsti. Sono consentiti i seguenti tipi di dati con trasmissione automatica: + **`Char`**: campo `Char`. Archiviato come stringa. + **`Date`**, **`LocalDate`** e **`LocalDateTime`**: vedi [Neo4j Temporal Instants](https://neo4j.com/docs/cypher-manual/current/values-and-types/temporal/#cypher-temporal-instants) per una descrizione dei tipi `date`, `localdate` e `localdatetime`. I valori vengono caricati letteralmente come stringhe, senza convalida. + **`Duration`**: vedi [Neo4j Duration format](https://neo4j.com/docs/cypher-manual/current/values-and-types/temporal/#cypher-temporal-durations). I valori vengono caricati letteralmente come stringhe, senza convalida. + **Point**: campo Point per l'archiviazione di dati spaziali. Vedi [Spatial instants](https://neo4j.com/docs/cypher-manual/current/values-and-types/spatial/#spatial-values-spatial-instants). I valori vengono caricati letteralmente come stringhe, senza convalida. ## Esempio del formato di caricamento openCypher Il seguente diagramma tratto dal TinkerPop Modern Graph mostra un esempio di due nodi e una relazione: ![\[Diagramma di due nodi e una relazione tra di essi.\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/tinkerpop-2-nodes-and-relationship.png) Di seguito è riportato il grafo nel normale formato di caricamento di Neptune openCypher. **File dei nodi:** ``` :ID,name:String,age:Int,lang:String,:LABEL v1,"marko",29,,person v2,"lop",,"java",software ``` **File di relazione:** ``` :ID,:START_ID,:END_ID,:TYPE,weight:Double e1,v1,v2,created,0.4 ``` In alternativa, è possibile utilizzare gli spazi ID e l'ID come proprietà, come segue: **File del primo nodo:** ``` name:ID(person),age:Int,lang:String,:LABEL "marko",29,,person ``` **File del secondo nodo:** ``` name:ID(software),age:Int,lang:String,:LABEL "lop",,"java",software ``` **File di relazione:** ``` :ID,:START_ID(person),:END_ID(software),:TYPE,weight:Double e1,"marko","lop",created,0.4 ``` # Formati dei dati di caricamento RDF Per caricare i dati Resource Descrizione Framework (RDF), puoi utilizzare uno dei seguenti formati standard come specificato dal World Wide Web Consortium (W3C): + N-Triples (`ntriples`) in base alle specifiche all'indirizzo [https://www.w3.org/TR/n-triples/](https://www.w3.org/TR/n-triples/) + N-Quads (`nquads`) in base alle specifiche all'indirizzo [https://www.w3.org/TR/n-quads/](https://www.w3.org/TR/n-quads/) + RDF/XML (`rdfxml`) in base alle specifiche all'indirizzo [https://www.w3.org/TR/rdf-syntax-grammar/](https://www.w3.org/TR/rdf-syntax-grammar/) + Turtle (`turtle`) in base alle specifiche all'indirizzo [https://www.w3.org/TR/turtle/](https://www.w3.org/TR/turtle/) **Importante** Tutti i file devono essere codificati in formato UTF-8. Per i dati N-Quads e N-triples che includono caratteri Unicode, sono supportate le sequenze di escape `\uxxxxx`. Tuttavia, Neptune non supporta la normalizzazione. Se è presente un valore che richiede la normalizzazione, non corrisponderà byte-to-byte durante l'interrogazione. Per ulteriori informazioni sulla normalizzazione, vedi la pagina relativa alla [normalizzazione](https://unicode.org/faq/normalization.html) su [Unicode.org](https://unicode.org). **Fasi successive** Ora che hai una maggiore conoscenza dei formati di caricamento, vedi [Esempio: caricamento di dati in un'istanza database Neptune](bulk-load-data.md). # Esempio: caricamento di dati in un'istanza database Neptune Questo esempio illustra come caricare dati in Amazon Neptune. Se non diversamente specificato, è necessario seguire questi passaggi da un'istanza Amazon Elastic Compute Cloud (Amazon EC2) nello stesso Amazon Virtual Private Cloud (VPC) dell'istanza database Neptune. ## Prerequisiti per l'esempio di caricamento di dati Prima di iniziare, devi: + Istanza database Neptune. Per informazioni sull'avvio di un'istanza database Neptune, consulta [Creazione di un cluster Amazon Neptune](get-started-create-cluster.md). + Bucket Amazon Simple Storage Service (Amazon S3) in cui inserire i file di dati. Puoi utilizzare un bucket esistente. Se non disponi di un bucket S3, consulta [Creare un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) nella *[Guida alle operazioni di base di Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)*. + Dati del grafo da caricare, in uno dei formati supportati dallo strumento di caricamento Neptune: Se state usando Gremlin per interrogare il vostro grafico, Neptune può caricare i dati in un formato comma-separated-values (`CSV`), come descritto in. [Formato dati di caricamento Gremlin](bulk-load-tutorial-format-gremlin.md) Se si utilizza openCypher per eseguire query sul grafo, Neptune può anche caricare i dati in un formato `CSV` specifico di openCypher, come descritto in [Formato di caricamento dei dati openCypher](bulk-load-tutorial-format-opencypher.md). Se si utilizza SPARQL, Neptune può caricare i dati in diversi formati RDF, come descritto in [Formati dei dati di caricamento RDF](bulk-load-tutorial-format-rdf.md). + Ruolo IAM che deve essere assunto dall'istanza database Neptune dotato di una policy IAM che consenta l'accesso ai file di dati nel bucket S3. La policy deve concedere le autorizzazioni per la lettura e la presentazione di elenchi. 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). **Nota** L'API Neptune `Load` necessita solo dell'accesso in lettura ai file di dati. Non è necessario che la policy IAM conceda l'accesso in scrittura o l'accesso all'intero bucket. + Endpoint VPC Amazon S3. Per ulteriori informazioni, consulta la sezione [Creazione di un endpoint VPC Amazon S3](#bulk-load-prereqs-s3). ### Creazione di un endpoint VPC Amazon S3 Lo strumento di caricamento Neptune richiede un endpoint VPC per Amazon S3. **Per configurare l'accesso ad Amazon S3** 1. Accedi Console di gestione AWS e apri la console Amazon VPC all'indirizzo. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. Nel riquadro di navigazione a sinistra, scegli **Endpoints** (Endpoint). 1. Scegliere **Create Endpoint** (Crea endpoint). 1. Scegli il **Service Name (Nome servizio)** `com.amazonaws.region.s3`. **Nota** Se la regione indicata qui non è corretta, verifica che lo sia la regione della console. 1. Scegli il VPC che contiene l'istanza database Neptune. 1. Selezionare la casella di controllo accanto alle tabelle di routing associate alle sottoreti correlate al proprio cluster. Se si dispone di una sola tabella di routing, è necessario selezionare la casella corrispondente. 1. Scegliere **Create Endpoint** (Crea endpoint). Per ulteriori informazioni sulla creazione dell'endpoint, consulta [Endpoint VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html#create-vpc-endpoint) nella *Guida per l'utente di Amazon VPC*. Per informazioni sulle limitazioni degli endpoint VPC, consulta [Endpoint VPC per Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html). **Per caricare i dati in un'istanza database Neptune** 1. Copiare i file di dati in un bucket Amazon S3. Il bucket S3 deve trovarsi nella stessa AWS regione del cluster che carica i dati. È possibile utilizzare il seguente AWS CLI comando per copiare i file nel bucket. **Nota** Non è necessario eseguire questo comando dall'istanza Amazon EC2. ``` aws s3 cp data-file-name s3://bucket-name/object-key-name ``` **Nota** In Amazon S3 un **nome chiave dell'oggetto** è il percorso intero di un file, incluso il nome. *Esempio:* nel comando `aws s3 cp datafile.txt s3://examplebucket/mydirectory/datafile.txt`, il nome chiave dell'oggetto è **`mydirectory/datafile.txt`**. In alternativa, puoi utilizzare il Console di gestione AWS per caricare file nel bucket S3. Apri la console Amazon S3 all'indirizzo [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)e scegli un bucket. Nell'angolo superiore sinistro, scegli **Upload (Carica)** per caricare i file. 1. Da una finestra a riga di comando, inserisci quanto segue per eseguire lo strumento di caricamento Neptune, utilizzando i valori corretti per l'endpoint, il percorso Amazon S3, il formato e l'ARN del ruolo IAM. Il parametro `format` può essere uno dei seguenti valori: `csv` per Gremlin, `opencypher` per openCypher o `ntriples`, `nquads`, `turtle` e `rdfxml` per RDF. Per informazioni sugli altri parametri, vedi [Comando dello strumento di caricamento Neptune](load-api-reference-load.md). Per informazioni su come trovare il nome host dell'istanza database Neptune, consulta la sezione [Connessione agli endpoint Amazon Neptune](feature-overview-endpoints.md). Il parametro della regione deve corrispondere alla regione del cluster e del bucket S3. Amazon Neptune è disponibile nelle seguenti regioni: AWS + 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` ``` curl -X POST \ -H 'Content-Type: application/json' \ https://your-neptune-endpoint:port/loader -d ' { "source" : "s3://bucket-name/object-key-name", "format" : "format", "iamRoleArn" : "arn:aws:iam::account-id:role/role-name", "region" : "region", "failOnError" : "FALSE", "parallelism" : "MEDIUM", "updateSingleCardinalityProperties" : "FALSE", "queueRequest" : "TRUE", "dependencies" : ["load_A_id", "load_B_id"] }' ``` Per informazioni su come creare un ruolo IAM e associarlo a un cluster Neptune, vedi [Prerequisiti: ruolo IAM e accesso ad Amazon S3](bulk-load-tutorial-IAM.md). **Nota** Consulta [Parametri della richiesta dello dello strumento di caricamento Neptune](load-api-reference-load.md#load-api-reference-load-parameters) per informazioni dettagliate sui parametri della richiesta di caricamento. In breve: Il parametro `source` accetta un URI Amazon S3 che punta a un file singolo o a una cartella. Se si specifica una cartella, Neptune carica tutti i file di dati presenti nella cartella. La cartella può contenere più file vertex e più file edge. 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` Il parametro `format` può essere uno dei seguenti: Formato CSV Gremlin (`csv`) per i grafi di proprietà Gremlin Formato CSV openCypher (`opencypher`) per i grafi di proprietà openCypher Formato N -Triples (`ntriples`) per RDF/SPARQL Formato N-Quads (`nquads`) per RDF/SPARQL Formato RDF/XML (`rdfxml`) per RDF/SPARQL Formato Turtle (`turtle`) per RDF/SPARQL Il parametro opzionale `parallelism` consente di limitare il numero di thread utilizzati nel processo di caricamento in blocco. Può essere impostato su `LOW`, `MEDIUM`, `HIGH` o `OVERSUBSCRIBE`. Quando `updateSingleCardinalityProperties` è impostato su `"FALSE"`, lo strumento di caricamento restituisce un errore se viene fornito più di un valore in un file di origine caricato per una proprietà vertice a cardinalità singola o edge. L'impostazione di `queueRequest` su `"TRUE"` fa sì che la richiesta di caricamento venga inserita in una coda se è già in esecuzione un’attività di caricamento. Il parametro `dependencies` rende l'esecuzione della richiesta di caricamento subordinata al completamento di una o più attività di caricamento già inserita nella coda. 1. Lo strumento di caricamento Neptune restituisce un oggetto `id` del processo che consente di controllare lo stato o di annullare il processo di caricamento, ad esempio: ``` { "status" : "200 OK", "payload" : { "loadId" : "ef478d76-d9da-4d94-8ff1-08d9d4863aa5" } } ``` 1. Inserisci il comando seguente per ottenere lo stato del caricamento con il valore `loadId` della **Fase 3**: ``` curl -G 'https://your-neptune-endpoint:port/loader/ef478d76-d9da-4d94-8ff1-08d9d4863aa5' ``` Se lo stato del caricamento elenca un errore, è possibile richiedere uno stato più dettagliato e un elenco degli errori. Per maggiori informazioni ed esempi, consulta [API Neptune Loader Get-Status](load-api-reference-status.md). 1. (Facoltativo) Annullare il processo `Load`. inserisci il comando seguente per eseguire un `Delete` del processo dello strumento di caricamento con il valore `id` del processo della **Fase 3**: ``` curl -X DELETE 'https://your-neptune-endpoint:port/loader/ef478d76-d9da-4d94-8ff1-08d9d4863aa5' ``` Il comando `DELETE` restituisce il codice HTTP `200 OK` ad annullamento eseguito. I dati provenienti dai file dal processo di caricamento terminato non vengono ripristinati. I dati rimangono nell'istanza database Neptune. # Ottimizzazione di un caricamento in blocco di Amazon Neptune Utilizzare le seguenti strategie per ridurre al minimo il tempo di caricamento per un caricamento in blocco di Neptune: + **Pulire i dati:** + Assicurarsi di convertire i dati in un [formato di dati supportato](bulk-load-tutorial-format.md) prima di caricarli. + Rimuovere eventuali duplicati o errori noti. + Ridurre il più possibile il numero di predicati univoci (come le proprietà di archi e vertici). + **Ottimizzare i file:** + Se si caricano file di grandi dimensioni come i file CSV da un bucket Amazon S3, lo strumento di caricamento gestisce la concorrenza per l'utente analizzandoli in blocchi che possono essere caricati in parallelo. L'utilizzo di un numero molto elevato di file di piccole dimensioni può rallentare questo processo. + Se carichi più file da un prefisso Amazon S3, il loader carica automaticamente prima i file vertex, poi i file edge. Tuttavia, se sai che caricherai solo file edge, `edgeOnlyLoad` puoi impostare in modo da `TRUE` ignorare il primo passaggio in cui tutti i file vengono scansionati per determinarne il contenuto (vertici o bordi) in modo che tutti i file con i vertici trovati vengano caricati prima di qualsiasi file edge. Questo può velocizzare notevolmente il tempo di caricamento, specialmente quando sono coinvolti molti file edge. Nel caso in cui alcuni file vertex siano presenti anche nello stesso prefisso Amazon S3 `source` (parametro), verranno caricati ma senza alcuna garanzia di ordine rispetto ad altri file. Inoltre, se alcuni `from` `to` vertici non sono presenti nel database, l'inserimento degli edge potrebbe riportare errori nel messaggio. `FROM_OR_TO_VERTEX_ARE_MISSING` Come best practice, inserisci nodi e edge in un prefisso Amazon S3 separato. + **Controllare le impostazioni dello dello strumento di caricamento:** + Se non è necessario eseguire altre operazioni durante il caricamento, utilizzare il parametro [`OVERSUBSCRIBE`  `parallelism`](load-api-reference-load.md#load-api-reference-load-syntax). Questa impostazione dei parametri fa sì che lo strumento di caricamento in blocco utilizzi tutte le risorse della CPU disponibili durante l'esecuzione. In genere è necessario il 60%-70% della capacità della CPU per mantenere l'operazione in esecuzione alla velocità consentita dai vincoli. I/O **Nota** Quando `parallelism` è impostato su `OVERSUBSCRIBE` o `HIGH` (l'impostazione predefinita), durante il caricamento dei dati openCypher c'è il rischio che i thread incontrino una race condition e un deadlock, causando un errore `LOAD_DATA_DEADLOCK`. In questo caso, impostare `parallelism` su un'impostazione inferiore e riprovare a eseguire il caricamento. + Se il processo di caricamento include più richieste di caricamento, utilizzare il parametro `queueRequest`. L'impostazione di `queueRequest` su `TRUE` consente a Neptune di mettere in coda le richieste in modo da non dover aspettare che una finisca prima di inviarne un'altra. + Se le richieste di caricamento vengono messe in coda, è possibile impostare i livelli di dipendenza utilizzando il parametro `dependencies`, in modo che l'esito negativo di un processo causi l'esito negativo dei processi dipendenti. In questo modo è possibile evitare incongruenze nei dati caricati. + Se un processo di caricamento prevede l'aggiornamento di valori caricati in precedenza, assicurarsi di impostare il parametro `updateSingleCardinalityProperties` su `TRUE`. In caso contrario, lo strumento di caricamento considererà un errore il tentativo di aggiornare un valore di cardinalità singola esistente. Per i dati Gremlin, la cardinalità è specificata anche nelle intestazioni di colonna di proprietà (vedi [Intestazioni di colonna delle proprietà](bulk-load-tutorial-format-gremlin.md#bulk-load-tutorial-format-gremlin-propheaders)). **Nota** Il parametro `updateSingleCardinalityProperties` non è disponibile per i dati RDF (Resource Description Framework). + È possibile utilizzare il parametro `failOnError` per determinare se le operazioni di caricamento in blocco devono avere esito negativo o continuare quando si verifica un errore. Inoltre, è possibile utilizzare il parametro `mode` per assicurarsi che un processo di caricamento riprenda il caricamento dal punto in cui un processo precedente ha avuto esito negativo anziché ricaricare i dati che erano già stati caricati. + **Aumentare la capacità:** impostare l'istanza di scrittura del cluster database sulla dimensione massima prima del caricamento in blocco. Tenere presente che se si esegue questa operazione, è necessario aumentare la capacità anche di tutte le istanze di replica di lettura nel cluster database o rimuoverle fino al termine del caricamento dei dati. Una volta completato il caricamento in blocco, assicurarsi di dimensionare nuovamente l'istanza di scrittura. **Importante** Se si verifica un ciclo di riavvii ripetuti delle repliche di lettura a causa del ritardo di replica durante un caricamento in blocco, è probabile che le repliche non riescano a stare al passo con l'istanza di scrittura nel cluster database. Dimensionare le istanze di lettura in modo che siano più grandi dell'istanza di scrittura oppure rimuoverle temporaneamente durante il caricamento in blocco e quindi ricrearle al termine dell'operazione. Vedi [Parametri della richiesta](load-api-reference-load.md#load-api-reference-load-parameters) per maggiori dettagli sull'impostazione dei parametri di richiesta dello strumento di caricamento. # 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' ``` # Utilizzo AWS Database Migration Service per caricare dati in Amazon Neptune da un altro data store AWS Database Migration Service (AWS DMS) può caricare dati in Neptune [dai database di origine supportati](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.html) in modo rapido e sicuro. Il database di origine resterà completamente operativo anche durante la migrazione, per ridurre al minimo le interruzioni delle applicazioni che lo utilizzano. [Informazioni dettagliate AWS DMS in merito sono disponibili nella [Guida per l'AWS Database Migration Service utente](https://docs.aws.amazon.com/dms/latest/userguide/) e nell'API Reference.AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/APIReference/) In particolare, è possibile trovare informazioni su come impostare un cluster Neptune come destinazione per la migrazione in [Utilizzo di Amazon Neptune come destinazione per AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.Neptune.html). Di seguito sono riportati alcuni prerequisiti per l'importazione di dati in Neptune usando AWS DMS: + Dovrai creare un oggetto di mappatura delle AWS DMS tabelle per definire come estrarre i dati dal database di origine (vedi [Specificare la selezione e le trasformazioni delle tabelle mediante la mappatura delle tabelle utilizzando JSON](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.html#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation) nella Userguide per i dettagli). AWS DMS Questo oggetto di configurazione della mappatura della tabella specifica quali tabelle devono essere lette e in quale ordine e come vengono denominate le colonne. Può anche filtrare le righe copiate e fornire semplici trasformazioni di valore come la conversione in minuscolo o l'arrotondamento. + Sarà necessario creare un oggetto Neptune `GraphMappingConfig` per specificare come devono essere caricati i dati estratti dal database di origine in Neptune. Per i dati RDF (interrogati utilizzando SPARQL), `GraphMappingConfig` viene scritto nel linguaggio di mappatura [R2RML](https://www.w3.org/TR/r2rml/) standard di W3. Per i dati dei grafi di proprietà (sottoposti a query mediante Gremlin), `GraphMappingConfig` è un oggetto JSON, descritto in [GraphMappingConfig Layout per dati Property-Graph/Gremlin](dms-neptune-graph-mapping.md#dms-neptune-graph-mapping-gremlin). + È necessario utilizzare AWS DMS per creare un'istanza di replica nello stesso VPC del cluster Neptune DB, per mediare il trasferimento dei dati. + Sarà inoltre necessario utilizzare un bucket Amazon S3 come spazio di archiviazione intermedio per la gestione temporanea dei dati di migrazione. # Creare un Nettuno GraphMappingConfig L'oggetto `GraphMappingConfig` creato specifica come i dati estratti da un datastore di origine devono essere caricati in un cluster database Neptune. Il suo formato varia a seconda che sia destinato al caricamento di dati RDF o al caricamento di dati del grafo delle proprietà. Per i dati RDF, è possibile utilizzare il linguaggio W3 [R2RML](https://www.w3.org/TR/r2rml/) per mappare i dati relazionali a RDF. Se si stanno caricando i dati del grafico delle proprietà per essere interrogati utilizzando Gremlin, si crea un oggetto JSON per `GraphMappingConfig`. ## GraphMappingConfig Layout per i dati RDF/SPARQL Se si stanno caricando dati RDF per essere interrogati utilizzando SPARQL, si scrive `GraphMappingConfig` in [R2RML](https://www.w3.org/TR/r2rml/). `R2RML` è un linguaggio W3 standard per la mappatura dei dati relazionali a RDF. Ecco un esempio: ``` @prefix rr: . @prefix ex: . <#TriplesMap1> rr:logicalTable [ rr:tableName "nodes" ]; rr:subjectMap [ rr:template "http://data.example.com/employee/{id}"; rr:class ex:Employee; ]; rr:predicateObjectMap [ rr:predicate ex:name; rr:objectMap [ rr:column "label" ]; ] . ``` Ecco un altro esempio: ``` @prefix rr: . @prefix ex: . @prefix foaf: . @prefix xsd: . <#TriplesMap2> rr:logicalTable [ rr:tableName "Student" ]; rr:subjectMap [ rr:template "http://example.com/{ID}{Name}"; rr:class foaf:Person ]; rr:predicateObjectMap [ rr:predicate ex:id ; rr:objectMap [ rr:column "ID"; rr:datatype xsd:integer ] ]; rr:predicateObjectMap [ rr:predicate foaf:name ; rr:objectMap [ rr:column "Name" ] ] . ``` La raccomandazione W3 a [R2RML: RDB to RDF Mapping Language](https://www.w3.org/TR/r2rml/) fornisce i dettagli della lingua. ## GraphMappingConfig Layout per dati Property-Graph/Gremlin Un oggetto comparabile `GraphMappingConfig` per i dati del grafico delle proprietà è un oggetto JSON che fornisce una regola di mapping per ogni entità grafico da generare dai dati di origine. Il modello seguente mostra l'aspetto di ogni regola in questo oggetto: ``` { "rules": [ { "rule_id": "(an identifier for this rule)", "rule_name": "(a name for this rule)", "table_name": "(the name of the table or view being loaded)", "vertex_definitions": [ { "vertex_id_template": "{col1}", "vertex_label": "(the vertex to create)", "vertex_definition_id": "(an identifier for this vertex)", "vertex_properties": [ { "property_name": "(name of the property)", "property_value_template": "{col2} or text", "property_value_type": "(data type of the property)" } ] } ] }, { "rule_id": "(an identifier for this rule)", "rule_name": "(a name for this rule)", "table_name": "(the name of the table or view being loaded)", "edge_definitions": [ { "from_vertex": { "vertex_id_template": "{col1}", "vertex_definition_id": "(an identifier for the vertex referenced above)" }, "to_vertex": { "vertex_id_template": "{col3}", "vertex_definition_id": "(an identifier for the vertex referenced above)" }, "edge_id_template": { "label": "(the edge label to add)", "template": "{col1}_{col3}" }, "edge_properties":[ { "property_name": "(the property to add)", "property_value_template": "{col4} or text", "property_value_type": "(data type like String, int, double)" } ] } ] } ] } ``` Si noti che la presenza di un'etichetta di vertice implica che il vertice viene creato qui, mentre la sua assenza implica che il vertice viene creato da una sorgente diversa e questa definizione aggiunge solo proprietà di vertice. Ecco una regola di esempio per un record dipendente: ``` { "rules": [ { "rule_id": "1", "rule_name": "vertex_mapping_rule_from_nodes", "table_name": "nodes", "vertex_definitions": [ { "vertex_id_template": "{emp_id}", "vertex_label": "employee", "vertex_definition_id": "1", "vertex_properties": [ { "property_name": "name", "property_value_template": "{emp_name}", "property_value_type": "String" } ] } ] }, { "rule_id": "2", "rule_name": "edge_mapping_rule_from_emp", "table_name": "nodes", "edge_definitions": [ { "from_vertex": { "vertex_id_template": "{emp_id}", "vertex_definition_id": "1" }, "to_vertex": { "vertex_id_template": "{mgr_id}", "vertex_definition_id": "1" }, "edge_id_template": { "label": "reportsTo", "template": "{emp_id}_{mgr_id}" }, "edge_properties":[ { "property_name": "team", "property_value_template": "{team}", "property_value_type": "String" } ] } ] } ] } ``` # Creazione di un'attività AWS DMS di replica con Neptune come destinazione Dopo aver creato le configurazioni di mapping delle tabelle e mapping dei grafi, utilizzare il seguente processo per caricare i dati dall'archivio di origine in Neptune. Consulta la AWS DMS documentazione per maggiori dettagli su questo argomento. APIs ## Crea un'istanza di AWS DMS replica Crea un'istanza di AWS DMS replica nel VPC su cui è in esecuzione il cluster Neptune DB ([vedi Lavorare con AWS un'istanza di replica DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html) e nella Guida per l'utente). [CreateReplicationInstance](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationInstance.html) AWS DMS A tale scopo, è possibile utilizzare un AWS CLI comando come il seguente: ``` aws dms create-replication-instance \ --replication-instance-identifier (the replication instance identifier) \ --replication-instance-class (the size and capacity of the instance, like 'dms.t2.medium') \ --allocated-storage (the number of gigabytes to allocate for the instance initially) \ --engine-version (the DMS engine version that the instance should use) \ --vpc-security-group-ids (the security group to be used with the instance) ``` ## Crea un AWS DMS endpoint per il database di origine Il passaggio successivo consiste nel creare un AWS DMS endpoint per il data store di origine. Puoi utilizzare l' AWS DMS [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)API in questo AWS CLI modo: ``` aws dms create-endpoint \ --endpoint-identifier (source endpoint identifier) \ --endpoint-type source \ --engine-name (name of source database engine) \ --username (user name for database login) \ --password (password for login) \ --server-name (name of the server) \ --port (port number) \ --database-name (database name) ``` ## Configura un bucket Amazon S3 per Neptune da utilizzare per lo staging dei dati Se non si dispone di un bucket Amazon S3 che è possibile utilizzare per i dati di gestione temporanea, crearne uno come spiegato in [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) nella Guida introduttiva di Amazon S3 o in [Come creare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html) nella Guida per l'utente della console. Sarà necessario creare una policy IAM che conceda le autorizzazioni `GetObject`, `PutObject`, `DeleteObject`e `ListObject` al bucket se non ne esiste già una: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "ListObjectsInBucket", "Effect": "Allow", "Action": [ "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket" ] }, { "Sid": "AllObjectActions", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:PutObject", "s3:DeleteObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/*" ] } ] } ``` ------ Se l'autenticazione IAM del cluster database Neptune è abilitata, sarà necessario includere anche le policy seguenti: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": "neptune-db:*", "Resource": "arn:aws:neptune-db:us-east-1:111122223333:cluster-resource-id/*" } ] } ``` ------ Creare un ruolo IAM come documento di attendibilità a cui collegare la policy: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "dms.amazonaws.com" }, "Action": "sts:AssumeRole" }, { "Sid": "neptune", "Effect": "Allow", "Principal": { "Service": "rds.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ Dopo aver collegato la policy al ruolo, collegare il ruolo al cluster database Neptune. Ciò consentirà di utilizzare il bucket AWS DMS per l'archiviazione temporanea dei dati in fase di caricamento. ## Crea un endpoint Amazon S3 nel VPC Neptune Creare ora un endpoint Gateway VPC per il bucket Amazon S3 intermedio nel VPC in cui si trova il cluster Neptune. È possibile utilizzare Console di gestione AWS o the AWS CLI per eseguire questa operazione, come descritto in [Creazione di un endpoint gateway](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-gateway.html#create-gateway-endpoint). ## Crea un endpoint AWS DMS di destinazione per Neptune Crea un AWS DMS endpoint per il tuo cluster Neptune DB di destinazione. Puoi usare l' AWS DMS [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)API con il `NeptuneSettings` parametro in questo modo: ``` aws dms create-endpoint \ --endpoint-identifier (target endpoint identifier) \ --endpoint-type target \ --engine-name neptune \ --server-name (name of the server) \ --port (port number) \ --neptune-settings '{ \ "ServiceAccessRoleArn": "(ARN of the service access role)", \ "S3BucketName": "(name of S3 bucket to use for staging files when migrating)", \ "S3BucketFolder": "(name of the folder to use in that S3 bucket)", \ "ErrorRetryDuration": (number of milliseconds to wait between bulk-load retries), \ "MaxRetryCount": (the maximum number of times to retry a failing bulk-load job), \ "MaxFileSize": (maximum file size, in bytes, of the staging files written to S3), \ "IamAuthEnabled": (set to true if IAM authentication is enabled on the Neptune cluster) }' ``` L'oggetto JSON passato all' AWS DMS `CreateEndpoint`API nel relativo `NeptuneSettings` parametro ha i seguenti campi: **** + **`ServiceAccessRoleArn`**: *(obbligatorio)* ARN di un ruolo IAM che consente l'accesso con granularità fine al bucket S3 utilizzato per la migrazione dei dati in Neptune. Questo ruolo dovrebbe inoltre disporre delle autorizzazioni per accedere al cluster database Neptune se è abilitata l'autorizzazione IAM. + **`S3BucketName`**: *(obbligatorio)* per la migrazione con caricamento completo, l'istanza di replica converte tutti i dati RDS in file CSV di quadruple e li carica in questo bucket di gestione temporanea in S3 e quindi li carica in blocco in Neptune. + **`S3BucketFolder`**: *(obbligatorio)* cartella da utilizzare nel bucket di gestione temporanea S3. + **`ErrorRetryDuration`**: *(facoltativo)* numero di millisecondi di attesa dopo che una richiesta Neptune ha esito negativo prima di effettuare una richiesta di nuovo tentativo. Il valore di default è 250. + **`MaxRetryCount`**— *(opzionale)* Il numero massimo di richieste di nuovi tentativi da AWS DMS effettuare dopo un errore riprovevole. Il predefinito è 5. + **`MaxFileSize`**: *(facoltativo)* dimensione massima in byte di ogni file di gestione temporanea salvato in S3 durante la migrazione. Il valore predefinito è 1.048.576 KB (1 GB). + **`IsIAMAuthEnabled`**: *(facoltativo)* impostare su `true` se l'autenticazione IAM è abilitata sul cluster database Neptune o su `false` in caso contrario. Il valore predefinito è `false`. ## Prova le connessioni ai nuovi endpoint Puoi testare la connessione a ciascuno di questi nuovi endpoint utilizzando l' AWS DMS [TestConnection](https://docs.aws.amazon.com/dms/latest/APIReference/API_TestConnection.html)API in questo modo: ``` aws dms test-connection \ --replication-instance-arn (the ARN of the replication instance) \ --endpoint-arn (the ARN of the endpoint you are testing) ``` ## Crea un'attività di AWS DMS replica Dopo aver completato con successo i passaggi precedenti, crea un'attività di replica per la migrazione dei dati dal tuo data store di origine a Neptune, utilizzando l'API in questo modo: AWS DMS [CreateReplicationTask](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationTask.html.html) ``` aws dms create-replication-task \ --replication-task-identifier (name for the replication task) \ --source-endpoint-arn (ARN of the source endpoint) \ --target-endpoint-arn (ARN of the target endpoint) \ --replication-instance-arn (ARN of the replication instance) \ --migration-type full-load \ --table-mappings (table-mapping JSON object or URI like 'file:///tmp/table-mappings,json') \ --task-data (a GraphMappingConfig object or URI like 'file:///tmp/graph-mapping-config.json') ``` Il parametro `TaskData` fornisce l'oggetto [GraphMappingConfig](dms-neptune-graph-mapping.md) che specifica come i dati copiati devono essere archiviati in Neptune. ## Avviate l'attività di replica AWS DMS Ora è possibile avviare l'attività di replica: ``` aws dms start-replication-task --replication-task-arn (ARN of the replication task started in the previous step) --start-replication-task-type start-replication ``` # Caricamento di dati in Amazon Neptune tramite query Neptune supporta la scrittura di dati direttamente tramite operazioni di linguaggio di interrogazione. È possibile utilizzare operazioni di scrittura standard come `CREATE` e `MERGE` in OpenCypher, in SPARQL o `INSERT` in Gremlin per aggiungere o `mergeV()` modificare dati `mergeE()` nel grafico. Queste operazioni sono adatte per aggiornamenti incrementali e scritture transazionali. Per caricare dati da Amazon S3, usa il [Utilizzo del bulk loader Amazon Neptune per importare dati](bulk-load.md) set di dati di grandi dimensioni che richiedono prestazioni ottimizzate. Per set di dati più piccoli in uno o pochi file Amazon S3, puoi utilizzare funzioni di caricamento basate su query per leggere ed elaborare i dati direttamente all'interno delle tue query. Sono disponibili le seguenti funzioni di caricamento basate su query: ## OpenCypher: neptune.read () La `neptune.read()` funzione legge i file CSV o Parquet da Amazon S3 all'interno di `CALL` una sottoquery, consentendoti di elaborare e caricare i dati al momento della query. ``` CALL neptune.read({ source: "s3://bucket/data.csv", format: "csv" }) YIELD row CREATE (n:Person {id: row.id, name: row.name}) ``` Per la documentazione completa, consulta. [neptune.read ()](access-graph-opencypher-21-extensions-s3-read.md) ## SPARQL: CARICA e SCARICA `LOAD`Le operazioni SPARQL importano dati RDF da un URI in un grafico denominato. `UNLOAD`esporta i dati da un grafico in Amazon S3. ``` LOAD INTO GRAPH ``` Per la documentazione completa, consulta[Utilizzo di SPARQL UPDATE LOAD per l'importazione di dati in Neptune](sparql-api-reference-update-load.md). ## Gremlin: passo io () Puoi anche usare il `g.io(URL).read()` passaggio di Gremlin per leggere file di dati in GraphML (un formato [XML), GraphSon](https://tinkerpop.apache.org/docs/current/dev/io/#graphml) (un formato [JSON](https://tinkerpop.apache.org/docs/current/dev/io/#graphson)) e altri formati. ``` g.io("s3://bucket/data.graphml").read().iterate() ``` [Consulta la documentazione per i dettagli. TinkerPop](https://tinkerpop.apache.org/docs/current/reference/#io-step)