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

Vous devez également disposer du privilège USAGE sur l’entrepôt utilisé pour exécuter l’application Streamlit.

Utilisez la commande GRANT <privilèges> pour accorder ces privilèges à un rôle, comme le montre cet exemple :

GRANT USAGE ON SCHEMA streamlit_db.streamlit_schema TO ROLE streamlit_creator;
GRANT USAGE ON DATABASE streamlit_db TO ROLE streamlit_creator;
GRANT USAGE ON WAREHOUSE streamlit_wh 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 attribution 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’attribution future.

Privilèges requis pour visualiser une application Streamlit¶

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

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

• Le schéma qui contient 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 ayant le rôle avec le privilège MANAGE GRANTS doit accorder le privilège USAGE à l’aide de la commande GRANT <privilèges> comme indiqué dans cet exemple :

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 STREAMLIT streamlit_db.streamlit_schema.streamlit_app TO ROLE streamlit_role;

Le propriétaire du schéma ou un utilisateur ayant le rôle avec le privilège MANAGE GRANTS peut accorder le privilège USAGE pour voir toutes les futures applications Streamlit créées dans le schéma, comme le montre cet exemple :

GRANT USAGE ON FUTURE STREAMLITS IN SCHEMA streamlit_db.streamlit_schema 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 Anaconda de Snowflake.

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. À mesure que l’entrepôt repris exécute davantage d’applications, le cache des paquets est reconstitué, et les applications qui peuvent tirer parti du cache verront leurs performances de chargement s’améliorer.

Notez que la facturation du crédit à la seconde et la suspension automatique vous donnent la flexibilité 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. Pour plus d’informations, voir Modifier l’entrepôt d’une application Streamlit.

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. Vous pouvez ainsi 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.

Pour plus d’informations, voir Considérations relatives aux entrepôts.

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. Avec cette commande, vous pouvez exécuter l’application en utilisant un entrepôt X-Small et exécuter 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 avec ce code :

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 modifiez la nouvelle application Streamlit 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 :

   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 occurred: {e}")
   
   expander = st.expander("See 100 most recent records")
   with expander:
       st.dataframe(get_data(session))
   

   Copy

4. Pour lancer l’application Streamlit, sélectionnez Run.