Tutoriel : Développement d’une Snowflake Native App avec le Snowflake Native App Framework¶
Introduction¶
Ce tutoriel décrit comment utiliser le Snowflake Native App Framework pour créer une Snowflake Native App permettant de partager des données et la logique métier associée avec d’autres comptes Snowflake.
Le tutoriel utilise les interfaces Web Snowflake CLI et Snowsight.
Ce que vous apprendrez¶
Dans ce tutoriel, vous apprendrez à :
Créez un paquet d’application qui contient les données et la logique d’entreprise de votre application.
Partager des données avec un paquet d’application.
Ajouter une logique métier à un paquet d’application.
Testez l’application localement.
Voyez et testez l’application dans Snowsight.
Publier votre application en créant une annonce privée.
Installez l’application à partir d’une annonce privée.
Utilisez Snowflake CLI pour effectuer la plupart des étapes ci-dessus.
À propos des fournisseurs et des consommateurs¶
Dans le contexte du Snowflake Native App Framework, les fournisseurs sont les rôles et les organisations qui disposent de données et d’une logique métier qu’ils souhaitent partager avec d’autres utilisateurs de Snowflake, qui sont les consommateurs. Un consommateur peut être un autre compte au sein de votre organisation, une organisation différente au sein de votre entreprise ou un utilisateur de Snowflake dans une autre entreprise.
Dans le cadre de ce tutoriel, la plupart des tâches que vous allez effectuer sont celles généralement réalisées par des fournisseurs, mais elles incluent des tâches qui peuvent être réalisées par plusieurs rôles au sein de votre organisation, notamment les développeurs d’applications et les administrateurs de bases de données.
Dans ce tutoriel, vous effectuerez également des tâches qui imitent les actions réalisées par les consommateurs pour installer une application.
Conditions préalables¶
Vous devez avoir installé Snowflake CLI sur votre machine.
Vous devez exécuter toutes les commandes SQL dans la même session de commande SQL, car le contexte de la session est nécessaire.
Pour ce faire dans Snowsight, par exemple, collez tout votre code dans la même feuille de calcul au fur et à mesure. Au fur et à mesure que vous progressez, chaque section s’appuie sur la précédente.
Vous devez être en mesure d’utiliser le rôle ACCOUNTADMIN.
Dans ce tutoriel, vous effectuerez toutes les étapes en utilisant le rôle ACCOUNTADMIN. En règle générale, cependant, vous utiliserez des rôles dont les privilèges sont spécifiquement définis pour l’action que vous effectuez. Par exemple, vous pouvez avoir des rôles distincts pour les développeurs qui créent des UDFs et des procédures stockées, pour les administrateurs de base de données qui gèrent les rôles et les autorisations, et pour les administrateurs qui gèrent les annonces à l’aide de la collaboration Snowflake.
Pour installer votre application à partir d’une annonce privée, vous devez avoir accès à un deuxième compte Snowflake. Vous utiliserez ce compte pour imiter la façon dont les consommateurs installeraient une application.
Note
Bien que le Snowflake Native App Framework prenne en charge le partage d’applis avec des comptes appartenant à des organisations différentes, pour les besoins de ce tutoriel, les deux comptes doivent appartenir à la même organisation.
Vous devez définir un entrepôt courant. Voir USE WAREHOUSE.
Créer les fichiers de l’application¶
Dans cette section, vous allez créer un script d’installation, un fichier manifeste et un fichier de définition de projet. Les deux premiers de ces fichiers sont requis par le Snowflake Native App Framework.
- Script d’installation
Script SQL qui s’exécute automatiquement lorsqu’un consommateur installe une appli dans son compte.
- Fichier manifeste
Fichier YAML qui contient des informations de configuration de base sur l’appli.
- Fichier de définition du projet
Un fichier YAML qui contient des informations sur les objets Snowflake que vous souhaitez créer.
Vous en apprendrez plus sur ces fichiers et leur contenu tout au long de ce tutoriel. Vous créerez également un fichier Lisez-moi qui vous sera utile lors de l’affichage et de la publication de votre appli dans les sections ultérieures de ce tutoriel.
Initialiser un nouveau dossier de projet¶
Vous utiliserez Snowflake CLI pour initialiser un nouveau projet Snowflake Native App dans votre système de fichiers local.
Pour ce faire, exécutez la commande suivante :
snow init --template app_basic tutorial
Cette commande crée un dossier nommé tutorial
dans le répertoire de travail actuel et le remplit avec un projet de base Snowflake Native App basé sur un modèle de base. Il s’agit du répertoire racine de tous les fichiers de votre application.
Note
Vous modifierez et ajouterez d’autres fichiers et sous-dossiers à ce dossier dans les sections suivantes.
Note
D’autres modèles sont disponibles pour vous aider à utiliser rapidement les applications natives. Veuillez consulter snow init --help
pour plus d’informations.
Créer le script d’installation¶
Modifiez ou remplacez le contenu du fichier app/setup_script.sql
comme affiché dans l’exemple suivant :
-- Setup script for the Hello Snowflake! app.
Cette ligne est un espace réservé, car le script d’installation ne peut pas être vide.
Note
Ce tutoriel fait référence à une structure et à un nom de fichier particuliers pour le script d’installation. Cependant, lorsque vous créez votre propre appli, vous pouvez choisir votre propre nom et votre propre structure de répertoire pour ce fichier.
Créer un fichier README pour votre appli¶
Un fichier Lisez-moi fournit une description de ce que fait votre application. Vous verrez le fichier Lisez-moi lorsque vous verrez votre appli dans Snowsight.
Modifiez ou remplacez le contenu de app/README.md
par ce qui suit :
This is the readme file for the Hello Snowflake app.
Créer le fichier manifeste¶
Le Snowflake Native App Framework exige un fichier manifeste pour chaque appli. Le fichier manifeste contient des métadonnées et des paramètres de configuration pour une appli et influence le comportement de votre appli pendant l’exécution.
Note
Ce fichier doit être nommé manifest.yml
. Les chemins vers d’autres fichiers, y compris le script d’installation, sont relatifs à l’emplacement de ce fichier.
Modifiez ou remplacez le contenu de app/manifest.yml
par ce qui suit :
manifest_version: 1
artifacts:
setup_script: setup_script.sql
readme: README.md
La propriété setup_script
spécifie l’emplacement du script d’installation par rapport à l’emplacement du fichier manifeste. Le chemin et le nom de fichier spécifiés ici doivent être identiques à l’emplacement relatif du script d’installation que vous avez modifié ci-dessus. La propriété readme
suit les mêmes règles.
Note
Les propriétés manifest_version
, artifacts
, et setup_script
sont obligatoires. La valeur readme
est facultative.
Créer le fichier de définition du projet¶
Snowflake CLI utilise un fichier de définition de projet pour décrire les objets qui peuvent être déployés sur Snowflake. Ce fichier doit être nommé snowflake.yml
. Ce fichier contrôle le nom du paquet d’application et de l’objet déployés, ainsi que les fichiers qui sont téléchargés dans la phase de projet.
Note
Ce fichier doit être nommé
snowflake.yml
et doit se trouver à la racine de votre projet. Les chemins vers d’autres fichiers, y compris lemanifest.yml
et le script d’installation, sont relatifs à l’emplacement de ce fichier.
Modifiez ou remplacez le contenu de snowflake.yml
par ce qui suit :
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
La section suivante de ce tutoriel décrira comment utiliser chacune de ces propriétés.
Passez en revue ce que vous avez appris dans cette section¶
Après avoir effectué les étapes décrites dans cette section, vous devriez avoir une structure de répertoire qui ressemble à ce qui suit :
/tutorial
snowflake.yml
README.md
/app/
manifest.yml
README.md
setup_script.sql
Dans cette section, vous avez appris à créer le script d’installation et les fichiers manifestes requis par le Snowflake Native App Framework et avez pris connaissance du fichier de définition de projet qui est requis par Snowflake CLI.
Bien que le contenu que vous avez ajouté au script d’installation et au fichier manifeste soit basique, toutes les applis doivent avoir ces fichiers.
Vous avez également ajouté un fichier Lisez-moi qui s’affiche lors de l’affichage de votre appli dans Snowsight ou lors de la publication de votre appli sous forme d’annonce.
Comprendre le fichier de définition du projet¶
Dans cette section, vous découvrirez le contenu du fichier de définition du projet <label-native_apps_project_definition> (snowflake.yml
) que vous avez créé dans la section précédente. Vous effectuerez également d’autres tâches de configuration pour votre compte fournisseur.
À la base, un paquet d’application est une base de données Snowflake qui est étendue pour inclure des informations supplémentaires sur une appli. En ce sens, il s’agit d’un conteneur pour une appli qui comprend :
Partage de contenu de données
Fichiers d’application
Pour créer un paquet d’application, votre rôle doit disposer du privilège CREATE APPLICATION PACKAGE. Pour accorder ce privilège à l’aide de Snowflake CLI, exécutez la commande suivante :
snow sql -q 'GRANT CREATE APPLICATION PACKAGE ON ACCOUNT TO ROLE accountadmin' -c connection_nameoù
connection_name
est le nom de la connexion que vous avez spécifiée dans le fichierconfig.toml
lorsque vous avez installé la CLI de Snowflake.
Note
Bien que le rôle ACCOUNTADMIN dispose de ce privilège par défaut, pour pouvoir créer un paquet d’application, vous devez vous assurer que votre rôle s’est vu attribuer ce privilège.
Le fichier de définition de projet (snowflake.yml
) définit les noms des objets qui sont créés dans votre compte Snowflake :
Le paquet d’application (
hello_snowflake_package
)L’objet d’application (
hello_snowflake_app
) qui est créé à partir du paquet d’applicationLa zone de préparation qui contient les fichiers de préparation (
stage_content.hello_snowflake_stage
)
Notez que le nom de la zone de préparation est spécifié sous la forme d’un nom qualifié par le schéma. Ce schéma est créé à l’intérieur du paquet d’application. Cette zone de préparation nommée est utilisée pour stocker les fichiers requis par le Snowflake Native App Framework. Cette zone de préparation doit inclure tous les fichiers que vous souhaitez mettre à la disposition du script de préparation de votre appli ou au moment de l’exécution.
Le fichier de définition du projet contient également une section appelée artifacts
qui est une liste de règles spécifiant quels fichiers sont copiés dans la zone de préparation nommée.
La règle précise que tout ce qui se trouve dans le sous-dossier app/
est copié à la racine de la zone de préparation. Cela signifie ce qui suit :
tutorial/app/manifest.yml
est téléchargé à la racine de@hello_snowflake_package.stage_content.hello_snowflake_stage
.tutorial/app/README.md
est téléchargé à la racine de@hello_snowflake_package.stage_content.hello_snowflake_stage
.tutorial/app/setup_script.sql
est téléchargé à la racine de@hello_snowflake_package.stage_content.hello_snowflake_stage
.
Vous n’êtes pas encore en train de créer le paquet d’application ou d’exécuter les commandes SQL qui effectuent ces tâches. Dans une section ultérieure, vous exécuterez la commande CLI de Snowflake pour effectuer ces tâches.
Enfin, vous définissez debug: false
dans la définition de l’appli. Pour les applications déployées à l’aide de CLI Snowflake, le mode débogage est activé par défaut.
Dans cette section, vous avez appris qu’un paquet d’application est un conteneur pour les ressources utilisées par une appli. Vous avez également appris à définir les champs dans le fichier de définition du projet.
Ajouter la logique d’application et installer votre première appli¶
Dans cette section, vous allez ajouter du code au paquet d’application et installer votre première appli. Pour ce faire, vous effectuerez les tâches suivantes :
Ajoutez une procédure stockée au script d’installation.
Installez et testez l’appli en mode développement dans une zone de préparation.
Ajouter une procédure stockée au script d’installation¶
Dans cette section, vous allez ajouter une procédure stockée à l’appli en ajoutant le code de la procédure stockée au script d’installation sur votre système de fichiers local.
Pour ajouter une procédure stockée au script d’installation :
Ajoutez les instructions SQL suivantes à la fin du fichier
setup_script.sql
que vous avez créé dans une section précédente de ce tutoriel :CREATE APPLICATION ROLE IF NOT EXISTS app_public; CREATE SCHEMA IF NOT EXISTS core; GRANT USAGE ON SCHEMA core TO APPLICATION ROLE app_public;
Lorsque le script d’installation s’exécute pendant l’installation de l’appli, ces instructions créent un rôle d’application nommé
app_public
. Les rôles d’application sont similaires aux rôles de base de données, mais ils ne peuvent être utilisés que dans le contexte d’une appli. Ils sont utilisés pour accorder l’accès à des objets au sein de l’objet d’application qui est créé dans le compte consommateur.Cet exemple crée également un schéma pour contenir la procédure stockée et accorde le privilège USAGE sur le schéma au rôle d’application. La création d’un rôle d’application et l’attribution de privilèges sur un objet, par exemple un schéma, au rôle d’application sont un schéma courant dans le script d’installation.
Ajoutez le code de la procédure stockée à la fin du fichier
setup_script.sql
:CREATE OR REPLACE PROCEDURE CORE.HELLO() RETURNS STRING LANGUAGE SQL EXECUTE AS OWNER AS BEGIN RETURN 'Hello Snowflake!'; END;
Cet exemple crée une procédure stockée qui produit la chaîne « Hello Snowflake ! ».
Ajoutez l’instruction suivante à la fin du fichier
setup_script.sql
:GRANT USAGE ON PROCEDURE core.hello() TO APPLICATION ROLE app_public;
Cet exemple attribue au rôle d’application le privilège USAGE sur la procédure stockée.
Dans cette section, vous avez ajouté une procédure stockée au script d’installation. Vous avez également créé un rôle d’application et attribué le privilège USAGE à ce rôle. Cela permet au script d’installation de créer la procédure stockée lors de l’installation de l’application. Cela autorise également l’appli à exécuter la procédure stockée.
Installer et tester l’appli en mode développement en zone de préparation¶
Vous êtes maintenant prêt à créer le paquet d’application, l’appli et toutes les autres entités que vous avez spécifiées dans le fichier de définition du projet.
Pour effectuer ces tâches, exécutez la commande suivante de Snowflake CLI :
snow app run -c connection_nameoù
connection_name
est le nom de la connexion que vous avez spécifiée dans le fichierconfig.toml
lorsque vous avez installé la CLI de Snowflake.
Cette commande permet d’effectuer les performances suivantes :
Créez un paquet d’application nommé
hello_snowflake_package
avec le schémastage_content
et la zone de préparationhello_snowflake_stage
.Téléchargez tous les fichiers nécessaires dans la zone de préparation nommée.
Créez ou mettez à niveau l’application
hello_snowflake_app
en utilisant les fichiers de cette zone de préparation.
Si la commande s’exécute avec succès, elle produit une URL où vous pouvez voir votre application dans Snowsight. Pour exécuter la procédure stockée HELLO
que vous avez ajoutée à setup_script.sql
dans une section précédente, exécutez la commande Snowflake CLI suivante :
snow sql -q "call hello_snowflake_app.core.hello()" -c connection_name
Regardez la sortie suivante après avoir exécuté cette commande :
+------------------+
| HELLO |
|------------------|
| Hello Snowflake! |
+------------------+
Passez en revue ce que vous avez appris dans cette section¶
Félicitations ! Vous avez créé, installé et testé votre première Snowflake Native App en utilisant le Snowflake Native App Framework ! Bien que l’appli n’ait qu’une fonctionnalité de base, les composants que vous avez utilisés pour développer l’appli sont les mêmes pour des applis plus complexes.
Dans cette section, vous avez complété les éléments suivants :
Ajout d’une procédure stockée au script d’installation. Le script d’installation spécifie comment votre appli est installée dans le compte consommateur. Dans les sections suivantes, vous ajouterez du contenu de données et d’autres types de logique d’application à votre appli.
Déploiement de votre appli pour la première fois à l’aide de Snowflake CLI.
Vous avez testé votre appli installée en exécutant une procédure stockée.
Dans les sections suivantes, vous découvrirez d’autres façons d’afficher et de tester votre appli.
Ajouter du contenu de données à votre appli¶
Dans la section précédente, vous avez créé une appli contenant une procédure stockée qui montre comment vous pouvez ajouter une logique d’application à une appli
Dans cette section, vous allez inclure du contenu de données dans votre appli en créant une base de données dans le paquet d’application HELLO_SNOWFLAKE_PACKAGE
et en accordant des privilèges pour partager cette base de données avec l’appli.
Ajouter une vue pour accéder au contenu des données¶
Dans cette section, vous allez mettre à jour le script d’installation pour ajouter une vue qui permet au consommateur qui a installé l’appli d’accéder aux données de la table ACCOUNTS
que vous avez créée dans la sous-section précédente.
Pour ajouter une vue permettant d’accéder au contenu des données :
Pour créer un schéma pour la vue, ajoutez ce qui suit au script d’installation :
CREATE OR ALTER VERSIONED SCHEMA code_schema; GRANT USAGE ON SCHEMA code_schema TO APPLICATION ROLE app_public;
Ces instructions créent un schéma versionné pour contenir la vue et attribuent le privilège USAGE sur le schéma. Le Snowflake Native App Framework utilise un schéma versionné pour gérer les différentes versions des procédures et fonctions stockées.
Pour créer la vue, ajoutez ce qui suit au script d’installation :
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;
Ces instructions créent la vue dans le schéma
code_schema
et accordent le privilège requis sur la vue au rôle d’application.Ce script d’installation mis à jour est également téléchargé dans la zone de préparation la prochaine fois que vous déployez votre appli à l’aide de Snowflake CLI.
Tester l’appli mise à jour¶
Dans cette sous-section, vous mettrez à niveau l’application et interrogerez la table d’exemple à l’aide de la vue au sein de l’appli installée.
Pour tester l’appli mise à jour, procédez comme suit :
Pour mettre à jour le paquet d’application et l’objet d’application installé dans le compte du consommateur, exécutez la commande suivante :
snow app run -c connection_name
où
connection_name
est le nom de la connexion que vous avez spécifié dans le fichierconfig.toml
lorsque vous avez installé la CLI de Snowflake.Cela permet de télécharger tous les fichiers modifiés vers la zone de préparation, d’exécuter le script
scripts/shared_content.sql
et de mettre à niveau l’application à l’aide de ces fichiers sur la zone de préparation.Pour vérifier que la vue fonctionne correctement, exécutez la commande suivante :
snow sql -q "SELECT * FROM hello_snowflake_app.code_schema.accounts_view" -c connection_name
La sortie de cette commande devrait être la suivante :
+----+----------+-----------+ | ID | NAME | VALUE | |----+----------+-----------| | 1 | Joe | Snowflake | | 2 | Nima | Snowflake | | 3 | Sally | Snowflake | | 4 | Juan | Acme | +----+----------+-----------+
Passez en revue ce que vous avez appris dans cette section¶
Dans cette section, vous avez appris à inclure du contenu de données partagées dans votre appli en effectuant les tâches suivantes :
Créer la table
ACCOUNTS
dans le paquet d’application et insérer des données dans la table.Attribuer au paquet d’application l’utilisation de la référence sur la table
ACCOUNTS
.Créer un schéma et une vue qui font référence à la table
ACCOUNTS
dans le paquet d’application.Accorder l’utilisation du schéma au rôle d’application.
Accorder la sélection de la vue au rôle d’application.
Vous avez également mis à jour le script d’installation pour effectuer les opérations suivantes lors de l’installation de l’application :
Créer un schéma et une vue que l’application utilise pour accéder aux données d’exemple.
Accorder l’utilisation du schéma au rôle d’application.
Accorder la sélection de la vue au rôle d’application.
Ajouter du code Python à votre appli¶
Dans cette section, vous allez étendre la fonctionnalité de votre appli en ajoutant du code Python pour améliorer la logique d’application. Dans cette section, vous inclurez le code Python suivant :
Une UDF Python en ligne qui est une fonction autonome dans le script d’installation.
Une UDF Python qui fait référence à un fichier Python en dehors du script d’installation.
Note
Bien que cette section présente des exemples utilisant Python, les mêmes techniques sont applicables à Java et JavaScript.
Ajouter une fonction Python en ligne en tant que fonction définie par l’utilisateur (UDF)¶
Dans cette section, vous ajouterez une fonction Python en tant qu’UDF.
Pour inclure une UDF Python dans votre appli, ajoutez le code suivant à votre fichier d’installation.
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;
Ces commandes exécutent les tâches suivantes lors de l’installation de l’appli :
Créez un schéma versionné nommé
code_schema
.Accordez le privilège d’utilisation du schéma au rôle d’application
APP_PUBLIC
.Créez l’UDF
ADDONE()
dans le schémacode_schema
.Accordez le privilège d’utilisation de la fonction au rôle d’application
APP_PUBLIC
.
Notez que le schéma créé dans l’exemple de code ci-dessus est un schéma versionné. Les fonctions définies par l’utilisateur et les procédures stockées doivent être définies dans un schéma versionné au lieu d’un schéma normal. Cela permet d’éviter que les mises à niveau d’applications n’interfèrent avec l’exécution simultanée de codes.
Ajouter un module Python externe¶
Pour ajouter un module Python externe à votre appli :
Ajoutez la fonction Python suivante à votre script d’installation :
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;
Comme dans l’exemple précédent, ces instructions créent une UDF Python dans un schéma et attribuent des privilèges sur la fonction au rôle d’application. Cependant, cet exemple contient une clause IMPORTS qui fait référence à un fichier Python externe que vous allez créer et inclure dans votre zone de préparation nommée.
Dans le dossier
tutorial
, créez un sous-dossier nommépython
.Dans le sous-dossier
python
, créez un fichier nomméhello_python.py
.Ajoutez ce qui suit au fichier
hello_python.py
:def multiply(num1, num2): return num1*num2
La fonction définie dans ce fichier externe correspond à la fonction en ligne définie dans le script d’installation.
Ajoutez ce qui suit à la section
artifacts
du fichier de définition du projet :- python/hello_python.py
Dans cette section, vous avez ajouté une UDF Python à votre appli. Cette UDF fait référence à un module Python externe qui peut être référencé par votre paquet d’application.
Installer et tester l’appli mise à jour¶
Pour installer et tester une appli :
Pour mettre à jour le paquet d’application et l’appli, exécutez la commande suivante :
snow app run -c connection_name
où
connection_name
est le nom de la connexion que vous avez spécifié dans votreconfig.toml
lorsque vous avez installé la CLI de Snowflake.Cette commande télécharge les fichiers modifiés et les nouveaux fichiers vers la zone de préparation et met à niveau votre application en utilisant les fichiers de la zone de préparation.
Pour tester la procédure stockée Python, exécutez la commande suivante :
snow sql -q "SELECT hello_snowflake_app.code_schema.addone(1)" -c connection_name
Pour tester la fonction Python référencée, exécutez la commande suivante :
snow sql -q "SELECT hello_snowflake_app.code_schema.multiply(1,2)" -c connection_name
Passez en revue ce que vous avez appris dans cette section¶
Dans cette section, vous avez ajouté les nouvelles fonctionnalités suivantes à votre appli :
Une fonction Python définie comme une UDF ligne.
Une fonction Python définie comme une UDF qui fait référence à du code externe.
Vous avez également testé chacun de ces exemples en installant une version mise à jour de votre appli et en exécutant chacune des fonctions.
Ajouter une application Streamlit à votre appli¶
Dans cette section, vous compléterez votre Snowflake Native App en ajoutant une interface utilisateur Streamlit. Streamlit est un framework Python libre, utilisé pour le développement d’applications de science des données et de machine learning. Vous pouvez inclure des applis Streamlit au sein d’une appli pour ajouter de l’interaction avec l’utilisateur et de la visualisation de données.
Créer le fichier d’appli Streamlit¶
Pour créer une application Streamlit, procédez comme suit :
Dans le dossier
tutorial
, créez un sous-dossier nomméstreamlit
.Dans le dossier
streamlit
, créez un fichier nomméhello_snowflake.py
.Ajoutez le code suivant à ce fichier :
# 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)
Ajoutez ce qui suit à la section
artifacts
du fichier de définition du projet :- streamlit/hello_snowflake.py
Ajouter l’objet Streamlit au script d’installation¶
Pour créer l’objet Streamlit dans l’appli, procédez comme suit :
Ajoutez l’instruction suivante à la fin du fichier
setup_script.sql
pour créer l’objet Streamlit :CREATE STREAMLIT IF NOT EXISTS code_schema.hello_snowflake_streamlit FROM '/streamlit' MAIN_FILE = '/hello_snowflake.py' ;
Cette instruction crée un objet STREAMLIT dans le schéma principal.
Ajoutez l’instruction suivante à la fin du fichier
setup_script.sql
pour permettre au rôle APP_PUBLIC d’accéder à l’objet Streamlit :GRANT USAGE ON STREAMLIT code_schema.hello_snowflake_streamlit TO APPLICATION ROLE app_public;
Installer l’appli mise à jour¶
Pour mettre à jour le paquet d’application et l’appli, exécutez la commande suivante :
snow app run -c connection_name
où
connection_name
est le nom de la connexion que vous avez spécifié dans le fichierconfig.toml
lorsque vous avez installé la CLI de Snowflake.Cette commande télécharge les fichiers modifiés et les nouveaux fichiers vers la zone de préparation et met à niveau votre application en utilisant les fichiers de la zone de préparation. Vous pouvez ensuite vous rendre à l’URL que cette commande imprime pour voir votre nouvelle Streamlit en action ; une fois sur place, cliquez sur l’onglet nommé HELLO_SNOWFLAKE_STREAMLIT qui apparaît à côté du nom de votre application.
Passez en revue ce que vous avez appris dans cette section¶
Dans cette section, vous avez ajouté une appli Streamlit à votre Snowflake Native App en procédant comme suit :
Création d’un fichier python qui utilise la bibliothèque Streamlit pour afficher une interface utilisateur.
Création d’une appli Streamlit dans votre Snowflake Native App qui affiche des données partagées.
Ajouter une version à votre appli¶
Dans les sections précédentes, vous avez utilisé un mode « développement en zone de préparation » pour pousser les changements. Le mode de développement en zone de préparation vous permet d’itérer rapidement le développement de l’appli sans avoir à créer de nouvelles versions ou de nouveaux correctifs. Cependant, vous devez créer une version de l’appli pour afficher votre paquet d’application et le partager avec d’autres utilisateurs de Snowflake.
Dans cette section, vous ajouterez une version à votre appli qui comprendra toutes les fonctionnalités que vous avez ajoutées dans ce tutoriel.
Pour ajouter une version au paquet d’application
HELLO_SNOWFLAKE_PACKAGE
, exécutez la commande suivante :snow app version create v1_0 -c connection_name
Dans cette commande, vous avez modifié votre paquet d’application pour ajouter une version basée sur les fichiers d’application que vous avez chargés dans la zone de préparation nommée dans une section précédente.
Note
La valeur spécifiée pour VERSION est une balise, et non une valeur numérique ou une chaîne.
Note
Le numéro de correctif de la nouvelle version que vous avez ajoutée est automatiquement créé à l’adresse
0
. Au fur et à mesure que vous ajoutez des correctifs supplémentaires pour une version, ceux-ci sont automatiquement incrémentés. Toutefois, lorsque vous créez une nouvelle version, par exempleV1_1
, le numéro de correctif de cette version est réinitialisé à0
.Pour vérifier que la version a été ajoutée au paquet de l’application, exécutez la commande suivante :
snow app version list -c connection_name
Cette commande affiche des informations supplémentaires sur la version, comme le montre la sortie suivante :
+---------+-------+-------+---------+-------------------------------+------------+-----------+-------------+-------+---------------+ | 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 | +---------+-------+-------+---------+-------------------------------+------------+-----------+-------------+-------+---------------+
Pour installer l’appli en fonction d’une version, exécutez la commande suivante :
snow app run --version V1_0 -c connection_name
Étant donné que l’appli existante a été créée à l’aide de fichiers sur la zone de préparation nommée, la mise à niveau de l’application à l’aide d’une version nécessite la suppression de l’application existante et sa recréation à l’aide de cette version. Répondez par l’affirmative à l’invite qui vous est faite.
Dans cette section, vous avez modifié le paquet d’application pour y inclure une version de votre appli. Vous avez aussi recréé l’objet d’application à l’aide du mode de développement en plusieurs versions.
Voir votre appli dans Snowsight¶
Dans cette section, vous verrez votre appli dans Snowsight. Dans les sections précédentes, vous avez utilisé des instructions SQL pour tester ou trouver des informations sur votre appli. Toutefois, vous pouvez également consulter les informations relatives à votre appli dans Snowsight. Vous pouvez également voir votre appli Streamlit déployée.
Pour voir votre appli dans Snowsight, procédez comme suit :
Connectez-vous à Snowsight.
Passez au rôle ACCOUNTADMIN en procédant comme suit :
Dans le menu de navigation, sélectionnez votre nom d’utilisateur pour ouvrir le menu du compte.
Sélectionnez le rôle actif. Par exemple, PUBLIC.
Le sélecteur de rôle apparaît.
Sélectionnez le rôle ACCOUNTADMIN.
Sélectionnez Data Products » Apps.
Sélectionnez
HELLO_SNOWFLAKE_APP
.L’onglet
Read Me
affiche le contenu que vous avez ajouté au fichierapp/README.md
dans une section précédente.Pour voir votre application Streamlit, sélectionnez HELLO_SNOWFLAKE_STREAMLIT.
Le contenu de la base de données
HELLO_SNOWFLAKE_DATA
s’affiche dans un cadre de données Streamlit.Pour ouvrir l’application dans une feuille de calcul, sélectionnez Projects » Worksheets.
Sélectionnez HELLO_SNOWFLAKE_APP dans la liste des feuilles de calcul.
Si nécessaire, sélectionnez l’entrepôt où vous avez installé l’application.
À partir de la feuille de calcul Snowflake, vous pouvez tester votre appli à l’aide de commandes SQL. Par exemple, vous pouvez réexécuter les commandes que vous avez exécutées dans les sections précédentes pour tester les fonctions que vous avez ajoutées à votre application :
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);
Note
Toutes les instructions SQL que vous ajoutez à cette feuille de calcul sont perdues lorsque vous naviguez vers une autre page de Snowsight.
Note
Vous pouvez également voir directement l’interface utilisateur de votre appli en utilisant la commande snow app open
dans Snowflake CLI. Cette commande ouvre l’URL appropriée dans votre navigateur web configuré pour le système.
Publier et installer votre appli¶
Dans cette section, vous allez publier votre appli en créant une annonce privée qui utilise le paquet d’application comme contenu de données. Après avoir créé l’annonce, vous vous connecterez à un autre compte pour installer l’annonce.
Définition de la directive de version par défaut¶
Avant de pouvoir créer une annonce pour votre paquet d’application, vous devez définir une directive de version. Une directive de version spécifie quelles versions de votre appli sont disponibles pour les consommateurs.
Dans ce tutoriel, vous allez définir la directive de version par défaut en utilisant la version que vous avez ajoutée dans une section précédente.
Pour définir la directive de version par défaut pour votre paquet d’application, procédez comme suit :
Pour voir les versions et les correctifs définis pour votre paquet d’application, exécutez la commande suivante :
snow app version list -c connection_name
Cette commande affiche les versions et les correctifs définis pour le paquet d’application.
Pour définir la directive de version par défaut sur la version
v1_0
et le correctif0
, exécutez la commande suivante :snow sql -q "ALTER APPLICATION PACKAGE hello_snowflake_package SET DEFAULT RELEASE DIRECTIVE VERSION = v1_0 PATCH = 0"
La sortie de cette commande est présentée dans l’exemple suivant :
+-----------------------------------------------------------+ | status | |-----------------------------------------------------------| | Default release directive set to version 'V1_0', patch 0. | +-----------------------------------------------------------+
Dans cette section, vous avez vérifié quelles versions et quels correctifs existent dans votre paquet d’application. À l’aide de ces informations, vous avez défini la directive de version par défaut pour le paquet d’application.
Créez une annonce pour votre appli¶
Maintenant que vous avez spécifié une directive de version pour votre paquet d’application, vous allez créer une annonce et ajouter le paquet d’application comme contenu de données de l’annonce. Cela vous permet de partager votre appli avec d’autres utilisateurs de Snowflake et leur permet d’installer et d’utiliser l’appli dans leur compte.
Pour créer une annonce pour votre appli :
Connectez-vous à Snowsight.
Dans le menu de navigation, sélectionnez Data Products » Provider Studio.
Sélectionnez + Listing. La fenêtre Créer une annonce s’ouvre.
Saisissez un nom pour votre annonce.
Dans la section In the Who can discover the listing, sélectionnez Only specified consumers pour partager en privé l’annonce avec des comptes spécifiques.
Cliquez sur + Select pour sélectionner le paquet d’application de l’annonce.
Saisissez une description de votre annonce.
Dans la section Add consumer accounts, ajoutez l’identificateur du compte que vous utilisez pour tester l’installation de l’appli à partir d’une annonce du point de vue du consommateur.
Dans cette section, vous avez créé une annonce privée contenant votre paquet d’application comme contenu de données partagées.
Installez l’appli dans un compte de consommateur¶
Dans cette section, vous installerez l’appli associée à l’annonce que vous avez créée dans la section précédente. Vous installerez l’annonce dans un compte différent qui imitera la façon dont un consommateur installerait l’appli dans son compte.
Pour installer votre appli à partir de l’annonce, procédez comme suit :
Connectez-vous à Snowsight.
Dans le menu de navigation, sélectionnez Data Products » Apps.
Sélectionnez la vignette pour l’annonce sous Recently shared with you.
Sélectionnez Get.
Saisissez un nom orienté client pour l’appli. Pour ce tutoriel, utilisez « Hello Snowflake App ».
Sélectionnez l’entrepôt dans lequel installer l’application.
Sélectionnez Get.
Sélectionnez Open pour voir votre annonce ou Done pour terminer.
Dans cette section, vous avez appris à publier et à installer une annonce qui vous permet de partager votre appli avec d’autres utilisateurs de Snowflake.
En savoir plus¶
Félicitations ! Non seulement vous avez terminé ce tutoriel, mais vous avez travaillé sur le cycle de vie du développement et de la publication d’une appli en utilisant le Snowflake Native App Framework.
Vous avez :
Utilisez Snowsight et Snowflake CLI pour construire une appli à l’aide de Snowflake Native App Framework.
Pour plus d’informations sur Snowsight, voir Premiers pas avec les feuilles de calcul et Utilisation de feuilles de calcul dans Snowsight.
Pour plus d’informations sur Snowflake Native App dans Snowflake CLI, reportez-vous à Utilisation de Snowflake Native App dans Snowflake CLI.
Créé le manifeste et le script d’installation requis par toutes les applis.
Reportez-vous à Création du fichier manifeste d’un paquet d’application et Création d’un script de configuration pour plus de détails.
Créé un paquet d’application qui fonctionne comme un conteneur pour la logique d’application et le contenu des données de votre appli.
Reportez-vous à Création d’un paquet d’application pour plus de détails.
Ajouté de la logique à votre appli en utilisant des procédures stockées et des UDFs écrites en Python.
Reportez-vous à Ajout d’une logique d’application à un paquet d’application pour obtenir des informations sur l’utilisation des procédures stockées, des UDFs, et des fonctions externes dans le Snowflake Native App Framework.
Reportez-vous à API Snowpark, Extension de Snowflake avec des fonctions et des procédures et Écriture de fonctions externes pour obtenir des informations générales sur chaque type de procédure et de fonction.
Ajouté un contenu de données partagées à votre application.
Pour plus d’informations, reportez-vous à Partager du contenu de données dans une Snowflake Native App.
Inclus une appli Streamlit dans votre appli.
Pour plus d’informations, reportez-vous à Ajouter une expérience front-end à une application en utilisant Streamlit.
Vu votre appli dans Snowsight.
Reportez-vous à Utilisation des applis en tant que consommateur
Créé une annonce privée pour votre appli et installé l’appli dans un compte Snowflake séparé.
Reportez-vous à Partage d’une appli avec des consommateurs pour obtenir des informations sur la publication d’une annonce contenant un paquet d’application.
Reportez-vous à Installation d’une appli à partir d’une annonce pour obtenir des informations sur la manière dont les consommateurs installent une appli à partir d’une annonce.