Gérer les secrets et configurer votre application Streamlit¶

Gestion de votre connexion à Snowflake¶

Pour gérer votre connexion à Snowflake, vous pouvez utiliser une st.connection("snowflake"). Celle-ci vous permet de vous connecter à Snowflake à partir de votre environnement de développement local et de votre application déployée.

import streamlit as st

conn = st.connection("snowflake")
session = conn.session()

session.sql("SELECT 1").collect()

Dans les exécutions d’entrepôts, vous pouvez également utiliser la fonction get_active_session() de Snowpark pour accéder à la session active.

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

# ONLY IN WAREHOUSE RUNTIMES
session = get_active_session()
session.sql("SELECT 1").collect()

Secrets dans les exécutions de conteneurs¶

Les exécutions de conteneurs n’ont pas accès au module _snowflake, car ils fonctionnent en dehors de l’environnement de la procédure stockée. Pour accéder aux secrets dans une exécution de conteneur, vous devez créer des fonctions SQL qui utilisent le module _snowflake, puis appeler ces fonctions depuis votre application Streamlit. Pour les appels d’API Cortex, vous devez utiliser des requests.

Si vous mettez à niveau une ancienne application Streamlit vers une exécution de conteneur, les fonctions _snowflake suivantes doivent être remplacées par des procédures stockées. Ceci est décrit dans la section suivante.

• get_generic_secret_string

• get_oauth_access_token

• get_username_password

• get_cloud_provider_token

• get_secret_type

En outre, la fonction _snowflake suivante doit être remplacée par un appel d’API manuel, authentifié avec un jeton de session. Ceci est décrit dans la section ultérieure Appel d’un Agent Cortex dans une exécution de conteneur.

• send_snow_api_request

# .streamlit/secrets.toml
# ONLY USE FOR NON-SECRET CONFIGURATION VALUES
app_name = "My Streamlit App"
api_endpoint = "https://api.example.com"
max_results = 100

import streamlit as st
import os

app_name = st.secrets["app_name"]
API_ENDPOINT = os.getenv("API_ENDPOINT")

import requests
import json
import os

SNOWFLAKE_HOST = os.getenv("SNOWFLAKE_HOST")
SNOWFLAKE_ACCOUNT = os.getenv("SNOWFLAKE_ACCOUNT")
ANALYST_ENDPOINT = "/api/v2/cortex/analyst/message"
URL = "https://" + SNOWFLAKE_HOST + ANALYST_ENDPOINT

def get_token() -> str:
    """Read the oauth token embedded into SPCS container"""
    return open("/snowflake/session/token", "r").read()

def send_request(semantic_model_file, prompt):
    """Sends the prompt using the semantic model file """
    headers = {
        "Content-Type": "application/json",
        "accept": "application/json",
        "Authorization": f"Bearer {get_token()}",
        "X-Snowflake-Authorization-Token-Type": "OAUTH"
    }
    request_body = {
        "messages": [
            {
                "role": "user",
                "content": [{"type": "text", "text": prompt}],
            }
        ],
        "semantic_model_file": semantic_model_file,
    }
    return requests.post(URL, headers=headers, data=json.dumps(request_body))

Secrets dans les exécutions d’entrepôts¶

Dans les exécutions d’entrepôts, vous pouvez utiliser le module _snowflake pour accéder aux secrets directement dans le code de votre application Streamlit. Les exécutions d’entrepôts héritent de l’accès au module _snowflake à partir de procédures stockées, ce qui vous permet de récupérer les secrets qui sont référencés dans l’objet Streamlit.

Pour utiliser des secrets dans une exécution d’entrepôts, procédez comme suit :

1. Créez un objet secret dans Snowflake. Pour plus d’informations, voir CREATE SECRET.

   CREATE OR REPLACE SECRET my_secret
     TYPE = GENERIC_STRING
     SECRET_STRING = 'my_secret_value';
   

   Copy

2. Créez une intégration d’accès externe et attribuez-lui le secret.

   CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION my_eai
     ALLOWED_AUTHENTICATION_SECRETS = (my_secret)
     ENABLED = TRUE;
   

   Copy

3. Référencez le secret dans votre objet Streamlit à l’aide du paramètre SECRETS :

   ALTER STREAMLIT my_warehouse_app
     SET EXTERNAL_ACCESS_INTEGRATIONS = (my_eai)
     SECRETS = ('my_secret_key' = my_secret);
   

   Copy

   Vous devez attribuer à l’objet Streamlit à la fois l’intégration d’accès externe et le secret. Vous ne pouvez pas attribuer un secret à un objet Streamlit par lui-même.

4. Dans le code de votre application Streamlit, importez le module _snowflake et récupérez le secret :

   import streamlit as st
   import _snowflake
   
   # Retrieve an API key from a generic string secret
   my_secret = _snowflake.get_generic_secret_string('my_secret_key')
   

   Copy

Pour plus d’informations sur l’accès aux secrets avec le module _snowflake, consultez API Python pour l’accès aux secrets.

Configuration de Streamlit¶

Les applications Streamlit peuvent inclure un fichier de configuration (.streamlit/config.toml). Ce fichier vous permet de personnaliser divers aspects de votre application, tels que le thème, la disposition et le comportement. Le fichier de configuration est écrit au format TOML. Pour plus d’informations sur les options de configuration disponibles, consultez la documentation Streamlit sur config.toml.

La prise en charge des options de configuration varie selon l’environnement d’exécution. Les exécutions de conteneurs offrent généralement une prise en charge plus large des options de configuration que les exécutions d’entrepôts, en particulier pour le service statique. Le tableau suivant montre les sections de configuration prises en charge dans les exécutions d’entrepôts et de conteneurs :

Pour plus d’informations sur l’utilisation de la section [snowflake.sleep] pour configurer les minuteurs de mise en veille dans les exécutions d’entrepôts, consultez Minuterie de mise en veille personnalisée pour une application Streamlit.

La structure des répertoires suivante montre un exemple d‘application Streamlit avec un fichier de configuration :

source_directory/
├── .streamlit/
│   └── config.toml
├── pyproject.toml
├── streamlit_app.py
└── uv.lock