Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Informazioni su ruoli e autorizzazioni di PostgreSQL Quando si crea un' per PostgreSQL utilizzando, viene creato contemporaneamente un account amministratore. Console di gestione AWS Per impostazione predefinita, verrà chiamato `postgres`, come mostrato nello screenshot seguente: ![\[L'identità di accesso predefinita per le credenziali nella pagina Create database (Crea database) è postgres.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/default-login-identity-apg-rpg.png) Anziché accettare il valore predefinito (`postgres`) è possibile scegliere un nome diverso. In tal caso, il nome scelto deve iniziare con una lettera e contenere da 1 a 16 caratteri alfanumerici. Per semplicità, facciamo riferimento a questo account utente principale utilizzando il suo valore predefinito (`postgres`) in tutta la Guida. Se si utilizza il `create-db-instance` AWS CLI anziché il Console di gestione AWS, si crea il nome passandolo con il parametro nel comando. `master-username` Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md). Sia che utilizzi l' Console di gestione AWS API Amazon RDS AWS CLI, che utilizzi il `postgres` nome predefinito o scelga un nome diverso, questo primo account utente del database è membro del `rds_superuser` gruppo e dispone di `rds_superuser` privilegi. **Topics** + [ # Comprendere il ruolo rds\$1superuser ](Appendix.PostgreSQL.CommonDBATasks.Roles.rds_superuser.md) + [ # Controllo dell'accesso utente al database PostgreSQL ](Appendix.PostgreSQL.CommonDBATasks.Access.md) + [ # Delega e controllo della gestione delle password utente ](Appendix.PostgreSQL.CommonDBATasks.RestrictPasswordMgmt.md) + [ # Utilizzo delle crittografia password SCRAM per PostgreSQL ](PostgreSQL_Password_Encryption_configuration.md) # Comprendere il ruolo rds\$1superuser In PostgreSQL, un *ruolo* può definire un utente, un gruppo o un insieme di autorizzazioni specifiche concesse a un gruppo o a un utente per vari oggetti nel database. I comandi PostgreSQL `CREATE USER` e `CREATE GROUP` sono stati sostituiti dal comando `CREATE ROLE` più generico, ma con proprietà specifiche per distinguere gli utenti del database. Un utente del database può essere paragonato a un ruolo con il privilegio LOGIN. **Nota** È comunque possibile continuare a utilizzare i comandi `CREATE USER` e `CREATE GROUP`. Per ulteriori informazioni, consulta la sezione relativa ai [ruoli di database](https://www.postgresql.org/docs/current/user-manag.html) nella documentazione di PostgreSQL. L'utente `postgres` è l'utente di database più privilegiato nell'istanza database di RDS per PostgreSQL. Ha le caratteristiche definite dalla seguente istruzione `CREATE ROLE`. ``` CREATE ROLE postgres WITH LOGIN NOSUPERUSER INHERIT CREATEDB CREATEROLE NOREPLICATION VALID UNTIL 'infinity' ``` Le proprietà `NOSUPERUSER`, `NOREPLICATION`, `INHERIT` e `VALID UNTIL 'infinity'` sono le opzioni predefinite per CREATE ROLE, se non diversamente specificato. Per impostazione predefinita, `postgres` dispone dei privilegi concessi al `rds_superuser` ruolo e delle autorizzazioni per creare ruoli e database. Il ruolo `rds_superuser` consente all'utente `postgres` di eseguire le seguenti operazioni: + Aggiungere le estensioni che sono disponibili per l'uso con Amazon RDS. Per ulteriori informazioni, consulta [Utilizzo delle caratteristiche di PostgreSQL supportate da Amazon RDS for PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.md) + Creare ruoli per gli utenti e concedere i relativi privilegi. Per ulteriori informazioni, consulta [CREATE ROLE](https://www.postgresql.org/docs/current/sql-createrole.html) e [GRANT](https://www.postgresql.org/docs/14/sql-grant.html)nella documentazione di PostgreSQL. + Creare database. Per ulteriori informazioni, consulta [CREATE DATABASE](https://www.postgresql.org/docs/14/sql-createdatabase.html) nella documentazione di PostgreSQL. + Concedere privilegi `rds_superuser` a ruoli utente che non dispongono di questi privilegi e revocare i privilegi, se necessario. Si consiglia di concedere questo ruolo solo agli utenti che eseguono attività superuser. In altre parole, è possibile concedere questo ruolo agli amministratori del database (DBAs) o agli amministratori di sistema. + Concedere (e revocare) il ruolo `rds_replication` per gli utenti del database che non hanno il ruolo `rds_superuser`. + Concedere (e revocare) il ruolo `rds_password` per gli utenti del database che non hanno il ruolo `rds_superuser`. + Ottenere informazioni sullo stato di tutte le connessioni al database utilizzando la vista `pg_stat_activity`. Quando necessario, il ruolo `rds_superuser` può arrestare qualsiasi connessione utilizzando il comando `pg_terminate_backend` o `pg_cancel_backend`. Nell'istruzione `CREATE ROLE postgres...`, si può vedere che il ruolo utente `postgres` non concede specificamente autorizzazioni PostgreSQL `superuser`. RDS per PostgreSQL è un servizio gestito e pertanto non è possibile accedere al sistema operativo host, né connettersi utilizzando l'account PostgreSQL`superuser`. Molte delle attività che richiedono l'accesso di tipo `superuser` su un PostgreSQL autonomo viene gestito automaticamente da Amazon RDS. Per ulteriori informazioni sulla concessione dei privilegi, consulta la sezione relativa al comando [GRANT](http://www.postgresql.org/docs/current/sql-grant.html) nella documentazione di PostgreSQL. Il ruolo `rds_superuser` è uno dei diversi ruoli *predefinito* in un Istanza database di RDS per PostgreSQL. **Nota** In PostgreSQL 13 e versioni precedenti, i ruoli di *default* sono conosciuti come ruoli *predefiniti*. L'elenco seguente fornisce alcuni degli altri ruoli predefiniti creati automaticamente per un nuovo . Istanza database di RDS per PostgreSQL. I ruoli predefiniti e i relativi privilegi non possono essere modificati. Non è possibile eliminare, rinominare o modificare i privilegi per questi ruoli predefiniti. Qualsiasi tentativo comporta la generazione di un errore. + **rds\$1password** - Un ruolo in grado di modificare le password e configurare vincoli di password per gli utenti del database. Questo ruolo `rds_superuser` viene assegnato al ruolo per impostazione predefinita e può concedere il ruolo agli utenti del database. Per ulteriori informazioni, consulta [Controllo dell'accesso utente al database PostgreSQLControllo dell'accesso utente a PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Access.md). + Per le versioni di RDS per PostgreSQL precedenti alla 14, il ruolo `rds_password` può modificare le password e configurare vincoli di password per gli utenti del database e gli utenti con ruolo `rds_superuser`. A partire dalla versione 14 di RDS per PostgreSQL, il ruolo `rds_password` può modificare le password e configurare vincoli di password solo per gli utenti del database. Solo gli utenti con ruolo `rds_superuser` possono eseguire queste azioni su altri utenti con ruolo `rds_superuser`. + **rdsadmin** – Un ruolo creato per gestire molte delle attività di gestione che l'amministratore con privilegi `superuser` esegue su un database PostgreSQL autonomo. Questo ruolo viene utilizzato internamente da RDS per PostgreSQL per molte attività di gestione. + **rdstopmgr**: un ruolo utilizzato internamente da Amazon RDS per supportare le implementazioni multi-AZ. + **rds\$1reserved**: un ruolo utilizzato internamente da Amazon RDS per prenotare le connessioni al database. # Visualizzazione dei ruoli e dei relativi privilegi È possibile visualizzare i ruoli predefiniti e i relativi privilegi nell’istanza database RDS per PostgreSQL utilizzando comandi diversi a seconda della versione di PostgreSQL in uso. Per visualizzare tutti i ruoli predefiniti, è possibile connettersi a un’istanza database RDS per PostgreSQL ed eseguire i comandi riportati di seguito tramite `psql`. **Per `psql` versione 15 e precedenti** Connettiti a un’istanza database RDS per PostgreSQL e utilizza il comando `\du` in 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 | ``` **Per `psql` versione 16 e successive** ``` 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 ``` Per verificare l’appartenenza ai ruoli senza dipendenza dalla versione, puoi utilizzare la seguente query 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; ``` Nell'output, si vede che `rds_superuser` non è un ruolo utente del database (non può effettuare il login), ma ha i privilegi di molti altri ruoli. È inoltre possibile vedere che l'utente di database `postgres` è membro del ruolo `rds_superuser`. Come accennato in precedenza, `postgres` è il valore predefinito nella pagina **Crea database** della console Amazon RDS. Se si sceglie un altro nome, tale nome viene visualizzato nell'elenco dei ruoli. # Controllo dell'accesso utente al database PostgreSQL I nuovi database in PostgreSQL vengono sempre creati con un set predefinito di privilegi nel schema `public` del database, che consente a tutti gli utenti e i ruoli del database di creare oggetti. I privilegi predefiniti permettono agli utenti del database di connettersi al database e di creare tabelle temporanee durante la connessione. Per controllare meglio l'accesso degli utenti alle istanze database create sull'istanza database RDS per PostgreSQL, si consiglia di revocare questi privilegi `public` predefiniti. Dopo averlo fatto, è consigliabile concedere privilegi specifici agli utenti del database su base più granulare, come mostrato nella procedura seguente. **Per impostare ruoli e privilegi per una nuova istanza database** Si supponga di aver configurando un database in un'istanza database RDS per PostgreSQL per poter essere usato da diversi ricercatori, che dovranno avere l'accesso in lettura-scrittura al database. 1. Utilizzare `psql` (o pgAdmin) per connettersi all'istanza database RDS per PostgreSQL: ``` psql --host=your-db-instance.666666666666.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password ``` Specifica la password, quando richiesto. Il client `psql` si connette e visualizza il database di connessione amministrativa predefinito `postgres=>` come prompt. 1. Per impedire agli utenti del database di creare oggetti nello schema `public`, eseguire le seguenti operazioni: ``` postgres=> REVOKE CREATE ON SCHEMA public FROM PUBLIC; REVOKE ``` 1. Creare quindi una nuova istanza database: ``` postgres=> CREATE DATABASE lab_db; CREATE DATABASE ``` 1. Revocare tutti i privilegi dallo schema `PUBLIC` in questo nuovo database. ``` postgres=> REVOKE ALL ON DATABASE lab_db FROM public; REVOKE ``` 1. Creare un ruolo per gli utenti del database. ``` postgres=> CREATE ROLE lab_tech; CREATE ROLE ``` 1. Concedere agli utenti del database con questo ruolo la possibilità di connettersi al database. ``` postgres=> GRANT CONNECT ON DATABASE lab_db TO lab_tech; GRANT ``` 1. Concedere a tutti gli utenti con il ruolo `lab_tech` tutti i privilegi per questo database. ``` postgres=> GRANT ALL PRIVILEGES ON DATABASE lab_db TO lab_tech; GRANT ``` 1. Creare utenti del database, come segue: ``` postgres=> CREATE ROLE lab_user1 LOGIN PASSWORD 'change_me'; CREATE ROLE postgres=> CREATE ROLE lab_user2 LOGIN PASSWORD 'change_me'; CREATE ROLE ``` 1. Concedere a questi due utenti i privilegi associati al ruolo lab\$1tech: ``` postgres=> GRANT lab_tech TO lab_user1; GRANT ROLE postgres=> GRANT lab_tech TO lab_user2; GRANT ROLE ``` A questo punto, `lab_user1` e `lab_user2` possono connettersi al database `lab_db`. Questo esempio non segue le best practice per l'utilizzo aziendale, che potrebbero includere la creazione di più istanze database, schemi diversi e la concessione di autorizzazioni limitate. Per informazioni più complete e scenari aggiuntivi, consulta [Gestione di utenti e ruoli PostgreSQL](https://aws.amazon.com/blogs//database/managing-postgresql-users-and-roles/). Per ulteriori informazioni sui privilegi in database PostgreSQL, consulta la sezione relativa al comando [GRANT](https://www.postgresql.org/docs/current/static/sql-grant.html) nella documentazione di PostgreSQL. # Delega e controllo della gestione delle password utente Un amministratore di database (DBA) potrebbe voler delegare la gestione delle password utente. In alternativa, è possibile impedire agli utenti del database di modificare le password o di riconfigurare i vincoli delle password, ad esempio la durata della password. Per garantire che solo gli utenti del database scelti possano modificare le impostazioni della password, è possibile attivare la funzione di gestione delle password con restrizioni. Quando si attiva questa funzione, solo gli utenti del database a cui è stato concesso il ruolo `rds_password` saranno in grado di gestire le password. **Nota** Per utilizzare la gestione delle password limitate, l'istanza database RDS per PostgreSQL deve eseguire PostgreSQL 10.6 o superiore. Per impostazione predefinita, questa funzione è impostata su `off`, come mostrato di seguito: ``` postgres=> SHOW rds.restrict_password_commands; rds.restrict_password_commands -------------------------------- off (1 row) ``` Per attivare questa funzione, utilizzare un gruppo di parametri personalizzato e modificare l'impostazione per `rds.restrict_password_commands` su 1. Assicurarsi di riavviare l'istanza database RDS per PostgreSQL per implementare l'impostazione. Con questa funzione attiva, i privilegi `rds_password` sono obbligatori per i seguenti comandi 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; ``` La ridenominazione di un role (`ALTER ROLE myrole RENAME TO newname`) è inoltre limitata se la password utilizza l'algoritmo di MD5 hashing. Con questa funzionalità attiva, se si tenta di eseguire uno di questi comandi SQL senza le autorizzazioni di ruolo `rds_password`, viene generato il seguente errore: ``` ERROR: must be a member of rds_password to alter passwords ``` Si consiglia di concedere i privilegi `rds_password` solo a ruoli utilizzati esclusivamente per la gestione delle password. Se si concedono i privilegi `rds_password` agli utenti del database sprovvisti dei privilegi `rds_superuser`, è necessario concedere loro anche l'attributo `CREATEROLE`. Assicurarsi di verificare i requisiti della password come la scadenza e la complessità necessaria sul lato client. Se si utilizza la propria utilità lato client per le modifiche relative alla password, l'utilità deve essere membro di `rds_password` e avere i privilegi `CREATE ROLE`. # Utilizzo delle crittografia password SCRAM per PostgreSQL Il *Salted Challenge Response Authentication Mechanism (SCRAM)* è un'alternativa all'algoritmo Message Digest (MD5) predefinito di PostgreSQL per la crittografia delle password. Il meccanismo di autenticazione SCRAM è considerato più sicuro di. MD5 Per ulteriori informazioni su questi due diversi approcci di protezione delle password, consulta la sezione relativa alla [autenticazione password](https://www.postgresql.org/docs/14/auth-password.html) nella documentazione di PostgreSQL. Si consiglia di utilizzare SCRAM anziché MD5 come schema di crittografia delle password per il cluster DB. l’istanza database RDS per PostgreSQL. È un meccanismo crittografico di richiesta/risposta che utilizza l'algoritmo scram-sha-256 per l'autenticazione e la crittografia delle password. Potrebbe essere necessario aggiornare le librerie per le applicazioni client per supportare SCRAM. Ad esempio, le versioni JDBC precedenti alla 42.2.0 non supportano SCRAM. Per ulteriori informazioni, consulta [PostgreSQL JDBC Driver](https://jdbc.postgresql.org/changelogs/2018-01-17-42.2.0-release/) nella documentazione di PostgreSQL JDBC Driver. Per un elenco di altri driver PostgreSQL e il supporto SCRAM, consulta [Elenco dei driver](https://wiki.postgresql.org/wiki/List_of_drivers) nella documentazione di PostgreSQL. RDS per PostgreSQL versione 13.1 e successive supportano scram-sha-256. Queste versioni consentono inoltre di configurare l'istanza database per richiedere SCRAM, come illustrato nelle procedure seguenti. ## Configurazione del SCRAM puoi richiedere che l'istanza database di RDS per PostgreSQL accetti solo password che utilizzano l'algoritmo scram-sha-256. **Importante** Per i proxy RDS esistenti con database PostgreSQL, se si modifica l'autenticazione del database in modo da utilizzare solo `SCRAM`, il proxy diventa non disponibile per un massimo di 60 secondi. Per evitare il problema, procedi in uno dei seguenti modi: Assicurati che il database consenta entrambe le autenticazioni `SCRAM` e `MD5`. Per utilizzare solo l'autenticazione `SCRAM`, crea un nuovo proxy, esegui la migrazione del traffico dell'applicazione sul nuovo proxy, quindi elimina il proxy precedentemente associato al database. Prima di apportare modifiche al sistema, assicurati di comprendere il processo completo, come segue: + Ottieni informazioni su tutti i ruoli e la crittografia password per tutti gli utenti del database. + Verifica le impostazioni dei parametri per l'istanza database di RDS per PostgreSQL per i parametri che controllano la crittografia password. + Se l'istanza database di RDS per PostgreSQL utilizza un gruppo di parametri predefinito, devi creare un gruppo di parametri database e applicarlo all'istanza database di RDS per PostgreSQL in modo da poter modificare i parametri quando necessario. Se l'istanza database di RDS per PostgreSQL utilizza un gruppo di parametri personalizzati, puoi modificare i parametri necessari in seguito nel processo, in base alle esigenze. + Modifica il parametro `password_encryption` in `scram-sha-256`. + Invia una notifica a tutti gli utenti del database per informarli che devono aggiornare le password. Esegui la stessa operazione per l'account `postgres`. Le nuove password sono crittografate e archiviate utilizzando l'algoritmo scram-sha-256. + Verifica che tutte le password siano crittografate utilizzando come il tipo di crittografia. + Se tutte le password utilizzano scram-sha-256, puoi modificare il `rds.accepted_password_auth_method` da `md5+scram` a `scram-sha-256`. **avvertimento** Dopo aver modificato `rds.accepted_password_auth_method` in scram-sha-256, gli eventuali utenti (ruoli) con password crittografate `md5` non potranno connettersi. ### Prepararsi a richiedere SCRAM per l' Prima di apportare modifiche all'istanza database RDS per PostgreSQL, controlla tutti gli account utente del database esistenti. Inoltre, controlla il tipo di crittografia utilizzato per le password. Puoi eseguire queste attività utilizzando l'estensione `rds_tools`. Per vedere quali versioni di PostgreSQL supportano `rds_tools`, consulta [Versioni delle estensioni per Amazon RDS per PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html). **Per ottenere un elenco di utenti del database (ruoli) e metodi di crittografia password** 1. Utilizza `psql` per connetterti all'istanza database RDS per PostgreSQL, come mostrato di seguito. ``` psql --host=db-name.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password ``` 1. Installa l’estensione `rds_tools`. ``` postgres=> CREATE EXTENSION rds_tools; CREATE EXTENSION ``` 1. Ottieni un elenco di ruoli e crittografia. ``` postgres=> SELECT * FROM rds_tools.role_password_encryption_type(); ``` L'output visualizzato è simile al seguente. ``` 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) ``` ### Creazione di un gruppo di parametri DB personalizzato **Nota** Se l'istanza database di RDS per PostgreSQL utilizza già un gruppo di parametri personalizzati, non è necessario crearne uno nuovo. Per una panoramica dei gruppi di parametri per Amazon RDS, consulta [Utilizzo dei parametri sull'istanza database RDS for PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Parameters.md). Il tipo di crittografia password utilizzato per le password è impostato in un parametro, `password_encryption`. La crittografia consentita dall'istanza database di RDS per PostgreSQL è impostata in un altro parametro, `rds.accepted_password_auth_method`. La modifica di uno di questi rispetto ai valori predefiniti richiede la creazione di un gruppo di parametri database personalizzato e l'applicazione all'istanza. Per ulteriori informazioni, consulta Ora puoi associare il gruppo di parametri personalizzati all'istanza database. **Per creare un gruppo di parametri di DB)** 1. Utilizza il comando CLI `[create-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-parameter-group.html) ` per creare il gruppo di parametri database personalizzato. Questo esempio utilizza `postgres13` come l'origine per questo gruppo di parametri personalizzati. Per 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' ``` Per 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. Utilizza il comando CLI `[modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)` per applicare questo gruppo di parametri personalizzati al cluster database RDS per PostgreSQL. Per Linux, macOS o Unix: ``` aws rds modify-db-instance --db-instance-identifier 'your-instance-name' \ --db-parameter-group-name "docs-lab-scram-passwords ``` Per Windows: ``` aws rds modify-db-instance --db-instance-identifier "your-instance-name" ^ --db-parameter-group-name "docs-lab-scram-passwords ``` Per ripetere la sincronizzazione dell'istanza database RDS per PostgreSQL con il gruppo di parametri DB personalizzato, è necessario riavviare l'istanza principale e tutte le altre istanze del cluster. Per ridurre al minimo l'impatto sugli utenti, pianifica questa operazione in modo che si verifichi durante la normale finestra di manutenzione. ### Configurazione della crittografia password per utilizzare SCRAM Il meccanismo di crittografia password utilizzato da un'istanza database RDS per PostgreSQL è impostato nel gruppo di parametri DB nel parametro `password_encryption`. I valori consentiti sono unset, `md5` o `scram-sha-256`. Il valore predefinito dipende dalla versione di RDS per PostgreSQL come segue: + RDS per PostgreSQL 14 e versioni successive: l'impostazione predefinita è `scram-sha-256` + RDS per PostgreSQL 13: l'impostazione predefinita è `md5` Con un gruppo di parametri database personalizzato collegato all'istanza database di RDS per PostgreSQL, puoi modificare i valori per il parametro di crittografia password. ![\[Di seguito, la console RDS mostra i valori predefiniti per i parametri password_encryption per RDS per PostgreSQL.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/rpg-pwd-encryption-md5-scram-1.png) **Per modificare l'impostazione di crittografia password in scram-sha-256** + Modifica il valore della crittografia password in scram-sha-256, come mostrato di seguito. La modifica può essere applicata immediatamente perché il parametro è dinamico, quindi non è necessario un riavvio per rendere effettiva la modifica. Per 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' ``` Per 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" ``` ### Migrazione delle password per i ruoli utente in SCRAM Puoi migrare le password per i ruoli utente a SCRAM come descritto di seguito. **Per migrare le password degli utenti (ruoli) del database da a SCRAM MD5** 1. Accedi come utente amministratore (nome utente predefinito, `postgres`) come mostrato di seguito. ``` psql --host=db-name.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password ``` 1. Controlla l'impostazione del parametro `password_encryption` sull'istanza database RDS per PostgreSQL utilizzando il comando seguente. ``` postgres=> SHOW password_encryption; password_encryption --------------------- md5 (1 row) ``` 1. Modifica il valore di questo parametro in scram-sha-256. Per ulteriori informazioni, consulta [Configurazione della crittografia password per utilizzare SCRAM](#PostgreSQL_Password_Encryption_configuration.configure-password-encryption). 1. Controlla nuovamente il valore per essere certo che ora sia impostato su `scram-sha-256`, come descritto di seguito. ``` postgres=> SHOW password_encryption; password_encryption --------------------- scram-sha-256 (1 row) ``` 1. Invia una notifica a tutti gli utenti del database con la richiesta di modificare le password. Assicurati di modificare anche la password per l'account `postgres` (l'utente del database con privilegi `rds_superuser`). ``` labdb=> ALTER ROLE postgres WITH LOGIN PASSWORD 'change_me'; ALTER ROLE ``` 1. Ripeti il processo per tutti i database sul l’istanza database RDS per PostgreSQL. ### Modifica del parametro per richiedere SCRAM Questo è il passaggio finale del processo. Dopo aver apportato la modifica nella procedura seguente, gli eventuali account utente (ruoli) che ancora utilizzano la crittografia `md5` per le password non possono accedere al l’istanza database RDS per PostgreSQL. Il `rds.accepted_password_auth_method` specifica il metodo di crittografia accettato dall'istanza database di RDS per PostgreSQL per una password utente durante il processo di accesso. Il valore predefinito è `md5+scram`, il che significa che entrambi i metodi sono accettati. Nell'immagine seguente, è disponibile l'impostazione predefinita per questo parametro. ![\[La console RDS che mostra i valori predefiniti e consentiti per i parametri rds.accepted_password_auth_method.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/pwd-encryption-md5-scram-2.png) I valori consentiti per questo parametro sono `md5+scram` o `scram`. La modifica del valore di questo parametro in `scram` lo rende un requisito. **Modificare il valore del parametro per richiedere l'autenticazione SCRAM per le password** 1. Verifica che tutte le password degli utenti del database per tutti i database sull'istanza database di RDS per PostgreSQL utilizzino `scram-sha-256` per la crittografia password. A questo proposito, esegui la query su `rds_tools` per il ruolo (utente) e il tipo di crittografia, come segue. ``` 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. Ripeti la query su tutte le istanze database nel l’istanza database RDS per PostgreSQL. Se tutte le password utilizzano scram-sha-256, puoi procedere. 1. Modifica il valore dell’autenticazione password accettata in scram-sha-256, come riportato di seguito. Per 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' ``` Per 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" ```