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.
# Authentification de base de données IAMpour MariaDB, MySQL et PostgreSQL
Vous pouvez vous authentifier auprès de votre d'instances de base de données à l'aide de l'authentification de base de données Gestion des identités et des accès AWS (IAM). L’authentification de base de données IAM fonctionne avec MariaDB, MySQL et PostgreSQL. Grâce à cette méthode d’authentification, vous n’avez plus besoin de mot de passe pour vous connecter à une instance de base de données. En revanche, un jeton d’authentification est nécessaire.
Un *jeton d’authentification* est une chaîne de caractères unique générée par Amazon RDS sur demande. Les jetons d'authentification sont générés à l'aide de AWS la version 4 de Signature. Chaque jeton a une durée de vie de 15 minutes. Il n’est pas nécessaire de stocker les informations d’identification des utilisateurs dans la base de données, car l’authentification est gérée de manière externe avec IAM. Vous pouvez aussi toujours utiliser l’authentification de base de données standard. Le jeton est uniquement utilisé pour l’authentification et n’affecte pas la session une fois qu’il est établi.
L’authentification de base de données IAM offre les avantages suivants :
+ Le trafic réseau à destination et en provenance de la base de données est chiffré à l’aide de Secure Socket Layer (SSL) ou de Transport Layer Security (TLS). Pour plus d'informations sur l'utilisation SSL/TLS d'Amazon RDS, consultez[](UsingWithRDS.SSL.md).
+ Vous pouvez utiliser IAM pour gérer de façon centralisée l’accès à vos ressources de base de données, au lieu de gérer l’accès de manière individuelle sur chaque instance de bases de données.
+ Pour les applications exécutées sur Amazon EC2, vous pouvez utiliser des informations d’identification spécifiques à votre instance EC2 pou accéder à la base de données, ce qui garantit une meilleure sécurité qu’un mot de passe.
En règle générale, envisagez d’utiliser l’authentification de base de données IAM lorsque vos applications créent moins de 200 connexions par seconde, et que vous ne souhaitez pas gérer les noms d’utilisateur et les mots de passe directement dans le code de votre application.
Le pilote JDBC Amazon Web Services (AWS) prend en charge l’authentification de la base de données IAM. Pour plus d'informations, consultez la section [Plug-in d'authentification AWS IAM](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) dans le [référentiel de pilotes JDBC Amazon Web Services (AWS)](https://github.com/aws/aws-advanced-jdbc-wrapper). GitHub
Le pilote Python Amazon Web Services (AWS) prend en charge l’authentification de la base de données IAM. Pour plus d'informations, consultez la section [Plug-in d'authentification AWS IAM](https://github.com/aws/aws-advanced-python-wrapper/blob/main/docs/using-the-python-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) dans le [ GitHubréférentiel de pilotes Python Amazon Web Services (AWS)](https://github.com/aws/aws-advanced-python-wrapper).
Consultez les rubriques suivantes pour apprendre à configurer IAM pour l’authentification de la base de données :
+ [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)
+ [Connexion à votre instance de base de données à l'aide de l'authentification IAM.](UsingWithRDS.IAMDBAuth.Connecting.md)
## Disponibilité des régions et des versions
La disponibilité et la prise en charge des fonctionnalités varient selon les versions spécifiques de chaque moteur de base de données. Pour obtenir plus d’informations sur la disponibilité des moteurs, versions et des régions avec Amazon RDS et l’authentification de la base de données IAM, consultez [Régions et moteurs de base de données pris en charge pour l’authentification de base de données IAM dans Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.IamDatabaseAuthentication.md).
## Support CLI et kit SDK
L'authentification de base de données IAM est disponible pour [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/generate-db-auth-token.html)et pour les langues AWS SDKs spécifiques suivantes :
+ [AWS SDK pour .NET](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/RDS/TRDSAuthTokenGenerator.html)
+ [AWS SDK pour C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/class_aws_1_1_r_d_s_1_1_r_d_s_client.html#ae134ffffed5d7672f6156d324e7bd392)
+ [AWS SDK pour Go](https://docs.aws.amazon.com/sdk-for-go/api/service/rds/#pkg-overview)
+ [AWS SDK pour Java](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/rds/RdsUtilities.html)
+ [AWS SDK pour JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_rds_signer.html)
+ [AWS SDK pour PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.Rds.AuthTokenGenerator.html)
+ [AWS SDK pour Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.generate_db_auth_token)
+ [AWS SDK pour Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/RDS/AuthTokenGenerator.html)
## Limites de l’authentification de base de données IAM
Les limitations suivantes s’appliquent lors de l’utilisation de l’authentification de base de données IAM :
+ Actuellement, l’authentification de base de données IAM ne prend pas en charge toutes les clés de contexte de condition globale.
Pour plus d’informations sur les clés de contexte de condition globale, consultez [Clés de contexte de condition globales AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dans le *Guide de l’utilisateur IAM*.
+ Pour PostgreSQL, si le rôle IAM (`rds_iam`) est ajouté à un utilisateur (y compris à l’utilisateur principal RDS), l’authentification IAM a priorité sur l’authentification par mot de passe, de sorte que l’utilisateur doit se connecter en tant qu’utilisateur IAM.
+ Pour PostgreSQL, Amazon RDS ne prend pas en charge l’activation simultanée des méthodes d’authentification IAM et Kerberos.
+ Pour PostgreSQL, vous ne pouvez pas utiliser l'authentification IAM pour établir une connexion de réplication.
+ 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.
+ CloudWatch et CloudTrail n'enregistrez pas l'authentification IAM. Ces services ne suivent pas les appels d’API `generate-db-auth-token` qui autorisent le rôle IAM à activer la connexion à la base de données.
+ L’authentification de base de données IAM nécessite des ressources de calcul sur l’instance de base de données. Pour garantir une connectivité fiable, votre base de données doit disposer de 300 à 1 000 Mio de mémoire supplémentaire. Pour connaître la mémoire nécessaire à votre charge de travail, comparez la colonne RES pour les processus RDS dans la liste des processus de surveillance améliorée avant et après l’activation de l’authentification de base de données IAM. Consultez [Affichage des métriques du système d’exploitation dans la console RDS](USER_Monitoring.OS.Viewing.md).
Si vous utilisez une instance de classe à performances extensibles, évitez de manquer de mémoire en réduisant d’autant la mémoire utilisée par d’autres paramètres tels que les tampons et le cache.
+ L’authentification de base de données IAM n’est prise en charge pour RDS on Outposts, quel que soit le moteur.
## Recommandations pour l’authentification de base de données IAM
Nous recommandons les pratiques suivantes lors de l’utilisation de l’authentification de base de données IAM :
+ Utilisez l’authentification de base de données IAM si votre application exige moins de 200 nouvelles connexions d’authentification de base de données IAM par seconde.
Les moteurs de base de données qui fonctionnent avec Amazon RDS n’imposent pas de limites de tentatives d’authentification par seconde. Néanmoins, lorsque vous utilisez l’authentification de base de données IAM, votre application doit générer un jeton d’authentification. Votre application emploie ensuite ce jeton pour la connexion à l’instance. Si vous dépassez la limite maximale de nouvelles connexions par seconde, le traitement supplémentaire d’authentification de base de données IAM peut entraîner une limitation de la connexion.
Envisagez d’utiliser le regroupement de connexions dans vos applications pour limiter la création constante de connexions. Cela peut réduire les frais généraux liés à l’authentification de base de données IAM et permettre à vos applications de réutiliser les connexions existantes. Vous pouvez également envisager d’utiliser le proxy RDS pour ces cas d’utilisation. Le proxy RDS entraîne des coûts supplémentaires. Consultez [Tarification de Proxy Amazon RDS](https://aws.amazon.com/rds/proxy/pricing/).
+ La taille d’un jeton d’authentification de base de données IAM dépend de nombreux facteurs, notamment du nombre de balises IAM, des politiques de service IAM, de la longueur des ARN, ainsi que d’autres propriétés IAM et de base de données. La taille minimale de ce jeton est généralement d’environ 1 Ko, mais elle peut être plus grande. Étant donné que ce jeton est utilisé comme mot de passe dans la chaîne de connexion à la base de données à l'aide de l'authentification IAM, vous devez vous assurer que les outils de votre pilote de base de données (par exemple, ODBC) and/or ne limitent ni ne tronquent ce jeton en raison de sa taille. Un jeton tronqué provoquera l’échec de la validation d’authentification effectuée par la base de données et IAM.
+ Si vous utilisez des informations d’identification temporaires lors de la création d’un jeton d’authentification d’une base de données IAM, les informations d’identification temporaires doivent toujours être valides lorsque vous utilisez le jeton d’authentification d’une base de données IAM pour effectuer une demande de connexion.
## Clés contextuelles de condition AWS globale non prises en charge
L'authentification de base de données IAM ne prend pas en charge le sous-ensemble suivant de clés AWS contextuelles de conditions globales.
+ `aws:Referer`
+ `aws:SourceIp`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserAgent`
+ `aws:VpcSourceIp`
Pour plus d’informations, consultez [Clés de contexte de condition globales AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dans le *Guide de l’utilisateur IAM*.
# Activation et désactivation de l’authentification de base de données IAM
Par défaut, l’authentification de base de données IAM est désactivée sur les instances et de bases de données. Vous pouvez activer ou désactiver l'authentification de base de données IAM à l'aide de AWS Management Console AWS CLI, ou de l'API.
Vous pouvez activer l’authentification de base de données IAM lorsque vous effectuez une des actions suivantes :
+ Pour créer une nouvelle instance de base de données avec l’authentification de base de données IAM activée, consultez [Création d'une instance de base de données Amazon RDS](USER_CreateDBInstance.md).
+ Pour modifier une instance de base de données afin d’activer l’authentification de base de données IAM, consultez [Modification d'une instance de base de données Amazon RDS](Overview.DBInstance.Modifying.md).
+ Pour restaurer une instance de base de données à partir d’un instantané avec l’authentification de base de données IAM activée, consultez [Restauration d’une instance de base de données](USER_RestoreFromSnapshot.md).
+ Pour restaurer une instance de base de données à un instant dans le passé avec l’authentification de base de données IAM activée, consultez [Restauration d’une instance de base de données à un instant précis pour Amazon RDS](USER_PIT.md).
## Console
Chaque flux de travail de création ou de modification comporte une section **Authentification de base de données** dans laquelle vous pouvez activer ou désactiver l’authentification de base de données IAM. Dans cette section, choisissez **Authentification de base de données par mot de passe et IAM** pour activer l’authentification de base de données IAM.
**Pour activer ou désactiver l’authentification de base de données IAM pour une instance**
1. Ouvrez la console Amazon RDS à l'adresse [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Dans la panneau de navigation, choisissez **Databases (Bases de données)**.
1. Choisissez instance que vous souhaitez modifier.
**Note**
Assurez-vous que l’instance de base de données est compatible avec l’authentification IAM. Consultez les exigences de compatibilité présentées dans [Disponibilité des régions et des versions](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
1. Sélectionnez **Modify**.
1. Dans la section **Authentification de base de données, sélectionnez Mot de passe et authentification** **de base de données IAM Authentification de base** de de base de données IAM. Choisissez **Authentification par mot de passe** ou **Authentification par mot de passe et Kerberos** pour désactiver l’authentification IAM.
1. Vous pouvez également choisir d'activer la publication des journaux d'authentification IAM DB dans CloudWatch Logs. Sous **Exportations de journaux**, choisissez l'option de **iam-db-auth-error journal**. La publication de vos CloudWatch journaux dans Logs consomme de l'espace de stockage et vous devez payer des frais pour ce stockage. Assurez-vous de supprimer tous les CloudWatch journaux dont vous n'avez plus besoin.
1. Choisissez **Continuer**.
1. Pour appliquer immédiatement les modifications, choisissez **Immédiatement** dans la section **Planification des modifications**.
1. Choisissez **Modifier l’instance de base de données** ou .
## AWS CLI
Pour créer une nouvelle instance de base de données avec authentification IAM à l'aide de AWS CLI, utilisez la [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)commande. Spécifiez l’option `--enable-iam-database-authentication`, comme indiqué dans l’exemple suivant.
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.m3.medium \
--engine MySQL \
--allocated-storage 20 \
--master-username masterawsuser \
--manage-master-user-password \
--enable-iam-database-authentication
```
Pour mettre à jour une instance de bases de données existante de manière à activer ou non l’authentification IAM, utilisez la commande de l’ AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html). Spécifiez l’option `--enable-iam-database-authentication` ou `--no-enable-iam-database-authentication`, selon le cas.
**Note**
Assurez-vous que l’instance de base de données est compatible avec l’authentification IAM. Consultez les exigences de compatibilité présentées dans [Disponibilité des régions et des versions](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Par défaut, Amazon RDS procède à la modification pendant la fenêtre de maintenance suivante. Si vous souhaitez ignorer ceci et activer l’authentification de bases de données IAM dès que possible, utilisez le paramètre `--apply-immediately`.
L’exemple suivant montre comment activer immédiatement l’authentification IAM pour une instance de base de données existante.
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--apply-immediately \
--enable-iam-database-authentication
```
Si vous restaurez un d'instances de base de données, utilisez l'une des AWS CLI commandes suivantes :
+ `[restore-db-instance-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)`
+ `[restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)`
Le paramètre d’authentification de base de données IAM par défaut est celui de l’instantané source. Pour le modifier, spécifiez l’option `--enable-iam-database-authentication` ou `--no-enable-iam-database-authentication`, selon le cas.
## API RDS
Pour créer une nouvelle instance de base de données avec authentification IAM par l’intermédiaire de l’API, utilisez l’opération d’API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). Définissez le paramètre `EnableIAMDatabaseAuthentication` sur `true`.
Pour mettre à jour une instance de base de données existante de manière à activer l’authentification IAM, utilisez l’opération d’API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html). Définissez le paramètre `EnableIAMDatabaseAuthentication` sur `true` pour activer l’authentification IAM ou sur `false` pour la désactiver.
**Note**
Assurez-vous que l’instance de base de données est compatible avec l’authentification IAM. Consultez les exigences de compatibilité présentées dans [Disponibilité des régions et des versions](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Si vous restaurez un ou une instance de base de données, utilisez l’une des opérations d’API suivantes :
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)
Le paramètre d’authentification de base de données IAM par défaut est celui de l’instantané source. Pour modifier ce paramètre, définissez le paramètre `EnableIAMDatabaseAuthentication` sur `true` pour activer l’authentification IAM ou sur `false` pour la désactiver.
# Création et utilisation d'une politique IAM pour l'accès à une base de données IAM
Pour autoriser un utilisateur ou un rôle à se connecter à votre instance de bases de données, vous devez créer une politique IAM. Vous attachez ensuite la politique à un jeu d'autorisations ou à un rôle.
**Note**
Pour en savoir plus sur les stratégies IAM, consultez [Identity and Access Management pour Amazon RDS](UsingWithRDS.IAM.md).
L'exemple de politique suivant autorise un utilisateur à se connecter à une instance de bases de données en utilisant l'authentification de base de données IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:db-ABCDEFGHIJKL01234/db_user"
]
}
]
}
```
------
**Important**
Un utilisateur doté d'autorisations d'administrateur peut accéder aux instances de base de données sans autorisations explicites dans une politique IAM. Si vous souhaitez restreindre l'accès de l'administrateur aux instances et aux de base de données, vous pouvez créer un rôle IAM avec les autorisations appropriées accordant moins de privilèges, puis les assigner à l'administrateur.
**Note**
Ne confondez pas le préfixe `rds-db:` avec d'autres préfixes d'opération d'API RDS; qui commencent par `rds:`. Vous utilisez le préfixe `rds-db:` et l'action `rds-db:connect` uniquement pour l'authentification de base de données IAM. Ils ne sont valides que dans ce contexte.
L'exemple de politique inclut une instruction unique avec les éléments suivants :
+ `Effect` – Spécifiez `Allow` pour octroyer l'accès à l'instance de base de données. Si vous n'autorisez pas explicitement l'accès, celui-ci est refusé par défaut.
+ `Action` – Spécifiez `rds-db:connect` pour autoriser les connexions à l'instance de base de données.
+ `Resource` – Spécifiez un ARN (Amazon Resource Name) qui décrit un compte de base de données dans une instance de base de données. Le format de l'ARN est le suivant.
```
arn:aws:rds-db:region:account-id:dbuser:DbiResourceId/db-user-name
```
Dans ce format, remplacez les variables suivantes :
+ `region`est la AWS région du d'instances de base de données. Dans l'exemple de politique, la AWS région est`us-east-2`.
+ `account-id`est le numéro de AWS compte du d'instances de base de données. Dans l'exemple de stratégie, le numéro de compte est `1234567890`. L'utilisateur doit figurer dans le même compte que le compte de l'instance de base de données.
Pour bénéficier d'un accès intercompte, créez un rôle IAM avec la politique décrite ci-dessus dans le compte de l'instance de base de données et autorisez votre autre compte à endosser ce rôle.
+ `DbiResourceId` correspond à l'identifiant de l'instance de base de données. Cet identifiant est propre à une AWS région et ne change jamais. Dans cet exemple de stratégie, l'identifiant est `db-ABCDEFGHIJKL01234`.
Pour trouver un ID de ressource de d'instance de base de AWS Management Console données dans Amazon RDS , choisissez le d'instance de base de données pour en voir les détails. Choisissez ensuite l'onglet **Configuration**. L'**ID de ressource** est indiqué dans la section **Configuration**.
Vous pouvez également utiliser la AWS CLI commande pour répertorier les identifiants et les ressources IDs de l'ensemble de votre d'instances de base de données dans la AWS région actuelle, comme indiqué ci-dessous.
```
aws rds describe-db-instances --query "DBInstances[*].[DBInstanceIdentifier,DbiResourceId]"
```
Si vous utilisez Amazon Aurora, spécifiez `DbClusterResourceId` au lieu de `DbiResourceId`. Pour plus d'informations, consultez la section [Creating and using an IAM policy for IAM database access](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.IAMPolicy.html) (Création et utilisation d'une politique IAM pour l'accès à la base de données IAM) dans le *Guide de l'utilisateur d'Amazon Aurora*.
**Note**
Si vous vous connectez à une base de données via le proxy RDS, spécifiez l'ID de ressource de proxy, par exemple `prx-ABCDEFGHIJKL01234`. Pour plus d'informations sur l'utilisation de l'authentification de base de données IAM avec le proxy RDS, consultez [Connexion à une base de données à l'aide de l'authentification IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
+ `db-user-name` correspond au nom du compte de base de données à associer à l'authentification IAM. Dans cet exemple de stratégie, le compte de la base de données est `db_user`.
Vous pouvez en créer d'autres ARNs pour prendre en charge différents modèles d'accès. La stratégie suivante permet d'accéder à deux comptes de base de données différents dans une instance de base de données.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/jane_doe",
"arn:aws:rds-db:us-east-2:123456789012:dbuser:db-ABCDEFGHIJKL01234/mary_roe"
]
}
]
}
```
------
La politique suivante utilise le caractère « \$1 » pour faire correspondre tous les d'instances de base de données et les comptes de base de données pour un AWS compte et une AWS région spécifiques.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:*/*"
]
}
]
}
```
------
La politique suivante correspond à tous les d'instances de base de données pour un AWS compte et une AWS région particuliers. Néanmoins, cette stratégie n'octroie l'accès qu'aux instances et de bases de données qui ont un compte de base de données `jane_doe`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:*/jane_doe"
]
}
]
}
```
------
L'utilisateur ou le rôle a uniquement accès aux bases de données auxquelles l'utilisateur de base de données a accès. Supposons par exemple que votre instance de base de donnés possède une base de données nommée *dev* et une autre base de données nommée *test*. Si l'utilisateur de base de données `jane_doe` a uniquement accès à *dev*, tous les rôles ou utilisateurs qui accèdent à cette instance de bases de données avec l'utilisateur `jane_doe` ont aussi uniquement accès à *dev*. Cette restriction d'accès s'applique également aux autres objets de bases de données, tels que les tables, les vues, etc.
Un administrateur doit créer des politiques IAM autorisant les entités à exécuter des opérations d'API spécifiques sur les ressources spécifiées dont ils ont besoin. L'administrateur doit ensuite attacher ces politiques aux jeux d'autorisations ou aux rôles qui ont besoin de ces autorisations. Pour obtenir des exemples de stratégies, consultez la section [Exemples de politiques basées sur l’identité pour Amazon RDS](security_iam_id-based-policy-examples.md).
## Attacher une politique IAM à un jeu d'autorisations ou à un rôle
Après avoir créé une politique IAM pour permettre l'authentification d'une base de données, il convient d'attacher la politique à un jeu d'autorisations ou à un rôle. Pour accéder à un didacticiel sur ce sujet, veuillez consulter [Créer et attacher votre première politique gérée par le client](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) dans le *Guide de l'utilisateur IAM*.
Tandis que vous parcourez ce didacticiel, vous pouvez utiliser un exemple de politique illustré dans cette section comme point de départ afin de le personnaliser en fonction de vos besoins. À la fin de ce didacticiel, vous obtenez un jeu d'autorisations avec une politique attachée qui peut utiliser l'action `rds-db:connect`.
**Note**
Vous pouvez mapper plusieurs jeux d'autorisations ou rôles au même compte d'utilisateur de base de données. Supposons par exemple que votre politique IAM a spécifié l'ARN de ressource suivant.
```
arn:aws:rds-db:us-east-2:123456789012:dbuser:db-12ABC34DEFG5HIJ6KLMNOP78QR/jane_doe
```
Si vous attachez la politique à *Jane*, *Bob* et *Diego*, chacun de ces utilisateurs peut se connecter à l'instance de bases de données en utilisant le compte de base de données `jane_doe`.
# Création d’un compte de base de données à l’aide de l’authentification IAM
Avec l’authentification de base de données IAM, vous n’avez pas besoin d’associer de mots de passe de base de données aux comptes d’utilisateurs que vous créez. Si vous supprimez un utilisateur qui est mappé à un compte de base de données, vous devez également supprimer le compte de base de données avec l’instruction `DROP USER`.
**Note**
Le nom d’utilisateur utilisé pour l’authentification IAM doit correspondre à la casse du nom d’utilisateur dans la base de données.
**Topics**
+ [Utilisation de l’authentification IAM avec MariaDB et MySQL](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [Utilisation de l'authentification IAM avec](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)
## Utilisation de l’authentification IAM avec MariaDB et MySQL
Avec MariaDB et MySQL, l'authentification est `AWSAuthenticationPlugin` gérée AWS par un plugin fourni qui fonctionne parfaitement avec IAM pour authentifier vos utilisateurs. Connectez-vous à l’instance de base de données en tant qu’utilisateur principal ou autre utilisateur qui peut créer des utilisateurs et accorder des privilèges. Après vous être connecté, exécutez l’instruction `CREATE USER`, comme indiqué dans l’exemple suivant.
```
CREATE USER 'jane_doe' IDENTIFIED WITH AWSAuthenticationPlugin AS 'RDS';
```
La clause `IDENTIFIED WITH` permet à MariaDB et MySQL d’utiliser `AWSAuthenticationPlugin` pour authentifier le compte de base de données (`jane_doe`). La clause `AS 'RDS'` fait référence à la méthode d’authentification. Assurez-vous que le nom d’utilisateur de base de données spécifié est identique à une ressource dans la politique IAM pour l’accès à la base de données IAM. Pour de plus amples informations, veuillez consulter [Création et utilisation d'une politique IAM pour l'accès à une base de données IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md).
**Note**
Si le message suivant s'affiche, cela signifie que le plug-in AWS fourni n'est pas disponible pour le d'instances de base de données actuel.
`ERROR 1524 (HY000): Plugin 'AWSAuthenticationPlugin' is not loaded`
Pour remédier à cette erreur, vérifiez si vous utilisez une configuration prise en charge et si vous avez activé l’authentification de base de données IAM sur votre instance. Pour plus d’informations, consultez [Disponibilité des régions et des versions](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) et [Activation et désactivation de l’authentification de base de données IAM](UsingWithRDS.IAMDBAuth.Enabling.md).
Après avoir créé un compte à l’aide de `AWSAuthenticationPlugin`, vous pouvez le gérer de la même manière que les autres comptes de base de données. Vous pouvez par exemple modifier les privilèges de compte avec `GRANT` et `REVOKE`, ou changer divers attributs de compte avec l’instruction `ALTER USER`.
Le trafic réseau de base de données est crypté SSL/TLS lors de l'utilisation d'IAM. Pour autoriser les connexions SSL, modifiez le compte d’utilisateur à l’aide de la commande suivante.
```
ALTER USER 'jane_doe'@'%' REQUIRE SSL;
```
## Utilisation de l'authentification IAM avec
Pour utiliser l’authentification IAM avec PostgreSQL, connectez-vous à l’instance de base de données en tant qu’utilisateur principal ou autre utilisateur qui peut créer des utilisateurs et accorder des privilèges. Après vous être connecté, créez des utilisateurs de base de données, puis accordez-leur le rôle `rds_iam`, comme indiqué dans l’exemple suivant.
```
CREATE USER db_userx;
GRANT rds_iam TO db_userx;
```
Assurez-vous que le nom d’utilisateur de base de données spécifié est identique à une ressource dans la politique IAM pour l’accès à la base de données IAM. Pour plus d’informations, consultez [Création et utilisation d'une politique IAM pour l'accès à une base de données IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Vous devez accorder le rôle `rds_iam` pour utiliser l’authentification IAM. Vous pouvez également utiliser des appartenances imbriquées ou des octrois indirects du rôle.
# 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).
# Résolution des problèmes liés à l’authentification de base de données IAM
Vous trouverez ci-dessous des idées de dépannage pour certains problèmes courants liés à l’authentification de base de données IAM, ainsi que des informations sur les journaux CloudWatch pour l’authentification de base de données IAM.
## Exportation des journaux d’erreurs d’authentification de base de données IAM vers CloudWatch Logs
Les journaux des erreurs d’authentification de base de données IAM sont stockés sur l’hôte de la base de données, et vous pouvez les exporter vers votre compte CloudWatch Logs. Utilisez les journaux et les méthodes de correction de cette page pour résoudre les problèmes liés à l’authentification de base de données IAM.
Vous pouvez activer les exportations de journaux vers CloudWatch Logs à partir de la console AWS CLI et de l’API RDS. Pour des instructions sur l’utilisation de la console, consultez [Publication des journaux de base de données dans Amazon CloudWatch Logs](USER_LogAccess.Procedural.UploadtoCloudWatch.md).
Pour exporter vos journaux d’erreurs d’authentification de base de données IAM vers CloudWatch Logs lors de la création d’une instance de base de données à partir du AWS CLI, utilisez la commande suivante :
```
aws rds create-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--db-instance-class db.t3.large \
--allocated-storage 50 \
--engine postgres \
--engine-version 16 \
--port 5432 \
--master-username master \
--master-user-password password \
--publicly-accessible \
--enable-iam-database-authentication \
--enable-cloudwatch-logs-exports=iam-db-auth-error
```
Pour exporter vos journaux d’erreurs d’authentification de base de données IAM vers CloudWatch Logs lors de la modification d’une instance de base de données à partir du AWS CLI, utilisez la commande suivante :
```
aws rds modify-db-instance --db-instance-identifier mydbinstance \
--region us-east-1 \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["iam-db-auth-error"]}'
```
Pour vérifier si votre instance de base de données exporte les journaux d’authentification de base de données IAM vers CloudWatch Logs, vérifiez si le paramètre `EnabledCloudwatchLogsExports` est défini sur `iam-db-auth-error` dans la sortie de la commande `describe-db-instances`.
```
aws rds describe-db-instances --region us-east-1 --db-instance-identifier mydbinstance
...
"EnabledCloudwatchLogsExports": [
"iam-db-auth-error"
],
...
```
## Métriques CloudWatch pour l’authentification de base de données IAM
Amazon RDS fournit des statistiques en temps quasi réel concernant l’authentification de base de données IAM sur votre compte Amazon CloudWatch. Le tableau suivant répertorie les métriques d’authentification de base de données IAM disponibles avec CloudWatch :
| Métrique | Description |
| --- | --- |
| `IamDbAuthConnectionRequests` | Nombre total de demandes de connexion effectuées avec l’authentification de base de données IAM. |
| `IamDbAuthConnectionSuccess` | Nombre total de demandes d’authentification de base de données IAM réussies. |
| `IamDbAuthConnectionFailure` | Nombre total de demandes d’authentification de base de données IAM ayant échoué. |
| `IamDbAuthConnectionFailureInvalidToken` | Nombre total de demandes d’authentification de base de données IAM ayant échoué à cause d’un jeton non valide. |
| `IamDbAuthConnectionFailureInsufficientPermissions` | Nombre total de demandes d’authentification de base de données IAM ayant échoué en raison de politiques ou d’autorisations incorrectes. |
| `IamDbAuthConnectionFailureThrottling` | Nombre total de demandes d’authentification de base de données IAM ayant échoué en raison de la limitation de l’authentification de base de données IAM. |
| `IamDbAuthConnectionFailureServerError` | Nombre total de demandes d’authentification de base de données IAM ayant échoué en raison d’une erreur interne du serveur dans la fonctionnalité d’authentification de base de données IAM. |
## Problèmes courants et solutions correspondantes
Vous pouvez rencontrer les problèmes suivants lors de l’utilisation de l’authentification de base de données IAM. Suivez les étapes de correction indiquées dans le tableau pour résoudre les problèmes :
| Erreur | Métrique(s) | Cause | Solution |
| --- | --- | --- | --- |
| `[ERROR] Failed to authenticate the connection request for user db_user because the provided token is malformed or otherwise invalid. (Status Code: 400, Error Code: InvalidToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | Le jeton d’authentification de base de données IAM figurant dans la demande de connexion n’est pas un jeton SigV4a valide ou il n’est pas formaté correctement. | Vérifiez votre stratégie de génération de jetons dans votre application. Dans certains cas, assurez-vous de transmettre le jeton avec un formatage valide. Le fait de tronquer le jeton (ou un formatage de chaîne incorrect) le rend non valide. |
| `[ERROR] Failed to authenticate the connection request for user db_user because the token age is longer than 15 minutes. (Status Code: 400, Error Code:ExpiredToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | Le jeton d’authentification de base de données IAM a expiré. Les jetons ne sont valides que pendant 15 minutes. | Vérifiez votre logique de mise en cache et/ou de réutilisation des jetons dans votre application. Vous ne devez pas réutiliser des jetons datant de plus de 15 minutes. |
| `[ERROR] Failed to authorize the connection request for user db_user because the IAM policy assumed by the caller 'arn:aws:sts::123456789012:assumed-role/ / ' is not authorized to perform `rds-db:connect` on the DB instance. (Status Code: 403, Error Code:NotAuthorized)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInsufficientPermissions` | Cette erreur peut être due aux raisons suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.Troubleshooting.html) | Vérifiez que vous assumez le rôle et/ou la politique IAM dans votre application. Assurez-vous de suivre la même politique pour générer le jeton que pour vous connecter à la base de données. |
| `[ERROR] Failed to authorize the connection request for user db_user due to IAM DB authentication throttling. (Status Code: 429, Error Code: ThrottlingException)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Vous envoyez trop de demandes de connexion à votre base de données en peu de temps. La limite de limitation de l’authentification IAM DB est de 200 connexions par seconde. | Réduisez le taux d’établissement de nouvelles connexions grâce à l’authentification IAM. Envisagez d’implémenter le regroupement de connexions à l’aide du proxy RDS afin de réutiliser les connexions établies dans votre application. |
| `[ERROR] Failed to authorize the connection request for user db_user due to an internal IAM DB authentication error. (Status Code: 500, Error Code: InternalError)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Une erreur interne s’est produite lors de l’autorisation de la connexion à la base de données avec l’authentification de base de données IAM. | Contactez https://aws.amazon.com/premiumsupport/ pour enquêter sur le problème. |