Docker 101

# Dockerfile
FROM python:3.12-slim

WORKDIR /app

# Instalar dependências
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar código
COPY . .

# Expor porta para o Streamlit
EXPOSE 8501

# Comando para iniciar o Streamlit
CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0"]

Criar arquivo de dependências

# Criar o arquivo requirements.txt
echo "streamlit==1.44.0
pandas==2.2.3
matplotlib==3.10.1" > requirements.txt

Construir a imagem Docker

# Construir a imagem Docker
docker build -t dashboard-vendas .

Executar o contêiner

# Executar o contêiner
docker run -p 8501:8501 -d --name streamlit-app dashboard-vendas

# Acessar o dashboard
# Abra seu navegador em http://localhost:8501

# Dockerfile
FROM python:3.12-slim

WORKDIR /app

# Copiar e instalar dependências
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar código
COPY . .

# Expor porta para a API
EXPOSE 8000

# Iniciar API com Uvicorn
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Criar arquivo de dependências

# Criar o arquivo requirements.txt
echo "fastapi==0.115.12
uvicorn==0.34.0
pandas==2.2.3
pydantic==2.11.1" > requirements.txt

Construir a imagem Docker

# Construir a imagem Docker
docker build -t api-vendas .

Executar o contêiner

# Executar o contêiner
docker run -p 8000:8000 -d --name fastapi-app api-vendas

Testar a API

# Testar a API
# Acesse http://localhost:8000/docs para ver a documentação interativa

-- Criar tabela para armazenar dados
CREATE TABLE vendas (
    id SERIAL PRIMARY KEY,
    data_venda DATE NOT NULL,
    produto VARCHAR(100) NOT NULL,
    categoria VARCHAR(50) NOT NULL,
    valor DECIMAL(10,2) NOT NULL,
    quantidade INT NOT NULL
);

-- Inserir dados de exemplo
INSERT INTO vendas (data_venda, produto, categoria, valor, quantidade)
VALUES 
  ('2025-01-15', 'Curso Python', 'Educação', 197.00, 45),
  ('2025-01-20', 'Assinatura BI', 'Software', 89.90, 28),
  ('2025-02-05', 'Consultoria', 'Serviços', 1200.00, 3),
  ('2025-02-12', 'Curso SQL', 'Educação', 147.00, 52),
  ('2025-03-01', 'Licença Tableau', 'Software', 999.00, 15);

-- Análise de vendas por categoria
SELECT 
    categoria,
    COUNT(*) AS total_vendas,
    SUM(valor * quantidade) AS receita_total,
    AVG(valor) AS ticket_medio
FROM vendas
GROUP BY categoria
ORDER BY receita_total DESC;

Executar PostgreSQL com volume

# Executar PostgreSQL com volume para persistência
docker run --name postgres-dados \
  -e POSTGRES_PASSWORD=segredo \
  -e POSTGRES_USER=analista \
  -e POSTGRES_DB=datawarehouse \
  -v postgres_data:/var/lib/postgresql/data \
  -p 5432:5432 \
  -d postgres:14.8

Conexão externa

# Acessar usando ferramentas externas
# Host: localhost
# Port: 5432
# User: analista
# Password: segredo
# Database: datawarehouse

Backup e restauração

# Criar backup do banco de dados
docker exec -t postgres-dados pg_dump -U analista -d datawarehouse > backup.sql

# Restaurar backup (para um contêiner novo)
# 1. Criar novo contêiner
docker run --name postgres-dados-novo -e POSTGRES_PASSWORD=segredo -e POSTGRES_USER=analista -e POSTGRES_DB=datawarehouse -v postgres_data_novo:/var/lib/postgresql/data -p 5433:5432 -d postgres:14.8

# 2. Restaurar dados
cat backup.sql | docker exec -i postgres-dados-novo psql -U analista -d datawarehouse

# api/main.py
from fastapi import FastAPI, Depends, HTTPException, Body
from sqlalchemy import create_engine, Column, Integer, String, Float, Date, func
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session
import os
from datetime import date
from pydantic import BaseModel
from typing import List, Optional

# Configuração do banco de dados
DATABASE_URL = os.environ.get("DATABASE_URL")
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

# Modelo SQLAlchemy
class VendaDB(Base):
    __tablename__ = "vendas"
    
    id = Column(Integer, primary_key=True, index=True)
    data_venda = Column(Date)
    produto = Column(String)
    categoria = Column(String)
    valor = Column(Float)
    quantidade = Column(Integer)

# Modelo Pydantic para leitura
class Venda(BaseModel):
    id: int
    data_venda: date
    produto: str
    categoria: str
    valor: float
    quantidade: int
    
    class Config:
        orm_mode = True

# Modelo Pydantic para criação
class VendaCreate(BaseModel):
    data_venda: date
    produto: str
    categoria: str
    valor: float
    quantidade: int

# Dependência para obter a sessão do banco
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

app = FastAPI(title="API de Análise de Dados")

@app.get("/vendas", response_model=List[Venda])
def listar_vendas(db: Session = Depends(get_db)):
    return db.query(VendaDB).all()

@app.get("/vendas/categoria/{categoria}", response_model=List[Venda])
def vendas_por_categoria(categoria: str, db: Session = Depends(get_db)):
    return db.query(VendaDB).filter(VendaDB.categoria == categoria).all()

@app.get("/vendas/analise")
def analise_vendas(db: Session = Depends(get_db)):
    resultado = db.query(
        VendaDB.categoria,
        func.count(VendaDB.id).label("total_vendas"),
        func.sum(VendaDB.valor * VendaDB.quantidade).label("receita_total"),
        func.avg(VendaDB.valor).label("ticket_medio")
    ).group_by(VendaDB.categoria).all()
    
    return [
        {
            "categoria": r.categoria,
            "total_vendas": r.total_vendas,
            "receita_total": float(r.receita_total),
            "ticket_medio": float(r.ticket_medio)
        }
        for r in resultado
    ]

# Endpoint para inserir novos dados - disponível apenas no Docker Compose
@app.post("/vendas", response_model=Venda)
def criar_venda(venda: VendaCreate, db: Session = Depends(get_db)):
    nova_venda = VendaDB(**venda.dict())
    db.add(nova_venda)
    db.commit()
    db.refresh(nova_venda)
    return nova_venda

# dashboard/app.py
import streamlit as st
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import requests
import os
import json
from datetime import datetime

# Configuração
API_URL = os.environ.get("API_URL", "http://api:8000")

st.set_page_config(
    page_title="Dashboard de Análise de Vendas",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Título
st.title("Dashboard de Análise de Vendas")
st.write("Dashboard interativo para análise de dados de vendas")

# Funções para carregar dados da API
@st.cache_data(ttl=300)
def carregar_vendas():
    response = requests.get(f"{API_URL}/vendas")
    return pd.DataFrame(response.json())

@st.cache_data(ttl=300)
def carregar_analise():
    response = requests.get(f"{API_URL}/vendas/analise")
    return pd.DataFrame(response.json())

# Função para inserir novos dados
def inserir_venda(dados):
    response = requests.post(f"{API_URL}/vendas", json=dados)
    return response.status_code == 200 or response.status_code == 201

try:
    # Carregar dados
    df_vendas = carregar_vendas()
    df_analise = carregar_analise()
    
    # Criar abas para separar visualização e entrada de dados
    tab1, tab2 = st.tabs(["Visualização de Dados", "Inserir Novos Dados"])
    
    with tab1:
        # Layout em colunas
        col1, col2 = st.columns(2)
        
        # Coluna 1: Gráfico de barras - Receita por categoria
        with col1:
            st.subheader("Receita Total por Categoria")
            fig1 = px.bar(
                df_analise, 
                x="categoria", 
                y="receita_total",
                text_auto=True,
                color="categoria",
                title="Receita Total por Categoria de Produto"
            )
            st.plotly_chart(fig1, use_container_width=True)
        
        # Coluna 2: Gráfico de pizza - Proporção de vendas
        with col2:
            st.subheader("Proporção de Vendas por Categoria")
            fig2 = px.pie(
                df_analise, 
                values="total_vendas", 
                names="categoria",
                title="Distribuição de Vendas por Categoria"
            )
            st.plotly_chart(fig2, use_container_width=True)
        
        # Tabela completa
        st.subheader("Dados de Vendas")
        st.dataframe(df_vendas)
        
        # Filtro por categoria
        st.sidebar.title("Filtros")
        categorias = ["Todas"] + sorted(df_vendas["categoria"].unique().tolist())
        categoria_selecionada = st.sidebar.selectbox("Selecione uma categoria:", categorias)
        
        if categoria_selecionada != "Todas":
            df_filtrado = df_vendas[df_vendas["categoria"] == categoria_selecionada]
            st.subheader(f"Vendas na categoria: {categoria_selecionada}")
            st.dataframe(df_filtrado)
            
            # Gráfico de linha para a categoria
            if not df_filtrado.empty:
                df_por_data = df_filtrado.groupby("data_venda").agg(
                    {"valor": lambda x: (x * df_filtrado["quantidade"]).sum()}
                ).reset_index()
                df_por_data.columns = ["data", "receita"]
                
                fig3 = px.line(
                    df_por_data, 
                    x="data", 
                    y="receita",
                    markers=True,
                    title=f"Evolução de Receita: {categoria_selecionada}"
                )
                st.plotly_chart(fig3, use_container_width=True)
    
    with tab2:
        # Formulário para adicionar novas vendas
        st.subheader("Adicionar Nova Venda")
        with st.form("nova_venda_form"):
            data_venda = st.date_input("Data da Venda", datetime.now().date())
            produto = st.text_input("Nome do Produto")
            
            # Usar categorias existentes ou permitir nova
            usar_categoria_existente = st.checkbox("Usar categoria existente", value=True)
            if usar_categoria_existente and not df_vendas.empty:
                categoria = st.selectbox("Categoria", sorted(df_vendas["categoria"].unique().tolist()))
            else:
                categoria = st.text_input("Nova Categoria")
                
            valor = st.number_input("Valor Unitário (R$)", min_value=0.01, format="%.2f")
            quantidade = st.number_input("Quantidade", min_value=1, step=1)
            
            submitted = st.form_submit_button("Adicionar Venda")
            
            if submitted:
                if not produto or not categoria:
                    st.error("Todos os campos são obrigatórios!")
                else:
                    nova_venda = {
                        "data_venda": data_venda.isoformat(),
                        "produto": produto,
                        "categoria": categoria,
                        "valor": valor,
                        "quantidade": quantidade
                    }
                    
                    if inserir_venda(nova_venda):
                        st.success("Venda adicionada com sucesso!")
                        st.cache_data.clear()  # Limpar cache para recarregar dados
                    else:
                        st.error("Erro ao adicionar venda. Verifique os dados e tente novamente.")
    
except Exception as e:
    st.error(f"Erro ao carregar dados: {e}")
    st.warning("Verifique se a API está disponível e funcionando corretamente.")

Estrutura inicial do projeto

# Estrutura de diretórios
mkdir -p projeto-dados/{api,dashboard}

Script de inicialização do banco

# Criar script de inicialização do banco
cat > init.sql << 'EOF'
CREATE TABLE vendas (
    id SERIAL PRIMARY KEY,
    data_venda DATE NOT NULL,
    produto VARCHAR(100) NOT NULL,
    categoria VARCHAR(50) NOT NULL,
    valor DECIMAL(10,2) NOT NULL,
    quantidade INT NOT NULL
);

INSERT INTO vendas (data_venda, produto, categoria, valor, quantidade)
VALUES 
  ('2025-01-15', 'Curso Python', 'Educação', 197.00, 45),
  ('2025-01-20', 'Assinatura BI', 'Software', 89.90, 28),
  ('2025-02-05', 'Consultoria', 'Serviços', 1200.00, 3),
  ('2025-02-12', 'Curso SQL', 'Educação', 147.00, 52),
  ('2025-03-01', 'Licença Tableau', 'Software', 999.00, 15);
EOF

Configuração da API

# Criar Dockerfile para a API
cat > api/Dockerfile << 'EOF'
FROM python:3.12-slim

WORKDIR /app

# Copiar e instalar dependências
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar código
COPY . .

# Expor porta para a API
EXPOSE 8000

# Iniciar API com Uvicorn
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
EOF

# Requisitos para a API
cat > api/requirements.txt << 'EOF'
fastapi==0.115.12
uvicorn==0.34.0
pydantic==2.11.1
sqlalchemy==2.0.22
psycopg2-binary==2.9.9
EOF

Configuração do Dashboard

# Criar Dockerfile para o Dashboard
cat > dashboard/Dockerfile << 'EOF'
FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0"]
EOF

# Requisitos para o Dashboard
cat > dashboard/requirements.txt << 'EOF'
streamlit==1.44.0
pandas==2.2.3
plotly==5.18.0
requests==2.31.0
EOF

Gerenciar Docker Compose

# Iniciar todos os serviços
docker-compose up -d

# Verificar logs dos serviços
docker-compose logs -f

# Parar todos os serviços
docker-compose down

# Parar e remover volumes (limpar dados)
docker-compose down -v