Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Connettore Aurora DSQL per Java JDBC
<a name="SECTION_program-with-jdbc-connector"></a>

L'[Aurora DSQL Connector per JDBC](https://github.com/awslabs/aurora-dsql-connectors/tree/main/java/jdbc) è progettato come un plug-in di autenticazione che estende la funzionalità del driver JDBC PostgreSQL per consentire alle applicazioni di autenticarsi con Aurora DSQL utilizzando le credenziali IAM. Il connettore non si connette direttamente al database, ma fornisce un’autenticazione IAM senza semplificata in aggiunta al driver JDBC PostgreSQL sottostante.

Il connettore Aurora DSQL per JDBC è progettato per funzionare con il [driver JDBC PostgreSQL e offre una perfetta integrazione con i requisiti di autenticazione IAM di Aurora DSQL.](https://github.com/pgjdbc/pgjdbc)

Oltre al driver JDBC PostgreSQL, il connettore Aurora DSQL per JDBC consente l'autenticazione basata su IAM per Aurora DSQL. Introduce una profonda integrazione con servizi di autenticazione come (IAM). AWS [AWS Identity and Access Management](https://aws.amazon.com/iam/)

## Informazioni sul connettore
<a name="SECTION_program-with-jdbc-connector-about"></a>

Aurora DSQL è un servizio di database SQL distribuito che offre disponibilità e scalabilità elevate per applicazioni compatibili con PostgreSQL. Aurora DSQL richiede l’autenticazione basata su IAM con token a tempo limitato che i driver JDBC esistenti non supportano nativamente.

L'idea principale alla base di Aurora DSQL Connector per JDBC è aggiungere un livello di autenticazione al driver JDBC PostgreSQL che gestisce la generazione di token IAM, permettendo agli utenti di connettersi ad Aurora DSQL senza modificare i flussi di lavoro JDBC esistenti.

### Che cos’è l’autenticazione di Aurora DSQL?
<a name="SECTION_program-with-jdbc-connector-authentication"></a>

In Aurora DSQL, l’**autenticazione** prevede:
+ **Autenticazione IAM:** tutte le connessioni utilizzano l’autenticazione basata su IAM con token a tempo limitato
+ **Generazione** di token: AWS i token di autenticazione vengono generati utilizzando credenziali e hanno una durata configurabile

Il connettore Aurora DSQL per JDBC è progettato per comprendere questi requisiti e generare automaticamente token di autenticazione IAM quando si stabiliscono connessioni.

### Vantaggi del connettore Aurora DSQL per JDBC
<a name="SECTION_program-with-jdbc-connector-benefits"></a>

Sebbene Aurora DSQL fornisca un’interfaccia compatibile con PostgreSQL, i driver PostgreSQL esistenti attualmente non supportano i requisiti di autenticazione IAM di Aurora DSQL. L'Aurora DSQL Connector per JDBC consente ai clienti di continuare a utilizzare i flussi di lavoro PostgreSQL esistenti abilitando al contempo l'autenticazione IAM tramite:
+ **Generazione automatica di token: i token IAM vengono generati** automaticamente utilizzando le credenziali AWS 
+ **Integrazione perfetta**: funziona con i modelli di connessione JDBC esistenti
+ **AWS Supporto credenziali**: supporta vari provider di AWS credenziali (predefiniti, basati sul profilo, ecc.)

### Utilizzo del connettore Aurora DSQL per JDBC con pool di connessioni
<a name="SECTION_program-with-jdbc-connector-connection-pooling"></a>

Il connettore Aurora DSQL per JDBC funziona con librerie di connection pooling come HikariCP. Il connettore gestisce la generazione di token IAM durante la creazione della connessione, consentendo ai pool di connessioni di funzionare normalmente.

## Funzionalità principali
<a name="SECTION_program-with-jdbc-connector-features"></a>

Generazione automatica di token  
I token IAM vengono generati automaticamente utilizzando le credenziali. AWS 

Integrazione perfetta  
Funziona con gli schemi di connessione JDBC esistenti senza richiedere modifiche al flusso di lavoro.

AWS Supporto per le credenziali  
Supporta vari provider di AWS credenziali (predefiniti, basati sul profilo, ecc.).

Compatibilità della gestione di pool di connessioni  
Funziona perfettamente con le librerie di gestione dei pool di connessioni come HikariCP.

## Prerequisiti
<a name="SECTION_program-with-jdbc-connector-prerequisites"></a>

Prima di cominciare, assicurarsi che i seguenti requisiti preliminari siano soddisfatti:
+ [Creazione di un cluster in Aurora DSQL](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html).
+ Installazione di Java Development Kit (JDK). Verifica della disponibilità della versione 17 o superiore.
+ Configurazione delle autorizzazioni IAM appropriate per consentire all’applicazione di connettersi ad Aurora DSQL.
+ AWS credenziali configurate (tramite AWS CLI variabili di ambiente o ruoli IAM).

## Utilizzo del connettore Aurora DSQL per JDBC
<a name="SECTION_program-with-jdbc-connector-usage"></a>

Per utilizzare il connettore Aurora DSQL per JDBC nella tua applicazione Java, procedi nel seguente modo:

1. Aggiungere la seguente dipendenza Maven al progetto:

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

   Per i progetti Gradle, aggiungere questa dipendenza:

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

1. Crea una connessione di base al tuo cluster Aurora DSQL utilizzando il formato del connettore DSQL AWS 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();
           }
       }
   }
   ```

### Proprietà della configurazione
<a name="SECTION_program-with-jdbc-connector-properties"></a>

Il connettore Aurora DSQL per JDBC supporta le seguenti proprietà di connessione:

user  
Determina l’utente per la connessione e il metodo di generazione del token utilizzato. Ad esempio: `admin`

token-duration-secs  
Durata in secondi della validità del token. Per maggiori informazioni sui limiti dei token, consulta [Generazione di un token di autenticazione in Amazon Aurora DSQL](SECTION_authentication-token.md).

profile  
Utilizzato per creare un'istanza di una generazione di token ProfileCredentialsProvider for con il nome di profilo fornito.

region  
AWS regione per le connessioni Aurora DSQL. Facoltativo. Se fornita, sostituirà la Regione estratta dall’URL.

database  
Il nome del database a cui connettersi. Il valore predefinito è “`postgres`”.

### Registrazione dei log
<a name="SECTION_program-with-jdbc-connector-logging"></a>

Abilita la registrazione per risolvere eventuali problemi che si potrebbero riscontrare durante l’utilizzo del connettore JDBC di Aurora DSQL.

Il connettore utilizza il sistema di registrazione dei log integrato (java.util.logging) di Java. È possibile configurare i livelli di registrazione creando un file `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
```

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

Per esempi e casi d'uso più completi, consulta l'archivio [Aurora DSQL Connector for JDBC](https://github.com/awslabs/aurora-dsql-connectors/tree/main/java/jdbc/examples)