Personnalisez pour chaque utilisateur avec Streamlit dans Snowflake (SiS)

Introduction

Fin juillet 2024, la politique d'accès à l'utilisateur actuel et à la ligne est devenue disponible dans Streamlit dans Snowflake.

La partie intéressante de cette mise à jour est qu'il est désormais facile et sécurisé d'identifier l'utilisateur Snowflake connecté à l'application et de personnaliser le traitement pour chaque utilisateur.

Sans avoir besoin de configurer un mécanisme de connexion personnalisé ou un tableau de gestion des utilisateurs, vous pouvez personnaliser une seule application pour chaque utilisateur de la manière suivante :

• Changer l'affichage de l'application pour chaque utilisateur
• Préparation de tableaux de bord d'analyse personnalisés pour chaque utilisateur
• Utilisation de stratégies d'accès aux lignes pour obtenir des résultats de requête différents pour chaque utilisateur (Enterprise Edition et versions ultérieures)

Dans cet article, nous allons créer une simple liste de tâches qui affiche les informations individuelles des utilisateurs.

Remarque : cet article représente mes opinions personnelles et non celles de Snowflake.

Présentation des fonctionnalités

Objectifs

• Gérez vos listes de tâches personnelles à l'aide d'une seule application partagée
• Utilisez la stratégie d'accès aux lignes pour empêcher l'affichage des tâches d'autres personnes

Image terminée

Écran de l'utilisateur TKANNO

Écran de l'utilisateur TARO

Conditions préalables

• Compte Flocon de Neige
  • Un compte Enterprise Edition est requis pour utiliser la stratégie d'accès aux lignes

Note

• Streamlit dans Snowflake s'exécute avec les privilèges de propriétaire, donc Current_Role sera le même que le rôle d'application Streamlit dans Snowflake. (Il ne peut donc pas être utilisé pour la personnalisation)

Procédure

Créer une table pour stocker la liste ToDo

Exécutez la commande suivante à partir d'une feuille de calcul :

-- Create ToDo list table
CREATE TABLE IF NOT EXISTS todo_list (
    id INT AUTOINCREMENT,
    task VARCHAR(255),
    status VARCHAR(20),
    due_date DATE,
    completed_date DATE,
    owner VARCHAR(50)
);

Créer une stratégie d'accès aux lignes

Cette stratégie renvoie les lignes où le propriétaire dans la table todo_list correspond à l'utilisateur actuel connecté à l'application Streamlit in Snowflake.

Exécutez la commande suivante à partir de la feuille de calcul :

-- Create row access policy
CREATE ROW ACCESS POLICY IF NOT EXISTS todo_row_access_policy
    AS (owner VARCHAR) RETURNS BOOLEAN ->
        owner = CURRENT_USER();

Appliquer la stratégie d'accès aux lignes

Exécutez la commande suivante à partir de la feuille de calcul :

-- Apply row access policy
ALTER TABLE todo_list ADD ROW ACCESS POLICY todo_row_access_policy ON (owner);

Ceci termine les opérations de la feuille de calcul.

Exécutez l'application Streamlit dans Snowflake

Créez une nouvelle application Streamlit dans Snowflake et copiez et collez le code suivant :

La ligne 14 est l'endroit où l'utilisateur actuel connecté à l'application est récupéré sous forme de chaîne.

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

# Layout settings
st.set_page_config(
    layout="wide"
)

# Get Snowflake session
session = get_active_session()

# Get current user
current_user = session.sql("SELECT CURRENT_USER()").collect()[0][0]

# Get ToDo list
def get_todo_list():
    return session.table("todo_list").to_pandas()

# Add or update task
def upsert_task(task_id, task, status, due_date, completed_date):
    due_date_sql = f"'{due_date}'" if due_date else "NULL"
    completed_date_sql = f"'{completed_date}'" if completed_date else "NULL"

    if task_id:
        session.sql(f"""
        UPDATE todo_list
        SET task = '{task}', status = '{status}', due_date = {due_date_sql}, completed_date = {completed_date_sql}
        WHERE id = {task_id}
        """).collect()
    else:
        session.sql(f"""
        INSERT INTO todo_list (task, status, owner, due_date, completed_date)
        VALUES ('{task}', '{status}', '{current_user}', {due_date_sql}, {completed_date_sql})
        """).collect()

# Delete task
def delete_task(task_id):
    session.sql(f"DELETE FROM todo_list WHERE id = {task_id}").collect()

# Main function
def main():
    st.title(f"{current_user}'s Personal Dashboard")

    # Task list
    st.subheader(f"{current_user}'s ToDo List")
    todo_df = get_todo_list()

    # Display header
    col1, col2, col3, col4, col5 = st.columns([3, 2, 2, 2, 2])
    col1.write("Task")
    col2.write("Status")
    col3.write("Due Date")
    col4.write("Completed Date")
    col5.write("Delete")

    # Display task list
    for _, row in todo_df.iterrows():
        col1, col2, col3, col4, col5 = st.columns([3, 2, 2, 2, 2])

        with col1:
            task = st.text_input("task", value=row['TASK'], key=f"task_{row['ID']}", label_visibility="collapsed")

        with col2:
            status = st.selectbox("status", ["Pending", "In Progress", "Completed"], index=["Pending", "In Progress", "Completed"].index(row['STATUS']), key=f"status_{row['ID']}", label_visibility="collapsed")

        with col3:
            due_date = st.date_input("due_date", value=pd.to_datetime(row['DUE_DATE']).date() if pd.notna(row['DUE_DATE']) else None, key=f"due_date_{row['ID']}", label_visibility="collapsed")

        with col4:
            completed_date = st.date_input("comp_date", value=pd.to_datetime(row['COMPLETED_DATE']).date() if pd.notna(row['COMPLETED_DATE']) else None, key=f"completed_date_{row['ID']}", label_visibility="collapsed")

        with col5:
            if st.button("Delete", key=f"delete_{row['ID']}"):
                delete_task(row['ID'])
                st.experimental_rerun()

        # Update database immediately if values change
        if task != row['TASK'] or status != row['STATUS'] or due_date != row['DUE_DATE'] or completed_date != row['COMPLETED_DATE']:
            upsert_task(row['ID'], task, status, due_date, completed_date)
            st.experimental_rerun()

    # Add new task
    st.subheader("Add New Task")
    new_task = st.text_input("New Task")
    new_status = st.selectbox("Status", ["Pending", "In Progress", "Completed"])
    new_due_date = st.date_input("Due Date")
    if st.button("Add"):
        upsert_task(None, new_task, new_status, new_due_date, None)
        st.success("New task added")
        st.experimental_rerun()

# Main process
if __name__ == "__main__":
    main()

Conclusion

Qu'en pensez-vous ? En combinant Current_User et la politique d'accès aux lignes, vous pouvez créer une application sécurisée personnalisée pour chaque utilisateur en quelques étapes simples. Cela ouvre des possibilités pour créer des applications encore plus conviviales basées sur vos idées.

Certaines idées avancées incluent l'ajout d'informations Current_User comme signature lors de l'écriture dans des tables via Streamlit dans Snowflake, ou l'utilisation d'informations personnalisées comme contexte pour Cortex LLM pour créer un assistant personnel.

Veuillez essayer de vous mettre au défi avec des utilisations intéressantes de Current_User !

Annonces

Snowflake Quoi de neuf Mises à jour sur X

Je partage les nouveautés de Snowflake sur X. N'hésitez pas à suivre si vous êtes intéressé !

Version anglaise

Snowflake Quoi de neuf Bot (version anglaise)
https://x.com/snow_new_en

Version japonaise

Snowflake Quoi de neuf Bot (version japonaise)
https://x.com/snow_new_jp

Historique des modifications

(20240914) Message initial

Article japonais original

https://zenn.dev/tsubasa_tech/articles/a23029dfe97c46

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!