Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Création d’un jeton d’authentification dans Amazon Aurora DSQL
<a name="SECTION_authentication-token"></a>

Pour vous connecter à Amazon Aurora DSQL avec un client SQL, générez un jeton d’authentification à utiliser comme mot de passe. Ce jeton est utilisé uniquement pour l’authentification de la connexion. Une fois la connexion établie, la connexion reste valide même si le jeton d’authentification expire.

Si vous créez un jeton d'authentification à l'aide de la AWS AWS CLI console SDKs, le jeton expire automatiquement dans 15 minutes par défaut. La durée maximale est de 604 800 secondes, soit une semaine. Pour vous reconnecter à Aurora DSQL depuis votre client, vous pouvez utiliser le même jeton d’authentification s’il n’a pas expiré, ou vous pouvez en générer un nouveau.

Pour commencer à générer un jeton, [créez une politique IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) et [un cluster dans Aurora DSQL](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html#getting-started-quickstart). Utilisez ensuite la AWS console ou AWS CLI le AWS SDKs pour générer un jeton.

Vous devez disposer au minimum des autorisations IAM répertoriées dans [Connexion à votre cluster à l’aide d’IAM](authentication-authorization.md#authentication-authorization-iam-role-connect), selon le rôle de base de données que vous utilisez pour vous connecter.

**Topics**
+ [Utiliser la AWS console pour générer un jeton d'authentification dans Aurora DSQL](#authentication-token-console)
+ [AWS CloudShell À utiliser pour générer un jeton d'authentification dans Aurora DSQL](#authentication-token-cloudshell)
+ [Utilisez le AWS CLI pour générer un jeton d'authentification dans Aurora DSQL](#authentication-token-cli)
+ [Utilisez le SDKs pour générer un jeton dans Aurora DSQL](#authentication-token-sdks)

## Utiliser la AWS console pour générer un jeton d'authentification dans Aurora DSQL
<a name="authentication-token-console"></a>

Aurora DSQL authentifie les utilisateurs à l’aide d’un jeton plutôt que d’un mot de passe. Vous pouvez générer le jeton à partir de la console.

**Pour créer un jeton d’authentification**

1. Connectez-vous à la console Aurora AWS Management Console DSQL et ouvrez-la à [https://console.aws.amazon.com/dsql](https://console.aws.amazon.com/dsql) l'adresse.

1. Choisissez l’ID du cluster pour lequel vous souhaitez générer un jeton d’authentification. Si vous n’avez pas encore créé de cluster, suivez les étapes décrites dans [Étape 1 : création d’un cluster à une seule région Aurora DSQL](getting-started.md#getting-started-create-cluster) ou [Étape 4 (facultatif) : créer un cluster multirégional](getting-started.md#getting-started-multi-region).

1. Choisissez **Connecter**, puis sélectionnez **Obtenir un jeton**.

1. Choisissez si vous voulez vous connecter en tant qu’`admin` ou avec un [rôle de base de données personnalisé](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/authentication-authorization.html#authentication-authorization-iam-role-connect).

1. Copiez le jeton d’authentification généré et utilisez-le pour [Accédez à Aurora DSQL à l'aide de clients SQL](accessing.md#accessing-sql-clients).

Pour plus d’informations sur les rôles de base de données personnalisés et IAM dans Aurora DSQL, consultez [Authentification et autorisation pour Aurora DSQL](authentication-authorization.md).

## AWS CloudShell À utiliser pour générer un jeton d'authentification dans Aurora DSQL
<a name="authentication-token-cloudshell"></a>

Avant de pouvoir générer un jeton d'authentification à l'aide de AWS CloudShell, assurez-vous de [créer un cluster Aurora DSQL](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html#getting-started-quickstart).

**Pour générer un jeton d'authentification à l'aide de AWS CloudShell**

1. Connectez-vous à la console Aurora AWS Management Console DSQL et ouvrez-la à [https://console.aws.amazon.com/dsql](https://console.aws.amazon.com/dsql) l'adresse.

1. En bas à gauche de la AWS console, choisissez AWS CloudShell.

1. Exécutez la commande suivante pour générer un jeton d’authentification pour le rôle `admin`. *us-east-1*Remplacez-le par votre région et *your\$1cluster\$1endpoint* par le point de terminaison de votre propre cluster. 
**Note**  
Si vous ne vous connectez pas en tant que `admin`, utilisez `generate-db-connect-auth-token` à la place.

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

   Si vous rencontrez des erreurs, consultez [Résoudre les problèmes liés à IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html) et [Comment résoudre les erreurs d’accès refusé ou d’opération non autorisée avec une politique IAM ?](https://repost.aws/knowledge-center/troubleshoot-iam-policy-issues).

1. Utilisez la commande suivante pour utiliser `psql` afin de démarrer une connexion à votre cluster.

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

1. Vous devriez être invité à saisir un mot de passe. Copiez le jeton que vous avez généré et assurez-vous de ne pas inclure d’espaces ni de caractères supplémentaires. Collez-le dans le formulaire d’invite `psql` suivant.

   ```
   Password for user admin: 
   ```

1. Appuyez sur **Entrée**. Vous devriez obtenir une invite PostgreSQL.

   ```
   postgres=>
   ```

   Si vous obtenez une erreur d’accès refusé, assurez-vous que votre identité IAM dispose de l’autorisation `dsql:DbConnectAdmin`. Si vous êtes autorisé et que vous continuez à recevoir des erreurs d’accès refusé, consultez [Résoudre les problèmes liés à IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html) et [Comment résoudre les erreurs d’accès refusé ou d’opération non autorisée avec une politique IAM ?](https://repost.aws/knowledge-center/troubleshoot-iam-policy-issues). 

Pour plus d’informations sur les rôles de base de données personnalisés et IAM dans Aurora DSQL, consultez [Authentification et autorisation pour Aurora DSQL](authentication-authorization.md).

## Utilisez le AWS CLI pour générer un jeton d'authentification dans Aurora DSQL
<a name="authentication-token-cli"></a>

Lorsque votre cluster est `ACTIVE`, vous pouvez générer un jeton d’authentification sur l’interface de ligne de commande (CLI) à l’aide de la commande `aws dsql`. Utilisez l’une des techniques suivantes :

**Note**  
La génération de jetons est une opération locale qui signe la demande à l'aide de vos informations d'identification IAM actuelles. Il ne contacte pas AWS pour valider les informations d'identification. Si vos informations d'identification sont expirées ou non valides, la génération du jeton réussit tout de même, mais la tentative de connexion échoue. Assurez-vous que vos informations d'identification IAM sont valides avant de générer un jeton.
+ Si vous vous connectez avec le rôle `admin`, utilisez l’option `generate-db-connect-admin-auth-token`.
+ Si vous vous connectez avec le rôle de base de données personnalisé, utilisez l’option `generate-db-connect-auth-token`.

L’exemple suivant utilise les attributs suivants pour générer un jeton d’authentification pour le rôle `admin`.
+ *your\$1cluster\$1endpoint*— Le point de terminaison du cluster. Il suit le format `your_cluster_identifier.dsql.region.on.aws`, comme dans l’exemple `01abc2ldefg3hijklmnopqurstu.dsql.us-east-1.on.aws`.
+ *region*— Le Région AWS, tel que `us-east-2` ou`us-east-1`.

Les exemples suivants définissent le délai d’expiration du jeton dans 3 600 secondes (1 heure).

------
#### [ 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
```

------

## Utilisez le SDKs pour générer un jeton dans Aurora DSQL
<a name="authentication-token-sdks"></a>

Vous pouvez générer un jeton d’authentification pour votre cluster lorsqu’il est à l’état `ACTIVE`. L’exemple de kits SDK utilise les attributs suivants pour générer un jeton d’authentification pour le rôle `admin` :
+ *your\$1cluster\$1endpoint*(ou*yourClusterEndpoint*) : point de terminaison de votre cluster Aurora DSQL. Le format de dénomination est `your_cluster_identifier.dsql.region.on.aws`, comme dans l’exemple `01abc2ldefg3hijklmnopqurstu.dsql.us-east-1.on.aws`.
+ *region*(ou*RegionEndpoint*) — L' Région AWS endroit dans lequel se trouve votre cluster, tel que `us-east-2` ou`us-east-1`.

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

**Astuce**  
AWS recommande d'utiliser le[Connecteur SQL Aurora pour PythonÀ propos du connecteurQu’est-ce que l’authentification Aurora DSQL ?CaractéristiquesGuide de démarrage rapideExigencesInstallationInstallez psycopg ou psycopg2 ou asyncpg séparémentUtilisation de basepsycopiepsycopg2asyncpgEn utilisant uniquement l'hôtepsycopiepsycopg2asyncpgEn utilisant uniquement l'ID du clusterpsycopiepsycopg2asyncpgpsycopiepsycopg2asyncpgChaîne de connexionpsycopiepsycopg2asyncpgConfiguration avancéepsycopiepsycopg2asyncpgOptions de configurationUtilisation du connecteur SQL Aurora pour Python avec regroupement de connexionspsycopiepsycopg2asyncpgAuthentificationAdministrateur et utilisateurs réguliersExemplespsycopiepsycopg2asyncpg](SECTION_program-with-dsql-connector-for-python.md), qui gère automatiquement la génération de jetons.

Vous pouvez générer le jeton des manières suivantes :
+ Si vous vous connectez avec le `admin` rôle, utilisez`generate_db_connect_admin_auth_token`.
+ Si vous vous connectez avec un rôle de base de données personnalisé, utilisez`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 ]

Vous pouvez générer le jeton des manières suivantes :
+ Si vous vous connectez avec le `admin` rôle, utilisez`GenerateDBConnectAdminAuthToken`.
+ Si vous vous connectez avec un rôle de base de données personnalisé, utilisez`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 ]

**Astuce**  
AWS recommande d'utiliser le[Connecteurs SQL Aurora pour Node.js](SECTION_Node-js-connectors.md), qui gère automatiquement la génération de jetons.

Vous pouvez générer le jeton des manières suivantes :
+ Si vous vous connectez avec le `admin` rôle, utilisez`getDbConnectAdminAuthToken`.
+ Si vous vous connectez avec un rôle de base de données personnalisé, utilisez`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 ]

**Astuce**  
AWS recommande d'utiliser le[Connecteur Aurora DSQL pour Java JDBC](SECTION_program-with-jdbc-connector.md), qui gère automatiquement la génération de jetons.

Vous pouvez générer le jeton des manières suivantes :
+ Si vous vous connectez avec le `admin` rôle, utilisez`generateDbConnectAdminAuthToken`.
+ Si vous vous connectez avec un rôle de base de données personnalisé, utilisez`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 ]

**Astuce**  
AWS recommande d'utiliser le[Connecteur SQL Aurora pour Rust SQLx](SECTION_program-with-dsql-connector-for-rust-sqlx.md), qui gère automatiquement la génération de jetons.

Vous pouvez générer le jeton des manières suivantes :
+ Si vous vous connectez avec le `admin` rôle, utilisez`db_connect_admin_auth_token`.
+ Si vous vous connectez avec un rôle de base de données personnalisé, utilisez`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 ]

**Astuce**  
AWS recommande d'utiliser le[Connecteur SQL Aurora pour Ruby pg](SECTION_program-with-dsql-connector-for-ruby-pg.md), qui gère automatiquement la génération de jetons.

Vous pouvez générer le jeton des manières suivantes :
+ Si vous vous connectez avec le `admin` rôle, utilisez`generate_db_connect_admin_auth_token`.
+ Si vous vous connectez avec un rôle de base de données personnalisé, utilisez`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 ]

**Astuce**  
AWS recommande d'utiliser le[Connecteur SQL Aurora pour PHP `PDO_PGSQL`](SECTION_program-with-dsql-connector-for-php-pdo-pgsql.md), qui gère automatiquement la génération de jetons.

Vous pouvez générer le jeton des manières suivantes :
+ Si vous vous connectez avec le `admin` rôle, utilisez`generateDbConnectAdminAuthToken`.
+ Si vous vous connectez avec un rôle de base de données personnalisé, utilisez`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 ]

**Astuce**  
AWS recommande d'utiliser le[Connecteur Aurora DSQL pour .NET Npgsql](SECTION_program-with-dsql-connector-for-dotnet-npgsql.md), qui gère automatiquement la génération de jetons.

**Note**  
Le kit SDK officiel pour .NET n’inclut pas d’appel d’API intégré pour générer un jeton d’authentification pour Aurora DSQL. À la place, vous devez utiliser `DSQLAuthTokenGenerator`, qui est une classe d’utilitaire. L’exemple de code suivant décrit comment générer le jeton d’authentification pour .NET. 

Vous pouvez générer le jeton des manières suivantes :
+ Si vous vous connectez avec le `admin` rôle, utilisez`DbConnectAdmin`.
+ Si vous vous connectez avec un rôle de base de données personnalisé, utilisez`DbConnect`.

L’exemple suivant utilise la classe d’utilitaire `DSQLAuthTokenGenerator` pour générer le jeton d’authentification pour un utilisateur avec le rôle `admin`. Remplacez-le *insert-dsql-cluster-endpoint* par le point de terminaison de votre 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 ]

**Astuce**  
AWS recommande d'utiliser le[Connecteur SQL Aurora pour Go pgx](SECTION_program-with-go-pgx-connector.md), qui gère automatiquement la génération de jetons.

Le AWS SDK pour Go v2 fournit une méthode intégrée pour générer des jetons d'authentification dans [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)le package.
+ Si vous vous connectez avec le `admin` rôle, utilisez`auth.GenerateDBConnectAdminAuthToken`.
+ Si vous vous connectez avec un rôle de base de données personnalisé, utilisez`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)
}
```

------