PostgreSQL
 sql >> Database >  >> RDS >> PostgreSQL

Gestione dei ruoli e degli attributi dei ruoli in PostgreSQL


Introduzione

PostgreSQL utilizza vari meccanismi per implementare l'autenticazione, l'autorizzazione e la proprietà degli oggetti all'interno dei cluster di database. Il fulcro di questi è il concetto di ruoli.

I ruoli PostgreSQL sono una combinazione delle idee di utenti e gruppi in un'unica entità flessibile. Sono la persona che l'utente adotta all'interno del sistema di database, sono l'entità mediante la quale il sistema di autenticazione accetta o rifiuta le connessioni e l'oggetto delle regole di gestione dei privilegi di tutti gli ambiti.

Questa guida tratterà quali sono i ruoli e come gestirli all'interno di un cluster di database PostgreSQL. Più specificamente, questa guida tratterà la gestione dei ruoli in relazione agli attributi dei ruoli. Per una panoramica più ampia di come i ruoli si inseriscono nel quadro più ampio, dai un'occhiata alla guida introduttiva all'autenticazione e all'autorizzazione. Per informazioni su come modificare i privilegi di ruolo su oggetti database specifici, consulta la nostra guida sulle concessioni di ruolo.



Cosa sono i ruoli?

In PostgreSQL, un ruolo è un raggruppamento di un insieme specifico di capacità, autorizzazioni ed entità "di proprietà". Invece di avere concetti distinti di "utenti" e "gruppi", PostgreSQL usa i ruoli per rappresentare entrambe queste idee. Un ruolo può corrispondere a una singola persona nel mondo reale, oppure può operare come un gruppo con un certo accesso di cui altri ruoli possono diventare membri.

I ruoli sono il punto di ancoraggio all'interno di PostgreSQL che determina a chi si applicano le politiche di autenticazione e autorizzazione. Qualsiasi politica che non si applica universalmente richiede una nozione di identità per definire chi limitare e chi consentire. In PostgreSQL, questa identità è rappresentata dai ruoli.

Il sistema di autenticazione di PostgreSQL ha diversi componenti, ognuno dei quali è legato a ruoli. Per essere utilizzati per la connessione iniziale al cluster di database, i ruoli devono prima avere il LOGIN insieme di attributi. Le regole di autenticazione stesse sono definite nel file di configurazione basato sull'host chiamato pg_hba.conf . Ciascuna regola definisce i metodi di autenticazione che possono avere come ambito il singolo ruolo. Per i ruoli configurati per l'autenticazione tramite password, è necessario disporre di un attributo password impostato in modo che il sistema possa convalidare la password utente fornita.

In termini di autorizzazione, i ruoli sono definiti a livello di cluster di database, che in PostgreSQL significa che sono condivisi tra database. Poiché i ruoli si estendono nei database, il sistema di autorizzazione controlla il livello di accesso di ciascun ruolo a ciascuna entità del database. Poiché i ruoli possono rappresentare gruppi di persone, c'è una grande flessibilità nel modo in cui è possibile configurare l'accesso.

I ruoli sono anche essenziali per il concetto di proprietà degli oggetti all'interno di PostgreSQL. Ogni database e tabella, ad esempio, ha esattamente un ruolo configurato come proprietario. Altro che superusers , il ruolo di proprietario è l'unico ruolo che può modificare o eliminare l'oggetto effettivo.

In sintesi, i ruoli sono al centro delle operazioni di database più pratiche. La loro flessibilità consente loro di agire sia come identificatori utente che come classi utente. Ogni azione all'interno del cluster di database viene verificata rispetto ai privilegi del ruolo e il successo di ogni connessione al cluster di database è determinato dal ruolo in cui ci si autentica. È importante avere una buona padronanza della gestione dei ruoli a causa della sua importanza all'interno di così tante operazioni principali.



Attributi del ruolo

Gli attributi del ruolo sono flag sul ruolo stesso che determinano alcuni dei privilegi principali di cui dispone a livello di cluster di database. Questi possono essere impostati al momento della creazione iniziale del ruolo o modificati in qualsiasi momento da qualsiasi ruolo con gli attributi appropriati (SUPERUSER o CREATEROLE in questo caso).

Gli attributi che possono essere applicati a un ruolo includono:

  • LOGIN :consente agli utenti di connettersi inizialmente al cluster di database utilizzando questo ruolo. Il CREATE USER comando aggiunge automaticamente questo attributo, mentre CREATE ROLE il comando non lo fa.
  • SUPERUSER :consente al ruolo di ignorare tutti i controlli di autorizzazione tranne il diritto di accesso. Solo altri SUPERUSER i ruoli possono creare ruoli con questo attributo.
  • CREATEDB :consente al ruolo di creare nuovi database.
  • CREATEROLE :consente al ruolo di creare, modificare ed eliminare altri ruoli. Questo attributo consente inoltre al ruolo di assegnare o modificare l'appartenenza al ruolo. Un'eccezione è che un ruolo con CREATEROLE l'attributo non può alterare SUPERUSER ruoli senza avere anche il SUPERUSER attributo.
  • REPLICATION :consente al ruolo di avviare la replica in streaming. I ruoli con questo attributo devono inoltre avere il LOGIN attributo.
  • PASSWORD :Assegna una password al ruolo che verrà utilizzato con password o md5 meccanismi di autenticazione. Questo attributo accetta una password tra virgolette come argomento subito dopo la parola chiave dell'attributo.
  • INHERIT :determina se il ruolo eredita i privilegi dei ruoli di cui è membro. Senza il INHERIT , i membri devono utilizzare SET ROLE passare all'altro ruolo per accedere a quei privilegi esclusivi. Questo attributo è impostato per i nuovi ruoli per impostazione predefinita.

Puoi scoprire di più sugli attributi dei ruoli consultando la documentazione di PostgreSQL sugli attributi dei ruoli e CREATE ROLE comando.



Cos'è un superuser ruolo?

Come accennato in precedenza, un privilegio speciale chiamato superuser consente l'accesso amministrativo illimitato al cluster di database. Questo è simile alla root account in sistemi operativi simili a Linux e Unix, ma a livello di database.

Deve esserci sempre almeno un ruolo con superuser privilegi in ogni cluster di database. Il superuser iniziale l'account viene creato durante il processo di installazione. Il nome del superuser iniziale l'account può variare a seconda del processo di installazione, ma il più delle volte questo account è chiamato postgres .

Non è consigliabile svolgere il lavoro quotidiano utilizzando un account con superuser privilegi, sia per il suo potenziale di azioni distruttive sia per ridurre al minimo la possibilità di compromettere un account con ampio accesso. Invece, la maggior parte delle volte, gli utenti dovrebbero utilizzare account dedicati alle funzioni specifiche o agli oggetti dati con cui stanno lavorando, usando solo il superuser account quando è richiesto un accesso più potente.



Verifica degli attributi del ruolo esistenti

Ora che hai un'idea generale di cosa sono gli attributi del ruolo e quali tipi di privilegi consentono, dovresti imparare come trovare gli attributi applicati ai ruoli in PostgreSQL. Questa sezione ti mostrerà alcuni comandi per aiutarti a trovare gli attributi impostati sui ruoli in generale e sul tuo ruolo attuale nello specifico.


Elencare tutti i ruoli del database e i relativi attributi

Esistono diversi modi per controllare gli attributi applicati ai ruoli nel sistema.

Se stai usando psql client della riga di comando, puoi sfruttare alcuni utili meta-comandi che ti consentono di ottenere informazioni sugli attributi del ruolo senza una query.

Il \du il meta-comando mostra tutti i ruoli e i loro attributi:

\du
 
                                   List of roles Role name |                         Attributes                         | Member of-----------+------------------------------------------------------------+----------- postgres  | Superuser, Create role, Create DB, Replication, Bypass RLS | {}

In questo caso, il postgres role è il ruolo predefinito con superuser privilegi configurati per questo cluster di database.

L'equivalente SQL per elencare i ruoli (rilevabile passando il -E o --echo-hidden flag all'avvio di psql ) è:

SELECT r.rolname, r.rolsuper, r.rolinherit,  r.rolcreaterole, r.rolcreatedb, r.rolcanlogin,  r.rolconnlimit, r.rolvaliduntil,  ARRAY(SELECT b.rolname        FROM pg_catalog.pg_auth_members m        JOIN pg_catalog.pg_roles b ON (m.roleid = b.oid)        WHERE m.member = r.oid) as memberof, r.rolreplication, r.rolbypassrlsFROM pg_catalog.pg_roles rWHERE r.rolname !~ '^pg_'ORDER BY 1;

Di seguito è riportata una query simile che fornisce informazioni sull'attributo del ruolo (senza il componente di appartenenza al ruolo). Usiamo il psql meta-comando \x on per emettere i risultati verticalmente per una migliore leggibilità qui:

-- turn on vertical display\x onSELECT * FROM pg_roles WHERE rolname !~ '^pg_';-- turn off vertical display\x off
 
-[ RECORD 1 ]--+---------rolname        | postgresrolsuper       | trolinherit     | trolcreaterole  | trolcreatedb    | trolcanlogin    | trolreplication | trolconnlimit   | -1rolpassword    | ********rolvaliduntil  | rolbypassrls   | trolconfig      | oid            | 10

Se sei interessato solo a vedere quali ruoli hanno il superuser attributo, puoi chiedere esplicitamente un elenco:

SELECT rolname FROM pg_roles WHERE rolsuper;
 
 rolname---------- postgres(1 row)

In alternativa, puoi elencare tutti gli utenti e il loro superuser stato per un quadro più completo:

SELECT usename,usesuper FROM pg_user;
 
 usename  | usesuper----------+---------- postgres | t user1    | f(2 rows)

Le stesse informazioni possono essere recuperate utilizzando il paradigma del "ruolo" di PostgreSQL invece della sua (a volte ambigua) sovrapposizione "utente" con questa query leggermente più lunga:

SELECT rolname,rolsuper FROM pg_roles WHERE rolname !~ '^pg_';
 
 rolname  | rolsuper----------+---------- postgres | t user1    | f(2 rows)


Elencare i tuoi attributi

Se vuoi trovare gli attributi del ruolo che stai attualmente utilizzando, puoi facilmente filtrare l'output.

Quando si utilizza psql meta-comandi, puoi usare il USER variabile, che verrà sostituita con il ruolo connesso corrente. psql usa i due punti (: ) per interpolare variabili:

\du :USER
 
                                   List of roles Role name |                         Attributes                         | Member of-----------+------------------------------------------------------------+----------- postgres  | Superuser, Create role, Create DB, Replication, Bypass RLS | {}

Per ottenere un elenco che mostri i valori di tutti i possibili attributi del ruolo, puoi utilizzare una query confrontando il nome del ruolo con il valore restituito da CURRENT_ROLE funzione PostgreSQL. Ancora una volta, stiamo usando l'output verticale per la leggibilità:

-- First, turn on vertical output\x onSELECT * FROM pg_roles WHERE rolename = CURRENT_ROLE;-- Change back to normal output\x off
 
-[ RECORD 1 ]--+---------rolname        | postgresrolsuper       | trolinherit     | trolcreaterole  | trolcreatedb    | trolcanlogin    | trolreplication | trolconnlimit   | -1rolpassword    | ********rolvaliduntil  |rolbypassrls   | trolconfig      |oid            | 10

Per verificare semplicemente se il tuo ruolo attuale ha superuser privilegi, puoi digitare:

SHOW is_superuser;
 
 is_superuser-------------- on(1 row)


Verifica se disponi dei privilegi di gestione dei ruoli

Per creare, modificare o eliminare ruoli, devi avere un superuser o CREATEROLE privilegi.

Per verificare quali ruoli all'interno del sistema dispongono dei privilegi di gestione dei ruoli, digitare:

SELECT rolname as "Users who can manage roles" FROM pg_roles WHERE rolsuper OR rolcreaterole;
 
 Users who can manage roles---------------------------- postgres(1 rows)

Se vuoi solo sapere se il tuo ruolo attuale dispone dei privilegi di gestione dei ruoli, puoi invece utilizzare:

SELECT 'Yes' AS "Can I manage roles?" FROM pg_roles WHERE rolname = :'USER' AND (rolsuper OR rolcreaterole);
 
 Can I manage roles?--------------------- Yes(1 row)



Creazione di ruoli

Dopo aver verificato di disporre dei privilegi di gestione dei ruoli, puoi iniziare a creare, modificare o rimuovere ruoli all'interno di PostgreSQL.

Un'opzione per impostare gli attributi del ruolo consiste nel dichiararli al momento della creazione del ruolo. Ciò consente di impostare le condizioni iniziali per il ruolo, ma è comunque possibile modificarle in seguito se si desidera modificare il livello di accesso del ruolo. Puoi trovare maggiori informazioni su CREATE ROLE comando che useremo per familiarizzare con la sintassi di base.

Un modo per creare un ruolo è dalla riga di comando. PostgreSQL include un createuser comando che creerà un ruolo all'interno del cluster di database con LOGIN privilegi.

La sintassi generale è:

createuser <options> <rolename>

Ad esempio, per creare un ruolo denominato admin con superuser privilegi durante la richiesta di una password, puoi digitare:

createuser --superuser admin

Sarai quindi in grado di accedere utilizzando l'admin account secondo i metodi di autenticazione descritti in pg_hba.conf file.

Per creare ruoli utilizzando SQL , la sintassi generale è simile alla seguente:

CREATE ROLE <role>;

Gli attributi possono essere definiti specificandoli dopo il nome del ruolo utilizzando WITH :

CREATE ROLE <role> WITH <options>;

Ad esempio, per creare un ruolo denominato user1 che può accedere con la password secretpassword , puoi digitare:

CREATE ROLE "user1" WITH LOGIN PASSWORD 'secretpassword';

Per creare invece un ruolo con superuser privilegi (devi anche essere un superuser per eseguire correttamente questo comando) che non può login (l'utente deve utilizzare SET ROLE per passare a questo ruolo), puoi digitare:

CREATE ROLE "user2" WITH SUPERUSER;


Cambiare i ruoli esistenti

Per modificare gli attributi dei ruoli esistenti, puoi utilizzare il ALTER ROLE comando invece. Come per la creazione del ruolo, anche il tuo ruolo attuale deve avere uno dei due superuser o CREATEROLE privilegi. Gli utenti che non dispongono di tali privilegi possono utilizzare solo il ALTER ROLE comando per modificare la propria password.

La modifica dei ruoli consente di modificare gli attributi assegnati a un ruolo dopo la creazione. Gli stessi attributi menzionati nella sezione di creazione del ruolo possono essere utilizzati con ALTER ROLE sintassi. Una differenza è che ogni tipo di attributo può essere negato aggiungendo il NO prefisso. Ad esempio, per consentire a un ruolo di accedere al cluster di database, puoi assegnargli il LOGIN attributo. Per rimuovere tale capacità, devi modificare il ruolo specificando NOLOGIN .

Il ALTER ROLE comando cambia solo gli attributi sono quelli esplicitamente menzionati. In altre parole, il ALTER ROLE il comando specifica modifiche agli attributi, non un set completo di nuovi attributi.

Per consentire a user2 ruolo per accedere al cluster di database, puoi digitare:

ALTER ROLE "user2" WITH LOGIN;

Tieni presente che mentre ciò consente la possibilità di accedere, i metodi di autenticazione consentiti sono comunque controllati da pg_hba.conf file.

Se vuoi user2 per poter accedere, creare ruoli e creare database invece, puoi specificare questi tre attributi, separati da spazi:

ALTER ROLE "user2" WITH LOGIN CREATEROLE CREATEDB;

Per revocare superuser status da un ruolo (puoi eseguire questo comando solo usando un altro superuser ruolo), digitare:

ALTER ROLE "user2" WITH NOSUPERUSER;

Per modificare la password per un ruolo, puoi digitare quanto segue (tutti i ruoli dovrebbero essere in grado di eseguire questo comando nel proprio ruolo, indipendentemente da CREATEROLE o superuser privilegi):

ALTER ROLE <role> WITH PASSWORD '<password>';

Sebbene il comando sopra funzioni, se possibile, è un'idea migliore usare psql metacomando per cambiare le password. Il psql Il comando richiede automaticamente una password e la crittografa prima di inviarla al server. Questo aiuta a evitare la perdita di dati sensibili nei log.

Puoi modificare la password di un ruolo con psql digitando quanto segue

-- To change your own password\password-- To change the password for another role\password <role>

Puoi anche usare il ALTER ROLE comando per rinominare un ruolo:

ALTER ROLE <role> RENAME TO <newrole>

Tieni presente che non puoi rinominare il tuo ruolo di sessione corrente.



Eliminazione ruoli

L'eliminazione di un ruolo esistente segue uno schema simile ai comandi precedenti. Ancora una volta, devi avere CREATEROLE o superuser privilegi per eseguire questi comandi.

Un fattore complicante è che i ruoli non possono essere rimossi se sono ancora referenziati da oggetti all'interno del database. Ciò significa che è necessario eliminare o trasferire la proprietà di tutti gli oggetti di cui è proprietario il ruolo. Successivamente, devi anche revocare eventuali privilegi aggiuntivi che il ruolo ha sugli oggetti del database.

Una spiegazione dettagliata di come riassegnare e rilasciare i privilegi in modo appropriato è fornita da Erwin Brandstetter sul sito Database Administrators Stack Exchange. Questo stesso processo viene utilizzato di seguito.

Innanzitutto, puoi riassegnare tutti gli oggetti di proprietà del ruolo utilizzando REASSIGNED OWNED comando. Ad esempio, se ti stai preparando a eliminare user2 ruolo, puoi assegnare i suoi oggetti al postgres ruolo digitando:

REASSIGN OWNED BY "user2" TO "postgres";

Ora gli oggetti sono di proprietà di postgres , possiamo usare il DROP OWNED comando per revocare tutti gli altri privilegi che ci sono stati concessi sugli oggetti. Questo comando cancella anche tutti gli oggetti che possediamo, ma poiché li abbiamo appena trasferiti nel postgres ruolo, il user2 il ruolo non ha più oggetti di proprietà. Per questo motivo, il comando revocherà solo i privilegi aggiuntivi del ruolo:

DROP OWNED BY "user2";

Senza il DROP OWNED scorciatoia sopra, dovresti eseguire REVOKE ALL PRIVILEGES su ogni singolo oggetto o tipo di oggetto su cui il ruolo ha i privilegi.

Dopo aver revocato tutti i privilegi associati, puoi rimuovere il ruolo digitando:

DROP ROLE "user2";


Accesso utilizzando psql

Dopo aver configurato un nuovo ruolo e aver configurato i dettagli di autenticazione utilizzando pg_hba.conf file, puoi accedere al cluster di database usando il tuo nuovo ruolo. Il psql il client della riga di comando fornisce un modo semplice per farlo.

Per impostazione predefinita, psql presuppone che tu voglia connetterti utilizzando un ruolo che corrisponda al nome utente del tuo sistema operativo. Quindi, se hai effettuato l'accesso al tuo computer come john , psql presumerà che tu voglia provare a connetterti al database usando un ruolo chiamato anche john .

Per ignorare questo comportamento, puoi passare il -U o --username= opzione. Ad esempio, se vuoi accedere a un ruolo chiamato kerry , puoi digitare:

psql -U kerry

Il successo di psql il comando dipenderà dall'esistenza del kerry ruolo, l'accessibilità del server a cui stai tentando di connetterti e le regole di autenticazione definite sul server.



Passare a un ruolo diverso durante una sessione

A volte, potresti voler adottare temporaneamente i privilegi e l'identità di un altro ruolo a cui hai accesso. Ad esempio, questo è necessario se vuoi ottenere i privilegi di un ruolo di cui sei membro se il tuo ruolo attuale non ha il INHERIT attributo.

Per capire come funziona, devi conoscere la terminologia utilizzata da PostgreSQL per classificare i ruoli attivi:

  • Ruolo della sessione :Un ruolo di sessione è il ruolo con cui hai effettuato l'accesso durante la connessione iniziale al cluster di database PostgreSQL. Imposta i tuoi privilegi iniziali e determina il tuo accesso al sistema. Questo ruolo deve avere il LOGIN attributo.
  • Ruolo attuale :Al contrario, il ruolo attuale è il ruolo che stai attualmente interpretando. I privilegi associati al ruolo corrente, siano essi impostati direttamente o ereditati da altri ruoli, determinano le azioni che puoi eseguire e gli oggetti a cui hai accesso.

Puoi visualizzare i valori della tua sessione e del ruolo corrente digitando:

SELECT SESSION_USER, CURRENT_USER;
 
 current_user | session_user--------------+-------------- postgres     | postgres(1 row)

Sebbene l'unico modo per modificare il ruolo della sessione sia avviare una nuova connessione utilizzando un ruolo diverso, puoi modificare il ruolo attuale utilizzando il SET ROLE comando. Il SET ROLE comando viene utilizzato per agire temporaneamente come un ruolo diverso. Il comando accetta facoltativamente anche i seguenti modificatori:

  • SESSION :L'impostazione predefinita. Ciò provoca il SET ROLE comando per influenzare l'intera sessione del database.
  • LOCAL :Questo modificatore farà cambiare il ruolo al comando solo per la transazione corrente.

Per cambiare il ruolo corrente in user2 ruolo (per il resto della sessione), digitare:

SET ROLE "user2";

Se controlli la tua sessione e i valori del ruolo corrente, vedrai che il valore del ruolo corrente è cambiato:

SELECT SESSION_USER, CURRENT_USER;
 
 current_user | session_user--------------+-------------- user2        | postgres(1 row)

Tutte le tue azioni ora utilizzeranno user2 ruolo come contesto.

Per tornare al ruolo di sessione che avevi utilizzato in precedenza, puoi digitare:

SET ROLE NONE;

Un'alternativa che ottiene lo stesso risultato è:

RESET ROLE;


Conclusione

Il sistema di ruoli, attributi di ruolo, concessioni e autenticazione di PostgreSQL crea un sistema flessibile che consente agli amministratori di gestire in modo efficace le autorizzazioni e l'accesso al database. Questa guida ha descritto cosa sono esattamente i ruoli e come comprendono un'ampia gamma di casi d'uso. Ha inoltre spiegato come creare, modificare ed eliminare ruoli e gestire gli attributi del ruolo che ne determinano le capacità globali. Comprendere come gestire queste identità è necessario per proteggere i tuoi database e fornire un accesso utilizzabile ai tuoi utenti legittimi.