Uso de Amazon Neptune como objetivo para AWS 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 componente principal de Neptune es un motor de base de datos de gráficos de alto rendimiento y personalizado. Este motor está optimizado para almacenar miles de millones de relaciones y consultar el gráfico con una latencia de milisegundos. Neptune es compatible con los populares lenguajes de consulta de gráficos Apache TinkerPop Gremlin y SPARQL de W3C. Para obtener más información sobre Amazon Neptune, consulte ¿Qué es Amazon Neptune? en la Guí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 con seguridad, copias de seguridad por defecto, compatibilidad Multi-AZ, compatibilidad con réplicas de lectura, etc.

A través de AWS DMS, puede migrar datos relacionales que modelan un gráfico altamente conectado a un punto de conexión de destino de Neptune desde un punto de conexión de origen de DMS para 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 la cuenta de AWS:

• Un clúster de Neptune para el punto de conexión de destino.

• Una base de datos relacional de SQL admitida por AWS DMS para el punto de conexión de origen.

• Un bucket de Amazon S3 para el punto de conexión de destino. Cree este bucket de S3 en la misma región de AWS en la que está el clúster de Neptune. AWS DMS usa este bucket de S3 como un archivo de almacenamiento intermedio para los datos de destino que realiza cargas por lotes en la base de datos de Neptune. Para obtener más información sobre la creación de un bucket de S3, consulte Creación de un bucket en la Guía del usuario de Amazon Simple Storage Service.

• Un punto de conexión de nube privada virtual (VPC) 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 rol lo asume AWS DMS y Neptune con acceso de IAM al bucket de S3 de destino y 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 una base de datos relacional de AWS DMS 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 conexión de destino de la base de datos de Neptune.

   Para conectar el punto de conexión de destino con la base de datos de Neptune, especifique el nombre del servidor para el punto de conexión del clúster de Neptune o para el punto de conexión de la instancia de escritor de Neptune. Especifique también la carpeta del bucket de S3 para que AWS DMS almacene sus archivos intermedios para la carga por lotes a 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 conexión 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-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 eligiendo una de las siguientes para especificar las reglas de asignación de las tablas y vistas de origen al gráfico de base de datos de destino de Neptune:

      • Gremlin JSON: para obtener información sobre el uso de JSON de Gremlin para cargar una base de datos de Neptune, consulte el formato de datos de carga Gremlin en la Guía del usuario de Amazon Neptune.

      • Lenguaje de asignación del RDB al marco de descripción de recursos (R2RML) de SPARQL: para obtener información sobre el uso de R2RML de SPARQL, consulte la especificación de W3C R2RML: lenguaje de asignación de RDB a RDF.

   3. Haga 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 asignación 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 conexión 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 destino de Neptune en la consola de AWS DMS, especifique los Ajustes específicos del punto de conexión en la página de la consola Crear punto de conexión o Modificar punto de conexión. En CreateEndpoint y ModifyEndpoint, especifique los parámetros de solicitud de la opción NeptuneSettings. El siguiente ejemplo muestra cómo hacer esto usando 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 opción --server-name de la CLI especifica el nombre del servidor del punto de conexión del escritor del clúster de Neptune. O puede especificar el nombre del servidor para un punto de conexión de instancia del escritor de Neptune.

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

• ServiceAccessRoleArn: (requerido) el nombre de recurso de Amazon (ARN) del rol de servicio que ha creado para el punto de conexión 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: (requerido) el 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: (requerido) una ruta de carpeta en la que desea que DMS almacene datos de gráficos migrados en el bucket de S3 especificado por S3BucketName.

• ErrorRetryDuration: (opcional) el número de milisegundos para DMS que 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 conexión, establezca este parámetro en true y adjunte el documento de política de IAM correspondiente al rol de servicio especificado por ServiceAccessRoleArn. 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 conexión de Neptune, adjunte a este rol alguna o todas las políticas de IAM y documentos de confianza. Cuando crea el punto de conexión de Neptune, proporciona el ARN de este rol de servicio. Esto permite que AWS DMS y Amazon Neptune asuman permisos para acceder tanto a Neptune como al bucket de Amazon S3 asociado.

Si establece el parámetro IAMAuthEnabled de NeptuneSettings en true en la configuración del punto de conexión de Neptune, adjunte una política de IAM como la siguiente al 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 por Resource.

Adjunte una política de IAM como la siguiente a su rol de servicio. Esta política permite a DMS almacenar de forma temporal datos de gráficos migrados en el bucket de S3 que ha creado para cargarlos por lotes a 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 la cuenta consultar el contenido del bucket de S3 (arn:aws:s3:::my-bucket) creado para el destino de 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 al rol de servicio para permitir a AWS DMS y al servicio de bases de datos de Amazon Neptune 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 el punto de conexión de destino de Neptune, consulte Especificación de la configuración del punto de conexión de Amazon Neptune como destino.

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

Las reglas de asignación 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 Neptune de base de datos. 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 la carga por lotes de 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 asignación de gráficos mediante el JSON de Gremlin, consulte Formato de datos de carga Gremlin en la Guí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 W3C R2RML: RDB to RDF mapping language.

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

AWS DMS realiza asignaciones de tipo de datos desde el punto de conexión de origen de SQL hasta el 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 asignación 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, consulte Tipos de datos de Gremlin en la Guí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, consulte RDF literals en la especificación de W3C Marco 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 sobre los tipos de datos RDF para cargar Neptune y las asignaciones a tipos de datos de origen de SQL, consulte Conversiones de tipos de datos en la especificación de W3C R2RML: Lenguaje de asignación RBD a RDF.

Restricciones del uso de Amazon Neptune como destino

Al utilizar Neptune como destino se aplican las siguientes restricciones:

• AWS DMS actualmente 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 elimina todos los datos de la 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) que hay en el 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 las 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).

• La operación DescribeTableStatistics de la API de DMS puede devolver resultados inexactos sobre una tabla dada debido a la naturaleza de las estructuras de datos de gráficos de Neptune.

  Durante la migración, AWS DMS analiza cada tabla de origen y utiliza la asignación 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 estos datos de S3 intermedios se generan correctamente, DescribeTableStatistics asume que los datos se han cargado correctamente en la base de datos de destino de 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 DMS ha cargado una tabla customer desde la base de datos de origen, que se asigna a la etiqueta 'customer' en el gráfico de la base de datos de Neptune de destino. Puede asegurarse de que esta etiqueta se escribe en la base de datos de destino. Para ello, compare la cantidad de filas customer disponibles en la base de datos de origen con la cantidad de filas etiquetadas con 'customer' cargadas en la base de datos de destino de Neptune después de la finalización de 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 el 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 DMS no admite la migración de datos de LOB a un objetivo de Neptune.