Tutorial: Eine Snowflake Native App mit dem Snowflake Native App Framework entwickeln

Einführung

In diesem Tutorial wird beschrieben, wie Sie das Snowflake Native App Framework verwenden, um eine Snowflake Native App zu erstellen, mit der Sie Daten und die zugehörige Geschäftslogik für andere Snowflake-Konten freigeben können.

Das Tutorial verwendet sowohl die Weboberfläche Snowflake CLI als auch Snowsight.

Lerninhalte

In diesem Tutorial erfahren Sie Folgendes:

  • Erstellen eines Anwendungspakets, das die Daten und die Geschäftslogik der App enthält

  • Freigeben von Daten für ein Anwendungspaket

  • Hinzufügen von Geschäftslogik zu einem Anwendungspaket

  • Lokales Testen der App

  • Anzeigen und testen der App in Snowsight

  • Veröffentlichen der App durch Erstellen eines privaten Freigabeangebots

  • Installieren der App über ein privates Freigabeangebot

  • Verwenden von Snowflake CLI, um viele der oben genannten Schritte auszuführen

Allgemeine Informationen zu Anbietern und Verbrauchern

Im Kontext des Snowflake Native App Framework stehen Anbieter für die Rollen und Organisationen, die über Daten und Geschäftslogik verfügen, die sie für andere Snowflake-Benutzer, die Verbraucher, freigeben möchten. Ein Verbraucher kann für ein anderes Konto in Ihrer Organisation, für eine andere Organisation innerhalb Ihres Unternehmens oder für einen Snowflake-Benutzer in einem anderen Unternehmen stehen.

Im Rahmen dieses Tutorials werden Sie die meisten Aufgaben ausführen, die typischerweise von Anbietern ausgeführt werden. Dazu gehören jedoch auch Aufgaben, die von mehreren Rollen innerhalb Ihrer Organisation ausgeführt werden können, wie Anwendungsentwickler und Datenbankadministratoren.

In diesem Tutorial werden Sie auch Aufgaben ausführen, mit denen Aktionen nachgeahmt werden, die Verbraucher zur Installation einer App ausführen.

Voraussetzungen

  • Auf Ihrem Computer muss Snowflake CLI installiert sein.

  • Sie müssen alle SQL-Befehle in der gleichen SQL-Befehlssitzung ausführen, da der Sitzungskontext erforderlich ist.

    Bei Verwendung von Snowsight fügen Sie beispielsweise Ihren gesamten Code nach und nach in dasselbe Arbeitsblatt ein. Während Sie von Abschnitt zu Abschnitt vorankommen, baut jeder Abschnitt auf dem vorherigen auf.

  • Sie müssen die Rolle ACCOUNTADMIN verwenden können.

    In diesem Tutorial werden Sie alle Schritte mit der Rolle ACCOUNTADMIN durchführen. In der Regel sollten Sie jedoch Rollen verwenden, deren Berechtigungen speziell für die von Ihnen auszuführende Aktion definiert sind. So können Sie z. B. getrennte Rollen für Entwickler haben, die UDFs und gespeicherte Prozeduren erstellen, für Datenbankadministratoren, die Rollen und Berechtigungen verwalten, und für Administratoren, die mit Snowflake Collaboration (Zusammenarbeiten mit Snowflake) Freigabeangebote verwalten.

  • Um Ihre App von einem privaten Freigabeangebot aus zu installieren, müssen Sie Zugriff auf ein zweites Snowflake-Konto haben. Mit diesem Konto werden Sie die Verbraucher nachahmen, die eine App installieren.

    Bemerkung

    Obwohl das Snowflake Native App Framework das Freigeben von Apps mit Konten in verschiedenen Organisationen unterstützt, müssen sich für die Zwecke dieses Tutorials beide Konten in derselben Organisation befinden.

  • Sie müssen ein aktuelles Warehouse festlegen. Siehe USE WAREHOUSE.

Anwendungsdateien erstellen

In diesem Abschnitt werden Sie ein Setup-Skript, eine Manifest-Datei und eine Projektdefinitionsdatei erstellen. Die ersten beiden Dateien werden vom Snowflake Native App Framework benötigt.

Setup-Skript

Ein SQL-Skript, das automatisch ausgeführt wird, wenn ein Verbraucher eine App in seinem Konto installiert.

Manifest-Datei

Eine YAML-Datei, die grundlegende Konfigurationsinformationen zu der App enthält.

Projektdefinitionsdatei

Eine YAML-Datei, die Informationen über die Snowflake-Objekte enthält, die Sie erstellen möchten.

Sie werden im Laufe dieses Tutorials mehr über diese Dateien und deren Inhalt erfahren. Sie werden auch eine Readme-Datei erstellen, die bei der Anzeige und Veröffentlichung Ihrer App in späteren Abschnitten dieses Tutorials nützlich sein wird.

Neuen Projektordner erstellen

Sie werden Snowflake CLI verwenden, um ein neues Snowflake Native App-Projekt in Ihrem lokalen Dateisystem zu initialisieren.

Führen Sie dazu den folgenden Befehl aus:

snow init --template app_basic tutorial
Copy

Dieser Befehl erstellt im aktuellen Verzeichnis einen Ordner namens tutorial und füllt ihn mit einem einfachen Snowflake Native App-Projekt, das auf einer einfachen Vorlage basiert. Dies ist das Stammverzeichnis für alle Ihre Anwendungsdateien.

Bemerkung

Sie werden in späteren Abschnitten weitere Dateien und Unterordner zu diesem Ordner hinzufügen.

Bemerkung

Es stehen weitere Vorlagen zur Verfügung, die Ihnen helfen, schnell mit nativen Anwendungen loszulegen. Weitere Informationen dazu erhalten Sie mit snow init --help.

Setup-Skript erstellen

Ändern oder ersetzen Sie den Inhalt der app/setup_script.sql-Datei, wie im folgenden Beispiel gezeigt:

-- Setup script for the Hello Snowflake! app.
Copy

Diese Zeile ist ein Platzhalter, da das Setup-Skript nicht leer sein darf.

Bemerkung

Dieses Tutorial bezieht sich auf eine bestimmte Struktur und einen bestimmten Dateinamen für das Setup-Skript. Wenn Sie Ihre eigene App erstellen, können Sie einen eigenen Namen und eine eigene Verzeichnisstruktur für diese Datei wählen.

README-Datei für die App erstellen

Eine Readme-Datei enthält eine Beschreibung darüber, was die Aufgabe Ihrer Anwendung ist. Sie sehen die Readme-Datei, wenn Sie Ihre App in Snowsight anzeigen.

Ändern oder ersetzen Sie den Inhalt von app/README.md wie folgt:

This is the readme file for the Hello Snowflake app.
Copy

Manifest-Datei erstellen

Das Snowflake Native App Framework benötigt für jede App eine Manifest-Datei. Die Manifest-Datei enthält Metadaten und Konfigurationsparameter für eine App und beeinflusst das Laufzeitverhalten Ihrer App.

Bemerkung

Diese Datei muss den Namen manifest.yml tragen. Pfade zu anderen Dateien, einschließlich des Setup-Skripts, sind relativ zum Speicherort dieser Datei.

Ändern oder ersetzen Sie den Inhalt der app/manifest.yml-Datei wie folgt:

manifest_version: 1
artifacts:
   setup_script: setup_script.sql
   readme: README.md
Copy

Die Eigenschaft setup_script gibt den Speicherort des Setup-Skripts relativ zum Speicherort der Manifest-Datei an. Der hier angegebene Pfad und Dateiname muss mit dem relativen Speicherort des oben geänderten Setup-Skripts übereinstimmen. Die Eigenschaft readme folgt den gleichen Regeln.

Bemerkung

Die Eigenschaften manifest_version, artifacts und setup_script sind erforderlich. Die Eigenschaft readme ist optional.

Projektdefinitionsdatei erstellen

Snowflake CLI verwendet eine Projektdefinitionsdatei, um Objekte zu beschreiben, die in Snowflake bereitgestellt werden können. Diese Datei muss den Namen snowflake.yml tragen. Diese Datei steuert den Namen des bereitgestellten Anwendungspakets und Anwendungsobjekts sowie die Dateien, die in den Stagingbereich des Projekts hochgeladen werden.

Bemerkung

Diese Datei muss den Namen snowflake.yml tragen und im Stammverzeichnis Ihres Projekts gespeichert sein. Pfade zu anderen Dateien, einschließlich manifest.yml-Datei und Setup-Skript, sind relativ zum Speicherort dieser Datei.

Ändern oder ersetzen Sie den Inhalt der snowflake.yml-Datei wie folgt:

definition_version: 2
entities:
   hello_snowflake_package:
      type: application package
      stage: stage_content.hello_snowflake_stage
      manifest: app/manifest.yml
      artifacts:
         - src: app/*
           dest: ./
   hello_snowflake_app:
      type: application
      from:
         target: hello_snowflake_package
      debug: false
Copy

Im nächsten Abschnitt dieses Tutorials wird beschrieben, wie Sie jede dieser Eigenschaften verwenden können.

Zusammenfassung

Nachdem Sie die Schritte in diesem Abschnitt ausgeführt haben, sollten Sie nun eine Verzeichnisstruktur haben, die wie folgt aussieht:

/tutorial
  snowflake.yml
  README.md
  /app/
    manifest.yml
    README.md
    setup_script.sql
Copy

In diesem Abschnitt haben Sie gelernt, wie Sie das Setup-Skript und die Manifest-Dateien erstellen, die für das Snowflake Native App Framework erforderlich sind, sowie die Projektdefinitionsdatei, die für Snowflake CLI erforderlich ist.

Obwohl der Inhalt, den Sie zum Setup-Skript und zu Manifest-Datei hinzugefügt haben, nicht von Bedeutung ist, müssen alle Apps über diese Dateien verfügen.

Sie haben auch eine Readme-Datei hinzugefügt, die angezeigt wird, wenn Sie Ihre App in Snowsight anzeigen oder wenn Sie Ihre App als Freigabeangebot veröffentlichen.

Erläuterungen zur Projektdefinitionsdatei

In diesem Abschnitt erfahren Sie mehr über den Inhalt der Projektdefinitionsdatei (snowflake.yml), die Sie im vorherigen Abschnitt erstellt haben. Sie werden auch zusätzliche Einrichtungsaufgaben für Ihr Anbieterkonto ausführen.

Im Kern ist ein Anwendungspaket eine Snowflake-Datenbank, die um zusätzliche Informationen zu einer App erweitert wird. In diesem Sinne ist es ein Container für eine App, der Folgendes enthält:

  • Freigegebene Dateninhalte

  • Anwendungsdateien

Um ein Anwendungspaket zu erstellen, muss Ihre Rolle über die Berechtigung CREATE APPLICATION PACKAGE verfügen. Um diese Berechtigung mithilfe von Snowflake CLI zu erteilen, führen Sie den folgenden Befehl aus:

snow sql -q 'GRANT CREATE APPLICATION PACKAGE ON ACCOUNT TO ROLE accountadmin' -c connection_name
Copy

Dabei ist connection_name der Name der Verbindung, die Sie bei der Installation von Snowflake CLI in Ihrer config.toml-Datei angegeben haben.

Bemerkung

Obwohl die Rolle ACCOUNTADMIN standardmäßig über diese Berechtigung verfügt, müssen Sie sicherstellen, dass Ihrer Rolle diese Berechtigung zugewiesen wurde, damit Sie das Anwendungspaket erstellen können.

Die Projektdefinitionsdatei (snowflake.yml) definiert die Namen der Objekte, die in Ihrem Snowflake-Konto erstellt werden:

  • Das Anwendungspaket (hello_snowflake_package)

  • Das Anwendungsobjekt (hello_snowflake_app), das aus dem Anwendungspaket erstellt wird

  • Der Stagingbereich, der die Anwendungsdateien enthält (stage_content.hello_snowflake_stage)

Beachten Sie, dass der Name des Stagingbereichs als Schema-qualifizierter Name angegeben wird. Dieses Schema wird innerhalb des Anwendungspakets erstellt. In diesem benannten Stagingbereich werden die vom Snowflake Native App Framework benötigten Dateien gespeichert. Dieser Stagingbereich muss alle Dateien enthalten, die für das Setup-Skript Ihres App-Setup-Skripts oder zur Laufzeit verfügbar sein sollen.

In der Projektdefinitionsdatei gibt es auch einen Abschnitt namens artifacts, der eine Liste von Regeln enthält, die angeben, welche Dateien in den benannten Stagingbereich kopiert werden.

Die Regel legt fest, dass alles, was sich im Unterordner app/ befindet, in das Stammverzeichnis des Stagingbereichs kopiert wird. Das bedeutet Folgendes:

  • tutorial/app/manifest.yml wird in das Stammverzeichnis von @hello_snowflake_package.stage_content.hello_snowflake_stage hochgeladen.

  • tutorial/app/README.md wird in das Stammverzeichnis von @hello_snowflake_package.stage_content.hello_snowflake_stage hochgeladen.

  • tutorial/app/setup_script.sql wird in das Stammverzeichnis von @hello_snowflake_package.stage_content.hello_snowflake_stage hochgeladen.

Sie erstellen das Anwendungspaket noch nicht und führen auch keine SQL-Befehle aus, die diese Aufgaben ausführen. In einem späteren Abschnitt werden Sie den Snowflake CLI-Befehl verwenden, um diese Aufgaben auszuführen.

Schließlich legen Sie debug: false innerhalb der App-Definition fest. Für Anwendungen, die mit Snowflake CLI bereitgestellt werden, ist der Debug-Modus standardmäßig aktiviert.

In diesem Abschnitt haben Sie gelernt, dass ein Anwendungspaket ein Container für die von einer App verwendeten Ressourcen ist. Sie haben auch gelernt, wie Sie die Felder in der Projektdefinitionsdatei festlegen.

Anwendungslogik hinzufügen und die erste App installieren

In diesem Abschnitt fügen Sie dem Anwendungspaket Code hinzu und installieren Ihre erste App. Dazu werden Sie die folgenden Aufgaben ausführen:

  • Hinzufügen einer gespeicherten Prozedur zum Setup-Skript

  • App im Stagingbereichs-Entwicklungsmodus installieren und testen

Gespeicherte Prozedur zum Setup-Skript hinzufügen

In diesem Abschnitt fügen Sie der App eine gespeicherte Prozedur hinzu, indem Sie den Code für die gespeicherte Prozedur in das Setup-Skript in Ihrem lokalen Dateisystem einfügen.

So fügen Sie dem Setup-Skript eine gespeicherte Prozedur hinzu:

  1. Fügen Sie die folgenden SQL-Anweisungen am Ende der Datei setup_script.sql hinzu, die Sie in einem vorherigen Abschnitt des Tutorials erstellt haben:

    CREATE APPLICATION ROLE IF NOT EXISTS app_public;
    CREATE SCHEMA IF NOT EXISTS core;
    GRANT USAGE ON SCHEMA core TO APPLICATION ROLE app_public;
    
    Copy

    Wenn das Setup-Skript während der App-Installation ausgeführt wird, erstellen diese Anweisungen eine Anwendungsrolle namens app_public. Anwendungsrollen sind ähnlich wie Datenbankrollen, können aber nur im Kontext einer App verwendet werden. Sie werden verwendet, um innerhalb der Anwendung Zugriff auf Objekte zu gewähren, die im Verbraucherkonto erstellt werden.

    In diesem Beispiel wird außerdem ein Schema erstellt, das die gespeicherte Prozedur enthält, und der Anwendungsrolle die Berechtigung USAGE für das Schema erteilt. Das Erstellen einer Anwendungsrolle und das Zuweisen von Berechtigungen für ein Objekt, z. B. für ein Schema, an die Anwendungsrolle ist ein typisches Muster innerhalb eines Setup-Skripts.

  2. Fügen Sie den Code für die gespeicherte Prozedur am Ende der Datei setup_script.sql hinzu:

    CREATE OR REPLACE PROCEDURE CORE.HELLO()
      RETURNS STRING
      LANGUAGE SQL
      EXECUTE AS OWNER
      AS
      BEGIN
        RETURN 'Hello Snowflake!';
      END;
    
    Copy

    In diesem Beispiel wird eine gespeicherte Prozedur erstellt, die die Zeichenfolge „Hello Snowflake!“ ausgibt.

  3. Fügen Sie am Ende der Datei setup_script.sql die folgende Anweisung hinzu:

    GRANT USAGE ON PROCEDURE core.hello() TO APPLICATION ROLE app_public;
    
    Copy

    In diesem Beispiel wird der Anwendungsrolle die Berechtigung USAGE für die gespeicherte Prozedur zugewiesen.

In diesem Abschnitt haben Sie dem Setup-Skript eine gespeicherte Prozedur hinzugefügt. Sie haben außerdem eine Anwendungsrolle erstellt und dieser Rolle die USAGE-Berechtigung erteilt. Dadurch kann das Setup-Skript die gespeicherte Prozedur erstellen, wenn die App installiert wird. Außerdem wird der App dadurch die Berechtigung zum Ausführen der gespeicherten Prozedur erteilt.

App im Modus der Stagingbereichsentwicklung installieren und testen

Sie sind nun bereit, das Anwendungspaket, die App und alle anderen Entitäten zu erstellen, die Sie in der Projektdefinitionsdatei angegeben haben.

Um diese Aufgaben auszuführen, führen Sie den folgenden Snowflake CLI-Befehl aus:

snow app run -c connection_name
Copy

Dabei ist connection_name der Name der Verbindung, die Sie bei der Installation von Snowflake CLI in Ihrer config.toml-Datei angegeben haben.

Dieser Befehl führt die folgenden Aufgaben aus:

  1. Erstellen eines Anwendungspakets namens hello_snowflake_package mit dem Schema stage_content und dem Stagingbereich hello_snowflake_stage.

  2. Hochladen aller erforderlichen Dateien in den benannten Stagingbereich.

  3. Erstellen oder aktualisieren der App hello_snowflake_app unter Verwendung der Dateien aus diesem Stagingbereich.

Wenn der Befehl erfolgreich ausgeführt wird, gibt er eine URL aus, unter der Sie Ihre App in Snowsight anzeigen können. Führen Sie mit dem folgenden Snowflake CLI-Befehl die gespeicherte Prozedur HELLO aus, die Sie in einem vorherigen Abschnitt zu setup_script.sql hinzugefügt haben:

snow sql -q "call hello_snowflake_app.core.hello()" -c connection_name
Copy

Nach der Ausführung dieses Befehls sollten Sie die folgende Ausgabe sehen:

+------------------+
| HELLO            |
|------------------|
| Hello Snowflake! |
+------------------+
Copy

Zusammenfassung

Herzlichen Glückwunsch! Sie haben Ihre erste Snowflake Native App mit dem Snowflake Native App Framework erstellt, installiert und getestet! Obwohl die App nur über grundlegende Funktionen verfügt, sind die Komponenten, die Sie zum Erstellen der App verwendet haben, die gleichen wie bei komplexeren Apps.

In diesem Abschnitt haben Sie die folgenden Aufgaben ausgeführt:

  • Sie haben dem Setup-Skript eine gespeicherte Prozedur hinzugefügt. Das Setup-Skript legt fest, wie Ihre App im Verbraucherkonto installiert wird. In späteren Abschnitten werden Sie Dateninhalte und andere Typen von Anwendungslogik zu Ihrer App hinzufügen.

  • Sie haben Ihre App zum ersten Mal mit Snowflake CLI bereitgestellt.

  • Sie haben Ihre installierte App durch Ausführen einer gespeicherten Prozedur getestet.

In späteren Abschnitten werden Sie weitere Möglichkeiten kennenlernen, wie Sie Ihre App anzeigen und testen können.

Dateninhalte zur App hinzufügen

Im vorherigen Abschnitt haben Sie eine App mit einer gespeicherten Prozedur erstellt, die demonstriert, wie Sie einer App Anwendungslogik hinzufügen können.

In diesem Abschnitt werden Sie Dateninhalte in Ihre App einbinden, indem Sie eine Datenbank innerhalb des HELLO_SNOWFLAKE_PACKAGE-Anwendungspakets erstellen und Berechtigungen erteilen, um diese Datenbank für die App freizugeben.

Tabelle zur Freigabe für eine App erstellen

In diesem Abschnitt erfahren Sie, wie Sie Dateninhalte für eine App freigeben können. Konkret werden Sie eine Tabelle im Anbieterkonto freigeben, indem Sie dem Anwendungspaket Berechtigungen für das Schema und die Tabelle erteilen.

  1. So erstellen Sie eine Tabelle und fügen die Beispieldaten in das Anwendungspaket ein, erstellen einen Ordner tutorial/scripts und dann in dem Ordner eine Datei shared_content.sql: Fügen Sie die folgenden Inhalte zu dieser Datei hinzu:

    USE APPLICATION PACKAGE <% ctx.entities.hello_snowflake_package.identifier %>;
    
    CREATE SCHEMA IF NOT EXISTS shared_data;
    USE SCHEMA shared_data;
    CREATE TABLE IF NOT EXISTS accounts (ID INT, NAME VARCHAR, VALUE VARCHAR);
    TRUNCATE TABLE accounts;
    INSERT INTO accounts VALUES
      (1, 'Joe', 'Snowflake'),
      (2, 'Nima', 'Snowflake'),
      (3, 'Sally', 'Snowflake'),
      (4, 'Juan', 'Acme');
    -- grant usage on the ``ACCOUNTS`` table
    GRANT USAGE ON SCHEMA shared_data TO SHARE IN APPLICATION PACKAGE <% ctx.entities.hello_snowflake_package.identifier %>;
    GRANT SELECT ON TABLE accounts TO SHARE IN APPLICATION PACKAGE <% ctx.entities.hello_snowflake_package.identifier %>;
    
    Copy

    In diesem Beispiel ist <% ctx.entities.hello_snowflake_package.identifier %> eine Vorlage, die durch den aufgelösten Bezeichner Ihrer application package aus der Datei snowflake.yml ersetzt wird, wenn Sie einen Snowflake-CLI-Befehl ausführen.

    Wenn Sie diese Berechtigungen für die Objekte innerhalb des Anwendungspakets zuweisen, steht die Tabelle shared_data.accounts allen Anwendungen zur Verfügung, die über das Anwendungspaket installiert werden. Diese Freigabe erfolgt durch den Berechtigungsbefehl GRANT TO SHARE am Ende des Skripts.

    Bemerkung

    Sie müssen die USAGE-Berechtigung für jedes Schema innerhalb eines Anwendungspakets für jedes Schema erteilen, das Sie für einen Verbraucher in einer App freigeben möchten. Sie müssen dann die Berechtigung SELECT für die Objekte innerhalb des Schemas erteilen, die Sie freigeben möchten.

  2. Fügen Sie einen Eintrag zur Projektdefinitionsdatei hinzu, um sicherzustellen, dass dieses Skript ausgeführt wird, wenn Sie Ihr Anwendungspaket aktualisieren. Die endgültige Projektdefinitionsdatei sollte wie folgt aussehen:

    definition_version: 2
    entities:
       hello_snowflake_package:
          type: application package
          stage: stage_content.hello_snowflake_stage
          manifest: app/manifest.yml
          artifacts:
             - src: app/*
               dest: ./
          meta:
             post_deploy:
                - sql_script: scripts/shared_content.sql
       hello_snowflake_app:
          type: application
          from:
             target: hello_snowflake_package
          debug: false
    
    Copy

Bemerkung

Da das Skript direkt von Ihrem lokalen Computer aus ausgeführt wird, ist es nicht notwendig (und auch nicht empfehlenswert), den artifacts-Abschnitt Ihrer Projektdefinitionsdatei mit Post-Deploy-Hooks zu versehen.

Bemerkung

Da Post-Deploy-Hooks jedes Mal ausgeführt werden, wenn Sie eine App bereitstellen, müssen sie auf idempotente Weise geschrieben werden.

Ansicht für den Zugriff auf Dateninhalte hinzufügen

In diesem Abschnitt aktualisieren Sie das Setup-Skript, indem Sie eine Ansicht hinzufügen, mit der der Verbraucher, der die App installiert hat, auf die Daten in der Tabelle ACCOUNTS zugreifen kann, die Sie im vorherigen Unterabschnitt erstellt haben.

So fügen Sie eine Ansicht für den Zugriff auf Dateninhalte hinzu:

  1. Erstellen Sie ein Schema für die Ansicht, indem Sie dem Setup-Skript Folgendes hinzufügen:

    CREATE OR ALTER VERSIONED SCHEMA code_schema;
    GRANT USAGE ON SCHEMA code_schema TO APPLICATION ROLE app_public;
    
    Copy

    Mit diesen Anweisungen wird ein versioniertes Schema erstellt, das die Ansicht enthält, und die USAGE-Berechtigung für das Schema zugewiesen. Das Snowflake Native App Framework verwendet ein versioniertes Schema, um verschiedene Versionen von gespeicherten Prozeduren und Funktionen nutzen zu können.

  2. Erstellen Sie die Ansicht, indem Sie dem Setup-Skript Folgendes hinzufügen:

    CREATE VIEW IF NOT EXISTS code_schema.accounts_view
      AS SELECT ID, NAME, VALUE
      FROM shared_data.accounts;
    GRANT SELECT ON VIEW code_schema.accounts_view TO APPLICATION ROLE app_public;
    
    Copy

    Mit diesen Anweisungen wird die Ansicht im Schema code_schema erstellt und der Anwendungsrolle die erforderliche Berechtigung für die Ansicht zugewiesen.

    Dieses aktualisierte Setup-Skript wird auch in den Stagingbereich hochgeladen, wenn Sie Ihre App das nächste Mal mit Snowflake CLI bereitstellen.

Aktualisierte App testen

In diesem Unterabschnitt werden Sie die App aktualisieren und die Beispieltabelle mithilfe der Ansicht innerhalb der installierten Anwendung abfragen.

Um die aktualisierte App zu testen, gehen Sie wie folgt vor:

  1. Um das Anwendungspaket und das im Verbraucherkonto installierte Anwendungsobjekt zu aktualisieren, führen Sie den folgenden Befehl aus:

    snow app run -c connection_name
    
    Copy

    Dabei ist connection_name der Name der Verbindung, die Sie bei der Installation von Snowflake CLI in Ihrer config.toml-Datei angegeben haben.

    Damit werden alle bearbeiteten Dateien in den Stagingbereich hochgeladen, das Skript scripts/shared_content.sql ausgeführt und die App mit diesen Dateien im Stagingbereich aktualisiert.

  2. Überprüfen Sie, ob die Ansicht korrekt funktioniert, indem Sie den folgenden Befehl ausführen:

    snow sql -q "SELECT * FROM hello_snowflake_app.code_schema.accounts_view" -c connection_name
    
    Copy

    Die Ausgabe dieses Befehls sollte wie folgt sein:

    +----+----------+-----------+
    | ID | NAME     | VALUE     |
    |----+----------+-----------|
    |  1 | Joe      | Snowflake |
    |  2 | Nima     | Snowflake |
    |  3 | Sally    | Snowflake |
    |  4 | Juan     | Acme      |
    +----+----------+-----------+
    
    Copy

Zusammenfassung

In diesem Abschnitt haben Sie gelernt, wie Sie freigegebene Dateninhalte in Ihre App einbinden können, indem Sie die folgenden Aufgaben ausgeführt haben:

  • Tabelle ACCOUNTS im Anwendungspaket erstellt und Daten in die Tabelle eingefügt.

  • Referenznutzungsberechtigung für die Tabelle ACCOUNTS zum Anwendungspaket hinzugefügt.

  • Schema und Ansicht erstellt, die auf die Tabelle ACCOUNTS im Anwendungspaket verweisen.

  • Nutzungsberechtigung für das Schema zur Anwendungsrolle hinzugefügt.

  • Select-Berechtigung für die Ansicht zur Anwendungsrolle hinzugefügt.

Sie haben außerdem das Setup-Skript aktualisiert, um bei der Installation der Anwendung Folgendes auszuführen:

  • Schema und Ansicht hinzugefügt, die die App für den Zugriff auf die Beispieldaten verwendet.

  • Nutzungsberechtigung für das Schema zur Anwendungsrolle hinzugefügt.

  • Select-Berechtigung für die Ansicht zur Anwendungsrolle hinzugefügt.

Python-Code zur App hinzufügen

In diesem Abschnitt werden Sie die Funktionalität Ihrer App erweitern, indem Sie Python-Code hinzufügen, um die Anwendungslogik zu erweitern. In diesem Abschnitt werden Sie Python-Code in folgender Form einfügen:

  • Als Inline-Python-UDF, die im Setup-Skript eine eigenständige Funktion ist.

  • Als Python-UDF, die auf eine Python-Datei außerhalb des Setup-Skripts verweist.

Bemerkung

Obwohl in diesem Abschnitt Beispiele mit Python vorgestellt werden, können bei diesen Verfahren auch Java und JavaScript genutzt werden.

Inline-Python-Funktion als benutzerdefinierte Funktion (UDF) hinzufügen

In diesem Abschnitt werden Sie eine Python-Funktion als UDF hinzufügen.

Um eine Python-UDF in Ihre App einzubinden, fügen Sie den folgenden Code in Ihre Setup-Datei ein:

CREATE OR REPLACE FUNCTION code_schema.addone(i int)
RETURNS INT
LANGUAGE PYTHON
RUNTIME_VERSION = '3.11'
HANDLER = 'addone_py'
AS
$$
def addone_py(i):
  return i+1
$$;

GRANT USAGE ON FUNCTION code_schema.addone(int) TO APPLICATION ROLE app_public;
Copy

Mit diesen Befehlen werden die folgenden Aufgaben bei Installation der App ausgeführt:

  • Erstellen eines versioniertes Schemas namens code_schema

  • Zuweisen der Nutzungsberechtigung für das Schema zur Anwendungsrolle APP_PUBLIC

  • Erstellen der UDF ADDONE() im Schema code_schema

  • Zuweisen der Nutzungsberechtigung für die Funktion zur Anwendungsrolle APP_PUBLIC

Beachten Sie, dass das im obigen Codebeispiel erstellte Schema ein versioniertes Schema ist. Benutzerdefinierte Funktionen und gespeicherte Prozeduren müssen in einem versionierten Schema anstelle eines normalen Schemas definiert werden. Dadurch wird verhindert, dass App-Upgrades die parallele Ausführung von Code beeinträchtigen.

Externes Python-Modul hinzufügen

So fügen Sie ein externes Python-Modul zu Ihrer App hinzu:

  1. Fügen Sie die folgende Python-Funktion zu Ihrem Setup-Skript hinzu:

    CREATE or REPLACE FUNCTION code_schema.multiply(num1 float, num2 float)
      RETURNS float
      LANGUAGE PYTHON
      RUNTIME_VERSION = 3.9
      IMPORTS = ('/python/hello_python.py')
      HANDLER='hello_python.multiply';
    
    GRANT USAGE ON FUNCTION code_schema.multiply(FLOAT, FLOAT) TO APPLICATION ROLE app_public;
    
    Copy

    Ähnlich wie im vorherigen Beispiel werden mit diesen Anweisungen eine Python-UDF in einem Schema erstellt und der Anwendungsrolle Berechtigungen für die Funktion erteilt. Dieses Beispiel enthält jedoch eine IMPORTS-Klausel, die auf eine externe Python-Datei verweist, die Sie erstellen und in Ihren benannten Stagingbereich einbinden werden.

  2. Erstellen Sie im Ordner tutorial einen Unterordner namens python.

  3. Erstellen Sie im Unterordner python eine Datei namens hello_python.py.

  4. Fügen Sie der Datei hello_python.py Folgendes hinzu:

    def multiply(num1, num2):
      return num1*num2
    
    Copy

    Die in dieser externen Datei definierte Funktion entspricht der im Setup-Skript definierten Inline-Funktion.

  5. Fügen Sie dem bestehenden Abschnitt artifacts der Projektdefinitionsdatei Folgendes hinzu:

    - python/hello_python.py
    
    Copy

In diesem Abschnitt haben Sie eine Python-UDF zu Ihrer App hinzugefügt. Diese UDF verweist auf ein externes Python-Modul, das von Ihrem Anwendungspaket referenziert werden kann.

Aktualisierte App installieren und testen

So installieren und testen Sie eine App:

  1. Um das Anwendungspaket und die App zu aktualisieren, führen Sie den folgenden Befehl aus:

    snow app run -c connection_name
    
    Copy

    Dabei ist connection_name der Name der Verbindung ist, die Sie bei der Installation von Snowflake CLI in Ihrer config.toml angegeben haben.

    Mit diesem Befehl werden die bearbeiteten und die neuen Dateien in den Stagingbereich hochgeladen und Ihre App wird mit den Dateien im Stagingbereich aktualisiert.

  2. Testen Sie die gespeicherte Python-Prozedur, indem Sie den folgenden Befehl ausführen:

    snow sql -q "SELECT hello_snowflake_app.code_schema.addone(1)" -c connection_name
    
    Copy
  3. Testen Sie die referenzierte Python-Funktion, indem Sie den folgenden Befehl ausführen:

    snow sql -q "SELECT hello_snowflake_app.code_schema.multiply(1,2)" -c connection_name
    
    Copy

Zusammenfassung

In diesem Abschnitt haben Sie die folgende neue Funktionalität zu Ihrer App hinzugefügt:

  • Eine Python-Funktion, die als Inline-UDF definiert ist.

  • Eine Python-Funktion, die als UDF definiert ist, die wiederum auf externen Code verweist.

Sie haben außerdem jedes dieser Beispiele getestet, indem Sie eine aktualisierte Version Ihrer App installiert und jede Funktion ausgeführt haben.

Streamlit-App zu Ihrer App hinzufügen

In diesem Abschnitt vervollständigen Sie Ihre Snowflake Native App, indem Sie eine Streamlit-Benutzeroberfläche hinzufügen. Streamlit ist ein Open-Source-Python-Framework für die Entwicklung von Anwendungen für Data Science und maschinelles Lernen. Sie können Streamlit-Apps in eine App integrieren, um Benutzerinteraktion und Datenvisualisierung hinzuzufügen.

Streamlit-App-Datei erstellen

Um eine Streamlit-App zu erstellen, gehen Sie wie folgt vor:

  1. Erstellen Sie im Ordner tutorial einen Unterordner namens streamlit.

  2. Erstellen Sie im Ordner streamlit eine Datei namens hello_snowflake.py.

  3. Fügen Sie den folgenden Code zu dieser Datei hinzu:

    # Import python packages
    import streamlit as st
    from snowflake.snowpark import Session
    
    # Write directly to the app
    st.title("Hello Snowflake - Streamlit Edition")
    st.write(
       """The following data is from the accounts table in the application package.
          However, the Streamlit app queries this data from a view called
          code_schema.accounts_view.
       """
    )
    
    # Get the current credentials
    session = Session.builder.getOrCreate()
    
    #  Create an example data frame
    data_frame = session.sql("SELECT * FROM code_schema.accounts_view")
    
    # Execute the query and convert it into a Pandas data frame
    queried_data = data_frame.to_pandas()
    
    # Display the Pandas data frame as a Streamlit data frame.
    st.dataframe(queried_data, use_container_width=True)
    
    Copy
  4. Fügen Sie dem bestehenden Abschnitt artifacts der Projektdefinitionsdatei Folgendes hinzu:

    - streamlit/hello_snowflake.py
    
    Copy

Streamlit-Objekt zum Setup-Skript hinzufügen

Um das Streamlit-Objekt in der App zu erstellen, gehen Sie wie folgt vor:

  1. Fügen Sie die folgende Anweisung am Ende der Datei setup_script.sql hinzu, um das Streamlit-Objekt zu erstellen:

    CREATE STREAMLIT IF NOT EXISTS code_schema.hello_snowflake_streamlit
      FROM '/streamlit'
      MAIN_FILE = '/hello_snowflake.py'
    ;
    
    Copy

    Diese Anweisung erstellt ein STREAMLIT-Objekt im Hauptschema.

  2. Fügen Sie die folgende Anweisung am Ende der Datei setup_script.sql hinzu, um der Rolle APP_PUBLIC den Zugriff auf das Streamlit-Objekt zu ermöglichen:

    GRANT USAGE ON STREAMLIT code_schema.hello_snowflake_streamlit TO APPLICATION ROLE app_public;
    
    Copy

Aktualisierte App installieren

  1. Um das Anwendungspaket und die App zu aktualisieren, führen Sie den folgenden Befehl aus:

    snow app run -c connection_name
    
    Copy

    Dabei ist connection_name der Name der Verbindung, die Sie bei der Installation von Snowflake CLI in Ihrer config.toml-Datei angegeben haben.

    Mit diesem Befehl werden die bearbeiteten und die neuen Dateien in den Stagingbereich hochgeladen und Ihre App wird mit den Dateien im Stagingbereich aktualisiert. Sie können dann zu der URL navigieren, die dieser Befehl ausgibt, um Ihr neues Streamlit in Aktion zu sehen. Sobald Sie dort sind, klicken Sie auf die Registerkarte HELLO_SNOWFLAKE_STREAMLIT, die neben dem Namen Ihrer Anwendung angezeigt wird.

Zusammenfassung

In diesem Abschnitt haben Sie eine Streamlit-App zu Ihrer Snowflake Native App hinzugefügt, indem Sie folgende Schritte ausgeführt haben:

  • Python-Datei erstellt, die die Streamlit-Bibliothek zum Rendern einer Benutzeroberfläche verwendet.

  • Streamlit-App in Ihrer Snowflake Native App erstellt, die freigegebene Daten anzeigt.

Version zur App hinzufügen

In den vorherigen Abschnitten haben Sie einen Modus der „Stagingbereichsentwicklung“ verwendet, um Änderungen vorzunehmen. Der Modus der Stagingbereichsentwicklung ermöglicht es Ihnen, die Entwicklung einer App schnell zu iterieren, ohne neue Versionen oder Patches erstellen zu müssen. Sie müssen jedoch eine Version der App erstellen, um Ihr Anwendungspaket aufzulisten und es für andere Benutzer von Snowflake freizugeben.

In diesem Abschnitt fügen Sie eine Version zu Ihrer App hinzu, die die gesamte Funktionalität enthält, die Sie in diesem Tutorial hinzugefügt haben.

  1. Fügen Sie eine Version zum Anwendungspaket HELLO_SNOWFLAKE_PACKAGE hinzu, indem Sie den folgenden Befehl ausführen:

    snow app version create v1_0 -c connection_name
    
    Copy

    Mit diesem Befehl haben Sie Ihr Anwendungspaket geändert, um eine Version hinzuzufügen, die auf den Anwendungsdateien basiert, die Sie in einem vorherigen Abschnitt in den benannten Stagingbereich hochgeladen haben.

    Bemerkung

    Der für VERSION angegebene Wert ist ein Bezeichner, d. h. kein numerischer Wert und keine Zeichenfolge.

    Bemerkung

    Die Patchnummer der neuen Version, die Sie hinzugefügt haben, ist automatisch 0. Wenn Sie weitere Patches für eine Version hinzufügen, werden diese automatisch hochgezählt. Wenn Sie jedoch eine neue Version erstellen, zum Beispiel V1_1, wird die Patchnummer dieser Version auf 0 zurückgesetzt.

  2. Überprüfen Sie, ob die Version zum Anwendungspaket hinzugefügt wurde, indem Sie den folgenden Befehl ausführen:

    snow app version list -c connection_name
    
    Copy

    Dieser Befehl zeigt zusätzliche Informationen zu der Version an, wie in der folgenden Ausgabe gezeigt:

    +---------+-------+-------+---------+-------------------------------+------------+-----------+-------------+-------+---------------+
    | version | patch | label | comment | created_on                    | dropped_on | log_level | trace_level | state | review_status |
    |---------+-------+-------+---------+-------------------------------+------------+-----------+-------------+-------+---------------|
    | V1_0    |     0 | NULL  | NULL    | 2024-05-09 10:33:39.768 -0700 | NULL       | OFF       | OFF         | READY | NOT_REVIEWED  |
    +---------+-------+-------+---------+-------------------------------+------------+-----------+-------------+-------+---------------+
    
    Copy
  3. Installieren Sie die App auf Basis einer Version, indem Sie den folgenden Befehl ausführen:

    snow app run --version V1_0 -c connection_name
    
    Copy

    Da die vorhandene App mit Dateien im benannten Stagingbereich erstellt wurde, muss beim Upgrade der App mit einer Version die vorhandene App gelöscht und mit dieser Version neu erstellt werden. Beantworten Sie die Aufforderung entsprechend mit „Yes“ (Ja).

In diesem Abschnitt haben Sie das Anwendungspaket so geändert, dass es eine Version für Ihre App enthält, und das Anwendungsobjekt im versionierten Entwicklungsmodus neu erstellt.

App in Snowsight anzeigen

In diesem Abschnitt werden Sie Ihre App in Snowsight anzeigen. In den vorherigen Abschnitten haben Sie SQL-Anweisungen verwendet, um Ihre Anwendung zu testen oder Informationen zu Ihrer App zu suchen. Sie können aber Informationen zu Ihrer App auch in Snowsight anzeigen. Sie können außerdem Ihre bereitgestellte Streamlit-App anzeigen.

Gehen Sie wie folgt vor, um Ihre App in Snowsight anzuzeigen:

  1. Melden Sie sich bei Snowsight an.

  2. Wechseln Sie in die Rolle ACCOUNTADMIN, indem Sie wie folgt vorgehen:

    1. Wählen Sie im Navigationsmenü Ihren Benutzernamen aus, um das Kontomenü zu öffnen.

    2. Wählen Sie die aktive Rolle. Beispiel: PUBLIC.

      Die Rollenauswahl wird angezeigt.

    3. Wählen Sie die Rolle ACCOUNTADMIN aus.

  3. Wählen Sie Data Products » Apps aus.

  4. Wählen Sie HELLO_SNOWFLAKE_APP aus.

    Die Registerkarte Read Me zeigt den Inhalt an, den Sie in einem vorherigen Abschnitt zur Datei app/README.md hinzugefügt haben.

  5. Um Ihre Streamlit-App anzuzeigen, wählen Sie HELLO_SNOWFLAKE_STREAMLIT aus.

    Der Inhalt der Datenbank HELLO_SNOWFLAKE_DATA wird in einem Streamlit-DataFrame angezeigt.

  6. Um die App in einem Arbeitsblatt zu öffnen, wählen Sie Projects » Worksheets.

  7. Wählen Sie HELLO_SNOWFLAKE_APP aus der Auflistung der Arbeitsblätter.

  8. Wenn notwendig, wählen Sie das Warehouse aus, in dem Sie die App installiert haben.

Vom Snowflake-Arbeitsblatt aus können Sie Ihre App mit SQL-Befehlen testen. Sie können zum Beispiel die Befehle, die Sie in den vorherigen Abschnitten ausgeführt haben, erneut ausführen, um die Features zu testen, die Sie Ihrer Anwendung hinzugefügt haben:

LIST @hello_snowflake_package.stage_content.hello_snowflake_stage;
CALL core.hello();
SELECT * FROM code_schema.accounts_view;
SELECT code_schema.addone(10);
SELECT code_schema.multiply(2,3);
Copy

Bemerkung

Alle SQL-Anweisungen, die Sie zu diesem Arbeitsblatt hinzufügen, gehen verloren, wenn Sie in Snowsight zu einer anderen Seite navigieren.

Bemerkung

Sie können die Benutzeroberfläche Ihrer App auch direkt anzeigen, indem Sie den Befehl snow app open in Snowflake CLI verwenden. Dieser Befehl öffnet die entsprechende URL in Ihrem systemkonfigurierten Webbrowser.

App veröffentlichen und installieren

In diesem Abschnitt werden Sie Ihre App veröffentlichen, indem Sie ein privates Freigabeangebot erstellen, das das Anwendungspaket als Dateninhalt verwendet. Nachdem Sie das Freigabeangebot erstellt haben, melden Sie sich bei einem anderen Konto an, um das Freigabeangebot zu installieren.

Standard-Release-Richtlinie festlegen

Bevor Sie ein Freigabeangebot für Ihr Anwendungspaket erstellen können, müssen Sie die Release-Richtlinie festlegen. Eine Release-Richtlinie gibt an, welche Version Ihrer App für Verbraucher verfügbar sind.

In diesem Tutorial werden Sie die Standard-Freigaberichtlinie anhand der Version festlegen, die Sie in einem vorherigen Abschnitt hinzugefügt haben.

Um die Standard-Freigaberichtlinie für Ihr Anwendungspaket festzulegen, gehen Sie wie folgt vor:

  1. Zeigen Sie die für Ihr Anwendungspaket definierten Versionen und Patches an, indem Sie den folgenden Befehl ausführen:

    snow app version list -c connection_name
    
    Copy

    Mit diesem Befehl werden die für das Anwendungspaket definierten Versionen und Patches angezeigt.

  2. Legen Sie für die Standard-Freigaberichtlinie die Version v1_0 und den Patch 0 fest, indem Sie den folgenden Befehl ausführen:

    snow sql -q "ALTER APPLICATION PACKAGE hello_snowflake_package SET DEFAULT RELEASE DIRECTIVE VERSION = v1_0 PATCH = 0"
    
    Copy

    Die Ausgabe dieses Befehls sehen Sie im folgenden Beispiel:

    +-----------------------------------------------------------+
    | status                                                    |
    |-----------------------------------------------------------|
    | Default release directive set to version 'V1_0', patch 0. |
    +-----------------------------------------------------------+
    
    Copy

In diesem Abschnitt haben Sie überprüft, welche Versionen und Patches in Ihrem Anwendungspaket vorhanden sind. Mit diesen Informationen haben Sie die Standard-Freigaberichtlinie für das Anwendungspaket definiert.

Freigabeangebot für App erstellen

Nachdem Sie eine Release-Richtliniefür Ihr Anwendungspaket angegeben haben, erstellen Sie ein Freigabeangebot und fügen das Anwendungspaket als Dateninhalt zum Freigabeangebot hinzu. Auf diese Weise können Sie Ihre App für andere Snowflake-Benutzer freigeben und ihnen die Installation und Nutzung der App im eigenen Konto ermöglichen.

So erstellen Sie ein Freigabeangebot für Ihre App:

  1. Melden Sie sich bei Snowsight an.

  2. Wählen Sie im Navigationsmenü die Option Data Products » Provider Studio aus.

  3. Wählen Sie + Listing aus. Das Fenster „Freigabeangebot erstellen“ wird geöffnet.

  4. Geben Sie einen Namen für Ihr Freigabeangebot ein.

  5. Wählen Sie im Bereich In the Who can discover the listing die Option Only specified consumers aus, um das Freigabeangebot bestimmten Konten privat bereitzustellen.

  6. Klicken Sie auf + Select, um das Anwendungspaket für das Freigabeangebot auszuwählen.

  7. Geben Sie eine Beschreibung zu Ihrem Freigabeangebot ein.

  8. Fügen Sie im Bereich Add consumer accounts den Kontobezeichner für das Konto hinzu, das Sie verwenden, um das Installieren der App aus einem Freigabeangebot aus Sicht eines Verbrauchers zu testen.

In diesem Abschnitt haben Sie ein privates Freigabeangebot erstellt, das Ihr Anwendungspaket als freigegebenen Dateninhalt enthält.

App in einem Verbraucherkonto installieren

In diesem Abschnitt installieren Sie die App, die zu dem im vorherigen Abschnitt erstellten Freigabeangebot gehört. Sie werden das Freigabeangebot in einem anderen Konto installieren, das nachahmt, wie ein Verbraucher die App in seinem Konto installieren würde.

Um Ihre App aus dem Freigabeangebot zu installieren, gehen Sie wie folgt vor:

  1. Melden Sie sich bei Snowsight an.

  2. Wählen Sie im Navigationsmenü die Option Data Products » Apps aus.

  3. Wählen Sie unter Recently shared with you die Kachel Ihres Freigabeangebots aus.

  4. Wählen Sie Get aus.

  5. Geben Sie für die App einen Namen ein, der dem Kunden angezeigt wird. Für dieses Tutorial verwenden Sie „Hello Snowflake App“.

  6. Wählen Sie das Warehouse aus, in dem Sie die App installieren möchten.

  7. Wählen Sie Get aus.

  8. Wählen Sie Open aus, um Ihr Freigabeangebot anzuzeigen, oder Done, um den Vorgang abzuschließen.

In diesem Abschnitt haben Sie gelernt, wie Sie ein Freigabeangebot veröffentlichen und installieren, das es Ihnen ermöglicht, Ihre App für andere Snowflake-Benutzern freizugeben.

Mehr erfahren

Herzlichen Glückwunsch! Sie haben nicht nur dieses Tutorial abgeschlossen, sondern auch den Lebenszyklus von Entwicklung und Veröffentlichung einer App mit dem Snowflake Native App Framework durchlaufen.

Auf dem Weg dorthin, haben Sie folgende Aufgaben ausgeführt: