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