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à.
# Autenticazione del database IAM per MariaDB, MySQL e PostgreSQL
Puoi autenticarti nel tuo di istanze DB utilizzando l'autenticazione del database AWS Identity and Access Management (IAM). L'autenticazione del database IAM funziona con MariaDB, MySQL e PostgreSQL. Con questo metodo di autenticazione, non devi utilizzare una password quando esegui la connessione all'istanza database. Utilizzi invece un token di autenticazione.
Un *token di autenticazione* è una stringa univoca di caratteri generata da Amazon RDS su richiesta. I token di autenticazione vengono generati utilizzando la versione 4 di AWS Signature. Ciascun token ha un ciclo di vita di 15 minuti. Non devi archiviare le credenziali dell'utente nel database, perché l'autenticazione è gestita esternamente utilizzando IAM. Puoi anche utilizzare ancora l'autenticazione standard del database. Il token viene utilizzato solo per l'autenticazione e non influisce sulla sessione dopo che è stato stabilito.
L'autenticazione del database IAM fornisce i seguenti vantaggi:
+ Il traffico di rete da e verso il database viene crittografato utilizzando Secure Socket Layer (SSL) o Transport Layer Security (TLS). Per ulteriori informazioni sull'utilizzo SSL/TLS con Amazon RDS Aurora, consulta. [](UsingWithRDS.SSL.md)
+ Puoi usare IAM per gestire in modo centralizzato l'accesso alle risorse del database invece di gestire l'accesso singolarmente in ogni istanza database.
+ Per le applicazioni in esecuzione su Amazon EC2, puoi utilizzare le credenziali specifiche dell'istanza EC2 per accedere al database invece di una password, per maggiore sicurezza.
In generale, prendi in considerazione l'utilizzo dell'autenticazione del database IAM quando le applicazioni creano meno di 200 connessioni al secondo e non desideri gestire nomi utente e password direttamente nel codice dell'applicazione.
Il driver JDBC Amazon Web Services (AWS) supporta l’autenticazione del database IAM. Per ulteriori informazioni, consulta [AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) nel [repository di driver GitHub JDBC di Amazon Web Services (AWS)](https://github.com/aws/aws-advanced-jdbc-wrapper).
Il driver Python Amazon Web Services (AWS) supporta l’autenticazione del database IAM. Per ulteriori informazioni, consulta [AWS IAM Authentication Plugin](https://github.com/aws/aws-advanced-python-wrapper/blob/main/docs/using-the-python-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) nel repository [Python Driver GitHub di Amazon Web Services (AWS)](https://github.com/aws/aws-advanced-python-wrapper).
Per apprendere il processo di impostazione di IAM per l’autenticazione del database, consulta i seguenti argomenti:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Connessione all'istanza tramite l'autenticazione IAM](UsingWithRDS.IAMDBAuth.Connecting.md)
## Disponibilità di regioni e versioni
La disponibilità e il supporto delle funzionalità variano a seconda delle versioni specifiche di ciascun motore di database. Per ulteriori informazioni sulla disponibilità di motore, versione e Regione con Amazon RDS e l’autenticazione del database IAM, consulta [Regioni e motori di database supportati per l’autenticazione del database IAM in Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.IamDatabaseAuthentication.md).
## Supporto per CLI e SDK
L'autenticazione del database IAM è disponibile per [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/generate-db-auth-token.html)e per i seguenti linguaggi: AWS SDKs
+ [AWS SDK per .NET](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/RDS/TRDSAuthTokenGenerator.html)
+ [AWS SDK per C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/class_aws_1_1_r_d_s_1_1_r_d_s_client.html#ae134ffffed5d7672f6156d324e7bd392)
+ [AWS SDK per Go](https://docs.aws.amazon.com/sdk-for-go/api/service/rds/#pkg-overview)
+ [AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/rds/RdsUtilities.html)
+ [AWS SDK per JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_rds_signer.html)
+ [AWS SDK per PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.Rds.AuthTokenGenerator.html)
+ [AWS SDK per Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.generate_db_auth_token)
+ [AWS SDK per Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/RDS/AuthTokenGenerator.html)
## Limitazioni per l'autenticazione database IAM
Quando utilizzi l'autenticazione database IAM, tieni presenti le seguenti limitazioni:
+ Attualmente, l'autenticazione database IAM non supporta nessuna delle chiavi di contesto delle condizioni globali.
Per ulteriori informazioni sulle chiavi di contesto delle condizioni globali, consulta [Chiavi di contesto delle condizioni globali AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) nella *Guida per l'utente di IAM*.
+ Per PostgreSQL, se il ruolo IAM (`rds_iam`) viene aggiunto a un utente (incluso l'utente principale RDS), l'autenticazione IAM ha la precedenza sull'autenticazione tramite password, quindi l'utente deve accedere come un utente IAM.
+ Per PostgreSQL, Amazon RDS non supporta l'attivazione dei metodi di autenticazione IAM e Kerberos contemporaneamente.
+ Per PostgreSQL, non è possibile utilizzare l'autenticazione IAM per stabilire una connessione di replica.
+ Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint dell'istanza databaseper generare il token di autenticazione.
+ CloudWatch e CloudTrail non registrate l'autenticazione IAM. Questi servizi non tengono traccia delle chiamate API `generate-db-auth-token` che autorizzano il ruolo IAM a consentire la connessione al database.
+ L’autenticazione del database IAM richiede risorse di calcolo sull’istanza database. Per una connettività affidabile è necessario disporre di una memoria aggiuntiva compresa tra 300 e 1000 MiB nel database. Per individuare la memoria necessaria per il carico di lavoro, si confronta la colonna RES per i processi RDS nell’elenco dei processi di monitoraggio avanzato prima e dopo aver abilitato l’autenticazione del database IAM. Per informazioni, consulta [Visualizzazione delle metriche nella console RDS](USER_Monitoring.OS.Viewing.md).
Se si utilizza un’istanza di classe espandibile, evitare di esaurire la memoria riducendo della stessa quantità la memoria utilizzata da altri parametri, come buffer e cache.
+ L’autenticazione del database IAM non è supportata per RDS su Outposts per tutti i motori.
## Consigli per l'autenticazione del database IAM
Quando si utilizza l'autenticazione del database IAM, è consigliabile procedere come segue:
+ Utilizzare l'autenticazione del database IAM quando l'applicazione richiede meno di 200 nuove connessioni di autenticazione del database IAM al secondo.
I motori di database che funzionano con Amazon RDS non prevedono limitazioni per i tentativi di autenticazione al secondo. Tuttavia, quando utilizzi un'autenticazione database IAM, l'applicazione deve generare un token di autenticazione. L'applicazione usa quindi il token per connettersi all'istanza database. Se eccedi il limite massimo di nuove connessioni al secondo, la gestione extra dell'autenticazione database IAM può causare throttling della connessione.
Valuta la possibilità di utilizzare il pool di connessioni nelle applicazioni per mitigare la creazione continua di connessioni. Questo può ridurre il sovraccarico derivante dall'autenticazione DB IAM e consentire alle applicazioni di riutilizzare le connessioni esistenti. In alternativa, per questi casi d'uso considera l'utilizzo di Server proxy per RDS. Per Server proxy per RDS sono previsti costi aggiuntivi. Consulta i [prezzi per Server proxy per RDS](https://aws.amazon.com/rds/proxy/pricing/).
+ La dimensione di un token di autenticazione del database IAM dipende da molti fattori, tra cui il numero di tag IAM, le policy di servizio IAM, la lunghezza del nome della risorsa Amazon (ARN) e altre proprietà IAM e del database. La dimensione minima del token è generalmente di circa 1 KB, ma può essere maggiore. Poiché questo token viene utilizzato come password nella stringa di connessione al database mediante l'autenticazione IAM, è necessario assicurarsi che il driver del database (ad esempio ODBC) and/or non limiti o altrimenti tronchi questo token a causa delle sue dimensioni. Un token troncato causa l'esito negativo della convalida dell'autenticazione effettuata dal database e da IAM.
+ Se si utilizzano credenziali temporanee durante la creazione di un token di autenticazione del database IAM, le credenziali temporanee devono essere ancora valide quando si utilizza il token di autenticazione del database IAM per effettuare una richiesta di connessione.
## Chiavi di contesto relative alle condizioni globali non supportate AWS
L'autenticazione del database IAM non supporta il seguente sottoinsieme di chiavi di contesto delle condizioni AWS globali.
+ `aws:Referer`
+ `aws:SourceIp`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserAgent`
+ `aws:VpcSourceIp`
Per ulteriori informazioni, consultare [Chiavi di contesto delle condizioni globali AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) nella *Guida per l'utente IAM*.
# Abilitazione e disabilitazione dell’autenticazione database IAM
Per impostazione predefinita, l’autenticazione database IAM è disabilitata nelle istanze database. Puoi abilitare o disabilitare l'autenticazione del database IAM utilizzando Console di gestione AWS AWS CLI, o l'API.
Puoi abilitare l’autenticazione database IAM quando esegui una delle seguenti operazioni:
+ Per creare una nuova istanza database con l’autenticazione database IAM abilitata, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per modificare un’istanza database per abilitare l’autenticazione database IAM, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
+ Per ripristinare un’istanza database da uno snapshot con l’autenticazione del database IAM abilitata, consulta [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md).
+ Per ripristinare un’istanza database a un momento specifico con l’autenticazione del database IAM abilitata, consulta [Ripristino di un’istanza database a un punto temporale specifico per Amazon RDS](USER_PIT.md).
## Console
Ogni flusso di lavoro di creazione o modifica include una sezione **Database authentication (Autenticazione database)** in cui puoi abilitare o disabilitare l’autenticazione database IAM. In questa sezione scegli **Password and IAM database authentication (Autenticazione password e database IAM)** per abilitare l’autenticazione database IAM.
**Per abilitare o disabilitare l’autenticazione database IAM per un’istanza database esistente**
1. Aprire la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegliere **Databases (Database)**.
1. Scegliere l’istanza database che si vuole modificare.
**Nota**
Verifica che l’istanza database sia compatibile con l’autenticazione IAM. Controllare i requisiti di compatibilità in [Disponibilità di regioni e versioni](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
1. Scegliere **Modify (Modifica)**.
1. Nella sezione **Autenticazione del database**, scegli **Password e autenticazione del database IAM** Autenticazione del autenticazione del database IAM. Scegli **Autenticazione password** o **Autenticazione di password e Kerberos** per disabilitare l’autenticazione IAM.
1. Puoi anche scegliere di abilitare la pubblicazione dei log di autenticazione IAM DB su Logs. CloudWatch In **Esportazioni di log**, scegli l'opzione **iam-db-auth-error log**. La pubblicazione dei log in CloudWatch Logs consuma spazio di archiviazione e comporta l'addebito di costi per tale archiviazione. Assicurati di eliminare tutti i CloudWatch log che non ti servono più.
1. Scegli **Continue (Continua)**.
1. Per applicare immediatamente le modifiche, scegli **Immediately (Immediatamente)** nella sezione **Scheduling of modifications (Pianificazione delle modifiche)**.
1. Scegliere **Modify DB instance (Modifica istanza database)** .
## AWS CLI
Per creare una nuova istanza DB con autenticazione IAM utilizzando il AWS CLI, usa il [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)comando. Specifica l’opzione `--enable-iam-database-authentication`, come visualizzato nell’esempio seguente.
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.m3.medium \
--engine MySQL \
--allocated-storage 20 \
--master-username masterawsuser \
--manage-master-user-password \
--enable-iam-database-authentication
```
Per aggiornare un’istanza database esistente in modo da abilitare o disabilitare l’autenticazione IAM, utilizzare il comando AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html). Specifica l’opzione `--enable-iam-database-authentication` o `--no-enable-iam-database-authentication`, come appropriato.
**Nota**
Verifica che l’istanza database sia compatibile con l’autenticazione IAM. Controllare i requisiti di compatibilità in [Disponibilità di regioni e versioni](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Per impostazione predefinita, Amazon RDS esegue la modifica durante la finestra di manutenzione successiva. Se desideri sostituire ciò e abilitare l’autenticazione database IAM il prima possibile, utilizza il parametro `--apply-immediately`.
L’esempio seguente mostra come abilitare immediatamente l’autenticazione IAM per un’istanza database esistente.
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--apply-immediately \
--enable-iam-database-authentication
```
Se stai ripristinando un di istanze DB, usa uno dei seguenti AWS CLI comandi:
+ `[restore-db-instance-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)`
+ `[restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)`
L’impostazione di autenticazione del database IAM corrisponde a quella della snapshot origine. Per modificare questa impostazione, imposta l’opzione `--enable-iam-database-authentication` or `--no-enable-iam-database-authentication`, come appropriato.
## API RDS
Per creare una nuova istanza database con autenticazione IAM tramite l’API, utilizzare l’operazione API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). Imposta il parametro `EnableIAMDatabaseAuthentication` su `true`.
Per aggiornare un’istanza database esistente in modo da abilitare l’autenticazione IAM, utilizzare l’operazione API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html). Imposta il parametro `EnableIAMDatabaseAuthentication` su `true` per abilitare l’autenticazione IAM o su `false` per disabilitarla.
**Nota**
Verifica che l’istanza database sia compatibile con l’autenticazione IAM. Controllare i requisiti di compatibilità in [Disponibilità di regioni e versioni](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Se ripristini un’istanza database, usa una delle operazioni API seguenti:
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)
L’impostazione di autenticazione del database IAM corrisponde a quella della snapshot origine. Per modificare questa impostazione, imposta il parametro `EnableIAMDatabaseAuthentication` su `true` per abilitare l’autenticazione IAM o su `false` per disabilitarla.
# Creazione e utilizzo di una policy IAM per l'accesso al database IAM
Per permettere a un utente o un ruolo di connettersi all'istanza database, devi creare una policy IAM. Dopo questa operazione, collega la policy a un set di autorizzazioni o un ruolo.
**Nota**
Per ulteriori informazioni sulle policy IAM, consulta [Gestione accessi e identità per Amazon RDS](UsingWithRDS.IAM.md).
La policy nell'esempio seguente permette a un utente di connettersi a un'istanza database tramite l'autenticazione database IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:db-ABCDEFGHIJKL01234/db_user"
]
}
]
}
```
------
**Importante**
Un utente con le autorizzazioni di amministratore può accedere alle istanze database senza una policy IAM esplicita. Se vuoi limitare l'accesso come amministratore a di istanze, puoi creare un ruolo IAM con le autorizzazioni appropriate, con privilegi minori e assegnarlo all'amministratore.
**Nota**
Non confondere il prefisso `rds-db:` con altri prefissi di operazione API RDS che iniziano con `rds:`. Utilizzi il prefisso `rds-db:` e l'operazione `rds-db:connect` solo per l'autenticazione database IAM. Non sono validi in altri contesti.
La policy di esempio include una singola istruzione con i seguenti elementi:
+ `Effect` – Specifica `Allow` per concedere l'accesso all'istanza database. Se non si concede esplicitamente l'accesso, questo viene rifiutato per impostazione predefinita.
+ `Action` – Specifica `rds-db:connect` per consentire le connessioni al dell'istanza database.
+ `Resource` – Specifica un Amazon Resource Name (ARN) che descrive un account database in un'istanza database. Di seguito è riportato il formato ARN.
```
arn:aws:rds-db:region:account-id:dbuser:DbiResourceId/db-user-name
```
In questo formato, sostituisci quanto segue:
+ `region`è la AWS regione per il di istanze DB. Nella politica di esempio, la AWS regione è`us-east-2`.
+ `account-id`è il numero di AWS account per il di istanze DB. Nella policy di esempio, il numero di account è `1234567890`. L'utente deve essere nello stesso account dell'account dell'istanza database.
Per eseguire l'accesso multi-account, crea un ruolo IAM con la policy mostrata in precedenza nell'account per l'istanza database e consenti all'altro account di assumere il ruolo.
+ `DbiResourceId` è l'identificatore del dell'istanza database. Questo identificatore è unico per una AWS regione e non cambia mai. Nella policy di esempio, l'identificatore è `db-ABCDEFGHIJKL01234`.
Per trovare un ID di risorsa del di istanze DB in Amazon RDS Aurora, scegli il cluster di DB per visualizzarne i dettagli. Quindi seleziona la scheda **Configuration (Configurazione)**. **Resource ID (ID risorsa)** è visualizzato nella sezione **Configuration (Configurazione)**.
In alternativa, puoi utilizzare il AWS CLI comando per elencare gli identificatori e le risorse IDs per tutto il di istanze DB nella AWS regione corrente, come illustrato di seguito.
```
aws rds describe-db-instances --query "DBInstances[*].[DBInstanceIdentifier,DbiResourceId]"
```
Se utilizzi Amazon Aurora, specifica `DbClusterResourceId` anziché `DbiResourceId`. Per ulteriori informazioni, consulta [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html) nella *Guida per l'utente di Amazon Aurora*.
**Nota**
Se si sta effettuando la connessione a un database tramite proxy RDS, specificare l'ID risorsa proxy, ad esempio `prx-ABCDEFGHIJKL01234`. Per informazioni sull'utilizzo dell'autenticazione del database IAM con proxy RDS, vedere [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
+ `db-user-name` è il nome dell'account database da associare all'autenticazione IAM. Nella policy di esempio, l'account database è `db_user`.
È possibile crearne altri ARNs per supportare vari modelli di accesso. La policy seguente permette l'accesso a due diversi account database in un dell'istanza database.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/jane_doe",
"arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/mary_roe"
]
}
]
}
```
------
La seguente politica utilizza il carattere «\$1» per abbinare tutte le istanze DB, i account di database per un account e una regione particolari AWS . AWS
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:*/*"
]
}
]
}
```
------
La seguente politica corrisponde a tutti i di istanze DB per un account e una regione particolari AWS . AWS Tuttavia, la policy concede l'accesso solo a istanze database che hanno un account database `jane_doe`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:*/jane_doe"
]
}
]
}
```
------
L'utente o il ruolo ha accesso solo a quei database ai quali l'utente ha accesso. Supponiamo, ad esempio, che il dell'istanza database abbia un database denominato *dev* e un altro database denominato *test*. Se l'utente del database `jane_doe` ha accesso solo a *dev*, anche qualsiasi utente o ruolo che accede all'istanza database con l'utente `jane_doe` ha accesso solo a *dev*. Questa restrizione dell'accesso è anche valida per altri oggetti database, come tabelle, visualizzazioni e così via.
Un amministratore deve creare policy IAM che concedono alle entità l'autorizzazione per eseguire operazioni API specifiche sulle risorse specificate di cui hanno bisogno. L'amministratore deve quindi collegare queste policy ai set di autorizzazioni o ai ruoli che richiedono tali autorizzazioni. Per esempi di policy, consulta [Esempi di policy di Amazon RDS basate su identità](security_iam_id-based-policy-examples.md).
## Collegamento di una policy IAM a un set di autorizzazioni o un ruolo
Dopo aver creato una policy IAM per consentire l'autenticazione del database, devi collegare la policy a un set di autorizzazioni o un ruolo. Per un tutorial su questo argomento, consulta [ Creare e collegare la tua prima policy gestita dal cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) nella *Guida per l'utente IAM*.
Durante il tutorial, puoi utilizzare uno degli esempi di policy indicati in questa sezione come punto di partenza e personalizzarli in base alle tue esigenze. Al termine del tutorial, avrai un set di autorizzazioni con una policy collegata che può utilizzare l'operazione `rds-db:connect`.
**Nota**
Puoi mappare più set di autorizzazioni o ruoli allo stesso account utente del database. Ad esempio, supponiamo che la policy IAM abbia specificato la seguente risorsa ARN.
```
arn:aws:rds-db:us-east-2:123456789012:dbuser:db-12ABC34DEFG5HIJ6KLMNOP78QR/jane_doe
```
Se colleghi la policy agli utenti *Jane*, *Bob* e *Diego*, ciascuno di quegli utenti potrà connettersi all'istanza database specificato utilizzando l'account di database `jane_doe`.
# Creazione di un account database tramite l’autenticazione IAM
Con l’autenticazione database IAM, non devi assegnare password di database agli account utente che crei. Se rimuovi un utente mappato a un account database, devi anche rimuovere l’account database con l’istruzione `DROP USER`.
**Nota**
Il nome utente utilizzato per l’autenticazione IAM deve avere lo stesso formato maiuscolo/minuscolo del nome utente nel database.
**Topics**
+ [
## Utilizzo dell’autenticazione IAM con MariaDB e MySQL
](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [
## Utilizzo dell'autenticazione IAM con
](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)
## Utilizzo dell’autenticazione IAM con MariaDB e MySQL
Con MariadB e MySQL, l'autenticazione è `AWSAuthenticationPlugin` gestita AWS da un plug-in fornito che funziona perfettamente con IAM per autenticare gli utenti. Connettiti all’istanza database come utente master o altro utente che può creare utenti e concedere privilegi. Dopo la connessione, immetti l’istruzione `CREATE USER`, come mostrato nell’esempio seguente.
```
CREATE USER 'jane_doe' IDENTIFIED WITH AWSAuthenticationPlugin AS 'RDS';
```
La clausola `IDENTIFIED WITH` permette a MariaDB e MySQL di utilizzare `AWSAuthenticationPlugin` per autenticare l’account database (`jane_doe`). La clausola `AS 'RDS'` fa riferimento al metodo di autenticazione. Assicurarsi che il nome utente del database specificato sia lo stesso di una risorsa nella policy IAM per l’accesso al database IAM. Per ulteriori informazioni, consulta [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md).
**Nota**
`ERROR 1524 (HY000): Plugin 'AWSAuthenticationPlugin' is not loaded`
Per correggere questo errore, assicurati di usare una configurazione supportata e di aver abilitato l’autenticazione database IAM nell’istanza database. Per ulteriori informazioni, consulta [Disponibilità di regioni e versioni](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) e [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md).
Dopo aver creato un account utilizzando `AWSAuthenticationPlugin`, lo gestisci nello stesso modo di altri account database. Ad esempio, puoi modificare i privilegi di account con le istruzioni `GRANT` e `REVOKE` o modificare vari attributi di account con l’istruzione `ALTER USER`.
Il traffico di rete del database viene SSL/TLS crittografato utilizzando IAM. Per consentire le connessioni SSL, modifica l’account utente con il comando seguente.
```
ALTER USER 'jane_doe'@'%' REQUIRE SSL;
```
## Utilizzo dell'autenticazione IAM con
Per utilizzare l’autenticazione IAM con PostgreSQL, connettiti all’istanza database come utente master o altro utente che può creare utenti e concedere privilegi. Dopo la connessione, crea gli utenti di database e autorizza il ruolo `rds_iam`, come mostrato nell’esempio seguente.
```
CREATE USER db_userx;
GRANT rds_iam TO db_userx;
```
Assicurarsi che il nome utente del database specificato sia lo stesso di una risorsa nella policy IAM per l’accesso al database IAM. Per ulteriori informazioni, consulta [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). È necessario fornire il ruolo `rds_iam` per utilizzare l’autenticazione IAM. È possibile utilizzare anche appartenenze nidificate o concessioni indirette del ruolo.
# Connessione all'istanza tramite l'autenticazione IAM
Con l'autenticazione database IAM devi usare un token di autenticazione per la connessione all'istanza. Un *token di autenticazione* è una stringa unica di caratteri che utilizzi invece di una password. Trascorsi 15 minuti dalla sua creazione, un token di autenticazione scade. Se cerchi di eseguire la connessione utilizzando un token scaduto la richiesta di connessione viene negata.
Ogni token di autenticazione deve essere accompagnato da una firma valida, utilizzando AWS Signature Version 4. Per ulteriori informazioni, consulta [Processo di firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in *Riferimenti generali di AWS*. La AWS CLI e un SDK AWS, come AWS SDK per Java o AWS SDK per Python (Boto3), possono firmare automaticamente ogni token che viene creato.
Poi usare un token di autenticazione quando ti connetti ad Amazon RDS da un altro servizio AWS, ad esempio AWS Lambda. Utilizzando un token, eviti di inserire una password nel codice. In alternativa, puoi utilizzare l'SDK AWS per creare e firmare in modo programmatico un token di autenticazione.
Quando hai un token di autenticazione IAM firmato, puoi connetterti a un'istanza database Amazon RDS. Di seguito vengono fornite informazioni su come eseguire questa operazione tramite uno strumento a riga di comando o un SDK AWS, come AWS SDK per Java o AWS SDK per Python (Boto3).
Per ulteriori informazioni, consulta il seguente post sul blog:
+ [Uso dell'autenticazione IAM per la connessione con SQL Workbench/J a Aurora MySQL o Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/).
+ [Utilizzo dell'autenticazione IAM per connettersi con pgAdmin Amazon Aurora PostgreSQL o Amazon RDS for PostgreSQL](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/)
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione al di istanzaDB utilizzando l'autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Topics**
+ [
# Connessione al dell’istanza database utilizzando l’autenticazione IAM con i driver AWS
](IAMDBAuth.Connecting.Drivers.md)
+ [
# Connessione al di istanze DB utilizzando l'autenticazione IAM dalla riga di comando: AWS CLI e il client mysql
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [
# Connessione al di istanze DB utilizzando l'autenticazione IAM dalla riga di comando: AWS CLI e il client psql
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [
# Connessione al di istanze DB utilizzando l'autenticazione IAM e AWS SDK per .NET
](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [
# Connessione al di istanze DB utilizzando l'autenticazione IAM e AWS SDK per Go
](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [
# Connessione al di istanze DB utilizzando l'autenticazione IAM e il AWS SDK per Java
](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [
# Connessione al di istanze DB utilizzando l'autenticazione IAM e il AWS SDK per Python (Boto3)
](UsingWithRDS.IAMDBAuth.Connecting.Python.md)
# Connessione al dell’istanza database utilizzando l’autenticazione IAM con i driver AWS
La suite di driver AWS è stata progettata per consentire tempi di switchover e failover più rapidi e per eseguire l’autenticazione con Gestione dei segreti AWS, AWS Identity and Access Management (IAM) e l’identità federata. I driver AWS si basano sul monitoraggio dello stato dell’istanza database e conoscono la topologia dell’istanza per determinare la nuova istanza di scrittura. Questo approccio riduce i tempi di switchover e failover a meno di dieci secondi, rispetto alle decine di secondi necessari per i driver open source.
Per ulteriori informazioni sui driver AWS, consulta il driver del linguaggio corrispondente per l’istanza database [RDS per MariaDB](MariaDB.Connecting.Drivers.md#MariaDB.Connecting.JDBCDriver), [RDS per MySQL](MySQL.Connecting.Drivers.md#MySQL.Connecting.JDBCDriver) o [RDS per PostgreSQL](PostgreSQL.Connecting.JDBCDriver.md).
**Nota**
Le uniche funzionalità supportate per RDS per MariaDB sono l’autenticazione Gestione dei segreti AWS, AWS Identity and Access Management (IAM) e l’identità federata.
# Connessione al di istanze DB utilizzando l'autenticazione IAM dalla riga di comando: AWS CLI e il client mysql
Puoi connetterti dalla riga di comando a un cluster DB di istanze Amazon RDS con AWS CLI lo strumento da riga di comando `mysql` and come descritto di seguito.
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione al di istanzaDB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Nota**
Per informazioni sulla connessione al database tramite SQL Workbench/J con autenticazione IAM, consulta il post del blog [Use IAM authentication to connect with SQL Workbench/J to Aurora MySQL o Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/).
**Topics**
+ [
## Generazione di un token di autenticazione IAM
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken)
+ [
## Connessione a un’istanza database
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect)
## Generazione di un token di autenticazione IAM
L'esempio seguente mostra come ottenere un token di autenticazione firmato utilizzando AWS CLI.
```
aws rds generate-db-auth-token \
--hostname rdsmysql.123456789012.us-west-2.rds.amazonaws.com \
--port 3306 \
--region us-west-2 \
--username jane_doe
```
Nell'esempio, i parametri sono come segue:
+ `--hostname` – Nome host dell'istanza database cui vuoi accedere.
+ `--port` – Numero di porta usato per la connessione al cluster
+ `--region`
+ `--username` – L'account database cui vuoi accedere.
I primi caratteri del token hanno il seguente aspetto.
```
rdsmysql.123456789012.us-west-2.rds.amazonaws.com:3306/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint dell'istanza databaseper generare il token di autenticazione.
## Connessione a un’istanza database
Il formato generale per la connessione è visualizzato di seguito.
```
mysql --host=hostName --port=portNumber --ssl-ca=full_path_to_ssl_certificate --enable-cleartext-plugin --user=userName --password=authToken
```
I parametri sono i seguenti:
+ `--host` – Nome host dell'istanza database cui vuoi accedere.
+ `--port` – Numero di porta usato per la connessione al cluster
+ `--ssl-ca` – Il percorso completo del file del certificato SSL che contiene la chiave pubblica
Per ulteriori informazioni sul SSL/TLS supporto per MariadB, consulta. [Supporto di SSL/TLS per le istanze database MariaDB in Amazon RDS](MariaDB.Concepts.SSLSupport.md)
Per ulteriori informazioni sul SSL/TLS supporto per MySQL, vedere. [Supporto di SSL/TLS per le istanze database MySQL in Amazon RDS](MySQL.Concepts.SSLSupport.md)
Per scaricare un certificato SSL consulta [](UsingWithRDS.SSL.md)
+ `--enable-cleartext-plugin` – Valore che specifica che per la connessione deve essere usato `AWSAuthenticationPlugin`.
Se si utilizza un client MariaDB, l'opzione `--enable-cleartext-plugin` non è richiesta.
+ `--user` – L'account database cui vuoi accedere.
+ `--password` – Token di autenticazione IAM firmato.
Il token di autenticazione consiste in diverse centinaia di caratteri. Può essere macchinoso nella riga di comando. Una soluzione è di salvare il token in una variabile di ambiente e utilizzare quella variabile durante la connessione. L'esempio seguente mostra un modo per eseguire questa soluzione. Nell'esempio, */sample\$1dir/* è il percorso completo del file del certificato SSL che contiene la chiave pubblica.
```
RDSHOST="mysqldb.123456789012.us-east-1.rds.amazonaws.com"
TOKEN="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 3306 --region us-west-2 --username jane_doe )"
mysql --host=$RDSHOST --port=3306 --ssl-ca=/sample_dir/global-bundle.pem --enable-cleartext-plugin --user=jane_doe --password=$TOKEN
```
Quando si esegue la connessione utilizzando `AWSAuthenticationPlugin`, la connessione viene protetta utilizzando SSL. Per verificare ciò, digita quanto segue al prompt del comando `mysql>`.
```
show status like 'Ssl%';
```
Le righe seguenti nell'output mostrano più dettagli.
```
+---------------+-------------+
| Variable_name | Value |
+---------------+-------------+
| ... | ...
| Ssl_cipher | AES256-SHA |
| ... | ...
| Ssl_version | TLSv1.1 |
| ... | ...
+-----------------------------+
```
Se desideri connetterti a un'istanza database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connessione al di istanze DB utilizzando l'autenticazione IAM dalla riga di comando: AWS CLI e il client psql
Puoi eseguire la connessione dalla riga di comando a una istanza database Amazon RDS for PostgreSQL con AWS CLI e lo strumento a riga di comando psql come descritto di seguito.
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione al di istanzaDB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Nota**
Per informazioni sulla connessione al database tramite pgAdmin con autenticazione IAM, consulta il post sul blog [Utilizzo dell'autenticazione IAM per connettersi con PGadmin Amazon Aurora PostgreSQL o Amazon RDS for PostgreSQL](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/).
**Topics**
+ [
## Generazione di un token di autenticazione IAM
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL)
+ [
## Connessione a un'istanza Amazon RDS PostgreSQL
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL)
## Generazione di un token di autenticazione IAM
Il token di autenticazione è costituito da diverse centinaia di caratteri, quindi può essere complesso nella riga di comando. Una soluzione è di salvare il token in una variabile di ambiente e utilizzare quella variabile durante la connessione. L'esempio seguente mostra come utilizzare il AWS CLI per ottenere un token di autenticazione firmato utilizzando il `generate-db-auth-token` comando e archiviarlo in una variabile di `PGPASSWORD` ambiente.
```
export RDSHOST="rdspostgres.123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
```
Nell'esempio, i parametri per il comando `generate-db-auth-token` sono i seguenti:
+ `--hostname` – Nome host dell'istanza database cui desideri accedere.
+ `--port` – Numero di porta usato per la connessione al cluster
+ `--region`— La AWS regione in cui è in esecuzione il di istanze DB
+ `--username` – L'account database cui vuoi accedere.
I primi caratteri del token generato hanno il seguente aspetto.
```
rdspostgres.123456789012.us-west-2.rds.amazonaws.com:5432/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint dell'istanza databaseper generare il token di autenticazione.
## Connessione a un'istanza Amazon RDS PostgreSQL
Di seguito è mostrato il formato generale per l'utilizzo di psql per la connessione.
```
psql "host=hostName port=portNumber sslmode=verify-full sslrootcert=full_path_to_ssl_certificate dbname=DBName user=userName password=authToken"
```
I parametri sono i seguenti:
+ `host` – Nome host dell'istanza database cui desideri accedere.
+ `port` – Numero di porta usato per la connessione al cluster
+ `sslmode` – Modalità SSL da utilizzare.
Quando si utilizza `sslmode=verify-full`, la connessione SSL verifica l'endpoint dell'istanza database rispetto a quello nel certificato SSL.
+ `sslrootcert` – Il percorso completo del file del certificato SSL che contiene la chiave pubblica
Per ulteriori informazioni, consulta [Utilizzo del protocollo SSL con un'istanza database PostgreSQL](PostgreSQL.Concepts.General.SSL.md).
Per scaricare un certificato SSL consulta [](UsingWithRDS.SSL.md)
+ `dbname` – Database a cui accedere.
+ `user` – L'account database cui vuoi accedere.
+ `password` – Token di autenticazione IAM firmato.
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint dell'istanza databaseper generare il token di autenticazione.
L'esempio seguente mostra l'utilizzo di psql per la connessione. Nell'esempio, psql utilizza la variabile d'ambiente `RDSHOST` per l'host e la variabile d'ambiente `PGPASSWORD` per il token generato. Inoltre, */sample\$1dir/* è il percorso completo del file del certificato SSL che contiene la chiave pubblica.
```
export RDSHOST="rdspostgres.123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
psql "host=$RDSHOST port=5432 sslmode=verify-full sslrootcert=/sample_dir/global-bundle.pem dbname=DBName user=jane_doe password=$PGPASSWORD"
```
Se desideri connetterti a un’istanza database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connessione al di istanze DB utilizzando l'autenticazione IAM e AWS SDK per .NET
È possibile connettersi a un cluster RDS per MariaDB, MySQL o PostgreSQL DB con Aurora MySQL o DB come descritto di seguito. AWS SDK per .NET
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione al di istanzaDB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Esempi**
Il seguente esempio di codice mostra come generare un token di autenticazione e utilizzarlo per eseguire la connessione a un'istanza del database.
Per eseguire questo esempio di codice, è necessario il file, trovato sul sito. [AWS SDK per .NET](https://aws.amazon.com/sdk-for-net/) AWS I pacchetti `AWSSDK.CORE` e `AWSSDK.RDS` sono obbligatori. Per connetterti a un di istanze DB, usa il connettore di database.NET per il motore DB, ad esempio MySqlConnector per MariaDB o MySQL, o Npgsql per PostgreSQL.
Questo codice si connette a un'istanza database MariaDB o MySQL. Modifica i valori delle variabili seguenti in base alle esigenze.
+ `server`: l'endpoint dell'istanza database cui vuoi accedere
+ `user` – L'account database cui vuoi accedere.
+ `database` – Database a cui accedere.
+ `port` – Numero di porta usato per la connessione al cluster
+ `SslMode` – Modalità SSL da utilizzare.
Quando si utilizza `SslMode=Required`, la connessione SSL verifica l'endpoint dell'istanza database rispetto a quello nel certificato SSL.
+ `SslCa` - Percorso completo del certificato SSL per Amazon RDS
Per scaricare un certificato, consultare [](UsingWithRDS.SSL.md).
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint dell'istanza databaseper generare il token di autenticazione.
```
using System;
using System.Data;
using MySql.Data;
using MySql.Data.MySqlClient;
using Amazon;
namespace ubuntu
{
class Program
{
static void Main(string[] args)
{
var pwd = Amazon.RDS.Util.RDSAuthTokenGenerator.GenerateAuthToken(RegionEndpoint.USEast1, "mysqldb.123456789012.us-east-1.rds.amazonaws.com", 3306, "jane_doe");
// for debug only Console.Write("{0}\n", pwd); //this verifies the token is generated
MySqlConnection conn = new MySqlConnection($"server=mysqldb.123456789012.us-east-1.rds.amazonaws.com;user=jane_doe;database=mydB;port=3306;password={pwd};SslMode=Required;SslCa=full_path_to_ssl_certificate");
conn.Open();
// Define a query
MySqlCommand sampleCommand = new MySqlCommand("SHOW DATABASES;", conn);
// Execute a query
MySqlDataReader mysqlDataRdr = sampleCommand.ExecuteReader();
// Read all rows and output the first column in each row
while (mysqlDataRdr.Read())
Console.WriteLine(mysqlDataRdr[0]);
mysqlDataRdr.Close();
// Close connection
conn.Close();
}
}
}
```
Questo codice si connette a un'istanza database PostgreSQL.
Modifica i valori delle variabili seguenti in base alle esigenze.
+ `Server`: l'endpoint dell'istanza database cui vuoi accedere
+ `User ID` – L'account database cui vuoi accedere.
+ `Database` – Database a cui accedere.
+ `Port` – Numero di porta usato per la connessione al cluster
+ `SSL Mode` – Modalità SSL da utilizzare.
Quando si utilizza `SSL Mode=Required`, la connessione SSL verifica l'endpoint dell'istanza database rispetto a quello nel certificato SSL.
+ `Root Certificate` - Percorso completo del certificato SSL per Amazon RDS
Per scaricare un certificato, consultare [](UsingWithRDS.SSL.md).
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint dell'istanza databaseper generare il token di autenticazione.
```
using System;
using Npgsql;
using Amazon.RDS.Util;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
var pwd = RDSAuthTokenGenerator.GenerateAuthToken("postgresmydb.123456789012.us-east-1.rds.amazonaws.com", 5432, "jane_doe");
// for debug only Console.Write("{0}\n", pwd); //this verifies the token is generated
NpgsqlConnection conn = new NpgsqlConnection($"Server=postgresmydb.123456789012.us-east-1.rds.amazonaws.com;User Id=jane_doe;Password={pwd};Database=mydb;SSL Mode=Require;Root Certificate=full_path_to_ssl_certificate");
conn.Open();
// Define a query
NpgsqlCommand cmd = new NpgsqlCommand("select count(*) FROM pg_user", conn);
// Execute a query
NpgsqlDataReader dr = cmd.ExecuteReader();
// Read all rows and output the first column in each row
while (dr.Read())
Console.Write("{0}\n", dr[0]);
// Close connection
conn.Close();
}
}
}
```
Se desideri connetterti a un’istanza database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connessione al di istanze DB utilizzando l'autenticazione IAM e AWS SDK per Go
È possibile connettersi a un cluster RDS per MariaDB, MySQL o PostgreSQL DB con Aurora MySQL o DB come descritto di seguito. AWS SDK per Go
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione al di istanzaDB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Esempi**
Per eseguire questi esempi di codice, è necessario il file, trovato sul sito. [AWS SDK per Go](https://aws.amazon.com/sdk-for-go/) AWS
Modifica i valori delle variabili seguenti in base alle esigenze.
+ `dbName` – Database a cui accedere.
+ `dbUser` – L'account database cui vuoi accedere.
+ `dbHost`: l'endpoint dell'istanza database cui vuoi accedere
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint dell'istanza databaseper generare il token di autenticazione.
+ `dbPort` – Numero di porta usato per la connessione al cluster
+ `region`— La AWS regione in cui è in esecuzione il di istanze DB
Inoltre, assicurarsi che le librerie importate nel codice di esempio esistano nel sistema.
**Importante**
Negli esempi riportati in questa sezione viene utilizzato il codice seguente per fornire credenziali che accedono a un database da un ambiente locale:
`creds := credentials.NewEnvCredentials()`
Se accedi a un database da un AWS servizio, come Amazon EC2 o Amazon ECS, puoi sostituire il codice con il seguente codice:
`sess := session.Must(session.NewSession())`
`creds := sess.Config.Credentials`
Se si apporta questa modifica, assicurarsi di aggiungere la seguente importazione:
`"github.com/aws/aws-sdk-go/aws/session"`
**Topics**
+ [
## Connessione tramite autenticazione IAM e V2 AWS SDK per Go
](#UsingWithRDS.IAMDBAuth.Connecting.GoV2)
+ [
## Connessione tramite autenticazione IAM e AWS SDK per Go V1.
](#UsingWithRDS.IAMDBAuth.Connecting.GoV1)
## Connessione tramite autenticazione IAM e V2 AWS SDK per Go
È possibile connettersi a un di istanze DB utilizzando l'autenticazione IAM e la AWS SDK per Go V2.
Il seguente esempio di codice mostra come generare un token di autenticazione e utilizzarlo per eseguire la connessione a un'istanza del database.
Questo codice si connette a un'istanza database MariaDB o MySQL.
```
package main
import (
"context"
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/go-sql-driver/mysql"
)
func main() {
var dbName string = "DatabaseName"
var dbUser string = "DatabaseUser"
var dbHost string = "mysqldb.123456789012.us-east-1.rds.amazonaws.com"
var dbPort int = 3306
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = "us-east-1"
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authenticationToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Questo codice si connette a un'istanza database PostgreSQL.
```
package main
import (
"context"
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/lib/pq"
)
func main() {
var dbName string = "DatabaseName"
var dbUser string = "DatabaseUser"
var dbHost string = "postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
var dbPort int = 5432
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = "us-east-1"
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
dbHost, dbPort, dbUser, authenticationToken, dbName,
)
db, err := sql.Open("postgres", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Se desideri connetterti a un'istanza database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
## Connessione tramite autenticazione IAM e AWS SDK per Go V1.
È possibile connettersi a un di istanze DB utilizzando l'autenticazione IAM e la AWS SDK per Go V1
Il seguente esempio di codice mostra come generare un token di autenticazione e utilizzarlo per eseguire la connessione a un'istanza del database.
Questo codice si connette a un'istanza database MariaDB o MySQL.
```
package main
import (
"database/sql"
"fmt"
"log"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/service/rds/rdsutils"
_ "github.com/go-sql-driver/mysql"
)
func main() {
dbName := "app"
dbUser := "jane_doe"
dbHost := "mysqldb.123456789012.us-east-1.rds.amazonaws.com"
dbPort := 3306
dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
region := "us-east-1"
creds := credentials.NewEnvCredentials()
authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
if err != nil {
panic(err)
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Questo codice si connette a un'istanza database PostgreSQL.
```
package main
import (
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/service/rds/rdsutils"
_ "github.com/lib/pq"
)
func main() {
dbName := "app"
dbUser := "jane_doe"
dbHost := "postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
dbPort := 5432
dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
region := "us-east-1"
creds := credentials.NewEnvCredentials()
authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
if err != nil {
panic(err)
}
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
dbHost, dbPort, dbUser, authToken, dbName,
)
db, err := sql.Open("postgres", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Se desideri connetterti a un'istanza database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connessione al di istanze DB utilizzando l'autenticazione IAM e il AWS SDK per Java
È possibile connettersi a un cluster RDS per MariaDB, MySQL o PostgreSQL DB con Aurora MySQL o DB come descritto di seguito. AWS SDK per Java
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione al di istanzaDB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Configurare l' AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)
Per esempi su come utilizzare l’SDK per Java 2.x, consulta [Esempi per Amazon RDS con SDK per Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html). [Puoi anche usare AWS Advanced JDBC Wrapper, consulta AWS la documentazione di Advanced JDBC Wrapper.](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/Documentation.md)
**Topics**
+ [
## Generazione di un token di autenticazione IAM
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken)
+ [
## Creazione manuale di un token di autenticazione IAM
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2)
+ [
## Connessione a un’istanza database
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect)
## Generazione di un token di autenticazione IAM
Se state scrivendo programmi utilizzando il AWS SDK per Java, potete ottenere un token di autenticazione firmato utilizzando la classe. `RdsIamAuthTokenGenerator` L'utilizzo di questa classe richiede l'immissione di AWS credenziali. A tale scopo, create un'istanza della `DefaultAWSCredentialsProviderChain` classe. `DefaultAWSCredentialsProviderChain`utilizza la prima chiave di AWS accesso e la chiave segreta che trova nella [catena di provider di credenziali predefinita](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default). Per ulteriori informazioni sulle chiavi di accesso AWS , consulta [Gestione delle chiavi di accesso per gli utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint dell'istanza databaseper generare il token di autenticazione.
Dopo aver creato un’istanza di `RdsIamAuthTokenGenerator`, puoi chiamare il metodo `getAuthToken` per ottenere un token firmato. Specifica la regione AWS , il nome host, il numero di porta e il nome utente. Il seguente esempio di codice dimostra come eseguire questa operazione.
```
package com.amazonaws.codesamples;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
public class GenerateRDSAuthToken {
public static void main(String[] args) {
String region = "us-west-2";
String hostname = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
String port = "3306";
String username = "jane_doe";
System.out.println(generateAuthToken(region, hostname, port, username));
}
static String generateAuthToken(String region, String hostName, String port, String username) {
RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
.credentials(new DefaultAWSCredentialsProviderChain())
.region(region)
.build();
String authToken = generator.getAuthToken(
GetIamAuthTokenRequest.builder()
.hostname(hostName)
.port(Integer.parseInt(port))
.userName(username)
.build());
return authToken;
}
}
```
## Creazione manuale di un token di autenticazione IAM
In Java, il modo più semplice di generare un token di autenticazione è di utilizzare `RdsIamAuthTokenGenerator`. Questa classe crea un token di autenticazione per te, quindi lo firma utilizzando la versione 4 AWS della firma. Per ulteriori informazioni, consulta la pagina relativa al [processo di firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) nella *Riferimenti generali di AWS*.
Tuttavia, puoi anche creare e firmare un token di autenticazione manualmente, come visualizzato nel seguente esempio di codice.
```
package com.amazonaws.codesamples;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.SigningAlgorithm;
import com.amazonaws.util.BinaryUtils;
import org.apache.commons.lang3.StringUtils;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.SortedMap;
import java.util.TreeMap;
import static com.amazonaws.auth.internal.SignerConstants.AWS4_TERMINATOR;
import static com.amazonaws.util.StringUtils.UTF8;
public class CreateRDSAuthTokenManually {
public static String httpMethod = "GET";
public static String action = "connect";
public static String canonicalURIParameter = "/";
public static SortedMap canonicalQueryParameters = new TreeMap();
public static String payload = StringUtils.EMPTY;
public static String signedHeader = "host";
public static String algorithm = "AWS4-HMAC-SHA256";
public static String serviceName = "rds-db";
public static String requestWithoutSignature;
public static void main(String[] args) throws Exception {
String region = "us-west-2";
String instanceName = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
String port = "3306";
String username = "jane_doe";
Date now = new Date();
String date = new SimpleDateFormat("yyyyMMdd").format(now);
String dateTimeStamp = new SimpleDateFormat("yyyyMMdd'T'HHmmss'Z'").format(now);
DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
String awsAccessKey = creds.getCredentials().getAWSAccessKeyId();
String awsSecretKey = creds.getCredentials().getAWSSecretKey();
String expiryMinutes = "900";
System.out.println("Step 1: Create a canonical request:");
String canonicalString = createCanonicalString(username, awsAccessKey, date, dateTimeStamp, region, expiryMinutes, instanceName, port);
System.out.println(canonicalString);
System.out.println();
System.out.println("Step 2: Create a string to sign:");
String stringToSign = createStringToSign(dateTimeStamp, canonicalString, awsAccessKey, date, region);
System.out.println(stringToSign);
System.out.println();
System.out.println("Step 3: Calculate the signature:");
String signature = BinaryUtils.toHex(calculateSignature(stringToSign, newSigningKey(awsSecretKey, date, region, serviceName)));
System.out.println(signature);
System.out.println();
System.out.println("Step 4: Add the signing info to the request");
System.out.println(appendSignature(signature));
System.out.println();
}
//Step 1: Create a canonical request date should be in format YYYYMMDD and dateTime should be in format YYYYMMDDTHHMMSSZ
public static String createCanonicalString(String user, String accessKey, String date, String dateTime, String region, String expiryPeriod, String hostName, String port) throws Exception {
canonicalQueryParameters.put("Action", action);
canonicalQueryParameters.put("DBUser", user);
canonicalQueryParameters.put("X-Amz-Algorithm", "AWS4-HMAC-SHA256");
canonicalQueryParameters.put("X-Amz-Credential", accessKey + "%2F" + date + "%2F" + region + "%2F" + serviceName + "%2Faws4_request");
canonicalQueryParameters.put("X-Amz-Date", dateTime);
canonicalQueryParameters.put("X-Amz-Expires", expiryPeriod);
canonicalQueryParameters.put("X-Amz-SignedHeaders", signedHeader);
String canonicalQueryString = "";
while(!canonicalQueryParameters.isEmpty()) {
String currentQueryParameter = canonicalQueryParameters.firstKey();
String currentQueryParameterValue = canonicalQueryParameters.remove(currentQueryParameter);
canonicalQueryString = canonicalQueryString + currentQueryParameter + "=" + currentQueryParameterValue;
if (!currentQueryParameter.equals("X-Amz-SignedHeaders")) {
canonicalQueryString += "&";
}
}
String canonicalHeaders = "host:" + hostName + ":" + port + '\n';
requestWithoutSignature = hostName + ":" + port + "/?" + canonicalQueryString;
String hashedPayload = BinaryUtils.toHex(hash(payload));
return httpMethod + '\n' + canonicalURIParameter + '\n' + canonicalQueryString + '\n' + canonicalHeaders + '\n' + signedHeader + '\n' + hashedPayload;
}
//Step 2: Create a string to sign using sig v4
public static String createStringToSign(String dateTime, String canonicalRequest, String accessKey, String date, String region) throws Exception {
String credentialScope = date + "/" + region + "/" + serviceName + "/aws4_request";
return algorithm + '\n' + dateTime + '\n' + credentialScope + '\n' + BinaryUtils.toHex(hash(canonicalRequest));
}
//Step 3: Calculate signature
/**
* Step 3 of the &AWS; Signature version 4 calculation. It involves deriving
* the signing key and computing the signature. Refer to
* http://docs.aws.amazon
* .com/general/latest/gr/sigv4-calculate-signature.html
*/
public static byte[] calculateSignature(String stringToSign,
byte[] signingKey) {
return sign(stringToSign.getBytes(Charset.forName("UTF-8")), signingKey,
SigningAlgorithm.HmacSHA256);
}
public static byte[] sign(byte[] data, byte[] key,
SigningAlgorithm algorithm) throws SdkClientException {
try {
Mac mac = algorithm.getMac();
mac.init(new SecretKeySpec(key, algorithm.toString()));
return mac.doFinal(data);
} catch (Exception e) {
throw new SdkClientException(
"Unable to calculate a request signature: "
+ e.getMessage(), e);
}
}
public static byte[] newSigningKey(String secretKey,
String dateStamp, String regionName, String serviceName) {
byte[] kSecret = ("AWS4" + secretKey).getBytes(Charset.forName("UTF-8"));
byte[] kDate = sign(dateStamp, kSecret, SigningAlgorithm.HmacSHA256);
byte[] kRegion = sign(regionName, kDate, SigningAlgorithm.HmacSHA256);
byte[] kService = sign(serviceName, kRegion,
SigningAlgorithm.HmacSHA256);
return sign(AWS4_TERMINATOR, kService, SigningAlgorithm.HmacSHA256);
}
public static byte[] sign(String stringData, byte[] key,
SigningAlgorithm algorithm) throws SdkClientException {
try {
byte[] data = stringData.getBytes(UTF8);
return sign(data, key, algorithm);
} catch (Exception e) {
throw new SdkClientException(
"Unable to calculate a request signature: "
+ e.getMessage(), e);
}
}
//Step 4: append the signature
public static String appendSignature(String signature) {
return requestWithoutSignature + "&X-Amz-Signature=" + signature;
}
public static byte[] hash(String s) throws Exception {
try {
MessageDigest md = MessageDigest.getInstance("SHA-256");
md.update(s.getBytes(UTF8));
return md.digest();
} catch (Exception e) {
throw new SdkClientException(
"Unable to compute hash while signing request: "
+ e.getMessage(), e);
}
}
}
```
## Connessione a un’istanza database
Il seguente esempio di codice mostra come generare un token di autenticazione e utilizzarlo per eseguire la connessione a un’istanza eseguendo MariaDB o MySQL.
Per eseguire questo esempio di codice, è necessario il [AWS SDK per Java](https://aws.amazon.com/sdk-for-java/)file, trovato sul AWS sito. Inoltre, hai bisogno di quanto segue:
+ MySQL Connector/J. Questo esempio di codice è stato testato con `mysql-connector-java-5.1.33-bin.jar`.
+ Un certificato intermedio per Amazon RDS specifico per una regione. AWS Per ulteriori informazioni, consulta [](UsingWithRDS.SSL.md). Durante il runtime, il loader della classe cerca un certificato nella stessa directory di questo esempio di codice Java, per permettere al loader della classe di trovarlo.
+ Modifica i valori delle variabili seguenti in base alle esigenze.
+ `RDS_INSTANCE_HOSTNAME`: il nome host dell’istanza database cui vuoi accedere.
+ `RDS_INSTANCE_PORT`: il numero di porta usato per la connessione all’istanza database PostgreSQL.
+ `REGION_NAME`— La AWS regione in cui è in esecuzione il di istanze DB.
+ `DB_USER`: l’account database cui vuoi accedere.
+ `SSL_CERTIFICATE`— Un certificato SSL per Amazon RDS specifico per una regione. AWS
Per scaricare un certificato per la regione AWS , consulta [](UsingWithRDS.SSL.md). Inserisci il certificato SSL nella stessa directory di questo file di programma Java, per permettere al loader di classe di trovare il certificato durante il runtime.
[Questo esempio di codice ottiene AWS le credenziali dalla catena di provider di credenziali predefinita.](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default)
**Nota**
Specifica una password per `DEFAULT_KEY_STORE_PASSWORD` diversa da quella mostrata qui come best practice di sicurezza.
```
package com.amazonaws.samples;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;
import java.net.URL;
public class IAMDatabaseAuthenticationTester {
//&AWS; Credentials of the IAM user with policy enabling IAM Database Authenticated access to the db by the db user.
private static final DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
private static final String AWS_ACCESS_KEY = creds.getCredentials().getAWSAccessKeyId();
private static final String AWS_SECRET_KEY = creds.getCredentials().getAWSSecretKey();
//Configuration parameters for the generation of the IAM Database Authentication token
private static final String RDS_INSTANCE_HOSTNAME = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
private static final int RDS_INSTANCE_PORT = 3306;
private static final String REGION_NAME = "us-west-2";
private static final String DB_USER = "jane_doe";
private static final String JDBC_URL = "jdbc:mysql://" + RDS_INSTANCE_HOSTNAME + ":" + RDS_INSTANCE_PORT;
private static final String SSL_CERTIFICATE = "rds-ca-2019-us-west-2.pem";
private static final String KEY_STORE_TYPE = "JKS";
private static final String KEY_STORE_PROVIDER = "SUN";
private static final String KEY_STORE_FILE_PREFIX = "sys-connect-via-ssl-test-cacerts";
private static final String KEY_STORE_FILE_SUFFIX = ".jks";
private static final String DEFAULT_KEY_STORE_PASSWORD = "changeit";
public static void main(String[] args) throws Exception {
//get the connection
Connection connection = getDBConnectionUsingIam();
//verify the connection is successful
Statement stmt= connection.createStatement();
ResultSet rs=stmt.executeQuery("SELECT 'Success!' FROM DUAL;");
while (rs.next()) {
String id = rs.getString(1);
System.out.println(id); //Should print "Success!"
}
//close the connection
stmt.close();
connection.close();
clearSslProperties();
}
/**
* This method returns a connection to the db instance authenticated using IAM Database Authentication
* @return
* @throws Exception
*/
private static Connection getDBConnectionUsingIam() throws Exception {
setSslProperties();
return DriverManager.getConnection(JDBC_URL, setMySqlConnectionProperties());
}
/**
* This method sets the mysql connection properties which includes the IAM Database Authentication token
* as the password. It also specifies that SSL verification is required.
* @return
*/
private static Properties setMySqlConnectionProperties() {
Properties mysqlConnectionProperties = new Properties();
mysqlConnectionProperties.setProperty("verifyServerCertificate","true");
mysqlConnectionProperties.setProperty("useSSL", "true");
mysqlConnectionProperties.setProperty("user",DB_USER);
mysqlConnectionProperties.setProperty("password",generateAuthToken());
return mysqlConnectionProperties;
}
/**
* This method generates the IAM Auth Token.
* An example IAM Auth Token would look like follows:
* btusi123---cmz7kenwo2ye---rds---cn-north-1.amazonaws.com.rproxy.goskope.com.cn:3306/?Action=connect&DBUser=iamtestuser&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20171003T010726Z&X-Amz-SignedHeaders=host&X-Amz-Expires=899&X-Amz-Credential=AKIAPFXHGVDI5RNFO4AQ%2F20171003%2Fcn-north-1%2Frds-db%2Faws4_request&X-Amz-Signature=f9f45ef96c1f770cdad11a53e33ffa4c3730bc03fdee820cfdf1322eed15483b
* @return
*/
private static String generateAuthToken() {
BasicAWSCredentials awsCredentials = new BasicAWSCredentials(AWS_ACCESS_KEY, AWS_SECRET_KEY);
RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
.credentials(new AWSStaticCredentialsProvider(awsCredentials)).region(REGION_NAME).build();
return generator.getAuthToken(GetIamAuthTokenRequest.builder()
.hostname(RDS_INSTANCE_HOSTNAME).port(RDS_INSTANCE_PORT).userName(DB_USER).build());
}
/**
* This method sets the SSL properties which specify the key store file, its type and password:
* @throws Exception
*/
private static void setSslProperties() throws Exception {
System.setProperty("javax.net.ssl.trustStore", createKeyStoreFile());
System.setProperty("javax.net.ssl.trustStoreType", KEY_STORE_TYPE);
System.setProperty("javax.net.ssl.trustStorePassword", DEFAULT_KEY_STORE_PASSWORD);
}
/**
* This method returns the path of the Key Store File needed for the SSL verification during the IAM Database Authentication to
* the db instance.
* @return
* @throws Exception
*/
private static String createKeyStoreFile() throws Exception {
return createKeyStoreFile(createCertificate()).getPath();
}
/**
* This method generates the SSL certificate
* @return
* @throws Exception
*/
private static X509Certificate createCertificate() throws Exception {
CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
URL url = new File(SSL_CERTIFICATE).toURI().toURL();
if (url == null) {
throw new Exception();
}
try (InputStream certInputStream = url.openStream()) {
return (X509Certificate) certFactory.generateCertificate(certInputStream);
}
}
/**
* This method creates the Key Store File
* @param rootX509Certificate - the SSL certificate to be stored in the KeyStore
* @return
* @throws Exception
*/
private static File createKeyStoreFile(X509Certificate rootX509Certificate) throws Exception {
File keyStoreFile = File.createTempFile(KEY_STORE_FILE_PREFIX, KEY_STORE_FILE_SUFFIX);
try (FileOutputStream fos = new FileOutputStream(keyStoreFile.getPath())) {
KeyStore ks = KeyStore.getInstance(KEY_STORE_TYPE, KEY_STORE_PROVIDER);
ks.load(null);
ks.setCertificateEntry("rootCaCertificate", rootX509Certificate);
ks.store(fos, DEFAULT_KEY_STORE_PASSWORD.toCharArray());
}
return keyStoreFile;
}
/**
* This method clears the SSL properties.
* @throws Exception
*/
private static void clearSslProperties() throws Exception {
System.clearProperty("javax.net.ssl.trustStore");
System.clearProperty("javax.net.ssl.trustStoreType");
System.clearProperty("javax.net.ssl.trustStorePassword");
}
}
```
Se desideri connetterti a un’istanza database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connessione al di istanze DB utilizzando l'autenticazione IAM e il AWS SDK per Python (Boto3)
È possibile connettersi a un cluster RDS per MariaDB, MySQL o PostgreSQL DB con Aurora MySQL o DB come descritto di seguito. AWS SDK per Python (Boto3)
**Prerequisiti**
Di seguito sono riportati i prerequisiti per la connessione al di istanzaDB utilizzando l’autenticazione IAM:
+ [Abilitazione e disabilitazione dell’autenticazione database IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creazione e utilizzo di una policy IAM per l'accesso al database IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creazione di un account database tramite l’autenticazione IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
Inoltre, assicurarsi che le librerie importate nel codice di esempio esistano nel sistema.
**Esempi**
Gli esempi di codice utilizzano i profili per le credenziali condivise. [Per informazioni sulla specificazione delle credenziali, AWS SDK per Python (Boto3) consulta Credenziali nella documentazione.](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html)
Il seguente esempio di codice mostra come generare un token di autenticazione e utilizzarlo per eseguire la connessione a un'istanza del database.
Per eseguire questo esempio di codice, è necessario il file [AWS SDK per Python (Boto3)](https://aws.amazon.com/sdk-for-python/), trovato sul sito. AWS
Modifica i valori delle variabili seguenti in base alle esigenze.
+ `ENDPOINT`: l'endpoint dell'istanza cui vuoi accedere
+ `PORT` – Numero di porta usato per la connessione al cluster
+ `USER` – L'account database cui vuoi accedere.
+ `REGION`— La AWS regione in cui è in esecuzione il di istanze DB
+ `DBNAME` – Database a cui accedere.
+ `SSLCERTIFICATE` - Percorso completo del certificato SSL per Amazon RDS
Per `ssl_ca`, specificare un certificato SSL. Per scaricare un certificato SSL consulta [](UsingWithRDS.SSL.md)
**Nota**
Non è possibile utilizzare un record DNS Route 53 personalizzato anziché l'endpoint dell'istanza databaseper generare il token di autenticazione.
Questo codice si connette a un'istanza database MariaDB o MySQL.
Prima di eseguire questo codice, installa il driver PyMy SQL seguendo le istruzioni nel [Python Package](https://pypi.org/project/PyMySQL/) Index.
```
import pymysql
import sys
import boto3
import os
ENDPOINT="mysqldb.123456789012.us-east-1.rds.amazonaws.com"
PORT="3306"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
os.environ['LIBMYSQL_ENABLE_CLEARTEXT_PLUGIN'] = '1'
#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='default')
client = session.client('rds')
token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)
try:
conn = pymysql.connect(auth_plugin_map={'mysql_clear_password':None},host=ENDPOINT, user=USER, password=token, port=PORT, database=DBNAME, ssl_ca='SSLCERTIFICATE', ssl_verify_identity=True, ssl_verify_cert=True)
cur = conn.cursor()
cur.execute("""SELECT now()""")
query_results = cur.fetchall()
print(query_results)
except Exception as e:
print("Database connection failed due to {}".format(e))
```
Questo codice si connette a un'istanza database PostgreSQL.
Prima di eseguire questo codice, installa`psycopg2`seguendo le istruzioni in [Documentazione di Psycopg](https://pypi.org/project/psycopg2/).
```
import psycopg2
import sys
import boto3
import os
ENDPOINT="postgresmydb.123456789012.us-east-1.rds.amazonaws.com"
PORT="5432"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='RDSCreds')
client = session.client('rds')
token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)
try:
conn = psycopg2.connect(host=ENDPOINT, port=PORT, database=DBNAME, user=USER, password=token, sslrootcert="SSLCERTIFICATE")
cur = conn.cursor()
cur.execute("""SELECT now()""")
query_results = cur.fetchall()
print(query_results)
except Exception as e:
print("Database connection failed due to {}".format(e))
```
Se desideri connetterti a un'istanza database tramite un proxy, consulta [Connessione a un database tramite l'autenticazione IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Risoluzione dei problemi relativi all’autenticazione database IAM
Di seguito, è possibile trovare idee per la risoluzione dei problemi comuni relativi all’autenticazione database IAM e informazioni sui log e sulle metriche di CloudWatch relativi all’autenticazione database IAM.
## Esportazione di log degli errori di autenticazione database IAM su CloudWatch Logs
I log degli errori di autenticazione database IAM sono archiviati sull’host del database e li puoi esportare nel tuo account CloudWatch Logs. Utilizza i log e i metodi di correzione in questa pagina per risolvere i problemi relativi all’autenticazione database IAM.
È possibile abilitare le esportazioni dei log verso CloudWatch Logs dalla console, dalla AWS CLI e dall’API RDS. Per istruzioni relative alla console, consulta [Pubblicazione di log di database su Amazon CloudWatch Logs](USER_LogAccess.Procedural.UploadtoCloudWatch.md).
Per esportare i log degli errori di autenticazione database IAM in CloudWatch Logs durante la modifica di un’istanza database dalla AWS CLI, usa il seguente comando:
```
aws rds create-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--db-instance-class db.t3.large \
--allocated-storage 50 \
--engine postgres \
--engine-version 16 \
--port 5432 \
--master-username master \
--master-user-password password \
--publicly-accessible \
--enable-iam-database-authentication \
--enable-cloudwatch-logs-exports=iam-db-auth-error
```
Per esportare i log degli errori di autenticazione database IAM in CloudWatch Logs durante la modifica di un’istanza database dalla AWS CLI, usa il seguente comando:
```
aws rds modify-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["iam-db-auth-error"]}'
```
Per verificare se l’istanza database sta esportando i log di autenticazione database IAM su CloudWatch Logs, controlla se il parametro `EnabledCloudwatchLogsExports` è impostato a `iam-db-auth-error` nell’output del comando `describe-db-instances`.
```
aws rds describe-db-instances --region us-east-1 --db-instance-identifier mydbinstance
...
"EnabledCloudwatchLogsExports": [
"iam-db-auth-error"
],
...
```
## Metriche CloudWatch relative all’autenticazione database IAM
Amazon RDS fornisce metriche quasi in tempo reale sull’autenticazione database IAM al tuo account Amazon CloudWatch. Nella tabella seguente sono elencati le metriche di autenticazione database IAM e le dimensioni disponibili con CloudWatch:
| Metrica | Descrizione |
| --- | --- |
| `IamDbAuthConnectionRequests` | Numero totale di richieste di connessione effettuate con l’autenticazione database IAM. |
| `IamDbAuthConnectionSuccess` | Numero totale di richieste di autenticazione database IAM riuscite. |
| `IamDbAuthConnectionFailure` | Numero totale di richieste di autenticazione database IAM non riuscite. |
| `IamDbAuthConnectionFailureInvalidToken` | Numero totale di richieste di autenticazione database IAM non riuscite a causa di un token non valido. |
| `IamDbAuthConnectionFailureInsufficientPermissions` | Numero totale di richieste di autenticazione database IAM non riuscite a causa di policy o autorizzazioni errate. |
| `IamDbAuthConnectionFailureThrottling` | Numero totale di richieste di autenticazione database IAM non riuscite a causa della limitazione (della larghezza di banda della rete) per l’autenticazione database IAM. |
| `IamDbAuthConnectionFailureServerError` | Numero totale di richieste di autenticazione database IAM non riuscite a causa di un errore interno del server nella funzionalità di autenticazione database IAM. |
## Problemi e soluzioni comuni
È possibile che si verifichino i seguenti problemi durante l’utilizzo dell’autenticazione database IAM. Utilizza i passaggi di correzione indicati nella tabella per risolvere i problemi:
| Errore | Metrica/metriche | Causa | Soluzione |
| --- | --- | --- | --- |
| `[ERROR] Failed to authenticate the connection request for user db_user because the provided token is malformed or otherwise invalid. (Status Code: 400, Error Code: InvalidToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | Il token di autenticazione database IAM nella richiesta di connessione non è un token SigV4a valido o non è formattato correttamente. | Controlla la tua strategia di generazione di token nella tua applicazione. In alcuni casi, assicurati di passare il token con una formattazione valida. La troncatura del token (o la formattazione errata della stringa) renderà il token non valido. |
| `[ERROR] Failed to authenticate the connection request for user db_user because the token age is longer than 15 minutes. (Status Code: 400, Error Code:ExpiredToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | Il token di autenticazione database IAM è scaduto. I token sono validi solo per 15 minuti. | Controlla la logica di memorizzazione nella cache dei token e/o di riutilizzo dei token nell’applicazione. Non riutilizzare token più vecchi di 15 minuti. |
| `[ERROR] Failed to authorize the connection request for user db_user because the IAM policy assumed by the caller 'arn:aws:sts::123456789012:assumed-role/ / ' is not authorized to perform `rds-db:connect` on the DB instance. (Status Code: 403, Error Code:NotAuthorized)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInsufficientPermissions` | Questo errore potrebbe essere dovuto ai seguenti fattori: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.Troubleshooting.html) | Verifica il ruolo e/o la policy IAM che stai assumendo nella tua applicazione. Assicurati di assumere la stessa policy per generare il token utilizzata per la connessione al database. |
| `[ERROR] Failed to authorize the connection request for user db_user due to IAM DB authentication throttling. (Status Code: 429, Error Code: ThrottlingException)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Stai effettuando troppe richieste di connessione al tuo database in un breve lasso di tempo. La limitazione (della larghezza di banda della rete) per l’autenticazione database IAM è di 200 connessioni al secondo. | Riduci la velocità di creazione di nuove connessioni con l’autenticazione IAM. Prendi in considerazione l’implementazione del pool di connessioni utilizzando Server proxy per RDS per riutilizzare le connessioni stabilite nell’applicazione. |
| `[ERROR] Failed to authorize the connection request for user db_user due to an internal IAM DB authentication error. (Status Code: 500, Error Code: InternalError)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Si è verificato un errore interno durante l’autorizzazione della connessione database con l’autenticazione database IAM. | Contatta https://aws.amazon.com/premiumsupport/ per indagare sul problema. |