# Noções básicas de perfis e permissões do PostgreSQL Ao criar uma instância de banco de dados do RDS para PostgreSQL usando o Console de gerenciamento da AWS, uma conta de administrador é criada ao mesmo tempo. Por padrão, o nome é `postgres`, conforme mostrado na captura de tela a seguir: ![\[A identidade de login padrão para credenciais na página Create database (Criar banco de dados) é postgres.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/default-login-identity-apg-rpg.png) É possível escolher outro nome em vez de aceitar esse padrão (`postgres`). Se você fizer isso, o nome escolhido deverá começar com uma letra e ter 1 a 16 caracteres alfanuméricos. Para simplificar, nós nos referimos a essa conta de usuário principal pelo seu valor padrão (`postgres`) ao longo deste guia. Ao usar `create-db-instance` na AWS CLI em vez de usar o Console de gerenciamento da AWS, você cria o nome ao passá-lo com o parâmetro `master-username` no comando. Para obter mais informações, consulte [Criar uma instância de banco de dados do Amazon RDS](USER_CreateDBInstance.md). Se você usar o Console de gerenciamento da AWS, a AWS CLI ou a API do Amazon RDS e se usar o nome `postgres` padrão ou escolher um nome diferente, essa primeira conta de usuário do banco de dados será membro do grupo `rds_superuser` e terá privilégios de `rds_superuser`. **Topics** + [Noções básicas sobre o perfil rds\$1superuser](Appendix.PostgreSQL.CommonDBATasks.Roles.rds_superuser.md) + [Controlar o acesso de usuários ao banco de dados PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Access.md) + [Delegar e controlar o gerenciamento de senhas de usuários](Appendix.PostgreSQL.CommonDBATasks.RestrictPasswordMgmt.md) + [Usar criptografia de senha SCRAM para PostgreSQL](PostgreSQL_Password_Encryption_configuration.md) # Noções básicas sobre o perfil rds\$1superuser No PostgreSQL, um *perfil* pode definir um usuário, um grupo ou um conjunto de permissões específicas concedidas a um grupo ou usuário a vários objetos no banco de dados. Os comandos do PostgreSQL para `CREATE USER` e `CREATE GROUP` foram substituídos pelo comando mais geral `CREATE ROLE` com propriedades específicas para distinguir usuários de banco de dados. Um usuário de banco de dados pode ser considerado um perfil com o privilégio LOGIN. **nota** Os comandos `CREATE USER` e `CREATE GROUP` ainda podem ser usados. Para obter mais informações, consulte [Database Roles](https://www.postgresql.org/docs/current/user-manag.html) (Perfis de banco de dados) na documentação do PostgreSQL. O usuário `postgres` é o usuário de banco de dados mais privilegiado na instância de banco de dados do RDS para PostgreSQL. Ele tem as características definidas pela seguinte instrução `CREATE ROLE`. ``` CREATE ROLE postgres WITH LOGIN NOSUPERUSER INHERIT CREATEDB CREATEROLE NOREPLICATION VALID UNTIL 'infinity' ``` As propriedades `NOSUPERUSER`, `NOREPLICATION`, `INHERIT` e `VALID UNTIL 'infinity'` são as opções padrão da instrução CREATE ROLE, a menos que especificado de outra forma. Por padrão, `postgres` tem privilégios concedidos à função `rds_superuser` e permissões para criar funções e bancos de dados. O perfil `rds_superuser` permite que o usuário `postgres` faça o seguinte: + Adicione as extensões que estão disponíveis para uso com o Amazon RDS. Para obter mais informações, consulte [Trabalhar com recursos do PostgreSQL compatíveis com o Amazon RDS para PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.md) + Crie funções para usuários e conceda privilégios aos usuários. Para obter mais informações, consulte [CREATE ROLE](https://www.postgresql.org/docs/current/sql-createrole.html) e [GRANT](https://www.postgresql.org/docs/14/sql-grant.html) na documentação do PostgreSQL. + Crie bancos de dados. Para obter mais informações, consulte [CREATE DATABASE](https://www.postgresql.org/docs/14/sql-createdatabase.html) na documentação do PostgreSQL. + Conceda privilégios de `rds_superuser` a outras funções de usuário que não têm esses privilégios e revogue esses privilégios conforme necessário. Recomendamos que você conceda esse perfil somente aos usuários que executam tarefas de superusuário. Em outras palavras, você pode conceder esse perfil a administradores de banco de dados (DBAs) ou administradores de sistema. + Conceda (e revogue) o perfil `rds_replication` a usuários de banco de dados que não têm o perfil `rds_superuser`. + Conceda (e revogue) o perfil `rds_password` a usuários de banco de dados que não têm o perfil `rds_superuser`. + Obtenha informações de status sobre todas as conexões de banco de dados usando a visualização `pg_stat_activity`. Quando necessário, `rds_superuser` pode interromper qualquer conexão usando `pg_terminate_backend` ou `pg_cancel_backend`. Na instrução `CREATE ROLE postgres...`, é possível ver que o perfil do usuário `postgres` não autoriza especificamente as permissões de `superuser` do PostgreSQL. O RDS para PostgreSQL é um serviço gerenciado, portanto, você não pode acessar o sistema operacional host nem se conectar usando a conta `superuser` do PostgreSQL. Muitas das tarefas que exigem o acesso de `superuser` em um PostgreSQL autônomo são gerenciadas automaticamente pelo Amazon RDS. Para obter mais informações sobre como conceder privilégios, consulte [GRANT](http://www.postgresql.org/docs/current/sql-grant.html) na documentação do PostgreSQL. O perfil `rds_superuser` é um dos vários perfis *predefinidos* em um Instância de banco de dados do RDS para PostgreSQL. **nota** No PostgreSQL 13 e em versões anteriores, os perfis *predefinidos* são conhecidos como perfis *padrão*. Na lista a seguir, você encontra alguns dos outros perfis predefinidos que são criados automaticamente para um novo Instância de banco de dados do RDS para PostgreSQL. Os perfis predefinidos e seus privilégios não podem ser alterados. Não é possível descartar, renomear ou modificar os privilégios desses perfis predefinidos. Qualquer tentativa de fazer isso gerará um erro. + **rds\$1password**: um perfil que pode alterar senhas e configurar restrições de senha para usuários de bancos de dados. O perfil `rds_superuser` recebe esse perfil por padrão e pode concedê-lo aos usuários do banco de dados. Para obter mais informações, consulte [Controlar o acesso de usuários ao banco de dados PostgreSQLControlar o acesso de usuários ao PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Access.md). + Para versões do RDS para PostgreSQL anteriores à 14, o perfil `rds_password` pode alterar senhas e configurar restrições de senha para usuários de bancos de dados e usuários com o perfil `rds_superuser`. Para versões do RDS para PostgreSQL 14 e posteriores, o perfil `rds_password` pode alterar senhas e configurar restrições de senha somente para usuários de banco de dados. Somente usuários com o perfil `rds_superuser` podem realizar essas ações em outros usuários com o perfil `rds_superuser`. + **rdsadmin**: um perfil criado para lidar com muitas das tarefas de gerenciamento que o administrador com privilégios de `superuser` executaria em um banco de dados PostgreSQL autônomo. Esse perfil é usado internamente pelo RDS para PostgreSQL para várias tarefas de gerenciamento. + **rdstopmgr**: um perfil usado internamente pelo Amazon RDS para comportar implantações multi-AZ. + **rds\$1reserved**: função usada internamente pelo Amazon RDS para reservar conexões de banco de dados. # Visualizar perfis e os respectivos privilégios Você pode visualizar perfis predefinidos e os respectivos privilégios na instância de banco de dados do RDS para PostgreSQL usando comandos diferentes, dependendo da versão do PostgreSQL. Para ver todos os perfis predefinidos, você pode se conectar à sua instância de banco de dados do RDS para PostgreSQL e executar os comandos a seguir usando o `psql`. **Para o `psql` 15 e versões anteriores** Conecte-se à instância de banco de dados do RDS para PostgreSQL e use o comando `\du` no 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 o `psql` 16 e versões 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 verificar a associação sem dependência de versão, você pode usar a seguinte 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; ``` Na saída, é possível ver que `rds_superuser` não é um perfil de usuário de banco de dados (não pode fazer login), mas tem os privilégios de muitos outros perfis. Também é possível ver que esse usuário do banco de dados `postgres` é membro do perfil `rds_superuser`. Como mencionado anteriormente, `postgres` é o valor padrão na página **Create database** (Criar banco de dados) do console do Amazon RDS. Se você escolheu outro nome, esse nome será mostrado na lista de perfis. # Controlar o acesso de usuários ao banco de dados PostgreSQL Os novos bancos de dados no PostgreSQL são sempre criados com um conjunto padrão de privilégios no esquema `public` do banco de dados que permite que todos os usuários e perfis do banco de dados criem objetos. Esses privilégios permitem que os usuários do banco de dados se conectem ao banco de dados, por exemplo, e criem tabelas temporárias durante a conexão. Para controlar melhor o acesso dos usuários às instâncias de bancos de dados que você cria na instância de banco de dados do RDS para PostgreSQL, recomendamos que você revogue esses privilégios de `public` padrão. Depois disso, conceda privilégios específicos aos usuários do banco de dados de forma mais granular, conforme mostrado no procedimento a seguir. **Como configurar perfis e privilégios para uma nova instância de banco de dados** Suponha que você esteja configurando um banco de dados em uma instância de banco de dados do RDS para PostgreSQL recém-criada para uso por vários pesquisadores que precisam de acesso de leitura-gravação ao banco de dados. 1. Use o `psql` (ou o pgAdmin) para se conectar à na instância de banco de dados do RDS para PostgreSQL: ``` psql --host=your-db-instance.666666666666.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password ``` Insira sua senha quando for solicitado. O cliente `psql` conecta-se e exibe o banco de dados de conexão administrativa padrão, `postgres=>`, como o prompt. 1. Para evitar que os usuários do banco de dados criem objetos no esquema `public`, faça o seguinte: ``` postgres=> REVOKE CREATE ON SCHEMA public FROM PUBLIC; REVOKE ``` 1. Em seguida, crie uma nova instância de banco de dados: ``` postgres=> CREATE DATABASE lab_db; CREATE DATABASE ``` 1. Revogue todos os privilégios do esquema `PUBLIC` nesse novo banco de dados. ``` postgres=> REVOKE ALL ON DATABASE lab_db FROM public; REVOKE ``` 1. Crie um perfil para os usuários do banco de dados. ``` postgres=> CREATE ROLE lab_tech; CREATE ROLE ``` 1. Permita que os usuários do banco de dados que têm esse perfil conectem-se ao banco de dados. ``` postgres=> GRANT CONNECT ON DATABASE lab_db TO lab_tech; GRANT ``` 1. Conceda a todos os usuários com o perfil `lab_tech` todos os privilégios nesse banco de dados. ``` postgres=> GRANT ALL PRIVILEGES ON DATABASE lab_db TO lab_tech; GRANT ``` 1. Crie os usuários do banco de dados, da seguinte forma: ``` 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 esses dois usuários os privilégios associados ao perfil lab\$1tech: ``` postgres=> GRANT lab_tech TO lab_user1; GRANT ROLE postgres=> GRANT lab_tech TO lab_user2; GRANT ROLE ``` Neste ponto, o `lab_user1` e o `lab_user2` podem conectar-se ao banco de dados `lab_db`. Este exemplo não segue as práticas recomendadas para uso corporativo, o que pode incluir a criação de várias instâncias de banco de dados, esquemas diferentes e concessão de permissões limitadas. Para obter informações mais completas e cenários adicionais, consulte [Managing PostgreSQL Users and Roles](https://aws.amazon.com/blogs//database/managing-postgresql-users-and-roles/) (Gerenciar usuários e perfis do PostgreSQL). Para obter mais informações sobre privilégios nos bancos de dados PostgreSQL, consulte o comando [GRANT](https://www.postgresql.org/docs/current/static/sql-grant.html) na documentação do PostgreSQL. # Delegar e controlar o gerenciamento de senhas de usuários Como DBA, talvez você queira delegar o gerenciamento de senhas de usuários. Ou talvez você queira impedir que os usuários do banco de dados alterem senhas ou reconfigurem restrições de senha, como o tempo de vida da senha. Para garantir que somente os usuários do banco de dados escolhidos possam alterar as configurações de senha, é possível ativar o recurso de gerenciamento restrito de senhas. Quando você ativa esse recurso, somente os usuários do banco de dados que receberam o perfil `rds_password` podem gerenciar senhas. **nota** Para usar o gerenciamento restrito de senhas, a instância de banco de dados do RDS para PostgreSQL deve estar executando o Amazon Aurora PostgreSQL 10.6 ou superior. Por padrão, esse recurso está `off`, conforme mostrado a seguir: ``` postgres=> SHOW rds.restrict_password_commands; rds.restrict_password_commands -------------------------------- off (1 row) ``` Para ativar esse recurso, use um grupo de parâmetros personalizado e altere a configuração de `rds.restrict_password_commands` para 1. Reinicialize a instância de banco de dados do RDS para PostgreSQL para que a configuração entre em vigor. Com esse recurso ativo, os privilégios de `rds_password` são necessários para os seguintes 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; ``` A renomeação de um perfil (`ALTER ROLE myrole RENAME TO newname`) também será restrita se a senha usar o algoritmo de hash MD5. Com esse recurso ativo, qualquer tentativa de executar um desses comandos SQL sem as permissões do perfil `rds_password` gerará o seguinte erro: ``` ERROR: must be a member of rds_password to alter passwords ``` Recomendamos conceder a `rds_password` a apenas alguns perfis usados exclusivamente para o gerenciamento de senhas. Se você conceder privilégios de `rds_password` a usuários de banco de dados que não têm privilégios de `rds_superuser`, também precisará conceder o atributo `CREATEROLE` a eles. Verifique os requisitos de senha, como expiração e complexidade necessária, no lado do cliente. Se você usar seu próprio utilitário do lado do cliente para alterações relacionadas a senhas, o utilitário precisará ser membro de `rds_password` e ter privilégios de `CREATE ROLE`. # Usar criptografia de senha SCRAM para PostgreSQL O *Salted Challenge Response Authentication Mechanism (SCRAM)* é uma alternativa ao algoritmo de resumo de mensagens padrão (MD5) do PostgreSQL para senhas de criptografia. O mecanismo de autenticação SCRAM é considerado mais seguro que o MD5. Para saber mais sobre essas duas abordagens diferentes para proteger senhas, consulte [Autorização com senha](https://www.postgresql.org/docs/14/auth-password.html) na documentação do PostgreSQL. Recomendamos que você use o SCRAM em vez de o MD5 como o esquema de criptografia de senha para seu Instância de banco de dados do RDS para PostgreSQL. É um mecanismo criptográfico de resposta a desafios que usa o algoritmo scram-sha-256 para autenticação e criptografia de senha. Convém atualizar as bibliotecas das aplicações cliente para oferecer compatibilidade com o SCRAM. Por exemplo, versões do JDBC anteriores à 42.2.0 não são compatíveis com o SCRAM. Para obter mais informações, consulte [Driver JDBC do PostgreSQL](https://jdbc.postgresql.org/changelogs/2018-01-17-42.2.0-release/) na documentação do driver JDBC do PostgreSQL. Para obter uma lista de outros drivers do PostgreSQL e compatibilidade com o SCRAM, consulte [Lista de drivers](https://wiki.postgresql.org/wiki/List_of_drivers) na documentação do PostgreSQL. A versão 13.1 do RDS para PostgreSQL e versões posteriores são compatíveis com scram-sha-256. Essas versões também permitem configurar sua instância de banco de dados para exigir o SCRAM, conforme abordado nos procedimentos a seguir. ## Configurar a instância de banco de dados do RDS para PostgreSQL para exigir o SCRAM você pode exigir que a instância de banco de dados do RDS para PostgreSQL aceite apenas senhas que usem o algoritmo scram-sha-256. **Importante** Para proxies RDS existentes com bancos de dados PostgreSQL, se você modificar a autenticação do banco de dados para usar somente `SCRAM`, o proxy ficará indisponível por até 60 segundos. Para evitar o problema, faça o seguinte: O banco de dados deve permitir tanto a autenticação `SCRAM` quanto a `MD5`. Para usar somente a autenticação `SCRAM`, crie um proxy, migre o tráfego da aplicação para o novo proxy e exclua o proxy anteriormente associado ao banco de dados. Antes de fazer alterações em seu sistema, entenda o processo completo da seguinte forma: + Obtenha informações sobre todos os perfis e criptografia de senha para todos os usuários do banco de dados. + Confira novamente as configurações dos parâmetros da instância de banco de dados do RDS para PostgreSQL para verificar os parâmetros que controlam a criptografia de senha. + Se a instância de banco de dados do RDS para PostgreSQL usar um grupo de parâmetros padrão, será necessário criar um grupo de parâmetros de banco de dados personalizado e aplicá-lo à instância de banco de dados do RDS para PostgreSQL para poder modificar parâmetros quando necessário. Se sua instância de banco de dados do RDS para PostgreSQL usa um grupo de parâmetros personalizado, você poderá modificar os parâmetros necessários posteriormente no processo, conforme necessário. + Altere o parâmetro `password_encryption` para `scram-sha-256`. + Avise a todos os usuários do banco de dados que eles precisam atualizar as senhas. Faça o mesmo para a conta `postgres`. As novas senhas são criptografadas e armazenadas usando o algoritmo scram-sha-256. + Verifique se todas as senhas são criptografadas usando o tipo de criptografia. + Se todas as senhas utilizarem scram-sha-256, você poderá alterar o parâmetro de `rds.accepted_password_auth_method` para `md5+scram`. **Atenção** Depois de alterar `rds.accepted_password_auth_method` para scram-sha-256, os usuários (perfis) com senhas criptografadas com `md5` não conseguirão se conectar. ### Preparar-se para exigir o SCRAM para sua instância de banco de dados do RDS para PostgreSQL Antes de fazer qualquer alteração em sua instância de banco de dados do RDS para PostgreSQL, confira todas as contas de usuário do banco de dados existentes. Além disso, verifique o tipo de criptografia usada para senhas. Você pode realizar essas tarefas usando a extensão `rds_tools`. Consulte quais versões do PostgreSQL são compatíveis com `rds_tools` em [Extension versions for Amazon RDS for PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html). **Como obter uma lista de usuários (perfis) de banco de dados e métodos de criptografia de senha** 1. Use o `psql` para conectar-se à instância de banco de dados do RDS para PostgreSQL conforme mostrado a seguir. ``` psql --host=db-name.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password ``` 1. Instale a extensão `rds_tools`. ``` postgres=> CREATE EXTENSION rds_tools; CREATE EXTENSION ``` 1. Obtenha uma lista de perfis e criptografias. ``` postgres=> SELECT * FROM rds_tools.role_password_encryption_type(); ``` Você verá uma saída semelhante à seguinte. ``` 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) ``` ### Criar um grupo de parâmetros de banco de dados personalizado **nota** Se sua instância de banco de dados do RDS para PostgreSQL já usa um grupo de parâmetros personalizado, não é necessário criar outro. Para obter uma visão geral dos grupos de parâmetros do Amazon RDS, consulte [Trabalhar com parâmetros na instância de banco de dados do RDS para PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Parameters.md). O tipo de criptografia de senha usada para senhas é definido em um parâmetro, `password_encryption`. A criptografia permitida pela instância de banco de dados do RDS para PostgreSQL é definida em outro parâmetro, `rds.accepted_password_auth_method`. Alterar qualquer um desses valores padrão exige que você crie um grupo de parâmetros de banco de dados personalizado e aplique-o à sua instância. Você também pode usar o Console de gerenciamento da AWS ou a API do RDS para criar um grupo de parâmetros de banco de dados personalizado. Consulte mais informações em Associe o grupo de parâmetros personalizado à sua instância de banco de dados. **Como criar um grupo de parâmetros de banco de dados personalizado** 1. Use o comando `[create-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-parameter-group.html) ` da CLI para criar o grupo de parâmetros de banco de dados personalizado. Este exemplo usa `postgres13` como a origem desse grupo de parâmetros personalizado. Para 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' ``` 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. Use o comando `[modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)` da CLI para aplicar esse grupo de parâmetros personalizado ao seu cluster de banco de dados do RDS para PostgreSQL. Para Linux, macOS ou 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 sincronizar novamente sua instância de banco de dados do RDS para PostgreSQL com seu grupo de parâmetros de cluster de banco de dados personalizado, você precisa reiniciar a instância primária e todas as outras instâncias do cluster. Programe para que isso ocorra durante sua janela de manutenção regular a fim de minimizar o impacto para os usuários. ### Configurar a criptografia de senha para usar o SCRAM O mecanismo de criptografia de senha usado por uma instância de banco de dados do RDS para PostgreSQL é definido no grupo de parâmetros de banco de dados no parâmetro `password_encryption`. Os valores permitidos não estão definidos, `md5` ou `scram-sha-256`. O valor padrão depende da versão do RDS para PostgreSQL da seguinte forma: + RDS para PostgreSQL 14 e superior: o padrão é `scram-sha-256` + RDS para PostgreSQL 13: o padrão é `md5` Com um grupo de parâmetros de banco de dados personalizado anexado à instância de banco de dados do RDS para PostgreSQL, é possível modificar valores do parâmetro de criptografia de senha. ![\[A seguir, o console do RDS mostra os valores padrão para os parâmetros password_encryption do RDS para PostgreSQL.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/rpg-pwd-encryption-md5-scram-1.png) **Como alterar a configuração de criptografia de senha para scram-sha-256** + Altere o valor da criptografia de senha para scram-sha-256, conforme mostrado a seguir. A alteração pode ser aplicada imediatamente porque o parâmetro é dinâmico, portanto, não é necessário reiniciar para que a alteração seja implementada. Para 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' ``` 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" ``` ### Migrar senhas para funções de usuário para o SCRAM Você pode migrar senhas de perfis de usuário para o SCRAM conforme descrito a seguir. **Como migrar senhas de usuário (função) do banco de dados do MD5 para o SCRAM** 1. Faça login como usuário administrador (nome de usuário padrão, `postgres`) conforme mostrado a seguir. ``` psql --host=db-name.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password ``` 1. Confira a configuração do parâmetro `password_encryption` em sua instância de banco de dados do RDS para PostgreSQL usando o comando a seguir. ``` postgres=> SHOW password_encryption; password_encryption --------------------- md5 (1 row) ``` 1. Altere o valor desse parâmetro para scram-sha-256. Para obter mais informações, consulte [Configurar a criptografia de senha para usar o SCRAM](#PostgreSQL_Password_Encryption_configuration.configure-password-encryption). 1. Confira o valor novamente para garantir que agora ele esteja definido como `scram-sha-256` da seguinte forma. ``` postgres=> SHOW password_encryption; password_encryption --------------------- scram-sha-256 (1 row) ``` 1. Avise a todos os usuários do banco de dados para alterar senhas. Altere também sua própria senha para a conta `postgres` (o usuário do banco de dados com privilégios de `rds_superuser`). ``` labdb=> ALTER ROLE postgres WITH LOGIN PASSWORD 'change_me'; ALTER ROLE ``` 1. Repita o processo para todos os bancos de dados no Instância de banco de dados do RDS para PostgreSQL. ### Alterar o parâmetro para exigir o SCRAM Esta é a etapa final do processo. Depois de fazer a alteração no procedimento a seguir, as contas de usuário (perfis) que ainda usam a criptografia `md5` para senhas não poderão fazer login no Instância de banco de dados do RDS para PostgreSQL. O `rds.accepted_password_auth_method` especifica o método de criptografia que a instância de banco de dados do RDS para PostgreSQL aceita para uma senha de usuário durante o processo de login. O valor padrão é `md5+scram`, o que significa que qualquer método é aceito. Na imagem a seguir, você pode encontrar a configuração padrão para esse parâmetro. ![\[O console do RDS mostrando os valores padrão e permitidos para os parâmetros rds.accepted_password_auth_method.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/pwd-encryption-md5-scram-2.png) Os valores permitidos para esse parâmetro são `md5+scram` ou `scram`. Alterar esse valor de parâmetro para `scram` torna isso um requisito. **Como alterar o valor do parâmetro para exigir autenticação SCRAM para senhas** 1. Verifique se todas as senhas de usuários para todos os bancos de dados na instância de banco de dados do RDS para PostgreSQL usam `scram-sha-256` para criptografia de senha. Para fazer isso, consulte `rds_tools` para obter o perfil (usuário) e o tipo de criptografia, da seguinte forma. ``` 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 a consulta para todas as instâncias de banco de dados em seu Instância de banco de dados do RDS para PostgreSQL. Se todas as senhas usam scram-sha-256, você pode prosseguir. 1. Altere o valor da autenticação de senha aceita para scram-sha-256 da seguinte forma. Para 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' ``` 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" ```