Paketrichtlinien

Einführung

Mithilfe einer Paketrichtlinie können Sie auf Kontoebene Zulassungslisten und Sperrlisten für Python-Pakete von Drittanbietern aus Anaconda erstellen. Auf diese Weise können Sie strengere Auditing- und Sicherheitsanforderungen erfüllen und haben eine genauere Kontrolle darüber, welche Pakete in Ihrer Umgebung verfügbar oder gesperrt sind.

Weitere Informationen zum Einbinden von Paketen von Drittanbietern aus Anaconda mit Snowpark Python finden Sie unter Verwenden von Drittanbieter-Paketen.

Wenn Sie eine UDF, UDTF oder gespeicherte Prozedur in Python erstellen, werden Zulassungsliste und Sperrliste beim Erstellen der Python-Umgebung berücksichtigt. Zulassungsliste und Sperrliste gelten für alle Pakete, die zum Erstellen der Python-Umgebung erforderlich sind. Wenn es nicht möglich ist, eine Umgebung mit den angegebenen Paketen zu erstellen, schlägt die Abfrage fehl.

Wenn Sie eine in Python geschriebene UDF, UDTF oder gespeicherte Prozedur ausführen, prüft Snowflake die Zulassungsliste und die Sperrliste und stellt sicher, dass alle Pakete von der Paketrichtlinie zugelassen sind. Andernfalls wird die Abfrage fehlschlagen.

Einschränkungen

  • Paketrichtlinien werden nur angewendet, wenn die Anaconda-Nutzungsbedingungen zugestimmt wurde.

  • Paketrichtlinien werden nicht auf integrierte Funktionen und auch nicht auf native Apps angewendet.

Implementieren und Verwenden einer Paketrichtlinie

Um eine Paketrichtlinie zu erstellen, müssen Sie über die folgenden Berechtigungen verfügen:

  • USAGE für die Datenbank und das Schema, in dem Sie die Paketrichtlinie erstellen möchten.

  • CREATE PACKAGES POLICY für das Schema, in dem Sie die Paketrichtlinie erstellen möchten.

Nachdem das Paketrichtlinienobjekt erstellt wurde, müssen Sie über die folgenden Berechtigungen verfügen, um es auf das Konto anzuwenden:

  • OWNERSHIP für das Paketrichtlinienobjekt.

  • APPLY PACKAGES POLICY für das Konto

Führen Sie die folgenden Schritte aus, um eine Paketrichtlinie zu implementieren.

Schritt 1: Kundenspezifische Admin-Rolle für die Paketrichtlinie definieren

Erstellen Sie eine kundenspezifische Rolle, mit der Benutzer Paketrichtlinien erstellen und verwalten können. Unter diesem Thema wird die kundenspezifische Rolle als policy_admin bezeichnet, obwohl die Rolle jeden beliebigen Namen haben kann.

Wenn die kundenspezifische Rolle bereits vorhanden ist, fahren Sie mit dem nächsten Schritt fort.

Erstellen Sie andernfalls die kundenspezifische Rolle policy_admin.

use role useradmin;

create role policy_admin;
Copy

Schritt 2: Kundenspezifischer Rolle policy_admin Berechtigungen zuweisen

Wenn die kundenspezifische Rolle policy_admin nicht bereits über die folgenden Berechtigungen verfügt, weisen Sie ihr folgende Berechtigungen zu:

  • USAGE für Datenbank und Schema, die die Paketrichtlinie enthalten wird

  • CREATE PACKAGES POLICY für das Schema, das die Paketrichtlinie enthalten wird

  • APPLY PACKAGES POLICY für das Konto

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

Schritt 3: Neue Paketrichtlinie erstellen

Erstellen Sie mit der kundenspezifischen Rolle policy_admin eine neue Paketrichtlinie, für die Sie eine Sprache, eine Zulassungsliste und eine Sperrliste angeben. ALLOWLIST, BLOCKLIST, ADDITIONAL_CREATION_BLOCKLIST und COMMENT sind optionale Parameter. Standardmäßig ist der Wert für die Zulassungsliste ('*') und für die Sperrliste ().

Wenn ein Paket sowohl in der Zulassungsliste als auch in der Sperrliste angegeben ist, hat die Sperrliste Vorrang. Sie müssen die Python-Laufzeitversion explizit in die Zulassungsliste aufnehmen, und Sie müssen auch alle Pakete und zugrunde liegenden Abhängigkeiten eines übergeordneten Pakets explizit in die Zulassungsliste aufnehmen.

Sie können eine bestimmte Paketversion oder eine Bereich von Versionen angeben, indem Sie die folgenden Versionsspezifizierer in der Zulassungsliste oder Sperrliste angeben: ==, <=, >=, < oder >. Beispiel: numpy>=1.2.3. Sie können Platzhalter verwenden, z. B. numpy==1.2.*, was eine beliebige Mikroversion von numpy 1.2 bedeutet.

Bemerkung

Derzeit kann in einer Zulassungsliste oder Sperrliste nur ein Bereichsoperator pro Paket angegeben werden. Die Angabe mehrerer Bereichsoperatoren, z. B. pkg>1.0, <1.5, wird nicht unterstützt. Um eine Richtlinie so zu konfigurieren, dass sie ein Intervall einer Paketversion zulässt, legen Sie eine Seite des Bereichs in der Zulassungsliste und die andere Seite des Bereichs in der Sperrliste fest. Um zum Beispiel Paketversionen größer als 1.0 und kleiner als 1.5 zuzulassen, legen Sie für die Zulassungsliste pkg>1.0 fest und für die Sperrliste 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

Wobei:

yourdb.yourschema.packages_policy_prod_1

Der vollqualifizierte Name der Paketrichtlinie.

LANGUAGE PYTHON

Die Sprache, für die diese Paketrichtlinie gelten soll.

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

Die Zulassungsliste für diese Paketrichtlinie. Dies ist eine durch Komma getrennte Zeichenfolge mit Paketangaben.

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

Die Sperrliste für diese Paketrichtlinie. Dies ist eine durch Komma getrennte Zeichenfolge mit Paketangaben.

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

Gibt eine Liste von Paketspezifikationen an, die zum Zeitpunkt der Erstellung blockiert werden. Um diesen Parameter zu deaktivieren, geben Sie eine leere Liste an. Wenn ADDITIONAL_CREATION_BLOCKLIST festgelegt ist, wird der Wert zum Erstellungszeitpunkt an die Basiswert für BLOCKLIST angehängt. Bei temporären UDFs und anonymen gespeicherten Prozeduren wird der Wert von ADDITIONAL_CREATION_BLOCKLIST sowohl zum Erstellungszeitpunkt als auch zum Ausführungszeitpunkt an den Wert von BLOCKLIST angehängt.

COMMENT = 'Packages policy for the prod_1 environment'

Ein Kommentar, der den Zweck der Paketrichtlinie angibt.

Im obigen Beispiel wird die Sperrliste für den Erstellungszeitpunkt aus dem Wert von ADDITIONAL_CREATION_BLOCKLIST plus dem Wert von BLOCKLIST bestehen, sodass die blockierten Pakete numpy==1.2.3, bad_package, bad_package2 und bad_package3 sein werden. Die Sperrliste für den Ausführungszeitpunkt wird wie folgt aussehen: numpy==1.2.3 und bad_package. Für temporäre UDFs und anonyme gespeicherte Prozeduren wird die Sperrliste, die numpy==1.2.3, bad_package, bad_package2 und bad_package3 enthält, sowohl zur Erstellungs- als auch zum Ausführungszeitpunkt angewendet.

Um eine Liste der Abhängigkeiten eines Python-Pakets zu erhalten, verwenden Sie die Funktion SHOW_PYTHON_PACKAGES_DEPENDENCIES. Der erste Parameter ist die Python-Laufzeitversion, die Sie verwenden, und der zweite ist eine Liste der Pakete, deren Abhängigkeiten angezeigt werden sollen. Um zum Beispiel die Abhängigkeiten des Pakets numpy anzuzeigen, verwenden Sie folgenden Befehl.

USE ROLE ACCOUNTADMIN;

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

Das Ergebnis ist eine Liste der Abhängigkeiten und ihrer Versionen.

['_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']

Um die Abhängigkeiten von Python 3.8 in der Snowpark-Umgebung anzuzeigen, rufen Sie die Funktion ohne Angabe von Paketen auf.

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

Wenn Sie wissen möchten, welche Pakete von einer Funktion verwendet werden, können Sie diese mit DESCRIBE FUNCTION ausgeben. Dies ist ein alternativer Weg, um alle Abhängigkeiten eines Pakets zu identifizieren. Erstellen Sie dazu eine Funktion, und geben Sie in der Paketspezifikation die Top-Level-Pakete an. Als Nächstes verwenden Sie DESCRIBE FUNCTION, um eine Liste aller Pakete und deren Abhängigkeiten zu erhalten. Sie können diese Liste kopieren und in die Zulassungsliste des Pakets einfügen. Beachten Sie, dass die Paketrichtlinie vorübergehend aufgehoben sein muss, da sonst einige Pakete blockiert werden könnten. Das folgende Beispiel zeigt, wie Sie die Abhängigkeiten für das Paket „snowflake-snowpark-python“ finden.

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

Wenn Sie alle verfügbaren Pakete und Versionen anzeigen möchten, fragen Sie die Ansicht INFORMATION_SCHEMA.PACKAGES ab.

select * from information_schema.packages;
Copy

Wenn Sie den aktuellen Satz der von Ihnen verwendeten Pakete anzeigen möchten, können Sie die folgende SQL-Anweisung verwenden.

-- 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

Schritt 4: Paketrichtlinie für ein Konto einstellen

Verwenden Sie die kundenspezifische Rolle policy_admin, um einem Konto die Richtlinie mit dem Befehl ALTER ACCOUNT zuzuweisen.

use role policy_admin;

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

Bemerkung

Um eine Paketrichtlinie zu ersetzen, die bereits für ein Konto festgelegt ist, heben Sie die Paketrichtlinie zuerst auf, und legen Sie dann die neue Paketrichtlinie für das Konto fest. Alternativ können Sie auch FORCE verwenden, um die Paketrichtlinie festzulegen, ohne die bisherige Paketrichtlinie aufheben zu müssen. Beispiel:

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

Wenn Sie anzeigen möchten, welche Richtlinie für das Konto aktiv ist, können Sie die folgende SQL-Anweisung verwenden.

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

Im Ergebnis dieser Abfrage wird eine Spalte mit dem Namen POLICY_STATUS angezeigt.

Wenn Sie später die Paketrichtlinie für Ihr Konto aufheben möchten, verwenden Sie diese SQL-Anweisung.

alter account unset packages policy;
Copy

Erforderliche Berechtigungen zum Ausführen von DDL-Befehlen

In der folgenden Tabelle wird die Beziehung zwischen den DDL-Operationen für die Paketrichtlinie und den dafür erforderlichen Berechtigungen zusammengefasst.

Operation

Erforderliche Berechtigung

Paketrichtlinie erstellen

Eine Rolle mit CREATE PACKAGES POLICY-Berechtigung für das Schema.

Paketrichtlinie ändern

Rolle mit OWNERSHIP-Berechtigung für die Paketrichtlinie.

Paketrichtlinie löschen

Rolle mit OWNERSHIP-Berechtigung für die Paketrichtlinie.

Paketrichtlinie beschreiben

Eine Rolle mit der Berechtigung OWNERSHIP oder USAGE für die Paketrichtlinie.

Paketrichtlinien anzeigen

Eine Rolle mit der Berechtigung OWNERSHIP oder USAGE für die Paketrichtlinie.

Paketrichtlinie festlegen/aufheben

Eine Rolle mit APPLY PACKAGES POLICY-Berechtigung für das Konto und OWNERSHIP-Berechtigung für die Paketrichtlinie.

DDL für Paketrichtlinien

Snowflake bietet die folgenden DDL-Befehle zum Verwalten von Paketrichtlinienobjekten:

Paketrichtlinien-Beobachtung

Benutzer, die keinen Zugriff auf die für das Konto festgelegte Paketrichtlinie haben, können den Inhalt der Richtlinie einsehen.

Benutzer können kontrollieren, wer den Inhalt der Paketrichtlinien sehen darf, indem sie den Paketrichtlinien die USAGE-Berechtigung hinzufügen. Der Kontoadministrator oder der Eigentümer der Paketrichtlinie kann diese Berechtigung Rollen zuweisen, die Paketrichtlinien verwenden müssen.

Die Information Schema-Ansicht CURRENT_PACKAGES_POLICY zeigt eine Zeile für jede Snowpark-Paketrichtlinie des aktuellen Kontos an.

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

Um die Anaconda-Pakete anzuzeigen, die auf Datenbankebene für Funktionen verwendet werden, verwenden Sie diese SQL-Anweisung.

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

Um die Anaconda-Pakete anzuzeigen, die auf Kontoebene für Funktionen verwendet werden, verwenden Sie diese SQL-Anweisung.

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

Um alle installierten Anaconda-Pakete auf Ihrem Konto anzuzeigen, verwenden Sie diese SQL-Anweisung.

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

Replikation und Paketrichtlinien

Paketrichtlinien werden von einem Quellkonto auf Zielkonten repliziert, wenn die Datenbank, die die Paketrichtlinie enthält, repliziert wird. Weitere Informationen dazu finden Sie unter Verwaiste Referenzen und Paketrichtlinien.