Introdução
O PostgreSQL usa vários mecanismos para implementar autenticação, autorização e propriedade de objetos em clusters de banco de dados. O núcleo entre estes é o conceito de papéis.
As funções do PostgreSQL são uma combinação das ideias de usuários e grupos em uma única entidade flexível. Eles são a persona que os usuários adotam dentro do sistema de banco de dados, são a entidade pela qual o sistema de autenticação aceita ou nega conexões e o assunto das regras de gerenciamento de privilégios de todos os escopos.
Este guia abordará quais são as funções e como gerenciá-las em um cluster de banco de dados PostgreSQL. Mais especificamente, este guia abordará o gerenciamento de função no que se refere aos atributos de função. Para uma visão mais ampla de como as funções se encaixam no quadro geral, dê uma olhada no guia de introdução à autenticação e autorização. Para saber como alterar privilégios de função em objetos de banco de dados específicos, confira nosso guia sobre concessões de função.
O que são funções?
No PostgreSQL, uma função é um agrupamento de um conjunto específico de recursos, permissões e entidades "próprias". Em vez de ter conceitos distintos de "usuários" e "grupos", o PostgreSQL usa papéis para representar essas duas ideias. Uma função pode corresponder a uma pessoa individual no mundo real ou pode operar como um grupo com determinado acesso do qual outras funções podem se tornar membros.
As funções são o ponto de ancoragem no PostgreSQL que determina a quem as políticas de autenticação e autorização se aplicam. Qualquer política que não se aplique universalmente requer uma noção de identidade para definir quem restringir e quem permitir. No PostgreSQL, essa identidade é representada por papéis.
O sistema de autenticação do PostgreSQL tem vários componentes diferentes, cada um deles vinculado a funções. Para serem usados para a conexão inicial com o cluster de banco de dados, as funções devem primeiro ter o
LOGIN
conjunto de atributos. As próprias regras de autenticação são definidas no arquivo de configuração baseado em host chamado pg_hba.conf
. Cada regra define métodos de autenticação que podem ser definidos para a função individual. Para funções configuradas para autenticação de senha, deve-se ter um atributo de senha definido para que o sistema possa validar a senha de usuário fornecida. Em termos de autorização, os papéis são definidos no nível do cluster de banco de dados, o que no PostgreSQL significa que eles são compartilhados entre bancos de dados. Como as funções abrangem bancos de dados, o sistema de autorização controla o nível de acesso que cada função tem a cada entidade de banco de dados. Como as funções podem representar grupos de pessoas, há muita flexibilidade em como o acesso pode ser configurado.
Os papéis também são essenciais para o conceito de propriedade do objeto no PostgreSQL. Cada banco de dados e tabela, por exemplo, tem exatamente uma função configurada como proprietária. Além de
superusers
, a função de proprietário é a única função que pode modificar ou excluir o objeto real. Em resumo, as funções estão no centro da maioria das operações práticas de banco de dados. Sua flexibilidade permite que eles atuem como identificadores de usuário e classes de usuário. Cada ação no cluster de banco de dados é verificada em relação aos privilégios da função e o sucesso de cada conexão com o cluster de banco de dados é determinado pela função na qual se autentica. É importante ter um bom controle sobre o gerenciamento de funções devido à sua importância em tantas operações principais.
Atributos de função
Os atributos de função são sinalizadores na própria função que determinam alguns dos principais privilégios que ela possui no nível do cluster de banco de dados. Elas podem ser definidas quando a função é criada inicialmente ou alteradas a qualquer momento por qualquer função com os atributos apropriados (
SUPERUSER
ou CREATEROLE
nesse caso). Os atributos que podem ser aplicados a uma função incluem:
LOGIN
:permite que os usuários se conectem inicialmente ao cluster de banco de dados usando essa função. OCREATE USER
comando adiciona automaticamente este atributo, enquantoCREATE ROLE
comando não.SUPERUSER
:permite que a função ignore todas as verificações de permissão, exceto o direito de fazer login. Somente outrosSUPERUSER
funções podem criar funções com este atributo.CREATEDB
:permite que a função crie novos bancos de dados.CREATEROLE
:permite que a função crie, altere e exclua outras funções. Esse atributo também permite que a função atribua ou altere a associação da função. Uma exceção é que um papel com oCREATEROLE
atributo não pode alterarSUPERUSER
funções sem também ter oSUPERUSER
atributo.REPLICATION
:permite que a função inicie a replicação de streaming. As funções com este atributo também devem ter oLOGIN
atributo.PASSWORD
:Atribui uma senha à função que será usada compassword
oumd5
mecanismos de autenticação. Este atributo recebe uma senha entre aspas como argumento diretamente após a palavra-chave do atributo.INHERIT
:determina se a função herda os privilégios das funções das quais é membro. Sem oINHERIT
, os membros devem usarSET ROLE
para mudar para a outra função para acessar esses privilégios exclusivos. Este atributo é definido para novas funções por padrão.
Você pode descobrir mais sobre atributos de função consultando a documentação do PostgreSQL sobre atributos de função e o
CREATE ROLE
comando. O que é um superuser
função?
Como mencionado brevemente acima, um privilégio especial chamado
superuser
permite acesso administrativo irrestrito ao cluster de banco de dados. Isso é semelhante ao root
conta em sistemas operacionais Linux e do tipo Unix, mas no nível do banco de dados. Sempre deve haver pelo menos uma função com
superuser
privilégios em cada cluster de banco de dados. O superuser
inicial conta é criada durante o processo de instalação. O nome do superuser
inicial conta pode variar dependendo do processo de instalação, mas na maioria das vezes, essa conta é chamada de postgres
. Não é recomendado fazer seu trabalho diário usando uma conta com
superuser
privilégios, tanto por seu potencial para ações destrutivas quanto para minimizar a chance de comprometer uma conta com amplo acesso. Em vez disso, na maioria das vezes, os usuários devem usar contas dedicadas a funções específicas ou objetos de dados com os quais estão trabalhando, usando apenas o superuser
contas quando um acesso mais poderoso é necessário. Verificando atributos de função existentes
Agora que você tem uma ideia ampla do que são atributos de função e quais tipos de privilégios eles permitem, você deve aprender como encontrar os atributos aplicados a funções em todo o PostgreSQL. Esta seção mostrará alguns comandos para ajudá-lo a encontrar os atributos definidos nas funções em geral e em sua própria função atual especificamente.
Listando todas as funções de banco de dados e seus atributos
Existem algumas maneiras diferentes de verificar os atributos aplicados às funções em todo o sistema.
Se você estiver usando o
psql
cliente de linha de comando, você pode tirar proveito de alguns meta-comandos úteis que permitem obter informações de atributo de função sem uma consulta. O
\du
meta-comando mostra todos os papéis e seus atributos:\du
List of roles Role name | Attributes | Member of-----------+------------------------------------------------------------+----------- postgres | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
Neste caso, o
postgres
role é o papel padrão com superuser
privilégios configurados para este cluster de banco de dados. O SQL equivalente para listar funções (detectável passando o
-E
ou --echo-hidden
sinalizar ao iniciar o 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;
Uma consulta semelhante que fornece informações de atributo de função (sem o componente de associação de função) está abaixo. Usamos o
psql
meta-comando \x on
para produzir os resultados verticalmente para melhor legibilidade aqui:-- 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 você estiver interessado apenas em ver quais funções têm o
superuser
atributo, você pode pedir uma lista explicitamente:SELECT rolname FROM pg_roles WHERE rolsuper;
rolname---------- postgres(1 row)
Como alternativa, você pode listar todos os usuários e seus
superusers
status para uma imagem mais completa:SELECT usename,usesuper FROM pg_user;
usename | usesuper----------+---------- postgres | t user1 | f(2 rows)
A mesma informação pode ser recuperada usando o paradigma de "função" do PostgreSQL em vez de sua (às vezes ambígua) sobreposição de "usuário" com esta consulta um pouco mais longa:
SELECT rolname,rolsuper FROM pg_roles WHERE rolname !~ '^pg_';
rolname | rolsuper----------+---------- postgres | t user1 | f(2 rows)
Listando seus próprios atributos
Se você deseja encontrar os atributos da função que está usando no momento, pode filtrar facilmente a saída.
Ao usar o
psql
meta-comandos, você pode usar o USER
variável, que será substituída pela função conectada atual. psql
usa os dois pontos (:
) para interpolar variáveis:\du :USER
List of roles Role name | Attributes | Member of-----------+------------------------------------------------------------+----------- postgres | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
Para obter uma listagem mostrando os valores de todos os atributos de função possíveis, você pode usar uma consulta comparando o nome da função com o valor retornado pelo
CURRENT_ROLE
Função PostgreSQL. Novamente, estamos usando a saída vertical para facilitar a leitura:-- 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
Para apenas verificar se sua função atual tem
superuser
privilégios, você pode digitar:SHOW is_superuser;
is_superuser-------------- on(1 row)
Verifique se você tem privilégios de gerenciamento de função
Para criar, alterar ou excluir funções, você deve ter
superuser
ou CREATEROLE
privilégios. Para verificar quais funções no sistema têm privilégios de gerenciamento de funções, digite:
SELECT rolname as "Users who can manage roles" FROM pg_roles WHERE rolsuper OR rolcreaterole;
Users who can manage roles---------------------------- postgres(1 rows)
Se você quiser apenas saber se sua função atual tem privilégios de gerenciamento de função, você pode usar:
SELECT 'Yes' AS "Can I manage roles?" FROM pg_roles WHERE rolname = :'USER' AND (rolsuper OR rolcreaterole);
Can I manage roles?--------------------- Yes(1 row)
Criando funções
Depois de verificar que você tem privilégios de gerenciamento de funções, você pode começar a criar, modificar ou remover funções no PostgreSQL.
Uma opção para definir atributos de função é declará-los no momento em que você cria a função. Isso permite definir as condições iniciais para a função, mas você ainda pode modificá-las posteriormente se desejar alterar o nível de acesso da função. Você pode encontrar mais informações sobre o
CREATE ROLE
comando que usaremos para se familiarizar com a sintaxe básica. Uma maneira de criar uma função é a partir da linha de comando. PostgreSQL inclui um
createuser
comando que criará uma função dentro do cluster de banco de dados com LOGIN
privilégios. A sintaxe geral é:
createuser <options> <rolename>
Por exemplo, para criar uma função chamada
admin
com superuser
privilégios ao solicitar uma senha, você pode digitar:createuser --superuser admin
Você poderá então fazer login usando o
admin
conta de acordo com os métodos de autenticação descritos no pg_hba.conf
Arquivo. Para criar funções usando
SQL
, a sintaxe geral fica assim:CREATE ROLE <role>;
Os atributos podem ser definidos especificando-os após o nome da função usando
WITH
:CREATE ROLE <role> WITH <options>;
Por exemplo, para criar uma função chamada
user1
que pode fazer login com a senha secretpassword
, você pode digitar:CREATE ROLE "user1" WITH LOGIN PASSWORD 'secretpassword';
Para criar uma função com
superuser
privilégios (você também deve ser um superuser
para executar com sucesso este comando) que não pode login (o usuário deve usar SET ROLE
para mudar para esta função), você pode digitar:CREATE ROLE "user2" WITH SUPERUSER;
Alterar funções existentes
Para modificar os atributos de papéis existentes, você pode usar o
ALTER ROLE
comando em vez disso. Assim como na criação de função, sua função atual também deve ter superuser
ou CREATEROLE
privilégios. Os usuários que não possuem esses privilégios só podem usar o ALTER ROLE
comando para alterar sua própria senha. Alterar funções permite alterar os atributos atribuídos a uma função após a criação. Os mesmos atributos mencionados na seção de criação de função podem ser usados com o
ALTER ROLE
sintaxe. Uma diferença é que cada tipo de atributo pode ser negado adicionando o NO
prefixo. Por exemplo, para permitir que uma função faça login no cluster de banco de dados, você pode atribuir a ela o LOGIN
atributo. Para remover essa habilidade, você alteraria a função especificando NOLOGIN
. O
ALTER ROLE
O comando altera apenas os atributos são os mencionados explicitamente. Em outras palavras, o ALTER ROLE
comando especifica alterações aos atributos, não a um conjunto completo de novos atributos. Para permitir que o
user2
role para fazer login no cluster de banco de dados, você pode digitar:ALTER ROLE "user2" WITH LOGIN;
Lembre-se de que, embora isso ative a capacidade de login, os métodos de autenticação permitidos ainda são controlados pelo
pg_hba.conf
Arquivo. Se você quiser
user2
para poder fazer login, criar funções e criar bancos de dados, você pode especificar esses três atributos, separados por espaços:ALTER ROLE "user2" WITH LOGIN CREATEROLE CREATEDB;
Para revogar
superuser
status de uma função (você só pode executar este comando usando outro superuser
função), digite:ALTER ROLE "user2" WITH NOSUPERUSER;
Para alterar a senha de uma função, você pode digitar o seguinte (todas as funções devem ser capazes de executar este comando em sua própria função, independentemente de
CREATEROLE
ou superuser
privilégios):ALTER ROLE <role> WITH PASSWORD '<password>';
Embora o comando acima funcione, se possível, é melhor usar o
psql
meta-comando para alterar senhas. O psql
O comando solicita automaticamente uma senha e a criptografa antes de enviá-la ao servidor. Isso ajuda a evitar o vazamento de dados confidenciais nos logs. Você pode alterar a senha de uma função com
psql
digitando o seguinte -- To change your own password\password-- To change the password for another role\password <role>
Você também pode usar o
ALTER ROLE
comando para renomear uma função:ALTER ROLE <role> RENAME TO <newrole>
Lembre-se de que você não pode renomear sua função de sessão atual.
Excluindo funções
A exclusão de uma função existente segue um padrão semelhante aos comandos anteriores. Novamente, você deve ter
CREATEROLE
ou superuser
privilégios para executar esses comandos. Um fator complicador é que as funções não podem ser removidos se ainda forem referenciados por objetos dentro do banco de dados. Isso significa que você deve excluir ou transferir a propriedade de quaisquer objetos pertencentes à função. Depois, você também deve revogar quaisquer privilégios adicionais que a função tenha em objetos de banco de dados.
Uma explicação detalhada de como reatribuir e descartar privilégios adequadamente é fornecida por Erwin Brandstetter no site Database Administrators Stack Exchange. Este mesmo processo é usado abaixo.
Primeiro, você pode reatribuir todos os objetos de propriedade da função usando o
REASSIGNED OWNED
comando. Por exemplo, se você estiver se preparando para excluir o user2
função, você pode atribuir seus objetos ao postgres
função digitando:REASSIGN OWNED BY "user2" TO "postgres";
Agora os objetos são de propriedade do
postgres
, podemos usar o DROP OWNED
comando para revogar todos os outros privilégios que recebemos em objetos. Este comando também exclui quaisquer objetos que possuímos, mas como acabamos de transferi-los para o postgres
função, o user2
função não tem mais nenhum objeto de propriedade. Por causa disso, o comando só revogará qualquer um dos privilégios adicionais da função:DROP OWNED BY "user2";
Sem o
DROP OWNED
atalho acima, você teria que executar REVOKE ALL PRIVILEGES
em cada objeto individual ou tipo de objeto em que a função tem privilégios. Depois de revogar todos os privilégios associados, você pode remover a função digitando:
DROP ROLE "user2";
Efetuando login usando psql
Depois de configurar uma nova função e configurar os detalhes de autenticação usando o
pg_hba.conf
arquivo, você pode fazer login no cluster de banco de dados usando sua nova função. O psql
cliente de linha de comando fornece uma maneira fácil de fazer isso. Por padrão,
psql
pressupõe que você deseja se conectar usando uma função que corresponda ao nome de usuário do seu sistema operacional. Portanto, se você estiver conectado ao seu computador como john
, psql
assumirá que você deseja tentar se conectar ao banco de dados usando uma função que também é chamada de john
. Para substituir esse comportamento, você pode passar o
-U
ou --username=
opção. Por exemplo, se você quiser fazer login em uma função chamada kerry
, Você pode digitar:psql -U kerry
O sucesso do
psql
comando dependerá da existência do kerry
função, a acessibilidade do servidor ao qual você está tentando se conectar e as regras de autenticação definidas no servidor. Mudando para uma função diferente durante uma sessão
Às vezes, você pode querer adotar temporariamente os privilégios e a identidade de outra função à qual você tem acesso. Por exemplo, isso é necessário se você deseja obter os privilégios de uma função da qual é membro, caso sua função atual não tenha o
INHERIT
atributo. Para entender como isso funciona, você precisa conhecer a terminologia que o PostgreSQL usa para categorizar os papéis ativos:
- Função da sessão :uma função de sessão é a função com a qual você efetuou login durante sua conexão inicial com o cluster de banco de dados PostgreSQL. Ele define seus privilégios iniciais e determina seu acesso ao sistema. Esta função deve ter o
LOGIN
atributo. - Função atual :Por outro lado, a função atual é a função na qual você está atuando no momento. Os privilégios associados à função atual, definidos diretamente ou herdados de outras funções, determinam as ações que você tem permissão para realizar e os objetos aos quais tem acesso.
Você pode visualizar sua sessão e valores de função atuais digitando:
SELECT SESSION_USER, CURRENT_USER;
current_user | session_user--------------+-------------- postgres | postgres(1 row)
Embora a única maneira de alterar sua função de sessão seja iniciar uma nova conexão usando uma função diferente, você pode alterar sua função atual usando o
SET ROLE
comando. O SET ROLE
O comando é usado para atuar temporariamente como uma função diferente. O comando também aceita opcionalmente os seguintes modificadores:SESSION
:A configuração padrão. Isso faz com que oSET ROLE
comando para afetar toda a sessão do banco de dados.LOCAL
:este modificador fará com que o comando altere a função apenas para a transação atual.
Para alterar a função atual para
user2
role (para o resto da sessão), digite:SET ROLE "user2";
Se você verificar seus valores de sessão e função atuais, verá que o valor da função atual foi alterado:
SELECT SESSION_USER, CURRENT_USER;
current_user | session_user--------------+-------------- user2 | postgres(1 row)
Todas as suas ações agora usarão o
user2
papel como seu contexto. Para voltar à função de sessão que você estava usando anteriormente, você pode digitar:
SET ROLE NONE;
Uma alternativa que alcança o mesmo resultado é:
RESET ROLE;
Conclusão
O sistema de funções, atributos de função, concessões e autenticação do PostgreSQL cria um sistema flexível que permite aos administradores gerenciar permissões e acesso ao banco de dados com eficiência. Este guia descreveu exatamente quais são as funções e como elas abrangem uma ampla variedade de casos de uso. Ele também abordou como criar, modificar e excluir funções e gerenciar os atributos de função que determinam seus recursos globais. É necessário entender como gerenciar essas identidades para proteger seus bancos de dados e fornecer acesso utilizável a seus usuários legítimos.