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 :

  1. Pour créer le rôle tutorial_role, exécutez la commande suivante :

    CREATE ROLE tutorial_role;
    
    Copy
  2. 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>;
    
    Copy

    Où :

    user_name

    Spécifie le nom de l’utilisateur qui effectue le tutoriel.

  3. 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;
    
    Copy

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.

  1. 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;
    
    Copy

    Si vous utilisez Snowflake CLI, vous pouvez utiliser --role tutorial_role à la place.

  2. 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;
    
    Copy

    Un entrepôt est requis par la Snowflake Native App pour exécuter les commandes SQL et les procédures stockées.

  3. 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;
    
    Copy

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 :

  1. Dans le terminal, exécutez la commande suivante :

    snow connection add
    
    Copy
  2. Entrez tut-connection comme nom de la connexion.

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

  4. Vérifiez la connexion en exécutant la commande suivante :

    snow connection test -c tut-connection
    
    Copy

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

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

  1. Pour créer un fichier de projet, exécutez la commande suivante :

    snow init --template app_basic na-spcs-tutorial
    
    Copy
  2. 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
Copy

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.

  1. Créez un dossier appelé service à l’intérieur du dossier na-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.

  2. Pour obtenir les fichiers Docker requis pour le tutoriel, téléchargez le fichier na_spcs_tutorial.zip sur votre système local.

  3. 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
Copy

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 :

  1. Dans une fenêtre de terminal, accédez au dossier na-spcs-tutorial/service.

  2. 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 .
    
    Copy

    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.

  3. 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
    
    Copy

    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.

  4. 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>
    
    Copy

    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 et my_echo_service_image:tutorial :

    docker tag my_echo_service_image:tutorial $REPO_URL/my_echo_service_image:tutorial
    
    Copy
  5. Pour vous authentifier auprès du registre Snowflake, exécutez la commande suivante de Snowflake CLI :

    snow spcs image-registry login -c tut-connection
    
    Copy

    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.

  6. 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>
    
    Copy

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

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 :

  1. 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"
    
    Copy

    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 :

  1. 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;
    
    Copy

Modifier le fichier README par défaut

Pour modifier le fichier README de l’application, procédez comme suit :

  1. Modifiez na-spcs-tutorial/app/README.md pour qu’il ressemble à ce qui suit :

    Welcome to your first app with containers!
    
    Copy

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.

  1. 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
    
    Copy

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 :

  1. Dans un terminal, accédez au dossier na-spcs-tutorial.

  2. Créez le paquet d’application et l’objet dans votre compte en exécutant la commande suivante :

    snow app run -c tut-connection
    
    Copy

    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 projet snowflake.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 :

  1. 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;
    
    Copy
  2. Exécutez la procédure app_public.start_app que nous avons définie dans le fichier setup_script.sql.

    CALL na_spcs_tutorial_app.app_public.start_app();
    
    Copy

    Cette procédure crée le pool de calcul, instancie le service et crée la fonction de service.

  3. 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;
    
    Copy

    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.

  4. 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();
    
    Copy

    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 pas READY, exécutez à nouveau l’instruction jusqu’à ce que le statut du conteneur de service soit READY.

  5. 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');
    
    Copy

    Le message suivant s’affiche, provenant du service que vous avez configuré dans une section précédente :

    ``Bob said hello``
    
    Copy

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.

  1. 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_%"
    
    Copy

    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.

  2. Exécutez la commande Snowflake CLI suivante pour démonter l’application :

    snow app teardown --cascade --force -c tut-connection
    
    Copy

    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.

  3. 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_%"
    
    Copy

    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 :