# Gerar um token de autenticação no Amazon Aurora DSQL
<a name="SECTION_authentication-token"></a>

Para se conectar ao Amazon Aurora DSQL com um cliente SQL, gere um token de autenticação para usar como senha. Esse token é usado somente para autenticar a conexão. Depois que a conexão é estabelecida, a conexão permanece válida mesmo que o token de autenticação expire.

Se você criar um token de autenticação usando o console da AWS, a AWS CLI ou SDKs, ele expirará automaticamente em 15 minutos por padrão. O máximo é 604.800 segundos, o que equivale a uma semana. Para se conectar novamente ao Aurora DSQL por meio do seu cliente, você pode usar o mesmo token de autenticação, caso ele não tenha expirado, ou pode gerar um novo.

Para começar a gerar um token, [crie uma política do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) e [um cluster no Aurora DSQL](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html#getting-started-quickstart). Em seguida, use o console da AWS, a AWS CLI ou os SDKs da AWS para gerar um token.

No mínimo, você deve ter as permissões do IAM listadas em [Conectar-se a um cluster usando o IAM](authentication-authorization.md#authentication-authorization-iam-role-connect), dependendo do perfil de banco de dados que você usa para se conectar.

**Topics**
+ [Usar o console da AWS para gerar um token de autenticação no Aurora DSQL](#authentication-token-console)
+ [Usar a AWS CloudShell para gerar um token de autenticação no Aurora DSQL](#authentication-token-cloudshell)
+ [Usar a AWS CLI para gerar um token de autenticação no Aurora DSQL](#authentication-token-cli)
+ [Usar os SDKs para gerar um token no Aurora DSQL](#authentication-token-sdks)

## Usar o console da AWS para gerar um token de autenticação no Aurora DSQL
<a name="authentication-token-console"></a>

O Aurora DSQL autentica os usuários com um token, em vez de uma senha. Você pode gerar o token no console.

**Gerar token de autenticação**

1. Faça login no Console de gerenciamento da AWS e abra o console do Aurora DSQL em [https://console.aws.amazon.com/dsql](https://console.aws.amazon.com/dsql).

1. Escolha o ID do cluster para o qual deseja gerar um token de autenticação. Se você ainda não criou um cluster, siga as etapas em [Etapa 1: criar um cluster do Aurora DSQL de região única](getting-started.md#getting-started-create-cluster) ou [Etapa 4 (opcional): criar um cluster multirregional](getting-started.md#getting-started-multi-region).

1. Escolha **Connect** e, em seguida, selecione **Get Token**.

1. Escolha se você deseja se conectar como `admin` ou com um [perfil de banco de dados personalizado](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/authentication-authorization.html#authentication-authorization-iam-role-connect).

1. Copie o token de autenticação gerado e use-o para [Acessar o Aurora DSQL usando clientes SQL](accessing.md#accessing-sql-clients).

Para saber mais sobre perfis de banco de dados personalizados e o IAM no Aurora DSQL, consulte [Autenticação e autorização para o Aurora DSQL](authentication-authorization.md).

## Usar a AWS CloudShell para gerar um token de autenticação no Aurora DSQL
<a name="authentication-token-cloudshell"></a>

Antes de gerar um token de autenticação usando o AWS CloudShell, você precisa [Criar um cluster do Aurora DSQL](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html#getting-started-quickstart).

**Como gerar token de autenticação usando o AWS CloudShell**

1. Faça login no Console de gerenciamento da AWS e abra o console do Aurora DSQL em [https://console.aws.amazon.com/dsql](https://console.aws.amazon.com/dsql).

1. Na parte inferior esquerda do Console da AWS, escolha AWS CloudShell.

1. Execute o comando a seguir para gerar um token de autenticação para o perfil `admin`. Substitua *us-east-1* pela sua região e *cluster\$1endpoint* pelo endpoint do seu cluster. 
**nota**  
Se você não estiver se conectando como `admin`, use `generate-db-connect-auth-token` em vez disso.

   ```
   aws dsql generate-db-connect-admin-auth-token \
     --expires-in 3600 \
     --region us-east-1 \
     --hostname your_cluster_endpoint
   ```

   Se você tiver problemas, consulte [Solucionar problemas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html) e [Como solucionar erros de acesso negado ou operação não autorizada em uma política do IAM?](https://repost.aws/knowledge-center/troubleshoot-iam-policy-issues).

1. Use o comando a seguir para utilizar o `psql` para iniciar uma conexão com o cluster.

   ```
   PGSSLMODE=require \
   psql --dbname postgres \
     --username admin \
     --host cluster_endpoint
   ```

1. Você verá uma solicitação para fornecer uma senha. Copie o token que você gerou e não inclua espaços ou caracteres adicionais. Cole-o no prompt a seguir do `psql`.

   ```
   Password for user admin: 
   ```

1. Pressione **Enter**. Você verá um prompt do PostgreSQL.

   ```
   postgres=>
   ```

   Se você receber um erro de acesso negado, confirme se sua identidade do IAM tenha a permissão `dsql:DbConnectAdmin`. Se você tiver a permissão e continuar recebendo erros de negação de acesso, consulte [Solucionar problemas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html) e [Como solucionar erros de acesso negado ou operação não autorizada em uma política do IAM?](https://repost.aws/knowledge-center/troubleshoot-iam-policy-issues). 

Para saber mais sobre perfis de banco de dados personalizados e o IAM no Aurora DSQL, consulte [Autenticação e autorização para o Aurora DSQL](authentication-authorization.md).

## Usar a AWS CLI para gerar um token de autenticação no Aurora DSQL
<a name="authentication-token-cli"></a>

Quando seu cluster estiver `ACTIVE`, você poderá gerar um token de autenticação na CLI usando o comando `aws dsql`. Use uma das seguintes técnicas:

**nota**  
A geração de tokens é uma operação local que assina a solicitação usando suas credenciais atuais do IAM. Ela não entra em contato com a AWS para validar as credenciais. Se credenciais expirarem ou forem inválidas, a geração do token ainda será bem-sucedida, mas a tentativa de conexão falhará. Suas credenciais do IAM devem ser válidas antes de gerar um token.
+ Se você estiver se conectando com o perfil `admin`, use a opção `generate-db-connect-admin-auth-token`.
+ Se você estiver se conectando com um perfil de banco de dados personalizado, use a opção `generate-db-connect-auth-token`.

O exemplo a seguir usa os atributos abaixo para gerar um token de autenticação para o perfil `admin`.
+ *your\$1cluster\$1endpoint*: o endpoint do cluster. Ele segue o formato `your_cluster_identifier.dsql.region.on.aws`, como no exemplo `01abc2ldefg3hijklmnopqurstu.dsql.us-east-1.on.aws`.
+ *region*: a Região da AWS, como `us-east-2` ou `us-east-1`.

Os exemplos a seguir definem que o token deve expirar em 3.600 segundos (1 hora).

------
#### [ Linux and macOS ]

```
aws dsql generate-db-connect-admin-auth-token \
  --region region \
  --expires-in 3600 \
  --hostname your_cluster_endpoint
```

------
#### [ Windows ]

```
aws dsql generate-db-connect-admin-auth-token ^
  --region=region ^
  --expires-in=3600 ^
  --hostname=your_cluster_endpoint
```

------

## Usar os SDKs para gerar um token no Aurora DSQL
<a name="authentication-token-sdks"></a>

Você pode gerar um token de autenticação para o cluster quando ele estiver no status `ACTIVE`. Os exemplos de SDK usam os seguintes atributos para gerar um token de autenticação para o perfil `admin`:
+ *your\$1cluster\$1endpoint* (ou *yourClusterEndpoint*): o endpoint do cluster do Aurora DSQL. O formato de nomenclatura é `your_cluster_identifier.dsql.region.on.aws`, como no exemplo `01abc2ldefg3hijklmnopqurstu.dsql.us-east-1.on.aws`.
+ *region* (ou *RegionEndpoint*): a Região da AWS em que o cluster está localizado, como `us-east-2` ou `us-east-1`.

------
#### [ Python SDK ]

**dica**  
A AWS recomenda usar [Conector do Aurora DSQL para PythonSobre o conectorO que é a autenticação do Aurora DSQL?RecursosGuia de início rápidoRequisitosInstalaçãoInstale a psycopg, a psycopg2 ou a asyncpg separadamente.Uso básicopsycopgpsycopg2asyncpgUsar apenas o hostpsycopgpsycopg2asyncpgUsar apenas o ID do clusterpsycopgpsycopg2asyncpgpsycopgpsycopg2asyncpgString de conexãopsycopgpsycopg2asyncpgConfiguração avançadapsycopgpsycopg2asyncpgOpções de configuraçãoUsar o conector do Aurora DSQL para Python com um grupo de conexõespsycopgpsycopg2asyncpgAutenticaçãoAdmin versus usuários regularesExemplospsycopgpsycopg2asyncpg](SECTION_program-with-dsql-connector-for-python.md), que gerencia a geração de tokens automaticamente.

Você pode gerar o token das seguintes maneiras:
+ Se você estiver se conectando com um perfil `admin`, use `generate_db_connect_admin_auth_token`.
+ Se você estiver se conectando com um perfil de banco de dados personalizado, use `generate_connect_auth_token`.

```
import boto3

def generate_token(your_cluster_endpoint, region):
    client = boto3.client("dsql", region_name=region)
    # use `generate_db_connect_auth_token` instead if you are not connecting as admin.
    token = client.generate_db_connect_admin_auth_token(your_cluster_endpoint, region)
    print(token)
    return token
```

------
#### [ C\$1\$1 SDK ]

Você pode gerar o token das seguintes maneiras:
+ Se você estiver se conectando com um perfil `admin`, use `GenerateDBConnectAdminAuthToken`.
+ Se você estiver se conectando com um perfil de banco de dados personalizado, use `GenerateDBConnectAuthToken`.

```
#include <aws/core/Aws.h>
#include <aws/dsql/DSQLClient.h>
#include <iostream>

using namespace Aws;
using namespace Aws::DSQL;

std::string generateToken(String yourClusterEndpoint, String region) {
    DSQLClientConfiguration clientConfig;
    clientConfig.region = region;
    DSQLClient client{clientConfig};
    std::string token = "";
    
    // If you are not using the admin role to connect, use GenerateDBConnectAuthToken instead
    const auto presignedString = client.GenerateDBConnectAdminAuthToken(yourClusterEndpoint, region);
    if (presignedString.IsSuccess()) {
        token = presignedString.GetResult();
    } else {
        std::cerr << "Token generation failed." << std::endl;
    }

    std::cout << token << std::endl;
    return token;
}

int main() {
    Aws::SDKOptions options;
    Aws::InitAPI(options);
    // Replace with your cluster endpoint and region
    std::string token = generateToken("your_cluster_endpoint.dsql.us-east-1.on.aws", "us-east-1");
    Aws::ShutdownAPI(options);
    return 0;
}
```

------
#### [ JavaScript SDK ]

**dica**  
A AWS recomenda usar [Conectores do Aurora DSQL para Node.js](SECTION_Node-js-connectors.md), que lida com a geração de tokens automaticamente.

Você pode gerar o token das seguintes maneiras:
+ Se você estiver se conectando com um perfil `admin`, use `getDbConnectAdminAuthToken`.
+ Se você estiver se conectando com um perfil de banco de dados personalizado, use `getDbConnectAuthToken`.

```
import { DsqlSigner } from "@aws-sdk/dsql-signer";

async function generateToken(yourClusterEndpoint, region) {
  const signer = new DsqlSigner({
    hostname: yourClusterEndpoint,
    region,
  });
  try {
    // Use `getDbConnectAuthToken` if you are _not_ logging in as the `admin` user
    const token = await signer.getDbConnectAdminAuthToken();
    console.log(token);
    return token;
  } catch (error) {
      console.error("Failed to generate token: ", error);
      throw error;
  }
}
```

------
#### [ Java SDK ]

**dica**  
A AWS recomenda usar [Conectar-se a clusters do Aurora DSQL com um conector JDBC](SECTION_program-with-jdbc-connector.md), que gerencia a geração de tokens automaticamente.

Você pode gerar o token das seguintes maneiras:
+ Se você estiver se conectando com um perfil `admin`, use `generateDbConnectAdminAuthToken`.
+ Se você estiver se conectando com um perfil de banco de dados personalizado, use `generateDbConnectAuthToken`.

```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.services.dsql.DsqlUtilities;
import software.amazon.awssdk.regions.Region;

public class GenerateAuthToken { 
    public static String generateToken(String yourClusterEndpoint, Region region) {
        DsqlUtilities utilities = DsqlUtilities.builder()
                .region(region)
                .credentialsProvider(DefaultCredentialsProvider.builder().build())
                .build();

        // Use `generateDbConnectAuthToken` if you are _not_ logging in as `admin` user 
        String token = utilities.generateDbConnectAdminAuthToken(builder -> {
            builder.hostname(yourClusterEndpoint)
                    .region(region);
        });

        System.out.println(token);
        return token;
    }
}
```

------
#### [ Rust SDK ]

Você pode gerar o token das seguintes maneiras:
+ Se você estiver se conectando com um perfil `admin`, use `db_connect_admin_auth_token`.
+ Se você estiver se conectando com um perfil de banco de dados personalizado, use `db_connect_auth_token`.

```
use aws_config::{BehaviorVersion, Region};
use aws_sdk_dsql::auth_token::{AuthTokenGenerator, Config};

async fn generate_token(your_cluster_endpoint: String, region: String) -> String {
    let sdk_config = aws_config::load_defaults(BehaviorVersion::latest()).await;
    let signer = AuthTokenGenerator::new(
        Config::builder()
            .hostname(&your_cluster_endpoint)
            .region(Region::new(region))
            .build()
            .unwrap(),
    );

    // Use `db_connect_auth_token` if you are _not_ logging in as `admin` user
    let token = signer.db_connect_admin_auth_token(&sdk_config).await.unwrap();
    println!("{}", token);
    token.to_string()
}
```

------
#### [ Ruby SDK ]

**dica**  
A AWS recomenda usar [Conectar-se a clusters do Aurora DSQL com um conector Ruby](SECTION_program-with-dsql-connector-for-ruby-pg.md), que gerencia a geração de tokens automaticamente.

Você pode gerar o token das seguintes maneiras:
+ Se você estiver se conectando com um perfil `admin`, use `generate_db_connect_admin_auth_token`.
+ Se você estiver se conectando com um perfil de banco de dados personalizado, use `generate_db_connect_auth_token`.

```
require 'aws-sdk-dsql'

def generate_token(your_cluster_endpoint, region)
  credentials = Aws::CredentialProviderChain.new.resolve

  token_generator = Aws::DSQL::AuthTokenGenerator.new({
    :credentials => credentials
  })

  # if you're not using admin role, use generate_db_connect_auth_token instead
  token = token_generator.generate_db_connect_admin_auth_token({
    :endpoint => your_cluster_endpoint,
    :region => region
  })
end
```

------
#### [ PHP SDK ]

Você pode gerar o token das seguintes maneiras:
+ Se você estiver se conectando com um perfil `admin`, use `generateDbConnectAdminAuthToken`.
+ Se você estiver se conectando com um perfil de banco de dados personalizado, use `generateDbConnectAuthToken`.

```
<?php
require 'vendor/autoload.php';

use Aws\DSQL\AuthTokenGenerator;
use Aws\Credentials\CredentialProvider;

function generateToken(string $yourClusterEndpoint, string $region): string {
    $provider = CredentialProvider::defaultProvider();
    $generator = new AuthTokenGenerator($provider);

    // Use generateDbConnectAuthToken if you are not connecting as admin
    $token = $generator->generateDbConnectAdminAuthToken($yourClusterEndpoint, $region);

    echo $token . PHP_EOL;
    return $token;
}
```

------
#### [ .NET ]

**dica**  
A AWS recomenda usar [Conectar-se a clusters do Aurora DSQL com um conector .NET](SECTION_program-with-dsql-connector-for-dotnet-npgsql.md), que gerencia a geração de tokens automaticamente.

**nota**  
O SDK oficial para .NET não inclui uma chamada de API integrada para gerar um token de autenticação para o Aurora DSQL. Em vez disso, você deve usar `DSQLAuthTokenGenerator`, que é uma classe de utilitário. O exemplo de código a seguir mostra como gerar o token de autenticação para .NET. 

Você pode gerar o token das seguintes maneiras:
+ Se você estiver se conectando com um perfil `admin`, use `DbConnectAdmin`.
+ Se você estiver se conectando com um perfil de banco de dados personalizado, use `DbConnect`.

O exemplo a seguir usa a classe utilitária `DSQLAuthTokenGenerator` para gerar o token de autenticação para um usuário com o perfil `admin`. Substitua *insert-dsql-cluster-endpoint pelo endpoint do cluster*.

```
using Amazon;
using Amazon.DSQL.Util;

var yourClusterEndpoint = "insert-dsql-cluster-endpoint";

// Use `DSQLAuthTokenGenerator.GenerateDbConnectAuthToken` if you are _not_ logging in as `admin` user
var token = DSQLAuthTokenGenerator.GenerateDbConnectAdminAuthToken(RegionEndpoint.USEast1, yourClusterEndpoint);

Console.WriteLine(token);
```

------
#### [ Go ]

**dica**  
A AWS recomenda usar [Conectar-se a clusters do Aurora DSQL com um conector Go](SECTION_program-with-go-pgx-connector.md), que gerencia a geração de tokens automaticamente.

O AWS SDK for Go v2 oferece um método integrado para gerar tokens de autenticação no pacote [https://github.com/aws/aws-sdk-go-v2/tree/main/feature/dsql/auth](https://github.com/aws/aws-sdk-go-v2/tree/main/feature/dsql/auth).
+ Se você estiver se conectando com um perfil `admin`, use `auth.GenerateDBConnectAdminAuthToken`.
+ Se você estiver se conectando com um perfil de banco de dados personalizado, use `auth.GenerateDbConnectAuthToken`.

```
package main

import (
	"context"
	"fmt"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/feature/dsql/auth"
)

func main() {
	ctx := context.Background()

	cfg, err := config.LoadDefaultConfig(ctx, config.WithRegion("region"))
	if err != nil {
		panic(err)
	}

	// Use auth.GenerateDbConnectAuthToken for non-admin users
	token, err := auth.GenerateDBConnectAdminAuthToken(ctx, "yourClusterEndpoint", "region", cfg.Credentials)
	if err != nil {
		panic(err)
	}

	fmt.Println(token)
}
```

------