Politiques des paquets

Introduction

L’utilisation d’une politique de paquets vous permet de définir des listes d’autorisation et des listes de blocage pour les paquets Python tiers d’Anaconda au niveau du compte. Cela vous permet de répondre à des exigences d’audit et de sécurité plus strictes et vous donne un contrôle plus précis sur les paquets disponibles ou bloqués dans votre environnement.

Pour plus d’informations sur la façon dont Snowpark Python vous permet d’importer des paquets tiers d’Anaconda, consultez Utilisation de paquets tiers.

Lorsque vous créez une UDF, une UDTF ou une procédure stockée Python, la liste d’autorisation et la liste de blocage seront prises en compte lors de la création de l’environnement Python. La liste d’autorisation et la liste de blocage s’appliqueront à tous les paquets requis pour créer l’environnement Python. S’il n’est pas possible de créer un environnement avec les paquets spécifiés, la requête échouera.

Lorsque vous exécutez une UDF, une UDTF ou une procédure stockée Python, Snowflake vérifiera la liste d’autorisation et la liste de blocage et s’assurera que tous les paquets sont autorisés par la politique des paquets. Sinon, la requête échouera.

Limitations

  • Les politiques relatives aux paquets ne s’appliqueront que si les conditions juridiques d’Anaconda ont été acceptées.

  • Les politiques de paquets ne seront pas appliquées aux fonctions intégrées et ne seront pas non plus appliquées aux applications natives.

Implémentation et utilisation d’une politique de paquets

Pour créer un objet de politique de paquets, vous devez disposer des privilèges suivants :

  • USAGE sur la base de données et le schéma dans lesquels vous envisagez de créer la politique de paquets.

  • CREATE PACKAGES POLICY sur le schéma dans lequel vous prévoyez de créer la politique de paquets.

Une fois l’objet de politique de paquets créé, vous devez disposer des privilèges suivants pour l’appliquer au compte :

  • OWNERSHIP sur l’objet de politique de paquets.

  • APPLY PACKAGES POLICY sur le compte.

Suivez ces étapes pour mettre en œuvre une politique de paquet.

Étape 1 : Créer un rôle personnalisé d’administrateur de politiques de paquets

Créez un rôle personnalisé qui permet à des utilisateurs de créer et de gérer des politiques de paquets. Dans cette rubrique, l’exemple de rôle personnalisé est nommé policy_admin, bien que le rôle puisse avoir n’importe quel nom approprié.

Si le rôle personnalisé existe déjà, passez à l’étape suivante.

Sinon, créez le rôle personnalisé policy_admin.

use role useradmin;

create role policy_admin;
Copy

Étape 2 : accorder des privilèges au rôle personnalisé policy_admin

Si le rôle personnalisé policy_admin ne dispose pas déjà des privilèges suivants, accordez ces privilèges comme indiqué ci-dessous :

  • USAGE sur la base de données et le schéma qui contiendront la politique de paquets.

  • CREATE PACKAGES POLICY sur le schéma qui contiendra la politique de paquets.

  • APPLY PACKAGES POLICY sur le compte.

use role securityadmin;

grant usage on database yourdb to role policy_admin;

grant usage, create packages policy on schema yourdb.yourschema to role policy_admin;

grant apply packages policy on account to role policy_admin;
Copy

Étape 3 : Créer une nouvelle politique de paquets

À l’aide du rôle personnalisé policy_admin, créez une nouvelle politique de paquets, avec un langage, une liste d’autorisation et une liste de blocage spécifiées. ALLOWLIST, BLOCKLIST, ADDITIONAL_CREATION_BLOCKLIST et COMMENT sont des paramètres facultatifs. Par défaut, la valeur de la liste d’autorisation est ('*') et la valeur de la liste de blocage est ().

Si un paquet est spécifié à la fois dans la liste d’autorisation et dans la liste de blocage, la liste de blocage est prioritaire. Vous devez explicitement ajouter la version d’exécution de Python dans la liste d’autorisation et vous devez également ajouter explicitement tous les paquets et dépendances sous-jacentes d’un paquet parent à la liste d’autorisation.

Vous pouvez spécifier une version particulière du paquet ou une série de versions en utilisant des spécificateurs de version dans la liste d’autorisation ou la liste de blocage tels que : ==, <=, >=, <, ou >. Par exemple, numpy>=1.2.3. Vous pouvez utiliser des caractères génériques, tels que numpy==1.2.*, ce qui signifie n’importe quelle version micro de numpy 1.2.

Note

Actuellement, dans une liste d’autorisation ou de blocage, un seul opérateur de plage peut être spécifié par paquet. La spécification de plusieurs opérateurs de plage n’est pas prise en charge, par exemple pkg>1.0, <1.5. Pour cette raison, pour configurer une politique afin d’autoriser un intervalle d’une version de paquet, définissez un côté de la plage dans la liste d’autorisation et l’autre côté de la plage dans la liste de blocage. Par exemple, pour autoriser les versions de paquets supérieures à 1.0 et inférieures à 1.5, définissez la liste d’autorisation sur pkg>1.0 et la liste de blocage sur pkg>1.5.

USE ROLE policy_admin;

CREATE PACKAGES POLICY yourdb.yourschema.packages_policy_prod_1
  LANGUAGE PYTHON
  ALLOWLIST = ('numpy', 'pandas==1.2.3', ...)
  BLOCKLIST = ('numpy==1.2.3', 'bad_package', ...)
  ADDITIONAL_CREATION_BLOCKLIST = ('bad_package2', 'bad_package3', ...)
  COMMENT = 'Packages policy for the prod_1 environment'
;
Copy

Où :

yourdb.yourschema.packages_policy_prod_1

Le nom entièrement qualifié de la politique de paquets.

LANGUAGE PYTHON

La langue à laquelle cette politique de paquets s’appliquera.

ALLOWLIST = ('numpy', 'pandas==1.2.3', ...)

La liste d’autorisation pour cette politique de paquets. Il s’agit d’une chaîne séparée par des virgules avec les spécifications du paquet.

BLOCKLIST = ('numpy==1.2.3', 'bad_package', ...)

La liste de blocage pour cette politique de paquets. Il s’agit d’une chaîne séparée par des virgules avec les spécifications du paquet.

ADDITIONAL_CREATION_BLOCKLIST = ('bad_package2', 'bad_package3', ...)

Spécifie une liste de spécifications de paquets bloquées au moment de la création. Pour désactiver ce paramètre, indiquez une liste vide. Si ADDITIONAL_CREATION_BLOCKLIST est défini, il est ajouté à la BLOCKLIST de base au moment de la création. Pour les UDFs temporaires et les procédures stockées anonymes, le ADDITIONAL_CREATION_BLOCKLIST est ajouté au BLOCKLIST au moment de la création et de l’exécution.

COMMENT = 'Packages policy for the prod_1 environment'

Un commentaire spécifiant l’objectif de la politique de paquets.

Dans l’exemple ci-dessus, la liste de blocage appliquée au moment de la création sera le ADDITIONAL_CREATION_BLOCKLIST plus le BLOCKLIST donc les paquets bloqués seront numpy==1.2.3, bad_package, bad_package2 et bad_package3. La liste de blocage appliquée pour l’exécution sera : numpy==1.2.3 et bad_package. Pour les UDFs temporaires et les procédures stockées anonymes, la liste de blocage contenant numpy==1.2.3, bad_package, bad_package2 et bad_package3 sera appliquée au moment de la création et de l’exécution.

Pour obtenir la liste des dépendances d’un paquet Python, utilisez la fonction SHOW_PYTHON_PACKAGES_DEPENDENCIES. Le premier paramètre est la version du moteur d’exécution Python que vous utilisez et le second est une liste des paquets dont il faut afficher les dépendances. Par exemple, pour afficher les dépendances du paquet numpy, utilisez cette commande.

USE ROLE ACCOUNTADMIN;

select SNOWFLAKE.SNOWPARK.SHOW_PYTHON_PACKAGES_DEPENDENCIES('3.8', ['numpy']);
Copy

Le résultat est une liste des dépendances et de leurs versions.

['_libgcc_mutex==0.1', '_openmp_mutex==5.1', 'blas==1.0', 'ca-certificates==2023.05.30', 'intel-openmp==2021.4.0',
'ld_impl_linux-64==2.38', 'ld_impl_linux-aarch64==2.38', 'libffi==3.4.4', 'libgcc-ng==11.2.0', 'libgfortran-ng==11.2.0',
'libgfortran5==11.2.0', 'libgomp==11.2.0', 'libopenblas==0.3.21', 'libstdcxx-ng==11.2.0', 'mkl-service==2.4.0',
'mkl==2021.4.0', 'mkl_fft==1.3.1', 'mkl_random==1.2.2', 'ncurses==6.4', 'numpy-base==1.24.3', 'numpy==1.24.3',
'openssl==3.0.10', 'python==3.8.16', 'readline==8.2', 'six==1.16.0', 'sqlite==3.41.2', 'tk==8.6.12', 'xz==5.4.2', 'zlib==1.2.13']

Pour afficher les dépendances de Python 3.8 dans l’environnement Snowpark, appelez la fonction sans spécifier de paquet.

select SNOWFLAKE.SNOWPARK.SHOW_PYTHON_PACKAGES_DEPENDENCIES('3.8', []);
Copy

Si vous souhaitez savoir quels paquets une fonction utilise, vous pouvez utiliser DESCRIBE FUNCTION pour les imprimer. Il s’agit d’une autre façon d’identifier toutes les dépendances d’un paquet. Pour ce faire, créez une fonction et dans la spécification du paquet, fournissez les paquets de niveau supérieur. Ensuite, utilisez DESCRIBEFUNCTION pour obtenir une liste de tous les paquets et de leurs dépendances. Vous pouvez copier et coller cette liste dans la liste d’autorisation du paquet. Notez que la politique des paquets doit être temporairement désactivée, sinon certains paquets pourraient être bloqués. L’exemple suivant montre comment trouver les dépendances du paquet « snowflake-snowpark-python ».

create or replace function my_udf()
returns string
language python
packages=('snowflake-snowpark-python')
runtime_version=3.10
handler='echo'
as $$
def echo():
  return 'hi'
$$;

describe function my_udf();
Copy

Si vous souhaitez afficher tous les paquets et versions disponibles, interrogez la vue INFORMATION_SCHEMA.PACKAGES.

select * from information_schema.packages;
Copy

Si vous souhaitez voir l’ensemble actuel de paquets que vous utilisez, vous pouvez utiliser cette instruction SQL.

-- at the database level

CREATE OR REPLACE VIEW USED_ANACONDA_PACKAGES
ASSELECT FUNCTION_NAME, VALUE PACKAGE_NAME
FROM (SELECT FUNCTION_NAME,PARSE_JSON(PACKAGES)
PACKAGES FROM INFORMATION_SCHEMA.FUNCTIONS
WHERE FUNCTION_LANGUAGE='PYTHON') USED_PACKAGES,LATERAL FLATTEN(USED_PACKAGES.PACKAGES);

-- at the account level

CREATE OR REPLACE VIEW ACCOUNT_USED_ANACONDA_PACKAGES
ASSELECT  FUNCTION_CATALOG, FUNCTION_SCHEMA, FUNCTION_NAME, VALUE PACKAGE_NAME
FROM (SELECT FUNCTION_CATALOG, FUNCTION_SCHEMA, FUNCTION_NAME,PARSE_JSON(PACKAGES)
PACKAGES FROM SNOWFLAKE.ACCOUNT_USAGE.FUNCTIONS
WHERE FUNCTION_LANGUAGE='PYTHON') USED_PACKAGES,LATERAL FLATTEN(USED_PACKAGES.PACKAGES);
Copy

Étape 4 : Définir la politique des paquets sur un compte

Avec le rôle personnalisé policy_admin, définissez la politique sur un compte avec la commande ALTER ACCOUNT.

use role policy_admin;

alter account set packages policy yourdb.yourschema.packages_policy_prod_1;
Copy

Note

Pour remplacer une politique de paquets déjà définie pour un compte, supprimez d’abord la politique de paquets, puis définissez la nouvelle politique de paquets pour le compte. Vous pouvez également utiliser FORCE pour définir la politique de paquets sans avoir à supprimer la politique de paquets. Par exemple :

alter account set packages policy yourdb.yourschema.packages_policy_prod_2 force;
Copy

Si vous souhaitez voir quelle politique est active sur le compte, vous pouvez utiliser cette instruction SQL.

select * from table(information_schema.policy_references(ref_entity_domain=>'ACCOUNT', ref_entity_name=>'<your_account_name>'))
Copy

Le résultat de cette requête affichera une colonne portant le nom POLICY_STATUS.

Plus tard, si vous souhaitez désactiver la politique de paquets sur votre compte, utilisez cette instruction SQL.

alter account unset packages policy;
Copy

Privilèges requis pour exécuter des commandes DDL

Le tableau suivant résume la relation entre les opérations DDL de politique de paquets et leurs privilèges nécessaires.

Fonctionnement

Privilège requis

Créer une politique de paquets

Un rôle avec le privilège CREATE PACKAGES POLICY sur le schéma.

Modifier la politique de paquets

Un rôle avec le privilège OWNERSHIP sur la politique de paquets.

Supprimer une politique de paquets

Un rôle avec le privilège OWNERSHIP sur la politique de paquets.

Décrire la politique de paquets

Un rôle avec le privilège OWNERSHIP ou USAGE sur la politique de paquets.

Afficher les politiques de paquets

Un rôle avec le privilège OWNERSHIP ou USAGE sur la politique de paquets.

Définir et annuler une politique de paquets

Un rôle avec le privilège APPLY PACKAGES POLICY sur le compte et le privilège OWNERSHIP sur la politique de paquets.

DDL de politique des paquets

Snowflake fournit les commandes DDL suivantes pour gérer les objets de politique de paquets.

Observabilité de la politique des paquets

Les utilisateurs qui n’ont pas accès à la politique de paquets définie sur le compte peuvent en voir le contenu.

Les utilisateurs peuvent contrôler qui voit le contenu de la politique de paquets en ajoutant le privilège USAGE aux politiques de paquets. L’administrateur du compte ou le propriétaire de la politique de paquets peut accorder ce privilège aux rôles qui doivent utiliser les politiques de paquets.

La vue CURRENT_PACKAGES_POLICY Information Schema affiche une ligne pour chaque politique de paquets Snowpark sur le compte courant.

select * from information_schema.current_packages_policy;
Copy
+------+----------+-----------+-----------+-------------------------------+---------+
| NAME | LANGUAGE | ALLOWLIST | BLOCKLIST | ADDITIONAL_CREATION_BLOCKLIST | COMMENT |
+------+----------+-----------+-----------+-------------------------------+---------+
| P1   | PYTHON   | ['*']     | []        | [NULL]                        | [NULL]  |
+------+----------+-----------+-----------+-------------------------------+---------+

Pour voir les paquets Anaconda qui sont utilisés au niveau de la base de données pour la fonction, utilisez cette instruction SQL.

USE DATABASE mydb;

CREATE OR REPLACE VIEW USED_ANACONDA_PACKAGES
AS
SELECT FUNCTION_NAME, VALUE PACKAGE_NAME
FROM (SELECT FUNCTION_NAME,PARSE_JSON(PACKAGES)
PACKAGES FROM INFORMATION_SCHEMA.FUNCTIONS
WHERE FUNCTION_LANGUAGE='PYTHON') USED_PACKAGES,LATERAL FLATTEN(USED_PACKAGES.PACKAGES);
Copy

Pour voir les paquets Anaconda qui sont utilisés au niveau du compte pour la fonction, utilisez cette instruction SQL.

USE DATABASE mydb;

CREATE OR REPLACE VIEW ACCOUNT_USED_ANACONDA_PACKAGES
AS
SELECT  FUNCTION_CATALOG, FUNCTION_SCHEMA, FUNCTION_NAME, VALUE PACKAGE_NAME
FROM (SELECT FUNCTION_CATALOG, FUNCTION_SCHEMA, FUNCTION_NAME,PARSE_JSON(PACKAGES)
PACKAGES FROM SNOWFLAKE.ACCOUNT_USAGE.FUNCTIONS
WHERE FUNCTION_LANGUAGE='PYTHON') USED_PACKAGES,LATERAL FLATTEN(USED_PACKAGES.PACKAGES);
Copy

Pour voir tous les paquets Anaconda installés sur votre compte, utilisez cette instruction SQL.

USE DATABASE mydb;

CREATE OR REPLACE VIEW ACCOUNT_USED_ANACONDA_PACKAGES
AS
SELECT 'FUNCTION' TYPE, FUNCTION_CATALOG DATABASE, FUNCTION_SCHEMA SCHEMA, FUNCTION_NAME NAME, VALUE::STRING PACKAGE_NAME
FROM (SELECT FUNCTION_CATALOG, FUNCTION_SCHEMA, FUNCTION_NAME,PARSE_JSON(PACKAGES)
PACKAGES FROM SNOWFLAKE.ACCOUNT_USAGE.FUNCTIONS
WHERE FUNCTION_LANGUAGE='PYTHON' AND PACKAGES IS NOT NULL) USED_PACKAGES,LATERAL FLATTEN(USED_PACKAGES.PACKAGES)
UNION
(SELECT 'PROCEDURE' TYPE, PROCEDURE_CATALOG DATABASE, PROCEDURE_SCHEMA SCHEMA, PROCEDURE_NAME, VALUE::STRING PACKAGE_NAME
FROM (SELECT PROCEDURE_CATALOG, PROCEDURE_SCHEMA,PROCEDURE_NAME,PARSE_JSON(PACKAGES)
PACKAGES FROM SNOWFLAKE.ACCOUNT_USAGE.PROCEDURES
WHERE PROCEDURE_LANGUAGE='PYTHON' AND PACKAGES IS NOT NULL) USED_PACKAGES,LATERAL FLATTEN(USED_PACKAGES.PACKAGES));
Copy

Politiques en matière de réplication et de paquets

Les politiques de paquets sont répliquées d’un compte source vers les comptes cibles si la base de données contenant la politique de paquets est répliquée. Pour plus d’informations, voir Références pendantes et politiques de paquets.