Pular para o conteúdo principal

Tutorial: Desenvolva um aplicativo Databricks com o Streamlit

Este tutorial mostra como criar um aplicativo Databricks usando o Databricks SQL Connector para Python e Streamlit. Você aprenderá a desenvolver um aplicativo que faça o seguinte:

  • Lê uma tabela do Unity Catalog e a exibe em uma interface Streamlit.
  • Edita os dados e os grava de volta na tabela.

Etapas :

Etapa 1: Configurar privilégios​

Esses exemplos pressupõem que seu aplicativo usa autorização de aplicativo. A entidade de serviço do seu aplicativo deve ter:

  • SELECT privilégio na tabela do Unity Catalog
  • MODIFY privilégio na tabela do Unity Catalog
  • CAN USE privilégio sobre o SQL warehouse

Para obter mais informações, consulte Unity Catalog privileges and securable objects e SQL warehouse ACLs.

Etapa 2: instalar dependências​

Inclua o seguinte pacote em seu arquivo requirements.txt:

databricks-sdk
databricks-sql-connector
streamlit
pandas
nota

pandas só é necessário se você estiver editando dados da tabela.

Etapa 3: Ler uma tabela do Unity Catalog​

Este exemplo demonstra como ler dados de uma tabela do Unity Catalog e exibi-los usando o Streamlit. O aplicativo executa as seguintes etapas:

  1. Solicita ao usuário o caminho HTTP do SQL warehouse e o nome da tabela do Unity Catalog.
  2. Estabelece uma conexão SQL em cache usando o Databricks SQL Connector for Python.
  3. Executa uma consulta SELECT * na tabela especificada.
  4. Exibe o resultado em um Streamlit st.dataframe.

app.py​

Python
import streamlit as st
from databricks import sql
from databricks.sdk.core import Config


cfg = Config()  # Set the DATABRICKS_HOST environment variable when running locally


@st.cache_resource # connection is cached
def get_connection(http_path):
    return sql.connect(
        server_hostname=cfg.host,
        http_path=http_path,
        credentials_provider=lambda: cfg.authenticate,
    )

def read_table(table_name, conn):
    with conn.cursor() as cursor:
        query = f"SELECT * FROM {table_name}"
        cursor.execute(query)
        return cursor.fetchall_arrow().to_pandas()

http_path_input = st.text_input(
    "Enter your Databricks HTTP Path:", placeholder="/sql/1.0/warehouses/xxxxxx"
)

table_name = st.text_input(
    "Specify a :re[UC] table name:", placeholder="catalog.schema.table"
)

if http_path_input and table_name:
    conn = get_connection(http_path_input)
    df = read_table(table_name, conn)
    st.dataframe(df)
nota
  • Este exemplo usa st.cache_resource para armazenar em cache a conexão do banco de dados em sessões e reexecuções.
  • Use os campos de entrada Streamlit (st.text_input) para aceitar a entrada do usuário.

Etapa 4: Editar uma tabela do Unity Catalog​

Este exemplo permite que os usuários leiam, editem e gravem alterações em uma tabela Unity Catalog usando o recurso de edição de dados do Streamlit. O aplicativo executa as seguintes etapas:

  1. Lê a tabela original em um Pandas DataFrame.
  2. Exibe a tabela em um editor Streamlit (st.data_editor).
  3. Detecta alterações entre o DataFrames original e o editado.
  4. Usa INSERT OVERWRITE para gravar os dados atualizados de volta na tabela.

app.py​

Python
import pandas as pd
import streamlit as st
from databricks import sql
from databricks.sdk.core import Config


cfg = Config() # Set the DATABRICKS_HOST environment variable when running locally


@st.cache_resource
def get_connection(http_path):
    return sql.connect(
        server_hostname=cfg.host,
        http_path=http_path,
        credentials_provider=lambda: cfg.authenticate,
    )


def read_table(table_name: str, conn) -> pd.DataFrame:
    with conn.cursor() as cursor:
        cursor.execute(f"SELECT * FROM {table_name}")
        return cursor.fetchall_arrow().to_pandas()


def insert_overwrite_table(table_name: str, df: pd.DataFrame, conn):
    progress = st.empty()
    with conn.cursor() as cursor:
        rows = list(df.itertuples(index=False))
        values = ",".join([f"({','.join(map(repr, row))})" for row in rows])
        with progress:
            st.info("Calling Databricks SQL...")
        cursor.execute(f"INSERT OVERWRITE {table_name} VALUES {values}")
    progress.empty()
    st.success("Changes saved")


http_path_input = st.text_input(
    "Specify the HTTP Path to your Databricks SQL Warehouse:",
    placeholder="/sql/1.0/warehouses/xxxxxx",
)

table_name = st.text_input(
    "Specify a Catalog table name:", placeholder="catalog.schema.table"
)

if http_path_input and table_name:
    conn = get_connection(http_path_input)
    original_df = read_table(table_name, conn)
    edited_df = st.data_editor(original_df, num_rows="dynamic", hide_index=True)

    df_diff = pd.concat([original_df, edited_df]).drop_duplicates(keep=False)
    if not df_diff.empty:
        if st.button("Save changes"):
            insert_overwrite_table(table_name, edited_df, conn)
else:
    st.warning("Provide both the warehouse path and a table name to load data.")
nota
  • O aplicativo determina se as atualizações são necessárias calculando as diferenças entre as tabelas originais e editadas.
  • Uma barra de progresso fornece feedback durante as operações de gravação usando st.info e st.success.
  • Essa abordagem substitui todas as linhas na tabela. Para atualizações parciais, use uma estratégia de gravação diferente.

Próximas etapas​

Última atualização em