Utilizzo di Amazon Neptune come destinazione per AWS Database Migration Service

Amazon Neptune è un servizio di database a grafo gestito rapido e affidabile che rende più semplice la creazione e l'esecuzione di applicazioni che funzionano con set di dati altamente connessi. Il cuore di Neptune è un motore di database a grafo ad alte prestazioni appositamente progettato. Questo motore è ottimizzato per archiviare miliardi di relazioni ed eseguire query sul database a grafo con una latenza di millisecondi. Neptune supporta i più comuni linguaggi di query sul database a grafo Apache TinkerPop Gremlin e SPARQL di W3C. Per ulteriori informazioni su Amazon Neptune, consulta What is Amazon Neptune? nella Guida per l'utente di Amazon Neptune.

Senza un database a grafo come Neptune, è probabile che dati altamente connessi vengano modellati in un database relazionale. Poiché i dati dispongono di connessioni potenzialmente dinamiche, le applicazioni che utilizzano tali origini dati devono modellare query di dati connessi in SQL. Questo approccio richiede la scrittura di un livello aggiuntivo per convertire le query a grafo in SQL. Inoltre, i database relazionali sono dotati di uno schema rigido. Qualsiasi modifica nello schema per modellare il cambio di connessioni richiede tempi di inattività e una ulteriore manutenzione della conversione della query per supportare il nuovo schema. Le prestazioni delle query sono un altro grande limite da considerare durante la progettazione delle applicazioni.

I database a grafo possono semplificare notevolmente tali situazioni. Libero da uno schema, un livello avanzato di query a grafo (Gremlin o SPARQL) e indici ottimizzati per le query a grafo aumentano la flessibilità e le prestazioni. Il database a grafo Amazon Neptune dispone anche di funzionalità aziendali come la crittografia a riposo, un livello di autorizzazione sicuro, backup predefiniti, supporto Multi-AZ, supporto delle repliche di lettura e altre ancora.

Con AWS DMS, è possibile eseguire la migrazione di dati relazionali, che modellano un grafo altamente connesso, a un endpoint di destinazione di Neptune da un endpoint di origine di DMS per qualsiasi database SQL supportato.

Per ulteriori dettagli, consulta quanto segue:

Panoramica sulla migrazione a Amazon Neptune come destinazione

Prima di avviare la migrazione a una destinazione Neptune, crea le seguenti risorse nell'account AWS:

• Un cluster Neptune per l'endpoint di destinazione.

• Un database relazionale SQL supportato da AWS DMS per l'endpoint di origine.

• Un bucket Amazon S3 per l'endpoint di destinazione. Crea questo bucket S3 nella stessa regione AWS del cluster Neptune. AWS DMS utilizza questo bucket S3 per lo storage dei file intermedio con i dati di destinazione caricati in blocco nel database Neptune. Per ulteriori informazioni sulla creazione di un bucket S3, consulta Creazione di un bucket nella Guida per l'utente di Amazon Simple Storage Service.

• Un endpoint del cloud privato virtuale (VPC) per S3 nello stesso VPC del cluster Neptune.

• Un ruolo AWS Identity and Access Management (IAM) che includa una policy IAM. Questa policy deve specificare al bucket S3 le autorizzazioni GetObject, PutObject, DeleteObject e ListObject per l'endpoint di destinazione. Questo ruolo viene assunto da AWS DMS e Neptune, con accesso IAM sia al bucket S3 di destinazione che al database Neptune. Per ulteriori informazioni, consulta Creazione di un ruolo di servizio IAM per l'accesso ad Amazon Neptune come destinazione.

Una volta in possesso di queste risorse, la configurazione e l'avvio di una migrazione a una destinazione Neptune è simile a qualsiasi migrazione di pieno carico tramite la console o l'API DMS. Tuttavia, una migrazione a una destinazione Neptune richiede alcuni passaggi specifici.

Per eseguire la migrazione di un database relazionale AWS DMS a Neptune

1. Creare un'istanza di replica nel modo descritto in Creazione di un'istanza di replica.

2. Creare e testare un database relazionale SQL supportato da AWS DMS per l'endpoint di origine.

3. Crea e testa l'endpoint di destinazione per il database Neptune.

   Per connettere l'endpoint di destinazione al database Neptune, specifica il nome del server per l'endpoint del cluster Neptune o per l'endpoint dell'istanza di scrittura Neptune. Inoltre, specifica la cartella del bucket S3 in modo che AWS DMS vi archivi i file intermedi per il caricamento in blocco nel database Neptune.

   Durante la migrazione, AWS DMS archivia tutti i dati di destinazione migrati in questa cartella del bucket S3 fino a una dimensione massima del file specificata. Quando questo storage di file raggiunge la dimensione massima, AWS DMS carica in blocco i dati S3 archiviati nel database di destinazione. Cancella la cartella per consentire lo storage di eventuali altri dati di destinazione per un successivo caricamento nel database di destinazione. Per ulteriori informazioni su come specificare queste impostazioni, consulta Specifica delle impostazioni degli endpoint per Amazon Neptune come destinazione.

4. Crea un'attività di replica di pieno carico con le risorse create nelle fasi da 1 a 3 ed effettua le seguenti operazioni:

   1. Utilizzare come sempre la mappatura delle tabelle dell'attività per identificare schemi, tabelle e viste di origine specifici di cui eseguire la migrazione dal database relazionale utilizzando le regole di selezione e trasformazione appropriate. Per ulteriori informazioni, consulta Utilizzo della mappatura delle tabelle per specificare le impostazioni delle attività.

   2. Specifica le mappature di destinazione scegliendo una delle seguenti opzioni per indicare le regole di mappatura dalle tabelle e dalle viste di origine al database a grafo di destinazione Neptune:

      • Gremlin JSON: per informazioni sull'utilizzo di Gremlin JSON per caricare un database Neptune, consulta Gremlin load data format nella Guida per l'utente di Amazon Neptune.

      • SPARQL RDB to Resource Description Framework Mapping Language (R2RML): per informazioni sull'utilizzo di SPARQL R2RML, consulta la specifica W3C R2RML: RDB to RDF mapping language.

   3. Completa una delle seguenti operazioni:

      • Tramite la console AWS DMS, specificare le opzioni di mappatura a grafo utilizzando Regole di mappatura a grafo nella pagina Crea attività di migrazione del database .

      • Tramite l'API AWS DMS, specificare queste opzioni utilizzando il parametro di richiesta TaskData della chiamata API CreateReplicationTask.

      Per ulteriori informazioni ed esempi sull'utilizzo di Gremlin JSON e SPARQL R2RML per specificare le regole di mappatura a grafo, consulta Specifica delle regole di mappatura del grafo utilizzando Gremlin e R2RML per Amazon Neptune come destinazione.

5. Avviare la replica per l'attività di migrazione.

Specifica delle impostazioni degli endpoint per Amazon Neptune come destinazione

Per creare o modificare un endpoint di destinazione, è possibile utilizzare la console o le operazioni API CreateEndpoint o ModifyEndpoint.

Per una destinazione Neptune nella console AWS DMS immetti le Impostazioni specifiche dell'endpoint nella pagina della console Crea endpoint o Modifica endpoint. Per CreateEndpoint e ModifyEndpoint, specificare i parametri di richiesta per l'opzione NeptuneSettings. Nell'esempio seguente viene illustrato come eseguire questa operazione utilizzando la CLI.

dms create-endpoint --endpoint-identifier my-neptune-target-endpoint
--endpoint-type target --engine-name neptune 
--server-name my-neptune-db.cluster-cspckvklbvgf.us-east-1.neptune.amazonaws.com 
--port 8192
--neptune-settings 
     '{"ServiceAccessRoleArn":"arn:aws:iam::123456789012:role/myNeptuneRole",
       "S3BucketName":"my-bucket",
       "S3BucketFolder":"my-bucket-folder",
       "ErrorRetryDuration":57,
       "MaxFileSize":100, 
       "MaxRetryCount": 10, 
       "IAMAuthEnabled":false}‘

Qui, l'opzione --server-name della CLI indica il nome del server per l'endpoint di scrittura del cluster Neptune. In alternativa, è possibile specificare il nome del server per un endpoint dell'istanza di scrittura Neptune.

Seguono i parametri di richiesta dell'opzione --neptune-settings:

• ServiceAccessRoleArn (obbligatorio): il nome della risorsa Amazon (ARN) del ruolo di servizio creato per l'endpoint di destinazione Neptune. Per ulteriori informazioni, consulta Creazione di un ruolo di servizio IAM per l'accesso ad Amazon Neptune come destinazione.

• S3BucketName (obbligatorio): il nome del bucket Amazon S3 in cui DMS può archiviare temporaneamente i dati a grafo migrati in file.csv prima di caricarli in blocco nel database di destinazione Neptune. DMS mappa i dati di origine SQL ai dati a grafo prima di archiviarli in questi file .csv.

• S3BucketFolder (obbligatorio): il percorso di una cartella in cui si desidera che DMS archivi i dati a grafo migrati nel bucket S3 specificato da S3BucketName.

• ErrorRetryDuration (facoltativo): il numero di millisecondi che DMS deve attendere per riprovare a caricare in blocco dati a grafo migrati nel database di destinazione Neptune prima di generare un errore. Il valore di default è 250.

• MaxFileSize (facoltativo): la dimensione massima in KB di dati a grafo migrati archiviati in un file con estensione .csv prima che DMS carichi in blocco i dati nel database di destinazione Neptune. Il valore predefinito è 1.048.576 KB (1 GB). In caso di esito positivo del caricamento, DMS cancella il bucket, pronto per memorizzare il successivo batch di dati a grafo migrati.

• MaxRetryCount (facoltativo): il numero di tentativi eseguiti da DMS per caricare in blocco i dati a grafo migrati nel database di destinazione Neptune prima di generare un errore. Il predefinito è 5.

• IAMAuthEnabled (facoltativo): per abilitare l'autorizzazione IAM per l'endpoint, imposta questo parametro su true e collega il documento della policy IAM appropriato al ruolo di servizio specificato da ServiceAccessRoleArn. Il valore predefinito è false.

Creazione di un ruolo di servizio IAM per l'accesso ad Amazon Neptune come destinazione

Per accedere a Neptune come destinazione, creare un ruolo del servizio utilizzando IAM. A seconda della configurazione dell'endpoint Neptune, collega a questo ruolo alcuni o tutti i documenti di trust e della policy IAM descritti di seguito. Quando si crea l'endpoint Neptune, occorre fornire l'ARN del ruolo di servizio. In questo modo si permette ad AWS DMS e Amazon Neptune di assumere le autorizzazioni per accedere a Neptune e al relativo bucket Amazon S3 associato.

Se imposti il parametro IAMAuthEnabled in NeptuneSettings su true nella configurazione dell'endpoint Neptune, collega al ruolo di servizio una policy IAM come la seguente. Se si imposta IAMAuthEnabled su false, è possibile ignorare questa policy.

// Policy to access Neptune

    {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Sid": "VisualEditor0",
                "Effect": "Allow",
                "Action": "neptune-db:*",
                "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-CLG7H7FHK54AZGHEH6MNS55JKM/*"
            }
        ]
    }

La policy IAM precedente consente l'accesso completo al cluster di destinazione Neptune specificato da Resource.

Collegare una policy IAM come la seguente al ruolo del servizio. Questa policy consente a DMS di archiviare temporaneamente i dati a grafo migrati nel bucket S3 creato per il caricamento in blocco nel database di destinazione Neptune.

//Policy to access S3 bucket

{
	"Version": "2012-10-17",
	"Statement": [{
			"Sid": "ListObjectsInBucket0",
			"Effect": "Allow",
			"Action": "s3:ListBucket",
			"Resource": [
				"arn:aws:s3:::my-bucket"
			]
		},
		{
			"Sid": "AllObjectActions",
			"Effect": "Allow",
			"Action": ["s3:GetObject",
				"s3:PutObject",
				"s3:DeleteObject"
			],

			"Resource": [
				"arn:aws:s3:::my-bucket/"
			]
		},
		{
			"Sid": "ListObjectsInBucket1",
			"Effect": "Allow",
			"Action": "s3:ListBucket",
			"Resource": [
				"arn:aws:s3:::my-bucket",
				"arn:aws:s3:::my-bucket/"
			]
		}
	]
}

La policy IAM precedente consente all'account di eseguire query sui contenuti del bucket S3 (arn:aws:s3:::my-bucket) creato per la destinazione Neptune. Permette inoltre all'account di operare in modo completo sui contenuti di tutti i file e le cartelle del bucket (arn:aws:s3:::my-bucket/).

Modifica la relazione di trust e collega il ruolo IAM seguente al ruolo di servizio per consentire ad AWS DMS e al servizio di database Amazon Neptune di assumere il ruolo.

{
  "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"
    }
  ]
}

Per informazioni su come specificare questo ruolo di servizio per l'endpoint di destinazione Neptune, consulta Specifica delle impostazioni degli endpoint per Amazon Neptune come destinazione.

Specifica delle regole di mappatura del grafo utilizzando Gremlin e R2RML per Amazon Neptune come destinazione

Le regole di mappatura del grafo create specificano il modo in cui i dati estratti da un'origine di database relazionale SQL vengono caricati in una destinazione del cluster di database Neptune. Il formato di queste regole di mappatura varia a seconda se le regole valgono per il caricamento dei dati del grafo delle proprietà tramite Apache TinkerPop Gremlin o per il caricamento dei dati RDF (Resource Description Framework) tramite R2RML. Di seguito è possibile trovare informazioni su questi formati e su dove approfondirle.

È possibile specificare queste regole di mappatura quando si crea l'attività di migrazione utilizzando la console o l'API DMS.

Tramite la console, specificare queste regole di mappatura utilizzando le Regole di mappatura a grafo nella pagina Crea attività di migrazione del database . In Regole di mappatura a grafo è possibile immettere e modificare le regole di mappatura direttamente utilizzando l'editor fornito. In alternativa, è possibile cercare un file che contenga le regole di mappatura nel formato di mappatura a grafo appropriato.

Tramite l'API, specificare queste opzioni utilizzando il parametro di richiesta TaskData della chiamata API CreateReplicationTask. Impostare TaskData sul percorso di un file contenente le regole di mappatura nel formato di mappatura a grafo appropriato.

Regole di mappatura a grafo per la generazione di dati del grafo di proprietà mediante Gremlin

Utilizzando Gremlin per generare i dati del grafo di proprietà, specificare un oggetto JSON con una regola di mappatura per ogni entità a grafo da generare dai dati di origine. Il formato di questo JSON è definito specificamente per il caricamento in blocco su Amazon Neptune. 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)"
                        }
                    ]
                }
            ]
        }
    ]
}
 

La presenza di un'etichetta del vertice implica che il vertice viene creato qui. La sua assenza implica che il vertice viene creato da un'origine diversa e che questa definizione aggiunge solo le proprietà del vertice. Specificare tutte le definizioni di vertici e di edge necessarie per specificare le mappature per l'intera origine del database relazionale.

Segue una regola di esempio per una tabella employee.

{
    "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"
                        }
                    ]
                }
            ]
        }
    ]
}
 

Qui, le definizioni dei vertici e degli edge mappano una relazione gerarchica da un nodo employee con ID dipendente (EmpID) e un nodo employee con un ID manager (managerId).

Per ulteriori informazioni sulla creazione di regole di mappatura a grafo utilizzando Gremlin JSON, consulta Gremlin load data format nella Guida per l'utente di Amazon Neptune.

Regole di mappatura a grafo per la generazione di dati RDF/SPARQL

Se si caricano dati RDF di cui eseguire query tramite SPARQL, scrivere le regole di mappatura a grafo in R2RML. R2RML è un linguaggio W3C standard per la mappatura dei dati relazionali a RDF. In un file R2RML, una mappa delle triple (ad esempio <#TriplesMap1> di seguito) specifica una regola per convertire ogni riga di una tabella logica in zero o più triple RDF. Una mappa dei soggetti (ad esempio, qualsiasi rr:subjectMap seguente) specifica una regola per generare i soggetti delle triple RDF generate da una mappa delle triple. Una mappa predicato-oggetto (ad esempio, qualsiasi rr:predicateObjectMap seguente) è una funzione che crea una o più coppie predicato-oggetto per ogni riga di una tabella logica.

Segue un semplice esempio per una tabella nodes.

@prefix rr: <http://www.w3.org/ns/r2rml#>.
@prefix ex: <http://example.com/ns#>.

<#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" ];
    ]

Nell'esempio precedente, la mappatura definisce i nodi del grafo mappati da una tabella di dipendenti.

Segue un altro semplice esempio per una tabella Student.

@prefix rr: <http://www.w3.org/ns/r2rml#>.
@prefix ex: <http://example.com/#>.
@prefix foaf: <http://xmlns.com/foaf/0.1/>.
@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.

<#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" ]
    ].

Nell'esempio precedente, la mappatura definisce i nodi del grafo che mappano le relazioni tra amici e amici nelle persone in una tabella Student.

Per ulteriori informazioni sulla creazione di regole di mappatura a grafo utilizzando SPARQL R2RML, consulta la specifica W3C R2RML: RDB to RDF Mapping Language.

Tipi di dati per la migrazione di Gremlin e R2RML ad Amazon Neptune come destinazione

AWS DMS esegue la mappatura dei tipi di dati dall'endpoint di origine SQL alla destinazione Neptune in due modi. Il modo che scegli dipende dal formato di mappatura del grafo utilizzato per caricare il database Neptune:

• Apache TinkerPop Gremlin, tramite una rappresentazione JSON dei dati di migrazione.

• SPARQL di W3C, tramite una rappresentazione R2RML dei dati di migrazione.

Per ulteriori informazioni su questi due formati di mappatura del grafo, consulta Specifica delle regole di mappatura del grafo utilizzando Gremlin e R2RML per Amazon Neptune come destinazione.

Di seguito è possibile trovare le descrizioni delle mappature dei tipi di dati per ogni formato.

Mappatura dei tipi di dati da un'origine SQL a una destinazione Gremlin

Nella tabella seguente vengono illustrate le mappature dei tipi di dati da un'origine SQL a una destinazione in formato Gremlin.

AWS DMS mappa qualsiasi tipo di dati di origine SQL non elencato a una String Gremlin.

Tipi di dati di origine SQL	Tipi di dati di destinazione Gremlin
NUMERIC (e varianti)	Double
DECIMAL
TINYINT	Byte
SMALLINT	Short
INT, INTEGER	Int
BIGINT	Long
FLOAT	Float
DOUBLE PRECISION
REAL	Double
BIT	Boolean
BOOLEAN
DATE	Date
TIME
TIMESTAMP
CHARACTER (e varianti)	String

Per ulteriori informazioni sui tipi di dati Gremlin per il caricamento di Neptune, consulta Gremlin data types nella Guida per l'utente di Amazon Neptune.

Mappatura dei tipi di dati da un'origine SQL a una destinazione R2RML (RDF)

Nella tabella seguente vengono illustrate le mappature dei tipi di dati da un'origine SQL a una destinazione in formato R2RML.

Tutti i tipi di dati RDF elencati fanno distinzione tra maiuscole e minuscole, ad eccezione dei letterali RDF. AWS DMS mappa qualsiasi tipo di dati di origine SQL non elencato a un letterale RDF.

Un letterale RDF è un valore di una serie di forme lessicali letterali e di tipi di dati. Per ulteriori informazioni, consulta RDF Literals nella specifica W3C Resource Description Framework (RDF): Concepts and Abstract Syntax.

Tipi di dati di origine SQL	Tipi di dati di destinazione R2RML (RDF)
BINARY (e varianti)	xsd:hexBinary
NUMERIC (e varianti)	xsd:decimal
DECIMAL
TINYINT	xsd:integer
SMALLINT
INT, INTEGER
BIGINT
FLOAT	xsd:double
DOUBLE PRECISION
REAL
BIT	xsd:boolean
BOOLEAN
DATE	xsd:date
TIME	xsd:time
TIMESTAMP	xsd:dateTime
CHARACTER (e varianti)	RDF letterale

Per ulteriori informazioni sui tipi di dati RDF per il caricamento su Neptune e le relative mappature ai tipi di dati di origine SQL, consulta Datatype conversions nella specifica W3C R2RML: RDB to RDF Mapping Language.

Limitazioni all'utilizzo di Amazon Neptune come destinazione

Le seguenti limitazioni si applicano quando si utilizza Neptune come destinazione:

• AWS DMS attualmente supporta le attività di pieno carico solo per la migrazione a una destinazione Neptune. La migrazione di acquisizione dei dati di modifica (CDC) a una destinazione Neptune non è supportata.

• Assicurati di eliminare manualmente tutti i dati nel database Neptune di destinazione prima di avviare l'attività di migrazione, come negli esempi seguenti.

  Per eliminare tutti i dati (vertici ed edge) all'interno del grafo, esegui il comando Gremlin seguente.

  gremlin> g.V().drop().iterate()

  Per eliminare i vertici con etichetta 'customer', esegui il comando Gremlin seguente.

  gremlin> g.V().hasLabel('customer').drop()

  Nota

  L’eliminazione di un set di dati di grandi dimensioni può richiedere del tempo. È consigliabile ripetere drop() con un limite, ad esempio limit(1000).

  Per eliminare gli edge con etichetta 'rated', esegui il comando Gremlin seguente.

  gremlin> g.E().hasLabel('rated').drop()

  Nota

  L’eliminazione di un set di dati di grandi dimensioni può richiedere del tempo. È consigliabile ripetere drop() con un limite, ad esempio limit(1000).

• L'operazione API DMS DescribeTableStatistics può restituire risultati imprecisi su una determinata tabella a causa della natura della struttura dei dati a grafo di Neptune.

  Durante la migrazione, AWS DMS esegue la scansione di ogni tabella di origine e utilizza la mappatura a grafo per convertire i dati di origine in un grafo Neptune. I dati convertiti vengono innanzitutto archiviati nella cartella del bucket S3 specificata per l'endpoint di destinazione. Se l'origine viene sottoposta a scansione e questi dati intermedi S3 vengono generati correttamente, DescribeTableStatistics presuppone che i dati siano stati caricati correttamente nel database di destinazione Neptune. Ma ciò non è sempre vero. Per verificare che i dati siano stati caricati correttamente per una determinata tabella, confrontare i valori count() restituiti a entrambe le estremità della migrazione per tale tabella.

  Nell'esempio seguente, AWS DMS ha caricato una tabella customer dal database di origine, a cui viene assegnata l'etichetta 'customer' nel database a grafo Neptune di destinazione. È possibile verificare che questa etichetta sia scritta nel database di destinazione. A tale scopo, confronta il numero di righe customer disponibili nel database di origine con il numero di righe con etichetta 'customer' caricate nel database di destinazione Neptune al termine dell'attività.

  Per ottenere il numero di righe cliente disponibili dal database di origine tramite SQL, eseguire le operazioni seguenti.

  select count(*) from customer;

  Per ottenere il numero di righe con etichetta 'customer' caricate nel grafo del database di destinazione tramite Gremlin, eseguire le operazioni seguenti.

  gremlin> g.V().hasLabel('customer').count()

• Attualmente, se il caricamento di una singola tabella non riesce, l'intera attività ha esito negativo. A differenza di una destinazione di database relazionale, i dati in Neptune sono altamente connessi, il che rende impossibile in molti casi il ripristino di un'attività. Se non è possibile ripristinare un'attività a causa di questo tipo di errore nel caricamento dei dati, creare una nuova attività per caricare la tabella che non è stato possibile caricare. Prima di eseguire questa nuova attività, elimina manualmente dalla destinazione Neptune la tabella parzialmente caricata.

  Nota

  È possibile ripristinare un'attività che non riesce a eseguire la migrazione a una destinazione Neptune se l'errore è recuperabile (ad esempio un errore di transito di rete).

• AWS DMS supporta la maggior parte degli standard per R2RML. Tuttavia, AWS DMS non supporta alcuni standard R2RML, incluse espressioni inverse, join e viste. Una soluzione alternativa per una vista R2RML consiste nel creare una vista SQL personalizzata corrispondente nel database di origine. Nell'attività di migrazione, utilizzare la mappatura delle tabelle per scegliere la vista come input. Quindi, mappare la vista a una tabella che viene quindi utilizzata da R2RML per generare dati a grafo.

• Quando si esegue la migrazione dei dati di origine con tipi di dati SQL non supportati, i dati di destinazione risultanti possono difettare di precisione. Per ulteriori informazioni, consulta Tipi di dati per la migrazione di Gremlin e R2RML ad Amazon Neptune come destinazione.

• AWS DMS non supporta la migrazione dei dati LOB in una destinazione Neptune.