Utilizar o Amazon Neptune como destino do AWS Database Migration Service

O Amazon Neptune é um serviço de banco de dados de grafos rápido, confiável e totalmente gerenciado que facilita a criação e a execução de aplicações que trabalham com conjuntos de dados altamente conectados. O recurso principal do Neptune é um mecanismo de banco de dados de grafo com projeto específico e alto desempenho. Esse mecanismo é otimizado para armazenar bilhões de relacionamentos e consultar grafos com latência de milissegundos. O Neptune é compatível com as linguagens de consulta de grafos populares do Apache TinkerPop Gremlin e do SPARQL do W3C. Para obter mais informações sobre o Amazon Neptune, consulte O que é o Amazon Neptune? no Guia do usuário do Amazon Neptune.

Sem um banco de dados de grafo, como o Neptune, é provável que você modele os dados altamente conectados em um banco de dados relacional. Como os dados têm conexões potencialmente dinâmicas, as aplicações que utilizam essas fontes de dados precisam modelar consultas de dados conectadas no SQL. Essa abordagem exigirá que você grave uma camada extra para converter consultas gráficas em SQL. Além disso, os bancos de dados relacionais vêm com rigidez de esquema. Quaisquer alterações no esquema para modelar conexões alteradas requerem tempo de inatividade e manutenção adicional da conversão da consulta para oferecer suporte ao novo esquema. Além disso, o desempenho da consulta é outra grande restrição a ser considerada ao projetar seus aplicativos.

Os bancos de dados de grafos podem simplificar muito essas situações. Livre de um esquema, uma camada de consulta de grafos avançada (Gremlin ou SPARQL) e índices otimizados para consultas de grafos aumentam a flexibilidade e o desempenho. O banco de dados de grafo Amazon Neptune também tem recursos corporativos, como a criptografia em repouso, uma camada de autorização segura, backups padrão, suporte a multi-AZ, suporte a réplicas de leitura e outros.

Utilizando o AWS DMS, é possível migrar dados relacionais que modelam um grafo altamente conectado a um endpoint de destino do Neptune de um endpoint de origem do DMS para qualquer banco de dados SQL compatível.

Para obter mais detalhes, consulte as informações a seguir.

Visão geral da migração para o Amazon Neptune como destino

Antes de iniciar uma migração para um destino do Neptune, crie os seguintes recursos na sua conta da AWS:

• Um cluster do Neptune para o endpoint de destino.

• Um banco de dados relacional SQL compatível com AWS DMS para o endpoint de origem.

• Um bucket do Amazon S3 para o endpoint de destino. Crie esse bucket do S3 na mesma região da AWS que o cluster do Neptune. O AWS DMS utilizará esse bucket do S3 como armazenamento de arquivos intermediário para os dados de destino que carrega em massa para o banco de dados Neptune. Para obter mais informações sobre como criar um bucket do S3, consulte Criar um bucket, no Guia do usuário do Amazon Simple Storage Service.

• Um endpoint de nuvem privada virtual (VPC) para o S3 na mesma VPC que o cluster do Neptune.

• Um perfil do AWS Identity and Access Management (IAM) que inclui uma política do IAM. Essa política deve especificar as permissões GetObject, PutObject, DeleteObject e ListObject para o bucket do S3 do endpoint de destino. Esse perfil será assumido pelo AWS DMS e pelo Neptune com acesso do IAM ao bucket do S3 de destino e ao banco de dados Neptune. Para obter mais informações, consulte Criar um perfil de serviço do IAM para acessar o Amazon Neptune como destino.

Depois de ter esses recursos, a configuração e a inicialização de uma migração para um destino do Neptune é semelhante a qualquer migração de carga máxima utilizando o console ou a API do DMS. No entanto, uma migração para um destino do Neptune exige algumas etapas exclusivas.

Como migrar um banco de dados relacional do AWS DMS para o Neptune

1. Crie uma instância de replicação conforme descrito em Criar uma instância de replicação.

2. Crie e teste um banco de dados relacional SQL compatível com AWS DMS para o endpoint de origem.

3. Crie e teste o endpoint de destino do banco de dados Neptune.

   Para conectar o endpoint de destino ao banco de dados Neptune, especifique o nome do servidor para o endpoint do cluster do Neptune ou para o endpoint da instância do gravador do Neptune. Além disso, especifique a pasta do bucket do S3 para o AWS DMS armazenar os arquivos intermediários de carga em massa no banco de dados do Neptune.

   Durante a migração, o AWS DMS armazenará todos os dados de destino migrados nesta pasta de bucket do S3 até o tamanho máximo de arquivo especificado. Quando esse armazenamento de arquivos atingir o tamanho máximo, o AWS DMS carregará em massa os dados do S3 armazenados no banco de dados de destino. Ele limpará a pasta para ativar o armazenamento de quaisquer dados de destino adicionais para carregamento posterior no banco de dados de destino. Para obter mais informações sobre como especificar essas configurações, consulte Especificar as configurações do endpoint do Amazon Neptune como destino.

4. Crie uma tarefa de replicação de carga máxima com os recursos criados nas etapas 1 a 3 e siga estas etapas:

   1. Utilize o mapeamento da tabela de tarefas como de costume para identificar esquemas, tabelas e visualizações de origem específicos para migrar do banco de dados relacional utilizando as regras de seleção e de transformação apropriadas. Para obter mais informações, consulte Utilizar o mapeamento de tabela para especificar as configurações da tarefa.

   2. Especifique os mapeamentos de destino, escolhendo uma das opções a seguir para especificar as regras de mapeamento de tabelas e visualizações de origem para o grafo do banco de dados de destino do Neptune:

      • JSON do Gremlin: para obter informações sobre como utilizar o JSON do Gremlin para carregar um banco de dados Neptune, consulte Formato de dados de carga do Gremlin no Guia do usuário do Amazon Neptune.

      • SPARQL RDB to Resource Description Framework Mapping Language (R2RML): para obter informações sobre como utilizar SPARQL R2RML, consulte a especificação do W3C R2RML: RDB para a linguagem de mapeamento RDF.

   3. Execute um dos seguintes procedimentos:

      • Utilizando o console do AWS DMS, especifique opções de mapeamento de grafos com Regras de mapeamento de grafos na página Criar tarefa de migração de banco de dados.

      • Utilizando a API do AWS DMS, especifique essas opções utilizando o parâmetro de solicitação TaskData da chamada da API CreateReplicationTask.

      Para obter mais informações e exemplos que utilizam JSON de Gremlin e o SPARQL R2RML para especificar regras de mapeamento de grafos, consulte Especificar regras de mapeamento de grafos utilizando Gremlin e R2RML para o Amazon Neptune como destino.

5. Iniciar a replicação para sua tarefa de migração.

Especificar as configurações do endpoint do Amazon Neptune como destino

Para criar ou modificar um endpoint de destino, é possível utilizar o console CreateEndpoint ou as operações da API ModifyEndpoint.

Para um destino do Neptune no console do AWS DMS, defina as Configurações específicas do endpoint na página do console Criar endpoint ou Modificar endpoint. Para CreateEndpoint e ModifyEndpoint, especifique os parâmetros de solicitação para a opção NeptuneSettings. O exemplo a seguir mostra como fazer isso utilizando a 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}‘

Aqui, a opção da CLI --server-name especifica o nome do servidor para o endpoint do gravador de cluster do Neptune. Ou é possível especificar o nome do servidor para um endpoint de instância do gravador do Neptune.

Os parâmetros de solicitação de opção --neptune-settings são:

• ServiceAccessRoleArn: (obrigatório) o nome do recurso da Amazon (ARN) do perfil de serviço criado para o endpoint de destino do Neptune. Para obter mais informações, consulte Criar um perfil de serviço do IAM para acessar o Amazon Neptune como destino.

• S3BucketName: (obrigatório) o nome do bucket do S3 em que o DMS pode armazenar temporariamente dados de grafo migrados em arquivos .csv antes de carregá-los em massa para o banco de dados de destino Neptune. O DMS mapeia os dados de origem SQL para dados de grafo antes de armazená-los nesses arquivos .csv.

• S3BucketFolder: (obrigatório) o caminho de uma pasta em que você deseja que o DMS armazene dados de grafo migrados no bucket do S3 especificado por S3BucketName.

• ErrorRetryDuration: (opcional) o número de milissegundos de espera do DMS para repetir uma carga de dados de grafo migrados para o banco de dados de destino Neptune antes de gerar um erro. O padrão é 250.

• MaxFileSize: (opcional) o tamanho máximo em KB de dados de grafo migrados armazenados em um arquivo .csv antes que o DMS execute a carga em massa dos dados para o banco de dados de destino Neptune. O padrão é 1.048.576 KB (1 GB). Se for bem-sucedido, o DMS limpará o bucket, pronto para armazenar o próximo lote de dados de grafo migrados.

• MaxRetryCount: (opcional) o número de vezes para o DMS repetir uma carga em massa de dados de grafo migrados para o banco de dados de destino do Neptune antes de gerar um erro. O padrão é 5.

• IAMAuthEnabled: (opcional) se desejar a autorização do IAM ativada para esse endpoint, defina esse parâmetro como ServiceAccessRoleArn e anexe o documento de política do IAM apropriado ao perfil de serviço especificado por true. O padrão é false.

Criar um perfil de serviço do IAM para acessar o Amazon Neptune como destino

Para acessar o Neptune como destino, crie um perfil de serviço utilizando o IAM. Dependendo da configuração do endpoint do Neptune, anexe a esse perfil alguns ou todos os documentos de confiança e de política do IAM. Ao criar o endpoint do Neptune, forneça o ARN desse perfil de serviço. Fazer isso permite que o AWS DMS e o Amazon Neptune tenham permissões para acessar o Neptune e o bucket do Amazon S3 associado.

Se você definir o parâmetro IAMAuthEnabled em NeptuneSettings como true na configuração do endpoint do Neptune, anexe uma política do IAM como a seguinte ao perfil de serviço. Se definir IAMAuthEnabled como false, é possível 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/*"
            }
        ]
    }

A política do IAM anterior permite acesso total ao cluster de destino do Neptune especificado por Resource.

Anexe uma política do IAM como a seguinte ao perfil de serviço. Essa política permite que o DMS armazene temporariamente dados de grafos migrados no bucket do S3 criados para carregamento em massa no banco de dados de destino do 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/"
			]
		}
	]
}

A política do IAM anterior permite que a sua conta consulte o conteúdo do bucket do S3 (arn:aws:s3:::my-bucket) criado para o destino do Neptune. Ela também permite que sua conta opere totalmente no conteúdo de todos os arquivos e pastas do bucket (arn:aws:s3:::my-bucket/).

Edite a relação de confiança e anexe o seguinte perfil do IAM ao perfil de serviço para permitir que o AWS DMS e os serviços de banco de dados Amazon Neptune assumam o perfil.

{
  "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 obter informações sobre como especificar esse perfil de serviço para o endpoint de destino Neptune, consulte Especificar as configurações do endpoint do Amazon Neptune como destino.

Especificar regras de mapeamento de grafos utilizando Gremlin e R2RML para o Amazon Neptune como destino

As regras de mapeamento de grafos criadas especificam como os dados extraídos de uma origem de banco de dados relacional SQL são carregados em um destino de cluster de banco de dados Neptune. O formato dessas regras de mapeamento difere dependendo de se as regras carregam dados do grafos de propriedades utilizando os dados do Apache TinkerPop Gremlin ou Resource Description Framework (RDF) utilizando R2RML. A seguir, você encontrará informações sobre esses formatos e muito mais.

É possível especificar essas regras de mapeamento ao criar a tarefa de migração utilizando o console ou a API do DMS.

Utilizando o console, especifique essas regras de mapeamento utilizando Regras de mapeamento de grafos na página Criar tarefa de migração de banco de dados. Em Regras de mapeamento de grafos, é possível inserir e editar as regras de mapeamento diretamente utilizando o editor fornecido. Ou é possível procurar um arquivo que contenha as regras de mapeamento no formato apropriado de mapeamento de grafos.

Utilizando a API, especifique essas opções utilizando o parâmetro de solicitação TaskData da chamada de API CreateReplicationTask. Defina TaskData como o caminho de um arquivo que contém as regras de mapeamento no formato de mapeamento de grafos apropriado.

Regras de mapeamento de grafos para geração de dados de grafo de propriedade utilizando o Gremlin

Utilizando o Gremlin para gerar os dados de grafos de propriedade, especifique um objeto JSON com uma regra de mapeamento para cada entidade de grafo a ser gerada dos dados de origem. O formato deste JSON é definido especificamente para carga em massa do Amazon Neptune. O modelo a seguir mostra como é cada regra nesse 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)"
                        }
                    ]
                }
            ]
        }
    ]
}
 

A presença de um rótulo de vértice implica que o vértice está sendo criado aqui. Sua ausência implica que o vértice está sendo criado por uma origem diferente, e essa definição está adicionando apenas propriedades de vértice. Especifique quantas definições de vértice e borda forem necessárias para especificar os mapeamentos para toda a origem do banco de dados relacional.

Veja a seguir uma regra de exemplo para uma tabela 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"
                        }
                    ]
                }
            ]
        }
    ]
}
 

Aqui, as definições de vértice e borda mapeiam uma relação hierárquica de um nó employee com ID de funcionário (EmpID) e um nó employee com um ID de gerente (managerId).

Para obter mais informações sobre como criar regras de mapeamento de grafos utilizando JSON do Gremlin, consulte Formato de dados de carga do Gremlin no Guia do usuário do Amazon Neptune.

Regras de mapeamento de grafos para geração de dados RDF/SPARQL

Se você estiver carregando dados RDF a serem consultados utilizando SPARQL, grave as regras de mapeamento de grafos no R2RML. R2RML é uma linguagem W3C padrão de mapeamento de dados relacionais para RDF. Em um arquivo R2RML, um mapa triplo (por exemplo, <#TriplesMap1> a seguir) especifica uma regra para transformar cada linha de uma tabela lógica em RDF triplos. Um mapa de assunto (por exemplo, rr:subjectMap a seguir) especifica uma regra para gerar os assuntos dos RDF triplos gerados por um mapa triplo. Um mapa de objeto de predicado (por exemplo, qualquer rr:predicateObjectMap a seguir) é um perfil que cria um ou mais pares de objetos de predicado para cada linha de uma tabela lógica.

Segue um exemplo simples para uma tabela 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" ];
    ]

No exemplo anterior, o mapeamento define nós de grafo mapeados a partir de uma tabela de funcionários.

Veja outro exemplo simples de tabela 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" ]
    ].

No exemplo anterior, o mapeamento define nós de grafo que mapeiam relações de terceiros entre pessoas de uma tabela Student.

Para obter mais informações sobre como criar regras de mapeamento de grafos utilizando SPARQL R2RML, consulte a especificação W3C R2RML: RDB to RDF Mapping Language.

Tipos de dados para migração de Gremlin e R2RML para o Amazon Neptune como destino

O AWS DMS executa o mapeamento do tipo de dados do endpoint de origem do SQL para o Neptune de destino de duas formas. O modo utilizado depende do formato do mapeamento de grafos utilizado para carregar o banco de dados Neptune:

• Apache TinkerPop Gremlin, utilizando uma representação JSON dos dados de migração.

• SPARQL do W3C, utilizando uma representação R2RML dos dados de migração.

Para obter mais informações sobre esses dois formatos de mapeamento de grafos, consulte Especificar regras de mapeamento de grafos utilizando Gremlin e R2RML para o Amazon Neptune como destino.

Veja a seguir descrições dos mapeamentos de tipos de dados para cada formato.

Mapeamentos de tipos de dados de origem SQL para destino Gremlin

A tabela a seguir mostra os mapeamentos de tipos de dados de uma origem SQL para um destino Gremlin formatado.

O AWS DMS mapeia qualquer tipo de dados de origem SQL não listado para um Gremlin String.

Tipos de dados de origem SQL	Tipos de dados de destino Gremlin
NUMERIC (e 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 (e variantes)	String

Para obter mais informações sobre os tipos de dados do Gremlin para carregamento do Neptune, consulte Tipos de dados do Gremlin no Guia do usuário do Neptune.

Mapeamentos de tipos de dados de origem SQL para destino R2RML (RDF)

A tabela a seguir mostra os mapeamentos de tipos de dados de uma origem SQL para um destino R2RML formatado.

Todos os tipos de dados RDF listados fazem distinção de maiúsculas e minúsculas, exceto RDF literal. O AWS DMS mapeia qualquer tipo de dados de origem SQL não listado em um RDF literal.

Um RDF literal é uma de muitas formas e tipos de dados lexicais e literais. Para obter mais informações, consulte RDF Literals na especificação W3C Resource Description Framework (RDF): conceitos e sintaxe abstrata.

Tipos de dados de origem SQL	Tipos de dados de destino R2RML (RDF)
BINARY (e variantes)	xsd:hexBinary
NUMERIC (e 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 (e variantes)	RDF literal

Para obter mais informações sobre os tipos de dados RDF para carregamento do Neptune e de seus mapeamentos para tipos de dados de origem SQL, consulte Conversões de tipo de dados na especificação do W3C R2RML: RDB para linguagem de mapeamento RDF.

Limitações da utilização do Amazon Neptune como destino

Aplicam-se as seguintes limitações ao utilizar o Neptune como destino:

• Atualmente, o AWS DMS é compatível com tarefas de carga máxima somente para migração para um destino do Neptune. A migração de captura de dados de alterações (CDC) para um destino do Neptune não é compatível.

• Verifique se o banco de dados Neptune de destino é limpo manualmente de todos os dados antes de iniciar a tarefa de migração, como nos exemplos a seguir.

  Para descartar todos os dados (vértices e bordas) dentro do grafo, execute o seguinte comando do Gremlin.

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

  Para descartar vértices com o rótulo 'customer', execute o seguinte comando do Gremlin.

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

  nota

  A remoção de um grande conjunto de dados pode levar algum tempo. Talvez você queira iterar drop() com uma limitação, por exemplo, limit(1000).

  Para descartar bordas com o rótulo 'rated', execute o seguinte comando do Gremlin.

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

  nota

  A remoção de um grande conjunto de dados pode levar algum tempo. Talvez você queira iterar drop() com uma limitação, por exemplo, limit(1000).

• A operação da API do DMS DescribeTableStatistics pode retornar resultados imprecisos sobre determinada tabela devido à natureza das estruturas de dados do grafo do Neptune.

  Durante a migração, o AWS DMS verifica cada tabela de origem e utiliza o mapeamento de grafos para converter os dados de origem em um grafo do Neptune. Os dados convertidos são armazenados primeiro na pasta de bucket do S3 especificada para o endpoint de destino. Se a origem for verificada e esses dados intermediários do S3 forem gerados com êxito, DescribeTableStatistics pressupõe que os dados foram carregados com êxito no banco de dados de destino do Neptune. Entretanto, isso nem sempre é verdade. Para verificar se os dados foram carregados corretamente para determinada tabela, compare os valores de retorno count() nas extremidades da migração para essa tabela.

  No exemplo a seguir, o AWS DMS carregou uma tabela customer do banco de dados de origem, à qual é atribuído o rótulo 'customer' no grafo do banco de dados de destino do Neptune. É possível certificar-se de que esse rótulo seja gravado no banco de dados de destino. Para isso, compare o número de linhas do customer disponíveis no banco de dados de origem com o número de linhas rotuladas do 'customer' carregadas no banco de dados de destino do Neptune após a conclusão da tarefa.

  Para obter o número de linhas disponíveis do cliente no banco de dados de origem utilizando SQL, execute o seguinte procedimento.

  select count(*) from customer;

  Para obter o número de linhas rotuladas 'customer' carregadas no grafo do banco de dados de destino utilizando Gremlin, execute o seguinte procedimento.

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

• Atualmente, se uma única tabela não for carregada, toda a tarefa falhará. Diferentemente de um banco de dados relacional de destino, os dados no Neptune são altamente conectados, o que torna impossível, em muitos casos, retomar uma tarefa. Se uma tarefa não puder ser retomada com êxito devido a esse tipo de falha de carga de dados, crie uma nova tarefa para carregar a tabela que apresentou falha no carregamento. Antes de executar essa nova tarefa, limpe manualmente a tabela parcialmente carregada do destino do Neptune.

  nota

  É possível retomar uma tarefa com falha na migração para um destino do Neptune se a falha for recuperável (por exemplo, um erro de trânsito de rede).

• O AWS DMS é compatível com a maioria dos padrões de R2RML. No entanto, o AWS DMS não é compatível com determinados padrões R2RML, incluindo expressões inversas, junções e visualizações. Uma solução alternativa para uma exibição R2RML é criar uma exibição SQL personalizada correspondente no banco de dados de origem. Na tarefa de migração, utilize o mapeamento de tabela para escolher a exibição como entrada. Mapeie a exibição para uma tabela que seja então consumida pelo R2RML para gerar dados de grafo.

• Ao migrar dados de origem com tipos de dados SQL não é compatível com dos, os dados de destino resultantes podem ter perda de precisão. Para obter mais informações, consulte Tipos de dados para migração de Gremlin e R2RML para o Amazon Neptune como destino.

• O AWS DMS não é compatível com a migração de dados LOB para um destino do Neptune.