Premiers pas avec Streamlit in Snowflake

Cette rubrique décrit comment commencer à utiliser Streamlit in Snowflake.

Conditions préalables à l’utilisation de Streamlit in Snowflake

Pour utiliser Streamlit in Snowflake, assurez-vous que vous remplissez les conditions préalables suivantes :

Privilèges requis pour créer et utiliser une application Streamlit

Au sein de Streamlit in Snowflake , une application Streamlit est un objet sécurisé qui adhère au cadre de contrôle d’accès Snowflake. Les applications Streamlit utilisent un modèle de permission basé sur les droits du propriétaire. Pour plus d’informations, voir Comprendre les droits du propriétaire et les applications Streamlit in Snowflake.

Un éditeur d’application et le propriétaire du schéma contenant l’application Streamlit peuvent déterminer quels rôles ont la permission d’utiliser l’application. Les utilisateurs peuvent interagir avec l’application et voir tout ce qui est affiché par l’application Streamlit. Les utilisateurs ont la même vision de l’application que le propriétaire.

Pour plus d’informations, voir Partagez une application Streamlit.

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

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

Versions prises en charge des bibliothèques Streamlit

Streamlit in Snowflake prend en charge les versions suivantes de la bibliothèque open-source Streamlit :

  • 1.39.0 (actuellement en avant-première)

  • 1.35.0

  • 1.31.1

  • 1.29.0

  • 1.26.0

  • 1.22.0

Pour consulter les notes de version de chaque version, voir le journal des modifications de la bibliothèque Streamlit. Notez que certaines fonctionnalités de la bibliothèque Streamlit open source ouvert ne sont pas prises en charge dans Streamlit in Snowflake. Voir Fonctions Streamlit non prises en charge.

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.

Paquets externes pris en charge

Par défaut, Streamlit in Snowflake inclut les paquets python, streamlit, et snowflake-snowpark-python préinstallés dans votre environnement. L’environnement a également accès aux dépendances requises par ces paquets.

Applications Streamlit in Snowflake exécutées en Python 3.8.

Vous pouvez installer des paquets supplémentaires dans votre application Streamlit. Pour obtenir la liste des paquets pris en charge, consultez le canal Snowflake Anaconda.

Consultez les rubriques suivantes pour obtenir des informations sur l’intégration d’un paquet pris en charge dans votre application Streamlit :

Lignes directrices pour la sélection d’un entrepôt dans Streamlit in Snowflake

Lorsque vous exécutez une application Streamlit dans Streamlit in Snowflake, de nombreux facteurs peuvent affecter les performances, notamment la complexité de l’application Streamlit, la disponibilité des entrepôts, la latence et le coût. Les sections suivantes fournissent des orientations générales pour l’utilisation des entrepôts virtuels dans Streamlit in 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.

Astuce

Pour éviter la suspension de l’entrepôt pendant l’initialisation, envisagez de définir la suspension automatique à un minimum de 30 secondes.

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()
Copy

Note

L’entrepôt n’est utilisé que pour la durée de la requête.

Construire votre première application Streamlit in Snowflake

  1. Connectez-vous à Snowsight.

  2. Dans le menu de navigation, sélectionnez Projects » Streamlit.

  3. Sélectionnez + Streamlit App.

  4. Saisissez un titre pour l’application et choisissez une base de données, un schéma et un entrepôt.

  5. Sélectionnez Create.

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.