Tutorial: Entwickeln einer Anwendung mit dem Native Apps Framework

Einführung

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

In dem Tutorial wird die Weboberfläche Snowsight verwendet, aber Sie können jeden Snowflake-Client verwenden, der die Ausführung von SQL wie z. B. SnowSQL unterstützt.

Lerninhalte

In diesem Tutorial erfahren Sie Folgendes:

  • Erstellen eines Anwendungspakets, das die Daten und die Geschäftslogik Ihrer Anwendung enthält

  • Freigeben von Daten für ein Anwendungspaket

  • Hinzufügen von Geschäftslogik zu einem Anwendungspaket

  • Lokales Testen der Anwendung

  • Anzeigen und Testen der Anwendung in Snowsight

  • Veröffentlichen der Anwendung durch Erstellen eines privaten Freigabeangebots

  • Installieren der Anwendung aus einem privaten Freigabeangebot

Allgemeine Informationen zu Anbietern und Verbrauchern

Im Kontext des Native Apps Frameworks 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 Anwendung ausführen.

Voraussetzungen

  • 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 Anwendung 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 Anwendung installieren.

    Bemerkung

    Obwohl das Native Apps Framework das Freigeben von Anwendungen 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 vor Durchführung des Tutorials ein aktuelles Warehouse festlegen. Für eine Sitzung muss ein Warehouse angegeben werden, und das Warehouse muss ausgeführt werden, bevor Abfragen und andere DML-Anweisungen in der Sitzung ausgeführt werden können. Weitere Informationen dazu finden Sie unter USE WAREHOUSE.

Anwendungsdateien erstellen

In diesem Abschnitt werden Sie ein Setup-Skript und eine Manifest-Datei erstellen. Diese beiden Dateien sind für das Native Apps Framework erforderlich.

Setup-Skript

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

Manifest-Datei

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

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

Setup-Skript erstellen

Um das Setup-Skript zu erstellen, gehen Sie wie folgt vor:

  1. Erstellen Sie in Ihrem lokalen Dateisystem einen Ordner mit dem Namen tutorial. Dies wird das Stammverzeichnis für die externen Dateien Ihrer Anwendung sein.

    Bemerkung

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

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

  3. Erstellen Sie in diesem Ordner eine neue Datei namens setup.sql.

    Bemerkung

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

  4. Fügen Sie zu dieser Datei die folgende SQL-Anweisung hinzu:

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

Diese Zeile wird als Platzhalter eingefügt, da das Setup-Skript nicht leer sein darf.

README-Datei für die Anwendung erstellen

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

So erstellen Sie die Datei „readme.md“ für Ihre Anwendung:

  1. Erstellen Sie im Ordner tutorial eine Datei namens readme.md.

  2. Fügen Sie den folgenden Inhalt zu dieser Datei hinzu:

    This is the readme file for the Hello Snowflake Application!
    
    Copy

Manifest-Datei erstellen

Das Native Apps Framework erfordert für jede Anwendung eine Manifest-Datei. Die Manifest-Datei enthält Metadaten und Konfigurationsparameter einer Anwendung.

So erstellen Sie die Manifest-Datei:

  1. Erstellen Sie im Ordner tutorial eine Datei namens manifest.yml.

    Bemerkung

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

  2. Fügen Sie den folgenden Inhalt zu dieser Datei hinzu:

    manifest_version: 1
    artifacts:
      setup_script: scripts/setup.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 Speicherort des oben erstellten Setup-Skripts übereinstimmen.

    Bemerkung

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

Zusammenfassung

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

/tutorial
  manifest.yml
  readme.md
  /scripts/
    setup.sql
Copy

In diesem Abschnitt haben Sie gelernt, wie Sie das Setup-Skript und die Manifest-Dateien erstellen, die für das Native Apps Framework erforderlich sind. Obwohl der Inhalt, den Sie zu diesen beiden Dateien hinzugefügt haben, nicht von Bedeutung ist, müssen alle Anwendungen über diese Dateien verfügen.

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

Anwendungspaket erstellen

In diesem Abschnitt werden Sie ein Anwendungspaket erstellen, das als Container für die von Ihrer Anwendung benötigten Ressourcen dient. Sie werden die folgenden Aufgaben ausführen:

  • Erstellen eines Anwendungspakets

  • Erstellen eines benannten Stagingbereichs innerhalb des Anwendungspakets

Anwendungspaket erstellen

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

  • Freigegebene Dateninhalte

  • Anwendungsdateien

So erstellen Sie ein Anwendungspaket:

  1. Um Ihrer Rolle die Berechtigung CREATE APPLICATION PACKAGE zu erteilen, führen Sie den folgenden Befehl aus:

    GRANT CREATE APPLICATION PACKAGE ON ACCOUNT TO ROLE accountadmin;
    
    Copy

    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.

  2. Um das Anwendungspaket zu erstellen, führen Sie den folgenden Befehl aus:

    CREATE APPLICATION PACKAGE hello_snowflake_package;
    
    Copy

    Bemerkung

    Nachdem Sie diesen Befehl ausgeführt haben, ändert sich der aktuelle Kontext in HELLO_SNOWFLAKE_PACKAGE.

  3. Um zu überprüfen, ob das Anwendungspaket erfolgreich erstellt wurde, führen Sie den folgenden Befehl aus:

    SHOW APPLICATION PACKAGES;
    
    Copy

    In der Spalte name der Ausgabe sollte HELLO_SNOWFLAKE_PACKAGE angezeigt werden. Weitere Informationen zu diesem Befehl finden Sie unter SHOW APPLICATION PACKAGES.

In diesem Abschnitt haben Sie gelernt, dass ein Anwendungspaket ein Container für die von einer Anwendung verwendeten Ressourcen ist. Sie haben auch gelernt, wie Sie ein Anwendungspaket erstellen.

Benannten Stagingbereich erstellen

In diesem Abschnitt erstellen Sie einen benannten Stagingbereich, in dem die vom Native Apps Framework benötigten Dateien gespeichert werden. Ein benannter Stagingbereich wird außerdem zum Speichern aller externen Codedateien benötigt, die Sie in die Anwendung einbinden möchten. Wenn Sie diese Dateien in einen benannten Stagingbereich hochladen, stehen sie beim Erstellen der Anwendung zur Verfügung.

Um mit einen benannten Stagingbereich zu erstellen, gehen Sie wie folgt vor:

  1. Um als Kontext das Anwendungspaket festzulegen, das Sie im vorherigen Abschnitt erstellt haben, führen Sie den folgenden Befehl aus:

    USE APPLICATION PACKAGE hello_snowflake_package;
    
    Copy
  2. Um das erforderliche Schema für den benannten Stagingbereich zu erstellen, führen Sie den folgenden Befehl aus:

    CREATE SCHEMA stage_content;
    
    Copy
  3. Um den benannten Stagingbereich zu erstellen, führen Sie den folgenden Befehl aus.

    CREATE OR REPLACE STAGE hello_snowflake_package.stage_content.hello_snowflake_stage
      FILE_FORMAT = (TYPE = 'csv' FIELD_DELIMITER = '|' SKIP_HEADER = 1);
    
    Copy

    Dieser Befehl erstellt den benannten Stagingbereich in der Datenbank und dem Schema, die Sie in den vorherigen Schritten erstellt haben.

    Bemerkung

    Sie müssen FILE_FORMAT = (TYPE = 'CSV' FIELD_DELIMITER = '|' SKIP_HEADER = 1); als Teil dieses Befehls angeben. Diese Angaben sind nicht optional.

Sie verfügen nun innerhalb des Anwendungspakets über einen benannten Stagingbereich, in den Sie die Dateien hochladen können, die Sie zum Erstellen der Anwendung verwenden werden.

Bemerkung

Obwohl in diesem Tutorial ein benannter Stagingbereich innerhalb des Anwendungspakets verwendet wird, ist dies nicht zwingend erforderlich. Sie können auch einen benannten Stagingbereich verwenden, der sich in einer Datenbank und einem Schema außerhalb des Anwendungspakets befindet.

Anwendungsdateien in den benannten Stagingbereich hochladen

Im vorigen Abschnitt haben Sie ein Anwendungspaket erstellt, das als Container für Ihre Anwendung dienen wird. Sie haben auch einen benannten Stagingbereich innerhalb des Anwendungspakets erstellt, der die erforderlichen Anwendungsdateien aufnehmen wird.

In diesem Abschnitt laden Sie diese Dateien in den benannten Stagingbereich hoch.

Führen Sie einen der folgenden Schritte aus, um die Anwendungsdateien hochzuladen:

  • Laden Sie die Anwendungsdateien über Snowsight hoch, wie unter Bereitstellen von Dateien im Stagingbereich mit Snowsight beschrieben.

  • Laden Sie die Anwendungsdateien mit SnowSQL hoch, indem Sie die folgenden Befehle ausführen:

    PUT file:///<path_to_your_root_folder>/tutorial/manifest.yml @hello_snowflake_package.stage_content.hello_snowflake_stage overwrite=true auto_compress=false;
    PUT file:///<path_to_your_root_folder>/tutorial/scripts/setup.sql @hello_snowflake_package.stage_content.hello_snowflake_stage/scripts overwrite=true auto_compress=false;
    PUT file:///<path_to_your_root_folder>/tutorial/readme.md @hello_snowflake_package.stage_content.hello_snowflake_stage overwrite=true auto_compress=false;
    
    Copy

    Bemerkung

    Ändern Sie den Pfad in den obigen Beispielen gemäß dem Pfad zum Stammordner Ihres Projekts.

Führen Sie in Ihrem Arbeitsblatt den folgenden Befehl aus, um zu überprüfen, ob das Hochladen der Datei erfolgreich war:

LIST @hello_snowflake_package.stage_content.hello_snowflake_stage;
Copy

Nachdem Sie diesen Befehl ausgeführt haben, sollten jede Datei wie in der folgenden Ausgabe angezeigt werden:

+----------------------------------------+------+----------------------------------+-------------------------------+
| name                                   | size | md5                              | last_modified                 |
|----------------------------------------+------+----------------------------------+-------------------------------|
| hello_snowflake_stage/manifest.yml      |   80 | 9acab2ba718eebfa5f98f4e95c822db6 | Mon, 29 May 2023 22:51:04 GMT |
| hello_snowflake_stage/readme.md         |   64 | 1bc95f95109dc60a09b478dd95c31808 | Mon, 29 May 2023 22:51:05 GMT |
| hello_snowflake_stage/scripts/setup.sql |   64 | 7807ee1f2f27312799fc83c66ba775cf | Mon, 29 May 2023 22:51:04 GMT |
+----------------------------------------+------+----------------------------------+-------------------------------+
Copy

In diesem Abschnitt haben Sie die Anwendungsdateien in einen benannten Stagingbereich hochgeladen. Diese Dateien sind nun für das Anwendungspaket verfügbar, während Sie mit der Entwicklung Ihrer Anwendung fortfahren. In späteren Abschnitten, wenn Sie Ihrer Anwendung Features hinzufügen, werden Sie zu diesem Abschnitt zurückkehren, um überarbeitete Versionen dieser Dateien und neue Dateien hochzuladen.

Anwendungslogik hinzufügen und die erste Anwendung installieren

In diesem Abschnitt werden Sie Code hinzufügen und Ihre erste Anwendung installieren. Dazu werden Sie die folgenden Aufgaben ausführen:

  • Hinzufügen einer gespeicherten Prozedur zum Setup-Skript

  • Hinzufügen einer Version zu der Anwendung

  • Installieren und Testen der Anwendung

Gespeicherte Prozedur zum Setup-Skript hinzufügen

Im vorherigen Abschnitt haben Sie ein Anwendungspaket erstellt. Das Anwendungspaket enthält jedoch noch keine Dateninhalte oder Anwendungsdateien.

In diesem Abschnitt fügen Sie der Anwendung 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.sql hinzu, die Sie in einem vorherigen Abschnitt erstellt haben:

    CREATE APPLICATION ROLE 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 Installation ausgeführt wird, erstellen diese Anweisungen eine Anwendungsrolle namens app_public. Anwendungsrollen sind ähnlich wie Datenbankrollen, können aber nur im Kontext einer Anwendung verwendet werden. Sie werden verwendet, um innerhalb der Anwendung Zugriff auf Objekte zu gewähren.

    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.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 die folgende Anweisung am Ende der Datei setup.sql 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.

  4. Laden Sie das überarbeitete Setup-Skript in den benannten Stagingbereich hoch.

    Lesen Sie dazu im vorherigen Abschnitt Anwendungsdateien in den benannten Stagingbereich hochladen, wie das überarbeitete Setup-Skript hochgeladen werden kann, und kehren Sie dann hierher zurück, um mit dem Tutorial fortzufahren.

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

Anwendung installieren

Im vorigen Abschnitt haben Sie das Setup-Skript so geändert, dass es eine gespeicherte Prozedur enthält.

In diesem Abschnitt werden Sie die Anwendung installieren und die gespeicherte Prozedur über Snowsight ausführen.

Um eine Anwendung zu installieren, gehen Sie wie folgt vor:

  1. Führen Sie den folgenden Befehl aus, um die Anwendung zu erstellen:

    CREATE APPLICATION HELLO_SNOWFLAKE_APP
      FROM APPLICATION PACKAGE HELLO_SNOWFLAKE_PACKAGE
      USING '@hello_snowflake_package.stage_content.hello_snowflake_stage';
    
    Copy
  2. Prüfen Sie, ob die Anwendung erfolgreich erstellt wurde, indem Sie den folgenden Befehl ausführen:

    SHOW APPLICATIONS;
    
    Copy

    Sie sollten die Anwendung HELLO_SNOWFLAKE_APP in der Spalte name der Ausgabe sehen.

  3. Führen Sie die gespeicherte Prozedur HELLO, die Sie in einem vorherigen Abschnitt zu setup.sql hinzugefügt haben, mit dem folgenden Befehl aus:

    CALL core.hello();
    
    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 Anwendung mit dem Native Apps Framework erstellt, installiert und getestet! Obwohl die Anwendung nur über grundlegende Funktionen verfügt, sind die Komponenten, die Sie zum Erstellen der Anwendung verwendet haben, die gleichen wie bei komplexeren Anwendungen.

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 Anwendung im Verbraucherkonto installiert wird. In späteren Abschnitten werden Sie Dateninhalte und andere Arten von Anwendungslogik zu Ihrer Anwendung hinzufügen.

  • Sie haben Ihre Anwendung installiert und getestet, indem Sie die gespeicherte Prozedur ausgeführt haben. In späteren Abschnitten werden Sie weitere Möglichkeiten kennenlernen, wie Sie Ihre Anwendung anzeigen und testen können.

Dateninhalte zur Anwendung hinzufügen

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

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

Datenbank zur Freigabe für eine Anwendung erstellen

In diesem Abschnitt erfahren Sie, wie Sie Dateninhalte für eine Anwendung freigeben können. Genauer gesagt, werden Sie eine Tabelle im Anwendungspaket freigeben.

So erstellen Sie eine Tabelle und fügen die Beispieldaten in das Anwendungspaket ein:

  1. Legen Sie den Kontext auf das Anwendungspaket, indem Sie den folgenden Befehl ausführen:

    USE APPLICATION PACKAGE hello_snowflake_package;
    
    Copy
  2. Um eine Tabelle zu erstellen und die freizugebenden Dateninhalte hinzuzufügen, führen Sie die folgenden Befehle aus:

    CREATE SCHEMA IF NOT EXISTS shared_data;
    CREATE TABLE IF NOT EXISTS accounts (ID INT, NAME VARCHAR, VALUE VARCHAR);
    INSERT INTO accounts VALUES
      (1, 'Nihar', 'Snowflake'),
      (2, 'Frank', 'Snowflake'),
      (3, 'Benoit', 'Snowflake'),
      (4, 'Steven', 'Acme');
    
    Copy
  3. Überprüfen Sie, ob die Dateninhalte korrekt in die Tabelle eingefügt wurden, indem Sie den folgenden Befehl ausführen:

    SELECT * FROM accounts;
    
    Copy

    In der Ausgabe dieses Befehls sollten drei Spalten mit den Namen ID, NAME und VALUE angezeigt werden. Außerdem sollten die Daten jeder Zeile wie im folgenden Ausgabebeispiel angezeigt werden:

    +----+----------+-----------+
    | ID | NAME     | VALUE     |
    |----+----------+-----------|
    |  1 | Nihar    | Snowflake |
    |  2 | Frank    | Snowflake |
    |  3 | Benoit   | Snowflake |
    |  4 | Steven   | Acme      |
    +----+----------+-----------+
    
    Copy
  4. Erteilen Sie die Nutzungsberechtigung für die Tabelle ACCOUNTS, indem Sie die folgenden Befehle ausführen:

    GRANT USAGE ON SCHEMA shared_data TO SHARE IN APPLICATION PACKAGE hello_snowflake_package;
    GRANT SELECT ON TABLE accounts TO SHARE IN APPLICATION PACKAGE hello_snowflake_package;
    
    Copy

    Wenn Sie diese Berechtigungen für die Objekte innerhalb des Anwendungspakets zuweisen, steht die Tabelle accounts allen Anwendungen zur Verfügung, die über das Anwendungspaket installiert werden.

    Bemerkung

    Sie müssen die USAGE-Berechtigung für jedes Objekt innerhalb eines Anwendungspakets erteilen, das Sie für einen Verbraucher in einer Anwendung freigeben möchten.

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 die Anwendung 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 Native Apps 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.

  3. Laden Sie das überarbeitete Setup-Skript in den benannten Stagingbereich hoch.

    Lesen Sie dazu im vorherigen Abschnitt Anwendungsdateien in den benannten Stagingbereich hochladen, wie die in diesem Abschnitt aktualisierten Dateien hochgeladen werden, und kehren Sie dann hierher zurück, um mit dem Tutorial fortzufahren.

Aktualisierte Anwendung testen

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

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

  1. Löschen Sie die vorhandene Anwendung, indem Sie den folgenden Befehl ausführen:

    DROP APPLICATION hello_snowflake_app;
    
    Copy
  2. Erstellen Sie eine neue Version der Anwendung, indem Sie die folgenden Befehle ausführen:

    CREATE APPLICATION hello_snowflake_app
      FROM APPLICATION PACKAGE hello_snowflake_package
      USING '@hello_snowflake_package.stage_content.hello_snowflake_stage';
    
    Copy
  3. Überprüfen Sie, ob die Ansicht korrekt funktioniert, indem Sie den folgenden Befehl ausführen:

    SELECT * FROM code_schema.accounts_view;
    
    Copy

    Die Ausgabe dieses Befehls ist identisch mit der Ausgabe des SELECT-Befehls, den Sie beim Einrichten der Beispieldaten ausgeführt haben:

    +----+----------+-----------+
    | ID | NAME     | VALUE     |
    |----+----------+-----------|
    |  1 | Nihar    | Snowflake |
    |  2 | Frank    | Snowflake |
    |  3 | Benoit   | Snowflake |
    |  4 | Steven   | Acme      |
    +----+----------+-----------+
    
    Copy

Zusammenfassung

In diesem Abschnitt haben Sie gelernt, wie Sie freigegebene Dateninhalte in Ihre Anwendung einbinden können, indem Sie die folgenden Aufgaben ausführen:

  • Erstellen der Tabelle ACCOUNTS im Anwendungspaket und einfügen der Daten in die Tabelle

  • Zuweisen der Referenznutzungsberechtigung für die Tabelle ACCOUNTS zum Anwendungspaket.

  • Erstellen eines Schemas und einer Ansicht, die auf die Tabelle ACCOUNTS im Anwendungspaket verweisen.

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

  • Zuweisen der Select-Berechtigung für die Ansicht zur Anwendungsrolle

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

  • Erstellen eines Schemas und einer Ansicht, die die Anwendung für den Zugriff auf die Beispieldaten verwendet

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

  • Zuweisen der Select-Berechtigung für die Ansicht zur Anwendungsrolle

Beachten Sie, dass die Befehle, die Sie zur Einrichtung der Datenbank HELLO_SNOWFLAKE_DATA ausgeführt haben, parallel auch im Setup-Skript zu finden sind.

Python-Code zur Anwendung hinzufügen

In diesem Abschnitt werden Sie die Funktionalität Ihrer Anwendung erweitern, indem Sie Python-Code hinzufügen, um die Anwendungslogik zu verbessern. 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 Anwendung 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.8'
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 Anwendung 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.

Externes Python-Modul hinzufügen

So fügen Sie ein externes Python-Modul zu Ihrer Anwendung 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.8
      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 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.

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

Aktualisierte Anwendung installieren und testen

  1. Laden Sie die neuen und überarbeiteten Dateien in den benannten Stagingbereich hoch.

    Lesen Sie dazu im Abschnitt Anwendungsdateien in den benannten Stagingbereich hochladen, wie die externe Python-Datei hochgeladen wird, und kehren Sie dann hierher zurück, um mit dem Tutorial fortzufahren.

    Wenn Sie SnowSQL zum Hochladen der Datei verwenden, führen Sie die folgenden Befehle aus:

    PUT file:///<path_to_your_root_folder>/tutorial/scripts/setup.sql @hello_snowflake_package.stage_content.hello_snowflake_stage/scripts overwrite=true auto_compress=false;
    PUT file:///<path_to_your_root_folder>/tutorial/python/hello_python.py @hello_snowflake_package.stage_content.hello_snowflake_stage/python overwrite=true auto_compress=false;
    
    Copy
  2. Entfernen Sie die vorhandene Anwendung, indem Sie den folgenden Befehl ausführen:

    DROP APPLICATION hello_snowflake_app;
    
    Copy
  3. Erstellen Sie eine neue Version der Anwendung, indem Sie die folgenden Befehle ausführen:

    CREATE APPLICATION hello_snowflake_app
      FROM APPLICATION PACKAGE hello_snowflake_package
      USING '@hello_snowflake_package.stage_content.hello_snowflake_stage';
    
    Copy
  4. Testen Sie die gespeicherte Python-Prozedur, indem Sie den folgenden Befehl ausführen:

    SELECT code_schema.addone(1);
    
    Copy
  5. Testen Sie die referenzierte Python-Funktion, indem Sie den folgenden Befehl ausführen:

    SELECT code_schema.multiply(1,2);
    
    Copy

Zusammenfassung

In diesem Abschnitt haben Sie die folgende neue Funktionalität zu Ihrer Anwendung 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 Anwendung installiert und jede Funktion ausgeführt haben.

Streamlit-App zu Ihrer Anwendung hinzufügen

In diesem Abschnitt vervollständigen Sie Ihre Anwendung, indem Sie eine Streamlit-App 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 native 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.context import get_active_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 = get_active_session()
    
    #  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

Streamlit-Objekt zum Setup-Skript hinzufügen

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

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

    CREATE STREAMLIT 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.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
  3. Laden Sie die neuen und aktualisierten Anwendungsdateien in den benannten Stagingbereich hoch:

    Lesen Sie dazu im vorherigen Abschnitt Anwendungsdateien in den benannten Stagingbereich hochladen, wie die soeben erstellte Streamlit-Datei hochgeladen werden kann, und kehren Sie dann hierher zurück, um mit dem Tutorial fortzufahren.

    Wenn Sie SnowSQL zum Hochladen der Datei verwenden, führen Sie den folgenden Befehl aus:

    PUT file:///<path_to_your_root_folder>/tutorial/scripts/setup.sql @hello_snowflake_package.stage_content.hello_snowflake_stage/scripts overwrite=true auto_compress=false;
    PUT file:///<path_to_your_root_folder>/tutorial/streamlit/hello_snowflake.py @hello_snowflake_package.stage_content.hello_snowflake_stage/streamlit overwrite=true auto_compress=false;
    
    Copy

Aktualisierte Anwendung installieren

  1. Laden Sie das überarbeitete Setup-Skript in den benannten Stagingbereich hoch.

    Lesen Sie dazu im vorherigen Abschnitt Anwendungsdateien in den benannten Stagingbereich hochladen, wie das überarbeitete Setup-Skript hochgeladen werden kann, und kehren Sie dann hierher zurück, um mit dem Tutorial fortzufahren.

  2. Entfernen Sie die vorherige Anwendung, indem Sie den folgenden Befehl ausführen:

    DROP APPLICATION hello_snowflake_app;
    
    Copy
  3. Erstellen Sie eine neue Version der Anwendung, indem Sie den folgenden Befehl ausführen:

    CREATE APPLICATION hello_snowflake_app
      FROM APPLICATION PACKAGE hello_snowflake_package
      USING '@hello_snowflake_package.stage_content.hello_snowflake_stage';
    
    Copy

Zusammenfassung

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

  • Erstellen einer Streamlit-App

Eine Version zur Anwendung hinzufügen

In diesem Abschnitt fügen Sie eine Version zu Ihrer Anwendung hinzu, die die gesamte Funktionalität enthält, die Sie in diesem Tutorial hinzugefügt haben. Um dies zu erreichen, verwenden Sie den Befehl ALTER APPLICATION PACKAGE, mit dem das zuvor erstellte Anwendungspaket aktualisiert wird.

So fügen Sie eine Version zu Ihrer Anwendung hinzu:

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

    ALTER APPLICATION PACKAGE hello_snowflake_package
      ADD VERSION v1_0 USING '@hello_snowflake_package.stage_content.hello_snowflake_stage';
    
    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. Weitere Informationen dazu finden Sie unter ALTER APPLICATION PACKAGE.

    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:

    SHOW VERSIONS IN APPLICATION PACKAGE hello_snowflake_package;
    
    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    | 2023-05-30 10:33:39.768 -0700 | NULL       | OFF       | OFF         | READY | NOT_REVIEWED  |
    +---------+-------+-------+---------+-------------------------------+------------+-----------+-------------+-------+---------------+
    
    Copy

    Weitere Informationen dazu finden Sie unter SHOW VERSIONS.

  3. Installieren Sie die Anwendung auf Basis einer Version, indem Sie den folgenden Befehl ausführen:

    DROP APPLICATION hello_snowflake_app;
    CREATE APPLICATION hello_snowflake_app
      FROM APPLICATION PACKAGE hello_snowflake_package
      USING VERSION V1_0;
    
    Copy

In diesem Abschnitt haben Sie das Anwendungspaket geändert und eine Version Ihrer Anwendung hinzugefügt.

Anwendung in Snowsight anzeigen

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

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

  1. Melden Sie sich bei Snowsight an.

  2. Wechseln Sie zur Rolle ACCOUNTADMIN.

  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 readme.md hinzugefügt haben.

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

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

  6. Wählen Sie Projects » Worksheets aus, um die Anwendung in einem Snowflake-Arbeitsblatt zu öffnen.

  7. Wählen Sie HELLO_SNOWFLAKE_APP aus, und wählen Sie dann in der Liste ein Schema aus.

    Das aufgelistete Schema entspricht dem Schema, das Sie während des Tutorials zu Ihrer Anwendung hinzugefügt haben.

Vom Snowflake-Arbeitsblatt aus können Sie Ihre Anwendung 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.

Anwendung veröffentlichen und installieren

In diesem Abschnitt werden Sie Ihre Anwendung 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 eine Release-Richtlinie festlegen. Eine Release-Richtlinie gibt an, welche Version Ihrer Anwendung für einen Verbraucher verfügbar ist.

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

Um die Standard-Release-Richtlinie 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:

    SHOW VERSIONS IN APPLICATION PACKAGE hello_snowflake_package;
    
    Copy

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

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

    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-Release-Richtlinie für das Anwendungspaket definiert.

Freigabeangebot für Anwendung erstellen

Nachdem Sie eine Release-Richtlinie fü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 Anwendung für andere Snowflake-Benutzer freigeben und ihnen die Installation und Nutzung der Anwendung im eigenen Konto ermöglichen.

So erstellen Sie ein Freigabeangebot für Ihre Anwendung:

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

Anwendung installieren

In diesem Abschnitt installieren Sie die Anwendung, 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 Anwendung in seinem Konto installieren würde.

Um Ihre Anwendung 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 Anwendung 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 Anwendung 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 Anwendung 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 Anwendung mit dem Native Apps Framework durchlaufen.

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