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.

# Connexion aux clusters Aurora DSQL à l’aide d’un connecteur JDBC
<a name="SECTION_program-with-jdbc-connector"></a>

Le [connecteur Aurora DSQL pour JDBC](https://github.com/awslabs/aurora-dsql-connectors/tree/main/java/jdbc) est conçu comme un plug-in d'authentification qui étend les fonctionnalités du pilote JDBC PostgreSQL afin de permettre aux applications de s'authentifier auprès d'Aurora DSQL à l'aide des informations d'identification IAM. Le connecteur ne se connecte pas directement à la base de données, mais fournit une authentification IAM fluide en plus du pilote JDBC PostgreSQL sous-jacent.

Le connecteur Aurora DSQL pour JDBC est conçu pour fonctionner avec le [pilote JDBC PostgreSQL et assure une intégration parfaite avec les exigences d'authentification](https://github.com/pgjdbc/pgjdbc) IAM d'Aurora DSQL.

Associé au pilote JDBC PostgreSQL, le connecteur Aurora DSQL pour JDBC permet l'authentification basée sur IAM pour Aurora DSQL. Il introduit une intégration approfondie avec les services AWS d'authentification tels que [Gestion des identités et des accès AWS](https://aws.amazon.com/iam/)(IAM).

## À propos du connecteur
<a name="SECTION_program-with-jdbc-connector-about"></a>

Aurora DSQL est un service de base de données SQL distribué qui fournit une disponibilité et une capacité de mise à l’échelle élevées aux applications compatibles avec PostgreSQL. Aurora DSQL nécessite une authentification basée sur IAM avec des jetons limités dans le temps que les pilotes JDBC existants ne prennent pas en charge de manière native.

L'idée principale du connecteur Aurora DSQL pour JDBC est d'ajouter une couche d'authentification au-dessus du pilote JDBC PostgreSQL qui gère la génération de jetons IAM, permettant aux utilisateurs de se connecter à Aurora DSQL sans modifier leurs flux de travail JDBC existants.

### Qu’est-ce que l’authentification Aurora DSQL ?
<a name="SECTION_program-with-jdbc-connector-authentication"></a>

Dans Aurora DSQL, **l’authentification** implique :
+ **Authentification IAM** : toutes les connexions utilisent l’authentification basée sur IAM avec des jetons à durée limitée
+ **Génération de jetons** : les jetons d'authentification sont générés à l'aide AWS d'informations d'identification et ont une durée de vie configurable

Le connecteur Aurora DSQL pour JDBC est conçu pour comprendre ces exigences et générer automatiquement des jetons d'authentification IAM lors de l'établissement de connexions.

### Avantages du connecteur Aurora DSQL pour JDBC
<a name="SECTION_program-with-jdbc-connector-benefits"></a>

Bien qu’Aurora DSQL fournisse une interface compatible avec PostgreSQL, les pilotes PostgreSQL existants ne prennent actuellement pas en charge les exigences d’authentification IAM d’Aurora DSQL. Le connecteur Aurora DSQL pour JDBC permet aux clients de continuer à utiliser leurs flux de travail PostgreSQL existants tout en activant l'authentification IAM via :
+ **Génération automatique de jetons** : les jetons IAM sont générés automatiquement à l'aide d'informations d'identification AWS 
+ **Intégration fluide** : compatible avec les modèles de connexion JDBC existants
+ **AWS Support des informations d'identification** : prend en charge différents fournisseurs AWS d'informations d'identification (par défaut, basé sur le profil, etc.)

### Utilisation du connecteur SQL Aurora pour JDBC avec regroupement de connexions
<a name="SECTION_program-with-jdbc-connector-connection-pooling"></a>

Le connecteur Aurora DSQL pour JDBC fonctionne avec des bibliothèques de regroupement de connexions telles que HikariCP. Le connecteur gère la génération de jetons IAM lors de l’établissement de la connexion, ce qui permet aux groupes de connexions de fonctionner normalement.

## Fonctions principales
<a name="SECTION_program-with-jdbc-connector-features"></a>

Génération automatique de jetons  
Les jetons IAM sont générés automatiquement à l'aide des AWS informations d'identification.

Intégration transparente  
Compatible avec les modèles de connexion JDBC existants sans nécessiter de modifications du flux de travail.

AWS Support des informations d'identification  
Prend en charge différents fournisseurs AWS d'identifiants (par défaut, basés sur le profil, etc.).

Compatibilité avec le regroupement de connexions  
Parfaitement compatible avec les bibliothèques de regroupement de connexions telles que HikariCP.

## Conditions préalables
<a name="SECTION_program-with-jdbc-connector-prerequisites"></a>

Avant de commencer, assurez-vous de remplir les prérequis suivants :
+ [Création d’un cluster dans Aurora DSQL](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html).
+ Installation du kit de développement Java (JDK). Assurez-vous qu’une version 17 ou supérieure est disponible.
+ Configuration des autorisations IAM appropriées pour permettre à votre application de se connecter à Aurora DSQL.
+ AWS informations d'identification configurées (via AWS CLI des variables d'environnement ou des rôles IAM).

## Utilisation du connecteur SQL Aurora pour JDBC
<a name="SECTION_program-with-jdbc-connector-usage"></a>

Pour utiliser le connecteur Aurora DSQL pour JDBC dans votre application Java, procédez comme suit :

1. Ajoutez les dépendances suivantes à votre projet Maven :

   ```
   <dependencies>
       <!-- Aurora DSQL Connector for JDBC -->
       <dependency>
           <groupId>software.amazon.dsql</groupId>
           <artifactId>aurora-dsql-jdbc-connector</artifactId>
           <version>1.0.0</version>
       </dependency>
   </dependencies>
   ```

   Pour les projets Gradle, ajoutez cette dépendance :

   ```
   implementation("software.amazon.dsql:aurora-dsql-jdbc-connector:1.0.0")
   ```

1. Créez une connexion de base à votre cluster Aurora DSQL à l'aide du format du connecteur AWS DSQL PostgreSQL :

   ```
   import java.sql.Connection;
   import java.sql.DriverManager;
   import java.sql.ResultSet;
   import java.sql.SQLException;
   import java.sql.Statement;
   
   public class DsqlJdbcConnectorExample {
       public static void main(String[] args) {
           // Using AWS DSQL PostgreSQL Connector prefix
           String jdbcUrl = "jdbc:aws-dsql:postgresql://your-cluster.dsql.us-east-1.on.aws/postgres?user=admin";
           
           try (Connection connection = DriverManager.getConnection(jdbcUrl)) {
               // Use the connection
               try (Statement statement = connection.createStatement()) {
                   // Create a table
                   statement.execute("CREATE TABLE IF NOT EXISTS test_table (id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name VARCHAR(100))");
                   
                   // Insert data
                   statement.execute("INSERT INTO test_table (name) VALUES ('Test Name')");
                   
                   // Query data
                   try (ResultSet resultSet = statement.executeQuery("SELECT * FROM test_table")) {
                       while (resultSet.next()) {
                           System.out.println("ID: " + resultSet.getInt("id") + ", Name: " + resultSet.getString("name"));
                       }
                   }
               }
               
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   }
   ```

### Propriétés de configuration
<a name="SECTION_program-with-jdbc-connector-properties"></a>

Le connecteur Aurora DSQL pour JDBC prend en charge les propriétés de connexion suivantes :

user  
Détermine l’utilisateur pour la connexion et la méthode de génération de jetons utilisée. Exemple : `admin`

token-duration-secs  
Durée de validité du jeton en secondes. Pour plus d’informations sur les limites des jetons, consultez [Génération d’un jeton d’authentification dans Amazon Aurora DSQL](SECTION_authentication-token.md).

profile  
Utilisé pour instancier une génération ProfileCredentialsProvider de jetons avec le nom de profil fourni.

region  
AWS région pour les connexions SQL Aurora. Elle est facultative. Lorsqu’elle est fournie, elle remplace la région extraite de l’URL.

database  
Le nom de la base de données à laquelle se connecter. La valeur par défaut est `postgres`.

### Logging
<a name="SECTION_program-with-jdbc-connector-logging"></a>

Activez la journalisation pour résoudre tout problème que vous pourriez rencontrer lors de l’utilisation du connecteur JDBC Aurora DSQL.

Le connecteur utilise le système de journalisation intégré (java.util.logging) de Java. Vous pouvez configurer les niveaux de journalisation en créant un fichier `logging.properties` :

```
# Set root logger level to INFO for clean output
.level = INFO

# Show Aurora DSQL Connector for JDBC FINE logs for detailed debugging
software.amazon.dsql.level = FINE

# Console handler configuration
handlers = java.util.logging.ConsoleHandler
java.util.logging.ConsoleHandler.level = FINE
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# Detailed formatter pattern with timestamp and logger name
java.util.logging.SimpleFormatter.format = %1$tH:%1$tM:%1$tS.%1$tL [%4$s] %3$s - %5$s%n
```

### Exemples
<a name="SECTION_program-with-jdbc-connector-examples"></a>

Pour des exemples et des cas d'utilisation plus complets, reportez-vous au [connecteur Aurora DSQL pour le référentiel JDBC](https://github.com/awslabs/aurora-dsql-connectors/tree/main/java/jdbc/examples)