Fonctionnalités Streamlit in Snowflake complémentaires¶

Exemple : accéder à l’API OpenAI¶

L’exemple suivant montre comment créer une intégration d’accès externe pour une demande sortante vers l’API OpenAI. Cet exemple inclut la configuration de l’intégration de sécurité et l’octroi des privilèges requis.

1. Pour créer une règle de réseau qui représente l’emplacement réseau externe et les restrictions d’accès, utilisez la commande CREATE NETWORK RULE comme indiqué dans l’exemple suivant :

   CREATE OR REPLACE NETWORK RULE network_rules
     MODE = EGRESS
     TYPE = HOST_PORT
     VALUE_LIST = ('api.openai.com');
   

   Copy

   Pour plus d’informations, voir Création d’une règle de réseau pour représenter l’emplacement réseau externe.

2. Pour créer un secret qui représente les identifiants de connexion requis pour s’authentifier auprès de l’emplacement réseau externe, utilisez la commande CREATE SECRET comme indiqué dans l’exemple suivant :

   CREATE OR REPLACE SECRET openai_key
     TYPE = GENERIC_STRING
     SECRET_STRING = '<any_string>';
   

   Copy

   Pour plus d’informations, voir Création d’un secret pour représenter les identifiants de connexion.

3. Pour créer une intégration d’accès externe, exécutez la commande CREATE EXTERNAL ACCESS INTEGRATION, en réglant ALLOWED_NETWORK_RULES sur la règle de réseau que vous avez créée et ALLOWED_AUTHENTICATION_SECRETS sur le secret que vous avez créé :

   CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION openai_access_int
     ALLOWED_NETWORK_RULES = (network_rules)
     ALLOWED_AUTHENTICATION_SECRETS = (openai_key)
     ENABLED = TRUE;
   

   Copy

4. Pour accorder les privilèges requis pour utiliser les objets SECRET et INTEGRATION pour un accès externe au créateur d’applications Streamlit, utilisez la commande GRANT <privilèges> comme indiqué dans l’exemple suivant :

   GRANT READ ON SECRET openai_key TO ROLE streamlit_app_creator_role;
   GRANT USAGE ON INTEGRATION openai_access_int TO ROLE streamlit_app_creator_role;
   

   Copy

5. Pour permettre à l’application Streamlit d’utiliser l’intégration, exécutez la commande ALTER STREAMLIT, en réglant la propriété EXTERNAL_ACCESS_INTEGRATIONS sur l’intégration comme indiqué dans l’exemple suivant :

   USE ROLE streamlit_app_creator_role;
   
   ALTER STREAMLIT streamlit_db.streamlit_schema.streamlit_app
     SET EXTERNAL_ACCESS_INTEGRATIONS = (openai_access_int)
     SECRETS = ('my_openai_key' = streamlit_db.streamlit_schema.openai_key);
   

   Copy

   Note

   Vous pouvez également configurer un nouvel objet Streamlit pour utiliser une intégration d’accès externe en spécifiant le paramètre EXTERNAL_ACCESS_INTEGRATIONS lorsque vous exécutez la commande CREATE STREAMLIT, comme indiqué dans l’exemple suivant :

   CREATE STREAMLIT streamlit_db.streamlit_schema.streamlit_app
     ROOT_LOCATION = '<stage_path_and_root_directory>'
     MAIN_FILE = '<path_to_main_file_in_root_directory>'
     EXTERNAL_ACCESS_INTEGRATIONS = (openai_access_int)
     SECRETS = ('my_openai_key' = streamlit_db.streamlit_schema.openai_key);
   

   Copy

6. Dans le code de votre application Streamlit, appelez l’API externe, comme le montre l’exemple suivant :

   from openai import OpenAI
   import streamlit as st
   import _snowflake
   
   st.title(":speech_balloon: Simple chat app using an external LLM")
   st.write("This app shows how to call an external LLM to build a simple chat application.")
   
   # Use the _snowflake library to access secrets
   secret = _snowflake.get_generic_secret_string('my_openai_key')
   client = OpenAI(api_key=secret)
   
   # ...
   # code to use API
   # ...
   

   Copy

Exemple : accéder aux données d’une table avec une politique d’accès aux lignes à l’aide de CURRENT_USER¶

Vous pouvez utiliser une application Streamlit in Snowflake permettant de gérer l’accès aux lignes d’une table protégée par une politique d’accès aux lignes. Précisez la fonction CURRENT_USER dans le corps de la politique d’accès aux lignes et ajoutez la politique d’accès aux lignes à la table.

L’exemple suivant montre comment gérer l’accès à une table protégée par une politique d’accès aux lignes dans une application Streamlit in Snowflake.

1. Créer une table et insérer des données :

   CREATE TABLE row_access_policy_test_table (
       id INT,
       some_data VARCHAR(100),
       the_owner VARCHAR(50)
   );
   
   INSERT INTO row_access_policy_test_table (id, some_data, the_owner)
   VALUES
       (4, 'Some information 4', 'ALICE'),
       (5, 'Some information 5', 'FRANK'),
       (6, 'Some information 6', 'ALICE');
   

   Copy

2. Créez une politique d’accès aux lignes :

   CREATE OR REPLACE ROW ACCESS POLICY st_schema.row_access_policy
   AS (the_owner VARCHAR) RETURNS BOOLEAN ->
       the_owner = CURRENT_USER();
   

   Copy

3. Ajoutez la politique d’accès aux lignes à la table :

   ALTER TABLE row_access_policy_test_table ADD ROW ACCESS POLICY st_schema.row_access_policy ON (the_owner);
   

   Copy

4. Créez une application Streamlit.

5. Accordez le privilège READ SESSION global au rôle de propriétaire de l’application Streamlit :

   GRANT READ SESSION ON ACCOUNT TO ROLE streamlit_owner_role;
   

   Copy

6. Ajoutez le code suivant à votre application Streamlit :

   # Import Python packages
   import streamlit as st
   from snowflake.snowpark.context import get_active_session
   
   st.title("CURRENT_USER() + Row Access Policy in SiS Demo :balloon:")
   st.write(
           """You can access `CURRENT_USER()` and data from tables with row access policies
           in Streamlit in Snowflake apps
           """)
   
   # Get the current credentials
   session = get_active_session()
   
   st.header('Demo')
   
   st.subheader('Credentials')
   sql = "SELECT CURRENT_USER();"
   df = session.sql(sql).collect()
   st.write(df)
   
   st.subheader('Row Access on a Table')
   sql = "SELECT * FROM st_db.st_schema.row_access_policy_test_table;"
   df = session.sql(sql).collect()
   
   st.write(df)
   

   Copy