Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Connexion à votre instance de base de données à l'aide de l'authentification IAM.
Avec l'authentification de base de données IAM, vous utilisez un jeton d'identification lors de la connexion à votre instance de base de données. Un *jeton d'authentification* constitue une chaîne de caractères unique qui remplace un mot de passe. Après avoir été créé, un jeton d'authentification est valable pendant 15 minutes avant d'expirer. Si vous tentez de vous connecter alors que le jeton expiré, la demande de connexion est rejetée.
Chaque jeton d'authentification doit être accompagné d'une signature valide, en utilisant AWS Signature Version 4. (Pour plus d'informations, consultez [Processus de signature Signature version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) dans la *Références générales AWS*.) L'AWS CLI et un kit SDK AWS tel que AWS SDK pour Java ou AWS SDK pour Python (Boto3) peuvent signer automatiquement chaque jeton que vous créez.
Vous pouvez utiliser un jeton d'authentification lorsque vous vous connectez à Amazon RDS à partir d'un autre service AWS tel que AWS Lambda. L'utilisation d'un jeton vous évite d'avoir à placer un mot de passe dans votre code. Vous pouvez aussi utiliser un kit SDK AWS pour créer et signer un jeton d'authentification par programmation.
Après avoir obtenu un jeton d'authentification IAM signé, vous pouvez vous connecter à une instance de base de données Amazon RDS. Utilisez les liens ci-dessous pour savoir comment procéder avec un outil de ligne de commande ou un kit SDK AWS, comme le AWS SDK pour Java ou AWS SDK pour Python (Boto3).
Pour plus d'informations, consultez les billets de blog suivants :
+ [Utilisation de l'authentification IAM pour se connecter avec SQL Workbench/J à Aurora MySQL ou 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/)
+ [Utilisation de l'authentification IAM pour se connecter à PgAdmin Amazon Aurora PostgreSQL ou 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/)
**Prérequis**
Les conditions préalables à la connexion à votre instance de base de données à l'aide de l'authentification IAM sont les suivantes :
+ [Activation et désactivation de l’authentification de base de données IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Création et utilisation d'une politique IAM pour l'accès à une base de données IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Création d’un compte de base de données à l’aide de l’authentification IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Topics**
+ [Connexion à votre instance de bases de données à l’aide de l’authentification IAM avec les pilotes AWS](IAMDBAuth.Connecting.Drivers.md)
+ [Connexion à votre d'instances de base de données à l'aide de l'authentification IAM à partir de la ligne de commande : AWS CLI et du client MySQL](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [Connexion à votre d'instances de base de données à l'aide de l'authentification IAM à partir de la ligne de commande : AWS CLI et du client psql](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [Connexion à votre d'instances de base de données à l'aide de l'authentification IAM et du AWS SDK pour .NET](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [Connexion à votre d'instances de base de données à l'aide de l'authentification IAM et du AWS SDK pour Go](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [Connexion à votre d'instances de base de données à l'aide de l'authentification IAM et du AWS SDK pour Java](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [Connexion à votre d'instances de base de données à l'aide de l'authentification IAM et du AWS SDK pour Python (Boto3)](UsingWithRDS.IAMDBAuth.Connecting.Python.md)
# Connexion à votre instance de bases de données à l’aide de l’authentification IAM avec les pilotes AWS
La suite de pilotes AWS a été conçue pour accélérer les temps de bascule et de basculement, ainsi que pour l’authentification avec AWS Secrets Manager, Gestion des identités et des accès AWS (IAM) et l’identité fédérée. Les pilotes AWS s’appuient sur la surveillance de l’état du l’instance de base de données et sur la connaissance de la topologie de l’instance pour déterminer le nouvel enregistreur. Cette approche réduit les temps de bascule et de basculement à moins de 10 secondes, contre des dizaines de secondes pour les pilotes open source.
Pour plus d’informations sur les pilotes AWS, consultez le pilote correspondant au langage utilisé pour votre instance de base de données [RDS for MariaDB](MariaDB.Connecting.Drivers.md#MariaDB.Connecting.JDBCDriver), [RDS for MySQL](MySQL.Connecting.Drivers.md#MySQL.Connecting.JDBCDriver) ou [RDS pour PostgreSQL](PostgreSQL.Connecting.JDBCDriver.md).
**Note**
Les seules fonctionnalités prises en charge par RDS for MariaDB sont l’authentification avec AWS Secrets Manager, Gestion des identités et des accès AWS, (IAM) et l’identité fédérée.
# Connexion à votre d'instances de base de données à l'aide de l'authentification IAM à partir de la ligne de commande : AWS CLI et du client MySQL
Vous pouvez vous connecter depuis la ligne de commande à un Amazon RDS à l'aide de l'outil de ligne de `mysql` commande AWS CLI et comme décrit ci-dessous.
**Conditions préalables**
Les conditions préalables à la connexion à votre instance de base de données à l’aide de l’authentification IAM sont les suivantes :
+ [Activation et désactivation de l’authentification de base de données IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Création et utilisation d'une politique IAM pour l'accès à une base de données IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Création d’un compte de base de données à l’aide de l’authentification IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Note**
Pour plus d'informations sur la connexion à votre base de données à l'aide de SQL Workbench/J avec authentification IAM, consultez le billet de blog [Utiliser l'authentification IAM pour vous connecter avec SQL à Workbench/J Aurora MySQL ou Amazon RDS](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/) for MySQL.
**Topics**
+ [Création d'un jeton d'authentification IAM](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken)
+ [Connexion à votre instance](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect)
## Création d'un jeton d'authentification IAM
L'exemple suivant illustre comment obtenir un jeton d'identification signé à l'aide d 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
```
Dans cet exemple, les paramètres sont les suivants :
+ `--hostname` – Le nom d'hôte de l'instance de base de données auquel vous souhaitez accéder.
+ `--port` – Le numéro du port utilisé lors de la connexion au d'instances de base de données.
+ `--region`— La AWS région dans laquelle le d'instances de base de données est exécuté
+ `--username` – Le compte de base de données auquel vous souhaitez accéder.
Les premiers caractères du jeton ressemblent à l'exemple suivant.
```
rdsmysql.123456789012.us-west-2.rds.amazonaws.com:3306/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**Note**
Vous ne pouvez pas utiliser un enregistrement DNS Route 53 personnalisé à la place du point de terminaison de l’instance pour générer le jeton d’authentification.
## Connexion à votre instance
Le format général de connexion est illustré ci-dessous.
```
mysql --host=hostName --port=portNumber --ssl-ca=full_path_to_ssl_certificate --enable-cleartext-plugin --user=userName --password=authToken
```
Les paramètres sont les suivants :
+ `--host` – Le nom d'hôte de l'instance de base de données auquel vous souhaitez accéder.
+ `--port` – Le numéro du port utilisé lors de la connexion au d'instances de base de données.
+ `--ssl-ca` – Le chemin d'accès complet vers le fichier de certificat SSL contenant la clé publique.
Pour plus d'informations sur la SSL/TLS prise en charge de MariaDB, consultez. [Prise en charge de SSL/TLS pour les instances de base de données MariaDB sur Amazon RDS](MariaDB.Concepts.SSLSupport.md)
Pour plus d'informations sur la SSL/TLS prise en charge de MySQL, consultez[Prise en charge de SSL/TLS pour les instances de base de données MySQL sur Amazon RDS](MySQL.Concepts.SSLSupport.md).
Pour télécharger un certificat SSL, consultez [](UsingWithRDS.SSL.md).
+ `--enable-cleartext-plugin` – Une valeur qui spécifie que `AWSAuthenticationPlugin` doit être utilisé pour cette connexion.
Si vous utilisez un client MariaDB, l'option `--enable-cleartext-plugin` n'est pas requise.
+ `--user` – Le compte de base de données auquel vous souhaitez accéder.
+ `--password` – Un jeton d'authentification IAM signé.
Le jeton d'authentification est composé de plusieurs centaines de caractères. Il peut être encombrant sur la ligne de commande. Pour contourner ce problème, vous pouvez enregistrer le jeton dans une variable d'environnement, puis utiliser cette variable pour la connexion. L'exemple suivant illustre une manière de contourner ce problème. Dans l'exemple, */sample\$1dir/* il s'agit du chemin complet du fichier de certificat SSL contenant la clé publique.
```
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
```
Lorsque vous vous connectez avec `AWSAuthenticationPlugin`, la connexion est sécurisée par SSL. Pour le vérifier, tapez la commande suivante à l'invite de commande `mysql>`.
```
show status like 'Ssl%';
```
Les lignes suivantes de l'affichage obtenu fournissent plus de détails.
```
+---------------+-------------+
| Variable_name | Value |
+---------------+-------------+
| ... | ...
| Ssl_cipher | AES256-SHA |
| ... | ...
| Ssl_version | TLSv1.1 |
| ... | ...
+-----------------------------+
```
Si vous souhaitez vous connecter à une instance de bases de données via un proxy, consultez [Connexion à une base de données à l'aide de l'authentification IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connexion à votre d'instances de base de données à l'aide de l'authentification IAM à partir de la ligne de commande : AWS CLI et du client psql
À partir de la ligne de commande, vous pouvez vous connecter à une instance de base de données Amazon RDS for PostgreSQL avec AWS CLI l'outil de ligne de commande psql comme décrit ci-après.
**Conditions préalables**
Les conditions préalables à la connexion à votre instance de base de données à l’aide de l’authentification IAM sont les suivantes :
+ [Activation et désactivation de l’authentification de base de données IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Création et utilisation d'une politique IAM pour l'accès à une base de données IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Création d’un compte de base de données à l’aide de l’authentification IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Note**
Pour plus d'informations sur la connexion à votre base de données à l'aide de pgAdmin avec authentification IAM, consultez le billet de blog [Utilisation de l'authentification IAM pour se connecter à PgAdmin Amazon Aurora PostgreSQL ou 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**
+ [Création d'un jeton d'authentification IAM](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL)
+ [Connexion à une instance PostgreSQL Amazon RDS](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL)
## Création d'un jeton d'authentification IAM
Le jeton d'authentification se compose de plusieurs centaines de caractères ; il peut donc être complexe à manipuler sur la ligne de commande. Pour contourner ce problème, vous pouvez enregistrer le jeton dans une variable d'environnement, puis utiliser cette variable pour la connexion. L'exemple suivant montre comment utiliser le pour AWS CLI obtenir un jeton d'authentification signé à l'aide de la `generate-db-auth-token` commande et le stocker dans une variable d'`PGPASSWORD`environnement.
```
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 )"
```
Dans cet exemple, les paramètres de la commande `generate-db-auth-token` sont les suivants :
+ `--hostname` – Nom d'hôte de l'instance de base de données auquel vous souhaitez accéder.
+ `--port` – Le numéro du port utilisé lors de la connexion au d'instances de base de données.
+ `--region`— La AWS région dans laquelle le d'instances de base de données est exécuté
+ `--username` – Le compte de base de données auquel vous souhaitez accéder.
Les premiers caractères du jeton généré ressemblent à l'exemple suivant.
```
rdspostgres.123456789012.us-west-2.rds.amazonaws.com:5432/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**Note**
Vous ne pouvez pas utiliser un enregistrement DNS Route 53 personnalisé à la place du point de terminaison de l’instance pour générer le jeton d’authentification.
## Connexion à une instance PostgreSQL Amazon RDS
Le format général pour utiliser psql pour la connexion est illustré ci-dessous.
```
psql "host=hostName port=portNumber sslmode=verify-full sslrootcert=full_path_to_ssl_certificate dbname=DBName user=userName password=authToken"
```
Les paramètres sont les suivants :
+ `host` – Nom d'hôte de l'instance de base de données auquel vous souhaitez accéder.
+ `port` – Le numéro du port utilisé lors de la connexion au d'instances de base de données.
+ `sslmode` – Le mode SSL à utiliser.
Lorsque vous utilisez `sslmode=verify-full`, la connexion SSL vérifie le point de terminaison de l'instance de base de données par rapport au point de terminaison dans le certificat SSL.
+ `sslrootcert` – Le chemin d'accès complet vers le fichier de certificat SSL contenant la clé publique.
Pour de plus amples informations, veuillez consulter [Utilisation de SSL avec une instance de base de données PostgreSQL](PostgreSQL.Concepts.General.SSL.md).
Pour télécharger un certificat SSL, consultez [](UsingWithRDS.SSL.md).
+ `dbname` – La base de données à laquelle vous souhaitez accéder.
+ `user` – Le compte de base de données auquel vous souhaitez accéder.
+ `password` – Un jeton d'authentification IAM signé.
**Note**
Vous ne pouvez pas utiliser un enregistrement DNS Route 53 personnalisé à la place du point de terminaison de l’instance pour générer le jeton d’authentification.
L'exemple suivant montre l'utilisation de psql pour se connecter. Dans cet exemple, psql utilise la variable d'environnement `RDSHOST` pour l'hôte et la variable d'environnement `PGPASSWORD` pour le jeton généré. Il s'*/sample\$1dir/*agit également du chemin complet vers le fichier de certificat SSL contenant la clé publique.
```
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"
```
Si vous souhaitez vous connecter à une instance de bases de données via un proxy, consultez [Connexion à une base de données à l'aide de l'authentification IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connexion à votre d'instances de base de données à l'aide de l'authentification IAM et du AWS SDK pour .NET
Vous pouvez vous connecter à une instance de base de données RDS pour MariaDB, MySQL ou PostgreSQL Aurora MySQL ou à un cluster de base de données Aurora PostgreSQL ci-dessous. AWS SDK pour .NET
**Conditions préalables**
Les conditions préalables à la connexion à votre instance de base de données à l’aide de l’authentification IAM sont les suivantes :
+ [Activation et désactivation de l’authentification de base de données IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Création et utilisation d'une politique IAM pour l'accès à une base de données IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Création d’un compte de base de données à l’aide de l’authentification IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Exemples**
Les exemples de code suivants montre comment générer un jeton d'authentification, puis comment l'utiliser pour se connecter à une instance de base de données.
Pour exécuter cet exemple de code, vous avez besoin du [AWS SDK pour .NET](https://aws.amazon.com/sdk-for-net/), qui se trouve sur le AWS site. Les paquets `AWSSDK.CORE` et `AWSSDK.RDS` sont requis. Pour vous connecter à un d'instances de base de données, utilisez le connecteur de base de données .NET pour le moteur de base de données, par exemple MySqlConnector pour MariaDB ou MySQL, ou Npgsql pour PostgreSQL.
Ce code se connecte à une instance de base de données MariaDB ou MySQL. Modifiez la valeur des variables suivantes selon les besoins :
+ `server` – Le point de terminaison de l'instance de base de données à laquelle vous souhaitez accéder.
+ `user` – Le compte de base de données auquel vous souhaitez accéder.
+ `database` – La base de données à laquelle vous souhaitez accéder.
+ `port` – Le numéro du port utilisé lors de la connexion au d'instances de base de données.
+ `SslMode` – Le mode SSL à utiliser.
Lorsque vous utilisez `SslMode=Required`, la connexion SSL vérifie le point de terminaison de l'instance de base de données par rapport au point de terminaison dans le certificat SSL.
+ `SslCa` – Le chemin d'accès complet au certificat SSL pour Amazon RDS
Pour télécharger un certificat, consultez [](UsingWithRDS.SSL.md).
**Note**
Vous ne pouvez pas utiliser un enregistrement DNS Route 53 personnalisé à la place du point de terminaison de l’instance pour générer le jeton d’authentification.
```
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();
}
}
}
```
Ce code se connecte à une instance de base de données PostgreSQL.
Modifiez la valeur des variables suivantes selon les besoins :
+ `Server` – Le point de terminaison de l'instance de base de données à laquelle vous souhaitez accéder.
+ `User ID` – Le compte de base de données auquel vous souhaitez accéder.
+ `Database` – La base de données à laquelle vous souhaitez accéder.
+ `Port` – Le numéro du port utilisé lors de la connexion au d'instances de base de données.
+ `SSL Mode` – Le mode SSL à utiliser.
Lorsque vous utilisez `SSL Mode=Required`, la connexion SSL vérifie le point de terminaison de l'instance de base de données par rapport au point de terminaison dans le certificat SSL.
+ `Root Certificate` – Le chemin d'accès complet au certificat SSL pour Amazon RDS
Pour télécharger un certificat, consultez [](UsingWithRDS.SSL.md).
**Note**
Vous ne pouvez pas utiliser un enregistrement DNS Route 53 personnalisé à la place du point de terminaison de l’instance pour générer le jeton d’authentification.
```
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();
}
}
}
```
Si vous souhaitez vous connecter à une instance de bases de données via un proxy, consultez [Connexion à une base de données à l'aide de l'authentification IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connexion à votre d'instances de base de données à l'aide de l'authentification IAM et du AWS SDK pour Go
Vous pouvez vous connecter à une instance de base de données RDS pour MariaDB, MySQL ou PostgreSQL Aurora MySQL ou à un cluster de base de données Aurora PostgreSQL ci-dessous. AWS SDK pour Go
**Conditions préalables**
Les conditions préalables à la connexion à votre instance de base de données à l’aide de l’authentification IAM sont les suivantes :
+ [Activation et désactivation de l’authentification de base de données IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Création et utilisation d'une politique IAM pour l'accès à une base de données IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Création d’un compte de base de données à l’aide de l’authentification IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Exemples**
Pour exécuter ces exemples de code, vous avez besoin du [AWS SDK pour Go](https://aws.amazon.com/sdk-for-go/), disponible sur le AWS site.
Modifiez la valeur des variables suivantes selon les besoins :
+ `dbName` – La base de données à laquelle vous souhaitez accéder.
+ `dbUser` – Le compte de base de données auquel vous souhaitez accéder.
+ `dbHost` – Le point de terminaison de l'instance de base de données à laquelle vous souhaitez accéder.
**Note**
Vous ne pouvez pas utiliser un enregistrement DNS Route 53 personnalisé à la place du point de terminaison de l’instance pour générer le jeton d’authentification.
+ `dbPort` – Le numéro du port utilisé lors de la connexion au d'instances de base de données.
+ `region`— La AWS région dans laquelle le d'instances de base de données est exécuté
En outre, assurez-vous que les bibliothèques importées dans l'exemple de code existent sur votre système.
**Important**
Les exemples de cette section utilisent le code suivant pour fournir des informations d'identification qui accèdent à une base de données à partir d'un environnement local :
`creds := credentials.NewEnvCredentials()`
Si vous accédez à une base de données depuis un AWS service, tel qu'Amazon EC2 ou Amazon ECS, vous pouvez remplacer le code par le code suivant :
`sess := session.Must(session.NewSession())`
`creds := sess.Config.Credentials`
Si vous effectuez cette modification, assurez-vous d'ajouter l'importation suivante :
`"github.com/aws/aws-sdk-go/aws/session"`
**Topics**
+ [Connexion à l'aide de l'authentification IAM et de la V2 AWS SDK pour Go](#UsingWithRDS.IAMDBAuth.Connecting.GoV2)
+ [Connexion à l'aide de l'authentification IAM et de la AWS SDK pour Go V1.](#UsingWithRDS.IAMDBAuth.Connecting.GoV1)
## Connexion à l'aide de l'authentification IAM et de la V2 AWS SDK pour Go
Vous pouvez vous connecter à un d'instances de base de données à l'aide de l'authentification IAM et de la AWS SDK pour Go V2.
Les exemples de code suivants montre comment générer un jeton d'authentification, puis comment l'utiliser pour se connecter à une instance de base de données.
Ce code se connecte à une instance de base de données MariaDB ou 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)
}
}
```
Ce code se connecte à une instance de base de données 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)
}
}
```
Si vous souhaitez vous connecter à une instance de bases de données via un proxy, consultez [Connexion à une base de données à l'aide de l'authentification IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
## Connexion à l'aide de l'authentification IAM et de la AWS SDK pour Go V1.
Vous pouvez vous connecter à un d'instances de base de données à l'aide de l'authentification IAM et du V1 AWS SDK pour Go
Les exemples de code suivants montre comment générer un jeton d'authentification, puis comment l'utiliser pour se connecter à une instance de base de données.
Ce code se connecte à une instance de base de données MariaDB ou 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)
}
}
```
Ce code se connecte à une instance de base de données 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)
}
}
```
Si vous souhaitez vous connecter à une instance de bases de données via un proxy, consultez [Connexion à une base de données à l'aide de l'authentification IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connexion à votre d'instances de base de données à l'aide de l'authentification IAM et du AWS SDK pour Java
Vous pouvez vous connecter à une instance de base de données RDS pour MariaDB, MySQL ou PostgreSQL Aurora MySQL ou à un cluster de base de données Aurora PostgreSQL ci-dessous. AWS SDK pour Java
**Conditions préalables**
Les conditions préalables à la connexion à votre instance de base de données à l’aide de l’authentification IAM sont les suivantes :
+ [Activation et désactivation de l’authentification de base de données IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Création et utilisation d'une politique IAM pour l'accès à une base de données IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Création d’un compte de base de données à l’aide de l’authentification IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Configuration du AWS SDK pour Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)
Pour des exemples d’utilisation du kit SDK pour Java 2.x, consultez [Exemples Amazon RDS utilisant le kit SDK pour Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html). Vous pouvez également utiliser l' AWS Advanced JDBC Wrapper, voir la documentation [AWS Advanced JDBC](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/Documentation.md) Wrapper.
**Topics**
+ [Création d’un jeton d’authentification IAM](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken)
+ [Construction manuelle d’un jeton d’authentification IAM](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2)
+ [Connexion à votre instance](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect)
## Création d’un jeton d’authentification IAM
Si vous écrivez des programmes à l'aide de AWS SDK pour Java, vous pouvez obtenir un jeton d'authentification signé à l'aide de la `RdsIamAuthTokenGenerator` classe. L'utilisation de cette classe nécessite que vous fournissiez des AWS informations d'identification. Pour ce faire, vous devez créer une instance de la `DefaultAWSCredentialsProviderChain` classe. `DefaultAWSCredentialsProviderChain`utilise la première clé AWS d'accès et la première clé secrète qu'il trouve dans la [chaîne de fournisseurs d'informations d'identification par défaut](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default). Pour plus d’informations sur les clés d’accès AWS , consultez [Gestion des clés d’accès pour les utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
**Note**
Vous ne pouvez pas utiliser un enregistrement DNS Route 53 personnalisé à la place du point de terminaison de l’instance pour générer le jeton d’authentification.
Après avoir créé une instance de `RdsIamAuthTokenGenerator`, vous pouvez appeler la méthode `getAuthToken` pour obtenir un jeton signé. Fournissez la région AWS , le nom d’hôte, le numéro de port et le nom d’utilisateur. L’exemple de code suivant montre comment procéder.
```
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;
}
}
```
## Construction manuelle d’un jeton d’authentification IAM
Dans Java, la manière la plus facile de créer un jeton d’authentification est d’utiliser `RdsIamAuthTokenGenerator`. Cette classe crée un jeton d'authentification pour vous, puis le signe à l'aide de AWS la version de signature 4. Pour plus d’informations, consultez [Processus de signature Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) dans le *Références générales AWS*.
Vous pouvez néanmoins aussi construire et signer un jeton d’authentification manuellement, comme indiqué dans l’exemple de code suivant.
```
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);
}
}
}
```
## Connexion à votre instance
L’exemple de code suivant montre comment créer un jeton d’authentification, puis comment l’utiliser pour se connecter à une instance exécutant MariaDB ou MySQL.
Pour exécuter cet exemple de code, vous avez besoin du [AWS SDK pour Java](https://aws.amazon.com/sdk-for-java/), qui se trouve sur le AWS site. En outre, vous avez besoin des éléments suivants :
+ MySQL Connector/J. Cet exemple de code a été testé avec `mysql-connector-java-5.1.33-bin.jar`.
+ Certificat intermédiaire pour Amazon RDS () spécifique à une AWS région. (Pour plus d’informations, consultez [](UsingWithRDS.SSL.md).) À l’exécution, le chargeur de classe recherche le certificat dans le même annuaire que celui de cet exemple de code Java, afin de pouvoir le trouver.
+ Modifiez la valeur des variables suivantes selon les besoins :
+ `RDS_INSTANCE_HOSTNAME` : le nom d’hôte de l’instance de base de données auquel vous souhaitez accéder.
+ `RDS_INSTANCE_PORT` : le numéro du port utilisé pour la connexion à votre instance de base de données PostgreSQL.
+ `REGION_NAME`— La AWS région dans laquelle le d'instances de base de données est exécuté.
+ `DB_USER` – Le compte de base de données auquel vous souhaitez accéder.
+ `SSL_CERTIFICATE`— Un certificat SSL pour Amazon RDS spécifique à une AWS région.
Pour télécharger un certificat pour votre région AWS , consultez [](UsingWithRDS.SSL.md). Placez le certificat SSL dans le même annuaire que ce fichier de programme Java, afin que le chargeur de classe puisse le trouver à l’exécution.
Cet exemple de code permet d'obtenir des AWS informations d'identification à partir de la chaîne de [fournisseurs d'informations d'identification par défaut](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default).
**Note**
Spécifiez un mot de passe pour `DEFAULT_KEY_STORE_PASSWORD` différent de celui indiqué ici, en tant que bonne pratique de sécurité.
```
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");
}
}
```
Si vous souhaitez vous connecter à une instance de bases de données via un proxy, consultez [Connexion à une base de données à l'aide de l'authentification IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Connexion à votre d'instances de base de données à l'aide de l'authentification IAM et du AWS SDK pour Python (Boto3)
Vous pouvez vous connecter à une instance de base de données RDS pour MariaDB, MySQL ou PostgreSQL Aurora MySQL ou à un cluster de base de données Aurora PostgreSQL ci-dessous. AWS SDK pour Python (Boto3)
**Conditions préalables**
Les conditions préalables à la connexion à votre instance de base de données à l’aide de l’authentification IAM sont les suivantes :
+ [Activation et désactivation de l’authentification de base de données IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Création et utilisation d'une politique IAM pour l'accès à une base de données IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Création d’un compte de base de données à l’aide de l’authentification IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
En outre, assurez-vous que les bibliothèques importées dans l'exemple de code existent sur votre système.
**Exemples**
Les exemples de code utilisent des profils pour les informations d'identification partagées. Pour plus d'informations sur la spécification des informations d'identification, consultez la section [Informations d'identification](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) dans la AWS SDK pour Python (Boto3) documentation.
Les exemples de code suivants montre comment générer un jeton d'authentification, puis comment l'utiliser pour se connecter à une instance de base de données.
Pour exécuter cet exemple de code, vous avez besoin du [AWS SDK pour Python (Boto3)](https://aws.amazon.com/sdk-for-python/), qui se trouve sur le AWS site.
Modifiez la valeur des variables suivantes selon les besoins :
+ `ENDPOINT` – Le point de terminaison de l'instance de base de données à laquelle vous souhaitez accéder.
+ `PORT` – Le numéro du port utilisé lors de la connexion au d'instances de base de données.
+ `USER` – Le compte de base de données auquel vous souhaitez accéder.
+ `REGION`— La AWS région dans laquelle le d'instances de base de données est exécuté
+ `DBNAME` – La base de données à laquelle vous souhaitez accéder.
+ `SSLCERTIFICATE` – Le chemin d'accès complet au certificat SSL pour Amazon RDS
Pour `ssl_ca`, spécifiez un certificat SSL. Pour télécharger un certificat SSL, consultez [](UsingWithRDS.SSL.md).
**Note**
Vous ne pouvez pas utiliser un enregistrement DNS Route 53 personnalisé à la place du point de terminaison de l’instance pour générer le jeton d’authentification.
Ce code se connecte à une instance de base de données MariaDB ou MySQL.
Avant d'exécuter ce code, installez le pilote PyMy SQL en suivant les instructions du [Python Package Index](https://pypi.org/project/PyMySQL/).
```
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))
```
Ce code se connecte à une instance de base de données PostgreSQL.
Avant d'exécuter ce code, installez `psycopg2` en suivant les instructions de la documentation de [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))
```
Si vous souhaitez vous connecter à une instance de bases de données via un proxy, consultez [Connexion à une base de données à l'aide de l'authentification IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).