Tutoriel 2 : Créer une application avec des conteneurs¶
Introduction¶
Le Snowflake Native App Framework permet aux fournisseurs de créer, de vendre et de distribuer des applications au sein de Snowflake Data Cloud. Les fournisseurs peuvent créer des applications qui s’appuient sur les fonctionnalités de base de Snowflake pour partager les données et la logique d’application avec les consommateurs. La logique d’une Snowflake Native App peut inclure des fonctionnalités telles que des procédures stockées et des fonctions définies par l’utilisateur (UDFs). Les fournisseurs peuvent partager leurs applications avec les consommateurs par le biais d’annonces sur le Snowflake MarketPlace ou de listes privées.
Une Snowflake Native App peut également mettre en œuvre Snowpark Container Services pour faciliter le déploiement, la gestion et la mise à l’échelle des applications conteneurisées au sein de l’écosystème Snowflake. Ce tutoriel décrit comment créer un Snowflake Native App with Snowpark Container Services, qui est une Snowflake Native App qui exécute des charges de travail de conteneur dans Snowflake. Snowflake Native Apps with Snowpark Container Services peut exécuter n’importe quel service conteneurisé, tout en tirant parti de toutes les fonctions du Snowflake Native App Framework, y compris la sécurité, la journalisation, le contenu de données partagé et la logique d’application.
Note
Ce tutoriel utilise à la fois Snowflake CLI et Snowsight pour effectuer les tâches requises.
Ce que vous apprenez dans ce tutoriel¶
Dans ce tutoriel, vous apprenez à :
Utilisez Snowflake CLI pour initialiser un projet Snowflake Native App with Snowpark Container Services.
Créez une image Docker pour une appli.
Créez le paquet d’application et les fichiers d’application requis pour un Snowflake Native App with Snowpark Container Services.
Testez un Snowflake Native App with Snowpark Container Services en appelant la fonction de service dans le conteneur.
Configurer votre environnement Snowflake¶
Pour réaliser ce tutoriel, vous devez remplir les conditions préalables suivantes :
Accès à un compte Snowflake qui prend en charge Snowpark Container Services.
Vous devez pouvoir utiliser le rôle ACCOUNTADMIN pour créer le rôle utilisé dans ce tutoriel et lui accorder les privilèges requis.
Vous devez avoir Snowflake CLI version
3.0.0
ou supérieure installée sur votre machine locale.Docker Desktop doit être installé sur votre machine locale.
Créer un rôle pour ce tutoriel¶
Ce tutoriel vous guide à travers le processus de création d’un Snowflake Native App with Snowpark Container Services à l’aide du rôle tutorial_role
. Avant de suivre ce tutoriel, un utilisateur de Snowflake ayant le rôle ACCOUNTADMIN doit effectuer les étapes suivantes pour configurer ce rôle.
Pour créer et configurer le rôle tutorial_role
, procédez comme suit :
Pour créer le rôle
tutorial_role
, exécutez la commande suivante :CREATE ROLE tutorial_role;
Pour accorder le
tutorial_role
à l’utilisateur Snowflake qui effectue le tutoriel, exécutez la commande suivante :GRANT ROLE tutorial_role TO USER <user_name>;
Où :
user_name
Spécifie le nom de l’utilisateur qui effectue le tutoriel.
Pour accorder les privilèges nécessaires à la création et à l’utilisation des objets Snowflake requis par une appli de conteneur, exécutez les commandes suivantes :
GRANT CREATE INTEGRATION ON ACCOUNT TO ROLE tutorial_role; GRANT CREATE WAREHOUSE ON ACCOUNT TO ROLE tutorial_role; GRANT CREATE DATABASE ON ACCOUNT TO ROLE tutorial_role; GRANT CREATE APPLICATION PACKAGE ON ACCOUNT TO ROLE tutorial_role; GRANT CREATE APPLICATION ON ACCOUNT TO ROLE tutorial_role; GRANT CREATE COMPUTE POOL ON ACCOUNT TO ROLE tutorial_role WITH GRANT OPTION; GRANT BIND SERVICE ENDPOINT ON ACCOUNT TO ROLE tutorial_role WITH GRANT OPTION;
Après avoir effectué les tâches décrites dans cette section, l’utilisateur auquel le rôle tutorial_role
a été attribué sur son compte dispose des autorisations nécessaires pour créer tous les objets Snowflake requis pour créer un Snowflake Native App with Snowpark Container Services.
Vous utiliserez ce rôle tout au long de ce tutoriel.
Dans une situation réelle, un fournisseur peut avoir besoin de privilèges similaires ou d’un accès à des objets existants pour développer une appli avec des conteneurs, notamment un pool de calcul, un entrepôt et une base de données.
Créer les objets requis dans votre compte¶
Dans cette section, vous créez les objets Snowflake requis par une application avec conteneurs.
Créer un entrepôt et un référentiel d’images¶
Pour créer les objets requis, effectuez les opérations suivantes via Snowsight ou Snowflake CLI.
Pour définir le contexte actuel dans Snowsight afin qu’il utilise le rôle
tutorial_role
, exécutez la commande suivante :USE ROLE tutorial_role;
Si vous utilisez Snowflake CLI, vous pouvez utiliser
--role tutorial_role
à la place.Pour créer un entrepôt pour Snowflake Native App with Snowpark Container Services, exécutez la commande suivante :
CREATE OR REPLACE WAREHOUSE tutorial_warehouse WITH WAREHOUSE_SIZE = 'X-SMALL' AUTO_SUSPEND = 180 AUTO_RESUME = true INITIALLY_SUSPENDED = false;
Un entrepôt est requis par la Snowflake Native App pour exécuter les commandes SQL et les procédures stockées.
Pour créer le référentiel d’images utilisé pour stocker le conteneur, exécutez la commande suivante :
CREATE DATABASE tutorial_image_database; CREATE SCHEMA tutorial_image_schema; CREATE IMAGE REPOSITORY tutorial_image_repo;
Dans cette section, vous avez créé un entrepôt qui est utilisé pour exécuter des requêtes pour l’application que vous allez créer, ainsi qu’un référentiel d’images pour héberger des images de conteneurs.
Dans la section suivante, vous créez une image pour le conteneur et la télécharger dans le référentiel d’images que vous avez créé ci-dessus.
Créer une connexion de CLI Snowflake pour le tutoriel¶
Pour exécuter les commandes Snowflake CLI de ce tutoriel, vous devez établir une connexion Snowflake CLI pour le tutoriel.
Pour créer une connexion, effectuez les tâches suivantes :
Dans le terminal, exécutez la commande suivante :
snow connection add
Entrez
tut-connection
comme nom de la connexion.Saisissez des informations supplémentaires pour la connexion Snowflake CLI.
Les valeurs spécifiques que vous utilisez dépendent de votre compte Snowflake. Toutefois, vous devez utiliser les valeurs suivantes pour les propriétés du rôle, de l’entrepôt, de la base de données et du schéma :
Paramètre
Valeur requise
Rôle de la connexion
tutorial_role
Entrepôt pour la connexion
tutorial_warehouse
Base de données pour la connexion
tutorial_image_database
Schéma de la connexion
tutorial_image_schema
Vérifiez la connexion en exécutant la commande suivante :
snow connection test -c tut-connection
La sortie de cette commande devrait ressembler à ce qui suit :
+----------------------------------------------------------------------------------+ | key | value | |-----------------+----------------------------------------------------------------| | Connection name | tut-connection | | Status | OK | | Host | USER_ACCOUNT.snowflakecomputing.com | | Account | USER_ACCOUNT | | User | tutorial_user | | Role | TUTORIAL_ROLE | | Database | TUTORIAL_IMAGE_DATABASE | | Warehouse | TUTORIAL_WAREHOUSE | +----------------------------------------------------------------------------------+
Prudence
Si vous ne créez pas la connexion tut-connection
, vous devez utiliser une connexion qui spécifie les valeurs correctes pour les propriétés du rôle, de la base de données et de la connexion à l’entrepôt.
Configurer un projet pour l’application¶
Dans la section précédente, vous avez établi une connexion Snowflake CLI pour le tutoriel.
Dans cette section, vous utilisez Snowflake CLI pour créer un projet pour votre application. Un projet contient toutes les ressources nécessaires à une application. Ces fichiers sont stockés sur votre système de fichiers local et peuvent être gérés par un système de contrôle de version dans le cadre de votre flux de développement.
Créer un fichier de projet à l’aide de la CLI Snowflake¶
Pour créer un fichier de projet, exécutez la commande suivante :
snow init --template app_basic na-spcs-tutorial
Saisissez une valeur pour l’identificateur du projet.
Vous ajoutez d’autres fichiers et sous-dossiers à ce dossier et vous modifiez les fichiers créés par cette commande dans les sous-sections suivantes.
Cette commande crée un dossier nommé na-spcs-tutorial
en utilisant le modèle de projet app_basic
.
Dans le dossier na-spcs-tutorial
, cette commande crée les fichiers et dossiers suivants :
├── README.md
├── app
└── manifest.yml
└── README.md
└── setup_script.sql
├── snowflake.yml
Dans les sections suivantes, vous modifiez ces fichiers et ajoutez des ressources supplémentaires à votre application.
Ajouter les fichiers de service au projet d’application¶
Dans la section précédente, vous avez créé un projet qui comprend les fichiers d’application par défaut nécessaires à votre application. Dans cette section, vous ajoutez les fichiers nécessaires à la création du conteneur pour votre application.
Créez un dossier appelé
service
à l’intérieur du dossierna-spcs-tutorial
.Ce dossier contient le code source du service basé sur un conteneur que nous sommes sur le point de construire et de publier sur Snowflake.
Pour obtenir les fichiers Docker requis pour le tutoriel, téléchargez le fichier
na_spcs_tutorial.zip
sur votre système local.Décompressez le contenu du fichier zip dans le dossier
na-spcs-tutorial/service
. Ce dossier doit contenir les fichiers suivants :echo_service.py
Dockerfile
templates/basic_ui.html
echo_spec.yaml
Vérifier la structure du répertoire de votre projet¶
Après avoir créé le projet pour votre application et ajouté les fichiers pour le service et le conteneur Docker, le projet doit avoir la structure suivante dans le dossier na-spcs-tutorial
:
├── app
└── manifest.yml
└── README.md
└── setup_script.sql
├── README.md
├── service
└── echo_service.py
├── echo_spec.yaml
├── Dockerfile
└── templates
└── basic_ui.html
├── snowflake.yml
Construire une image pour un service Snowpark Container Services¶
Dans cette section, vous créez une image Docker et la téléchargez dans le référentiel d’images que vous avez créé dans la section précédente.
Créer une image Docker et la télécharger dans le référentiel d’images.¶
Pour créer une image Docker et la télécharger dans le référentiel d’images, procédez comme suit :
Dans une fenêtre de terminal, accédez au dossier
na-spcs-tutorial/service
.Exécutez la commande Docker CLI suivante. Notez que vous devez spécifier le répertoire de travail actuel (.) dans la commande :
docker build --rm --platform linux/amd64 -t my_echo_service_image:tutorial .
Cette commande permet d’effectuer les opérations suivantes :
Construit une image Docker en utilisant le fichier Docker inclus dans le fichier zip que vous avez téléchargé
Nomme l’image
my_echo_service_image
Applique la balise
tutorial
à l’image.
Pour identifier l’URL du référentiel d’images que vous avez créé dans une section précédente, exécutez la commande suivante :
REPO_URL=$(snow spcs image-repository url tutorial_image_database.tutorial_image_schema.tutorial_image_repo -c tut-connection) echo $REPO_URL
L’URL du référentiel d’images est capturée dans la variable
$REPO_URL
, puis imprimée dans la console. Vous utiliserez cette valeur à l’étape suivante.Pour créer une balise pour l’image qui inclut l’URL de l’image, exécutez la commande Docker CLI suivante :
docker tag <image_name> <image_url>/<image_name>
Cette commande nécessite deux paramètres :
<image_name>
Spécifie le nom de l’image et de la balise.<image_url>/<image_name>
Spécifie l’URL du référentiel d’images où l’image est téléchargée ainsi que le nom et la balise de l’image où elle doit être stockée dans le référentiel distant.
Pour ce tutoriel, utilisez
$REPO_URL
etmy_echo_service_image:tutorial
:docker tag my_echo_service_image:tutorial $REPO_URL/my_echo_service_image:tutorial
Pour vous authentifier auprès du registre Snowflake, exécutez la commande suivante de Snowflake CLI :
snow spcs image-registry login -c tut-connection
Cette commande charge les identifiants de connexion nécessaires pour que Docker CLI utilise les référentiels d’images de votre compte Snowflake. Vous devez spécifier le nom de la connexion si vous n’utilisez pas le nom par défaut.
Le message
Login Succeeded
s’affiche si tout s’est déroulé correctement.Pour télécharger l’image Docker dans le référentiel d’images, exécutez la commande
docker push
suivante :docker push $REPO_URL/<image_name>
En utilisant la même valeur que
<image_name>
des étapes précédentes, cette commande est :docker push $REPO_URL/my_echo_service_image:tutorial
Confirmez que l’image a été téléchargée avec succès en exécutant la commande suivante :
snow spcs image-repository list-images tutorial_image_database.tutorial_image_schema.tutorial_image_repo -c tut-connection
Dans cette section, vous avez créé une image Docker contenant le service echo et l’avez poussée vers le référentiel d’images tutorial_repository
que vous avez créé plus tôt dans le tutoriel.
Dans la section suivante, vous créez un paquet d’application qui utilise cette image.
Développer votre Snowflake Native App¶
Dans une section précédente, vous avez utilisé la Snowflake CLI pour créer un fichier de projet basé sur un modèle de projet. Ce modèle crée des versions par défaut des fichiers requis par l’application.
Dans cette section, vous mettez à jour ces fichiers par défaut pour votre application :
- Fichier de définition du projet
Un fichier YAML qui contient des informations sur le(s) objet(s) Snowflake que vous souhaitez créer. Ce fichier s’appelle
snowflake.yml
et est utilisé par Snowflake CLI pour déployer le paquet d’application et l’objet dans votre compte.- Fichier manifeste
Un fichier YAML qui contient des informations de configuration de base sur l’application. Ce fichier s’appelle
manifest.yml
.- Script d’installation
Script SQL qui s’exécute automatiquement lorsqu’un consommateur installe une application dans son compte. Ce fichier peut être appelé comme vous le souhaitez, tant qu’il est référencé par votre manifeste.
Le premier fichier est utilisé par Snowflake CLI, tandis que les deux derniers sont requis par le Snowflake Native App Framework.
Vous en apprendrez plus sur ces fichiers et leur contenu tout au long de ce tutoriel.
Dans cette section, vous créez également un fichier lisez-moi qui sera utile lors de la vue et de la publication de votre application.
Modifier le fichier manifeste par défaut¶
Pour modifier le fichier manifeste de l’application, procédez comme suit :
Modifiez
na-spcs-tutorial/app/manifest.yml
pour qu’il ressemble à ce qui suit :manifest_version: 1 artifacts: setup_script: setup_script.sql readme: README.md container_services: images: - /tutorial_image_database/tutorial_image_schema/tutorial_image_repo/my_echo_service_image:tutorial privileges: - BIND SERVICE ENDPOINT: description: "A service that can respond to requests from public endpoints." - CREATE COMPUTE POOL: description: "Permission to create compute pools for running services"
Cet exemple comprend ce qui suit :
La propriété
artifacts
spécifie les emplacements des ressources requises par une appli avec des conteneurs, y compris l’emplacement de l’image Docker que vous avez créée dans une étape précédente, ainsi que le projet README qui est visible dans Snowsight.La propriété
privileges
permet à un service de répondre aux demandes publiques et de créer son propre pool de calcul. Ces propriétés sont nécessaires à l’instanciation de notre service dans l’étape suivante du tutoriel.
Modifier le script d’installation par défaut¶
Pour modifier le script d’installation par défaut du paquet d’application, procédez comme suit :
Modifiez le fichier
na-spcs-tutorial/app/setup_script.sql
pour y inclure les éléments suivants :CREATE APPLICATION ROLE IF NOT EXISTS app_user; CREATE SCHEMA IF NOT EXISTS core; GRANT USAGE ON SCHEMA core TO APPLICATION ROLE app_user; CREATE OR ALTER VERSIONED SCHEMA app_public; GRANT USAGE ON SCHEMA app_public TO APPLICATION ROLE app_user; CREATE OR REPLACE PROCEDURE app_public.start_app() RETURNS string LANGUAGE sql AS $$ BEGIN -- account-level compute pool object prefixed with app name to prevent clashes LET pool_name := (SELECT CURRENT_DATABASE()) || '_compute_pool'; CREATE COMPUTE POOL IF NOT EXISTS IDENTIFIER(:pool_name) MIN_NODES = 1 MAX_NODES = 1 INSTANCE_FAMILY = CPU_X64_XS AUTO_RESUME = true; CREATE SERVICE IF NOT EXISTS core.echo_service IN COMPUTE POOL identifier(:pool_name) FROM spec='service/echo_spec.yaml'; CREATE OR REPLACE FUNCTION core.my_echo_udf (TEXT VARCHAR) RETURNS varchar SERVICE=core.echo_service ENDPOINT=echoendpoint AS '/echo'; GRANT USAGE ON FUNCTION core.my_echo_udf (varchar) TO APPLICATION ROLE app_user; RETURN 'Service successfully created'; END; $$; GRANT USAGE ON PROCEDURE app_public.start_app() TO APPLICATION ROLE app_user; CREATE OR REPLACE PROCEDURE app_public.service_status() RETURNS TABLE () LANGUAGE SQL EXECUTE AS OWNER AS $$ BEGIN LET stmt VARCHAR := 'SHOW SERVICE CONTAINERS IN SERVICE core.echo_service; LET res RESULTSET := (EXECUTE IMMEDIATE :stmt); RETURN TABLE(res); END; $$; GRANT USAGE ON PROCEDURE app_public.service_status() TO APPLICATION ROLE app_user;
Modifier le fichier README par défaut¶
Pour modifier le fichier README de l’application, procédez comme suit :
Modifiez
na-spcs-tutorial/app/README.md
pour qu’il ressemble à ce qui suit :Welcome to your first app with containers!
Ce fichier README est visible par les consommateurs après l’installation de votre application.
Modifier le fichier de définition du projet par défaut¶
Dans cette section, vous modifiez le fichier de définition du projet utilisé par la Snowflake CLI.
Modifiez
na-spcs-tutorial/snowflake.yml
pour qu’il ressemble à ce qui suit :definition_version: 2 entities: na_spcs_tutorial_pkg: type: application package manifest: app/manifest.yml artifacts: - src: app/* dest: ./ - service/echo_spec.yaml meta: role: tutorial_role warehouse: tutorial_warehouse na_spcs_tutorial_app: type: application from: target: na_spcs_tutorial_pkg debug: false meta: role: tutorial_role warehouse: tutorial_warehouse
Dans cette section, vous avez défini une structure de fichiers locale qui peut être déployée dans un compte Snowflake en tant que Snowflake Native App with Snowpark Container Services. Dans la section suivante, vous effectuez ce déploiement à l’aide de Snowflake CLI.
Créer et tester l’appli¶
Après avoir défini le fichier manifeste, le script d’installation et la spécification de service pour votre Snowflake Native App with Snowpark Container Services, vous pouvez tester l’appli en la déployant sur votre compte à l’aide de Snowflake CLI.
Télécharger les fichiers dans la zone de préparation et créer l’objet de l’application¶
Pour créer une application en mode développement, procédez comme suit :
Dans un terminal, accédez au dossier
na-spcs-tutorial
.Créez le paquet d’application et l’objet dans votre compte en exécutant la commande suivante :
snow app run -c tut-connection
Cette commande affiche une confirmation qu’un paquet d’application appelé
na_spcs_tutorial_pkg
et un objet d’application appeléna_spcs_tutorial_app
ont été créés dans votre compte. Ces noms correspondent aux noms de la définition du projetsnowflake.yml
que vous avez modifié dans une section précédente.
Vous pouvez utiliser la sortie d’URL vers la console pour voir l’application. Cependant, vous devez d’abord vous assurer qu’il dispose de tous les privilèges nécessaires pour créer son service basé sur un conteneur.
Accorder les privilèges et tester l’application¶
Dans cette section, vous accordez les privilèges requis à l’application et vous la testez en appelant les services du conteneur.
Vous pouvez exécuter les commandes SQL en utilisant soit Snowsight soit Snowflake CLI.
Pour accorder les privilèges et tester l’application, effectuez les étapes suivantes à partir d’une feuille calcul Snowflake :
Accordez le privilège
CREATE COMPUTE POOL
à l’appli en exécutant ce qui suit :GRANT CREATE COMPUTE POOL ON ACCOUNT TO APPLICATION na_spcs_tutorial_app; GRANT BIND SERVICE ENDPOINT ON ACCOUNT TO APPLICATION na_spcs_tutorial_app;
Exécutez la procédure
app_public.start_app
que nous avons définie dans le fichiersetup_script.sql
.CALL na_spcs_tutorial_app.app_public.start_app();
Cette procédure crée le pool de calcul, instancie le service et crée la fonction de service.
Confirmez la création de la fonction en exécutant la procédure suivante :
SHOW FUNCTIONS LIKE '%my_echo_udf%' IN APPLICATION na_spcs_tutorial_app;
Note
Les consommateurs ne peuvent pas voir le service en cours d’exécution, car il s’exécute dans le cadre du Snowflake Native App. Par exemple, l’exécution de
SHOW SERVICES IN APPLICATION na_spcs_tutorial_app;
ne renvoie rien.Pour vérifier que le service a été créé et qu’il est intègre, exécutez la commande suivante :
CALL na_spcs_tutorial_app.app_public.service_status();
Cette instruction appelle la procédure
app_public.service_status
que vous avez définie dans le script d’installation. La procédure renvoie des informations sur les conteneurs de ce service.Si la valeur de la colonne
status
n’est pasREADY
, exécutez à nouveau l’instruction jusqu’à ce que le statut du conteneur de service soitREADY
.Pour appeler la fonction de service afin d’envoyer une requête au service et de vérifier la réponse, exécutez la commande suivante :
SELECT na_spcs_tutorial_app.core.my_echo_udf('hello');
Le message suivant s’affiche, provenant du service que vous avez configuré dans une section précédente :
``Bob said hello``
Démonter l’application et les objets créés dans le tutoriel¶
Prudence
Si vous planifiez d’effectuer la Tutoriel 3 : Mettre à niveau une application avec des conteneurs après avoir terminé ce tutoriel, n’effectuez pas les étapes de cette section. L’application avec conteneurs que vous avez créée dans ce tutoriel est un prérequis pour le tutoriel de mise à niveau.
Comme l’appli utilise un pool de calcul, elle accumule des crédits sur votre compte et son utilisation coûte de l’argent. Pour empêcher l’application de consommer des ressources, vous devez supprimer l’objet d’application et tous les objets de niveau compte qu’elle a créés, par exemple le pool de calcul.
Pour confirmer que le pool de calcul est en cours d’exécution, exécutez la commande suivante :
snow object list compute-pool -l "na_spcs_tutorial_app_%"
Si le pool de calcul est en cours d’exécution, une ligne contenant un pool de calcul
ACTIVE
créé par l’objet d’application s’affiche.Exécutez la commande Snowflake CLI suivante pour démonter l’application :
snow app teardown --cascade --force -c tut-connection
Cette commande supprime tous les objets Snowflake créés par l’application. Sans l’option
--force
, cette commande n’abandonne pas le paquet d’application parce qu’il contient des versions.Pour confirmer que le pool de calcul a été détruit, exécutez à nouveau la commande suivante :
snow object list compute-pool -l "na_spcs_tutorial_app_%"
Cette commande renvoie
no data
si le pool de calcul a été détruit correctement.
Note
La commande snow app teardown
supprime à la fois le paquet d’application et l’objet de l’application. Par conséquent, toutes les données relatives à l’état sont perdues.
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 Snowflake Native App with Snowpark Container Services.
Vous avez :
Utilisé Snowsight et Snowflake CLI pour créer une application à l’aide de Snowflake Native App Framework.
Voir Configuration de Snowflake CLI et connexion à Snowflake pour plus d’informations sur la configuration des connexions utilisées par Snowflake CLI.
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 les Native Apps 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 applications.
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 application.
Reportez-vous à Création d’un paquet d’application pour plus de détails.
Utilisé Docker CLI et Snowflake CLI pour construire et télécharger un conteneur dans Snowflake.
Utilisé Snowpark Container Services pour créer un
COMPUTE POOL
et instancier le conteneur à l’intérieur d’une Snowflake Native App.