Usando TinkerPop 3.4.11 ou superior Antes de TinkerPop 3.4.11

Conectando-se aos bancos de dados do Amazon Neptune IAM usando autenticação com o console Gremlin

A forma como você se conecta ao Amazon Neptune usando o console Gremlin com a autenticação Signature versão 4 depende se você está TinkerPop usando uma 3.4.11 versão ou superior, ou uma versão anterior. Nos dois casos, os seguintes pré-requisitos são necessários:

Você deve ter as IAM credenciais necessárias para assinar as solicitações. Consulte Uso da cadeia de fornecedores de credenciais padrão no Guia do AWS SDK for Java desenvolvedor.
Você deve ter instalado uma versão do console do Gremlin que seja compatível com a versão do mecanismo do Neptune que está sendo usada pelo cluster de banco de dados.

Se você estiver usando credenciais temporárias, elas vão expirar após um intervalo especificado, assim como o token da sessão. Portanto, é necessário atualizar o token da sessão ao solicitar novas credenciais. Consulte Uso de credenciais de segurança temporárias para solicitar acesso aos AWS recursos no Guia do IAM usuário.

Para obter ajuda na conexão usandoSSL/TLS, consulteSSL/TLSconfiguração.

Usando TinkerPop 3.4.11 ou superior para se conectar a Neptune com assinatura Sig4

Com TinkerPop 3.4.11 ou superior, você usaráhandshakeInterceptor(), que fornece uma maneira de conectar um assinante Sigv4 à conexão estabelecida pelo comando. :remote Assim como na abordagem utilizada para Java, ela exige que você configure o objeto Cluster manualmente e depois o transmita ao comando :remote.

Observe que isso é bem diferente da situação típica em que o comando :remote usa um arquivo de configuração para estabelecer a conexão. A abordagem do arquivo de configuração não funcionará porque handshakeInterceptor() deve ser definida de modo programático e não pode carregar a configuração por um arquivo.

Conecte o console Gremlin (TinkerPop 3.4.11 e superior) com a assinatura Sig4

Inicie o console do Gremlin:
```
$ bin/gremlin.sh
```
No prompt gremlin>, instale a biblioteca amazon-neptune-sigv4-signer (é necessário realizar esse procedimento apenas uma vez para o console):
```
:install com.amazonaws amazon-neptune-sigv4-signer 2.4.0
```
Se você encontrar problemas com essa etapa, pode ser útil consultar a TinkerPop documentação sobre a configuração do Grape.
nota
Se você estiver usando um HTTP proxy, poderá encontrar erros nessa etapa em que o :install comando não será concluído. Para corrigir esse problema, execute os comandos a seguir para informar o console sobre o proxy:
```
System.setProperty("https.proxyHost", "(the proxy IP address)")
System.setProperty("https.proxyPort", "(the proxy port)")
```

Importe a classe necessária para lidar com o login em handshakeInterceptor():


:import com.amazonaws.auth.DefaultAWSCredentialsProviderChain
:import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer

Se você estiver usando credenciais temporárias, também precisará fornecer o token de sessão da seguinte forma:
```
System.setProperty("aws.sessionToken","(your session token)")
```

Se você não estabeleceu as credenciais da conta de outra forma, poderá atribuí-las da seguinte maneira:


System.setProperty("aws.accessKeyId","(your access key)")
System.setProperty("aws.secretKey","(your secret key)")

Crie manualmente o objeto Cluster para conectar-se ao Neptune:



cluster = Cluster.build("(host name)")  \
                 .enableSsl(true) \
                 .handshakeInterceptor { r ->  \
                   def sigV4Signer = new NeptuneNettyHttpSigV4Signer("(Amazon region)", \
                                     new DefaultAWSCredentialsProviderChain()); \
                   sigV4Signer.signRequest(r); \
                   return r; } \
                 .create()

Para obter ajuda para encontrar o nome do host de uma instância de banco de dados do Neptune, consulte Conectar-se a endpoints do Amazon Neptune.

Estabeleça a conexão :remote usando o nome da variável do objeto Cluster na etapa anterior:
```
:remote connect tinkerpop.server cluster
```
Insira o comando a seguir para alternar para modo remoto. Isso envia todas as consultas do Gremlin para a conexão remota:
```
:remote console
```

Usando uma versão TinkerPop anterior à 3.4.11 para se conectar ao Netuno com a assinatura Sig4

Com a TinkerPop versão 3.4.10 ou inferior, use a amazon-neptune-gremlin-java-sigv4 biblioteca fornecida pelo Neptune para conectar o console ao Neptune com a assinatura Sigv4, conforme descrito abaixo:

Conecte o console Gremlin (TinkerPop versões anteriores à 3.4.11) com a assinatura Sig4

Inicie o console do Gremlin:
```
$ bin/gremlin.sh
```
No prompt gremlin>, instale a biblioteca amazon-neptune-sigv4-signer (é necessário realizar esse procedimento apenas uma vez para o console):
```
:install com.amazonaws amazon-neptune-sigv4-signer 2.4.0
```
nota
Se você estiver usando um HTTP proxy, poderá encontrar erros nessa etapa em que o :install comando não será concluído. Para corrigir esse problema, execute os comandos a seguir para informar o console sobre o proxy:
```
System.setProperty("https.proxyHost", "(the proxy IP address)")
System.setProperty("https.proxyPort", "(the proxy port)")
```
Também pode ser útil consultar a TinkerPop documentação sobre a configuração do Grape.
No subdiretório conf do diretório extraído, crie um arquivo chamado neptune-remote.yaml.

Se você usou o AWS CloudFormation modelo para criar seu cluster de banco de dados Neptune, neptune-remote.yaml um arquivo já existirá. Nesse caso, basta editar o arquivo existente para incluir a configuração do canalizador mostrada abaixo.

Caso contrário, copie o texto a seguir no arquivo, substituindo (host name) com o nome do host ou endereço IP da sua instância de banco de dados Neptune. Observe que os colchetes ([]) ao lado do nome do host são obrigatórios.
```
hosts: [(host name)]
port: 8182
connectionPool: {
  channelizer: org.apache.tinkerpop.gremlin.driver.SigV4WebSocketChannelizer,
  enableSsl: true
}
serializer: { className: org.apache.tinkerpop.gremlin.driver.ser.GraphBinaryMessageSerializerV1,
              config: { serializeResultToString: true }}
```

Importante

Você deve fornecer IAM credenciais para assinar as solicitações. Digite os comandos a seguir para definir as credenciais como variáveis de ambiente, substituindo os itens relevantes por suas credenciais.


export AWS_ACCESS_KEY_ID=access_key_id
export AWS_SECRET_ACCESS_KEY=secret_access_key
export SERVICE_REGION=us-east-1 or us-east-2 or us-west-1 or us-west-2 or ca-central-1 or
                      sa-east-1 or eu-north-1 or eu-west-1 or eu-west-2 or eu-west-3 or eu-central-1 or me-south-1 or
                      me-central-1 or il-central-1 or af-south-1 or ap-east-1 or ap-northeast-1 or ap-northeast-2 or ap-southeast-1 or ap-southeast-2 or ap-south-1 or
                      cn-north-1 or cn-northwest-1 or
                      us-gov-east-1 or us-gov-west-1

O Neptune versão 4 Signer usa a cadeia de fornecedores de credenciais padrão. Para conhecer métodos adicionais de fornecimento de credenciais, consulte Using the Default Credential Provider Chain no Guia do desenvolvedor do AWS SDK for Java .

A variável SERVICE_REGION é necessária, mesmo ao usar um arquivo de credenciais.

Estabeleça a conexão :remote usando o arquivo .yaml:


:remote connect tinkerpop.server conf/neptune-remote.yaml

Digite o seguinte comando para alternar para o modo remoto, que envia todas as consultas do Gremlin para a conexão remota:
```
:remote console
```

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Conectando-se a partir da linha de comando

Conectando-se usando Gremlin Java