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á.

# Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com o console do Gremlin
<a name="iam-auth-connecting-gremlin-console"></a>

Para se conectar ao Amazon Neptune usando o console Gremlin com a autenticação Signature Version 4, você `requestInterceptor()` usa para conectar um assinante SigV4 à conexão estabelecida pelo comando. `:remote` Isso exige que você configure o `Cluster` objeto manualmente e depois o passe para o `:remote` comando.

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 `requestInterceptor()` deve ser definida de modo programático e não pode carregar a configuração por um arquivo.

**nota**  
Os exemplos a seguir usam`requestInterceptor()`, que foi introduzido em TinkerPop 3.6.6. Se você estiver usando uma TinkerPop versão anterior à 3.6.6 (mas 3.5.5 ou superior), use `requestInterceptor()` em `handshakeInterceptor()` vez dos exemplos de código abaixo.

Os seguintes pré-requisitos são necessários:
+ É necessário ter as credenciais do IAM necessárias para assinar as solicitações. Consulte [Uso da cadeia de fornecedores de credenciais padrão](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/credentials-chain.html) no Guia do AWS SDK para 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](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) no Guia do usuário do IAM.

Para obter ajuda na conexão usando SSL/TLS, consulte [Configuração de SSL/TLS](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl).

**Conecte o console Gremlin com a assinatura Sig4**

1. Inicie o console do Gremlin:

   ```
   $ bin/gremlin.sh
   ```

1. 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](https://tinkerpop.apache.org/docs/current/reference/#gremlin-applications) sobre a configuração do [Grape](http://docs.groovy-lang.org/latest/html/documentation/grape.html).
**nota**  
Se você estiver usando um proxy HTTP, poderá encontrar erros nessa etapa em que o comando `:install` não é 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)")
   ```

1. Importe a classe necessária para lidar com o login em `requestInterceptor()`:

   ```
   :import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider
   :import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer
   ```

1. 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)")
   ```

1. 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)")
   ```

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

   ```
   cluster = Cluster.build("(host name)")  \
                    .enableSsl(true) \
                    .requestInterceptor { r ->  \
                      def sigV4Signer = new NeptuneNettyHttpSigV4Signer("(Amazon region)", \
                                        DefaultCredentialsProvider.create()); \
                      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](feature-overview-endpoints.md).

1. Estabeleça a conexão `:remote` usando o nome da variável do objeto `Cluster` na etapa anterior:

   ```
   :remote connect tinkerpop.server cluster
   ```

1. Insira o comando a seguir para alternar para modo remoto. Isso envia todas as consultas do Gremlin para a conexão remota:

   ```
   :remote console
   ```