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á.
# Usando AWS Database Migration Service para carregar dados no Amazon Neptune a partir de um armazenamento de dados diferente
AWS Database Migration Service (AWS DMS) pode carregar dados no Neptune a partir de bancos de dados de [origem compatíveis de](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.html) forma rápida e segura. O banco de dados de origem permanece totalmente operacional durante a migração, o que minimiza o tempo de inatividade de aplicativos que dependem dele.
Você pode encontrar informações detalhadas sobre isso AWS DMS no [Guia do AWS Database Migration Service usuário](https://docs.aws.amazon.com/dms/latest/userguide/) e na [Referência AWS Database Migration Service da API](https://docs.aws.amazon.com/dms/latest/APIReference/). Em específico, é possível descobrir como configurar um cluster do Neptune como destino para migração em [Using Amazon Neptune as a Target for AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.Neptune.html).
Veja alguns pré-requisitos para importar dados para o Neptune usando o AWS DMS:
+ Você precisará criar um objeto de mapeamento de AWS DMS tabela para definir como os dados devem ser extraídos do banco de dados de origem (consulte [Especificação da seleção e transformações de tabelas por mapeamento de tabelas usando JSON](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.html#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation) no Guia do AWS DMS usuário para obter detalhes). Esse objeto de configuração de mapeamento de tabelas especifica quais tabelas devem ser lidas e em que ordem e como suas colunas são chamadas. Ele também pode filtrar as linhas que estão sendo copiadas e fornecer transformações de valor simples, como converter para letras minúsculas ou arredondar.
+ Será necessário criar um `GraphMappingConfig` do Neptune para especificar como os dados extraídos do banco de dados de origem devem ser carregados no Neptune. Para dados do RDF (consultados usando o SPARQL), o `GraphMappingConfig` é escrito na linguagem de mapeamento [R2RML](https://www.w3.org/TR/r2rml/) padrão do W3. Para dados de grafos de propriedades (consultados usando o Gremlin), o `GraphMappingConfig` é um objeto JSON, descrito em [GraphMappingConfig Layout para dados de gráfico de propriedade/Gremlin](dms-neptune-graph-mapping.md#dms-neptune-graph-mapping-gremlin).
+ Você deve usar AWS DMS para criar uma instância de replicação na mesma VPC do seu cluster de banco de dados Neptune, para mediar a transferência de dados.
+ Também será necessário um bucket do Amazon S3 a ser usado como armazenamento intermediário para preparar os dados de migração.
# Criando um Netuno GraphMappingConfig
O `GraphMappingConfig` criado especifica como os dados extraídos de um armazenamento de dados de origem devem ser carregados em um cluster de banco de dados do Neptune. O formato será diferente dependendo se ele for destinado a carregar dados do RDF ou a carregar dados de grafos de propriedades.
Para dados do RDF, é possível usar a linguagem [R2RML](https://www.w3.org/TR/r2rml/) do W3 para mapear dados relacionais para o RDF.
Se você estiver carregando dados de gráficos de propriedades a serem consultados usando o Gremlin, crie um objeto JSON para `GraphMappingConfig`.
## GraphMappingConfig Layout para RDF/SPARQL dados
Se você estiver carregando dados do RDF a serem consultados usando o SPARQL, escreva o `GraphMappingConfig` em [R2RML](https://www.w3.org/TR/r2rml/). `R2RML` é uma linguagem W3 padrão para mapear dados relacionais para o RDF. Veja aqui um exemplo:
```
@prefix rr: .
@prefix ex: .
<#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" ];
] .
```
Aqui está outro exemplo:
```
@prefix rr: .
@prefix ex: .
@prefix foaf: .
@prefix xsd: .
<#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" ]
] .
```
A recomendação do W3 em [R2RML: RDB to RDF Mapping Language](https://www.w3.org/TR/r2rml/) fornece detalhes da linguagem.
## GraphMappingConfig Layout para dados de gráfico de propriedade/Gremlin
Um `GraphMappingConfig` comparável para dados de gráficos de propriedades é um objeto JSON que fornece uma regra de mapeamento para cada entidade de gráfico a ser gerada com base nos dados de origem. 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)"
}
]
}
]
}
]
}
```
Observe que a presença de um rótulo de vértice implica que o vértice está sendo criado aqui, enquanto sua ausência implica que o vértice foi criado por uma fonte diferente e que esta definição está apenas adicionando propriedades do vértice.
Veja a seguir um exemplo de regra para um registro de funcionário:
```
{
"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"
}
]
}
]
}
]
}
```
# Criação de uma tarefa AWS DMS de replicação com Neptune como destino
Depois de criar as configurações de mapeamento de tabelas e mapeamento de grafos, use o processo a seguir para carregar dados do armazenamento de origem no Neptune. Consulte a AWS DMS documentação para obter mais detalhes sobre o assunto APIs em questão.
## Crie uma instância de AWS DMS replicação
Crie uma instância de AWS DMS replicação na VPC em que seu cluster de banco de dados Neptune está sendo executado ([consulte Como trabalhar com AWS uma instância de replicação do DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_ReplicationInstance.html) e no Guia do usuário). [CreateReplicationInstance](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationInstance.html) AWS DMS Você pode usar um AWS CLI comando como o seguinte para fazer isso:
```
aws dms create-replication-instance \
--replication-instance-identifier (the replication instance identifier) \
--replication-instance-class (the size and capacity of the instance, like 'dms.t2.medium') \
--allocated-storage (the number of gigabytes to allocate for the instance initially) \
--engine-version (the DMS engine version that the instance should use) \
--vpc-security-group-ids (the security group to be used with the instance)
```
## Crie um AWS DMS endpoint para o banco de dados de origem
A próxima etapa é criar um AWS DMS endpoint para seu armazenamento de dados de origem. Você pode usar a AWS DMS [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)API da seguinte AWS CLI forma:
```
aws dms create-endpoint \
--endpoint-identifier (source endpoint identifier) \
--endpoint-type source \
--engine-name (name of source database engine) \
--username (user name for database login) \
--password (password for login) \
--server-name (name of the server) \
--port (port number) \
--database-name (database name)
```
## Configurar um bucket do Amazon S3 para o Neptune para uso para dados de preparação
Se você não tiver um bucket do Amazon S3 que possa ser usado para preparar os dados, crie um conforme explicado em [Creating a Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) no Guia de conceitos básicos do Amazon S3 ou [How Do I Create an S3 Bucket?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html) no Guia do usuário do console.
Será necessário criar uma política do IAM que conceda permissões `GetObject`, `PutObject`, `DeleteObject` e `ListObject` para o bucket, se você ainda não tiver uma:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ListObjectsInBucket",
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
},
{
"Sid": "AllObjectActions",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}
```
------
Se o cluster de banco de dados do Neptune tiver a autenticação do IAM habilitada, também será necessário incluir a seguinte política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "neptune-db:*",
"Resource": "arn:aws:neptune-db:us-east-1:111122223333:cluster-resource-id/*"
}
]
}
```
------
Crie um perfil do IAM como um documento de confiança para associar a política a:
------
#### [ JSON ]
****
```
{
"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"
}
]
}
```
------
Depois de associar a política ao perfil, associe o perfil ao cluster de banco de dados do Neptune. Isso permitirá AWS DMS usar o bucket para preparar os dados que estão sendo carregados.
## Criar um endpoint do Amazon S3 na VPC do Neptune
Agora, crie um endpoint de gateway de VPC para o bucket do Amazon S3 intermediário, na VPC na qual o cluster do Neptune está localizado. Você pode usar o Console de gerenciamento da AWS ou o AWS CLI para fazer isso, conforme descrito em [Criação de um endpoint de gateway](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-gateway.html#create-gateway-endpoint).
## Crie um endpoint de AWS DMS destino para Neptune
Crie um AWS DMS endpoint para seu cluster de banco de dados Neptune de destino. Você pode usar a AWS DMS [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html)API com o `NeptuneSettings` parâmetro como este:
```
aws dms create-endpoint \
--endpoint-identifier (target endpoint identifier) \
--endpoint-type target \
--engine-name neptune \
--server-name (name of the server) \
--port (port number) \
--neptune-settings '{ \
"ServiceAccessRoleArn": "(ARN of the service access role)", \
"S3BucketName": "(name of S3 bucket to use for staging files when migrating)", \
"S3BucketFolder": "(name of the folder to use in that S3 bucket)", \
"ErrorRetryDuration": (number of milliseconds to wait between bulk-load retries), \
"MaxRetryCount": (the maximum number of times to retry a failing bulk-load job), \
"MaxFileSize": (maximum file size, in bytes, of the staging files written to S3), \
"IamAuthEnabled": (set to true if IAM authentication is enabled on the Neptune cluster) }'
```
O objeto JSON passado para a AWS DMS `CreateEndpoint` API em seu `NeptuneSettings` parâmetro tem os seguintes campos:
****
+ **`ServiceAccessRoleArn`**: *(obrigatório)* o ARN de um perfil do IAM que permite acesso refinado ao bucket do S3 usado para preparar a migração dos dados para o Neptune. Esse perfil também deverá ter permissões para acessar o cluster de banco de dados do Neptune se a autorização do IAM estiver habilitada nela.
+ **`S3BucketName`**: *(obrigatório)* para a migração de carregamento completo, a instância de replicação converte todos os dados do RDS em arquivos CSV e quad, carrega-os para esse bucket de preparação no S3 e carrega-os em massa para o Neptune.
+ **`S3BucketFolder`**: *(obrigatório)* a pasta a ser usada no bucket de preparação do S3.
+ **`ErrorRetryDuration`**: *(opcional)* o número de milissegundos a aguardar após uma solicitação do Neptune falhar antes de tentar fazer uma nova solicitação. O padrão é 250.
+ **`MaxRetryCount`**— *(opcional)* O número máximo de solicitações de repetição que AWS DMS devem ser feitas após uma falha que possa ser repetida. O padrão é 5.
+ **`MaxFileSize`**: *(opcional)* o tamanho máximo em bytes de cada arquivo de teste salvo no S3 durante a migração. O padrão é 1.048.576 KB (1 GB).
+ **`IsIAMAuthEnabled`** *(opcional)* Defina como `true` defina se a autenticação do IAM estiver habilitada no cluster de banco de dados do Neptune ou `false` se não estiver. O padrão é `false`.
## Testar conexões com os novos endpoints
Você pode testar a conexão com cada um desses novos endpoints usando a AWS DMS [TestConnection](https://docs.aws.amazon.com/dms/latest/APIReference/API_TestConnection.html)API da seguinte forma:
```
aws dms test-connection \
--replication-instance-arn (the ARN of the replication instance) \
--endpoint-arn (the ARN of the endpoint you are testing)
```
## Crie uma tarefa de AWS DMS replicação
Depois de concluir as etapas anteriores com êxito, crie uma tarefa de replicação para migrar dados do seu armazenamento de dados de origem para o Neptune, usando a API da seguinte forma: AWS DMS [CreateReplicationTask](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateReplicationTask.html.html)
```
aws dms create-replication-task \
--replication-task-identifier (name for the replication task) \
--source-endpoint-arn (ARN of the source endpoint) \
--target-endpoint-arn (ARN of the target endpoint) \
--replication-instance-arn (ARN of the replication instance) \
--migration-type full-load \
--table-mappings (table-mapping JSON object or URI like 'file:///tmp/table-mappings,json') \
--task-data (a GraphMappingConfig object or URI like 'file:///tmp/graph-mapping-config.json')
```
O parâmetro `TaskData` fornece o [GraphMappingConfig](dms-neptune-graph-mapping.md), que especifica como os dados que estão sendo copiados devem ser armazenados no Neptune.
## Inicie a tarefa de AWS DMS replicação
Agora, é possível iniciar a tarefa de replicação:
```
aws dms start-replication-task
--replication-task-arn (ARN of the replication task started in the previous step)
--start-replication-task-type start-replication
```