A dados em tempo real são importantes para as empresas tomarem decisões rápidas. Visualizar esses dados pode ajudar a tomar decisões ainda mais rapidamente. Podemos criar representações visuais de dados usando várias aplicações de dados ou painéis. Dash é uma biblioteca Python de código aberto que oferece uma ampla gama de componentes internos para criar gráficos interativos, tabelas, gráficos e outros elementos de interface do usuário. RisingWave é um banco de dados de streaming baseado em SQL para processamentos de dados em tempo real. Este artigo explicará como usar Python, Dash e RisingWave para criar visualizações de dados em tempo real.
Como Visualizar Dados em Tempo Real
Sabemos que dados em tempo real são dados gerados e processados imediatamente, à medida que são coletados de diferentes fontes de dados. As fontes podem ser bancos de dados típicos como Postgres ou MySQL, e brokers de mensagens como Kafka. Uma visualização de dados em tempo real consiste em alguns passos: primeiro, ingerimos, depois processamos e, finalmente, mostramos esses dados em um painel.
No caso de dados de entrega de pedidos, visualizar esses dados em tempo real pode fornecer insights valiosos sobre o desempenho de um restaurante ou serviço de entrega. Por exemplo, podemos usar dados em tempo real para monitorar quanto tempo leva para os pedidos serem entregues, identificar gargalos no processo de entrega e rastrear mudanças no volume de pedidos ao longo do tempo. Ao lidar com dados que estão constantemente mudando, pode ser difícil acompanhar tudo o que está acontecendo e identificar padrões ou tendências. Usando ferramentas gratuitas, como Dash e RisingWave, podemos criar visualizações interativas que nos permitem explorar e analisar esses dados em constante mudança.
Quando se trata de trabalhar com dados, a primeira linguagem de programação que você pode pensar é Python, pois possui uma gama de bibliotecas. Dash é uma delas que nos permite criar um aplicativo de dados com uma interface rica e personalizável usando apenas código Python. Dash é construído sobre Flask, Plotly.js e React.js, que são ferramentas populares de desenvolvimento web, portanto, você não precisa saber HTML, CSS ou outras frameworks JavaScript.
Com RisingWave, podemos consumir fluxos de dados de várias fontes, criar visualizações materializadas otimizadas para consultas complexas e consultar dados em tempo real usando SQL. Como RisingWave é compatível com o PostgreSQL, podemos usar o driver psycopg2 (biblioteca cliente PostgreSQL em Python) para conectar-se a RisingWave e realizar operações de consulta. Veja na próxima seção.
Visualizar Dados de Entrega de Pedidos Demo
No tutorial de demonstração, vamos utilizar o seguinte repositório do GitHub com demos do RisingWave, onde assumimos que todas as configurações necessárias foram feitas usando Docker Compose. Você pode verificar outras maneiras de executar o RisingWave no site oficial. Temos um tópico do Kafka chamado delivery_orders que contém eventos para cada pedido feito em um site de entrega de comida. Cada evento inclui informações sobre o pedido, como o ID do pedido, ID do restaurante e status de entrega. O gerador de carga (script Python chamado Datagen) simula a geração contínua de dados falsos aleatórios e os envia para os tópicos do Kafka. Na prática, esses dados falsos podem ser substituídos por dados provenientes de seu aplicativo web ou serviço de backend.
Antes de Começar
Para concluir este tutorial, você precisa do seguinte:
- Certifique-se de ter Docker e Docker Compose instalados em seu ambiente.
- Certifique-se de que o terminal interativo PostgreSQL, psql, esteja instalado em seu ambiente. Para instruções detalhadas, consulte Download PostgreSQL.
- Faça o download e instale o Python 3 para o seu sistema operacional. O comando
pipserá instalado automaticamente.
O demo que testei no Windows OS, Docker Desktop e Python 3.10.11 instalado.
Passo 1: Configurar o Cluster de Demonstração do RisingWave
Primeiro, clone o repositório de amostra RisingWave para o seu ambiente local.
git clone <https://github.com/risingwavelabs/risingwave.git>
Em seguida, acesse o diretório integration_tests/delivery e inicie o cluster de demonstração a partir do arquivo docker compose.
cd risingwave/integration_tests/delivery
docker compose up -d
Certifique-se de que todos os contêineres estejam em execução!
Passo 2: Instalar as Bibliotecas Dash e Psycopg2
Para instalar o Dash, você também pode consultar o guia de instalação do Dash no site. Basicamente, precisamos instalar duas bibliotecas (o próprio Dash e Pandas) executando o seguinte comando pip install:
# This also brings along the Plotly graphing library.
# Plotly is known for its interactive charts
# Plotly Express requires Pandas to be installed too.
pip install dash pandas
Devemos também instalar o psycopg2 para interagir com o banco de dados em streaming RisingWave:
pip install psycopg2-binary
Etapa 3: Criar uma Fonte de Dados
Para ingerir dados em tempo real com o RisingWave, primeiro é necessário configurar uma fonte de dados. No projeto de demonstração, o Kafka deve ser definido como a fonte de dados. Vamos criar um novo arquivo chamado create-a-source.py, no mesmo diretório integration_tests/delivery com o script Python onde nos conectamos ao RisingWave e criamos uma tabela para consumir e persistir tópicos Kafka de delivery_orders. Você pode simplesmente copiar e colar o código abaixo no novo arquivo.
import psycopg2
conn = psycopg2.connect(database="dev", user="root", password="", host="localhost", port="4566") # Connect to RisingWave.
conn.autocommit = True # Set queries to be automatically committed.
with conn.cursor() as cur:
cur.execute("""
CREATE TABLE delivery_orders_source (
order_id BIGINT,
restaurant_id BIGINT,
order_state VARCHAR,
order_timestamp TIMESTAMP
) WITH (
connector = 'kafka',
topic = 'delivery_orders',
properties.bootstrap.server = 'message_queue:29092',
scan.startup.mode = 'earliest'
) ROW FORMAT JSON;""") # Execute the query.
conn.close() # Close the connection.
Após criar o arquivo, execute python create-a-source.py e isso criará a tabela de origem no RisingWave.
Etapa 4: Criar uma Visualização Materializada
Em seguida, criamos uma nova visualização materializada de maneira semelhante à criação da tabela. Criamos um novo arquivo chamado create-a-materialized-view.py e executamos uma consulta SQL usando a biblioteca psycopg2. Também é possível fundir os dois últimos passos acima em um único arquivo de script Python.
import psycopg2
conn = psycopg2.connect(database="dev", user="root", password="", host="localhost", port="4566")
conn.autocommit = True
with conn.cursor() as cur:
cur.execute("""CREATE MATERIALIZED VIEW restaurant_orders_view AS
SELECT
window_start,
restaurant_id,
COUNT(*) AS total_order
FROM
HOP(delivery_orders_source, order_timestamp, INTERVAL '1' MINUTE, INTERVAL '15' MINUTE)
WHERE
order_state = 'CREATED'
GROUP BY
restaurant_id,
window_start;""")
conn.close()
Acima, a consulta SQL calcula o número total de pedidos criados a partir de um restaurante específico nos últimos 15 minutos em tempo real e armazena o resultado na visualização materializada. Se houver qualquer alteração nos dados ou novos tópicos Kafka chegarem, o RisingWave incrementa e atualiza automaticamente o resultado da visualização materializada. Uma vez configurado a fonte de dados, a visualização materializada, você pode começar a ingerir dados e visualizar esses dados usando Dash.
Etapa 5: Construindo um Aplicativo Dash
Agora, construímos nosso aplicativo Dash para consultar e visualizar o conteúdo da visualização materializada que temos no RisingWave. Você pode seguir o tutorial Dash em 20 minutos para entender os blocos de construção básicos de Dash. Nosso código de aplicativo de exemplo exibe dados de pedidos de restaurante em formatos de tabela e gráfico. Veja o código Python abaixo no dash-example.py:
import psycopg2
import pandas as pd
import dash
from dash import dash_table
from dash import dcc
import dash_html_components as html
import plotly.express as px
# Connect to the PostgreSQL database
conn = psycopg2.connect(database="dev", user="root", password="", host="localhost", port="4566")
# Retrieve data from the materialized view using pandas
df = pd.read_sql_query("SELECT window_start, restaurant_id, total_order FROM restaurant_orders_view;", conn)
# Create a Dash application
app = dash.Dash(__name__)
# Define layout
app.layout = html.Div(children=[
html.H1("Restaurant Orders Table"),
dash_table.DataTable(id="restaurant_orders_table", columns=[{"name": i, "id": i} for i in df.columns], data=df.to_dict("records"), page_size=10),
html.H1("Restaurant Orders Graph"),
dcc.Graph(id="restaurant_orders_graph", figure=px.bar(df, x="window_start", y="total_order", color="restaurant_id", barmode="group"))
])
# Run the application
if __name__ == '__main__':
app.run_server(debug=True)
Este trecho de código recupera os dados da visão materializada restaurant_orders_view usando o pandas e os exibe em uma tabela Dash usando dash_table.DataTable e um gráfico de barras usando dcc.Graph. A tabela e o gráfico de barras possuem colunas que correspondem às colunas na visão materializada (‘window_start’, ‘total_order’, e ‘restaurant_id’) e linhas que correspondem aos dados na visão materializada.
Passo 6: Visualizar os Resultados
Você pode executar o aplicativo executando o script dash-example.py acima e navegando para http://localhost:8050/ em seu navegador da web (você receberá uma mensagem no terminal informando para ir a este link).
Resumo
No geral, o Dash é uma ferramenta poderosa para criar visualizações analíticas de dados que exigem UIs complexas e capacidades de visualização de dados, tudo usando a simplicidade e elegância da linguagem de programação Python. Quando o usamos em conjunto com o banco de dados de streaming RisingWave, ganhamos insights sobre dados em tempo real que podem nos ajudar a tomar decisões mais informadas e agir para otimizar o desempenho.
Recursos Relacionados
Source:
https://dzone.com/articles/visualize-real-time-data-with-python-dash-and-risi