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'istanza RDS del cluster Aurora PostgreSQL DB . 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/AuroraUserGuide/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-cluster` AWS CLI anziché il Console di gestione AWS, si crea il nome utente passandolo con il `master-username` parametro. Per ulteriori informazioni, consulta [Fase 2: creazione di un cluster di database Aurora PostgreSQL](CHAP_GettingStartedAurora.AuroraPostgreSQL.FullConfig.md#CHAP_GettingStarted.AuroraPostgreSQL.CreateDBCluster). 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 nel cluster di database Aurora 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 Aurora PostgreSQL. Per ulteriori informazioni, consulta [Utilizzo di estensioni e wrapper di dati esterni](Appendix.PostgreSQL.CommonDBATasks.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`. Aurora 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 Aurora. 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 uncluster di database Aurora 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 cluster di database Aurora 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 Aurora PostgreSQL per molte attività di gestione. # 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. **Nota** Aurora PostgreSQL versioni 15.2 e 14.7 hanno introdotto un funzionamento restrittivo del ruolo `rds_superuser`. A un utente Aurora PostgreSQL deve essere concesso il privilegio `CONNECT` per consentire la connessione al database corrispondente anche se tale utente è associato al ruolo `rds_superuser`. Prima delle versioni 14.7 e 15.2 di Aurora PostgreSQL, un utente era in grado di connettersi a qualsiasi database e tabella di sistema se disponeva del ruolo `rds_superuser`. Questo comportamento restrittivo è in linea con AWS gli impegni di Amazon Aurora per il miglioramento continuo della sicurezza. Aggiorna la rispettiva logica nelle tue applicazioni se sono state interessate dal miglioramento precedentemente descritto. # 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 sul nodo primario del cluster Aurora 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 cluster di database Aurora 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 primaria sul cluster di database Aurora PostgreSQL: ``` psql --host=your-cluster-instance-1.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, il cluster di database Aurora PostgreSQL deve eseguire Amazon Aurora 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 principale Aurora 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 Aurora PostgreSQL DB. SCRAM è supportato in Aurora PostgreSQL versione 10 e in tutte le versioni principali e secondarie successive. È 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. Aurora PostgreSQL versione 14 e successive supportano scram-sha-256 per la crittografia password per impostazione predefinita per nuovi cluster database. Per queste versioni, il gruppo di parametri del cluster di database predefinito (`default.aurora-postgresql14`) ha il valore `password_encryption` è impostato su scram-sha-256. SCRAM non è supportato per Aurora Serverless v1. ## Configurazione del cluster RDS di Aurora PostgreSQL DB per l'istanza DB PostgreSQL per l'istanza DB di PostgreSQL per richiedere Per Aurora PostgreSQL 14.3 e versioni successive, puoi richiedere che il cluster database Aurora 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 il cluster database Aurora PostgreSQL per i parametri che controllano la crittografia password. + Se il cluster database Aurora PostgreSQL utilizza un gruppo di parametri predefinito, devi creare un gruppo di parametri cluster database e applicarlo al cluster database Aurora PostgreSQL in modo da poter modificare i parametri quando necessario. Se il cluster database Aurora 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. ### Prima di apportare modifiche al cluster database Aurora 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 principale del cluster database Aurora PostgreSQL , come mostrato di seguito. ``` psql --host=cluster-name-instance-1.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 del cluster DB personalizzato **Nota** Se il cluster database Aurora PostgreSQL utilizza già un gruppo di parametri personalizzati, non è necessario crearne uno nuovo. Per una panoramica dei gruppi di parametri per Aurora, consulta [Creazione di un gruppo di parametri del cluster DB in Amazon Aurora](USER_WorkingWithParamGroups.CreatingCluster.md). Il tipo di crittografia password utilizzato per le password è impostato in un parametro, `password_encryption`. La crittografia consentita dal cluster database Aurora 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 del cluster database personalizzato e l'applicazione al cluster. Per ulteriori informazioni, consulta [Creazione di un gruppo di parametri del cluster DB in Amazon Aurora](USER_WorkingWithParamGroups.CreatingCluster.md). Ora puoi associare il gruppo di parametri personalizzati all'istanza database. **Per creare un gruppo di parametri di cluster DB personalizzato (gruppo di parametri )** 1. Utilizza il comando CLI `[create-db-cluster-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster-parameter-group.html)` per creare il gruppo di parametri personalizzati per il cluster. Il seguente esempio utilizza `aurora-postgresql13` come l'origine per questo gruppo di parametri personalizzati. Per Linux, macOS o Unix: ``` aws rds create-db-cluster-parameter-group --db-cluster-parameter-group-name 'docs-lab-scram-passwords' \ --db-parameter-group-family aurora-postgresql13 --description 'Custom DB cluster parameter group for SCRAM' ``` Per Windows: ``` aws rds create-db-cluster-parameter-group --db-cluster-parameter-group-name "docs-lab-scram-passwords" ^ --db-parameter-group-family aurora-postgresql13 --description "Custom DB cluster parameter group for SCRAM" ``` Ora puoi associare il gruppo di parametri personalizzati al cluster. 1. Utilizza il comando CLI `[modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html)` per applicare questo gruppo di parametri personalizzati al cluster database Aurora PostgreSQL. Per Linux, macOS o Unix: ``` aws rds modify-db-cluster --db-cluster-identifier 'your-instance-name' \ --db-cluster-parameter-group-name "docs-lab-scram-passwords ``` Per Windows: ``` aws rds modify-db-cluster --db-cluster-identifier "your-instance-name" ^ --db-cluster-parameter-group-name "docs-lab-scram-passwords ``` Per ripetere la sincronizzazione del cluster database Aurora PostgreSQL con il gruppo di parametri del cluster DB personalizzati, è necessario riavviare l'istanza principale e tutte le altre istanze del cluster. ### Configurazione della crittografia password per utilizzare SCRAM Il meccanismo di crittografia password utilizzato da un cluster database Aurora PostgreSQL è impostato nel gruppo di parametri del cluster DB nel parametro `password_encryption`. I valori consentiti sono unset, `md5` o `scram-sha-256`. Il valore predefinito dipende dalla versione di Aurora PostgreSQL come segue: + Aurora PostgreSQL 14:-l'impostazione predefinita è `scram-sha-256` + Aurora PostgreSQL 13: l'impostazione predefinita è `md5` Con un gruppo di parametri del cluster database personalizzato collegato al cluster database Aurora 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 Aurora PostgreSQL.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/apg-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-cluster-parameter-group --db-cluster-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=cluster-name-instance-1.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 cluster database Aurora 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 cluster database Aurora PostgreSQL. Il `rds.accepted_password_auth_method` specifica il metodo di crittografia accettato dal cluster database Aurora 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/AuroraUserGuide/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 sul cluster database Aurora 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 cluster database Aurora 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-cluster-parameter-group --db-cluster-parameter-group-name 'docs-lab-scram-passwords' \ --parameters 'ParameterName=rds.accepted_password_auth_method,ParameterValue=scram,ApplyMethod=immediate' ``` Per Windows: ``` aws rds modify-db-cluster-parameter-group --db-cluster-parameter-group-name "docs-lab-scram-passwords" ^ --parameters "ParameterName=rds.accepted_password_auth_method,ParameterValue=scram,ApplyMethod=immediate" ```