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