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á.
# Carregar dados no Amazon Neptune
Existem várias maneiras diferentes de carregar dados de grafo no Amazon Neptune:
+ Se você precisar carregar apenas uma quantidade relativamente pequena de dados, poderá usar consultas como `INSERT` instruções SPARQL ou Gremlin `mergeV` e `mergeE` etapas. O OpenCypher também inclui cláusulas e. `CREATE` `MERGE`
+ É possível aproveitar [Carregador em massa do Neptune](bulk-load.md) para ingerir grandes quantidades de dados que residem em arquivos externos. O comando do carregador em massa é mais rápido e tem menos sobrecarga do que os comandos query-language. Ele é otimizado para grandes conjuntos de dados e oferece suporte a dados do RDF (Resource Description Framework) e do Gremlin.
+ Você pode usar AWS Database Migration Service (AWS DMS) para importar dados de outros armazenamentos de dados (consulte [Usando AWS Database Migration Service para carregar dados no Amazon Neptune a partir de um armazenamento de dados diferente](dms-neptune.md) o [Guia AWS Database Migration Service do Usuário](https://docs.aws.amazon.com/dms/latest/userguide/)).
+ Para conjuntos de dados menores em um ou alguns arquivos do Amazon S3, você pode usar funções de carregamento baseadas em consultas para ler e processar dados diretamente em suas consultas. Consulte [Carregamento de dados no Amazon Neptune usando consultas](load-data-via-query.md) para obter mais detalhes.
**Topics**
+ [Usar o carregador em massa do Amazon Neptune para ingerir dados](bulk-load.md)
+ [Usando AWS Database Migration Service para carregar dados no Amazon Neptune a partir de um armazenamento de dados diferente](dms-neptune.md)
+ [Carregamento de dados no Amazon Neptune usando consultas](load-data-via-query.md)
# Usar o carregador em massa do Amazon Neptune para ingerir dados
O Amazon Neptune fornece um comando `Loader` para carregar dados de arquivos externos diretamente em um cluster de banco de dados do Neptune. É possível usar esse comando em vez de executar um grande número de declarações `INSERT`, etapas `addV` e `addE` ou outras chamadas de API.
O comando **Loader** do Neptune é mais rápido, tem menor sobrecarga, é otimizado para grandes conjuntos de dados e é compatível com dados do Gremlin e do RDF (Resource Description Framework) usados pelo SPARQL.
O diagrama a seguir mostra uma visão geral do processo de carga:
![\[Diagrama que mostra as etapas básicas envolvidas no carregamento de dados no Neptune.\]](http://docs.aws.amazon.com/pt_br/neptune/latest/userguide/images/load-diagram.png)
Veja as etapas do processo de carregamento:
1. Copie os arquivos de dados em um bucket do Amazon Simple Storage Service (Amazon S3).
1. Crie uma função do IAM com acesso de leitura e lista no bucket.
1. Crie um endpoint da VPC do Amazon S3.
1. Inicie o carregador do Neptune enviando uma solicitação à instância de banco de dados do Neptune por meio de HTTP.
1. A instância de banco de dados do Neptune assume o perfil do IAM para carregar os dados do bucket.
**nota**
Será possível carregar dados criptografados do Amazon S3 se eles tiverem sido criptografados usando `SSE-S3` do Amazon S3 ou o modo `SSE-KMS`, desde que o perfil utilizado para carregamento em massa tenha acesso ao objeto do Amazon S3 e, no caso da SSE-KMS, `kms:decrypt`. O Neptune pode personificar suas credenciais e emitir chamadas do `s3:getObject` em seu nome.
No entanto, o Neptune no momento não é compatível com o carregamento de dados criptografados usando o modo `SSE-C`.
As seções a seguir fornecem instruções para preparar e carregar dados no Neptune.
**Topics**
+ [Pré-requisitos: perfil do IAM e acesso ao Amazon S3](bulk-load-tutorial-IAM.md)
+ [Formatos de dados de carga](bulk-load-tutorial-format.md)
+ [Exemplo: carregamento de dados em uma instância de banco de dados do Neptune](bulk-load-data.md)
+ [Otimizar uma carga em massa do Amazon Neptune](bulk-load-optimize.md)
+ [Referência do carregador do Neptune](load-api-reference.md)
# Pré-requisitos: perfil do IAM e acesso ao Amazon S3
Carregar dados de um bucket do Amazon Simple Storage Service (Amazon S3) requer AWS Identity and Access Management uma função (IAM) que tenha acesso ao bucket. O Amazon Neptune assume essa função de carregar os dados.
**nota**
Você poderá carregar dados criptografados do Amazon S3 se ele foi criptografado usando o modo `SSE-S3` do Amazon S3. Nesse caso, o Neptune pode personificar suas credenciais e emitir chamadas `s3:getObject` em seu nome.
Você também pode carregar dados criptografados do Amazon S3 que foram criptografados usando o modo `SSE-KMS`, desde que o perfil do IAM inclua as permissões necessárias para acessar o AWS KMS. Sem AWS KMS as permissões adequadas, a operação de carregamento em massa falha e retorna uma `LOAD_FAILED` resposta.
No momento, o Neptune não é compatível com o carregamento de dados criptografados do Amazon S3 usando o modo `SSE-C`.
As seções a seguir mostram como usar uma política do IAM gerenciada para criar um perfil do IAM para acessar recursos do Amazon S3 e, depois, associar o perfil ao seu cluster do Neptune.
**Topics**
+ [Criar um perfil do IAM para permitir que o Amazon Neptune acesse os recursos do Amazon S3](bulk-load-tutorial-IAM-CreateRole.md)
+ [Adicionar o perfil do IAM a um cluster do Amazon Neptune](bulk-load-tutorial-IAM-add-role-cluster.md)
+ [Criar o endpoint da VPC do Amazon S3](bulk-load-tutorial-vpc.md)
+ [Encadear perfis do IAM no Amazon Neptune](bulk-load-tutorial-chain-roles.md)
**nota**
Essas instruções exigem que você tenha acesso ao console do IAM e permissões para gerenciar perfis e políticas do IAM. Para obter mais informações, consulte [Permissões para trabalhar no console AWS de gerenciamento](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions-required.html#Credentials-Permissions-overview-console) no *Guia do usuário do IAM*.
O console do Amazon Neptune exige que o usuário tenha as seguintes permissões do IAM para associar o perfil ao cluster do Neptune:
```
iam:GetAccountSummary on resource: *
iam:ListAccountAliases on resource: *
iam:PassRole on resource: * with iam:PassedToService restricted to rds.amazonaws.com
```
# Criar um perfil do IAM para permitir que o Amazon Neptune acesse os recursos do Amazon S3
Use a política gerenciada do IAM `AmazonS3ReadOnlyAccess` para criar um perfil do IAM que permitirá ao Amazon Neptune acessar os recursos do Amazon S3.
**Como criar um perfil do IAM que permita ao Neptune acessar o Amazon S3**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Perfis**.
1. Escolha **Criar Perfil**.
1. Em **Serviço da AWS **, escolha **S3**.
1. Escolha **Próximo: Permissões**.
1. Use a caixa de filtro para filtrar pelo termo **S3** e marque a caixa ao lado de **ReadOnlyAccessAmazonS3**.
**nota**
Essa política concede as permissões `s3:Get*` e `s3:List*` a todos os buckets. As próximas etapas restringem o acesso à função usando a política de confiança.
O carregador requer apenas as permissões `s3:Get*` e `s3:List*` para o bucket a partir do qual você está realizando o carregamento, para que também possa restringir essas permissões pelo recurso do Amazon S3.
Se o bucket do S3 foi criptografado, você precisa adicionar permissões `kms:Decrypt`
1. Escolha **Próximo: revisar**.
1. Defina **Nome do perfil** como um nome para o perfil do IAM, por exemplo, `NeptuneLoadFromS3`. Você também pode adicionar um valor **Descrição do perfil**, como: "Permitir que o Neptune acesse os recursos do Amazon S3 em seu nome".
1. Selecione **Criar função**.
1. No painel de navegação, escolha **Perfis**.
1. No campo **Search (Pesquisar)**, digite o nome da função que você criou e selecione a função quando ela aparecer na lista.
1. Na guia **Trust Relationships (Relacionamentos confiáveis)**, selecione **Edit Trust Relationship (Editar relacionamento confiável)**.
1. No campo de texto, cole a política de confiança a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"rds.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Selecione **Atualizar política de confiança**.
1. Siga as etapas em [Adicionar o perfil do IAM a um cluster do Amazon Neptune](bulk-load-tutorial-IAM-add-role-cluster.md).
# Adicionar o perfil do IAM a um cluster do Amazon Neptune
Use o console para adicionar o perfil do IAM a um cluster do Amazon Neptune. Isso permite que qualquer instância de banco de dados do Neptune no cluster assuma o perfil e carregue do Amazon S3.
**nota**
O console do Amazon Neptune exige que o usuário tenha as seguintes permissões do IAM para associar o perfil ao cluster do Neptune:
```
iam:GetAccountSummary on resource: *
iam:ListAccountAliases on resource: *
iam:PassRole on resource: * with iam:PassedToService restricted to rds.amazonaws.com
```
**Como adicionar um perfil do IAM a um cluster do Amazon Neptune**
1. [Faça login no AWS Management Console e abra o console do Amazon Neptune em casa. https://console.aws.amazon.com/neptune/](https://console.aws.amazon.com/neptune/home)
1. No painel de navegação, escolha **Bancos de dados**.
1. Selecione o identificador de cluster que deseja modificar.
1. Selecione a guia **Conectividade e segurança**.
1. Na seção Perfis do IAM, selecione o perfil criado na seção anterior.
1. Escolha **Add role (adicionar função)**.
1. Aguarde até que o perfil do IAM se torne acessível para o cluster para usá-lo.
# Criar o endpoint da VPC do Amazon S3
O carregador do Neptune exige um endpoint da VPC do tipo Gateway para Amazon S3.
**Para configurar o acesso ao Amazon S3**
1. Faça login no Console de gerenciamento da AWS e abra o console da Amazon VPC em. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)
1. No painel de navegação, escolha **Endpoints**.
1. Escolha **Create Endpoint** (Criar endpoint).
1. Selecione o **Nome do serviço** `com.amazonaws.region.s3` para o endpoint do tipo Gateway.
**nota**
Se a região aqui estiver incorreta, verifique se a região do console está correta.
1. Selecione a VPC que contém a instância de banco de dados do Neptune (ela está listada para a instância de banco de dados no console do Neptune).
1. Marque a caixa de seleção ao lado das tabelas de rotas associadas às sub-redes relacionados ao cluster. Se tiver apenas uma tabela de rotas, você deverá selecionar essa caixa.
1. Escolha **Criar endpoint**.
Para obter informações sobre criação do endpoint, consulte [VPC Endpoints](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html#create-vpc-endpoint) no *Guia do usuário da Amazon VPC*. Para obter informações sobre as limitações dos endpoints da VPC, consulte [VPC Endpoints for Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html).
**Próximas etapas**
Agora que concedeu acesso ao bucket do Amazon S3, você pode se preparar para carregar os dados. Para obter informações sobre os formatos compatíveis, consulte [Formatos de dados de carga](bulk-load-tutorial-format.md).
# Encadear perfis do IAM no Amazon Neptune
**Importante**
O novo atributo de carregamento em massa entre contas introduzido na [versão 1.2.1.0.R3 do mecanismo](engine-releases-1.2.1.0.R3.md), que utiliza o encadeamento de perfis do IAM, pode, em alguns casos, causar degradação do desempenho de carregamento em massa. Como resultado, as atualizações das versões do mecanismo compatíveis com esse atributo foram temporariamente suspensas até que o problema seja resolvido.
Ao associar um perfil ao cluster, seu cluster poderá assumir esse perfil para obter acesso aos dados armazenados no Amazon S3. A partir da [versão 1.2.1.0.R3 do mecanismo](engine-releases-1.2.1.0.R3.md), se esse perfil não tiver acesso a todos os recursos necessários, você poderá encadear um ou mais perfis adicionais que o cluster poderá assumir para obter acesso a outros recursos. Cada perfil na cadeia assume o próximo perfil na cadeia, até que o cluster assuma o perfil no final da cadeia.
Para encadear perfis, você estabelece uma relação de confiança entre eles. Por exemplo, para encadear o `RoleB` com o `RoleA`, o `RoleA` precisa ter uma política de permissões que o possibilite assumir o `RoleB` e `RoleB` deve ter uma política de confiança que o permita transmitir as permissões de volta ao `RoleA`. Para obter mais informações, consulte [Using IAM roles](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html).
O primeiro perfil da cadeia deve ser associado ao cluster que está carregando dados.
O primeiro perfil e cada perfil subsequente que assumir o perfil seguinte na cadeia devem ter:
+ Uma política que inclua uma declaração específica com o efeito `Allow` na ação `sts:AssumeRole`.
+ O nome do recurso da Amazon (ARN) do próximo perfil em um elemento `Resource`.
**nota**
O bucket de destino do Amazon S3 deve estar na mesma AWS região do cluster.
## Acesso entre contas usando perfis encadeados
É possível conceder acesso entre contas encadeando um perfil ou perfis pertencentes a outra conta. Quando o cluster assume temporariamente um perfil pertencente a outra conta, ele pode obter acesso aos recursos dessa conta.
Por exemplo, suponha que a **Conta A** queira acessar dados em um bucket do Amazon S3 que pertença à **Conta B**:
+ A **conta A cria uma** função AWS de serviço para Neptune `RoleA` chamada e a anexa a um cluster.
+ A **Conta B** cria um perfil chamado `RoleB` que é autorizado a acessar os dados no bucket da **Conta B**.
+ A **Conta A** associa uma política de permissões ao `RoleA` que permite a ele assumir o `RoleB`.
+ A **Conta B** atribui uma política de confiança ao `RoleB` que permite a ele transmitir as permissões de volta ao `RoleA`.
+ Para acessar os dados no bucket da **Conta B**, a **Conta A** executa um comando do carregador usando um parâmetro `iamRoleArn` que encadeia `RoleA` e `RoleB`. Durante a operação do carregador, `RoleA` assume temporariamente `RoleB` para acessar o bucket do Amazon S3 na **Conta B**.
![\[Diagrama que ilustra o acesso entre contas usando perfis encadeados\]](http://docs.aws.amazon.com/pt_br/neptune/latest/userguide/images/cross-account-bulk-load.png)
Por exemplo, o `RoleA` teria uma política de confiança que estabelecesse uma relação de confiança com o Neptune:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
O `RoleA` também teria uma política de permissão que permitisse a ele assumir o `RoleB`, que é de propriedade da **Conta B**:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1487639602000",
"Effect": "Allow",
"Action": [
"sts:AssumeRole"
],
"Resource": "arn:aws:iam::111122223333:role/RoleB"
}
]
}
```
------
Por outro lado, o `RoleB` teria uma política de confiança para estabelecer uma relação de confiança com o `RoleA`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleA"
}
}
]
}
```
------
O `RoleB` também precisaria de permissão para acessar dados no bucket do Amazon S3 localizado na **Conta B**.
## Criação de um AWS Security Token Service endpoint VPC (STS)
O carregador Neptune exige um VPC AWS STS endpoint para quando você está encadeando funções do IAM para acesso privado por meio de endereços IP privados. AWS STS APIs Você pode se conectar diretamente de uma Amazon VPC a AWS STS um VPC Endpoint de forma segura e escalável. Quando você usa um endpoint da VPC de interface, ele fornece um melhor procedimento de segurança, pois você não precisa abrir firewalls de tráfego de saída. Ele também oferece os outros benefícios do uso de endpoints da Amazon VPC.
Ao usar um VPC Endpoint, o tráfego para AWS STS não é transmitido pela Internet e nunca sai da rede Amazon. Sua VPC está conectada com segurança, AWS STS sem riscos de disponibilidade ou restrições de largura de banda no tráfego da rede. Para obter mais informações, consulte [Using AWS STS interface VPC endpoints](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_sts_vpce.html).
**Para configurar o acesso para AWS Security Token Service (STS)**
1. Faça login no Console de gerenciamento da AWS e abra o console da Amazon VPC em. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)
1. No painel de navegação, escolha **Endpoints**.
1. Escolha **Create Endpoint** (Criar endpoint).
1. Selecione o **Nome do serviço** `com.amazonaws.region.sts` para o endpoint do tipo Interface.
1. Selecione a **VPC** que contém a instância de banco de dados do Neptune e a instância do EC2.
1. Marque a caixa de seleção ao lado da sub-rede na qual a instância do EC2 está presente. Não é possível selecionar várias sub-redes em uma mesma zona de disponibilidade.
1. Em IP address type (Tipo de endereço IP), escolha uma das seguintes opções:
+ **IPv4**— Atribua IPv4 endereços às interfaces de rede do seu terminal. Essa opção é suportada somente se todas as sub-redes selecionadas tiverem intervalos de IPv4 endereços.
+ **IPv6**— Atribua IPv6 endereços às interfaces de rede do seu terminal. Essa opção é suportada somente se todas as sub-redes selecionadas forem IPv6 sub-redes somente.
+ **Dualstack** — atribua IPv6 endereços IPv4 e endereços às suas interfaces de rede de endpoints. Essa opção é suportada somente se todas as sub-redes selecionadas tiverem intervalos de IPv6 endereços IPv4 e ambos.
1. Em **Grupos de segurança**, selecione os grupos de segurança para associar às interfaces de rede do endpoint para o endpoint da VPC. Você precisaria selecionar todos os grupos de segurança associados à instância de banco de dados do Neptune e à instância do EC2.
1. Em **Policy** (Política), selecione **Full access** (Acesso total) para permitir todas as operações de todas as entidades principais em todos os recursos no endpoint da VPC. Ou então selecione **Custom** (Personalizar) para anexar uma política de endpoint da VPC que controle as permissões das entidades principais para realizar ações em recursos sobre o endpoint da VPC. Essa opção ficará disponível somente se o serviço for compatível com as políticas de endpoint da VPC. Para obter mais informações, consulte [Endpoint policies](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html).
1. (*Opcional*) Para adicionar uma tag, escolha **Adicionar nova tag** e insira a chave e o valor da tag que você deseja.
1. Escolha **Criar endpoint**.
Para obter mais informações sobre criação de endpoints, consulte [VPC Endpoints](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) no Guia do usuário do Amazon VPC. Observe que o endpoint da VPC do Amazon STS é um pré-requisito obrigatório para o encadeamento de perfis do IAM.
Agora que você concedeu acesso ao AWS STS endpoint, pode se preparar para carregar os dados. Para obter informações sobre os formatos compatíveis, consulte [Formatos de dados de carga](bulk-load-tutorial-format.md).
## Encadear perfis em um comando de carregador
Você pode especificar o encadeamento de funções ao executar um comando do carregador incluindo uma lista de funções ARNs separada por vírgula no parâmetro. `iamRoleArn`
Embora na maioria das vezes você precise ter apenas dois perfis em uma cadeia, certamente é possível encadear três ou mais. Por exemplo, esse comando do carregador encadeia três perfis:
```
curl -X POST https://localhost:8182/loader \
-H 'Content-Type: application/json' \
-d '{
"source" : "s3://(the target bucket name)/(the target date file name)",
"iamRoleArn" : "arn:aws:iam::(Account A ID):role/(RoleA),arn:aws:iam::(Account B ID):role/(RoleB),arn:aws:iam::(Account C ID):role/(RoleC)",
"format" : "csv",
"region" : "us-east-1"
}'
```
# Formatos de dados de carga
A API `Load` do Amazon Neptune é compatível com o carregamento de dados em vários formatos.
**Formatos de carregamento de grafos de propriedades**
Os dados carregados em um dos seguintes formatos de grafo de propriedades podem então ser consultados usando o Gremlin e o openCypher:
+ [Formato de dados de carga do Gremlin](bulk-load-tutorial-format-gremlin.md) (`csv`): um formato de valores separados por vírgula (CSV).
+ [Formato de carregamento de dados openCypher](bulk-load-tutorial-format-opencypher.md) (`opencypher`): um formato de valores separados por vírgula (CSV).
**Formatos de carregamento RDF**
Para carregar dados do Resource Description Framework (RDF) que você pode consultar usando SPARQL, é possível utilizar um dos seguintes formatos padrão conforme especificado pelo World Wide Web Consortium (W3C):
+ N-Triples (`ntriples`) da especificação em [https://www.w3.org/TR/n-triples/](https://www.w3.org/TR/n-triples/).
+ N-Quads (`nquads`) da especificação em [https://www.w3.org/TR/n-quads/](https://www.w3.org/TR/n-quads/).
+ RDF/XML (`rdfxml`) da especificação em [https://www.w3.org/TR/rdf-syntax-grammar/](https://www.w3.org/TR/rdf-syntax-grammar/).
+ Turtle (`turtle`) da especificação em [https://www.w3.org/TR/turtle/](https://www.w3.org/TR/turtle/).
**Os dados de carregamento devem usar a codificação UTF-8**.
**Importante**
Todos os arquivos de dados de carga devem ser codificados em formato UTF-8. Se um arquivo não estiver codificado em UTF-8, o Neptune tentará carregá-lo de qualquer maneira como UTF-8.
Para dados N-Quads e N-triples que incluem caracteres Unicode, sequências de escape `\uxxxxx` são compatíveis. No entanto, o Neptune não é compatível com a normalização. Se houver um valor que exija normalização, ele não corresponderá byte-to-byte durante a consulta. Para obter mais informações sobre normalização, consulte a página [Normalização](https://unicode.org/faq/normalization.html) em [Unicode.org](https://unicode.org).
Se os dados não estiverem em um formato compatível, você deverá convertê-los antes de carregá-los.
[Uma ferramenta para converter o GraphML para o formato CSV do Neptune está disponível no projeto Graph CSV em. ML2 [GitHub](https://github.com/)](https://github.com/awslabs/amazon-neptune-tools/blob/master/graphml2csv/README.md)
## Suporte à compactação de arquivos de dados de carregamento
O Neptune é compatível com a compactação de arquivos individuais no formato `gzip` ou `bzip2`.
O arquivo compactado deve ter a extensão `.gz` ou `.bz2` e deve ser um único arquivo de texto codificado no formato UTF-8. É possível carregar vários arquivos, mas cada um deve estar em um `.gz`, um `.bz2` ou um texto não compactado separado. Arquivos com extensões, como `.tar`, `.tar.gz` e `.tgz` são compatíveis.
As seções a seguir descrevem os formatos em mais detalhes.
**Topics**
+ [Suporte à compactação de arquivos de dados de carregamento](#bulk-load-tutorial-format-compression)
+ [Formato de dados de carga do Gremlin](bulk-load-tutorial-format-gremlin.md)
+ [Formato de carregamento para dados do openCypher](bulk-load-tutorial-format-opencypher.md)
+ [Formatos de dados de carga do RDF](bulk-load-tutorial-format-rdf.md)
# Formato de dados de carga do Gremlin
Para carregar dados do Apache TinkerPop Gremlin usando o formato CSV, você deve especificar os vértices e as bordas em arquivos separados.
O carregador pode carregar vários arquivos de vértice e vários arquivos de ponto em um único trabalho de carga.
Para cada comando de carga, o conjunto de arquivos a serem carregados deve estar na mesma pasta no bucket do Amazon S3 e você deve especificar o nome da pasta para o parâmetro `source`. Os nomes dos arquivos e as extensões dos nomes dos arquivos não são importantes.
O formato CSV do Amazon Neptune segue a especificação RFC 4180 CSV. Para obter mais informações consulte [Formato comum e tipo MIME para arquivos CSV](https://tools.ietf.org/html/rfc4180) no site do Internet Engineering Task Force (IETF).
**nota**
Todos os arquivos devem ser codificados em formato UTF-8.
Cada arquivo tem uma linha de cabeçalho separada por vírgula. A linha de cabeçalho consiste nos cabeçalhos da coluna do sistema e nos cabeçalhos da coluna de propriedade.
## Cabeçalhos de colunas do sistema
Os cabeçalhos da coluna do sistema exigidos e permitidos são diferentes para arquivos de vértice e arquivos de ponto.
Cada coluna do sistema pode aparecer apenas uma vez em um cabeçalho.
Todos os rótulos diferenciam maiúsculas de minúsculas.
**Cabeçalhos de vértice**
+ `~id`- **Obrigatório**
Um ID para o vértice.
+ `~label`
Um rótulo para o vértice. Vários valores de rótulo são permitidos, separados por ponto e vírgula (`;`).
Se não `~label` estiver presente, TinkerPop fornece um rótulo com o valor`vertex`, porque cada vértice deve ter pelo menos um rótulo.
**Cabeçalhos de ponto**
+ `~id`- **Obrigatório**
Um ID para o ponto.
+ `~from`- **Obrigatório**
O ID do vértice do vértice *de*.
+ `~to`- **Obrigatório**
O ID do vértice do vértice *para*.
+ `~label`
Um rótulo para o ponto. Os pontos podem ter apenas um único rótulo.
Se não `~label` estiver presente, TinkerPop fornece uma etiqueta com o valor`edge`, pois cada borda deve ter uma etiqueta.
## Cabeçalhos de coluna de propriedade
É possível especificar uma coluna (`:`) para uma propriedade usando a sintaxe a seguir. Os nomes dos tipos não diferenciam maiúsculas de minúsculas. No entanto, observe que, se houver o caractere de dois pontos no nome de uma propriedade, ele deverá ser precedido por uma barra invertida como caractere de escape: `\:`
```
propertyname:type
```
**nota**
Espaços, vírgulas, caracteres de retorno e de nova linha não são permitidos nos cabeçalhos de coluna, portanto, os nomes de propriedades não podem incluir esses caracteres.
Você pode especificar uma coluna para um tipo de matriz adicionando `[]` para o tipo:
```
propertyname:type[]
```
**nota**
As propriedades de borda podem ter apenas um único valor e causarão um erro se um tipo de matriz é especificado ou um segundo valor é especificado.
O exemplo a seguir mostra o cabeçalho da coluna de uma propriedade denominada `age` do tipo `Int`.
```
age:Int
```
Cada linha no arquivo precisa ter um número inteiro nessa posição ou ser deixada em branco.
Matrizes de strings são permitidas, mas as strings em uma matriz não podem incluir o caractere ponto e vírgula (`;`), a menos que ele tenha uma barra invertida como caractere de escape (como este: `\;`).
**Especificar a cardinalidade de uma coluna**
O cabeçalho de coluna pode ser usado para especificar a *cardinalidade* da propriedade identificada pela coluna. Isso permite que o carregador em massa use a cardinalidade de forma semelhante à forma como as consultas do Gremlin fazem.
Você especifica a cardinalidade de uma coluna da seguinte forma:
```
propertyname:type(cardinality)
```
O valor de *cardinality* pode ser `single` ou `set`. O padrão é `set`, o que significa que a coluna pode aceitar vários valores. No caso de arquivos de ponto, a cardinalidade é sempre única e especificar qualquer outra cardinalidade faz com que o carregador gere uma exceção.
Se a cardinalidade for `single`, o carregador lançará um erro se um valor anterior já estiver presente quando um valor for carregado, ou se vários valores forem carregados. Esse comportamento pode ser substituído para que um valor existente seja substituído quando um novo valor é carregado usando o sinalizador `updateSingleCardinalityProperties`. Consulte [Comando Loader](load-api-reference-load.md).
É possível usar uma configuração de cardinalidade com um tipo de matriz, embora isso não seja geralmente necessário. Estas são as combinações possíveis:
+ `name:type`: a cardinalidade é `set`, e o conteúdo é um único valor.
+ `name:type[]`: a cardinalidade é `set`, e o conteúdo são vários valores.
+ `name:type(single)`: a cardinalidade é `single`, e o conteúdo é um único valor.
+ `name:type(set)`: a cardinalidade é `set`, equivalente ao padrão, e o conteúdo é um único valor.
+ `name:type(set)[]`: a cardinalidade é `set`, e o conteúdo são vários valores.
+ `name:type(single)[]`: isso é contraditório e gera um erro.
A seção a seguir lista todos os tipos de dados do Gremlin disponíveis.
## Tipos de dados do Gremlin
Esta é uma lista dos tipos de propriedade permitidos, com uma descrição de cada tipo.
**Bool (ou booliano)**
Indica um campo booliano. Valores permitidos: `false`, `true`
**nota**
Qualquer valor diferente de `true` será tratado como falso.
**Tipos de número inteiro**
Os valores fora dos intervalos definidos resultam em um erro.
|
|
| Tipo | Intervalo |
| --- |--- |
| Byte | -128 a 127 |
| Short | -32768 a 32767 |
| Int | -2^31 a 2^31-1 |
| Long | -2^63 a 2^63-1 |
**Tipos de número decimal**
Compatíveis com a notação decimal ou com a notação científica. Também permite símbolos, como (\$1/-) Infinity ou NaN. INF não é compatível.
|
|
| Tipo | Intervalo |
| --- |--- |
| Float | Ponto flutuante de 32 bits IEEE 754 |
| Duplo | Ponto flutuante de 64 bits IEEE 754 |
Valores flutuantes e duplos que são muito longos são carregados e arredondados para a precisão do valor mais próximo de 24 bits (flutuante) e 53 bits (duplo). Um valor intermediário é arredondado para zero para os últimos dígitos restantes no nível de bits.
**String**
Aspas são opcionais. Os caracteres de vírgulas, nova linha e retorno de carro serão escapados automaticamente se forem incluídos em uma sequência entre aspas duplas (`"`). *Exemplo*: `"Hello, World"`
Para incluir aspas em uma string entre aspas, você pode efetuar o escape as aspas usando duas em seguida: *Exemplo:* `"Hello ""World"""`
Matrizes de strings são permitidas, mas as strings em uma matriz não podem incluir o caractere ponto e vírgula (`;`), a menos que ele tenha uma barra invertida como caractere de escape (como este: `\;`).
Se desejar usar sequências entre aspas em uma matriz, você deverá colocar a matriz inteira entre um conjunto de aspas. *Exemplo*: `"String one; String 2; String 3"`
**Data**
Data do Java no formato ISO-8601. Suporta os seguintes formatos:`yyyy-MM-dd`,`yyyy-MM-ddTHH:mm`,`yyyy-MM-ddTHH:mm:ss`,`yyyy-MM-ddTHH:mm:ssZ`. Os valores são convertidos em horário de época e armazenados.
**Datetime**
Data do Java no formato ISO-8601. Suporta os seguintes formatos:`yyyy-MM-dd`,`yyyy-MM-ddTHH:mm`,`yyyy-MM-ddTHH:mm:ss`,`yyyy-MM-ddTHH:mm:ssZ`. Os valores são convertidos em horário de época e armazenados.
## Formato de linhas do Gremlin
**Delimitadores**
Os campos em uma linha são separados por uma vírgula. Os registros são separados por uma nova linha ou por uma nova linha seguida por um retorno de carro.
**Campos em branco**
Os campos em branco são permitidos para colunas não necessárias (como as propriedades definidas pelo usuário). Um campo em branco ainda exige uma vírgula separadora. Campos em branco nas colunas obrigatórias resultarão em erro de análise. Valores de string vazios são interpretados como valores de string vazios para o campo, não como um campo em branco. O exemplo na próxima seção tem um campo em branco em cada vértice de exemplo.
**Vértice IDs**
Os valores de `~id` devem ser exclusivos para todos os vértices em cada arquivo de vértice. Várias linhas de vértices com valores idênticos de `~id` são aplicadas a um único vértice no gráfico. Uma string vazia (`""`) é uma identificação válida e o vértice é criado com uma string vazia como a identificação.
**Borda IDs**
Além disso, os valores de `~id` devem ser exclusivos para todos os pontos em cada arquivo de ponto. Várias linhas de pontos com valores idênticos de `~id` são aplicadas ao único ponto no gráfico. Uma string vazia (`""`) é uma identificação válida e a borda é criada com uma string vazia como a identificação.
**Rótulos**
Os rótulos diferenciam maiúsculas e minúsculas e não podem ser vazios. Um valor de `""` resultará em erro.
**Valores de sequências**
Aspas são opcionais. Os caracteres de vírgulas, nova linha e retorno de carro serão escapados automaticamente se forem incluídos em uma sequência entre aspas duplas (`"`). Valores de string vazios, como `("")`, são interpretados como valores de string vazios para o campo, não como um campo em branco.
## Especificação do formato CSV
O formato CSV do Neptune segue a especificação RFC 4180 CSV, incluindo os requisitos a seguir.
+ Os finais de linha no estilo do Unix e do Windows são compatíveis (\$1n ou \$1r\$1n).
+ Qualquer campo pode ser colocado entre aspas (usando aspas duplas).
+ Campos que contêm uma quebra de linha, aspas duplas ou vírgulas devem ser colocados entre aspas. (Se não estiverem, o carregamento será abortado imediatamente.)
+ Um caractere de aspas duplas (`"`) em um campo deve ser representado por dois caracteres de aspas duplas. Por exemplo, uma sequência `Hello "World"` deve estar presente como `"Hello ""World"""` nos dados.
+ Espaços circundantes entre delimitadores são ignorados. Se uma linha estiver presente como `value1, value2`, são armazenados como `"value1"` e `"value2"`.
+ Todos os outros caracteres de escape são armazenados textualmente. Por exemplo, `"data1\tdata2"` é armazenado como `"data1\tdata2"`. Nenhum outro escape é necessário, desde que esses caracteres sejam incluídos entre aspas.
+ Campos em branco são permitidos. Um campo em branco é considerado um valor vazio.
+ Vários valores para um campo são especificados com um ponto e vírgula (`;`) entre os valores.
Para obter mais informações consulte [Formato comum e tipo MIME para arquivos CSV](https://tools.ietf.org/html/rfc4180) no site do Internet Engineering Task Force (IETF).
## Exemplo do Gremlin
O diagrama a seguir mostra um exemplo de dois vértices e uma aresta retirados do gráfico TinkerPop moderno.
![\[Diagrama que descreve dois vértices e um ponto, contém marko com 29 anos e o software lop com a linguagem: java.\]](http://docs.aws.amazon.com/pt_br/neptune/latest/userguide/images/tiny-modern-graph.png)
Veja o grafo no formato de carga do CSV do Neptune.
Arquivo de vértice:
```
~id,name:String,age:Int,lang:String,interests:String[],~label
v1,"marko",29,,"sailing;graphs",person
v2,"lop",,"java",,software
```
Visualização tabular do arquivo de vértice:
| | | | | | |
| --- |--- |--- |--- |--- |--- |
| \$1id | name:String | age:Int | lang:String | Interesses: string [] | \$1label |
| v1 | "marko" | 29 | | ["navegação”, “gráficos"] | pessoa |
| v2 | "lop" | | "java" | | software |
Arquivo de ponto
```
~id,~from,~to,~label,weight:Double
e1,v1,v2,created,0.4
```
Visualização tabular do arquivo de ponto:
| | | | | |
| --- |--- |--- |--- |--- |
| \$1id | \$1from | \$1to | \$1label | weight:Double |
| e1 | v1 | v2 | created | 0.4 |
**Próximas etapas**
Agora que você sabe mais sobre os formatos de carregamento, consulte [Exemplo: carregamento de dados em uma instância de banco de dados do Neptune](bulk-load-data.md).
# Formato de carregamento para dados do openCypher
Para carregar dados do openCypher usando o formato CSV do openCypher, é necessário especificar nós e relacionamentos em arquivos separados. O carregador pode carregar vários desses arquivos de nós e arquivos de relacionamento em um único trabalho de carregamento.
Para cada comando de carregamento, o conjunto de arquivos a serem carregados deve ter o mesmo prefixo de caminho em um bucket do Amazon Simple Storage Service. Você especifica esse prefixo no parâmetro de origem. Os nomes e as extensões dos arquivos não são importantes.
No Amazon Neptune, o formato CSV do openCypher está em conformidade com a especificação CSV RFC 4180. Para obter mais informações, consulte [Formato comum e tipo MIME para arquivos CSV](https://tools.ietf.org/html/rfc4180) (https://tools.ietf.org/html/rfc4180) no site da Internet Engineering Task Force (IETF).
**nota**
Esses arquivos DEVEM ser codificados em formato UTF-8.
Cada arquivo tem uma linha de cabeçalhos separados por vírgula que contém cabeçalhos de coluna do sistema e cabeçalhos de coluna de propriedades.
## Cabeçalhos de coluna do sistema em arquivos de carregamento de dados do openCypher
Uma coluna do sistema específica pode aparecer apenas uma vez em cada arquivo. Todos os rótulos de cabeçalho de coluna do sistema diferenciam maiúsculas de minúsculas.
Os cabeçalhos de coluna do sistema obrigatórios e permitidos são diferentes para arquivos de carregamento de nós e arquivos de carregamento de relacionamento do openCypher:
### Cabeçalhos de coluna do sistema em arquivos de nós
+ **`:ID`**: (obrigatório) um ID para o nó.
Um espaço de ID opcional pode ser adicionado ao cabeçalho de coluna `:ID` de nó como este: `:ID(ID Space)`. Um exemplo é `:ID(movies)`.
Ao carregar relacionamentos que conectam os nós nesse arquivo, use os mesmos espaços de ID nas `:START_ID` and/or `:END_ID` colunas dos arquivos de relacionamento.
Também é possível armazenar a coluna `:ID` do nó como uma propriedade no formulário, `property name:ID`. Um exemplo é `name:ID`.
O nó IDs deve ser exclusivo em todos os arquivos do nó nas cargas atuais e anteriores. Se um espaço de ID for usado, o nó IDs deverá ser exclusivo em todos os arquivos do nó que usam o mesmo espaço de ID nos carregamentos atuais e anteriores.
+ **`:LABEL`**: um rótulo para o nó.
Ao usar vários valores de rótulo para um único nó, cada rótulo deve ser separado por ponto e vírgula (`;`).
### Cabeçalhos de coluna do sistema em arquivos de relacionamento
+ **`:ID`**: um ID para o relacionamento. Isso é necessário quando `userProvidedEdgeIds` é verdadeiro (o padrão), mas inválido quando `userProvidedEdgeIds` é `false`.
O relacionamento IDs deve ser exclusivo em todos os arquivos de relacionamento nas cargas atuais e anteriores.
+ **`:START_ID`**: (*obrigatório*) o ID do nó no qual esse relacionamento começa.
Opcionalmente, um espaço de ID pode ser associado à coluna de ID inicial no formato `:START_ID(ID Space)`. O espaço de ID atribuído ao ID do nó inicial deve corresponder ao espaço de ID atribuído ao nó no arquivo de nós.
+ **`:END_ID`**: (*obrigatório*) o ID do nó no qual esse relacionamento termina.
Opcionalmente, um espaço de ID pode ser associado à coluna de ID final no formato `:END_ID(ID Space)`. O espaço de ID atribuído ao ID do nó final deve corresponder ao espaço de ID atribuído ao nó no arquivo de nós.
+ **`:TYPE`**: um tipo para o relacionamento. Os relacionamentos só podem ter um único tipo.
**nota**
Consulte [Carregar dados do openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher) para obter informações sobre como o nó ou o relacionamento IDs duplicados são tratados pelo processo de carregamento em massa.
### Cabeçalhos de coluna de propriedades em arquivos de carregamento de dados do openCypher
É possível especificar que uma coluna contenha os valores de uma propriedade específica usando um cabeçalho de coluna de propriedade no seguinte formato:
```
propertyname:type
```
Espaços, vírgulas, caracteres de retorno e de nova linha não são permitidos nos cabeçalhos de coluna, portanto, os nomes de propriedades não podem incluir esses caracteres. Veja um exemplo de cabeçalho de coluna para uma propriedade chamada `age` do tipo `Int`:
```
age:Int
```
A coluna com `age:Int` como cabeçalho de coluna teria então que conter um valor inteiro ou vazio em cada linha.
## Tipos de dados nos arquivos de carregamento de dados do openCypher do Neptune
+ **`Bool`** ou **`Boolean`**: um campo booliano. Os valores permitidos são `true` e `false`.
Qualquer valor diferente de `true` é tratado como `false`.
+ **`Byte`**: um número inteiro no intervalo de `-128` a `127`.
+ **`Short`**: um número inteiro no intervalo de `-32,768` a `32,767`.
+ **`Int`**: um número inteiro no intervalo de `-2^31` a `2^31 - 1`.
+ **`Long`**: um número inteiro no intervalo de `-2^63` a `2^63 - 1`.
+ **`Float`**: um número de ponto flutuante IEEE 754 de 32 bits. Tanto a notação decimal quanto a notação científica são aceitas. `Infinity`, `-Infinity` e `NaN` são todos reconhecidos, mas `INF` não.
Valores com muitos dígitos para caberem são arredondados para o valor mais próximo (um valor intermediário é arredondado para 0 para o último dígito restante no nível de bit).
+ **`Double`**: um número de ponto flutuante IEEE 754 de 64 bits. Tanto a notação decimal quanto a notação científica são aceitas. `Infinity`, `-Infinity` e `NaN` são todos reconhecidos, mas `INF` não.
Valores com muitos dígitos para caberem são arredondados para o valor mais próximo (um valor intermediário é arredondado para 0 para o último dígito restante no nível de bit).
+ **`String`**: aspas são opcionais. Os caracteres de vírgulas, nova linha e retorno de carro receberão escape automaticamente se forem incluídos em uma string entre aspas duplas (`"`) como `"Hello, World"`.
Você pode incluir aspas em uma string entre aspas usando duas em uma linha, como `"Hello ""World"""`.
+ **`DateTime`**: uma data Java em um dos seguintes formatos ISO-8601:
+ `yyyy-MM-dd`
+ `yyyy-MM-ddTHH:mm`
+ `yyyy-MM-ddTHH:mm:ss`
+ `yyyy-MM-ddTHH:mm:ssZ`
### Tipos de dados de transmissão automática nos arquivos de carregamento de dados do openCypher do Neptune
Os tipos de dados de transmissão automática são fornecidos para carregar tipos de dados não aceitos nativamente pelo Neptune no momento. Os dados nessas colunas são armazenados como strings, literalmente, sem verificação em relação aos formatos pretendidos. Os seguintes tipos de dados de transmissão automática são permitidos:
+ **`Char`**: um campo `Char`. Armazenado como uma string.
+ **`Date`**, **`LocalDate`** e **`LocalDateTime`**: consulte [Neo4j Temporal Instants](https://neo4j.com/docs/cypher-manual/current/values-and-types/temporal/#cypher-temporal-instants) para ver uma descrição dos tipos `date`, `localdate` e `localdatetime`. Os valores são carregados literalmente como strings, sem validação.
+ **`Duration`**: consulte [Neo4j Duration format](https://neo4j.com/docs/cypher-manual/current/values-and-types/temporal/#cypher-temporal-durations). Os valores são carregados literalmente como strings, sem validação.
+ **Ponto**: um campo de pontos, para armazenar dados espaciais. Consulte [Spatial instants](https://neo4j.com/docs/cypher-manual/current/values-and-types/spatial/#spatial-values-spatial-instants). Os valores são carregados literalmente como strings, sem validação.
## Exemplo do formato de carregamento do openCypher
O diagrama a seguir, retirado do gráfico TinkerPop moderno, mostra um exemplo de dois nós e uma relação:
![\[Diagrama de dois nós e um relacionamento entre eles.\]](http://docs.aws.amazon.com/pt_br/neptune/latest/userguide/images/tinkerpop-2-nodes-and-relationship.png)
Veja o grafo no formato de carregamento normal do openCypher no Neptune.
**Arquivo de nós:**
```
:ID,name:String,age:Int,lang:String,:LABEL
v1,"marko",29,,person
v2,"lop",,"java",software
```
**Arquivo de relacionamento:**
```
:ID,:START_ID,:END_ID,:TYPE,weight:Double
e1,v1,v2,created,0.4
```
Como alternativa, você pode usar espaços de ID e ID como uma propriedade, da seguinte maneira:
**Primeiro arquivo de nós:**
```
name:ID(person),age:Int,lang:String,:LABEL
"marko",29,,person
```
**Segundo arquivo de nós:**
```
name:ID(software),age:Int,lang:String,:LABEL
"lop",,"java",software
```
**Arquivo de relacionamento:**
```
:ID,:START_ID(person),:END_ID(software),:TYPE,weight:Double
e1,"marko","lop",created,0.4
```
# Formatos de dados de carga do RDF
Para carregar dados do Resource Description Framework (RDF), você pode usar um dos seguintes formatos padrão conforme especificado pelo World Wide Web Consortium (W3C):
+ N-Triples (`ntriples`) da especificação em [https://www.w3.org/TR/n-triples/](https://www.w3.org/TR/n-triples/)
+ N-Quads (`nquads`) da especificação em [https://www.w3.org/TR/n-quads/](https://www.w3.org/TR/n-quads/)
+ RDF/XML (`rdfxml`) da especificação em [https://www.w3.org/TR/rdf-syntax-grammar/](https://www.w3.org/TR/rdf-syntax-grammar/)
+ Turtle (`turtle`) da especificação em [https://www.w3.org/TR/turtle/](https://www.w3.org/TR/turtle/)
**Importante**
Todos os arquivos devem ser codificados em formato UTF-8.
Para dados N-Quads e N-triples que incluem caracteres Unicode, sequências de escape `\uxxxxx` são compatíveis. No entanto, o Neptune não é compatível com a normalização. Se houver um valor que exija normalização, ele não corresponderá byte-to-byte durante a consulta. Para obter mais informações sobre normalização, consulte a página [Normalização](https://unicode.org/faq/normalization.html) em [Unicode.org](https://unicode.org).
**Próximas etapas**
Agora que você sabe mais sobre os formatos de carregamento, consulte [Exemplo: carregamento de dados em uma instância de banco de dados do Neptune](bulk-load-data.md).
# Exemplo: carregamento de dados em uma instância de banco de dados do Neptune
Este exemplo mostra como carregar dados no Amazon Neptune. Salvo indicação em contrário, você deve seguir essas etapas em uma instância do Amazon Elastic Compute Cloud (Amazon EC2) na mesma Amazon Virtual Private Cloud (VPC) que a instância do banco de dados Neptune.
## Pré-requisitos para o exemplo de carregamento de dados
Antes de começar, você deve ter o seguinte:
+ Uma instância de banco de dados do Neptune.
Para obter informações sobre como iniciar uma instância de banco de dados do Neptune, consulte [Criar um cluster do Amazon Neptune](get-started-create-cluster.md).
+ Um bucket do Amazon Simple Storage Service (Amazon S3) no qual colocar os arquivos de dados.
Você pode usar um bucket existente. Se você não tiver um bucket do S3, consulte [Create a Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) no *[Guia de conceitos básicos do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)*.
+ Dados do grafo a serem carregados, em um dos formatos compatíveis com o carregador do Neptune:
Se você estiver usando o Gremlin para consultar seu gráfico, o Neptune poderá carregar dados no formato comma-separated-values (`CSV`), conforme descrito em. [Formato de dados de carga do Gremlin](bulk-load-tutorial-format-gremlin.md)
Se você estiver usando o openCypher para consultar o grafo, o Neptune também poderá carregar dados em um formato `CSV`específico do openCypher, conforme descrito em [Formato de carregamento para dados do openCypher](bulk-load-tutorial-format-opencypher.md).
Se você estiver usando o SPARQL, o Neptune poderá carregar dados em vários formatos do RDF, conforme descrito em [Formatos de dados de carga do RDF](bulk-load-tutorial-format-rdf.md).
+ Um perfil do IAM para a instância de banco de dados do Neptune assumir que tem uma política do IAM que permite acesso aos arquivos de dados no bucket do S3. A política deve conceder permissões de leitura e lista.
Para obter informações sobre como criar um perfil que tenha acesso ao Amazon S3 e associá-lo a um cluster do Neptune, consulte [Pré-requisitos: perfil do IAM e acesso ao Amazon S3](bulk-load-tutorial-IAM.md).
**nota**
A API `Load` do Neptune precisa de acesso de leitura apenas aos arquivos de dados. A política do IAM não precisa permitir acesso de gravação nem acesso a todo o bucket.
+ Um endpoint da VPC do Amazon S3. Para obter mais informações, consulte a seção [Criar o endpoint da VPC do Amazon S3](#bulk-load-prereqs-s3).
### Criar o endpoint da VPC do Amazon S3
O carregador do Neptune requer um endpoint da VPC para Amazon S3.
**Para configurar o acesso ao Amazon S3**
1. Faça login no Console de gerenciamento da AWS e abra o console da Amazon VPC em. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)
1. No painel de navegação à esquerda, escolha **Endpoints**.
1. Escolha **Criar endpoint**.
1. Selecione o **Service Name (Nome do serviço)** `com.amazonaws.region.s3`.
**nota**
Se a região aqui estiver incorreta, verifique se a região do console está correta.
1. Selecione a VPC que contém a instância de banco de dados do Neptune.
1. Marque a caixa de seleção ao lado das tabelas de rotas associadas às sub-redes relacionados ao cluster. Se tiver apenas uma tabela de rotas, você deverá selecionar essa caixa.
1. Escolha **Criar endpoint**.
Para obter informações sobre criação do endpoint, consulte [VPC Endpoints](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html#create-vpc-endpoint) no *Guia do usuário da Amazon VPC*. Para obter informações sobre as limitações dos endpoints da VPC, consulte [VPC Endpoints for Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html).
**Como carregar dados em uma instância de banco de dados do Neptune**
1. Copie os arquivos de dados em um bucket do Amazon S3. O bucket do S3 deve estar na mesma AWS região do cluster que carrega os dados.
Você pode usar o AWS CLI comando a seguir para copiar os arquivos para o bucket.
**nota**
Esse comando não precisa ser executado na instância do Amazon EC2.
```
aws s3 cp data-file-name s3://bucket-name/object-key-name
```
**nota**
No Amazon S3, um **nome de chave de objeto** é o caminho inteiro de um arquivo, inclusive o nome do arquivo.
*Exemplo:* no comando `aws s3 cp datafile.txt s3://examplebucket/mydirectory/datafile.txt`, o nome da chave do objeto é **`mydirectory/datafile.txt`**.
Como alternativa, você pode usar o Console de gerenciamento da AWS para fazer upload de arquivos para o bucket do S3. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)e escolha um bucket. No canto superior esquerdo, selecione **Upload (Fazer upload)** para fazer upload dos arquivos.
1. Em uma janela de linha de comando, insira o seguinte para executar o carregador do Neptune, usando os valores corretos para o endpoint, o caminho do Amazon S3, o formato e o ARN do perfil do IAM.
O parâmetro `format` pode ser qualquer um dos seguintes valores: `csv` para Gremlin, `opencypher` para openCypher ou `ntriples`, `nquads`, `turtle` e `rdfxml` para RDF. Para obter informações sobre outros parâmetros, consulte [Comando do carregador do Neptune](load-api-reference-load.md).
Para obter informações sobre como localizar o nome do host da instância de banco de dados do Neptune, consulte a seção [Conectar-se a endpoints do Amazon Neptune](feature-overview-endpoints.md).
O parâmetro da região deve corresponder à região do cluster e do bucket do S3.
O Amazon Neptune está disponível nas seguintes regiões: AWS
+ Leste dos EUA (Norte da Virgínia): `us-east-1`
+ Leste dos EUA (Ohio): `us-east-2`
+ Oeste dos EUA (N. da Califórnia): `us-west-1`
+ Oeste dos EUA (Oregon): `us-west-2`
+ Canadá (Central): `ca-central-1`
+ Oeste do Canadá (Calgary): `ca-west-1`
+ América do Sul (São Paulo): `sa-east-1`
+ Europa (Estocolmo): `eu-north-1`
+ Europa (Espanha): `eu-south-2`
+ Europa (Irlanda): `eu-west-1`
+ Europa (Londres): `eu-west-2`
+ Europa (Paris): `eu-west-3`
+ Europa (Frankfurt): `eu-central-1`
+ Oriente Médio (Bahrein): `me-south-1`
+ Oriente Médio (Emirados Árabes Unidos): `me-central-1`
+ Israel (Tel Aviv): `il-central-1`
+ África (Cidade do Cabo): `af-south-1`
+ Ásia-Pacífico (Hong Kong): `ap-east-1`
+ Ásia-Pacífico (Tóquio): `ap-northeast-1`
+ Ásia-Pacífico (Seul): `ap-northeast-2`
+ Ásia-Pacífico (Osaka): `ap-northeast-3`
+ Ásia-Pacífico (Singapura): `ap-southeast-1`
+ Ásia-Pacífico (Sydney): `ap-southeast-2`
+ Ásia-Pacífico (Jacarta): `ap-southeast-3`
+ Ásia-Pacífico (Melbourne): `ap-southeast-4`
+ Ásia-Pacífico (Malásia): `ap-southeast-5`
+ Ásia-Pacífico (Mumbai): `ap-south-1`
+ Ásia-Pacífico (Hyderabad): `ap-south-2`
+ China (Pequim): `cn-north-1`
+ China (Ningxia): `cn-northwest-1`
+ AWS GovCloud (Oeste dos EUA): `us-gov-west-1`
+ AWS GovCloud (Leste dos EUA): `us-gov-east-1`
```
curl -X POST \
-H 'Content-Type: application/json' \
https://your-neptune-endpoint:port/loader -d '
{
"source" : "s3://bucket-name/object-key-name",
"format" : "format",
"iamRoleArn" : "arn:aws:iam::account-id:role/role-name",
"region" : "region",
"failOnError" : "FALSE",
"parallelism" : "MEDIUM",
"updateSingleCardinalityProperties" : "FALSE",
"queueRequest" : "TRUE",
"dependencies" : ["load_A_id", "load_B_id"]
}'
```
Para obter informações sobre como criar e associar um perfil do IAM a um cluster do Neptune, consulte [Pré-requisitos: perfil do IAM e acesso ao Amazon S3](bulk-load-tutorial-IAM.md).
**nota**
Consulte [Parâmetros de solicitação do carregador do Neptune](load-api-reference-load.md#load-api-reference-load-parameters)) para obter informações detalhadas sobre parâmetros de solicitação de carga. Resumindo:
O parâmetro `source` aceita um URI do Amazon S3 que aponte para um único arquivo ou para uma pasta. Se você especificar uma pasta, o Neptune fará upload de cada arquivo de dados na pasta.
A pasta pode conter vários arquivos de vértice e vários arquivos de ponto.
O URI pode estar em qualquer um dos seguintes formatos.
`s3://bucket_name/object-key-name`
`https://s3.amazonaws.com/bucket_name/object-key-name`
`https://s3-us-east-1.amazonaws.com/bucket_name/object-key-name`
O parâmetro `format` pode ser:
Formato CSV do Gremlin (`csv`) para propriedade de grafo do Gremlin
Formato CSV do openCypher (`opencypher`) para grafos de propriedades do openCypher
N-Triples (`ntriples`) formato para RDF/SPARQL
N-Quads (`nquads`) formato para RDF/SPARQL
RDF/XML (`rdfxml`) formato para RDF/SPARQL
Turtle (`turtle`) formato para RDF / SPARQL
O parâmetro opcional `parallelism` permite que você restrinja o número de threads usados no processo de carregamento em massa. Ele pode ser definido como `LOW`, `MEDIUM`, `HIGH`, or `OVERSUBSCRIBE`.
Quando `updateSingleCardinalityProperties` estiver definido como `"FALSE"`, o carregador retornará um erro se mais de um valor for fornecido em um arquivo de origem sendo carregado para uma propriedade de vértice de borda ou de cardinalidade única.
Configurar o `queueRequest` para o `"TRUE"` faz com que a solicitação de carga seja colocada em uma fila na qual já existe um trabalho de carga em execução.
O parâmetro `dependencies` torna a execução da solicitação de carga dependente da conclusão com êxito de um ou mais trabalhos de carga que já foram colocados na fila.
1. O carregador do Neptune retorna um trabalho `id` que permite que você confira o status ou cancele o processo de carregamento, por exemplo:
```
{
"status" : "200 OK",
"payload" : {
"loadId" : "ef478d76-d9da-4d94-8ff1-08d9d4863aa5"
}
}
```
1. Digite o seguinte para obter o status da carga com o `loadId` da **Etapa 3**:
```
curl -G 'https://your-neptune-endpoint:port/loader/ef478d76-d9da-4d94-8ff1-08d9d4863aa5'
```
Se o status da carga listar um erro, você poderá solicitar um status mais detalhado e uma lista dos erros. Para ter mais informações e exemplos, consulte [API do Neptune Loader Get-Status](load-api-reference-status.md).
1. (Opcional) Cancele o trabalho de `Load`.
Digite o seguinte para `Delete` o trabalho do carregador com o `id` de trabalho da **Etapa 3**:
```
curl -X DELETE 'https://your-neptune-endpoint:port/loader/ef478d76-d9da-4d94-8ff1-08d9d4863aa5'
```
O comando `DELETE` retorna o código HTTP `200 OK` após o cancelamento bem-sucedido.
Os dados dos arquivos do trabalho de carga que concluíram o carregamento não são revertidos. Os dados permanecem na instância de banco de dados do Neptune.
# Otimizar uma carga em massa do Amazon Neptune
Use as seguintes estratégias para reduzir ao mínimo o tempo de carregamento de uma carga em massa do Neptune:
+ **Limpe os dados:**
+ Converta os dados em um [formato de dados compatível](bulk-load-tutorial-format.md) antes de carregá-los.
+ Remova todas as duplicações ou erros conhecidos.
+ Reduza o número de predicados exclusivos (como propriedades de bordas e vértices) o máximo possível.
+ **Otimize os arquivos:**
+ Se você carregar arquivos grandes, como arquivos CSV, de um bucket do Amazon S3, o carregador gerenciará a simultaneidade para você, analisando-os em partes que poderão ser carregadas paralelamente. Usar um número muito grande de arquivos pequenos pode retardar esse processo.
+ Se você carregar vários arquivos de um prefixo do Amazon S3, o carregador automaticamente carregará os arquivos de vértice primeiro e depois os arquivos de borda. No entanto, se você souber que só carregará arquivos de borda, `edgeOnlyLoad` pode ser definido como `TRUE` para pular a primeira passagem em que todos os arquivos são digitalizados para determinar seu conteúdo (vértices ou bordas) para que todos os arquivos de vértice encontrados sejam carregados antes de qualquer arquivo de borda. Isso pode acelerar significativamente o tempo de carregamento, principalmente quando muitos arquivos de borda estão envolvidos. Caso alguns arquivos de vértice também estejam presentes no mesmo prefixo `source` (parâmetro) do Amazon S3, eles serão carregados, mas sem nenhuma garantia de ordenação em relação a outros arquivos. Além disso, se alguns vértices `from` ou `to` não estiverem presentes no banco de dados, a inserção da borda poderá relatar erros com a mensagem `FROM_OR_TO_VERTEX_ARE_MISSING`. Como prática recomendada, coloque nós e bordas prefixos separados do S3.
+ **Confira as configurações do carregador:**
+ Se você não precisar realizar nenhuma outra operação durante o carregamento, use o parâmetro [`OVERSUBSCRIBE` `parallelism`](load-api-reference-load.md#load-api-reference-load-syntax). Essa configuração de parâmetro faz com que o carregador em massa use todos os recursos de CPU disponíveis ao ser executado. Geralmente, é necessária de 60% a 70% da capacidade da CPU para manter a operação funcionando tão rápido quanto I/O as restrições permitirem.
**nota**
Quando `parallelism` é definido como `OVERSUBSCRIBE` ou `HIGH` (a configuração padrão), há o risco de, ao carregar dados do openCypher, que os threads encontrem uma condição de corrida e um deadlock, gerando um erro `LOAD_DATA_DEADLOCK`. Nesse caso, defina `parallelism` como uma configuração mais baixa e repita o carregamento.
+ Se o trabalho de carregamento incluir várias solicitações de carregamento, use o parâmetro `queueRequest`. A configuração de `queueRequest` como `TRUE` permite que o Neptune coloque suas solicitações na fila para que você não precise esperar que uma termine antes de emitir outra.
+ Se suas solicitações de carregamento estiverem sendo colocadas na fila, você poderá configurar níveis de dependência usando o parâmetro `dependencies`, para que a falha de um trabalho cause falhas nos trabalhos dependentes. Isso pode evitar inconsistências nos dados carregados.
+ Se um trabalho de carregamento envolver a atualização de valores carregados anteriormente, defina o parâmetro `updateSingleCardinalityProperties` como `TRUE`. Caso contrário, o carregador tratará uma tentativa de atualizar um valor de cardinalidade único existente como um erro. No caso de dados do Gremlin, a cardinalidade também é especificada nos cabeçalhos de coluna de propriedades (consulte [Cabeçalhos de coluna de propriedade](bulk-load-tutorial-format-gremlin.md#bulk-load-tutorial-format-gremlin-propheaders)).
**nota**
O parâmetro `updateSingleCardinalityProperties` não está disponível para dados do Resource Description Framework (RDF).
+ É possível usar o parâmetro `failOnError` para determinar se as operações de carregamento em massa devem falhar ou continuar quando um erro for encontrado. Além disso, você pode usar o parâmetro `mode` para garantir que uma tarefa de carregamento seja retomada a partir do ponto em que uma tarefa anterior falhou, em vez de recarregar dados que já haviam sido carregados.
+ **Aumentar a escala verticalmente**: defina a instância de gravador do cluster de banco de dados como o tamanho máximo antes do carregamento em massa. Observe que, se você fizer isso, também deverá aumentar a escala verticalmente de todas as instâncias de réplica de leitura no cluster de banco de dados ou removê-las até terminar de carregar os dados.
Quando o carregamento em massa estiver concluído, não se esqueça de reduzir a escala verticalmente da instância de gravador novamente.
**Importante**
Se você tiver um ciclo de reinicializações repetidas de réplica de leitura em virtude do atraso na replicação durante o carregamento em massa, é provável que as réplicas não consigam acompanhar o gravador no cluster de banco de dados. Escale os leitores para serem maiores do que o gravador ou remova-os temporariamente durante o carregamento em massa e, depois, recrie-os após a conclusão.
Consulte [Parâmetros da solicitação](load-api-reference-load.md#load-api-reference-load-parameters) para obter mais detalhes sobre como definir os parâmetros de solicitação do carregador.
# Referência do carregador do Neptune
Esta seção descreve os itens `Loader` APIs para Amazon Neptune que estão disponíveis no endpoint HTTP de uma instância de banco de dados Neptune.
**nota**
Consulte [Erro de carregador do Neptune e mensagens de feed](loader-message.md) para obter uma lista das mensagens de erro e feed geradas pelo carregador em caso de erros.
**Contents**
+ [Comando do carregador do Neptune](load-api-reference-load.md)
+ [Sintaxe da solicitação do carregador do Neptune](load-api-reference-load.md#load-api-reference-load-syntax)
+ [Parâmetros de solicitação do carregador do Neptune](load-api-reference-load.md#load-api-reference-load-parameters)
+ [Considerações especiais sobre o carregamento de dados do openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher)
+ [Sintaxe da resposta do carregador do Neptune](load-api-reference-load.md#load-api-reference-load-return)
+ [Erros do carregador do Neptune](load-api-reference-load-errors.md)
+ [Exemplos do carregador do Neptune](load-api-reference-load-examples.md)
+ [API do Neptune Loader Get-Status](load-api-reference-status.md)
+ [Solicitações do Neptune Loader Get-Status](load-api-reference-status-requests.md)
+ [Sintaxe da Get-Status solicitação do carregador](load-api-reference-status-requests.md#load-api-reference-status-request-syntax)
+ [Parâmetros de solicitação do Neptune Loader Get-Status](load-api-reference-status-requests.md#load-api-reference-status-parameters)
+ [Respostas do Neptune Loader Get-Status](load-api-reference-status-response.md)
+ [Layout JSON do Neptune Loader Get-Status Response](load-api-reference-status-response.md#load-api-reference-status-response-layout)
+ [Neptune Loader e objetos de resposta Get-Status `overallStatus` `failedFeeds`](load-api-reference-status-response.md#load-api-reference-status-response-objects)
+ [Objeto de resposta do Neptune Loader Get-Status `errors`](load-api-reference-status-response.md#load-api-reference-status-errors)
+ [Objeto de resposta do Neptune Loader Get-Status `errorLogs`](load-api-reference-status-response.md#load-api-reference-error-logs)
+ [Exemplos do Neptune Loader Get-Status](load-api-reference-status-examples.md)
+ [Exemplo de solicitação do status da carga](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request)
+ [Exemplo de solicitação de loadIs](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request)
+ [Exemplo de solicitação de status detalhado](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request)
+ [Exemplos do Neptune Loader Get-Status `errorLogs`](load-api-reference-error-logs-examples.md)
+ [Exemplo de resposta de status detalhada quando ocorreram erros](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors)
+ [Exemplo de erro `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted)
+ [Trabalho de cancelamento do carregador do Neptune](load-api-reference-cancel.md)
+ [Sintaxe da solicitação de trabalho de cancelamento](load-api-reference-cancel.md#load-api-reference-cancel-syntax)
+ [Parâmetros da solicitação de trabalho de cancelamento](load-api-reference-cancel.md#load-api-reference-cancel-parameters)
+ [Sintaxe da resposta de trabalho de cancelamento](load-api-reference-cancel.md#load-api-reference-cancel-parameters-response)
+ [Erros do trabalho de cancelamento](load-api-reference-cancel.md#load-api-reference-cancel-parameters-errors)
+ [Mensagens de erro do trabalho de cancelamento](load-api-reference-cancel.md#load-api-reference-cancel-parameters-errors-messages)
+ [Exemplos do trabalho de cancelamento](load-api-reference-cancel.md#load-api-reference-cancel-examples)
# Comando do carregador do Neptune
Carrega dados de um bucket do Amazon S3 em uma instância de banco de dados do Neptune.
Para carregar os dados, você deve enviar uma solicitação HTTP `POST` ao endpoint `https://your-neptune-endpoint:port/loader`. Os parâmetros da solicitação de `loader` podem ser enviados no corpo do `POST` ou como parâmetros codificados por URL.
**Importante**
O tipo MIME deve ser `application/json`.
O bucket do Amazon S3 deve estar na mesma AWS região do cluster.
**nota**
Você poderá carregar dados criptografados do Amazon S3 se ele foi criptografado usando o modo `SSE-S3` do Amazon S3. Nesse caso, o Neptune pode personificar suas credenciais e emitir chamadas `s3:getObject` em seu nome.
Você também pode carregar dados criptografados do Amazon S3 que foram criptografados usando o modo `SSE-KMS`, desde que o perfil do IAM inclua as permissões necessárias para acessar o AWS KMS. Sem AWS KMS as permissões adequadas, a operação de carregamento em massa falha e retorna uma `LOAD_FAILED` resposta.
No momento, o Neptune não é compatível com o carregamento de dados criptografados do Amazon S3 usando o modo `SSE-C`.
Não é necessário aguardar a conclusão de um trabalho de carregamento antes de iniciar outro. O Neptune poderá colocar na fila até 64 solicitações de trabalho por vez, desde que os parâmetros `queueRequest` estiverem definidos como `"TRUE"`. A ordem da fila dos trabalhos será first-in-first-out (FIFO). Por outro lado, se não quiser que um trabalho de carga seja colocado na fila, é possível definir o parâmetro `queueRequest` como `"FALSE"` (padrão), para que o trabalho de carga falhe se outro já estiver em andamento.
É possível usar o parâmetro `dependencies` para enfileirar um trabalho que deve ser executado somente após os trabalhos anteriores especificados na fila terem sido concluídos com êxito. Se fizer isso e qualquer um desses trabalhos especificados falharem, o trabalho não será executado e o status será definido como `LOAD_FAILED_BECAUSE_DEPENDENCY_NOT_SATISFIED`.
## Sintaxe da solicitação do carregador do Neptune
```
{
"source" : "string",
"format" : "string",
"iamRoleArn" : "string",
"mode": "NEW|RESUME|AUTO",
"region" : "us-east-1",
"failOnError" : "string",
"parallelism" : "string",
"parserConfiguration" : {
"baseUri" : "http://base-uri-string",
"namedGraphUri" : "http://named-graph-string"
},
"updateSingleCardinalityProperties" : "string",
"queueRequest" : "TRUE",
"dependencies" : ["load_A_id", "load_B_id"]
}
```
**edgeOnlyLoad Sintaxe**
Para um `edgeOnlyLoad`, a sintaxe seria:
```
{
"source" : "string",
"format" : "string",
"iamRoleArn" : "string",
"mode": "NEW|RESUME|AUTO",
"region" : "us-east-1",
"failOnError" : "string",
"parallelism" : "string",
"edgeOnlyLoad" : "string",
"parserConfiguration" : {
"baseUri" : "http://base-uri-string",
"namedGraphUri" : "http://named-graph-string"
},
"updateSingleCardinalityProperties" : "string",
"queueRequest" : "TRUE",
"dependencies" : ["load_A_id", "load_B_id"]
}
```
## Parâmetros de solicitação do carregador do Neptune
+ **`source`**: um URI do Amazon S3.
O parâmetro `SOURCE` aceita um URI do Amazon S3 que identifica um único arquivo, vários arquivos, uma pasta ou várias pastas. O Neptune carrega todos os arquivos de dados em qualquer pasta especificada.
O URI pode estar em qualquer um dos seguintes formatos.
+ `s3://bucket_name/object-key-name`
+ `https://s3.amazonaws.com/bucket_name/object-key-name`
+ `https://s3.us-east-1.amazonaws.com/bucket_name/object-key-name`
O `object-key-name` elemento do URI é equivalente ao parâmetro de [prefixo](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html#API_ListObjects_RequestParameters) em uma chamada de API do Amazon [ListObjects](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html)S3. Ele identifica todos os objetos no bucket do Amazon S3 especificado cujos nomes começam com esse prefixo. Isso pode ser um único arquivo ou pasta, ou várias and/or pastas de arquivos.
A pasta ou as pastas especificadas podem conter vários arquivos de vértice e vários arquivos de borda.
Por exemplo, se você tiver a seguinte estrutura de pasta e arquivos em um bucket do Amazon S3 chamado `bucket-name`:
```
s3://bucket-name/a/bc
s3://bucket-name/ab/c
s3://bucket-name/ade
s3://bucket-name/bcd
```
Se o parâmetro de origem for especificado como `s3://bucket-name/a`, os três primeiros arquivos serão carregados.
```
s3://bucket-name/a/bc
s3://bucket-name/ab/c
s3://bucket-name/ade
```
+ **`format`**: o formato dos dados. Para obter mais informações sobre os formatos de dados para o comando `Loader` do Neptune, consulte [Usar o carregador em massa do Amazon Neptune para ingerir dados](bulk-load.md).
**Valores permitidos**
+ **`csv`** para o [formato de dados CSV do Gremlin](bulk-load-tutorial-format-gremlin.md).
+ **`opencypher`** para o [formato de dados CSV do openCypher](bulk-load-tutorial-format-opencypher.md).
+ **`ntriples`** para o [formato de dados N-Triples do RDF](https://www.w3.org/TR/n-triples/).
+ **`nquads`** para o [formato de dados N-Quads do RDF](https://www.w3.org/TR/n-quads/).
+ **`rdfxml`** para o [formato de dados RDF\$1XML do RDF](https://www.w3.org/TR/rdf-syntax-grammar/).
+ **`turtle`** para o [formato de dados Turtle do RDF](https://www.w3.org/TR/turtle/).
+ **`iamRoleArn`**: o nome do recurso da Amazon (ARN) de um perfil do IAM a ser assumido pela instância de banco de dados do Neptune para acesso ao bucket do S3. Para obter informações sobre como criar um perfil que tenha acesso ao Amazon S3 e associá-lo a um cluster do Neptune, consulte [Pré-requisitos: perfil do IAM e acesso ao Amazon S3](bulk-load-tutorial-IAM.md).
A partir da [versão 1.2.1.0.R3 do mecanismo](engine-releases-1.2.1.0.R3.md), você também pode encadear várias funções do IAM se a instância de banco de dados Neptune e o bucket do Amazon S3 estiverem localizados em contas diferentes. AWS Nesse caso, `iamRoleArn` contém uma lista de funções separada por vírgulas ARNs, conforme descrito em. [Encadear perfis do IAM no Amazon Neptune](bulk-load-tutorial-chain-roles.md) Por exemplo:
```
curl -X POST https://localhost:8182/loader \
-H 'Content-Type: application/json' \
-d '{
"source" : "s3://(the target bucket name)/(the target date file name)",
"iamRoleArn" : "arn:aws:iam::(Account A ID):role/(RoleA),arn:aws:iam::(Account B ID):role/(RoleB),arn:aws:iam::(Account C ID):role/(RoleC)",
"format" : "csv",
"region" : "us-east-1"
}'
```
+ **`region`**— O `region` parâmetro deve corresponder à AWS região do cluster e ao bucket do S3.
O Amazon Neptune está disponível nas seguintes regiões da :
+ Leste dos EUA (Norte da Virgínia): `us-east-1`
+ Leste dos EUA (Ohio): `us-east-2`
+ Oeste dos EUA (N. da Califórnia): `us-west-1`
+ Oeste dos EUA (Oregon): `us-west-2`
+ Canadá (Central): `ca-central-1`
+ Oeste do Canadá (Calgary): `ca-west-1`
+ América do Sul (São Paulo): `sa-east-1`
+ Europa (Estocolmo): `eu-north-1`
+ Europa (Espanha): `eu-south-2`
+ Europa (Irlanda): `eu-west-1`
+ Europa (Londres): `eu-west-2`
+ Europa (Paris): `eu-west-3`
+ Europa (Frankfurt): `eu-central-1`
+ Oriente Médio (Bahrein): `me-south-1`
+ Oriente Médio (Emirados Árabes Unidos): `me-central-1`
+ Israel (Tel Aviv): `il-central-1`
+ África (Cidade do Cabo): `af-south-1`
+ Ásia-Pacífico (Hong Kong): `ap-east-1`
+ Ásia-Pacífico (Tóquio): `ap-northeast-1`
+ Ásia-Pacífico (Seul): `ap-northeast-2`
+ Ásia-Pacífico (Osaka): `ap-northeast-3`
+ Ásia-Pacífico (Singapura): `ap-southeast-1`
+ Ásia-Pacífico (Sydney): `ap-southeast-2`
+ Ásia-Pacífico (Jacarta): `ap-southeast-3`
+ Ásia-Pacífico (Melbourne): `ap-southeast-4`
+ Ásia-Pacífico (Malásia): `ap-southeast-5`
+ Ásia-Pacífico (Mumbai): `ap-south-1`
+ Ásia-Pacífico (Hyderabad): `ap-south-2`
+ China (Pequim): `cn-north-1`
+ China (Ningxia): `cn-northwest-1`
+ AWS GovCloud (Oeste dos EUA): `us-gov-west-1`
+ AWS GovCloud (Leste dos EUA): `us-gov-east-1`
+ **`mode`**: o modo do trabalho de carga.
*Valores permitidos*: `RESUME`, `NEW`, `AUTO`.
*Valor padrão*: `AUTO`
****
+ `RESUME`: no modo RESUME, o carregador procura uma carga anterior dessa origem e, se encontrar, retomará esse trabalho de carga. Se nenhum trabalho de carga anterior for encontrado, o carregador será interrompido.
O carregador evita recarregar arquivos que foram carregados com êxito em um trabalho anterior. Ele só tenta processar arquivos com falha. Se você descartou anteriormente dados carregados do cluster do Neptune, esses dados não serão recarregados nesse modo. Se um trabalho de carga anterior carregou todos os arquivos da mesma origem com êxito, nada será recarregado, e o recarregador exibirá êxito.
+ `NEW`: no modo NEW, cria uma solicitação de carga, independentemente de quaisquer cargas anteriores. É possível usar esse modo para recarregar todos dados de uma origem depois de eliminar dados carregados anteriormente do cluster do Neptune ou de carregar novos dados disponíveis na mesma origem.
+ `AUTO`: no modo AUTO, o carregador procura um trabalho de carga anterior da mesma origem e, se encontrar, retomará esse trabalho, assim como no modo `RESUME`.
Se o carregador não encontrar um trabalho de carga anterior da mesma origem, ele carregará todos os dados da origem, assim como no modo `NEW`.
+ **`edgeOnlyLoad`**: um sinalizador que controla a ordem de processamento de arquivos durante o carregamento em massa.
*Valores permitidos:* `"TRUE"`, `"FALSE"`
*Valor padrão:* `"FALSE"`.
Quando esse parâmetro é definido como “FALSE”, o carregador automaticamente carregará os arquivos de vértice primeiro e depois os arquivos de borda. Ele faz isso examinando todos os arquivos para determinar seu conteúdo (vértices ou bordas). Quando esse parâmetro é definido como “TRUE”, o carregador pula a fase inicial de varredura e carrega imediatamente todos os arquivos na ordem em que aparecem. Para obter mais informações, consulte [otimização de carregamento em massa](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-optimize.html).
+ **`failOnError`**: sinalizador para alternar uma interrupção completa em um erro.
*Valores permitidos:* `"TRUE"`, `"FALSE"`
*Valor padrão:* `"TRUE"`.
Quando este parâmetro estiver configurado como `"FALSE"`, o carregador tentará carregar todos os dados no local especificado, ignorando as entradas com erros.
Quando este parâmetro for definido como `"TRUE"`, o carregador será interrompido assim que encontrar um erro. Os dados carregados até esse momento serão mantidos.
+ **`parallelism`**: é um parâmetro opcional que pode ser definido para reduzir o número de threads usados pelo processo de carregamento em massa.
*Valores permitidos*:
+ `LOW`— O número de threads usados é o número de v disponíveis CPUs dividido por 8.
+ `MEDIUM`— O número de threads usados é o número de v disponíveis CPUs dividido por 2.
+ `HIGH`— O número de threads usados é igual ao número de v disponíveisCPUs.
+ `OVERSUBSCRIBE`— O número de threads usados é o número de v disponíveis CPUs multiplicado por 2. Se esse valor for usado, o carregador em massa usará todos os recursos disponíveis.
No entanto, isso não significa que a configuração `OVERSUBSCRIBE` resulte em 100% de utilização da CPU. Como a operação de carga está I/O limitada, a maior utilização esperada da CPU está na faixa de 60% a 70%.
*Valor padrão*: `HIGH`
Às vezes, a configuração `parallelism` pode causar um deadlock entre os threads ao carregar dados do openCypher. Quando isso acontece, o Neptune gera o erro `LOAD_DATA_DEADLOCK`. Geralmente, é possível corrigir o problema definindo uma configuração `parallelism` mais baixa e tentando novamente o comando de carregamento.
+ **`parserConfiguration`**: um objeto opcional com valores de configuração de analisador adicional. Os parâmetros filho também são opcionais:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/neptune/latest/userguide/load-api-reference-load.html)
Para obter mais informações, consulte [Gráfico padrão e gráficos nomeados do SPARQL](feature-sparql-compliance.md#sparql-default-graph).
+ **`updateSingleCardinalityProperties`**: é um parâmetro opcional que controla como o carregador em massa trata um novo valor das propriedades de vértice de cardinalidade única ou de borda. Isso não é compatível com o carregamento de dados do openCypher (consulte [Carregar dados do openCypher](#load-api-reference-load-parameters-opencypher)).
*Valores permitidos:* `"TRUE"`, `"FALSE"`
*Valor padrão:* `"FALSE"`.
Por padrão, ou quando `updateSingleCardinalityProperties` está explicitamente definido como `"FALSE"`, o carregador trata um novo valor como um erro, porque ele viola a cardinalidade única.
Quando `updateSingleCardinalityProperties` está definido como `"TRUE"`, por outro lado, o carregador em massa substitui o valor existente pelo novo. Se vários valores de propriedade de vértice de cardinalidade única ou de ponto forem fornecidos nos arquivos de origem que estão sendo carregados, o valor final quando o carregamento em massa terminar poderá ser qualquer um desses novos valores. O carregador só garante que o valor existente tenha sido substituído por um dos novos.
+ **`queueRequest`**: é um parâmetro de sinalizador opcional que indica se a solicitação de carga pode ser colocada na fila ou não.
Não é necessário esperar um trabalho de carga ser concluído antes de emitir o próximo, porque o Neptune pode colocar na fila até 64 trabalhos por vez, desde que os parâmetros `queueRequest` estejam todos definidos como `"TRUE"`. A ordem da fila dos trabalhos será first-in-first-out (FIFO).
Se o parâmetro `queueRequest` for omitido ou definido como `"FALSE"`, a solicitação de carga falhará se outro trabalho de carga já estiver em execução.
*Valores permitidos:* `"TRUE"`, `"FALSE"`
*Valor padrão:* `"FALSE"`.
+ **`dependencies`**: é um parâmetro opcional que pode tornar uma solicitação de carga na fila dependente da conclusão com êxito de um ou mais trabalhos anteriores na fila.
O Neptune poderá colocar na fila até 64 solicitações de carga por vez se os parâmetros `queueRequest` estiverem definidos como `"TRUE"`. O parâmetro `dependencies` permite executar a solicitação enfileirada dependente da conclusão com êxito de uma ou mais solicitações anteriores especificadas na fila.
Por exemplo, se as cargas `Job-A` e `Job-B` forem interdependentes, mas a carga `Job-C` precisar que a `Job-A` e a `Job-B` sejam concluídas antes de começar, prossiga da seguinte forma:
1. Envie `load-job-A` e `load-job-B`, uma após a outra, em qualquer ordem e salve os load-ids.
1. Envie `load-job-C` com os load-ids dos dois trabalhos no campo `dependencies`:
```
"dependencies" : ["job_A_load_id", "job_B_load_id"]
```
Devido ao parâmetro `dependencies`, o carregador em massa não iniciará a `Job-C` até que a `Job-A` e a `Job-B` tenham sido concluídas com êxito. Se uma delas falhar, a Job-C não será executada e o status será definido como `LOAD_FAILED_BECAUSE_DEPENDENCY_NOT_SATISFIED`.
É possível configurar vários níveis de dependência desta forma, para que a falha de um trabalho faça com que todas as solicitações direta ou indiretamente dependentes sejam canceladas.
+ **`userProvidedEdgeIds`**— Esse parâmetro é necessário somente ao carregar dados do OpenCypher que contêm relacionamento. IDs Ele deve ser incluído e configurado para `True` quando os relacionamentos do OpenCypher IDs forem fornecidos explicitamente nos dados de carregamento (recomendado).
Quando `userProvidedEdgeIds` está ausente ou definido como `True`, uma coluna `:ID` deve estar presente em cada arquivo de relacionamento no carregamento.
Quando `userProvidedEdgeIds` está presente e definido como `False`, os arquivos de relacionamento no carregamento **não devem** conter uma coluna `:ID`. Em vez disso, o carregador do Neptune gera automaticamente um ID para cada relacionamento.
É útil fornecer uma relação IDs explícita para que o carregador possa retomar o carregamento após a correção do erro nos dados CSV, sem precisar recarregar nenhuma relação que já tenha sido carregada. Se o relacionamento não IDs tiver sido atribuído explicitamente, o carregador não poderá retomar um carregamento com falha se algum arquivo de relacionamento precisar ser corrigido e, em vez disso, deverá recarregar todos os relacionamentos.
+ `accessKey`: **[obsoleto]** um ID de chave de acesso de um perfil do IAM com acesso ao bucket do S3 e arquivos de dados.
Em vez disso, o parâmetro `iamRoleArn` será recomendado. Para obter informações sobre como criar um perfil que tenha acesso ao Amazon S3 e associá-lo a um cluster do Neptune, consulte [Pré-requisitos: perfil do IAM e acesso ao Amazon S3](bulk-load-tutorial-IAM.md).
Para obter mais informações, consulte [Chaves de acesso (ID da chave de acesso e chave de acesso secreta)](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys).
+ `secretKey`: **[obsoleto]** O parâmetro `iamRoleArn` será recomendado em vez disso. Para obter informações sobre como criar um perfil que tenha acesso ao Amazon S3 e associá-lo a um cluster do Neptune, consulte [Pré-requisitos: perfil do IAM e acesso ao Amazon S3](bulk-load-tutorial-IAM.md).
Para obter mais informações, consulte [Chaves de acesso (ID da chave de acesso e chave de acesso secreta)](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys).
### Considerações especiais sobre o carregamento de dados do openCypher
+ Ao carregar dados do openCypher no formato CSV, o parâmetro de formato deverá ser definido como `opencypher`.
+ O parâmetro `updateSingleCardinalityProperties` não é compatível com carregamento do openCypher porque todas as propriedades do openCypher têm cardinalidade única. O formato de carregamento do openCypher não é compatível com matrizes e, se um valor de ID aparecer mais de uma vez, ele será tratado como uma duplicação ou um erro de inserção (veja abaixo).
+ O carregador do Neptune trata as duplicações encontradas nos dados do openCypher da seguinte forma:
+ Se o carregador encontrar várias linhas com o mesmo ID de nó, elas serão mescladas usando a seguinte regra:
+ Todos os rótulos nas linhas são adicionados ao nó.
+ Para cada propriedade, somente um dos valores é carregado. A seleção do que será carregado não é determinística.
+ Se o carregador encontrar várias linhas com o mesmo ID de relacionamento, somente uma delas será carregada. A seleção de uma para carregamento não é determinística.
+ O carregador nunca atualizará os valores das propriedades de um nó ou relacionamento existente no banco de dados se encontrar dados de carregamento com o ID do nó ou do relacionamento existente. No entanto, ele carrega rótulos e propriedades de nós que não estão presentes no nó ou no relacionamento existente.
+ Embora você não precise atribuir IDs a relacionamentos, geralmente é uma boa ideia (veja o `userProvidedEdgeIds` parâmetro acima). Sem um relacionamento explícito IDs, o carregador deve recarregar todos os relacionamentos em caso de erro em um arquivo de relacionamento, em vez de retomar o carregamento de onde ele falhou.
Além disso, se os dados de carregamento não contiverem uma relação explícita IDs, o carregador não tem como detectar relações duplicadas.
Veja a seguir o exemplo de um comando de carregamento do openCypher:
```
curl -X POST https://your-neptune-endpoint:port/loader \
-H 'Content-Type: application/json' \
-d '
{
"source" : "s3://bucket-name/object-key-name",
"format" : "opencypher",
"userProvidedEdgeIds": "TRUE",
"iamRoleArn" : "arn:aws:iam::account-id:role/role-name",
"region" : "region",
"failOnError" : "FALSE",
"parallelism" : "MEDIUM",
}'
```
A resposta do carregador é a mesma de sempre. Por exemplo:
```
{
"status" : "200 OK",
"payload" : {
"loadId" : "guid_as_string"
}
}
```
## Sintaxe da resposta do carregador do Neptune
```
{
"status" : "200 OK",
"payload" : {
"loadId" : "guid_as_string"
}
}
```
**200 OK**
O trabalho de carga iniciado com êxito retorna um código `200`.
# Erros do carregador do Neptune
Quando ocorre um erro, um objeto JSON é retornado no `BODY` da resposta. O objeto `message` contém uma descrição do erro.
**Categorias de erros**
+ `Error 400`: erros de sintaxe retornam uma solicitação HTTP `400` inadequada. A mensagem descreve o erro.
+ `Error 500`: uma solicitação válida que não pode ser processada gera um erro interno do servidor HTTP `500`. A mensagem descreve o erro.
As seguintes são as mensagens de erro possíveis no carregador com uma descrição do erro.
**Mensagens de erro do carregador**
+ `Couldn't find the AWS credential for iam_role_arn` (HTTP 400)
As credenciais não foram encontradas. Verifique as credenciais fornecidas no console ou na AWS CLI saída do IAM. Assegure-se de ter adicionado o perfil do IAM especificado no `iamRoleArn` ao cluster.
+ `S3 bucket not found for source` (HTTP 400)
O bucket do S3 não existe. Confirme o nome do bucket.
+ `The source source-uri does not exist/not reachable` (HTTP 400)
Nenhum arquivo correspondente foi encontrado no bucket do S3.
+ `Unable to connect to S3 endpoint. Provided source = source-uri and region = aws-region` (HTTP 500)
Não foi possível se conectar ao Amazon S3. A região deve corresponder à região do cluster. Verifique se você tem um VPC endpoint. Para obter informações sobre como criar um VPC endpoint, consulte [Criar o endpoint da VPC do Amazon S3](bulk-load-data.md#bulk-load-prereqs-s3).
+ `Bucket is not in provided Region (aws-region)` (HTTP 400)
O bucket deve estar na mesma AWS região da sua instância de banco de dados Neptune.
+ `Unable to perform S3 list operation` (HTTP 400)
O usuário ou a função do IAM fornecido não tem permissões `List` no bucket ou na pasta. Verifique a política ou a lista de controle de acesso (ACL) no bucket.
+ `Start new load operation not permitted on a read replica instance` (HTTP 405)
O carregamento é uma operação de gravação. Tente carregar novamente no endpoint do read/write cluster.
+ `Failed to start load because of unknown error from S3` (HTTP 500)
O Amazon S3 gerou um erro desconhecido. Entre em contato com a [AWS Support](https://aws.amazon.com/premiumsupport/).
+ `Invalid S3 access key` (HTTP 400)
A chave de acesso é inválida. Verifique as credenciais fornecidas.
+ `Invalid S3 secret key` (HTTP 400)
A chave secreta é inválida. Verifique as credenciais fornecidas.
+ `Max concurrent load limit breached` (HTTP 400)
Se uma solicitação de carga for enviada sem `"queueRequest" : "TRUE"` e um trabalho de carga estiver atualmente em execução, a solicitação falhará com esse erro.
+ `Failed to start new load for the source "source name". Max load task queue size limit breached. Limit is 64` (HTTP 400)
O Neptune é compatível com a colocação de até 64 trabalhos de carregador na fila por vez. Se uma solicitação de carga adicional for enviada para a fila quando esta já contiver 64 trabalhos, a solicitação falhará com essa mensagem.
# Exemplos do carregador do Neptune
Este exemplo demonstra como usar o carregador do Neptune para carregar dados em um banco de dados de grafos do Neptune usando o formato CSV do Gremlin. A solicitação é enviada como uma solicitação HTTP POST ao endpoint do carregador do Neptune, e o corpo da solicitação contém os parâmetros necessários para especificar a fonte de dados, o formato, o perfil do IAM e outras opções de configuração. A resposta inclui o ID de carregamento, que pode ser usado para acompanhar o progresso do processo de carregamento de dados.
**Example Solicitação**
O seguinte é uma solicitação enviada por HTTP POST usando o comando `curl`. Ele carrega um arquivo no formato CSV do Neptune. Para obter mais informações, consulte [Formato de dados de carga do Gremlin](bulk-load-tutorial-format-gremlin.md).
```
curl -X POST \
-H 'Content-Type: application/json' \
https://your-neptune-endpoint:port/loader -d '
{
"source" : "s3://bucket-name/object-key-name",
"format" : "csv",
"iamRoleArn" : "ARN for the IAM role you are using",
"region" : "region",
"failOnError" : "FALSE",
"parallelism" : "MEDIUM",
"updateSingleCardinalityProperties" : "FALSE",
"queueRequest" : "FALSE"
}'
```
**Example Resposta**
```
{
"status" : "200 OK",
"payload" : {
"loadId" : "ef478d76-d9da-4d94-8ff1-08d9d4863aa5"
}
}
```
# API do Neptune Loader Get-Status
Obtém o status de trabalho do `loader`.
Para obter o status da carga, você deve enviar uma solicitação HTTP `GET` ao endpoint `https://your-neptune-endpoint:port/loader`. Para obter o status de uma determinada solicitação de carga, você deve incluir o `loadId` como um parâmetro da URL ou acrescentar `loadId` ao caminho da URL.
O Neptune mantém o controle somente dos 1.024 trabalhos de carregamento em massa mais recentes e armazena somente os últimos dez mil detalhes de erro por trabalho.
Consulte [Erro de carregador do Neptune e mensagens de feed](loader-message.md) para obter uma lista das mensagens de erro e feed geradas pelo carregador em caso de erros.
**Contents**
+ [Solicitações do Neptune Loader Get-Status](load-api-reference-status-requests.md)
+ [Sintaxe da Get-Status solicitação do carregador](load-api-reference-status-requests.md#load-api-reference-status-request-syntax)
+ [Parâmetros de solicitação do Neptune Loader Get-Status](load-api-reference-status-requests.md#load-api-reference-status-parameters)
+ [Respostas do Neptune Loader Get-Status](load-api-reference-status-response.md)
+ [Layout JSON do Neptune Loader Get-Status Response](load-api-reference-status-response.md#load-api-reference-status-response-layout)
+ [Neptune Loader e objetos de resposta Get-Status `overallStatus` `failedFeeds`](load-api-reference-status-response.md#load-api-reference-status-response-objects)
+ [Objeto de resposta do Neptune Loader Get-Status `errors`](load-api-reference-status-response.md#load-api-reference-status-errors)
+ [Objeto de resposta do Neptune Loader Get-Status `errorLogs`](load-api-reference-status-response.md#load-api-reference-error-logs)
+ [Exemplos do Neptune Loader Get-Status](load-api-reference-status-examples.md)
+ [Exemplo de solicitação do status da carga](load-api-reference-status-examples.md#load-api-reference-status-examples-status-request)
+ [Exemplo de solicitação de loadIs](load-api-reference-status-examples.md#load-api-reference-status-examples-loadId-request)
+ [Exemplo de solicitação de status detalhado](load-api-reference-status-examples.md#load-api-reference-status-examples-details-request)
+ [Exemplos do Neptune Loader Get-Status `errorLogs`](load-api-reference-error-logs-examples.md)
+ [Exemplo de resposta de status detalhada quando ocorreram erros](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-details-request-errors)
+ [Exemplo de erro `Data prefetch task interrupted`](load-api-reference-error-logs-examples.md#load-api-reference-status-examples-task-interrupted)
# Solicitações do Neptune Loader Get-Status
## Sintaxe da Get-Status solicitação do carregador
```
GET https://your-neptune-endpoint:port/loader?loadId=loadId
```
```
GET https://your-neptune-endpoint:port/loader/loadId
```
```
GET https://your-neptune-endpoint:port/loader
```
## Parâmetros de solicitação do Neptune Loader Get-Status
+ **`loadId`**: o ID do trabalho de carga. Se você não especificar a`loadId`, uma lista de carga IDs será retornada.
+ **`details`**: inclua detalhes além do status geral.
*Valores permitidos:* `TRUE`, `FALSE`
*Valor padrão:* `FALSE`.
+ **`errors`**: inclua a lista de erros.
*Valores permitidos:* `TRUE`, `FALSE`
*Valor padrão:* `FALSE`.
A lista de erros é paginada. Os parâmetros `page` e `errorsPerPage` permitem que você pagine por todos os erros.
+ **`page`**: o número da página do erro. Válido apenas com o parâmetro `errors` definido como `TRUE`.
*Valores permitidos*: inteiros positivos.
*Valor padrão*: 1.
+ **`errorsPerPage`**: o número de erros por página. Válido apenas com o parâmetro `errors` definido como `TRUE`.
*Valores permitidos*: inteiros positivos.
*Valor padrão*: 10
+ **`limit`**: o número de IDs de cargas a serem listados. Válido somente ao solicitar uma lista de carga IDs enviando uma `GET` solicitação sem `loadId` especificação.
*Valores permitidos*: inteiros positivos de 1 a 100.
*Valor padrão*: 100
+ **`includeQueuedLoads`**— Um parâmetro opcional que pode ser usado para excluir a carga IDs de solicitações de carregamento em fila quando uma lista de carga IDs é solicitada.
Por padrão, a carga IDs de todas as tarefas de carga com status `LOAD_IN_QUEUE` é incluída nessa lista. Elas aparecem antes do carregamento IDs de outras tarefas, ordenadas pelo momento em que foram adicionadas à fila, da mais recente para a mais antiga.
*Valores permitidos:* `TRUE`, `FALSE`
*Valor padrão:* `TRUE`.
# Respostas do Neptune Loader Get-Status
O exemplo de resposta a seguir da API Get-Status Neptune descreve a estrutura geral da resposta, explica os vários campos e seus tipos de dados, bem como os detalhes do tratamento e do registro de erros.
## Layout JSON do Neptune Loader Get-Status Response
O layout geral de uma resposta de status do carregador é o seguinte:
```
{
"status" : "200 OK",
"payload" : {
"feedCount" : [
{
"LOAD_FAILED" : number
}
],
"overallStatus" : {
"fullUri" : "s3://bucket/key",
"runNumber" : number,
"retryNumber" : number,
"status" : "string",
"totalTimeSpent" : number,
"startTime" : number,
"totalRecords" : number,
"totalDuplicates" : number,
"parsingErrors" : number,
"datatypeMismatchErrors" : number,
"insertErrors" : number,
},
"failedFeeds" : [
{
"fullUri" : "s3://bucket/key",
"runNumber" : number,
"retryNumber" : number,
"status" : "string",
"totalTimeSpent" : number,
"startTime" : number,
"totalRecords" : number,
"totalDuplicates" : number,
"parsingErrors" : number,
"datatypeMismatchErrors" : number,
"insertErrors" : number,
}
],
"errors" : {
"startIndex" : number,
"endIndex" : number,
"loadId" : "string,
"errorLogs" : [ ]
}
}
}
```
## Neptune Loader e objetos de resposta Get-Status `overallStatus` `failedFeeds`
As possíveis respostas exibidas para cada feed com falha, incluindo as descrições dos erros, são as mesmas para o objeto `overallStatus` em uma resposta `Get-Status`.
Os seguintes campos são exibidos no objeto `overallStatus` de todas as cargas e o objeto `failedFeeds` de cada feed com falha:
+ **`fullUri` **: o URI do arquivo ou dos arquivos a serem carregados.
*Tipo*: *string*
*Formato*: `s3://bucket/key`.
+ **`runNumber`**: o número de execução dessa carga ou feed. É incrementado quando a carga é reiniciada.
*Tipo:* *longo não assinado*.
+ **`retryNumber`**: o número de repetição dessa carga ou feed. É incrementado quando o carregador tenta novamente um feed ou carga automaticamente.
*Tipo:* *longo não assinado*.
+ **`status`**: o status exibido da carga ou do feed. `LOAD_COMPLETED` indica uma carga bem-sucedida sem problemas. Para obter uma lista de outras mensagens de status de carregamento, consulte [Erro de carregador do Neptune e mensagens de feed](loader-message.md).
*Tipo*: *string*.
+ **`totalTimeSpent`**: o tempo, em segundos, gasto para analisar e inserir os dados para a carga ou o feed. Isso não inclui o tempo gasto para buscar a lista de arquivos de origem.
*Tipo:* *longo não assinado*.
+ **`totalRecords`**: total de registros carregados ou que tentaram carregar.
*Tipo:* *longo não assinado*.
Observe que, ao realizar o carregamento de um arquivo CSV, a contagem de registros não se refere ao número de linhas carregadas, mas sim ao número de registros individuais nessas linhas. Por exemplo, pegue como exemplo um pequeno arquivo CSV como este:
```
~id,~label,name,team
'P-1','Player','Stokes','England'
```
O Neptune consideraria que esse arquivo contém três registros, a saber:
```
P-1 label Player
P-1 name Stokes
P-1 team England
```
+ **`totalDuplicates`**: o número de registros duplicados encontrados.
*Tipo:* *longo não assinado*.
Como no caso da contagem `totalRecords`, esse valor contém o número de registros duplicados individuais em um arquivo CSV, não o número de linhas duplicadas. Pegue como exemplo este pequeno arquivo CSV:
```
~id,~label,name,team
P-2,Player,Kohli,India
P-2,Player,Kohli,India
```
O status exibido após o carregamento ficaria assim, relatando seis registros no total, dos quais três são duplicados:
```
{
"status": "200 OK",
"payload": {
"feedCount": [
{
"LOAD_COMPLETED": 1
}
],
"overallStatus": {
"fullUri": "(the URI of the CSV file)",
"runNumber": 1,
"retryNumber": 0,
"status": "LOAD_COMPLETED",
"totalTimeSpent": 3,
"startTime": 1662131463,
"totalRecords": 6,
"totalDuplicates": 3,
"parsingErrors": 0,
"datatypeMismatchErrors": 0,
"insertErrors": 0
}
}
}
```
Para carregamento do openCypher, uma duplicação é contada quando:
+ O carregador detecta que uma linha em um arquivo de nó tem um ID sem um espaço de ID que é igual a outro valor de ID sem um espaço de ID, seja em outra linha ou pertencente a um nó existente.
+ O carregador detecta que uma linha em um arquivo de nó tem um ID com um espaço de ID igual a outro valor de ID com um espaço de ID, seja em outra linha ou pertencente a um nó existente.
Consulte [Considerações especiais sobre o carregamento de dados do openCypher](load-api-reference-load.md#load-api-reference-load-parameters-opencypher).
+ **`parsingErrors`**: o número de erros de análise encontrados.
*Tipo:* *longo não assinado*.
+ **`datatypeMismatchErrors`**: o número de registros com um tipo de dados que não corresponderam aos dados fornecidos.
*Tipo:* *longo não assinado*.
+ **`insertErrors`**: o número de registros que não puderam ser inseridos devido a erros.
*Tipo:* *longo não assinado*.
## Objeto de resposta do Neptune Loader Get-Status `errors`
Os erros se enquadram nas seguintes categorias:
+ **`Error 400`**: um `loadId` inválido gera um erro de solicitação HTTP `400` inadequada. A mensagem descreve o erro.
+ **`Error 500`**: uma solicitação válida que não pode ser processada gera um erro interno do servidor HTTP `500`. A mensagem descreve o erro.
Consulte [Erro de carregador do Neptune e mensagens de feed](loader-message.md) para obter uma lista das mensagens de erro e feed geradas pelo carregador em caso de erros.
Quando ocorre um erro, um objeto JSON `errors` é gerado no `BODY` da resposta, com os seguintes campos:
+ **`startIndex`**: o índice do primeiro erro incluído.
*Tipo:* *longo não assinado*.
+ **`endIndex`**: o índice do último erro incluído.
*Tipo:* *longo não assinado*.
+ **`loadId`**: o ID da carga. Você pode usar esse ID para imprimir os erros do carregamento definindo o parâmetro `errors` como `TRUE`.
*Tipo*: *string*.
+ **`errorLogs`**: uma lista dos erros.
*Tipo:* *lista*.
## Objeto de resposta do Neptune Loader Get-Status `errorLogs`
O objeto `errorLogs` em `errors` na resposta Get-Status do carregador contém um objeto que descreve cada erro usando os seguintes campos:
+ **`errorCode`**: identifica a natureza do erro.
Pode utilizar um dos seguintes valores:
+ `PARSING_ERROR`
+ `S3_ACCESS_DENIED_ERROR`
+ `FROM_OR_TO_VERTEX_ARE_MISSING`
+ `ID_ASSIGNED_TO_MULTIPLE_EDGES`
+ `SINGLE_CARDINALITY_VIOLATION`
+ `FILE_MODIFICATION_OR_DELETION_ERROR`
+ `OUT_OF_MEMORY_ERROR`
+ `INTERNAL_ERROR` (gerado quando o carregador em massa não consegue determinar o tipo do erro).
+ **`errorMessage`**: uma mensagem descrevendo o erro.
Pode ser uma mensagem genérica associada ao código de erro ou uma mensagem específica contendo detalhes, por exemplo, sobre um from/to vértice ausente ou sobre um erro de análise.
+ **`fileName`**: o nome do feed.
+ **`recordNum`**: no caso de um erro de análise, esse é o número do registro no arquivo do registro que não pôde ser analisado. Será definido como zero se o número do registro não for aplicável ao erro ou se não puder ser determinado.
Por exemplo, o carregador em massa geraria um erro de análise se encontrasse uma linha com defeito, como a seguinte, em um arquivo RDF `nquads`:
```
|http://base#predicate> .
```
Como você pode ver, o segundo `http` na linha acima deve ser precedido por `<` em vez de `|`. O objeto de erro resultante abaixo de `errorLogs` em uma resposta de status deverá ser semelhante a este:
```
{
"errorCode" : "PARSING_ERROR",
"errorMessage" : "Expected '<', found: |",
"fileName" : "s3://bucket/key",
"recordNum" : 12345
},
```
# Exemplos do Neptune Loader Get-Status
Os exemplos a seguir mostram o uso da API GET-Status do carregador do Neptune, que permite recuperar informações sobre o status do carregamento de dados no banco de dados de grafos do Amazon Neptune. Esses exemplos abrangem três cenários principais: recuperar o status de uma carga específica, listar a carga IDs disponível e solicitar informações detalhadas sobre o status de uma carga específica.
## Exemplo de solicitação do status da carga
O seguinte é uma solicitação enviada por HTTP `GET` usando o comando `curl`.
```
curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)'
```
**Example Resposta**
```
{
"status" : "200 OK",
"payload" : {
"feedCount" : [
{
"LOAD_FAILED" : 1
}
],
"overallStatus" : {
"datatypeMismatchErrors" : 0,
"fullUri" : "s3://bucket/key",
"insertErrors" : 0,
"parsingErrors" : 5,
"retryNumber" : 0,
"runNumber" : 1,
"status" : "LOAD_FAILED",
"totalDuplicates" : 0,
"totalRecords" : 5,
"totalTimeSpent" : 3.0
}
}
}
```
## Exemplo de solicitação de loadIs
O seguinte é uma solicitação enviada por HTTP `GET` usando o comando `curl`.
```
curl -X GET 'https://your-neptune-endpoint:port/loader?limit=3'
```
**Example Resposta**
```
{
"status" : "200 OK",
"payload" : {
"loadIds" : [
"a2c0ce44-a44b-4517-8cd4-1dc144a8e5b5",
"09683a01-6f37-4774-bb1b-5620d87f1931",
"58085eb8-ceb4-4029-a3dc-3840969826b9"
]
}
}
```
## Exemplo de solicitação de status detalhado
O seguinte é uma solicitação enviada por HTTP `GET` usando o comando `curl`.
```
curl -X GET 'https://your-neptune-endpoint:port/loader/loadId (a UUID)?details=true'
```
**Example Resposta**
```
{
"status" : "200 OK",
"payload" : {
"failedFeeds" : [
{
"datatypeMismatchErrors" : 0,
"fullUri" : "s3://bucket/key",
"insertErrors" : 0,
"parsingErrors" : 5,
"retryNumber" : 0,
"runNumber" : 1,
"status" : "LOAD_FAILED",
"totalDuplicates" : 0,
"totalRecords" : 5,
"totalTimeSpent" : 3.0
}
],
"feedCount" : [
{
"LOAD_FAILED" : 1
}
],
"overallStatus" : {
"datatypeMismatchErrors" : 0,
"fullUri" : "s3://bucket/key",
"insertErrors" : 0,
"parsingErrors" : 5,
"retryNumber" : 0,
"runNumber" : 1,
"status" : "LOAD_FAILED",
"totalDuplicates" : 0,
"totalRecords" : 5,
"totalTimeSpent" : 3.0
}
}
}
```
# Exemplos do Neptune Loader Get-Status `errorLogs`
Os exemplos a seguir mostram a resposta de status detalhada do carregador do Neptune quando erros ocorrem durante o processo de carregamento de dados. Os exemplos ilustram a estrutura da resposta, incluindo informações sobre feeds com falha, status geral e registros em log de erros detalhados.
## Exemplo de resposta de status detalhada quando ocorreram erros
Trata-se de uma solicitação enviada via HTTP `GET` usando `curl`:
```
curl -X GET 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802?details=true&errors=true&page=1&errorsPerPage=3'
```
**Example de uma resposta detalhada quando ocorreram erros**
Este é um exemplo da resposta que você pode obter da consulta acima, com um objeto `errorLogs` listando os erros de carregamento encontrados:
```
{
"status" : "200 OK",
"payload" : {
"failedFeeds" : [
{
"datatypeMismatchErrors" : 0,
"fullUri" : "s3://bucket/key",
"insertErrors" : 0,
"parsingErrors" : 5,
"retryNumber" : 0,
"runNumber" : 1,
"status" : "LOAD_FAILED",
"totalDuplicates" : 0,
"totalRecords" : 5,
"totalTimeSpent" : 3.0
}
],
"feedCount" : [
{
"LOAD_FAILED" : 1
}
],
"overallStatus" : {
"datatypeMismatchErrors" : 0,
"fullUri" : "s3://bucket/key",
"insertErrors" : 0,
"parsingErrors" : 5,
"retryNumber" : 0,
"runNumber" : 1,
"status" : "LOAD_FAILED",
"totalDuplicates" : 0,
"totalRecords" : 5,
"totalTimeSpent" : 3.0
},
"errors" : {
"endIndex" : 3,
"errorLogs" : [
{
"errorCode" : "PARSING_ERROR",
"errorMessage" : "Expected '<', found: |",
"fileName" : "s3://bucket/key",
"recordNum" : 1
},
{
"errorCode" : "PARSING_ERROR",
"errorMessage" : "Expected '<', found: |",
"fileName" : "s3://bucket/key",
"recordNum" : 2
},
{
"errorCode" : "PARSING_ERROR",
"errorMessage" : "Expected '<', found: |",
"fileName" : "s3://bucket/key",
"recordNum" : 3
}
],
"loadId" : "0a237328-afd5-4574-a0bc-c29ce5f54802",
"startIndex" : 1
}
}
}
```
## Exemplo de erro `Data prefetch task interrupted`
Ocasionalmente, quando você obtém um status `LOAD_FAILED` e solicita informações mais detalhadas, o erro retornado pode ser um `PARSING_ERROR` com uma mensagem `Data prefetch task interrupted`, da seguinte forma:
```
"errorLogs" : [
{
"errorCode" : "PARSING_ERROR",
"errorMessage" : "Data prefetch task interrupted: Data prefetch task for 11467 failed",
"fileName" : "s3://amzn-s3-demo-bucket/some-source-file",
"recordNum" : 0
}
]
```
Esse erro ocorre quando há uma interrupção temporária no processo de carregamento de dados que normalmente não foi causada por sua solicitação ou seus dados. De maneira geral, ele pode ser resolvido simplesmente executando a solicitação de upload em massa novamente. Se você estiver usando as configurações padrão, ou seja, `"mode":"AUTO"` e `"failOnError":"TRUE"`, o carregador ignorará os arquivos que ele já tiver carregado com êxito e retomará o carregamento de arquivos que ainda não tinha carregado quando a interrupção ocorreu.
# Trabalho de cancelamento do carregador do Neptune
Cancela um trabalho de carga.
Para cancelar um trabalho, você deve enviar uma solicitação HTTP `DELETE` ao endpoint `https://your-neptune-endpoint:port/loader`. O `loadId` pode ser acrescentado ao caminho da URL `/loader` ou incluído como uma variável na URL.
## Sintaxe da solicitação de trabalho de cancelamento
```
DELETE https://your-neptune-endpoint:port/loader?loadId=loadId
```
```
DELETE https://your-neptune-endpoint:port/loader/loadId
```
## Parâmetros da solicitação de trabalho de cancelamento
**loadId**
O ID do trabalho de carga.
## Sintaxe da resposta de trabalho de cancelamento
```
no response body
```
**200 OK**
O trabalho de carga excluído com êxito retorna um código `200`.
## Erros do trabalho de cancelamento
Quando ocorre um erro, um objeto JSON é retornado no `BODY` da resposta. O objeto `message` contém uma descrição do erro.
**Categorias de erros**
+ **`Error 400`**: um `loadId` inválido gera um erro de solicitação HTTP `400` inadequada. A mensagem descreve o erro.
+ **`Error 500`**: uma solicitação válida que não pode ser processada gera um erro interno do servidor HTTP `500`. A mensagem descreve o erro.
## Mensagens de erro do trabalho de cancelamento
As seguintes são as mensagens de erro possíveis da API de cancelamento com uma descrição do erro.
+ `The load with id = load_id does not exist or not active` (HTTP 404): a carga não foi encontrada. Verifique o valor do parâmetro `id`.
+ `Load cancellation is not permitted on a read replica instance.` (HTTP 405): o carregamento é uma operação de gravação. Tente carregar novamente no endpoint do read/write cluster.
## Exemplos do trabalho de cancelamento
**Example Solicitação**
O seguinte é uma solicitação enviada por HTTP `DELETE` usando o comando `curl`.
```
curl -X DELETE 'https://your-neptune-endpoint:port/loader/0a237328-afd5-4574-a0bc-c29ce5f54802'
```
# 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
```
# Carregamento de dados no Amazon Neptune usando consultas
O Neptune suporta a gravação de dados diretamente por meio de operações de linguagem de consulta. Você pode usar operações de gravação padrão, como `CREATE` e `MERGE` no OpenCypher, `INSERT` no SPARQL ou `mergeV()` no Gremlin, para adicionar ou modificar dados `mergeE()` em seu gráfico. Essas operações são adequadas para atualizações incrementais e gravações transacionais.
Para carregar dados do Amazon S3, use o [Usar o carregador em massa do Amazon Neptune para ingerir dados](bulk-load.md) para grandes conjuntos de dados que exigem desempenho otimizado. Para conjuntos de dados menores em um ou alguns arquivos do Amazon S3, você pode usar funções de carregamento baseadas em consultas para ler e processar dados diretamente em suas consultas.
As seguintes funções de carregamento baseadas em consultas estão disponíveis:
## OpenCypher: neptune.read ()
A `neptune.read()` função lê arquivos CSV ou Parquet do Amazon S3 em `CALL` uma subconsulta, permitindo que você processe e carregue dados no momento da consulta.
```
CALL neptune.read({
source: "s3://bucket/data.csv",
format: "csv"
})
YIELD row
CREATE (n:Person {id: row.id, name: row.name})
```
Para obter a documentação completa, consulte[netuno.read ()](access-graph-opencypher-21-extensions-s3-read.md).
## SPARQL: CARREGAR e DESCARREGAR
`LOAD`As operações SPARQL importam dados RDF de um URI para um gráfico nomeado. `UNLOAD`exporta dados de um gráfico para o Amazon S3.
```
LOAD INTO GRAPH
```
Para obter a documentação completa, consulte[Usar SPARQL UPDATE LOAD para importar dados para o Neptune](sparql-api-reference-update-load.md).
## Gremlin: io () etapa
[Você também pode usar a `g.io(URL).read()` etapa de Gremlin para ler arquivos de dados em GraphML (formato XML), GraphSon (formato [JSON](https://tinkerpop.apache.org/docs/current/dev/io/#graphson)) e outros formatos.](https://tinkerpop.apache.org/docs/current/dev/io/#graphml)
```
g.io("s3://bucket/data.graphml").read().iterate()
```
Consulte a [TinkerPopdocumentação](https://tinkerpop.apache.org/docs/current/reference/#io-step) para obter detalhes.