As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

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:

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.

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:

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:

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.

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.

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: