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

# Generazione di un token di autenticazione in Amazon Aurora DSQL
<a name="SECTION_authentication-token"></a>

Per connetterti ad Amazon Aurora DSQL con un client SQL, genera un token di autenticazione da utilizzare come password. Questo token viene utilizzato solo per autenticare la connessione. Una volta stabilita la connessione, la connessione rimane valida anche se il token di autenticazione scade.

Se si crea un token di autenticazione utilizzando la AWS console, il AWS CLI, o SDKs, il token scade automaticamente dopo 15 minuti per impostazione predefinita. La durata massima è di 604.800 secondi, ovvero una settimana. Per connetterti nuovamente ad Aurora DSQL dal client, puoi utilizzare lo stesso token di autenticazione se non è scaduto oppure è possibile generarne uno nuovo.

Per iniziare a generare un token, [crea una policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) e [un cluster in Aurora DSQL](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html#getting-started-quickstart). Quindi usa la AWS console o AWS CLI il AWS SDKs per generare un token.

È necessario disporre almeno delle autorizzazioni IAM elencate in [Connessione al cluster tramite IAM](authentication-authorization.md#authentication-authorization-iam-role-connect), a seconda del ruolo del database utilizzato per la connessione.

**Topics**
+ [Usa la AWS console per generare un token di autenticazione in Aurora DSQL](#authentication-token-console)
+ [AWS CloudShell Da utilizzare per generare un token di autenticazione in Aurora DSQL](#authentication-token-cloudshell)
+ [Usa AWS CLI per generare un token di autenticazione in Aurora DSQL](#authentication-token-cli)
+ [Usa SDKs per generare un token in Aurora DSQL](#authentication-token-sdks)

## Usa la AWS console per generare un token di autenticazione in Aurora DSQL
<a name="authentication-token-console"></a>

Aurora DSQL autentica gli utenti con un token anziché una password. Puoi generare il token dalla console.

**Per generare un token di autenticazione**

1. Accedi a Console di gestione AWS e apri la console Aurora DSQL all'indirizzo. [https://console.aws.amazon.com/dsql](https://console.aws.amazon.com/dsql)

1. Seleziona l’ID del cluster per cui desideri generare un token di autenticazione. Se non è ancora stato creato un cluster, segui i passaggi indicati in [Passo 1: Creazione di cluster Aurora DSQL a Regione singola](getting-started.md#getting-started-create-cluster) o [Fase 4 (opzionale): Creare un cluster multiregionale](getting-started.md#getting-started-multi-region).

1. Scegli **Connetti**, quindi seleziona **Ottieni token**.

1. Scegli se vuoi connetterti come `admin` o con un [ruolo del database personalizzato](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/authentication-authorization.html#authentication-authorization-iam-role-connect).

1. Copia il token di autenticazione generato e utilizzalo per [Accedi ad Aurora DSQL utilizzando client SQL](accessing.md#accessing-sql-clients).

Per maggiori informazioni sui ruoli del database personalizzati e su IAM in Aurora DSQL, consulta [Autenticazione e autorizzazione per Aurora DSQL](authentication-authorization.md).

## AWS CloudShell Da utilizzare per generare un token di autenticazione in Aurora DSQL
<a name="authentication-token-cloudshell"></a>

Prima di poter generare un token di autenticazione utilizzando AWS CloudShell, assicurati di [creare un cluster Aurora DSQL](https://docs.aws.amazon.com/aurora-dsql/latest/userguide/getting-started.html#getting-started-quickstart).

**Per generare un token di autenticazione utilizzando AWS CloudShell**

1. Accedi a Console di gestione AWS e apri la console Aurora DSQL all'indirizzo. [https://console.aws.amazon.com/dsql](https://console.aws.amazon.com/dsql)

1. In basso a sinistra della AWS console, scegli. AWS CloudShell

1. Esegui il comando seguente per generare un token di autenticazione per il ruolo `admin`. Sostituisci {{us-east-1}} con la tua regione e {{your\_cluster\_endpoint}} con l'endpoint del tuo cluster. 
**Nota**  
Se non ti connetti come `admin`, utilizza invece `generate-db-connect-auth-token`.

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

   In caso di problemi, consulta [Risoluzione dei problemi di IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html) e [Come posso risolvere gli errori di accesso negato o di operazione non autorizzata con una policy IAM?](https://repost.aws/knowledge-center/troubleshoot-iam-policy-issues)

1. Utilizza il comando seguente per utilizzare `psql` per aprire una connessione al cluster.

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

1. Dovrebbe comparire un prompt di immissione della password. Copia il token che generato e assicurati di non includere spazi o caratteri aggiuntivi. Incollalo nel seguente prompt da `psql`.

   ```
   Password for user admin: 
   ```

1. Premere **Invio**. Dovrebbe comparire un prompt di PostgreSQL.

   ```
   postgres=>
   ```

   Se ricevi un errore di accesso negato, assicurati che la tua identità IAM disponga dell’autorizzazione `dsql:DbConnectAdmin`. Se disponi dell’autorizzazione e continui a ricevere errori di accesso negato, consulta [Risoluzione dei problemi di IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html) e [Come posso risolvere gli errori di accesso negato o di operazione non autorizzata con una policy IAM?](https://repost.aws/knowledge-center/troubleshoot-iam-policy-issues) 

Per maggiori informazioni sui ruoli del database personalizzati e su IAM in Aurora DSQL, consulta [Autenticazione e autorizzazione per Aurora DSQL](authentication-authorization.md).

## Usa AWS CLI per generare un token di autenticazione in Aurora DSQL
<a name="authentication-token-cli"></a>

Se il cluster è in stato `ACTIVE`, è possibile generare un token di autenticazione dalla CLI utilizzando il comando `aws dsql`. È possibile utilizzare una delle seguenti tecniche:

**Nota**  
La generazione di token è un'operazione locale che firma la richiesta utilizzando le credenziali IAM correnti. Non contatta AWS per convalidare le credenziali. Se le credenziali sono scadute o non sono valide, la generazione del token riesce comunque, ma il tentativo di connessione fallisce. Assicurati che le tue credenziali IAM siano valide prima di generare un token.
+ Se ti stai connettendo con il ruolo `admin`, utilizza l’opzione `generate-db-connect-admin-auth-token`.
+ Se ti stai connettendo con un ruolo del database personalizzato, utilizza l’opzione `generate-db-connect-auth-token`.

L’esempio seguente utilizza i seguenti attributi per generare un token di autenticazione per il ruolo `admin`.
+ {{your\_cluster\_endpoint}}— L'endpoint del cluster. Segue il formato `{{your_cluster_identifier}}.dsql.{{region}}.on.aws`, come nell’esempio `01abc2ldefg3hijklmnopqurstu.dsql.us-east-1.on.aws`.
+ {{region}}— Il Regione AWS, ad esempio `us-east-2` o`us-east-1`.

Gli esempi seguenti impostano il tempo di scadenza del token in 3.600 secondi (1 ora).

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

------

## Usa SDKs per generare un token in Aurora DSQL
<a name="authentication-token-sdks"></a>

È possibile generare un token di autenticazione per il cluster quando è in stato `ACTIVE`. Gli esempi basati su SDK utilizzano i seguenti attributi per generare un token di autenticazione per il ruolo `admin`:
+ {{your\_cluster\_endpoint}}(o{{yourClusterEndpoint}}) — L'endpoint del cluster Aurora DSQL. Il formato di denominazione è `{{your_cluster_identifier}}.dsql.{{region}}.on.aws`, come nell’esempio `01abc2ldefg3hijklmnopqurstu.dsql.us-east-1.on.aws`.
+ {{region}}(o{{RegionEndpoint}}) — L'area Regione AWS in cui si trova il cluster, ad esempio o. `us-east-2` `us-east-1`

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

**Suggerimento**  
AWS consiglia di utilizzare[Connettore Aurora DSQL per PythonInformazioni sul connettoreChe cos’è l’autenticazione di Aurora DSQL?FunzionalitàGuida rapida di avvioRequisitiInstallazioneInstalla psycopg o psycopg2 o asyncpg separatamenteUtilizzo di basepsicocopiapsycopg2asyncpgUsando just hostpsicocopiapsycopg2asyncpgUtilizzando solo l'ID del clusterpsicocopiapsycopg2asyncpgpsicocopiapsycopg2asyncpgStringa di connessionepsicocopiapsycopg2asyncpgConfigurazione avanzatapsicocopiapsycopg2asyncpgOpzioni di configurazioneUtilizzo del connettore Aurora DSQL per Python con pool di connessionipsicocopiapsycopg2asincronoAutenticazioneAmministratore e utenti regolariEsempipsicocopiapsycopg2asyncpg](SECTION_program-with-dsql-connector-for-python.md), che gestisce automaticamente la generazione di token.

È possibile generare il token nei modi seguenti:
+ Se ti stai connettendo al `admin` ruolo, usa`generate_db_connect_admin_auth_token`.
+ Se ti stai connettendo con un ruolo di database personalizzato, usa`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\+\+ SDK ]

È possibile generare il token nei modi seguenti:
+ Se ti stai connettendo con il `admin` ruolo, usa`GenerateDBConnectAdminAuthToken`.
+ Se ti stai connettendo con un ruolo di database personalizzato, usa`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 ]

**Suggerimento**  
AWS consiglia di utilizzare[Connettori Aurora DSQL per Node.js](SECTION_Node-js-connectors.md), che gestisce automaticamente la generazione di token.

È possibile generare il token nei modi seguenti:
+ Se ti stai connettendo al `admin` ruolo, usa`getDbConnectAdminAuthToken`.
+ Se ti stai connettendo con un ruolo di database personalizzato, usa`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 ]

**Suggerimento**  
AWS consiglia di utilizzare[Connettore Aurora DSQL per Java JDBC](SECTION_program-with-jdbc-connector.md), che gestisce automaticamente la generazione di token.

È possibile generare il token nei modi seguenti:
+ Se ti stai connettendo al `admin` ruolo, usa`generateDbConnectAdminAuthToken`.
+ Se ti stai connettendo con un ruolo di database personalizzato, usa`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 ]

**Suggerimento**  
AWS consiglia di utilizzare[Connettore Aurora DSQL per Rust SQLx](SECTION_program-with-dsql-connector-for-rust-sqlx.md), che gestisce automaticamente la generazione di token.

È possibile generare il token nei modi seguenti:
+ Se ti stai connettendo al `admin` ruolo, usa`db_connect_admin_auth_token`.
+ Se ti stai connettendo con un ruolo di database personalizzato, usa`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 ]

**Suggerimento**  
AWS consiglia di utilizzare[Connettore DSQL Aurora per Ruby pg](SECTION_program-with-dsql-connector-for-ruby-pg.md), che gestisce automaticamente la generazione di token.

È possibile generare il token nei modi seguenti:
+ Se ti stai connettendo al `admin` ruolo, usa`generate_db_connect_admin_auth_token`.
+ Se ti stai connettendo con un ruolo di database personalizzato, usa`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 ]

**Suggerimento**  
AWS consiglia di utilizzare[Connettore Aurora DSQL per PHP `PDO_PGSQL`](SECTION_program-with-dsql-connector-for-php-pdo-pgsql.md), che gestisce automaticamente la generazione di token.

È possibile generare il token nei modi seguenti:
+ Se ti stai connettendo al `admin` ruolo, usa`generateDbConnectAdminAuthToken`.
+ Se ti stai connettendo con un ruolo di database personalizzato, usa`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 ]

**Suggerimento**  
AWS consiglia di utilizzare[Connettore Aurora DSQL per.NET Npgsql](SECTION_program-with-dsql-connector-for-dotnet-npgsql.md), che gestisce automaticamente la generazione di token.

**Nota**  
L’SDK ufficiale per .NET non include una chiamata API integrata per generare un token di autenticazione per Aurora DSQL. È necessario utilizzare invece `DSQLAuthTokenGenerator`, che è una classe di utilità. Nell’esempio di codice riportato di seguito viene illustrato come generare il token di autenticazione in .NET. 

È possibile generare il token nei modi seguenti:
+ Se ti stai connettendo al `admin` ruolo, usa`DbConnectAdmin`.
+ Se ti stai connettendo con un ruolo di database personalizzato, usa`DbConnect`.

L’esempio seguente utilizza la classe di utilità `DSQLAuthTokenGenerator` per generare il token di autenticazione per un utente con il ruolo `admin`. {{insert-dsql-cluster-endpoint}}Sostituiscilo con il tuo endpoint del 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 ]

**Suggerimento**  
AWS consiglia di utilizzare[Connettore Aurora DSQL per Go pgx](SECTION_program-with-go-pgx-connector.md), che gestisce automaticamente la generazione di token.

L' AWS SDK for Go v2 fornisce un metodo integrato per generare token di autenticazione nel pacchetto. [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 ti stai connettendo al `admin` ruolo, usa. `auth.GenerateDBConnectAdminAuthToken`
+ Se ti stai connettendo con un ruolo di database personalizzato, usa`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)
}
```

------