Uso de Amazon Neptune como objetivo paraAWS Database Migration Service

Amazon Neptune es un servicio de base de datos de gráficos rápido, fiable y completamente administrado que le permite crear y ejecutar fácilmente aplicaciones que funcionen con conjuntos de datos altamente conectados. El núcleo de Neptune es un motor de base de datos de gráficos de alto rendimiento y diseñado específicamente. Este motor está optimizado para almacenar miles de millones de relaciones y consultar gráficos con una latencia de milisegundos. Neptune admite los lenguajes de consulta de gráficos populares, Apache TinkerPop Gremlin y SPARQL de W3C. Para obtener más información sobre Amazon Neptune, consulte¿Qué es Amazon Neptune?en laGuía del usuario de Amazon Neptune.

Sin una base de datos de gráficos como Neptune, probablemente modele datos altamente conectados en una base de datos relacional. Como los datos tienen conexiones potencialmente dinámicas, las aplicaciones que usan dichos orígenes de datos deben modelar consultas de datos conectados en SQL. Este enfoque requiere que escriba una capa adicional para convertir consultas de gráficos a SQL. Además, las bases de datos relacionales vienen con rigidez de esquema. Cualquier cambio en el esquema para modelar las conexiones cambiantes requiere tiempo de inactividad y mantenimiento adicional de la conversión de la consulta para admitir el nuevo esquema. El rendimiento de la consulta es otra gran restricción a tener en cuenta al diseñar sus aplicaciones.

Las bases de datos de gráficos pueden simplificar en gran medida dichas situaciones. Sin ningún esquema, las capas (Gremlin o SPARQL) de consulta de gráficos enriquecidos y los índices optimizados para la consulta de gráficos aumentan la flexibilidad y el rendimiento. La base de datos de gráficos de Amazon Neptune también tiene características empresariales como el cifrado en reposo, una capa de autorización segura, copias de seguridad por defecto, compatibilidad Multi-AZ, compatibilidad con réplicas de lectura y otros.

Uso deAWS DMS, puede migrar datos relacionales que modelan un gráfico altamente conectado a un punto de enlace de destino de Neptune desde un punto de enlace de DMS de cualquier base de datos SQL admitida.

Para obtener más detalles, consulte lo siguiente.

Información general sobre la migración a Amazon Neptune como destino

Antes de empezar una migración a un destino de Neptune, cree los siguientes recursos en suAWScuenta:

• Un clúster de Neptune para el punto de enlace de destino.

• Base de datos relacional SQL admitida porAWS DMSpara el punto de enlace de origen.

• Un bucket de Amazon S3 para el punto de enlace de destino. Cree este bucket de S3 en el mismoAWSRegión como clúster de Neptune.AWS DMSutiliza este bucket de S3 como un archivo de almacenamiento intermedio para los datos de destino que carga por lotes en la base de datos de Neptune. Para obtener más información sobre la creación de un bucket de S3, consulteCrear un bucketen laGuía del usuario de Amazon Simple Storage Service.

• Un punto de enlace de virtual private cloud de S3 en la misma VPC que el clúster de Neptune.

• Un rol de AWS Identity and Access Management (IAM) que incluye una política de IAM. Esta política especifica los permisos GetObject, PutObject, DeleteObject y ListObject del bucket de S3 de su punto de enlace de destino. Este papel es asumido por ambosAWS DMSy Neptune con acceso IAM tanto al bucket de S3 de destino como a la base de datos de Neptune. Para obtener más información, consulte Creación de un rol de servicio de IAM para acceder a Amazon Neptune como destino.

Después de obtener estos recursos, la configuración y el inicio de una migración a un destino de Neptune es similar a cualquier migración de carga completa mediante la consola o la API de DMS. Sin embargo, una migración a un destino de Neptune requiere algunos pasos únicos.

Para migrar un proceso deAWS DMSbase de datos relacional a Neptune

1. Cree una instancia de replicación como se describe en Creación de una instancia de replicación.

2. Cree y pruebe una base de datos relacional SQL admitida por AWS DMS para el punto de enlace de origen.

3. Cree y pruebe el punto de enlace de destino para su base de datos de Neptune.

   Para conectar el punto de enlace de destino de la base de datos de Neptune, especifique el nombre del servidor tanto para el punto de enlace del clúster de Neptune como para el punto de enlace de la instancia del escritor de Neptune. Especifique también la carpeta del bucket de S3 paraAWS DMSpara almacenar sus archivos intermedios para su carga por lotes en la base de datos de Neptune.

   Durante la migración, AWS DMS almacena todos los datos de destino migrados en esta carpeta de bucket de S3 hasta el tamaño máximo de archivo que especifique. Cuando este almacenamiento de archivos alcance su tamaño máximo, AWS DMS realiza una carga por lotes de los datos de S3 almacenados en la base de datos de destino. Luego elimina la carpeta para permitir el almacenamiento de cualquier dato de destino adicional para su carga posterior en la base de datos de destino. Para obtener más información sobre cómo especificar esta configuración, consulte Especificación de la configuración del punto de enlace de Amazon Neptune como destino.

4. Cree una tarea de replicación de carga completa con los recursos que ha creado en los pasos 1 a 3 y haga lo siguiente:

   1. Use la asignación de la tabla de tareas como de costumbre para identificar esquemas, tablas y vistas de origen concreto para migrar de su base de datos relacional mediante las reglas de transformación y selección adecuadas. Para obtener más información, consulte Uso del mapeo de tablas para especificar la configuración de tareas.

   2. Especifique las asignaciones de destino seleccionando una de las siguientes para especificar las reglas de asignación de las tablas y vistas de origen a su gráfico de base de datos de destino de Neptune:

      • JSON de Gremlin — Para obtener información sobre el uso de Gremlin JSON para cargar una base de datos Neptune, consulteFormato de datos de carga de Gremlinen laGuía del usuario de Amazon Neptune.

      • Lenguaje de asignación de SPARQL RDB to Resource Description Framework (R2RML): Para obtener información sobre el uso de SPARQL R2RML, consulte la especificación de W3CR2 RML: Lenguaje de asignación de RDB a RDF.

   3. Realice una de las siguientes acciones:

      • Mediante la consola de AWS DMS, especifique las opciones de asignación de gráficos mediante las Reglas de asignación de gráficos en la página Crear base de datos de tareas de migración.

      • Mediante la API de AWS DMS, especifique estas opciones mediante el parámetro de solicitud de TaskData en la llamada de la API CreateReplicationTask.

      Para obtener más información y ejemplos de uso de JSON de Gremlin y R2RML de SPARQL para especificar reglas de asignación de gráficos, consulte Especificación de reglas de mapeo de gráficos mediante Gremlin y R2RML para Amazon Neptune como destino.

5. Inicie la replicación de la tarea de migración.

Especificación de la configuración del punto de enlace de Amazon Neptune como destino

Para crear o modificar un punto de enlace de destino, puede usar la consola o las operaciones de la API CreateEndpoint o ModifyEndpoint.

Para un objetivo Neptune en elAWS DMSconsola, especifiqueConfiguración específica del punto finalen elCreación de un punto de enlaceoModificar un punto de enlacepágina de consola. En CreateEndpoint y ModifyEndpoint, especifique los parámetros de solicitud de la opción NeptuneSettings. El siguiente ejemplo le muestra cómo hacerlo mediante 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}‘

Aquí, la CLI--server-nameespecifica el nombre del servidor del punto de enlace del escritor del clúster Neptune. O puede especificar el nombre del servidor de un punto de enlace de instancia de Neptune.

Los parámetros de la solicitud de la opción --neptune-settings son los siguientes:

• ServiceAccessRoleArn— (Obligatorio) Nombre de recurso de Amazon (ARN) del rol de servicio que ha creado para el punto de enlace de destino de Neptune. Para obtener más información, consulte Creación de un rol de servicio de IAM para acceder a Amazon Neptune como destino.

• S3BucketName— (Obligatorio) Nombre del bucket de S3 en el que DMS puede almacenar temporalmente datos de gráficos migrados en archivos .csv antes de cargarlos en masa en la base de datos de destino de Neptune. DMS asigna los datos de origen SQL a datos gráficos antes de almacenarlos en estos archivos.csv.

• S3BucketFolder— (Obligatorio) Ruta de carpeta en la que desea que DMS almacene datos de gráficos migrados en el bucket de S3 especificado porS3BucketName.

• ErrorRetryDuration— (Opcional) El número de milisegundos que DMS espera para volver a intentar una carga en masa de datos de gráficos migrados a la base de datos de destino de Neptune antes de generar un error. El valor predeterminado es 250.

• MaxFileSize— (Opcional) El tamaño máximo en KB de datos de gráficos migrados almacenados en un archivo.csv antes de que DMS cargue en masa los datos en la base de datos de destino de Neptune. El valor predeterminado es 1.048.576 KB (1 GB). Si se realiza correctamente, DMS borra el bucket y está listo para almacenar el siguiente lote de datos de gráficos migrados.

• MaxRetryCount— (Opcional) El número de veces que DMS vuelve a intentar una carga en masa de datos de gráficos migrados a la base de datos de destino de Neptune antes de generar un error. El valor predeterminado es 5.

• IAMAuthEnabled— (Opcional) Si desea habilitar la autorización de IAM para este punto de enlace, establezca este parámetro entruey adjunte el documento de la política de IAM apropiado a su rol de servicio especificado porServiceAccessRoleArn. El valor predeterminado es false.

Creación de un rol de servicio de IAM para acceder a Amazon Neptune como destino

Para acceder a Neptune como destino, cree un rol de servicio mediante IAM. En función de la configuración del punto de enlace de Neptune, adjunte a este rol algunos o todos los documentos de confianza y la política de IAM siguientes. Cuando crea el punto de enlace de Neptune, proporciona el ARN de este rol de servicio. Hacerlo habilitaAWS DMSy Amazon Neptune asume permisos para acceder tanto a Neptune como a su bucket de Amazon S3 asociado.

Si configuras elIAMAuthEnabledparámetro enNeptuneSettingsatrueen la configuración del punto de enlace de Neptune, adjunte una política de IAM como la siguiente a su rol de servicio. Si establece IAMAuthEnabled como false, puede ignorar esta política.

// 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 política de IAM anterior permite acceso completo al clúster de destino de Neptune especificado porResource.

Adjunte una política de IAM como la siguiente a su rol de servicio. Esta política permite a DMS almacenar temporalmente datos de gráficos migrados en el bucket de S3 que ha creado para cargarlos por lotes en la base de datos de destino de 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 política de IAM anterior permite a su cuenta consultar el contenido del bucket de S3 (arn:aws:s3:::my-bucket) creado para tu objetivo Neptune. También permite que su cuenta funcione completamente con el contenido de todos los archivos y carpetas del bucket (arn:aws:s3:::my-bucket/).

Edite la relación de confianza y adjunte el siguiente rol de IAM a su rol de servicio para permitir tantoAWS DMSy el servicio de base de datos de Amazon Neptune para asumir el rol.

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

Para obtener información sobre cómo especificar este rol de servicio para su punto de enlace de destino de Neptune, consulteEspecificación de la configuración del punto de enlace de Amazon Neptune como destino.

Especificación de reglas de mapeo de gráficos mediante Gremlin y R2RML para Amazon Neptune como destino

Las reglas de mapeo de gráficos que cree especifican cómo se cargan los datos extraídos de un origen de base de datos relacional SQL en un destino de clúster de base de datos de Neptune. El formato de estas reglas de asignación varía en función de si las reglas son para cargar datos de gráficos de propiedades utilizando Apache TinkerPop Gremlin o los datos de Resource Description Framework (RDF) utilizando R2RML. A continuación, puede encontrar información sobre estos formatos y dónde obtener más información.

Puede especificar estas reglas de asignación al crear la tarea de migración mediante la consola o la API de DMS.

Mediante la consola, especifique estas reglas de asignación mediante Graph mapping rules (Reglas de asignación de gráficos) en la página Create database migration task (Crear migración de base de datos). En Graph mapping rules (Reglas de asignación de gráficos), puede introducir y editar las reglas de asignación directamente mediante el editor proporcionado. También puede buscar un archivo que contenga las reglas de asignación en el formato de asignación de gráficos adecuado.

Mediante la API, especifique estas opciones mediante el parámetro de solicitud TaskData de la llamada a la API CreateReplicationTask. Establezca TaskData en la ruta de un archivo que contiene las reglas de asignación en el formato de asignación de gráficos adecuado.

Reglas de mapeo de gráficos para generar datos de gráficos de propiedades mediante Gremlin

Usando Gremlin para generar los datos de gráficos de propiedades, especifique un objeto JSON con una regla de asignación para cada entidad de gráfico que se generará a partir de los datos de origen. El formato de este JSON se define específicamente para cargar en masa Amazon Neptune. La plantilla siguiente muestra el aspecto de cada regla en este objeto:

{
    "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 presencia de una etiqueta de vértice implica que el vértice se está creando aquí. Su ausencia implica que el vértice es creado por una fuente diferente, y esta definición solo añade propiedades de vértice. Especifique tantas definiciones de borde y vértice como sea necesario para especificar las asignaciones de su origen de base de datos relacional entero.

A continuación se muestra una regla de ejemplo para una tabla de 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"
                        }
                    ]
                }
            ]
        }
    ]
}
 

Aquí, las definiciones de vértice y borde asignan una relación de informe de un nodo employee con el ID de empleado (EmpID) y un nodo employee con un ID de empleado (managerId).

Para obtener más información acerca de la creación de reglas de mapeo de gráficos mediante el JSON de Gremlin, consulteFormato de datos de carga de Gremlinen laGuía del usuario de Amazon Neptune.

Reglas de mapeo de gráficos para generar datos RDF/SPARQL

Si está cargando datos de RDF para realizar consultas mediante SPARQL, escriba las reglas de asignación de gráficos en R2RML. R2RML es un lenguaje W3C estándar para asignar datos relacionales a RDF. En un archivo R2RML, una asignación de triples (por ejemplo, el <#TriplesMap1> a continuación) especifica una regla para traducir cada fila de una tabla lógica a cero o más triples de RDF. Una asignación de asunto (por ejemplo, cualquier rr:subjectMap a continuación) especifica una regla para generar los sujetos de los triples de RDF generados por las asignaciones de triples. Una asignación de predicación-objeto (por ejemplo, cualquier rr:predicateObjectMap a continuación) es una función que crea uno o más pares de predicación-objeto para cada fila de tabla lógica de una tabla lógica.

A continuación se muestra un sencillo ejemplo de 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" ];
    ]

En el ejemplo anterior, la asignación define los nodos de gráficos asignados a partir de una tabla de empleados.

A continuación se muestra otro sencillo ejemplo de una tabla de 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" ]
    ].

En el ejemplo anterior, la asignación define nodos de gráficos que asignan relaciones de amigo de amigo entre personas en una tabla de Student.

Para obtener más información acerca de la creación de reglas de mapeo de gráficos mediante SPARQL R2RML, consulte la especificación de W3CR2 RML: Lenguaje de asignación de RDB a RDF.

Tipos de datos para la migración de Gremlin y R2RML a Amazon Neptune como destino

AWS DMSrealiza asignaciones de tipo de datos desde su punto de enlace de origen de SQL hasta su destino de Neptune de una de estas dos maneras. La forma en que los utilice depende del formato de asignación de gráficos que utilice para cargar la base de datos de Neptune:

• Apache TinkerPop Gremlin, mediante una representación JSON de los datos de migración.

• SPARQL de W3C, mediante una representación R2RML de los datos de migración.

Para obtener más información sobre estos dos formatos de asignación de gráficos, consulte Especificación de reglas de mapeo de gráficos mediante Gremlin y R2RML para Amazon Neptune como destino.

A continuación, puede encontrar descripciones de las asignaciones de tipos de datos para cada formato.

Mapeo de tipos de datos de origen de SQL a destino de Gremlin

En la siguiente tabla se muestran las asignaciones de tipos de datos de un origen SQL a un destino con formato Gremlin.

AWS DMS asigna cualquier tipo de datos de origen SQL no listado a un String Gremlin.

Tipos de datos de origen de SQL	Tipos de datos de destino de Gremlin
NUMERIC (y variantes)	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 (y variantes)	String

Para obtener más información sobre los tipos de datos de Gremlin para cargar Neptune, consulteTipos de datos de Gremlinen laGuía del usuario de Neptune.

Mapeo de tipos de datos de origen de SQL a destino de R2RML (RDF)

En la tabla siguiente se muestran las asignaciones de tipos de datos de un origen SQL a un destino con formato R2RML.

Todos los tipos de datos de RDF enumerados distinguen entre mayúsculas y minúsculas, excepto los RDF literales. AWS DMS asigna cualquier tipo de datos de origen SQL sin enumerar a un RDF literal.

Un RDF literal es uno de entre una variedad de formas léxicas literales y tipos de datos. Para obtener más información, consulteLiterales de RDFen la especificación del W3CMarco de descripción de recursos (RDF): Conceptos y sintaxis abstracta.

Tipos de datos de origen de SQL	Tipos de datos de destino de R2RML (RDF)
BINARY (y variantes)	xsd:hexBinary
NUMERIC (y variantes)	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 (y variantes)	RDF literal

Para obtener más información acerca de los tipos de datos RDF para cargar Neptune y sus mapeos a tipos de datos de origen SQL, consulteConversiones de los tipos de datosen la especificación del W3CR2 RML: Lenguaje de asignación de RDB a RDF.

Restricciones del uso de Amazon Neptune como destino

Al utilizar Neptune como destino se aplican las siguientes restricciones:

• AWS DMSactualmente admite tareas de carga completa solo para la migración a un destino de Neptune. No se admite la migración de captura de datos (CDC) a un destino de Neptune.

• Asegúrese de que borre todos los datos de su base de datos de Neptune de destino antes de empezar la tarea de migración, como en los siguientes ejemplos.

  Para borrar todos los datos (vértices y bordes) del gráfico, ejecute el siguiente comando Gremlin.

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

  Para borrar los vértices que tienen la etiqueta'customer', ejecute el siguiente comando Gremlin.

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

  nota

  Puede llevar algún tiempo eliminar un conjunto de datos grande. Es posible que desee iterar drop() con un límite, por ejemplo, limit(1000).

  Para borrar aristas que tienen la etiqueta'rated', ejecute el siguiente comando Gremlin.

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

  nota

  Puede llevar algún tiempo eliminar un conjunto de datos grande. Es posible que desee iterar drop() con un límite, por ejemplo limit(1000).

• Operación de la API de DMSDescribeTableStatisticspuede devolver resultados inexactos acerca de una tabla dada debido a la naturaleza de las estructuras de datos de gráficos de Neptune.

  Durante la migración,AWS DMSanaliza cada tabla de origen y utiliza asignaciones de gráficos para convertir los datos de origen en un gráfico de Neptune. Los datos convertidos se almacenan primero en la carpeta del bucket de S3 en el punto de enlace de destino. Si se analiza el origen y los datos de S3 intermedios se generan correctamente,DescribeTableStatisticssupone que los datos se han cargado correctamente en la base de datos de destino Neptune. Pero esto no siempre es cierto. Para verificar que los datos se han cargado correctamente en una tabla, compare los valores de retorno de count() en ambos extremos de la migración de esa tabla.

  En el siguiente ejemplo,AWS DMSha cargado uncustomerde la base de datos de origen, a la que se asigna la etiqueta'customer'en el gráfico de base de datos Neptune de destino. Puede asegurarse de que esta etiqueta se escribe en la base de datos de destino. Para ello, compare el número decustomerfilas disponibles en la base de datos de origen con el número de'customer'filas etiquetadas cargadas en la base de datos de destino Neptune una vez finalizada la tarea.

  Para obtener la cantidad de filas de cliente disponibles en la base de datos de origen mediante SQL, ejecute lo siguiente.

  select count(*) from customer;

  Para obtener la cantidad de filas etiquetadas como 'customer' cargadas en el gráfico de la base de datos de destino mediante Gremlin, ejecute lo siguiente.

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

• Actualmente, si una sola tabla no se carga, se produce un error en toda la tarea. A diferencia de un destino de base de datos relacional, los datos de Neptune están altamente conectados, lo que hace que en muchos casos sea imposible realizar una tarea. Si no se puede reanudar una tarea correctamente debido a esta clase de error de carga de datos, cree una nueva tarea para cargar la tabla que no se ha podido cargar. Antes de ejecutar esta nueva tarea, borre manualmente la tabla parciamente cargada del destino de Neptune.

  nota

  Puede reanudar una tarea con un error de migración a un destino de Neptune si en error se puede recuperar (por ejemplo, un error de tránsito de red).

• AWS DMS admite la mayoría de los estándares para R2RML. Sin embargo, AWS DMS no admite ciertos estándares de R2RML, incluidas las expresiones inversas, las uniones y las vistas. Una solución alternativa para una vista R2RML consiste en crear una vista SQL personalizada correspondiente en la base de datos de origen. En la tarea de migración, utilice la asignación de tablas para elegir la vista como entrada. A continuación, asigne la vista a una tabla que R2RML consume para generar datos de gráficos.

• Al migrar datos de origen con tipos de datos SQL no admitidos, puede haber una pérdida de precisión en los datos de destino resultantes. Para obtener más información, consulte Tipos de datos para la migración de Gremlin y R2RML a Amazon Neptune como destino.

• AWS DMSno admite la migración de datos LOB a un destino Neptune.