Gestion des utilisateurs, des rôles et des attributions Snowflake avec Python

Vous pouvez utiliser Python pour gérer les utilisateurs, les rôles et les autorisations de Snowflake. Pour plus d’informations sur la gestion des utilisateurs et de leurs privilèges dans Snowflake, consultez Gestion des utilisateurs.

Conditions préalables

Les exemples de cette rubrique supposent que vous ayez ajouté le code nécessaire pour vous connecter à Snowflake et créer un objet Root à partir duquel utiliser les Snowflake Python APIs.

Par exemple, le code suivant utilise les paramètres de connexion définis dans un fichier de configuration pour créer une connexion à Snowflake.

from snowflake.core import Root
from snowflake.snowpark import Session

session = Session.builder.config("connection_name", "myconnection").create()
root = Root(session)
Copy

En utilisant l’objet Session obtenu, le code crée un objet Root pour utiliser les types et les méthodes de l’API. Pour plus d’informations, voir Connexion à Snowflake avec Snowflake Python APIs.

Gestion des utilisateurs

Vous pouvez gérer les utilisateurs dans Snowflake. Un utilisateur est un objet au niveau du compte dans Snowflake. Les Snowflake Python APIs représentent des utilisateurs avec deux types distincts :

  • User : expose les propriétés d’un utilisateur, telles que son nom.

  • UserResource : expose des méthodes que vous pouvez utiliser pour extraire un objet User correspondant et pour supprimer l’utilisateur.

Création d’un utilisateur

Vous pouvez créer un utilisateur en appelant la méthode UserCollection.create et en lui transmettant un objet User représentant l’utilisateur que vous souhaitez créer. Pour créer un utilisateur, commencez par créer un objet User qui spécifie le nom de l’utilisateur.

Le code de l’exemple suivant crée un objet User représentant un utilisateur nommé my_user puis crée l’utilisateur en transmettant l’objet User à la méthode UserCollection.create :

from snowflake.core.user import User

my_user = User(name="my_user")
root.users.create(my_user)
Copy

Obtention d’informations sur les utilisateurs

Vous pouvez obtenir des informations sur un utilisateur en appelant la méthode UserResource.fetch, qui renvoie un objet User.

Le code de l’exemple suivant permet d’obtenir des informations sur un utilisateur nommé my_user :

my_user = root.users["my_user"].fetch()
print(my_user.to_dict())
Copy

Affichage des utilisateurs

Vous pouvez répertorier les utilisateurs en utilisant la méthode iter, qui renvoie un itérateur PagedIter.

Le code de l’exemple suivant répertorie les utilisateurs dont le nom commence par my :

users = root.users.iter(like="my%")
for user in users:
  print(user.name)
Copy

Suppression d’un utilisateur

Vous pouvez supprimer un utilisateur en utilisant la méthode UserResource.drop.

Le code dans l’exemple suivant supprime l’utilisateur my_user :

my_user_res = root.users["my_user"]
my_user_res.drop()
Copy

Gestion des rôles

Vous pouvez gérer les rôles dans Snowflake. Un rôle est un objet au niveau du compte. Les Snowflake Python APIs représentent des rôles avec deux types distincts :

  • Role : expose les propriétés d’un rôle telles que son nom.

  • RoleResource : expose des méthodes que vous pouvez utiliser pour extraire un objet Role correspondant et pour supprimer le rôle.

Création d’un rôle

Pour créer un rôle, commencez par créer un objet Role qui spécifie le nom du rôle.

Le code de l’exemple suivant crée un objet Role représentant un rôle nommé my_role :

from snowflake.core.role import Role

my_role = Role(name="my_role")
root.roles.create(my_role)
Copy

Le code crée ensuite le rôle en transmettant l’objet Role à la méthode RoleCollection.create.

Utilisation d’un rôle dans une session

Le code de l’exemple suivant applique le rôle my_role dans la session en cours.

root.session.use_role("my_role")
Copy

Affichage des rôles

Vous pouvez répertorier les rôles dans un compte en utilisant la méthode iter. La méthode renvoie un itérateur PagedIter d’objets Role.

Le code de l’exemple suivant répertorie tous les noms de rôles dans un compte :

role_list = root.roles.iter()
for role_obj in role_list:
  print(role_obj.name)
Copy

Suppression d’un rôle

Vous pouvez supprimer un rôle en utilisant la méthode RoleResource.drop.

Le code dans l’exemple suivant supprime le rôle my_role :

my_role_res = root.roles["my_role"]
my_role_res.drop()
Copy

Gestion des rôles de bases de données

Vous pouvez gérer des rôles de bases de données dans Snowflake. Un rôle de base de données est un objet au niveau de la base de données. Les Snowflake Python APIs représentent des rôles de base de données avec deux types distincts :

  • DatabaseRole : expose les propriétés d’un rôle de base de données telles que son nom et un commentaire.

  • DatabaseRoleResource : expose des méthodes que vous pouvez utiliser pour extraire un objet DatabaseRole correspondant et pour supprimer le rôle de base de données.

Création d’un rôle de base de données

Pour créer un rôle de base de données, commencez par créer un objet DatabaseRole qui spécifie le nom du rôle.

Le code de l’exemple suivant crée un objet DatabaseRole représentant un rôle de base de données nommé my_db_role :

from snowflake.core.database_role import DatabaseRole

my_db_role = DatabaseRole(
  name="my_db_role",
  comment="sample comment"
)

my_db_role_ref = root.databases['my_db'].database_roles.create(my_db_role)
Copy

Le code crée ensuite le rôle de base de données en transmettant l’objet DatabaseRole à la méthode DatabaseRoleCollection.create.

Clonage d’un rôle de base de données

Le code de l’exemple suivant crée un rôle de base de données nommé dr2 dans la base de données cible my_db_2 en tant que copie du rôle de base de données existant dr1 dans la base de données my_db.

database_role_ref = root.databases['my_db'].database_roles['dr1'].clone(target_database_role='dr2', target_database='my_db_2')
Copy

Affichage des rôles de base de données

Vous pouvez répertorier les rôles de base de données dans un compte à l’aide de la méthode iter. La méthode renvoie un itérateur PagedIter d’objets DatabaseRole.

Le code de l’exemple suivant répertorie le rôle de base de données nommé my_db_role dans la base de données my_db, limitant le nombre de résultats à 1 :

db_role_list = root.databases['my_db'].database_roles.iter(limit=1, from_name='my_db_role')
for db_role_obj in db_role_list:
  print(db_role_obj.name)
Copy

Suppression d’un rôle de base de données

Vous pouvez supprimer un rôle de base de données à l’aide de la méthode DatabaseRoleResource.drop.

Le code dans l’exemple suivant supprime le rôle de la base de données my_db_role :

root.databases['my_db'].database_roles['my_db_role'].drop()
Copy

Gestion des privilèges d’accès

Vous pouvez utiliser l’API pour gérer les privilèges d’accès sur un objet Snowflake sécurisable à un rôle de compte, un rôle de base de données ou un utilisateur. Pour plus d’informations sur les rôles, les objets sécurisables et le framework de contrôle d’accès dans Snowflake, consultez Aperçu du contrôle d’accès.

Pour les rôles de compte

Les exemples de code suivants illustrent les opérations d’APIpermettant d’accorder des privilèges, de révoquer des privilèges et de répertorier les autorisations pour les rôles de compte.

Accorder des privilèges

from snowflake.core.role import Securable

root.roles['my_role'].grant_privileges(
    privileges=["OPERATE"], securable_type="WAREHOUSE", securable=Securable(name='my_wh')
)
Copy

Accorder un rôle

from snowflake.core.role import Securable

root.roles['my_role'].grant_role(role_type="ROLE", role=Securable(name='my_role_1'))
Copy

Accorder des privilèges sur tout

from snowflake.core.role import ContainingScope

root.roles['my_role'].grant_privileges_on_all(
    privileges=["SELECT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Accorder des privilèges futurs

from snowflake.core.role import ContainingScope

root.roles['my_role'].grant_future_privileges(
    privileges=["SELECT", "INSERT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Révoquer les privilèges

from snowflake.core.role import Securable

root.roles['my_role'].revoke_privileges(
    privileges=["OPERATE"], securable_type="WAREHOUSE", securable=Securable(name='my_wh')
)
Copy

Révoquer le rôle

from snowflake.core.role import Securable

root.roles['my_role'].revoke_role(role_type="ROLE", role=Securable(name='my_role_1'))
Copy

Révoquer des privilèges sur tout

from snowflake.core.role import ContainingScope

root.roles['my_role'].revoke_privileges_on_all(
    privileges=["SELECT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Révoquer des privilèges futurs

from snowflake.core.role import ContainingScope

root.roles['my_role'].revoke_future_privileges(
    privileges=["SELECT", "INSERT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Révoquer l’option d’accord de privilèges

from snowflake.core.role import Securable

 root.roles['my_role'].revoke_grant_option_for_privileges(
    privileges=["OPERATE"], securable_type="WAREHOUSE", securable=Securable(name='my_wh')
)
Copy

Révoquer l’option d’accord de privilèges sur tout

from snowflake.core.role import ContainingScope

root.roles['my_role'].revoke_grant_option_for_privileges_on_all(
    privileges=["SELECT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Révoquer l’option d’accord de privilèges futurs

from snowflake.core.role import ContainingScope

root.roles['my_role'].revoke_grant_option_for_future_privileges(
    privileges=["SELECT", "INSERT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Afficher les autorisations accordées au rôle

root.roles['my_role'].iter_grants_to()
Copy

Afficher les autorisations accordées sur le rôle

root.roles['my_role'].iter_grants_on()
Copy

Afficher les autorisations du rôle

root.roles['my_role'].iter_grants_of()
Copy

Afficher les autorisations futures accordées au rôle

root.roles['my_role'].iter_future_grants_to()
Copy

Pour les utilisateurs

Les exemples de code suivants illustrent les opérations d’API permettant d’accorder un rôle, de révoquer un rôle et de répertorier les rôles des utilisateurs.

Accorder un rôle à un utilisateur

from snowflake.core.user import Securable

root.users['my_user'].grant_role(role_type="ROLE", role=Securable(name='my_role'))
Copy

Révoquer le rôle d’un utilisateur

from snowflake.core.user import Securable

root.users['my_user'].revoke_role(role_type="ROLE", role=Securable(name='my_role'))
Copy

Attribuer des rôles accordés à un utilisateur

root.users['my_user'].iter_grants_to()
Copy

Pour les rôles de base de données

Les exemples de code suivants illustrent les opérations d’APIpermettant d’accorder des privilèges, de révoquer des privilèges et de répertorier les accords pour des rôles de base de données.

Accorder des privilèges

from snowflake.core.database_role import Securable

root.databases['my_db'].database_roles['my_db_role'].grant_privileges(
    privileges=["MODIFY"], securable_type="DATABASE", securable=Securable(name='my_db')
)
Copy

Accorder un rôle

from snowflake.core.database_role import Securable

root.databases['my_db'].database_roles['my_db_role'].grant_role(role_type="DATABASE ROLE", role=Securable(name='my_db_role_1'))
Copy

Accorder des privilèges sur tout

from snowflake.core.database_role import ContainingScope

root.databases['my_db'].database_roles['my_db_role'].grant_privileges_on_all(
    privileges=["SELECT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Accorder des privilèges futurs

from snowflake.core.database_role import ContainingScope

root.databases['my_db'].database_roles['my_db_role'].grant_future_privileges(
    privileges=["SELECT", "INSERT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Révoquer les privilèges

from snowflake.core.database_role import Securable

root.databases['my_db'].database_roles['my_db_role'].revoke_privileges(
    privileges=["MODIFY"], securable_type="DATABASE", securable=Securable(name='my_db')
)
Copy

Révoquer le rôle

from snowflake.core.database_role import Securable

root.databases['my_db'].database_roles['my_db_role'].revoke_role(role_type="DATABASE ROLE", role=Securable(name='my_db_role_1'))
Copy

Révoquer tous les privilèges

from snowflake.core.database_role import ContainingScope

root.databases['my_db'].database_roles['my_db_role'].revoke_privileges_on_all(
    privileges=["SELECT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Révoquer des privilèges futurs

from snowflake.core.database_role import ContainingScope

root.databases['my_db'].database_roles['my_db_role'].revoke_future_privileges(
    privileges=["SELECT", "INSERT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Révoquer l’option d’accord de privilèges

from snowflake.core.database_role import Securable

root.databases['my_db'].database_roles['my_db_role'].revoke_grant_option_for_privileges(
    privileges=["MODIFY"], securable_type="DATABASE", securable=Securable(name='my_db')
)
Copy

Révoquer l’option d’accord de privilèges sur tout

from snowflake.core.database_role import ContainingScope

root.databases['my_db'].database_roles['my_db_role'].revoke_grant_option_for_privileges_on_all(
    privileges=["SELECT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Révoquer l’option d’accord de privilèges futurs

from snowflake.core.database_role import ContainingScope

root.databases['my_db'].database_roles['my_db_role'].revoke_grant_option_for_future_privileges(
    privileges=["SELECT", "INSERT"],
    securable_type="TABLE",
    containing_scope=ContainingScope(database='my_db', schema='my_schema'),
)
Copy

Afficher les autorisations accordées au rôle

root.databases['my_db'].database_roles['my_db_role'].iter_grants_to()
Copy

Afficher les autorisations futures accordées au rôle

root.databases['my_db'].database_roles['my_db_role'].iter_future_grants_to()
Copy

Gestion des autorisations à l’aide de la ressource Grant — Obsolète

Vous pouvez exécuter les opérations GRANT <privilèges> permettant d’accorder des privilèges d’accès sur un objet Snowflake sécurisable à un rôle.

Accord de privilèges

Pour accorder des privilèges sur un objet Snowflake, vous créez d’abord un objet Grant qui spécifie les attributs suivants :

  • grantee : le rôle ou l’utilisateur auquel les privilèges sont accordés.

  • securable : l’objet Snowflake qui est sécurisé par les privilèges.

  • privileges : les privilèges accordés à un rôle.

Accord de privilèges CREATE dans un compte à un rôle

Le code dans l’exemple suivant crée un objet Grant représentant une opération d’accord qui accorde les privilèges create_database et create_warehouse au rôle my_role dans le compte Snowflake actuel. Le code exécute l’opération en utilisant la méthode root.grants.grant.

from snowflake.core.grant import Grant
from snowflake.core.grant._grantee import Grantees
from snowflake.core.grant._privileges import Privileges
from snowflake.core.grant._securables import Securables

root.grants.grant(
  Grant(
    grantee=Grantees.role(name='my_role'),
    securable=Securables.current_account,
    privileges=[Privileges.create_database,
                Privileges.create_warehouse],
  )
)
Copy

Accord de privilèges sur une base de données à un rôle

Le code dans l’exemple suivant accorde des privilèges importés sur la base de données my_db au rôle my_role :

from snowflake.core.grant import Grant
from snowflake.core.grant._grantee import Grantees
from snowflake.core.grant._privileges import Privileges
from snowflake.core.grant._securables import Securables

root.grants.grant(
  Grant(
    grantee=Grantees.role('my_role'),
    securable=Securables.database('my_db'),
    privileges=[Privileges.imported_privileges],
  )
)
Copy

Accorder un rôle à un autre rôle

L’attribution d’un rôle à un autre rôle crée une relation « parent-enfant » entre les rôles (également appelée hiérarchie des rôles).

Le code dans l’exemple suivant accorde le rôle d’utilisateur my_role au rôle système ACCOUNTADMIN :

from snowflake.core.grant import Grant
from snowflake.core.grant._grantee import Grantees
from snowflake.core.grant._securables import Securables

root.grants.grant(
  Grant(
    grantee=Grantees.role('ACCOUNTADMIN'),
    securable=Securables.role('my_role'),
  )
)
Copy
Langage: Français