# Descripción de los roles y permisos de PostgreSQL Al crear una instancia de base de datos de RDS for PostgreSQL utilizando la Consola de administración de AWS, se crea una cuenta de administrador al mismo tiempo. De forma predeterminada su nombre es `postgres`, tal y como se muestra en la siguiente captura de pantalla: ![\[La identidad de inicio de sesión predeterminada para las credenciales en la página Create database (Crear base de datos) es postgres.\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/default-login-identity-apg-rpg.png) Puede elegir otro nombre en lugar de aceptar el valor predeterminado (`postgres`). Si lo hace, el nombre que elija debe empezar por una letra y tener entre 1 y 16 caracteres alfanuméricos. Por simplicidad, nos referimos a esta cuenta de usuario principal por su valor predeterminado (`postgres`) en toda esta guía. Si utiliza `create-db-instance` de la AWS CLI en lugar de la Consola de administración de AWS, crea el nombre pasándolo con el parámetro `master-username` en el comando. Para obtener más información, consulte [Creación de una instancia de base de datos de Amazon RDS](USER_CreateDBInstance.md). Ya sea que utilice la Consola de administración de AWS, la AWS CLI o la API de Amazon RDS y si usa el nombre predeterminado `postgres` o elige otro nombre, esta primera cuenta de usuario de la base de datos es miembro del grupo `rds_superuser` y tiene `rds_superuser` privilegios. **Topics** + [Descripción del rol rds\$1superuser](Appendix.PostgreSQL.CommonDBATasks.Roles.rds_superuser.md) + [Control del acceso de los usuarios a la base de datos de PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Access.md) + [Delegación y control de la administración de contraseñas de usuario](Appendix.PostgreSQL.CommonDBATasks.RestrictPasswordMgmt.md) + [Uso de SCRAM para el cifrado de contraseñas de PostgreSQL](PostgreSQL_Password_Encryption_configuration.md) # Descripción del rol rds\$1superuser En PostgreSQL, un *rol* puede definir un usuario, un grupo o un conjunto de permisos específicos concedidos a un grupo o usuario para varios objetos de la base de datos. Comandos de PostgreSQL para `CREATE USER` y `CREATE GROUP` se han sustituidos por los más generales, `CREATE ROLE` con propiedades específicas para distinguir a los usuarios de bases de datos. Un usuario de base de datos se puede concebir como un rol con el privilegio LOGIN. **nota** Los comandos `CREATE USER` y `CREATE GROUP` se pueden seguir utilizando. Para obtener más información, consulte [Roles de base de datos](https://www.postgresql.org/docs/current/user-manag.html) en la documentación de PostgreSQL. El usuario `postgres` es el usuario de base de datos más privilegiado de la instancia de base de datos de RDS for PostgreSQL. Tiene las características definidas mediante la siguiente instrucción `CREATE ROLE`. ``` CREATE ROLE postgres WITH LOGIN NOSUPERUSER INHERIT CREATEDB CREATEROLE NOREPLICATION VALID UNTIL 'infinity' ``` Las propiedades `NOSUPERUSER`, `NOREPLICATION`, `INHERIT` y `VALID UNTIL 'infinity'` son las opciones predeterminadas de CREATE ROLE, a menos que se especifique lo contrario. De forma predeterminada, `postgres` tiene privilegios otorgados al rol `rds_superuser` y permisos para crear roles y bases de datos. El rol `rds_superuser` permite al usuario `postgres` hacer lo siguiente: + Añadir extensiones que estén disponibles para el uso con Amazon RDS. Para obtener más información, consulte [Uso de las características de PostgreSQL admitidas por Amazon RDS para PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.md) + Cree roles para los usuarios y conceder privilegios a los usuarios. Para obtener más información, consulte [CREATE ROLE](https://www.postgresql.org/docs/current/sql-createrole.html) y [GRANT](https://www.postgresql.org/docs/14/sql-grant.html) en la documentación de PostgreSQL. + Creación de bases de datos Para obtener más información, consulte [CREATE DATABASE](https://www.postgresql.org/docs/14/sql-createdatabase.html) en la documentación de PostgreSQL. + Conceder privilegios de `rds_superuser` a los roles de usuario que no tengan estos privilegios y revocarlos según sea necesario. Le recomendamos que conceda este rol solo a los usuarios que realizan tareas de superusuario. En otras palabras, puede conceder este rol a los administradores de bases de datos (DBA) o a los administradores del sistema. + Conceda (y revoque) el rol `rds_replication` a usuarios de bases de datos que no tengan el rol `rds_superuser`. + Conceder (y revocar) el rol `rds_password` a usuarios de bases de datos que no tengan el rol `rds_superuser`. + Obtener información de estado sobre todas las conexiones de base de datos mediante la vista `pg_stat_activity`. Cuando sea necesario, `rds_superuser` puede detener cualquier conexión mediante `pg_terminate_backend` o `pg_cancel_backend`. En la instrucción `CREATE ROLE postgres...`, se puede ver que el rol de usuario `postgres` no permite específicamente permisos `superuser` de PostgreSQL. RDS for PostgreSQL es un servicio administrado, por lo que no puede acceder al sistema operativo host y no puede conectarse con la cuenta `superuser` de PostgreSQL. Muchas de las tareas que requieren acceso `superuser` en un PostgreSQL independiente se administra automáticamente mediante Amazon RDS. Para obtener más información sobre la concesión de privilegios, consulte [GRANT](http://www.postgresql.org/docs/current/sql-grant.html) en la documentación de PostgreSQL. El rol `rds_superuser` es uno de varios roles *predefinidos* en un Instancia de base de datos RDS for PostgreSQL. **nota** En PostgreSQL 13 y versiones anteriores, los roles *predefinidos* se denominan roles *predeterminados*. En la siguiente lista encontrará algunos de los otros roles predefinidos que se crean automáticamente para un nuevo Instancia de base de datos RDS para PostgreSQL. Los roles predefinidos y sus privilegios no se pueden cambiar. No se pueden eliminar, cambiar de nombre ni modificar los privilegios de estos roles predefinidos. Intentar realizar una de estas operaciones producirá un error. + **rds\$1password**: rol que puede cambiar las contraseñas y configurar restricciones de contraseña para los usuarios de bases de datos. Al rol `rds_superuser` se le otorga este rol de forma predeterminada y puede otorgarlo a los usuarios de la base de datos. Para obtener más información, consulte [Control del acceso de los usuarios a la base de datos de PostgreSQLControl del acceso de los usuarios a PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Access.md). + En las versiones de RDS para PostgreSQL anteriores a la 14, el rol `rds_password` puede cambiar las contraseñas y establecer restricciones de contraseña para los usuarios de la base de datos y los usuarios con el rol `rds_superuser`. A partir de la versión 14 de RDS para PostgreSQL, el rol `rds_password` puede cambiar las contraseñas y establecer restricciones de contraseña solo para los usuarios de la base de datos. Solo los usuarios con el rol `rds_superuser` pueden realizar estas acciones en otros usuarios con el rol `rds_superuser`. + **rdsadmin**: rol creado para administrar muchas de las tareas de administración que el administrador con privilegios de `superuser` realizaría en una base de datos PostgreSQL independiente. Este rol lo utiliza internamente RDS for PostgreSQLpara muchas tareas de administración. + **rdstopmgr**: rol que Amazon RDS utiliza internamente para admitir implementaciones multi-AZ. + **rds\$1reserved**: función que Amazon RDS utiliza internamente para reservar conexiones a bases de datos. # Visualización los de roles y sus privilegios Puede ver los roles predefinidos y sus privilegios en la instancia de base de datos de RDS para PostgreSQL mediante distintos comandos en función de la versión de PostgreSQL. Para ver todos los roles predefinidos, puede conectarse a la instancia de base de datos de RDS para PostgreSQL y ejecutar los siguientes comandos con `psql`. **Para `psql` 15 y versiones anteriores** Conéctese a la instancia de base de datos de RDS para PostgreSQL y use el comando `\du` en 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 | ``` **Para `psql` 16 y versiones posteriores** ``` 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 ``` Para comprobar la pertenencia al rol sin dependencia de versiones, puede utilizar la siguiente consulta SQL: ``` 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; ``` En la salida, puede ver que `rds_superuser` no es un rol de usuario de base de datos (no puede iniciar sesión), pero tiene los privilegios de muchos otros roles. También puede ver que el usuario de la base de datos `postgres` es miembro del rol `rds_superuser`. Como se ha mencionado anteriormente, `postgres` es el valor predeterminado de **Create database (Crear base de datos)** de la consola de Amazon RDS. Si ha elegido otro nombre, ese nombre se muestra en la lista de roles. # Control del acceso de los usuarios a la base de datos de PostgreSQL Las nuevas bases de datos de PostgreSQL siempre se crean con un conjunto predeterminado de privilegios en el esquema `public` de la base de datos que permite a todos los usuarios y roles de la base de datos crear objetos. Estos privilegios permiten a los usuarios de la base de datos conectarse a la base de datos, or ejemplo, y crear tablas temporales mientras están conectados. Para controlar mejor el acceso de los usuarios a las instancias de bases de datos que cree en su instancia de base de datos de RDS for PostgreSQL, le recomendamos que revoque estos privilegios de `public` predeterminados. Después de ello, conceda a continuación los privilegios específicos a los usuarios de base de datos de forma más detallada, como se muestra en el siguiente procedimiento. **Para configurar roles y privilegios para una nueva instancia de base de datos** Supongamos que está configurando una base de datos en Instancia de base de datos de RDS for PostgreSQL de reciente creación para que lo utilicen varios investigadores, todos los cuales necesitan acceso de lectura y escritura a la base de datos. 1. Use `psql` (o pgAdmin) para conectarse a su instancia de base de datos de RDS for PostgreSQL: ``` psql --host=your-db-instance.666666666666.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password ``` Escriba la contraseña cuando se le solicite. El cliente `psql` se conecta y muestra la base de datos de conexión administrativa predeterminada, `postgres=>`, como el símbolo del sistema. 1. Para evitar que los usuarios de la base de datos creen objetos en el esquema `public`, realice una de las siguientes opciones: ``` postgres=> REVOKE CREATE ON SCHEMA public FROM PUBLIC; REVOKE ``` 1. A continuación, cree una nueva instancia de base de datos: ``` postgres=> CREATE DATABASE lab_db; CREATE DATABASE ``` 1. Revoque todos los privilegios del esquema `PUBLIC` de esta nueva base de datos. ``` postgres=> REVOKE ALL ON DATABASE lab_db FROM public; REVOKE ``` 1. Cree un rol para los usuarios de bases de datos. ``` postgres=> CREATE ROLE lab_tech; CREATE ROLE ``` 1. Otorgue a los usuarios de bases de datos que tengan este rol la posibilidad de conectarse a la base de datos. ``` postgres=> GRANT CONNECT ON DATABASE lab_db TO lab_tech; GRANT ``` 1. Conceda a todos los usuarios que tengan el rol `lab_tech` todos los privilegios de esta base de datos. ``` postgres=> GRANT ALL PRIVILEGES ON DATABASE lab_db TO lab_tech; GRANT ``` 1. Cree usuarios de bases de datos de la siguiente manera: ``` postgres=> CREATE ROLE lab_user1 LOGIN PASSWORD 'change_me'; CREATE ROLE postgres=> CREATE ROLE lab_user2 LOGIN PASSWORD 'change_me'; CREATE ROLE ``` 1. Conceda a estos dos usuarios los privilegios asociados al rol lab\$1tech: ``` postgres=> GRANT lab_tech TO lab_user1; GRANT ROLE postgres=> GRANT lab_tech TO lab_user2; GRANT ROLE ``` En este punto,`lab_user1` y `lab_user2` se pueden conectar a la base de datos de `lab_db`. En este ejemplo no se siguen las prácticas recomendadas para el uso empresarial, que pueden incluir la creación de varias instancias de base de datos, distintos esquemas y la concesión de permisos limitados. Para obtener más información y escenarios adicionales, consulte [Administración de usuarios y roles de PostgreSQL](https://aws.amazon.com/blogs//database/managing-postgresql-users-and-roles/). Para obtener más información sobre los privilegios en las bases de datos de PostgreSQL, consulte el comando [GRANT](https://www.postgresql.org/docs/current/static/sql-grant.html) en la documentación de PostgreSQL. # Delegación y control de la administración de contraseñas de usuario Como DBA, es posible que desee delegar la administración de contraseñas de usuario. O bien, puede que desee evitar que los usuarios de la base de datos cambien sus contraseñas o reconfiguren las restricciones de contraseña, como la duración de la contraseña. Para asegurarse de que solo los usuarios de la base de datos que elija puedan cambiar la configuración de contraseñas, puede activar la función de administración de contraseñas restringidas. Cuando activa esta función, solo pueden administrar contraseñas aquellos usuarios de base de datos a los que se les haya concedido el rol `rds_password`. **nota** Para utilizar la administración de contraseñas restringida, su instancia de base de datos RDS for PostgreSQL debe estar ejecutando para 10.6 o una versión posterior. De forma predeterminada, esta función es `off`, tal y como se muestra en el ejemplo siguiente: ``` postgres=> SHOW rds.restrict_password_commands; rds.restrict_password_commands -------------------------------- off (1 row) ``` Para activar esta función, utilice un grupo de parámetros personalizado y cambie la configuración de `rds.restrict_password_commands` a 1. Asegúrese de reiniciar su Instancia de base de datos de RDS for PostgreSQL para que la configuración surta efecto. Con esta función activa, se necesitan privilegios de `rds_password` para los siguientes comandos SQL: ``` 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; ``` Cambiar el nombre de un rol (`ALTER ROLE myrole RENAME TO newname`) también está restringido si la contraseña utiliza el algoritmo hash MD5. Con esta función activa, intentar cualquiera de estos comandos SQL sin los permisos de rol `rds_password`, genera el siguiente error: ``` ERROR: must be a member of rds_password to alter passwords ``` Recomendamos que otorgar el `rds_password` solamente a unos cuantos roles que utilice únicamente para la administración de contraseñas. Si concede privilegios de `rds_password` a usuarios de bases de datos que no tengan privilegios de `rds_superuser`, también debe otorgarles el atributo `CREATEROLE`. Asegúrese de que comprueba los requisitos de las contraseñas del lado del cliente, como el vencimiento y la complejidad necesaria. Si utiliza su propia utilidad del lado del cliente para cambios relacionados con la contraseña, la utilidad debe ser miembro de `rds_password` tener privilegios de `CREATE ROLE`. # Uso de SCRAM para el cifrado de contraseñas de PostgreSQL El mecanismo de autenticación mediante *desafío-respuesta discontinuo (SCRAM)* es una alternativa al algoritmo de resumen de mensajes (MD5) predeterminado de PostgreSQL para cifrar contraseñas. El mecanismo de autenticación SCRAM se considera más seguro que MD5. Para obtener más información sobre estos dos enfoques diferentes para proteger las contraseñas, consulte [Password Authentication](https://www.postgresql.org/docs/14/auth-password.html) (Autenticación de contraseñas) en la documentación de PostgreSQL. Le recomendamos que utilice SCRAM en lugar de MD5 como esquema de cifrado de contraseñas para su . Instancia de base de datos RDS para PostgreSQL. Es un mecanismo criptográfico de desafío-respuesta que utiliza el algoritmo scram-sha-256 algorithm para la autenticación y el cifrado de contraseñas. Es posible que deba actualizar las bibliotecas de las aplicaciones cliente para que sean compatibles con SCRAM. Por ejemplo, las versiones de JDBC anteriores a la 42.2.0 no admiten SCRAM. Para obtener más información, consulte [PostgreSQL JDBC Driver](https://jdbc.postgresql.org/changelogs/2018-01-17-42.2.0-release/) (Controlador JDBC de PostgreSQL) en la documentación del controlador JDBC de PostgreSQL. Para ver una lista de otros controladores de PostgreSQL y la compatibilidad con SCRAM, consulte [List of drivers](https://wiki.postgresql.org/wiki/List_of_drivers) (Lista de controladores) en la documentación de PostgreSQL. RDS para PostgreSQL versión 13.1 y posteriores admite scram-sha-256. Estas versiones también le permiten configurar la instancia de la base de datos para que requiera SCRAM, como se explica en los siguientes procedimientos. ## Configuración de la instancia de base de datos de RDS para PostgreSQL para que requiera SCRAM puede requerir que la instancia de RDS para PostgreSQL DB acepte únicamente contraseñas que utilicen el algoritmo scram-sha-256. **importante** En el caso de los proxies RDS existentes con bases de datos de PostgreSQL, si modifica la autenticación de la base de datos para utilizar únicamente `SCRAM`, el proxy dejará de estar disponible durante un máximo de 60 segundos. Para evitar este problema, lleve a cabo alguna de las siguientes operaciones: Asegúrese de que la base de datos permita la autenticación `SCRAM` y `MD5`. Para utilizar únicamente la autenticación `SCRAM`, cree un nuevo proxy, migre el tráfico de la aplicación al nuevo proxy y, a continuación, elimine el proxy previamente asociado a la base de datos. Antes de realizar cambios en el sistema, asegúrese de entender el proceso completo, como se indica a continuación: + Obtenga información sobre todos los roles y el cifrado de las contraseñas de todos los usuarios de la base de datos. + Compruebe de nuevo la configuración de los parámetros de la instancia de base de datos de Aurora correspondiente a los parámetros que controlan el cifrado de las contraseñas. + Si la instancia de base de datos de RDS para PostgreSQL utiliza un grupo de parámetros predeterminado, deberá crear un grupo de parámetros de base de datos personalizado y aplicarlo a la instancia de base de datos de RDS para PostgreSQL para poder modificar los parámetros cuando sea necesario. Si la instancia de base de datos de RDS para PostgreSQL utiliza un grupo de parámetros personalizado, puede modificar los parámetros necesarios más adelante en el proceso, según sea necesario. + Cambie el parámetro `password_encryption` por `scram-sha-256`. + Notifique a todos los usuarios de la base de datos que deben actualizar las contraseñas. Haga lo mismo con su cuenta de `postgres`. Las nuevas contraseñas se cifran y almacenan mediante el algoritmo scram-sha-256. + Verifique que todas las contraseñas están cifradas con el tipo de cifrado. + Si todas las contraseñas utilizan scram-sha-256, puede cambiar el parámetro `rds.accepted_password_auth_method` de `md5+scram` a `scram-sha-256`. **aviso** Después de cambiar `rds.accepted_password_auth_method` a scram-sha-256 únicamente, no podrá conectarse ningún usuario (rol) con una contraseña cifrada con `md5`. ### Preparación para requerir SCRAM para su instancia de base de datos de RDS para PostgreSQL Antes de realizar cambios en la instancia de RDS para PostgreSQL, compruebe todas las cuentas de usuario de base de datos existentes. Compruebe también el tipo de cifrado utilizado para las contraseñas. Puede hacer estas tareas con la extensión `rds_tools`. Para ver qué versiones de PostgreSQL son compatibles con `rds_tools`, consulte [Versiones de extensión para Amazon RDS para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html). **Para obtener una lista de usuarios de base de datos (roles) y métodos de cifrado de contraseñas** 1. Use `psql` para conectarse a la instancia de base de datos de RDS para PostgreSQL, tal como se muestra a continuación. ``` psql --host=db-name.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password ``` 1. Instale la extensión de `rds_tools`. ``` postgres=> CREATE EXTENSION rds_tools; CREATE EXTENSION ``` 1. Obtenga una lista de los roles y el cifrado. ``` postgres=> SELECT * FROM rds_tools.role_password_encryption_type(); ``` Se muestra una salida similar a la siguiente. ``` 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) ``` ### Creación de un grupo de parámetros de base de datos personalizado **nota** Si la instancia de base de datos de RDS para PostgreSQL ya utiliza un grupo de parámetros personalizado, no necesita crear uno nuevo. Para obtener información general sobre los grupos de parámetros para Amazon RDS, consulte [Uso de parámetros en su instancia de base de datos de RDS for PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Parameters.md). El tipo de cifrado de contraseñas que se usa para las contraseñas se establece a un parámetro, `password_encryption`. El cifrado que permite la instancia de base de datos de RDS para PostgreSQL se establece a otro parámetro, `rds.accepted_password_auth_method`. Para cambiar cualquiera de los valores predeterminados, es necesario crear un grupo de parámetros de base de datos personalizado y aplicarlo a la instancia. También puede utilizar la Consola de administración de AWS o la API de RDS para crear un grupo de parámetros de base de datos personalizado. Para obtener más información, consulte Ahora puede asociar el grupo de parámetros personalizado con su instancia de base de datos. **Para crear un grupo de parámetros de base de datos personalizado** 1. Utilice el comando `[create-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-parameter-group.html) ` de la CLI para crear el grupo de parámetros de base de datos personalizado. En este ejemplo se utiliza `postgres13` como origen de este grupo de parámetros personalizado. Para Linux, macOS o 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' ``` Para 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. Utilice el comando `[modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)` de la CLI para aplicar este grupo de parámetros personalizado al clúster de base de datos de RDS para PostgreSQL. Para Linux, macOS o Unix: ``` aws rds modify-db-instance --db-instance-identifier 'your-instance-name' \ --db-parameter-group-name "docs-lab-scram-passwords ``` Para Windows: ``` aws rds modify-db-instance --db-instance-identifier "your-instance-name" ^ --db-parameter-group-name "docs-lab-scram-passwords ``` Para volver a sincronizar la instancia de base de datos de RDS para PostgreSQL con el grupo de parámetros de base de datos personalizado, debe reiniciar la instancia principal y todas las demás instancias del clúster. Para minimizar el impacto en sus usuarios, programe esto para que se produzca durante su periodo de mantenimiento regular. ### Configuración del cifrado de contraseñas para utilizar SCRAM El mecanismo de cifrado de contraseñas que utiliza una instancia de base de datos de RDS para PostgreSQL se establece en el grupo de parámetros de base de datos en el parámetro `password_encryption`. Los valores permitidos son: no establecido, `md5` o `scram-sha-256`. El valor predeterminado depende de la versión de RDS para PostgreSQL del modo que se indica a continuación: + RDS para PostgreSQL 14 y versiones posteriores: el valor predeterminado es `scram-sha-256` + RDS para PostgreSQL 13: el valor predeterminado es `md5` Con un grupo de parámetros de base de datos personalizado adjuntado a la instancia de base de datos de RDS para PostgreSQL, puede modificar los valores del parámetro de cifrado de contraseñas. ![\[A continuación, la consola de RDS muestra los valores predeterminados de los parámetros password_encryption de RDS para PostgreSQL.\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/rpg-pwd-encryption-md5-scram-1.png) **Para cambiar la configuración de cifrado de contraseñas a scram-sha-256** + Cambie el valor del cifrado de contraseñas a scram-sha-256, como se muestra a continuación. El cambio se puede aplicar inmediatamente porque el parámetro es dinámico, por lo que no se requiere un reinicio para que el cambio surta efecto. Para Linux, macOS o 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' ``` Para 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" ``` ### Migración de las contraseñas de los roles de usuario a SCRAM Puede migrar las contraseñas de los roles de usuario a SCRAM, tal y como se describe a continuación. **Para migrar las contraseñas de usuario (rol) de base de datos de MD5 a SCRAM** 1. Inicie sesión como usuario administrador (nombre de usuario predeterminado, `postgres`) como se muestra a continuación. ``` psql --host=db-name.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password ``` 1. Compruebe la configuración del parámetro `password_encryption` en la instancia de base de datos de RDS para PostgreSQL con el siguiente comando. ``` postgres=> SHOW password_encryption; password_encryption --------------------- md5 (1 row) ``` 1. Cambie el valor de este parámetro a scram-sha-256. Para obtener más información, consulte [Configuración del cifrado de contraseñas para utilizar SCRAM](#PostgreSQL_Password_Encryption_configuration.configure-password-encryption). 1. Compruebe de nuevo el valor para asegurarse de que ahora está establecido en `scram-sha-256`, como se indica a continuación. ``` postgres=> SHOW password_encryption; password_encryption --------------------- scram-sha-256 (1 row) ``` 1. Notifique a todos los usuarios de base de datos que deben cambiar la contraseña. Asegúrese de cambiar también su propia contraseña para la cuenta `postgres` (el usuario de base de datos con privilegios `rds_superuser`). ``` labdb=> ALTER ROLE postgres WITH LOGIN PASSWORD 'change_me'; ALTER ROLE ``` 1. Repita el proceso para todas las bases de datos del Instancia de base de datos RDS para PostgreSQL. ### Cambio del parámetro para requerir SCRAM Este es el último paso del proceso. Después de realizar el cambio en el siguiente procedimiento, ninguna cuenta de usuario (rol) que aún utilice el cifrado `md5` para las contraseñas podrá iniciar sesión en el . Instancia de base de datos RDS para PostgreSQL. Con `rds.accepted_password_auth_method` se especifica el método de cifrado que la instancia de base de datos de RDS para PostgreSQL acepta una contraseña de usuario durante el proceso de inicio de sesión. El valor predeterminado es `md5+scram`, lo que significa que se acepta cualquiera de los dos métodos. En la siguiente imagen, puede encontrar la configuración predeterminada de este parámetro. ![\[Consola de RDS con los valores predeterminados y permitidos para los parámetros rds.accepted_password_auth_method.\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/pwd-encryption-md5-scram-2.png) Los valores permitidos para este parámetro son:`md5+scram` o `scram` solo. El cambio de este valor de parámetro a `scram` lo convierte en un requisito. **Para cambiar el valor de parámetro para requerir la autenticación SCRAM para las contraseñas** 1. Verifique que todas las contraseñas de los usuarios de base de datos de la instancia de base de datos de RDS para PostgreSQL utilizan `scram-sha-256` para el cifrado de contraseña. Para ello, consulte `rds_tools` para el rol (usuario) y el tipo de cifrado, de la siguiente manera. ``` 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. Repita la consulta en todas las instancias de base de datos del Instancia de base de datos RDS para PostgreSQL. Si todas las contraseñas usan scram-sha-256, puede continuar. 1. Cambie el valor de la autenticación de contraseña aceptada a scram-sha-256, como se indica a continuación. Para Linux, macOS o 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' ``` Para 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" ```