gerenciar permissões

info

O provisionamento Lakebase é a oferta original Lakebase que usa compute de provisionamento que você escala manualmente. Para regiões compatíveis, consulte Disponibilidade por região. Para obter a versão mais recente do Lakebase, com compute, redução de recursos a zero, ramificação e restauração instantânea, consulte a documentação sobre escalonamento automáticoLakebase.

Desde 12 de março de 2026, novas instâncias Lakebase são criadas como projetos de escalonamento automático. As instâncias de provisionamento existentes serão atualizadas automaticamente para escalonamento automático a partir de junho de 2026. Para obter detalhes, consulte Atualização para dimensionamento automático Lakebase.

Esta página descreve quando e como conceder permissões de usuários e identidades do Databricks a uma instância de banco de dados.

Para permitir que outros usuários usem o PostgreSQL para acessar a instância do banco de dados, o databricks_superuser deve criar funções Postgres correspondentes para eles. Para obter detalhes sobre como criar funções do Postgres, consulte Funções do Postgres.

Quando e como as permissões são verificadas

Quando o senhor usa a sintaxe do Postgres ou se conecta por meio de uma interface do PostgreSQL, o Lakebase impõe controles de acesso específicos do PostgreSQL usando o seguinte:

Funções do Postgres
Associações a funções
Permissões concedidas pelo Postgres

Em todos os outros cenários, o Lakebase aplica controles de acesso específicos do Databricks:

Databricks identidades (usuários, grupos e entidade de serviço)
Membros do grupo Databricks
listas de controle de acesso ao espaço de trabalho (ACLs)
Unity Catalog privilégios

nota

Não há sincronização automática entre as identidades e associações do Databricks e as funções e associações do Postgres.

Caso de uso//Permissão ou identidade	gerenciar instâncias de banco de dados	Criar ou excluir tabelas sincronizadas	gerenciar tabela sincronizada pipeline	Consultar tabelas Postgres a partir de um SQL warehouse	Consultar recurso on-line em recurso e servindo modelo	Consultar tabelas Postgres no PostgreSQL
Identidades da Databricks	✅	✅	✅	✅	✅	Requer uma função Postgres correspondente
Membros do grupo Databricks	✅	✅	✅	✅	✅	Só é verificado no login ao fazer login como um grupo
ACLs de instância	✅	✅
ACLs de pipeline		É necessário ser proprietário de um pipeline ao reutilizar um pipeline existente ou excluir uma tabela sincronizada (que edita o pipeline)	✅
Permissões de UC		✅		✅	✅
Funções do Postgres						✅
Associações a funções do Postgres						✅
Permissões do Postgres						✅

permissões da instância do banco de dados

Um usuário deve ter permissões específicas na instância do banco de dados para gerenciá-la e executar operações nas tabelas a partir da interface do usuário, API ou SDK do Databricks . Os administradores do espaço de trabalho e o criador da instância podem atribuir permissões adicionais a quaisquer usuários, grupos ou entidades de serviço desejados na página de visão geral das instâncias do banco de dados .

Clique Acesse os aplicativos no canto superior direito e selecione Lakebase Postgres .
Clique em provisionamento para abrir a página de instâncias de provisionamento .
Selecione sua instância de banco de dados.
Selecione a página Permissões na barra lateral do aplicativo Lakebase.
Clique em "Conceder permissão" no canto superior direito.
No menu suspenso Principal , selecione um usuário, grupo ou entidade de serviço à qual deseja conceder permissões.
No menu suspenso "Permissões" , selecione o nível de permissão que deseja conceder. Consulte ACLs da instância do banco de dados.
Clique em Conceder .

Permissões do Postgres

Para ler ou gravar em uma tabela no Postgres, os usuários precisam das seguintes permissões no Postgres:

CONNECT no banco de dados
USAGE no esquema (ou CREATE para criar novas tabelas)
SELECT, INSERT, UPDATE ou DELETE na mesa

Para obter a lista completa de privilégios do Postgres, consulte a documentação do PostgreSQL.

Verificar permissões de usuário em uma tabela específica no Postgres

execute a seguinte instrução SQL para criar uma função chamada pg_temp.check_permissions que verifica as permissões de um usuário, incluindo permissões herdadas.

SQL
CREATE OR REPLACE FUNCTION pg_temp.check_permissions(p_user TEXT, p_table_name TEXT)
RETURNS TABLE(database_connect BOOLEAN, schema_usage BOOLEAN, table_select BOOLEAN,
              table_insert BOOLEAN, table_update BOOLEAN, table_delete BOOLEAN) AS $$
WITH p AS (SELECT string_to_array(p_table_name, '.') AS a),
c AS (
    SELECT
        COALESCE(a[1], current_schema()) AS sc,
        COALESCE(a[2], a[1]) AS tb
    FROM p
)
SELECT
    has_database_privilege(p_user, current_database(), 'CONNECT'),
    has_schema_privilege(p_user, sc, 'USAGE'),
    has_table_privilege(p_user, sc || '.' || tb, 'SELECT'),
    has_table_privilege(p_user, sc || '.' || tb, 'INSERT'),
    has_table_privilege(p_user, sc || '.' || tb, 'UPDATE'),
    has_table_privilege(p_user, sc || '.' || tb, 'DELETE')
FROM c
$$ LANGUAGE sql;

Para usar a função, utilize a seguinte consulta:

SQL
SELECT * FROM pg_temp.check_permissions('<your_user>', '<your_table>');

-- Example:
SELECT * FROM pg_temp.check_permissions('joe@acme.org', 'public.table1');

Visualizar todas as permissões para banco de dados, esquema e tabela no Postgres.

A seguinte instrução SQL cria uma função chamada pg_temp.make_owner_acl que retorna uma view detalhada de todas as permissões concedidas, excluindo as permissões herdadas, para todos os usuários:

SQL
CREATE OR REPLACE FUNCTION pg_temp.make_owner_acl(owner_oid OID)
RETURNS TABLE(grantor OID, grantee OID, privilege_type TEXT, is_grantable BOOLEAN) AS $$
SELECT owner_oid, owner_oid,'OWNER'::TEXT, True
$$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_temp.get_all_permissions(TEXT, TEXT, TEXT)
RETURNS TABLE(type TEXT, name TEXT, role TEXT, acl TEXT, can_grant TEXT) AS $$
SELECT type, name,
  CASE WHEN grantee = 0 THEN 'PUBLIC' ELSE pg_get_userbyid(grantee) END AS role, privilege_type,
  CASE WHEN privilege_type = 'OWNER' THEN 'YES, ALL' WHEN is_grantable THEN 'YES' ELSE 'NO' END AS can_grant
FROM (
  SELECT 'DATABASE' type, datname as name, (pg_temp.make_owner_acl(datdba)).*
    FROM pg_database
    WHERE datname = $1
  UNION ALL
  SELECT 'DATABASE' type, datname as name, (aclexplode(datacl)).*
    FROM pg_database
    WHERE datname = $1
  UNION ALL
  SELECT 'SCHEMA' type, nspname as name, (pg_temp.make_owner_acl(nspowner)).*
    FROM pg_namespace
    WHERE nspname = $2
  UNION ALL
  SELECT 'SCHEMA' type, nspname as name, (aclexplode(nspacl)).*
    FROM pg_namespace
    WHERE nspname = $2
  UNION ALL
  SELECT 'TABLE' type, relname as name, (pg_temp.make_owner_acl(relowner)).*
    FROM pg_class
    WHERE relname = $3
  UNION ALL
  SELECT 'TABLE' type, relname as name, (aclexplode(relacl)).*
    FROM pg_class
    WHERE relname = $3
  )
$$ LANGUAGE SQL
;

Para usar a função, utilize a seguinte consulta:

SQL
SELECT * FROM pg_temp.get_all_permissions('<your_database>', '<your_schema>', '<your_table>');

-- Example:
SELECT * FROM pg_temp.get_all_permissions('databricks_postgres', 'public', 'table1');

Verificar a hierarquia de herança de funções no Postgres

No Postgres, uma função pode ser membro de outra função, e essa associação especifica se as permissões são herdadas da função pai. Para ver todas as funções das quais uma determinada função faz parte, use a seguinte instrução SQL para criar a função SQL pg_temp.get_inherited_roles:

SQL
CREATE OR REPLACE FUNCTION pg_temp.get_inherited_roles(
  role_name TEXT
)
RETURNS TABLE(inherited_roles TEXT, member_via TEXT, inherits_permissions TEXT) AS $$
  WITH RECURSIVE role_tree AS (
    SELECT
        m.roleid,
        pg_get_userbyid(m.roleid) rolname,
         'DIRECT' COLLATE "C" as member_via,
        m.inherit_option as inherits_permissions
    FROM pg_auth_members m
    WHERE m.member = (SELECT oid FROM pg_roles WHERE rolname = $1)
    UNION ALL
    SELECT
        m.roleid,
        pg_get_userbyid(m.roleid) rolname,
        rt.rolname::text as member_via,
        (rt.inherits_permissions AND m.inherit_option) as inherits_permissions
    FROM pg_auth_members m
    JOIN role_tree rt ON m.member = rt.roleid
  )
  SELECT
      rolname AS inherited_roles,
      member_via,
      CASE WHEN inherits_permissions THEN 'YES' ELSE 'NO' END as inherits_permissions
  FROM role_tree
  GROUP BY inherited_roles, member_via, inherits_permissions
  ORDER BY inherits_permissions DESC
$$ LANGUAGE sql
;

Para usar a função, substitua <your_user> por um nome de usuário do Databricks:

SQL
SELECT * FROM pg_temp.get_inherited_roles('<your role>');

Encontre administradores de função no Postgres

Para visualizar o administrador de uma função, use a seguinte consulta SQL e substitua o nome da função por <target_role>:

SQL
SELECT pg_get_userbyid(m.member) admin
FROM pg_auth_members m
WHERE m.roleid = (SELECT oid FROM pg_roles WHERE rolname = '<target_role>')
  AND m.admin_option = true;

Quando e como as permissões são verificadas​

permissões da instância do banco de dados​

Permissões do Postgres​

Verificar permissões de usuário em uma tabela específica no Postgres​

Visualizar todas as permissões para banco de dados, esquema e tabela no Postgres.​

Verificar a hierarquia de herança de funções no Postgres​

Encontre administradores de função no Postgres​