Premiers pas avec Streamlit in Snowflake¶

Privilèges requis pour créer une application Streamlit¶

Les applications Streamlit sont des objets de niveau schéma.

Pour créer et modifier une application Streamlit en utilisant Streamlit in Snowflake, vous devez utiliser un rôle qui possède soit le privilège OWNERSHIP sur le schéma, soit les deux privilèges suivants :

• Accordé(s) sur la base de données qui contient l’application Streamlit :

  • USAGE

• Accordé(s) sur le schéma qui contient l’application Streamlit :

  • USAGE

  • CREATE STREAMLIT

  • CREATE STAGE

Utilisez la commande GRANT <privilèges> pour accorder ces privilèges à un rôle, comme le montrent les exemples suivants :

GRANT USAGE ON SCHEMA streamlit_db.streamlit_schema TO ROLE streamlit_creator;
GRANT USAGE ON DATABASE streamlit_db TO ROLE streamlit_creator;
GRANT CREATE STREAMLIT ON SCHEMA streamlit_db.streamlit_schema TO ROLE streamlit_creator;
GRANT CREATE STAGE ON SCHEMA streamlit_db.streamlit_schema TO ROLE streamlit_creator;

Copy

Si une autorisation future est définie sur la base de données ou le schéma, assurez-vous que l’utilisateur crée l’application Streamlit en utilisant le rôle défini dans l’autorisation future.

Privilèges requis pour visualiser une application Streamlit¶

Pour visualiser une application Streamlit, vous devez avoir un compte Snowflake et être connecté. De plus, vous devez utiliser un rôle qui bénéficie du privilège USAGE sur les éléments suivants :

• La base de données qui contient l’application Streamlit.

• Le schéma qui contient l’application Streamlit.

• L’entrepôt utilisé pour exécuter l’application Streamlit.

• L’application Streamlit.

Dans la plupart des cas, lorsque le propriétaire d’applications partage une application Streamlit avec un autre rôle, le privilège USAGE est automatiquement accordé au nouveau rôle. Cependant, si une application Streamlit est créée dans un schéma avec MANAGED ACCESS, le privilège USAGE doit être accordé manuellement au nouveau rôle.

Le propriétaire du schéma ou un utilisateur avec le rôle disposant du privilège MANAGE GRANTS doit accorder le privilège USAGE à l’aide de la commande GRANT <privilèges> comme indiqué dans les exemples suivants :

GRANT USAGE ON DATABASE streamlit_db TO ROLE streamlit_role;
GRANT USAGE ON SCHEMA streamlit_db.streamlit_schema TO ROLE streamlit_role;
GRANT USAGE ON WAREHOUSE streamlit_wh TO ROLE streamlit_role;
GRANT USAGE ON STREAMLIT streamlit_db.streamlit_schema.streamlit_app TO ROLE streamlit_role;

Sélectionnez la version de la bibliothèque Streamlit¶

Pour chaque application Streamlit in Snowflake, vous pouvez sélectionner la version de la bibliothèque Streamlit dans Snowsight ou épingler la version dans le fichier environment.yml de l’application. Si vous ne précisez pas la version, la dernière version disponible est utilisée.

Snowflake recommande d’épingler une version de Streamlit pour éviter que l’application ne soit mise à niveau lorsqu’une nouvelle version de Streamlit est disponible dans le canal Snowflake Anaconda.

Utiliser des entrepôts plus petits¶

Lorsque vous exécutez une application Streamlit dans Streamlit in Snowflake vous devez sélectionner l’entrepôt le plus petit possible.

Lorsqu’il est en cours d’exécution, un entrepôt conserve un cache des paquets Python utilisés par une application Streamlit. La mise en cache des paquets Python améliore les performances lors des chargements ultérieurs des applications en utilisant la version mise en cache d’un paquet au lieu de télécharger à nouveau les paquets. Le cache est supprimé lorsque l’entrepôt est suspendu, ce qui peut ralentir le chargement de l’application après la reprise de l’entrepôt. Au fur et à mesure que l’entrepôt repris fonctionne et exécute davantage d’applications, le cache des paquets est reconstruit. Les applications qui sont en mesure de tirer parti du cache verront leurs performances de chargement s’améliorer.

La facturation à la seconde et la suspension automatique permettent de commencer avec des entrepôts plus petits, puis d’ajuster la taille de l’entrepôt en fonction de la charge de travail de l’application Streamlit. Vous pouvez augmenter la taille d’un entrepôt à tout moment. Consultez Modifier l’entrepôt d’une application Streamlit pour plus d’informations.

Utiliser les entrepôts dédiés¶

Lorsque vous utilisez Streamlit in Snowflake, Snowflake recommande d’utiliser un entrepôt dédié à l’exécution des applications Streamlit. Cela vous permet d’isoler les coûts de fonctionnement d’une application Streamlit. Un entrepôt dédié peut également améliorer le temps de chargement de l’application, car l’entrepôt n’a pas à gérer d’autres charges de travail.

Consultez Considérations relatives aux entrepôts pour plus d’informations.

Utiliser un entrepôt séparé pour exécuter les requêtes¶

Les applications Streamlit utilisent un entrepôt virtuel pour exécuter l’application et ses requêtes. Des applis et des cas d’utilisation plus avancés peuvent impliquer l’exécution d’une requête complexe, ce qui nécessite un entrepôt plus important.

Streamlit in Snowflake prend en charge la commande USE WAREHOUSE qui spécifie un entrepôt actuel pour la session. Ainsi, vous pouvez exécuter l’application en utilisant un entrepôt X-Small et des requêtes complexes en utilisant un entrepôt plus grand.

Vous pouvez utiliser un entrepôt séparé pour exécuter des requêtes dans une application Streamlit de la manière suivante :

import streamlit as st
from snowflake.snowpark.context import get_active_session

# Get the current credentials
session = get_active_session()

warehouse_sql = f"USE WAREHOUSE LARGE_WH"
session.sql(warehouse_sql).collect()

# Execute the SQL using a different warehouse
sql = """SELECT * from MY_DB.INFORMATION_SCHEMA.PACKAGES limit 100"""
session.sql(sql).collect()

Accéder aux données Snowflake dans votre application Streamlit in Snowflake¶

Dans cette section, vous allez modifier l’application Streamlit que vous venez de créer pour accéder aux données d’une table Snowflake.

1. Créez une table BUG_REPORT_DATA dans votre base de données et votre schéma :

   CREATE OR REPLACE TABLE <your_database>.<your_schema>.BUG_REPORT_DATA (
     AUTHOR VARCHAR(25),
     BUG_TYPE VARCHAR(25),
     COMMENT VARCHAR(100),
     DATE DATE,
     BUG_SEVERITY NUMBER(38,0)
   );
   

   Copy

2. Ajoutez des exemples de données dans la table BUG_REPORT_DATA :

   INSERT INTO <your_database>.<your_schema>.BUG_REPORT_DATA (AUTHOR, BUG_TYPE, COMMENT, DATE, BUG_SEVERITY)
   VALUES
   ('John Doe', 'UI', 'The button is not aligned properly', '2024-03-01', 3),
   ('Aisha Patel', 'Performance', 'Page load time is too long', '2024-03-02', 5),
   ('Bob Johnson', 'Functionality', 'Unable to submit the form', '2024-03-03', 4),
   ('Sophia Kim', 'Security', 'SQL injection vulnerability found', '2024-03-04', 8),
   ('Michael Lee', 'Compatibility', 'Does not work on Internet Explorer', '2024-03-05', 2),
   ('Tyrone Johnson', 'UI', 'Font size is too small', '2024-03-06', 3),
   ('David Martinez', 'Performance', 'Search feature is slow', '2024-03-07', 4),
   ('Fatima Abadi', 'Functionality', 'Logout button not working', '2024-03-08', 3),
   ('William Taylor', 'Security', 'Sensitive data exposed in logs', '2024-03-09', 7),
   ('Nikolai Petrov', 'Compatibility', 'Not compatible with Safari', '2024-03-10', 2);
   

   Copy

3. Modifiez le code de l’application Streamlit avec l’exemple suivant :

   import streamlit as st
   
   session = st.connection('snowflake').session()
   
   # Change the query to point to your table
   def get_data(_session):
       query = """
       select * from <your_database>.<your_schema>.BUG_REPORT_DATA
       order by date desc
       limit 100
       """
       data = _session.sql(query).collect()
       return data
   
   # Change the query to point to your table
   def add_row_to_db(session, row):
       sql = f"""INSERT INTO <your_database>.<your_schema>.BUG_REPORT_DATA VALUES
       ('{row['author']}',
       '{row['bug_type']}',
       '{row['comment']}',
       '{row['date']}',
       '{row['bug_severity']}')"""
   
       session.sql(sql).collect()
   
   st.set_page_config(page_title="Bug report", layout="centered")
   
   st.title("Bug report demo!")
   
   st.sidebar.write(
       f"This app demos how to read and write data from a Snowflake Table"
   )
   
   form = st.form(key="annotation", clear_on_submit=True)
   
   with form:
       cols = st.columns((1, 1))
       author = cols[0].text_input("Report author:")
       bug_type = cols[1].selectbox(
           "Bug type:", ["Front-end", "Back-end", "Data related", "404"], index=2
       )
       comment = st.text_area("Comment:")
       cols = st.columns(2)
       date = cols[0].date_input("Bug date occurrence:")
       bug_severity = cols[1].slider("Bug priority :", 1, 5, 2)
       submitted = st.form_submit_button(label="Submit")
   
   if submitted:
       try:
           add_row_to_db(
               session,
               {'author':author,
               'bug_type': bug_type,
               'comment':comment,
               'date':str(date),
               'bug_severity':bug_severity
           })
           st.success("Thanks! Your bug was recorded in the database.")
           st.balloons()
       except Exception as e:
           st.error(f"An error occured: {e}")
   
   expander = st.expander("See 100 most recent records")
   with expander:
       st.dataframe(get_data(session))
   

   Copy

4. Sélectionnez Run pour exécuter l’application Streamlit.