Inleiding
PostgreSQL gebruikt verschillende mechanismen om authenticatie, autorisatie en objecteigendom binnen databaseclusters te implementeren. De kern hiervan is het concept van rollen.
PostgreSQL-rollen zijn een combinatie van de ideeën van gebruikers en groepen in een enkele, flexibele entiteit. Ze zijn de persona die de gebruiker binnen het databasesysteem aanneemt, zijn de entiteit waarmee het authenticatiesysteem verbindingen accepteert of weigert, en het onderwerp van privilegebeheerregels van alle scopes.
In deze handleiding wordt beschreven wat rollen zijn en hoe u deze kunt beheren binnen een PostgreSQL-databasecluster. Meer in het bijzonder zal deze gids betrekking hebben op rolbeheer met betrekking tot rolattributen. Voor een breder overzicht van hoe rollen in het grotere geheel passen, bekijk je de inleiding tot authenticatie en autorisatiehandleiding. Raadpleeg onze gids over roltoekenning voor meer informatie over het wijzigen van rolrechten voor specifieke databaseobjecten.
Wat zijn rollen?
In PostgreSQL is een rol een groepering van een specifieke set van mogelijkheden, machtigingen en entiteiten die eigendom zijn. In plaats van verschillende concepten van 'gebruikers' en 'groepen' te hebben, gebruikt PostgreSQL rollen om beide ideeën weer te geven. Een rol kan overeenkomen met een individuele persoon in de echte wereld, of het kan werken als een groep met bepaalde toegang waar andere rollen lid van kunnen worden.
Rollen zijn het ankerpunt binnen PostgreSQL die bepalen op wie het authenticatie- en autorisatiebeleid van toepassing is. Elk beleid dat niet universeel van toepassing is, vereist een idee van identiteit om te bepalen wie te beperken en wie toe te staan. In PostgreSQL wordt deze identiteit weergegeven door rollen.
Het authenticatiesysteem van PostgreSQL heeft een aantal verschillende componenten, die elk aan rollen zijn gekoppeld. Om te worden gebruikt voor de eerste verbinding met het databasecluster, moeten rollen eerst de LOGIN . hebben attributen ingesteld. De authenticatieregels zelf worden gedefinieerd in het hostgebaseerde configuratiebestand met de naam pg_hba.conf . Elke regel definieert verificatiemethoden die kunnen worden toegespitst op de individuele rol. Voor rollen die zijn geconfigureerd voor wachtwoordverificatie moet een wachtwoordkenmerk zijn ingesteld zodat het systeem het geleverde gebruikerswachtwoord kan valideren.
In termen van autorisatie worden rollen gedefinieerd op databaseclusterniveau, wat in PostgreSQL betekent dat ze worden gedeeld tussen databases. Aangezien rollen databases omvatten, bepaalt het autorisatiesysteem het toegangsniveau dat elke rol heeft tot elke database-entiteit. Omdat rollen groepen mensen kunnen vertegenwoordigen, is er veel flexibiliteit in de manier waarop toegang kan worden geconfigureerd.
Rollen zijn ook essentieel voor het concept van objecteigendom binnen PostgreSQL. Elke database en tabel heeft bijvoorbeeld precies één rol die is geconfigureerd als de eigenaar. Anders dan superusers , is de rol van eigenaar de enige rol die het werkelijke object kan wijzigen of verwijderen.
Samengevat vormen rollen de kern van de meeste praktische databasebewerkingen. Hun flexibiliteit stelt hen in staat om zowel als gebruikersidentificaties als gebruikersklassen te fungeren. Elke actie binnen het databasecluster wordt getoetst aan de privileges van de rol en het succes van elke verbinding met het databasecluster wordt bepaald door de rol waarvoor men zich legitimeert. Het is belangrijk om rolmanagement goed onder de knie te krijgen vanwege het belang ervan binnen zoveel kernactiviteiten.
Rolkenmerken
Rolattributen zijn vlaggen op de rol zelf die een aantal van de kernrechten bepalen die de rol heeft op databaseclusterniveau. Deze kunnen worden ingesteld wanneer de rol voor het eerst wordt gemaakt, of op elk moment worden gewijzigd door elke rol met de juiste kenmerken (SUPERUSER of CREATEROLE in dit geval).
Kenmerken die op een rol kunnen worden toegepast, zijn onder meer:
LOGIN:Hiermee kunnen gebruikers in eerste instantie verbinding maken met het databasecluster met behulp van deze rol. DeCREATE USERcommando voegt dit attribuut automatisch toe, terwijlCREATE ROLEcommando niet.SUPERUSER:Hiermee kan de rol alle toestemmingscontroles omzeilen, behalve het recht om in te loggen. Alleen andereSUPERUSERrollen kunnen rollen maken met dit kenmerk.CREATEDB:Hiermee kan de rol nieuwe databases maken.CREATEROLE:Hiermee kan de rol andere rollen maken, wijzigen en verwijderen. Met dit kenmerk kan de rol ook het lidmaatschap van een rol toewijzen of wijzigen. Een uitzondering is dat een rol met deCREATEROLEattribuut kanSUPERUSERniet veranderen rollen zonder ook deSUPERUSER. te hebben attribuut.REPLICATION:Hiermee kan de rol streamingreplicatie starten. Rollen met dit kenmerk moeten ook deLOGIN. hebben attribuut.PASSWORD:wijst een wachtwoord toe aan de rol die zal worden gebruikt metpasswordofmd5authenticatie mechanismen. Dit kenmerk neemt een wachtwoord tussen aanhalingstekens als argument direct na het kenmerk trefwoord.INHERIT:Bepaalt of de rol de privileges overneemt van de rollen waarvan hij lid is. Zonder deINHERIT, leden moetenSET ROLE. gebruiken om in de andere rol te veranderen om toegang te krijgen tot die exclusieve privileges. Dit kenmerk is standaard ingesteld voor nieuwe rollen.
U kunt meer te weten komen over rolkenmerken door de documentatie van PostgreSQL over rolkenmerken en de CREATE ROLE te bekijken. commando.
Wat is een superuser rol?
Zoals hierboven kort vermeld, een speciaal privilege genaamd superuser staat onbeperkte beheerderstoegang tot het databasecluster toe. Dit is vergelijkbaar met de root account in Linux en Unix-achtige besturingssystemen, maar op databaseniveau.
Er moet altijd minimaal één rol zijn met superuser bevoegdheden in elk databasecluster. De initiële superuser account wordt aangemaakt tijdens het installatieproces. De naam van de initiële superuser account kan variëren afhankelijk van het installatieproces, maar meestal heet dit account postgres .
Het wordt niet aanbevolen om uw dagelijkse werk te doen met een account bij superuser privileges, zowel vanwege het potentieel voor destructieve acties als om de kans op het compromitteren van een account met brede toegang te minimaliseren. In plaats daarvan moeten gebruikers meestal accounts gebruiken die zijn toegewezen aan de specifieke functies of gegevensobjecten waarmee ze werken, alleen met behulp van de superuser accounts wanneer krachtigere toegang vereist is.
Bestaande rolattributen controleren
Nu je een algemeen idee hebt van wat rolattributen zijn en welke soorten privileges ze toestaan, moet je leren hoe je de attributen kunt vinden die in PostgreSQL op rollen zijn toegepast. In dit gedeelte vindt u enkele opdrachten waarmee u de kenmerken kunt vinden die zijn ingesteld voor rollen in het algemeen en voor uw eigen huidige rol in het bijzonder.
Alle databaserollen en hun attributen weergeven
Er zijn een paar verschillende manieren om de kenmerken te controleren die in het hele systeem op rollen zijn toegepast.
Als u de psql . gebruikt opdrachtregelclient, kunt u profiteren van enkele handige meta-commando's waarmee u zonder query informatie over rolattributen kunt krijgen.
De \du meta-commando toont alle rollen en hun attributen:
\du
List of roles Role name | Attributes | Member of-----------+------------------------------------------------------------+----------- postgres | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
In dit geval is de postgres rol is de standaardrol bij superuser privileges geconfigureerd voor dit databasecluster.
De equivalente SQL om rollen weer te geven (vindbaar door de -E . door te geven of --echo-hidden vlag bij het starten van psql ) is:
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;
Hieronder vindt u een vergelijkbare query die informatie over rolattributen biedt (zonder de component rollidmaatschap). We gebruiken de psql meta-commando \x on om de resultaten verticaal uit te voeren voor een betere leesbaarheid hier:
-- 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
Als je alleen geïnteresseerd bent om te zien welke rollen de superuser . hebben kenmerk, kunt u expliciet om een lijst vragen:
SELECT rolname FROM pg_roles WHERE rolsuper;
rolname---------- postgres(1 row)
Als alternatief kunt u alle gebruikers en hun superuser list weergeven status voor een completer beeld:
SELECT usename,usesuper FROM pg_user;
usename | usesuper----------+---------- postgres | t user1 | f(2 rows)
Dezelfde informatie kan worden opgehaald met behulp van het "rol"-paradigma van PostgreSQL in plaats van de (soms dubbelzinnige) "gebruiker"-overlay met in plaats daarvan deze iets langere zoekopdracht:
SELECT rolname,rolsuper FROM pg_roles WHERE rolname !~ '^pg_';
rolname | rolsuper----------+---------- postgres | t user1 | f(2 rows)
Uw eigen kenmerken vermelden
Als u de kenmerken wilt vinden van de rol die u momenteel gebruikt, kunt u de uitvoer eenvoudig filteren.
Bij gebruik van psql meta-commando's, kunt u de USER variabele, die wordt vervangen door de huidige verbonden rol. psql gebruikt de dubbele punt (: ) om variabelen te interpoleren:
\du :USER
List of roles Role name | Attributes | Member of-----------+------------------------------------------------------------+----------- postgres | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
Om een lijst te krijgen met de waarden van alle mogelijke rolkenmerken, kunt u een query gebruiken die de rolnaam vergelijkt met de waarde die wordt geretourneerd door de CURRENT_ROLE PostgreSQL-functie. Nogmaals, we gebruiken verticale uitvoer voor de leesbaarheid:
-- 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
Om gewoon te controleren of uw huidige rol superuser heeft privileges, typt u:
SHOW is_superuser;
is_superuser-------------- on(1 row)
Controleer of u rechten heeft voor rolbeheer
Om rollen aan te maken, te wijzigen of te verwijderen, moet u ofwel superuser . hebben of CREATEROLE privileges.
Om te controleren welke rollen binnen het systeem rolbeheerrechten hebben, typt u:
SELECT rolname as "Users who can manage roles" FROM pg_roles WHERE rolsuper OR rolcreaterole;
Users who can manage roles---------------------------- postgres(1 rows)
Als u alleen wilt weten of uw huidige rol rolbeheerrechten heeft, kunt u in plaats daarvan het volgende gebruiken:
SELECT 'Yes' AS "Can I manage roles?" FROM pg_roles WHERE rolname = :'USER' AND (rolsuper OR rolcreaterole);
Can I manage roles?--------------------- Yes(1 row)
Rollen maken
Nadat u heeft geverifieerd dat u over rolbeheerrechten beschikt, kunt u beginnen met het maken, wijzigen of verwijderen van rollen binnen PostgreSQL.
Een optie om rolkenmerken in te stellen is om ze te declareren op het moment dat u de rol maakt. Hiermee kunt u de initiële voorwaarden voor de rol instellen, maar u kunt deze achteraf nog wijzigen als u het toegangsniveau van de rol wilt wijzigen. Je kunt meer informatie vinden over de CREATE ROLE commando dat we zullen gebruiken om vertrouwd te raken met de basissyntaxis.
Een manier om een rol aan te maken is vanaf de opdrachtregel. PostgreSQL bevat een createuser commando dat een rol creëert binnen het databasecluster met LOGIN privileges.
De algemene syntaxis is:
createuser <options> <rolename>
Om bijvoorbeeld een rol te maken met de naam admin met superuser privileges terwijl u om een wachtwoord vraagt, kunt u typen:
createuser --superuser admin
U kunt dan inloggen met de admin account volgens de authenticatiemethoden beschreven in de pg_hba.conf bestand.
Rollen maken met SQL , ziet de algemene syntaxis er als volgt uit:
CREATE ROLE <role>;
Attributen kunnen worden gedefinieerd door ze achter de rolnaam te specificeren met WITH :
CREATE ROLE <role> WITH <options>;
Om bijvoorbeeld een rol te maken met de naam user1 die kan inloggen met het wachtwoord secretpassword , je zou kunnen typen:
CREATE ROLE "user1" WITH LOGIN PASSWORD 'secretpassword';
Om in plaats daarvan een rol te maken met superuser privileges (je moet ook een superuser zijn om deze opdracht met succes uit te voeren) die niet login (gebruiker moet SET ROLE gebruiken om naar deze rol te veranderen), typt u:
CREATE ROLE "user2" WITH SUPERUSER;
Bestaande rollen wijzigen
Om de attributen van bestaande rollen te wijzigen, kunt u de ALTER ROLE . gebruiken commando in plaats daarvan. Net als bij het maken van rollen, moet uw huidige rol ook een superuser . hebben of CREATEROLE voorrechten. Gebruikers die deze rechten niet hebben, kunnen alleen de ALTER ROLE . gebruiken commando om hun eigen wachtwoord te wijzigen.
Door rollen te wijzigen, kunt u de kenmerken wijzigen die aan een rol zijn toegewezen nadat deze zijn gemaakt. Dezelfde attributen die worden genoemd in de sectie voor het maken van rollen kunnen worden gebruikt met de ALTER ROLE syntaxis. Een verschil is dat elk attribuuttype kan worden genegeerd door het toevoegen van de NO voorvoegsel. Als u bijvoorbeeld een rol wilt toestaan in te loggen op het databasecluster, kunt u deze de LOGIN . geven attribuut. Als u die mogelijkheid wilt verwijderen, wijzigt u de rol door NOLOGIN op te geven .
De ALTER ROLE commando verandert alleen de attributen die expliciet worden genoemd. Met andere woorden, de ALTER ROLE commando specificeert wijzigingen naar attributen, niet een volledige set nieuwe attributen.
Om de user2 . toe te staan rol om in te loggen op het databasecluster, typt u:
ALTER ROLE "user2" WITH LOGIN;
Houd er rekening mee dat hoewel dit de mogelijkheid biedt om in te loggen, de toegestane authenticatiemethoden nog steeds worden beheerd door de pg_hba.conf bestand.
Als u user2 . wilt om in plaats daarvan in te kunnen loggen, rollen aan te maken en databases te maken, kunt u deze drie kenmerken specificeren, gescheiden door spaties:
ALTER ROLE "user2" WITH LOGIN CREATEROLE CREATEDB;
superuser intrekken status van een rol (u kunt deze opdracht alleen uitvoeren met een andere superuser rol), typ:
ALTER ROLE "user2" WITH NOSUPERUSER;
Om het wachtwoord voor een rol te wijzigen, typt u het volgende (alle rollen moeten dit commando op hun eigen rol kunnen uitvoeren, ongeacht CREATEROLE of superuser privileges):
ALTER ROLE <role> WITH PASSWORD '<password>';
Hoewel de bovenstaande opdracht werkt, is het een beter idee om, indien mogelijk, de psql . te gebruiken meta-opdracht om wachtwoorden te wijzigen. De psql commando vraagt automatisch om een wachtwoord en versleutelt het voordat het naar de server wordt verzonden. Dit helpt voorkomen dat gevoelige gegevens in logboeken worden gelekt.
U kunt het wachtwoord van een rol wijzigen met psql door het volgende te typen
-- To change your own password\password-- To change the password for another role\password <role>
U kunt ook de ALTER ROLE . gebruiken commando om een rol te hernoemen:
ALTER ROLE <role> RENAME TO <newrole>
Houd er rekening mee dat u de naam van uw huidige sessierol niet kunt wijzigen.
Rollen verwijderen
Het verwijderen van een bestaande rol volgt een soortgelijk patroon als de vorige opdrachten. Nogmaals, je moet CREATEROLE . hebben of superuser privileges om deze opdrachten uit te voeren.
Een complicerende factor is dat rollen niet kunnen worden verwijderd als er nog steeds naar wordt verwezen door objecten in de database. Dit betekent dat u het eigendom van objecten waarvan de rol eigenaar is, moet verwijderen of overdragen. Daarna moet u ook alle extra rechten die de rol heeft op databaseobjecten intrekken.
Erwin Brandstetter op de Stack Exchange-site van Database Administrators geeft een gedetailleerde uitleg over het op de juiste manier opnieuw toewijzen en verwijderen van privileges. Hetzelfde proces wordt hieronder gebruikt.
Ten eerste kunt u alle eigendomsobjecten van de rol opnieuw toewijzen met behulp van de REASSIGNED OWNED opdracht. Als u zich bijvoorbeeld voorbereidt op het verwijderen van de user2 rol, kunt u zijn objecten toewijzen aan de postgres rol door te typen:
REASSIGN OWNED BY "user2" TO "postgres";
Nu zijn de objecten eigendom van postgres , kunnen we de DROP OWNED . gebruiken commando om alle andere privileges in te trekken die we voor objecten hebben gekregen. Deze opdracht verwijdert ook alle objecten die we bezitten, maar aangezien we ze zojuist hebben overgebracht naar de postgres rol, de user2 rol heeft geen eigendomsvoorwerpen meer. Hierdoor zal de opdracht alleen de extra privileges van de rol intrekken:
DROP OWNED BY "user2";
Zonder de DROP OWNED bovenstaande snelkoppeling, moet u REVOKE ALL PRIVILEGES . uitvoeren op elk individueel object of objecttype waarvoor de rol privileges heeft.
Nadat u alle bijbehorende privileges heeft ingetrokken, kunt u de rol verwijderen door te typen:
DROP ROLE "user2";
Aanmelden met psql
Zodra u een nieuwe rol hebt geconfigureerd en authenticatiegegevens hebt geconfigureerd met behulp van de pg_hba.conf bestand, kunt u zich met uw nieuwe rol aanmelden bij het databasecluster. De psql opdrachtregelclient biedt een gemakkelijke manier om dit te doen.
Standaard psql gaat ervan uit dat u verbinding wilt maken met een rol die overeenkomt met de gebruikersnaam van uw besturingssysteem. Dus als u op uw computer bent ingelogd als john , psql gaat ervan uit dat u wilt proberen verbinding te maken met de database met behulp van een rol die ook john wordt genoemd .
Om dit gedrag te negeren, kunt u de -U . doorgeven of --username= optie. Als u bijvoorbeeld wilt inloggen met een rol genaamd kerry , kunt u typen:
psql -U kerry
Het succes van de psql commando zal afhangen van het bestaan van de kerry rol, de toegankelijkheid van de server waarmee u verbinding probeert te maken en de authenticatieregels die op de server zijn gedefinieerd.
Overschakelen naar een andere rol tijdens een sessie
Soms wil je misschien tijdelijk de privileges en identiteit overnemen van een andere rol waartoe je toegang hebt. Dit is bijvoorbeeld nodig als u de privileges wilt krijgen van een rol waarvan u lid bent als uw huidige rol niet de INHERIT heeft attribuut.
Om te begrijpen hoe dit werkt, moet je de terminologie kennen die PostgreSQL gebruikt om actieve rollen te categoriseren:
- Sessierol :Een sessierol is de rol waarmee u zich hebt aangemeld tijdens uw eerste verbinding met het PostgreSQL-databasecluster. Het stelt uw initiële privileges in en bepaalt uw toegang tot het systeem. Deze rol moet de
LOGIN. hebben attribuut. - Huidige rol :Daarentegen is de huidige rol de rol die u momenteel vervult. De privileges die aan de huidige rol zijn gekoppeld, of ze nu rechtstreeks zijn ingesteld of van andere rollen zijn overgenomen, bepalen de acties die u mag uitvoeren en de objecten waartoe u toegang hebt.
U kunt uw sessie- en huidige rolwaarden bekijken door te typen:
SELECT SESSION_USER, CURRENT_USER;
current_user | session_user--------------+-------------- postgres | postgres(1 row)
Hoewel de enige manier om uw sessierol te wijzigen is door een nieuwe verbinding te maken met een andere rol, kunt u uw huidige rol wijzigen met de SET ROLE opdracht. De SET ROLE commando wordt gebruikt om tijdelijk als een andere rol te fungeren. De opdracht heeft optioneel ook de volgende modificaties:
SESSION:De standaardinstelling. Dit zorgt ervoor dat deSET ROLEcommando om de hele databasesessie te beïnvloeden.LOCAL:Deze modifier zorgt ervoor dat de opdracht de rol alleen voor de huidige transactie verandert.
Om de huidige rol te wijzigen in de user2 rol (voor de rest van de sessie), typ:
SET ROLE "user2";
Als u uw sessie en huidige rolwaarden controleert, zult u zien dat de huidige rolwaarde is gewijzigd:
SELECT SESSION_USER, CURRENT_USER;
current_user | session_user--------------+-------------- user2 | postgres(1 row)
Al je acties gebruiken nu de user2 rol als hun context.
Om terug te keren naar de sessierol die u eerder gebruikte, typt u:
SET ROLE NONE;
Een alternatief dat hetzelfde resultaat behaalt is:
RESET ROLE;
Conclusie
Het systeem van rollen, rolattributen, toekenningen en authenticatie van PostgreSQL creëert een flexibel systeem waarmee beheerders machtigingen en databasetoegang effectief kunnen beheren. In deze gids wordt beschreven wat rollen precies zijn en hoe ze een breed scala aan gebruiksscenario's omvatten. Er werd ook ingegaan op het maken, wijzigen en verwijderen van rollen en het beheren van de rolattributen die hun globale mogelijkheden bepalen. Het is noodzakelijk om te begrijpen hoe u deze identiteiten kunt beheren om uw databases te beveiligen en bruikbare toegang te bieden aan uw legitieme gebruikers.