Gérer les autorisations

info

Lakebase Provisioned est l'offre originale de Lakebase qui utilise un compute provisionné que vous mettez à l'échelle manuellement. Pour les régions prises en charge, consultez la disponibilité des régions. Pour la dernière version de Lakebase, avec compute à dimensionnement automatique, mise à l'échelle jusqu'à zéro, création de branches et restauration instantanée, consultez Lakebase Autoscaling.

Depuis le 12 mars 2026, les nouvelles instances Lakebase sont créées en tant que projets de dimensionnement automatique. Les instances provisionnées existantes sont mises à niveau automatiquement vers la mise à l'échelle automatique, à compter de juin 2026. Pour plus de détails, consultez Mise à niveau vers le dimensionnement automatique Lakebase.

Cette page décrit quand et comment accorder des autorisations aux utilisateurs et identités Databricks pour une instance de base de données.

Pour permettre à d'autres utilisateurs d'utiliser PostgreSQL pour accéder à l'instance de base de données, le databricks_superuser doit créer des rôles Postgres correspondants pour eux. Pour plus de détails sur la création de rôles Postgres, consultez Rôles Postgres.

Quand et comment les autorisations sont vérifiées

Lorsque vous utilisez la syntaxe Postgres ou que vous vous connectez via une interface PostgreSQL, Lakebase applique des contrôles d'accès spécifiques à PostgreSQL en utilisant les éléments suivants :

rôles Postgres
Appartenances aux rôles.
Autorisations accordées par Postgres

Dans tous les autres scénarios, Lakebase applique des contrôles d'accès Databricks spécifiques.

Identités Databricks (utilisateurs, groupes et principaux de service)
Appartenances aux groupes Databricks
Listes de contrôle d'accès (ACL) du Workspace.
Privilèges Unity Catalog

remarque

Il n'y a pas de synchronisation automatique entre les identités et les adhésions Databricks, et les rôles et adhésions Postgres.

Cas d'utilisation / Autorisation ou identité	Gérer les instances de base de données	Créer ou supprimer des tables synchronisées	Gérer le pipeline de tables synchronisées	Query des tables Postgres à partir d'un SQL Warehouse	query les fonctionnalités en ligne dans le service de fonctionnalités et de modèles	Query les tables Postgres dans PostgreSQL
Identités Databricks	✅	✅	✅	✅	✅	Nécessite un rôle Postgres correspondant
Appartenances aux groupes Databricks	✅	✅	✅	✅	✅	Vérifié uniquement à la connexion lors de la connexion en tant que groupe
ACL d'instance	✅	✅
Listes de contrôle d'accès de pipeline		Il est nécessaire d'être propriétaire du pipeline lors de la réutilisation d'un pipeline existant ou de la suppression d'une table synchronisée (ce qui modifie le pipeline).	✅
Autorisations UC		✅		✅	✅
rôles Postgres						✅
Adhésions de rôle Postgres						✅
Autorisations Postgres						✅

Cas d'utilisation / Autorisation ou identité	Gérer les instances de base de données	Créer ou supprimer des tables synchronisées	Gérer le pipeline de tables synchronisées	Query des tables Postgres à partir d'un SQL Warehouse	query les fonctionnalités en ligne dans le service de fonctionnalités et de modèles	Query les tables Postgres dans PostgreSQL
Identités Databricks	✅	✅	✅	✅	✅	Nécessite un rôle Postgres correspondant
Appartenances aux groupes Databricks	✅	✅	✅	✅	✅	Vérifié uniquement à la connexion lors de la connexion en tant que groupe
ACL d'instance	✅	✅
Listes de contrôle d'accès de pipeline		Il est nécessaire d'être propriétaire du pipeline lors de la réutilisation d'un pipeline existant ou de la suppression d'une table synchronisée (ce qui modifie le pipeline).	✅
Autorisations UC		✅		✅	✅
rôles Postgres						✅
Adhésions de rôle Postgres						✅
Autorisations Postgres						✅

Autorisations d'instance de base de données

Un utilisateur doit disposer de permissions spécifiques sur l'instance de base de données pour gérer l'instance et effectuer des Opérations de table à partir de l'interface utilisateur, de l'API ou du SDK Databricks. Les administrateurs du Workspace et le créateur de l'instance peuvent attribuer des permissions supplémentaires à tous les utilisateurs, groupes ou Service Principals souhaités dans la page d'aperçu Instances de base de données .

Cliquez sur Applications dans le coin supérieur droit et sélectionnez Lakebase Postgres .
Cliquez sur **Provisionné** pour ouvrir la page **Instances provisionnées**.
Sélectionnez votre instance de base de données.
Sélectionnez la page **Permissions** dans la barre latérale de l'application Lakebase.
Cliquez sur Accorder l'autorisation en haut à droite.
Dans le menu déroulant Principal , sélectionnez un utilisateur, un groupe ou un Service Principal auquel accorder des autorisations.
Dans le menu déroulant Autorisation , sélectionnez le niveau d’autorisation que vous souhaitez accorder. Consultez Listes de contrôle d’accès aux instances de base de données.
Cliquez sur Accorder .

Autorisations Postgres

Pour lire à partir d'une table ou écrire dans une table dans Postgres, les utilisateurs nécessitent les autorisations suivantes dans Postgres :

CONNECT sur la base de données
USAGE sur le schéma (ou CREATE pour créer de nouvelles tables)
SELECT, INSERT, UPDATE, ou DELETE sur la table

Pour la liste complète des privilèges Postgres, consultez la documentation PostgreSQL.

Vérifiez les autorisations de l'utilisateur sur une table spécifique dans Postgres

Exécutez l’instruction SQL suivante pour créer une fonction nommée pg_temp.check_permissions qui vérifie les autorisations d’un utilisateur, y compris les autorisations héritées.

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;

Pour utiliser la fonction, utilisez la query suivante :

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

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

Afficher toutes les autorisations pour les bases de données, les schémas et les tables dans Postgres

L'instruction SQL suivante crée une fonction nommée pg_temp.make_owner_acl qui renvoie une vue détaillée de toutes les autorisations accordées, à l'exclusion des autorisations héritées, pour tous les utilisateurs :

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
;

Pour utiliser la fonction, utilisez la query suivante :

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');

Vérifier la hiérarchie d'héritage des rôles dans Postgres

Dans Postgres, un rôle peut être membre d'un autre rôle, et l'appartenance spécifie si les autorisations sont héritées du rôle parent. Pour voir tous les rôles dont un certain rôle fait partie, utilisez l'instruction SQL suivante pour créer la fonction 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
;

Pour utiliser la fonction, substituez un nom d'utilisateur Databricks à <your_user>:

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

Rechercher les administrateurs de rôle dans Postgres

Pour voir l'administrateur d'un rôle, utilisez la query SQL suivante et remplacez le nom du rôle par <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;

Quand et comment les autorisations sont vérifiées​

Autorisations d'instance de base de données​

Autorisations Postgres​

Vérifiez les autorisations de l'utilisateur sur une table spécifique dans Postgres​

Afficher toutes les autorisations pour les bases de données, les schémas et les tables dans Postgres​

Vérifier la hiérarchie d'héritage des rôles dans Postgres​

Rechercher les administrateurs de rôle dans Postgres​