Tutorial: Developing an Application with the Native Apps Framework¶
Introduction¶
This tutorial describes how to use the Native Apps Framework to create an application to share data and related business logic with other Snowflake accounts.
The tutorial uses the Snowsight web interface, but you can use any Snowflake client that supports running SQL, for example SnowSQL.
What You Will Learn¶
In this tutorial, you will learn how to:
Create an application package that contains the data and business logic of your application.
Share data with an application package.
Add business logic to an application package.
Test the application locally.
View and test the application in Snowsight.
Publish your application by creating a private listing.
Install the application from a private listing.
About Providers and Consumers¶
Within the context of the Native Apps Framework, providers are the roles and organizations who have data and business logic that they want to share with other Snowflake users, who are the consumers. A consumer can be another account within your organization, a different organization within your company, or a Snowflake user in another company.
Within the context of this tutorial, most of the tasks you will perform are those typically performed by providers, but these include tasks that may be performed by multiple roles within your organization including application developers and database administrators.
In this tutorial, you will also perform tasks that mimic the actions performed by consumers to install an application.
Prerequisites¶
You must run all of the SQL commands in the same SQL command session because the session context is required.
To do this in Snowsight, for example, paste all of your code into the same worksheet as you go along. As you progress from section to section, each section builds on the previous.
You must be able to use the ACCOUNTADMIN role.
In this tutorial, you will perform all the steps using the ACCOUNTADMIN role. In general practice, however, you would use roles with privileges specifically defined for the action you’re performing. For example, you might have separate roles for developers who create UDFs and stored procedures, for database administrators who manage roles and permissions, and for administrators who manage listings using Snowflake Collaboration.
To install your application from a private listing, you must have access to a second Snowflake account. You will use this account to mimic how consumers would install an application.
Note
Although the Native Apps Framework supports sharing applications with accounts in different organizations, for the purposes of this tutorial, both accounts must be in the same organization.
You must set a current warehouse before performing the tutorial. A warehouse must be specified for a session and the warehouse must be running before queries and other DML statements can be executed in the session. Refer to USE WAREHOUSE for details.
Create the Application Files¶
In this section, you will create a setup script and manifest file. Both of these files are required by the Native Apps Framework.
- Setup Script
An SQL script that runs automatically when a consumer installs an application in their account.
- Manifest file
A YAML file that contains basic configuration information about the application.
You will learn more about both of these files, and their contents, throughout this tutorial. You will also create a readme file that will be useful when viewing and publishing your application in later sections of this tutorial.
Create the Setup Script¶
To create the setup script, do the following:
On your local file system create a folder named
tutorial
. This will be the root directory for the external files of your application.Note
You will add additional files and subfolders to this folder in later sections.
In the
tutorial
folder create a subfolder namedscripts
.In this folder create a new file named
setup.sql
.Note
This tutorial will refer to this structure and filename for the setup script. However, when building your own application you can choose your own name and directory structure for this file.
Add the following SQL statement to this file:
-- Setup script for the Hello Snowflake! application.
You are adding this line as a placeholder because the setup script cannot be empty.
Create a README File for Your Application¶
A readme file provides a description of what your application does. You will see the readme when you view your application in Snowsight.
To create the readme.md file for your application:
In the
tutorial
folder, create a file namedreadme.md
.Add the following content to this file:
This is the readme file for the Hello Snowflake Application!
Create the Manifest File¶
The Native Apps Framework requires a manifest file for each application. The manifest file contains metadata and configuration parameters for an application.
To create the manifest file:
In the
tutorial
folder, create a file namedmanifest.yml
.Note
This file must be named
manifest.yml
and it must exist at the root level of your project. Paths to other files, including the setup script are relative to the location of this file.Add the following content to this file:
manifest_version: 1 artifacts: setup_script: scripts/setup.sql readme: readme.md
The
setup_script
property specifies the location of the setup script relative to the location of the manifest file. The path and file name specified here must be the same as the location of the setup script you created above.Note
The
manifest_version
,artifacts
, andsetup_script
properties are required. Thereadme
property is optional.
Review What You Learned in This Section¶
After performing the steps in this section, you should now have a directory structure that looks like the following:
/tutorial
manifest.yml
readme.md
/scripts/
setup.sql
In this section you learned how to create the setup script and manifest files that are required by the Native Apps Framework. Although the content you added to both of these files is basic, all applications must have these files.
You also added a readme file that is displayed when viewing your application in Snowsight or when publishing your application as a listing.
Create an Application Package¶
In this section you will create an application package that will function as a container for the resources required by your application. You will perform the following tasks:
Create an application package.
Create a named stage within the application package.
Create an Application Package¶
At its core, an application package is a Snowflake database that is extended to include additional information about an application. In that sense, it is a container for an application that includes:
Shared data content
Application files
To create an application package:
To grant the CREATE APPLICATION PACKAGE privilege to your role, run the following command:
GRANT CREATE APPLICATION PACKAGE ON ACCOUNT TO ROLE accountadmin;
Note
Although the ACCOUNTADMIN role has this privilege by default, to be able to create an application package, you must ensure that your role has been granted this privilege.
To create the application package, run the following command:
CREATE APPLICATION PACKAGE hello_snowflake_package;
Note
After running this command, the current context changes to HELLO_SNOWFLAKE_PACKAGE.
To verify the application package was successfully created, run the following command:
SHOW APPLICATION PACKAGES;
You should see
HELLO_SNOWFLAKE_PACKAGE
in thename
column of the output. Refer to SHOW APPLICATION PACKAGES for additional information on this command.
In this section you learned that an application package is a container for the resources used by an application. You also learned how to create an application package.
Create a Named Stage¶
In this section you will create a named stage to store files required by the Native Apps Framework. A named stage is also required to store any external code files you want to include in your application. Uploading these files to a named stage makes them available when creating your application.
To create a named stage, do the following:
To set the context to the application package you created in the previous section, run the following command:
USE APPLICATION PACKAGE hello_snowflake_package;
To create the required schema for the named stage, run the following command:
CREATE SCHEMA stage_content;
To create the named stage, run the following command.
CREATE OR REPLACE STAGE hello_snowflake_package.stage_content.hello_snowflake_stage FILE_FORMAT = (TYPE = 'csv' FIELD_DELIMITER = '|' SKIP_HEADER = 1);
This command creates the named stage in the database and schema you created in the previous steps.
Note
You must include
FILE_FORMAT = (TYPE = 'CSV' FIELD_DELIMITER = '|' SKIP_HEADER = 1);
as part of this command. These are not optional.
You now have a named stage within the application package where you can upload the files you will use to build your application.
Note
Although this tutorial uses a named stage within the application package, this is not a requirement. You can also use a named stage that exists in a database and schema outside the application package.
Upload the Application Files to the Named Stage¶
In the previous section, you created an application package that will serve as the container for your application. You also created a named stage within the application package that contains the required application files.
In this section you will upload these files to the named stage.
To upload application files, do one of the following:
Upload the application files using Snowsight as described in Staging Files Using Snowsight
Upload the application files using SnowSQL by running the following commands:
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;
Note
Modify the path in the examples above to reflect the path to the root folder of your project.
In your worksheet, run the following command to verify that the file upload was successful:
LIST @hello_snowflake_package.stage_content.hello_snowflake_stage;
After running this command, you should see each of the files listed as shown in the following output:
+----------------------------------------+------+----------------------------------+-------------------------------+
| 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 |
+----------------------------------------+------+----------------------------------+-------------------------------+
In this section, you uploaded the application files to a named stage. These files are now available to the application package as you continue to develop your application. In later sections, as you add features to your application, you will return to this section to upload revised versions of these files and new files.
Add Application Logic and Install Your First Application¶
In this section, you will add code and install your first application. To do this, you will perform the following tasks:
Add a stored procedure to the setup script.
Add a version to the application.
Install and test the application.
Add a Stored Procedure to the Setup Script¶
In the previous section, you created an application package. However, the application package doesn’t yet contain any data content or application files.
In this section, you will add a stored procedure to the application by adding the code for the stored procedure to the setup script on your local file system.
To add a stored procedure to the setup script:
Add the following SQL statements at the end of the
setup.sql
file you created in an earlier section:CREATE APPLICATION ROLE app_public; CREATE SCHEMA IF NOT EXISTS core; GRANT USAGE ON SCHEMA core TO APPLICATION ROLE app_public;
When the setup script is run during installation, these statements create an application role named
app_public
. Application roles are similar to database roles, but they can only be used within the context of an application. They are used to grant access to objects within the application.This example also creates a schema to contain the stored procedure and grants the USAGE privilege on the schema to the application role. Creating an application role and granting privileges on an object, for example a schema, to the application role is a common pattern within the setup script.
Add the code for the stored procedure at the end of the
setup.sql
file:CREATE OR REPLACE PROCEDURE CORE.HELLO() RETURNS STRING LANGUAGE SQL EXECUTE AS OWNER AS BEGIN RETURN 'Hello Snowflake!'; END;
This example creates a stored procedure that outputs the string “Hello Snowflake!”.
Add the following the following statement to the end of the
setup.sql
file:GRANT USAGE ON PROCEDURE core.hello() TO APPLICATION ROLE app_public;
This example grants the USAGE privilege on the stored procedure to the application role.
Upload the revised setup script to the named stage.
Refer to the previous section Upload the Application Files to the Named Stage to upload the revised setup script, then return here to continue the tutorial.
In this section you added a stored procedure to the setup script. You also created an application role and granted USAGE privileges to this role. This allows the setup script to create the stored procedure when the application is created. It also give the application permission to run the stored procedure.
Install the Application¶
In the previous section you modified the setup script to include a stored procedure.
In this section, you will install the application and run the stored procedure using Snowsight.
To install an application, do the following:
To create the application, run the following command:
CREATE APPLICATION HELLO_SNOWFLAKE_APP FROM APPLICATION PACKAGE HELLO_SNOWFLAKE_PACKAGE USING '@hello_snowflake_package.stage_content.hello_snowflake_stage';
To verify that the application was created successfully, run the following command:
SHOW APPLICATIONS;
You should see the
HELLO_SNOWFLAKE_APP
listed under thename
column of the output.To run the
HELLO
stored procedure that you added tosetup.sql
in a previous section, run the following command:CALL core.hello();
You should see the following output after running this command:
+------------------+ | HELLO | |------------------| | HELLO SNOWFLAKE! | +------------------+
Review What You Learned in This Section¶
Congratulations! You have created, installed, and tested your first application using the Native Apps Framework! Although the application only has basic functionality, the components you used to build the application are the same for more complex applications.
In this section you completed the following:
Added a stored procedure to the setup script. The setup script specifies how your application is installed in the consumer account. In later sections you will add data content and other types of application logic to your application.
Installed and tested your application by running the stored procedure. In later sections you will learn about other ways to view and test your application.
Add Data Content to Your Application¶
In the previous section you created an application containing a stored procedure that demonstrates how you would add application logic to an application.
In this section you will include data content in your application by creating a database within
the HELLO_SNOWFLAKE_PACAKAGE
application package and granting privileges to share this
database with the application.
Add a View to Access Data Content¶
In this section you will update the setup script to add a view that allows the application to
access the data in the ACCOUNTS
table you created in the previous subsection.
To add a view to access data content:
To create a schema for the view, add the following to the setup script:
CREATE OR ALTER VERSIONED SCHEMA code_schema; GRANT USAGE ON SCHEMA code_schema TO APPLICATION ROLE app_public;
These statements create a versioned schema to contain the view and grant the USAGE privilege on the schema. The Native Apps Framework uses versioned schema to handle different versions of stored procedures and functions.
To create the view, add the following to the setup script:
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;
These statements create the view in the
code_schema
schema and grant the required privilege on the view to the application role.Upload the revised setup script to the named stage.
Refer to the previous section Upload the Application Files to the Named Stage to upload the files you updated in this section, then return here to continue the tutorial.
Test the Updated Application¶
In this subsection, you will reinstall the application and query the example table using the view within the installed application.
To test the updated application, do the following:
To delete the existing application, run the following command:
DROP APPLICATION hello_snowflake_app;
To create a new version of the application, run the following commands:
CREATE APPLICATION hello_snowflake_app FROM APPLICATION PACKAGE hello_snowflake_package USING '@hello_snowflake_package.stage_content.hello_snowflake_stage';
To verify that the view functions correctly, run the following command:
SELECT * FROM code_schema.accounts_view;
The output of this command is identical to the SELECT command you ran when setting up the example data:
+----+----------+-----------+ | ID | NAME | VALUE | |----+----------+-----------| | 1 | Nihar | Snowflake | | 2 | Frank | Snowflake | | 3 | Benoit | Snowflake | | 4 | Steven | Acme | +----+----------+-----------+
Review What You Learned in This Section¶
In this section you learned how to include shared data content in your application by performing the following tasks:
Create the
ACCOUNTS
table within the application package and inserted data into the table.Grant reference usage on the
ACCOUNTS
table to the application package.Create a schema and view that reference the
ACCOUNTS
table in the application package.Grant usage on the schema to the application role.
Grant select on the view to the application role.
You also updated the setup script to perform the following when the application is installed:
Create a schema and view that the application uses to access the example data.
Grant usage on the schema to the application role.
Grant select on the view to the application role.
Note that the commands you ran to set up the HELLO_SNOWFLAKE_DATA
database have parallels in
the setup script.
Add Python Code to Your Application¶
In this section, you will expand the functionality of your application by adding Python code to enhance the application logic. In this section you will include Python code as the following:
An inline Python UDF that is a self-contained function in the setup script.
A Python UDF that references a Python file outside the setup script.
Note
Although this section introduces examples using Python, the same techniques are applicable to Java and JavaScript.
Add an Inline Python Function as a User-defined Function (UDF)¶
In this section you will add a Python function as a UDF.
To include a Python UDF in your application, add the following code to your setup file.
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;
These commands perform the following tasks when the application is installed:
Create a versioned schema named
code_schema
.Grant the usage privilege on the schema to the
APP_PUBLIC
application role.Create the
ADDONE()
UDF in thecode_schema
schema.Grant the usage privilege on the function to the
APP_PUBLIC
application role.
Note that the schema created in the code sample above is a versioned schema. User-defined functions and stored procedures must be defined in a versioned schema instead of a normal schema.
Add an External Python Module¶
To add an external python module to your application:
Add the following Python function to your setup script:
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;
Similar to the previous example, these statement create a Python UDF in a schema and grant privileges on the function to the application role. However, this example contains an IMPORTS clause that refers to an external Python file that you will create.
In the
tutorial
folder create a subfolder namedpython
.In the
python
subfolder, create a file namedhello_python.py
.Add the following to the
hello_python.py
file:def multiply(num1, num2): return num1*num2
The function defined in this external file matches the inline function defined in the setup script.
In this section, you added a Python UDF to your application. This UDF refers to an external Python module that can be referenced by your application package.
Install and Test the Updated Application¶
Upload the new and revised files to the named stage.
Refer to the section Upload the Application Files to the Named Stage to upload the external Python file, then return here to continue the tutorial.
If you are using SnowSQL to upload the file, run the following commands:
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;
To remove the existing application, run the following command:
DROP APPLICATION hello_snowflake_app;
To create a new version of the application, run the following commands:
CREATE APPLICATION hello_snowflake_app FROM APPLICATION PACKAGE hello_snowflake_package USING '@hello_snowflake_package.stage_content.hello_snowflake_stage';
To test the Python stored procedure, run the following command:
SELECT code_schema.addone(1);
To test the referenced Python function, run the following command:
SELECT code_schema.multiply(1,2);
Review What You Learned in This Section¶
In this section, you added the following new functionality to your application:
A Python function defined as an inline UDF.
A Python function defined as a UDF that references external code.
You also tested each of these examples by installing an updated version of your application and running each of the functions.
Add a Streamlit App to Your Application¶
In this section, you will complete your application by adding a Streamlit app. Streamlit is an open source Python framework for developing data science and machine learning applications. You can include Streamlit apps within a Native App to add user interaction and data visualization.
Create the Streamlit App File¶
To create a Streamlit app, do the following:
In the
tutorial
folder, create a subfolder namedstreamlit
.In the
streamlit
folder, create a file namedhello_snowflake.py
.Add the following code to this file:
# 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)
Add the Streamlit Object to the Setup Script¶
To create the Streamlit object in the application, do the following:
Add the following statement at the end of the
setup.sql
file to create the Streamlit object:CREATE STREAMLIT code_schema.hello_snowflake_streamlit FROM '/streamlit' MAIN_FILE = '/hello_snowflake.py' ;
This statement creates a STREAMLIT object in the core schema.
Add the following statement at the end of the
setup.sql
file to allow the APP_PUBLIC role to access the Streamlit object:GRANT USAGE ON STREAMLIT code_schema.hello_snowflake_streamlit TO APPLICATION ROLE app_public;
Upload the new and updated application files to the named stage:
Refer to the previous section Upload the Application Files to the Named Stage to upload the Streamlit file you just created, then return here to continue the tutorial.
If you are using SnowSQL to upload the file, run the following command:
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;
Install the Updated Application¶
Upload the revised setup script to the named stage.
Refer to the previous section Upload the Application Files to the Named Stage to upload the revised setup script, then return here to continue the tutorial.
To remove the previous application, run the following command:
DROP APPLICATION hello_snowflake_app;
To create a new version of the application, run the following command:
CREATE APPLICATION hello_snowflake_app FROM APPLICATION PACKAGE hello_snowflake_package USING '@hello_snowflake_package.stage_content.hello_snowflake_stage';
Review What You Learned in This Section¶
In this section you added a Streamlit app to your application by doing the following:
Create a Streamlit app.
Add a Version to Your Application¶
In this section, you will add a version to your application that includes all of the functionality you have added in this tutorial. To accomplish this, you will use the ALTER APPLICATION PACKAGE command to update the application package you created previously.
To add a version to your application:
To add a version to the
HELLO_SNOWFLAKE_PACKAGE
application package, run the following command:ALTER APPLICATION PACKAGE hello_snowflake_package ADD VERSION v1_0 USING '@hello_snowflake_package.stage_content.hello_snowflake_stage';
In this command, you modified your application package to add a version based on the application files that you uploaded to the named stage in an earlier section.
Note
The value specified for VERSION is a label, not a numerical value or string. Refer to ALTER APPLICATION PACKAGE for more information.
Note
The patch number for the new version you added is automatically created at
0
. As you add additional patches for a version, these are automatically incremented. However, when you create a new version, for exampleV1_1
, the patch number for that version is reset to0
.To verify that the version was added to the application package, run the following command:
SHOW VERSIONS IN APPLICATION PACKAGE hello_snowflake_package;
This command shows additional information about the version as shown in the following output:
+---------+-------+-------+---------+-------------------------------+------------+-----------+-------------+-------+---------------+ | 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 | +---------+-------+-------+---------+-------------------------------+------------+-----------+-------------+-------+---------------+
Refer to SHOW VERSIONS for more information.
To install the application based on a version, run the following command:
DROP APPLICATION hello_snowflake_app; CREATE APPLICATION hello_snowflake_app FROM APPLICATION PACKAGE hello_snowflake_package USING VERSION V1_0;
In this section, you modified the application package to include a version for your application.
View Your Application in Snowsight¶
In this section, you will view your application in Snowsight. In previous sections, you used SQL statements to test or find information about your application. However, you can also view information about your application in Snowsight. You can also view your deployed Streamlit application.
To view your application in Snowsight, do the following:
Sign in to Snowsight.
Open Apps and select the Apps tab.
In Installed Apps select
HELLO_SNOWFLAKE_APP
.The
Read Me
tab displays the content you added to thereadme.md
file in an earlier section.To view your Streamlit app, select HELLOSNOWFLAKE_STREAMLIT.
The content of the
HELLO_SNOWFLAKE_DATA
database displays in a Streamlit data frame.Select Worksheets to open the application in a Snowflake worksheet.
Select HELLO_SNOWFLAKE_APP, then select a schema from the list.
The list of schema corresponds to the schema you added to your application during the tutorial.
From the Snowflake worksheet you can test your application using SQL commands. For example, you can re-run the commands you ran in previous sections to test the features you added to your 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
Any SQL statements that you add to this worksheet are lost when you when you navigate to a different page in Snowsight.
Publish and Install Your Application¶
In this section, you will publish your application by creating a private listing that uses the application package as the data content. After creating the listing, you will login to another account to install the listing.
Set the Default Release Directive¶
Before you can create a listing for your application application package, you must set a release directive. A release directive specifies which version of your application is available to a consumers.
In this tutorial you will set the default release directive using the version you added in a previous section.
To set the default release directive for your application package, do the following:
To view the versions and patches defined for your application package, run the following command:
SHOW VERSIONS IN APPLICATION PACKAGE hello_snowflake_package;
This command displays the versions and patches defined for the application package.
To set the default release directive to version
v1_0
and patch0
, run the following command:ALTER APPLICATION PACKAGE hello_snowflake_package SET DEFAULT RELEASE DIRECTIVE VERSION = v1_0 PATCH = 0;
The output of this command is shown in the following example:
+-----------------------------------------------------------+ | status | |-----------------------------------------------------------| | Default release directive set to version 'V1_0', patch 2. | +-----------------------------------------------------------+
In this section, you verified what versions and patches exist in your application package. Using this information, you defined the default release directive for the application package.
Create a Listing for Your Application¶
Now that you have specified a release directive for your application package, you will create a listing and add the application package as the data content of the listing. This lets you to share your application with other Snowflake users and allows them to install and use the application in their account.
To create a listing for your application:
Sign in to Snowsight.
In the left navigation bar, select Data » Provider Studio.
Select + Listing. The Create Listing window opens.
Enter a name for your listing.
In the Who can discover the listing section, select Only specified consumers to privately share the listing with specific accounts.
Click + Select to select the application package for the listing.
Enter a description for your listing.
In the Add consumer accounts section, add the account identifier for the account you are using to test the consumer experience of installing the application from a listing.
In this section you created a private listing containiing your application package as the shared data content.
Install the Application¶
In this section you will install the application associated with the listing you created in the previous section. You will install the listing in a different account which will mimic how a consumer would install the application in their account.
To install your application from the listing, do the following:
Sign in to Snowsight.
In the left navigation bar, select Apps.
Select the tile for the listing under Recently shared with you.
Select Get.
Enter a customer-facing name for the application. For this tutorial, use “Hello Snowflake App”.
Select the warehouse where you want to install the application.
Select Get.
Select Open to view your listing or Done to finish.
In this section you learned how to publish and install a listing that allows you to share your application with other Snowflake users.
Learn More¶
Congratulations! Not only have you finished this tutorial, but you have worked through development and publishing life cycle of an application using the Native Apps Framework.
Along the way, you:
Used Snowsight and Snowflake worksheets to build an application using the Native Apps Framework.
For more information about Snowsight, refer to Getting Started With Worksheets and Managing and Using Worksheets in Snowsight.
Created the manifest and setup script that are required by all applications.
Refer to Creating the Manifest File and Creating the Setup Script for details.
Created an application package that works as a container for the application logic and data content of your application.
Refer to Creating an Application Package for details.
Added logic to your application using stored procedures and UDFs written in Python.
Refer to Adding Application Logic to an Application Package for information on using stored procedures, UDFs, and external function in the Native Apps Framework.
Refer to Snowpark API, Extending Snowflake with Functions and Procedures and Writing External Functions for general information on each type of procedure and function.
Added shared data content to your application.
Refer to Adding Shared Data Content to an Application Package for additional information.
Included a Streamlit app in your application.
Refer to Adding a Streamlit App to an Application Package for additional information.
Viewed your application in Snowsight.
Created a private listing for your application and installed the application in a separate account.
Refer to Sharing an Application with Consumers for information on publish a listing containing an application package.
Refer to Installing an Application from a Listing for information on how consumers install an application from a listing.