Zusätzliche Streamlit in Snowflake-Features¶

Beispiel: Zugriff auf die OpenAI API¶

Das folgende Beispiel zeigt, wie Sie eine externe Zugriffsintegration für eine ausgehende Anfrage an die OpenAI API erstellen. Dieses Beispiel umfasst die Einstellung der Sicherheitsintegration und die Gewährung der erforderlichen Berechtigungen.

1. Um eine Netzwerkregel zu erstellen, die den Speicherort des externen Netzwerks und die Zugriffsbeschränkungen darstellt, verwenden Sie den CREATE NETWORK RULE-Befehl, wie im folgenden Beispiel gezeigt:

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

   Copy

   Weitere Informationen dazu finden Sie unter Erstellen einer Netzwerkregel zur Darstellung des externen Netzwerkstandorts.

2. Um ein Geheimnis zu erstellen, das die Anmeldeinformationen darstellt, die für die Authentifizierung mit dem externen Speicherort des Netzwerks erforderlich sind, verwenden Sie den CREATE SECRET-Befehl, wie im folgenden Beispiel gezeigt:

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

   Copy

   Weitere Informationen dazu finden Sie unter Erstellen eines Geheimnisses zur Darstellung von Anmeldeinformationen.

3. Um eine externe Zugriffsintegration zu erstellen, führen Sie den CREATE EXTERNAL ACCESS INTEGRATION-Befehl aus und setzen ALLOWED_NETWORK_RULES auf die von Ihnen erstellte Netzwerkregel und ALLOWED_AUTHENTICATION_SECRETS auf das von Ihnen erstellte Geheimnis:

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

   Copy

4. Um dem Ersteller der Streamlit-App die erforderlichen Berechtigungen zur Verwendung der Objekte SECRET und INTEGRATION für den externen Zugriff zu gewähren, verwenden Sie den GRANT <Berechtigungen>-Befehl, wie im folgenden Beispiel gezeigt:

   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. Damit die Streamlit-App die Integration nutzen kann, führen Sie den Befehl ALTER STREAMLIT aus und stellen die EXTERNAL_ACCESS_INTEGRATIONS-Eigenschaft auf die Integration ein, wie im folgenden Beispiel gezeigt:

   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

   Bemerkung

   Sie können ein neues Streamlit-Objekt auch so einrichten, dass es eine externe Zugriffsintegration verwendet, indem Sie den EXTERNAL_ACCESS_INTEGRATIONS-Parameter angeben, wenn Sie den CREATE STREAMLIT-Befehl ausführen, wie im folgenden Beispiel gezeigt:

   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. Rufen Sie im Code Ihrer Streamlit-App die externe API auf, wie im folgenden Beispiel gezeigt:

   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

Beispiel: Zugriff auf Daten in einer Tabelle mit Zeilenzugriffsrichtlinie mit CURRENT_USER¶

Sie können eine Streamlit in Snowflake-App verwenden, um den Zugriff auf Zeilen in einer Tabelle zu regeln, die durch eine Zeilenzugriffsrichtlinie geschützt ist. Geben Sie die Funktion CURRENT_USER im Body der Zeilenzugriffsrichtlinie an und fügen Sie die Zeilenzugriffsrichtlinie der Tabelle hinzu.

Das folgende Beispiel zeigt, wie Sie den Zugriff auf eine Tabelle regeln, die durch eine Zeilenzugriffsrichtlinie auf Zeilen in einer Streamlit in Snowflake-App geschützt ist.

1. Erstellen Sie eine Tabelle, und fügen Sie Daten ein:

   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. Erstellen Sie eine Zeilenzugriffsrichtlinie:

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

   Copy

3. Fügen Sie die Zeilenzugriffsrichtlinie der Tabelle hinzu:

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

   Copy

4. Erstellen einer Streamlit-App

5. Weisen Sie die globale READ SESSION-Berechtigung der Rolle des Eigentümers der Streamlit-App zu:

   GRANT READ SESSION ON ACCOUNT TO ROLE streamlit_owner_role;
   

   Copy

6. Fügen Sie den folgenden Code in Ihre Streamlit-App ein:

   # 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