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.
# Comprendre les rôles et les autorisations PostgreSQL
Lorsque vous créez une instance de base de RDS pour PostgreSQL à l'aide de, un compte administrateur est créé en AWS Management Console même temps. Par défaut, son nom est `postgres`, comme illustré dans la capture d'écran ci-dessous :
![\[L'identité de connexion par défaut pour les informations d'identification sur la page Create database (Créer une base de données) est postgres.\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/default-login-identity-apg-rpg.png)
Vous pouvez choisir un autre nom plutôt que d'accepter le nom par défaut (`postgres`). Le nom que vous choisissez doit commencer par une lettre et comporter entre 1 et 16 caractères alphanumériques. Par souci de simplicité, nous nous référons à ce compte utilisateur principal par sa valeur par défaut (`postgres`) tout au long de ce manuel.
Si vous utilisez le `create-db-instance` AWS CLI plutôt que le AWS Management Console, vous créez le nom en le transmettant avec le `master-username` paramètre dans la commande. Pour plus d'informations, consultez [Création d'une instance de base de données Amazon RDS](USER_CreateDBInstance.md).
Que vous utilisiez l'API AWS Management Console AWS CLI, la ou l'API Amazon RDS, que vous utilisiez le `postgres` nom par défaut ou que vous choisissiez un autre nom, ce premier compte utilisateur de base de données est membre du `rds_superuser` groupe et dispose de `rds_superuser` privilèges.
**Topics**
+ [Comprendre le rôle rds\$1superuser](Appendix.PostgreSQL.CommonDBATasks.Roles.rds_superuser.md)
+ [Contrôle de l'accès utilisateur à la base de données PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Access.md)
+ [Délégation et contrôle de la gestion des mots de passe utilisateur](Appendix.PostgreSQL.CommonDBATasks.RestrictPasswordMgmt.md)
+ [Utilisation de SCRAM pour le chiffrement de mot de passe PostgreSQL](PostgreSQL_Password_Encryption_configuration.md)
# Comprendre le rôle rds\$1superuser
Dans PostgreSQL, un *rôle* peut définir un utilisateur, un groupe ou un ensemble d’autorisations spécifiques accordées à un groupe ou à un utilisateur pour divers objets de la base de données. Les commandes PostgreSQL `CREATE USER` et `CREATE GROUP` ont été remplacées par la commande `CREATE ROLE` plus générique avec des propriétés spécifiques permettant de distinguer les utilisateurs de la base de données. Un utilisateur de base de données peut être considéré comme un rôle disposant du privilège LOGIN.
**Note**
Les commandes `CREATE USER` et `CREATE GROUP` peuvent toujours être utilisées. Pour plus d’informations, consultez [Database Roles](https://www.postgresql.org/docs/current/user-manag.html) dans la documentation de PostgreSQL.
L’utilisateur `postgres` est l’utilisateur de base de données disposant des privilèges les plus élevés sur votre instance de base de données RDS pour PostgreSQL. Il présente les caractéristiques définies par l’instruction `CREATE ROLE` suivante.
```
CREATE ROLE postgres WITH LOGIN NOSUPERUSER INHERIT CREATEDB CREATEROLE NOREPLICATION VALID UNTIL 'infinity'
```
Sauf indication contraire, les propriétés `NOSUPERUSER`, `NOREPLICATION`, `INHERIT` et `VALID UNTIL 'infinity'` sont les options par défaut de CREATE ROLE.
Par défaut, `postgres` fait en sorte que des privilèges soient octroyés au rôle `rds_superuser` ainsi que des autorisations permettant de créer des rôles et des bases de données. Le rôle `rds_superuser` permet à l’utilisateur `postgres` d’effectuer les opérations suivantes :
+ Ajoutez les extensions qu’il est possible d’utiliser avec Amazon RDS. Pour plus d’informations, consultez [Utilisation des fonctions PostgreSQL prises en charge par Amazon RDS pour PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.md)
+ Créer des rôles pour les utilisateurs et leur accorder des privilèges. Pour plus d’informations, consultez [CREATE ROLE](https://www.postgresql.org/docs/current/sql-createrole.html) et [GRANT](https://www.postgresql.org/docs/14/sql-grant.html) dans la documentation de PostgreSQL.
+ Créer des bases de données. Pour plus d’informations, consultez [CREATE DATABASE](https://www.postgresql.org/docs/14/sql-createdatabase.html) dans la documentation de PostgreSQL.
+ Accorder des privilèges `rds_superuser` aux rôles utilisateur qui ne disposent pas de ces privilèges, et révoquer les privilèges si nécessaire. Nous vous recommandons d’accorder ce rôle uniquement aux utilisateurs effectuant des tâches de super-utilisateur. En d'autres termes, vous pouvez attribuer ce rôle aux administrateurs de base de données (DBAs) ou aux administrateurs système.
+ Accorder (et révoquer) le rôle `rds_replication` aux utilisateurs de base de données qui ne possèdent pas le rôle `rds_superuser`.
+ Accorder (et révoquer) le rôle `rds_password` aux utilisateurs de base de données qui ne possèdent pas le rôle `rds_superuser`.
+ Obtenir des informations d’état sur toutes les connexions à la base de données en utilisant la vue `pg_stat_activity`. En cas de besoin, `rds_superuser` peut arrêter toutes les connexions à l’aide de `pg_terminate_backend` ou `pg_cancel_backend`.
Dans l’instruction `CREATE ROLE postgres...`, vous pouvez voir que le rôle utilisateur `postgres` rejette spécifiquement les autorisations `superuser` PostgreSQL. RDS pour PostgreSQL étant un service géré, vous ne pouvez ni accéder au système d’exploitation hôte, ni vous connecter à l’aide du compte `superuser` PostgreSQL. La plupart des tâches qui exigent un accès `superuser` sur une instance autonome de PostgreSQL sont gérées automatiquement par Amazon RDS.
Pour plus d’informations sur l’octroi de privilèges, consultez [GRANT](http://www.postgresql.org/docs/current/sql-grant.html) dans la documentation de PostgreSQL.
Le rôle `rds_superuser` est l’un des nombreux rôles *prédéfinis* d’un Instance de base de données RDS pour PostgreSQL.
**Note**
Dans PostgreSQL 13 et versions antérieures, les rôles *prédéfinis* s’appellent rôles *par défaut*.
La liste suivante répertorie certains des autres rôles prédéfinis créés automatiquement pour un nouveau Instance de base de données RDS pour PostgreSQL. Les rôles prédéfinis et leurs privilèges ne peuvent pas être modifiés. Vous ne pouvez pas supprimer, renommer ou modifier les privilèges de ces rôles prédéfinis. Toute tentative de ce type génère une erreur.
+ **rds\$1password** : rôle pouvant modifier les mots de passe et configurer des contraintes de mot de passe pour les utilisateurs de base de données. Le rôle `rds_superuser` se voit accorder ce rôle par défaut et peut accorder le rôle aux utilisateurs de base de données. Pour plus d’informations, consultez [Contrôle de l'accès utilisateur à la base de données PostgreSQLContrôle de l'accès utilisateur à PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Access.md).
+ Pour les versions de RDS pour PostgreSQL antérieures à 14, le rôle `rds_password` peut modifier les mots de passe et configurer des contraintes de mot de passe pour les utilisateurs de bases de données et les utilisateurs ayant un rôle `rds_superuser`. À partir de RDS pour PostgreSQL versions 14 et ultérieures, le rôle `rds_password` peut modifier les mots de passe et configurer des contraintes de mot de passe uniquement pour les utilisateurs de bases de données. Seuls les utilisateurs ayant le rôle `rds_superuser` peuvent effectuer ces actions sur d’autres utilisateurs ayant le rôle `rds_superuser`.
+ **rdsadmin** : rôle créé pour gérer la plupart des tâches de gestion que l’administrateur qui utilise les privilèges `superuser` aurait exécutées sur une base de données PostgreSQL autonome. Ce rôle est utilisé en interne par RDS pour PostgreSQL pour de nombreuses tâches de gestion.
+ **rdstopmgr** : rôle utilisé en interne par Amazon RDS pour prendre en charge les déploiements multi-AZ.
+ **rds\$1reserved** : rôle utilisé en interne par Amazon RDS pour réserver des connexions à la base de données.
# Affichage des rôles et de leurs privilèges
Vous pouvez afficher les rôles prédéfinis et leurs privilèges dans votre instance de base de données RDS pour PostgreSQL à l’aide de différentes commandes en fonction de votre version de PostgreSQL. Pour voir tous les rôles prédéfinis, vous pouvez vous connecter à votre instance de base de données RDS pour PostgreSQL et exécuter les commandes suivantes à l’aide de `psql`.
**Pour `psql` 15 et versions antérieures**
Connectez-vous à votre instance de base de données RDS pour PostgreSQL et utilisez la commande `\du` dans psql :
```
postgres=> \du
List of roles
Role name | Attributes | Member of
-----------------+------------------------------------------------------------+------------------------------------------------------
postgres | Create role, Create DB +| {rds_superuser}
| Password valid until infinity |
rds_ad | Cannot login | {}
rds_iam | Cannot login | {}
rds_password | Cannot login | {}
rds_replication | Cannot login | {}
rds_superuser | Cannot login | {pg_monitor,pg_signal_backend,rds_password,rds_replication}
rdsadmin | Superuser, Create role, Create DB, Replication, Bypass RLS+| {}
| Password valid until infinity |
```
**Pour `psql` 16 et versions ultérieures**
```
postgres=> \drg+
List of role grants
Role name | Member of | Options | Grantor
---------------+-----------------------------+---------------------+----------
postgres | rds_superuser | INHERIT, SET | rdsadmin
rds_superuser | pg_checkpoint | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | pg_monitor | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | pg_signal_backend | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | pg_use_reserved_connections | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | rds_password | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | rds_replication | ADMIN, INHERIT, SET | rdsadmin
```
Pour vérifier l’appartenance à un rôle sans dépendance de version, vous pouvez utiliser la requête SQL suivante :
```
SELECT m.rolname AS "Role name", r.rolname AS "Member of"
FROM pg_catalog.pg_roles m
JOIN pg_catalog.pg_auth_members pam ON (pam.member = m.oid)
LEFT JOIN pg_catalog.pg_roles r ON (pam.roleid = r.oid)
LEFT JOIN pg_catalog.pg_roles g ON (pam.grantor = g.oid)
WHERE m.rolname !~ '^pg_'
ORDER BY 1, 2;
```
Dans la sortie, vous pouvez voir que `rds_superuser` n’est pas un rôle utilisateur de base de données (il ne peut pas se connecter), mais qu’il dispose des privilèges de nombreux autres rôles. Vous pouvez également voir que l’utilisateur de base de données `postgres` est membre du rôle `rds_superuser`. Comme mentionné précédemment, `postgres` est la valeur par défaut sur la page **Create database** (Créer une base de données) de la console Amazon RDS. Si vous avez choisi un autre nom, ce nom apparaît dans la liste des rôles.
# Contrôle de l'accès utilisateur à la base de données PostgreSQL
Les nouvelles bases de données de PostgreSQL sont toujours créées avec un ensemble de privilèges par défaut dans le schéma `public` de la base de données, qui permet à tous les utilisateurs et rôles de base de données de créer des objets. Ces privilèges permettent aux utilisateurs de base de données de se connecter à la base de données, par exemple, et de créer des tables temporaires lorsqu'ils sont connectés.
Pour mieux contrôler l'accès des utilisateurs aux instances de base de données que vous créez sur votre instance de base de données RDS for PostgreSQL, nous vous recommandons de révoquer ces privilèges `public` par défaut. Vous accordez ensuite des privilèges spécifiques aux utilisateurs de base de données de manière plus détaillée, comme indiqué dans la procédure suivante.
**Pour configurer des rôles et des privilèges pour une nouvelle instance de base de données**
Supposons que vous configuriez une base de données sur une instance de base de données RDS for PostgreSQL récemment créée à l'usage de plusieurs chercheurs, qui ont tous besoin d'un accès en lecture/écriture à la base de données.
1. Utilisez `psql` (ou pgAdmin) pour vous connecter à votre instance de base de données RDS for PostgreSQL :
```
psql --host=your-db-instance.666666666666.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
Lorsque vous y êtes invité, saisissez votre mot de passe. Le client `psql` se connecte à la base de données de connexions administratives par défaut, `postgres=>`, et l'affiche sous forme d'invite.
1. Pour empêcher les utilisateurs de base de données de créer des objets dans le schéma `public`, procédez comme suit :
```
postgres=> REVOKE CREATE ON SCHEMA public FROM PUBLIC;
REVOKE
```
1. Vous créez ensuite une instance de base de données :
```
postgres=> CREATE DATABASE lab_db;
CREATE DATABASE
```
1. Révoquez tous les privilèges du schéma `PUBLIC` sur cette nouvelle base de données.
```
postgres=> REVOKE ALL ON DATABASE lab_db FROM public;
REVOKE
```
1. Créez un rôle pour les utilisateurs de base de données.
```
postgres=> CREATE ROLE lab_tech;
CREATE ROLE
```
1. Donnez aux utilisateurs de base de données disposant de ce rôle la possibilité de se connecter à la base de données.
```
postgres=> GRANT CONNECT ON DATABASE lab_db TO lab_tech;
GRANT
```
1. Accordez à tous les utilisateurs dotés du rôle `lab_tech` tous les privilèges sur cette base de données.
```
postgres=> GRANT ALL PRIVILEGES ON DATABASE lab_db TO lab_tech;
GRANT
```
1. Créez des utilisateurs de base de données, comme suit :
```
postgres=> CREATE ROLE lab_user1 LOGIN PASSWORD 'change_me';
CREATE ROLE
postgres=> CREATE ROLE lab_user2 LOGIN PASSWORD 'change_me';
CREATE ROLE
```
1. Accordez à ces deux utilisateurs les privilèges associés au rôle lab\$1tech :
```
postgres=> GRANT lab_tech TO lab_user1;
GRANT ROLE
postgres=> GRANT lab_tech TO lab_user2;
GRANT ROLE
```
À ce stade, `lab_user1` et `lab_user2` peuvent se connecter à la base de données `lab_db`. Cet exemple ne respecte pas les bonnes pratiques pour une utilisation en entreprise, qui peuvent inclure la création de plusieurs instances de base de données, différents schémas et l'octroi d'autorisations limitées. Pour des informations plus complètes et des scénarios supplémentaires, consultez [Managing PostgreSQL Users and Roles](https://aws.amazon.com/blogs//database/managing-postgresql-users-and-roles/).
Pour plus d'informations sur les privilèges dans les bases de données PostgreSQL, veuillez consulter la commande [GRANT](https://www.postgresql.org/docs/current/static/sql-grant.html) dans la documentation PostgreSQL.
# Délégation et contrôle de la gestion des mots de passe utilisateur
En tant qu'administrateur de base de données, vous souhaitez peut-être déléguer la gestion des mots de passe utilisateur. Vous souhaitez peut-être également empêcher les utilisateurs de base de données de modifier leurs mots de passe ou de reconfigurer les contraintes de mot de passe, telles que la durée de vie d'un mot de passe. Pour vous assurer que seuls les utilisateurs de base de données que vous choisissez peuvent modifier les paramètres de mot de passe, vous pouvez activer la fonctionnalité de gestion restreinte des mots de passe. Lorsque vous activez cette fonctionnalité, seuls les utilisateurs de base de données qui ont obtenu le rôle `rds_password` peuvent gérer les mots de passe.
**Note**
Pour utiliser la gestion restreinte des mots de passe, votre instance de base de données RDS for PostgreSQL doit exécuter PostgreSQL 10.6 ou versions ultérieures.
Par défaut, cette fonctionnalité est désactivée (`off`), comme illustré ci-dessous :
```
postgres=> SHOW rds.restrict_password_commands;
rds.restrict_password_commands
--------------------------------
off
(1 row)
```
Pour l'activer, vous utilisez un groupe de paramètres personnalisé et redéfinissez le paramètre `rds.restrict_password_commands` sur 1. Assurez-vous de redémarrer votre instance de base de données RDS for PostgreSQL pour que le réglage prenne effet.
Lorsque cette fonctionnalité est activée, les privilèges `rds_password` sont requis pour les commandes SQL suivantes :
```
CREATE ROLE myrole WITH PASSWORD 'mypassword';
CREATE ROLE myrole WITH PASSWORD 'mypassword' VALID UNTIL '2023-01-01';
ALTER ROLE myrole WITH PASSWORD 'mypassword' VALID UNTIL '2023-01-01';
ALTER ROLE myrole WITH PASSWORD 'mypassword';
ALTER ROLE myrole VALID UNTIL '2023-01-01';
ALTER ROLE myrole RENAME TO myrole2;
```
Le changement de nom d'un rôle (`ALTER ROLE myrole RENAME TO newname`) est également restreint si le mot de passe utilise l'algorithme de MD5 hachage.
Lorsque cette fonctionnalité est activée, toute tentative d'exécution de l'une de ces commandes SQL sans les autorisations de rôle `rds_password` génère l'erreur suivante :
```
ERROR: must be a member of rds_password to alter passwords
```
Nous vous recommandons de n'accorder `rds_password` qu'à quelques rôles utilisés exclusivement pour la gestion des mots de passe. Si vous accordez des privilèges `rds_password` aux utilisateurs de base de données qui ne disposent pas de privilèges `rds_superuser`, vous devez également leur accorder l'attribut `CREATEROLE`.
Assurez-vous de vérifier les exigences de mot de passe telles que la date d'expiration et le niveau de complexité requis du côté du client. Si vous utilisez votre propre utilitaire côté client pour les modifications relatives aux mots de passe, l'utilitaire doit être membre de `rds_password` et disposer des privilèges `CREATE ROLE`.
# Utilisation de SCRAM pour le chiffrement de mot de passe PostgreSQL
Le *mécanisme d'authentification Salted Challenge Response (SCRAM)* est une alternative à l'algorithme message digest (MD5) par défaut de PostgreSQL pour chiffrer les mots de passe. Le mécanisme d'authentification SCRAM est considéré comme plus sûr que. MD5 Pour en savoir plus sur ces deux approches différentes de sécurisation des mots de passe, consultez [Password Authentication](https://www.postgresql.org/docs/14/auth-password.html) (Authentification par mot de passe) dans la documentation PostgreSQL.
Nous vous recommandons d'utiliser SCRAM plutôt que MD5 comme schéma de chiffrement de mot de passe pour votre cluster de bases de données . Instance de base de données RDS pour PostgreSQL. Il s’agit d’un mécanisme stimulation/réponse cryptographique qui utilise l’algorithme scram-sha-256 pour l’authentification par mot de passe et le chiffrement de mot de passe.
Vous devrez peut-être mettre à jour les bibliothèques pour vos applications clientes de sorte qu’elles prennent en charge SCRAM. Par exemple, les versions JDBC antérieures à 42.2.0 ne prennent pas en charge SCRAM. Pour plus d’informations, consultez [PostgreSQL JDBC Driver](https://jdbc.postgresql.org/changelogs/2018-01-17-42.2.0-release/) (Pilote JDBC PostgreSQL) dans la documentation du pilote JDBC PostgreSQL. Pour obtenir la liste des autres pilotes PostgreSQL prenant en charge SCRAM, consultez la [liste des pilotes](https://wiki.postgresql.org/wiki/List_of_drivers) dans la documentation PostgreSQL.
RDS pour PostgreSQL versions 13.1 et ultérieures prennent en charge scram-sha-256. Ces versions vous permettent également de configurer votre instance de base de données pour qu’elle requiert SCRAM, comme indiqué dans les procédures suivantes.
## Configuration du cluster de de base de données PostgreSQL nécessite de la SCRAM
Pour , vous pouvez exiger que l’instance de base de données RDS pour PostgreSQL n’accepte que les mots de passe qui utilisent l’algorithme scram-sha-256.
**Important**
Pour les proxys RDS existants avec des bases de données PostgreSQL, si vous modifiez l’authentification de base de données pour utiliser uniquement `SCRAM`, le proxy devient indisponible pendant 60 secondes au maximum. Pour éviter ce problème, effectuez l’une des actions suivantes :
Veillez à ce que la base de données permette à la fois l’authentification `SCRAM` et `MD5`.
Pour utiliser uniquement l’authentification `SCRAM`, créez un nouveau proxy, migrez le trafic de votre application vers ce nouveau proxy, puis supprimez le proxy précédemment associé à la base de données.
Avant d’apporter des modifications à votre système, assurez-vous de bien comprendre le processus complet, comme suit :
+ Obtenez des informations sur tous les rôles et sur le chiffrement des mots de passe pour tous les utilisateurs de base de données.
+ Revérifiez les paramètres de votre instance de base de données RDS pour PostgreSQL qui contrôlent le chiffrement des mots de passe.
+ Si votre instance de base de données RDS pour PostgreSQL utilise un groupe de paramètres par défaut, vous devez créer un groupe de paramètres de base de données personnalisé et l’appliquer à votre instance de base de données RDS pour PostgreSQL de sorte à pouvoir modifier les paramètres si nécessaire. Si votre instance de base de données RDS pour PostgreSQL utilise un groupe de paramètres personnalisé, vous pouvez modifier ultérieurement les paramètres nécessaires dans le processus, selon vos besoins.
+ Remplacez le paramètre `password_encryption` par `scram-sha-256`.
+ Informez tous les utilisateurs de la base de données qu’ils doivent mettre à jour leurs mots de passe. Faites de même pour votre compte `postgres`. Les nouveaux mots de passe sont chiffrés et stockés à l’aide de l’algorithme scram-sha-256.
+ Vérifiez que tous les mots de passe utilisent le même type de chiffrement.
+ Si tous les mots de passe utilisent scram-sha-256, vous pouvez modifier le paramètre `rds.accepted_password_auth_method` de `md5+scram` à `scram-sha-256`.
**Avertissement**
Après avoir changé `rds.accepted_password_auth_method` pour scram-sha-256 uniquement, tous les utilisateurs (rôles) avec des mots de passe chiffrés par `md5` ne peuvent pas se connecter.
### Préparez-vous à avoir besoin de SCRAM pour votre instance de base de données
Avant d’apporter des modifications à votre instance de base de données RDS pour PostgreSQL, vérifiez tous les comptes utilisateurs de base de données existants. Vérifiez également le type de chiffrement utilisé pour les mots de passe. Pour ce faire, utilisez l’extension `rds_tools`. Pour savoir quelles versions de PostgreSQL prennent en charge `rds_tools`, consultez [Versions d’extension pour Amazon RDS pour PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html).
**Pour obtenir la liste des utilisateurs de base de données (rôles) et des méthodes de chiffrement des mots de passe**
1. Utilisez `psql` pour vous connecter à votre instance de base de données RDS pour PostgreSQL, comme suit.
```
psql --host=db-name.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Installez l’extension `rds_tools`.
```
postgres=> CREATE EXTENSION rds_tools;
CREATE EXTENSION
```
1. Obtenez la liste des rôles et des méthodes de chiffrement.
```
postgres=> SELECT * FROM
rds_tools.role_password_encryption_type();
```
Vous voyez des résultats similaires à ce qui suit.
```
rolname | encryption_type
----------------------+-----------------
pg_monitor |
pg_read_all_settings |
pg_read_all_stats |
pg_stat_scan_tables |
pg_signal_backend |
lab_tester | md5
user_465 | md5
postgres | md5
(8 rows)
```
### Création d’un groupe de paramètres de base de données personnalisé
**Note**
Si votre instance de base de données RDS pour PostgreSQL utilise déjà un groupe de paramètres personnalisé, vous n’avez pas besoin d’en créer un.
Pour obtenir un aperçu des groupes de paramètres pour Amazon RDS, consultez [Utilisation de paramètres sur votre instance de base de données RDS pour PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Parameters.md).
Le type de chiffrement utilisé pour les mots de passe est défini dans un paramètre, `password_encryption`. Le chiffrement autorisé par l’instance de base de données RDS pour PostgreSQL est défini dans un autre paramètre, `rds.accepted_password_auth_method`. Le remplacement de l’un de ces paramètres par une valeur autre que celle par défaut requiert de créer un groupe de paramètres de base de données personnalisé et de l’appliquer à votre instance.
Vous pouvez également utiliser l'API AWS Management Console ou l'API RDS pour créer un de base de données personnalisé. Pour plus d'informations, consultez
Vous pouvez maintenant employer le groupe de paramètres personnalisés avec votre instance de base de données.
**Pour créer un groupe de de paramètres de base de données**
1. Utilisez la commande CLI `[create-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-parameter-group.html) ` pour créer le groupe de paramètres de base de données personnalisé. Cet exemple utilise `postgres13` comme source pour ce groupe de paramètres personnalisé.
Pour Linux, macOS ou Unix :
```
aws rds create-db-parameter-group --db-parameter-group-name 'docs-lab-scram-passwords' \
--db-parameter-group-family postgres13 --description 'Custom parameter group for SCRAM'
```
Pour Windows :
```
aws rds create-db-parameter-group --db-parameter-group-name "docs-lab-scram-passwords" ^
--db-parameter-group-family postgres13 --description "Custom DB parameter group for SCRAM"
```
1. Utilisez la commande CLI `[modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)` pour appliquer ce groupe de paramètres personnalisé à votre cluster de bases de données RDS pour PostgreSQL.
Pour Linux, macOS ou Unix :
```
aws rds modify-db-instance --db-instance-identifier 'your-instance-name' \
--db-parameter-group-name "docs-lab-scram-passwords
```
Pour Windows :
```
aws rds modify-db-instance --db-instance-identifier "your-instance-name" ^
--db-parameter-group-name "docs-lab-scram-passwords
```
Pour resynchroniser votre instance de base de données RDS pour PostgreSQL avec votre groupe de paramètres de base de données personnalisé, vous devez redémarrer l’instance principale et toutes les autres instances du cluster. Planifiez cette opération pendant votre fenêtre de maintenance habituelle afin de minimiser l’impact sur vos utilisateurs.
### Configuration du chiffrement des mots de passe pour utiliser SCRAM
Le mécanisme de chiffrement du mot de passe utilisé par une instance de base de données RDS pour PostgreSQL est défini(e) dans le groupe de paramètres de base de données dans le paramètre `password_encryption`. Les valeurs autorisées incluent une valeur non définie, `md5` ou `scram-sha-256`. La valeur par défaut dépend de la version de RDS pour PostgreSQL, comme suit :
+ RDS pour PostgreSQL versions 14 et ultérieures : la valeur par défaut est `scram-sha-256`
+ RDS pour PostgreSQL 13 : la valeur par défaut est `md5`
En attachant un groupe de paramètres de base de données personnalisé à votre instance de base de données RDS pour PostgreSQL, vous pouvez modifier les valeurs du paramètre de chiffrement des mots de passe.
![\[Puis, la console RDS affiche les valeurs par défaut des paramètres password_encryption pour RDS pour PostgreSQL.\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/rpg-pwd-encryption-md5-scram-1.png)
**Pour remplacer le paramètre de chiffrement des mots de passe par scram-sha-256**
+ Remplacez la valeur du chiffrement des mots de passe par scram-sha-256, comme indiqué ci-après. Cette modification peut être appliquée immédiatement, car le paramètre est dynamique. Aucun redémarrage n’est donc nécessaire pour que la modification soit appliquée.
Pour Linux, macOS ou Unix :
```
aws rds modify-db-parameter-group --db-parameter-group-name \
'docs-lab-scram-passwords' --parameters 'ParameterName=password_encryption,ParameterValue=scram-sha-256,ApplyMethod=immediate'
```
Pour Windows :
```
aws rds modify-db-parameter-group --db-parameter-group-name ^
"docs-lab-scram-passwords" --parameters "ParameterName=password_encryption,ParameterValue=scram-sha-256,ApplyMethod=immediate"
```
### Migration des mots de passe des rôles utilisateur vers SCRAM
Vous pouvez migrer les mots de passe pour les rôles d’utilisateur vers SCRAM comme décrit ci-dessous.
**Pour migrer les mots de passe des utilisateurs (rôles) de base de données MD5 vers SCRAM**
1. Connectez-vous en tant qu’utilisateur administrateur (nom d’utilisateur par défaut, `postgres`) comme suit.
```
psql --host=db-name.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Vérifiez la valeur du paramètre `password_encryption` sur votre instance de base de données RDS pour PostgreSQL à l’aide de la commande suivante.
```
postgres=> SHOW password_encryption;
password_encryption
---------------------
md5
(1 row)
```
1. Remplacez la valeur de ce paramètre par scram-sha-256. Pour de plus amples informations, veuillez consulter [Configuration du chiffrement des mots de passe pour utiliser SCRAM](#PostgreSQL_Password_Encryption_configuration.configure-password-encryption).
1. Vérifiez à nouveau la valeur pour vous assurer qu’elle est maintenant réglée sur `scram-sha-256`, comme suit.
```
postgres=> SHOW password_encryption;
password_encryption
---------------------
scram-sha-256
(1 row)
```
1. Demandez à tous les utilisateurs de base de données de modifier leurs mots de passe. Veillez également à modifier votre propre mot de passe pour le compte `postgres` (utilisateur de base de données avec privilèges `rds_superuser`).
```
labdb=> ALTER ROLE postgres WITH LOGIN PASSWORD 'change_me';
ALTER ROLE
```
1. Répétez l’opération pour toutes les bases de données de votre Instance de base de données RDS pour PostgreSQL.
### Modification du paramètre de sorte à utiliser SCRAM
Il s’agit de la dernière étape du processus. Une fois que vous avez effectué la modification de la procédure suivante, tous les comptes utilisateurs (rôles) qui utilisent toujours le chiffrement `md5` pour les mots de passe ne pourront pas se connecter au Instance de base de données RDS pour PostgreSQL.
Le paramètre `rds.accepted_password_auth_method` spécifie la méthode de chiffrement acceptée par l’instance de base de données RDS pour PostgreSQL pour un mot de passe utilisateur pendant le processus de connexion. La valeur par défaut est `md5+scram`, ce qui signifie que l’une des méthodes est acceptée. L’image suivante indique la valeur par défaut de ce paramètre.
![\[La console RDS affiche les valeurs par défaut et autorisées pour les paramètres rds.accepted_password_auth_method.\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/pwd-encryption-md5-scram-2.png)
Les valeurs autorisées pour ce paramètre sont `md5+scram` ou `scram`. Si la valeur de ce paramètre est remplacée par `scram`, le paramètre devient obligatoire.
**Pour modifier la valeur du paramètre afin d’exiger l’authentification SCRAM pour les mots de passe**
1. Vérifiez que tous les mots de passe utilisateur de toutes les bases de données de votre instance de base de données RDS pour PostgreSQL utilisent `scram-sha-256` pour le chiffrement des mots de passe. Pour ce faire, interrogez `rds_tools` pour obtenir le rôle (utilisateur) et le type de chiffrement, comme suit.
```
postgres=> SELECT * FROM rds_tools.role_password_encryption_type();
rolname | encryption_type
----------------------+-----------------
pg_monitor |
pg_read_all_settings |
pg_read_all_stats |
pg_stat_scan_tables |
pg_signal_backend |
lab_tester | scram-sha-256
user_465 | scram-sha-256
postgres | scram-sha-256
( rows)
```
1. Répétez la requête sur toutes les instances de base de données de votre Instance de base de données RDS pour PostgreSQL.
Si tous les mots de passe utilisent scram-sha-256, vous pouvez continuer.
1. Remplacez la valeur de l’authentification par mot de passe acceptée par scram-sha-256, comme suit.
Pour Linux, macOS ou Unix :
```
aws rds modify-db-parameter-group --db-parameter-group-name 'docs-lab-scram-passwords' \
--parameters 'ParameterName=rds.accepted_password_auth_method,ParameterValue=scram,ApplyMethod=immediate'
```
Pour Windows :
```
aws rds modify-db-parameter-group --db-parameter-group-name "docs-lab-scram-passwords" ^
--parameters "ParameterName=rds.accepted_password_auth_method,ParameterValue=scram,ApplyMethod=immediate"
```