Recursos adicionais do Streamlit in Snowflake¶

Exemplo: Acesse a API OpenAI¶

O exemplo a seguir mostra como criar uma integração de acesso externo para uma solicitação de saída para a API OpenAI. Este exemplo inclui a configuração da integração de segurança e a concessão dos privilégios necessários.

1. Para criar uma regra de rede que represente o local da rede externa e as restrições de acesso, use o comando CREATE NETWORK RULE conforme mostrado no exemplo a seguir:

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

   Copy

   Para obter mais informações, consulte Criação de uma regra de rede para representar o local da rede externa.

2. Para criar um segredo que represente as credenciais necessárias para autenticação com o local de rede externa, use o comando CREATE SECRET, conforme mostrado no exemplo a seguir:

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

   Copy

   Para obter mais informações, consulte Criação de um segredo para representar credenciais.

3. Para criar uma integração de acesso externo, execute o comando CREATE EXTERNAL ACCESS INTEGRATION, configuração ALLOWED_NETWORK_RULES como a regra de rede que você criou e ALLOWED_AUTHENTICATION_SECRETS como o segredo que você criou:

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

   Copy

4. Para conceder os privilégios necessários para usar os objetos SECRET e INTEGRATION para acesso externo ao criador do aplicativo Streamlit, use o comando GRANT <privilégios>, conforme mostrado no exemplo a seguir:

   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. Para permitir que o aplicativo Streamlit use a integração, execute o comando ALTER STREAMLIT, configurando a propriedade EXTERNAL_ACCESS_INTEGRATIONS para a integração, conforme mostrado no exemplo a seguir:

   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

   Nota

   Você também pode definir um novo objeto Streamlit para usar uma integração de acesso externo especificando o parâmetro EXTERNAL_ACCESS_INTEGRATIONS ao executar o comando CREATE STREAMLIT, conforme mostrado no exemplo a seguir:

   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. No código do aplicativo Streamlit, chame a API externa, conforme mostrado no exemplo a seguir:

   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

Exemplo: Como acessar dados em uma tabela com a política de acesso a linhas usando CURRENT_USER¶

É possível usar um aplicativo Streamlit in Snowflake para controlar o acesso a linhas em uma tabela protegida por uma política de acesso a linhas. Especifique a função CURRENT_USER no corpo da política de acesso a linhas e adicione a política de acesso a linhas à tabela.

O exemplo a seguir demonstra como controlar o acesso a uma tabela protegida por uma política de acesso a linhas em um aplicativo Streamlit in Snowflake.

1. Criar uma tabela e inserir dados:

   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. Crie uma política de acesso a linhas:

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

   Copy

3. Adicione a política de acesso a linhas à tabela:

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

   Copy

4. Criar um aplicativo Streamlit.

5. Conceda o privilégio global READ SESSION à função de proprietário do aplicativo Streamlit:

   GRANT READ SESSION ON ACCOUNT TO ROLE streamlit_owner_role;
   

   Copy

6. Adicione o seguinte código ao seu aplicativo 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