Forem: Francisco Júnior

Construindo seu Próprio BI com Python: O Fim do Vendor Lock-in (DuckDB, Marimo e Polars)

Francisco Júnior — Wed, 25 Feb 2026 12:12:44 +0000

Se você trabalha com dados, provavelmente já viveu este pesadelo: a diretoria pede um novo dashboard de análise financeira. Você abre a sua ferramenta de BI tradicional (Power BI, Tableau, Looker), conecta no banco de dados, e de repente... a interface congela. O custo de licenciamento sobe a cada novo usuário, e você fica engessado nas limitações visuais da plataforma.

E se nós pudéssemos quebrar essa barreira? E se pudéssemos processar milhões de linhas em milissegundos, criar interfaces 100% customizáveis e rodar tudo sem pagar um centavo de licença por usuário?

Bem-vindo à Modern Data Stack 2.0. Hoje, vamos construir nosso próprio motor de Business Intelligence usando Python.

🏗️ A Arquitetura do Nosso BI Customizado

Para abandonar as ferramentas tradicionais, precisamos de uma arquitetura que suporte extração, processamento analítico (OLAP) e visualização reativa. Nossa stack de elite será:

Ambiente: uv (para gestão de pacotes ultrarrápida) e OrbStack (se precisarmos subir serviços via Docker).
Ingestão e Transformação: Polars (adeus, Pandas e MemoryError!).
Motor OLAP: DuckDB (consultas SQL na velocidade da luz direto do disco).
Frontend Reativo: Marimo (o notebook de nova geração que vira uma aplicação web instantânea).

💻 Mão na Massa: O Caso de Uso Financeiro

Para tornar isso real, vamos construir um mini-BI financeiro que analisa o histórico de ações (como BBAS3, PETR4, VALE3). Queremos extrair os dados, salvar em um formato de alta performance e criar um dashboard interativo.

Passo 1: O Setup "V8"

Esqueça o pip demorado. Vamos inicializar nosso projeto com o uv:

# Inicializa o projeto e cria o ambiente virtual em segundos
uv init meu_bi_python
cd meu_bi_python

# Adiciona as nossas ferramentas de elite
uv add duckdb polars marimo yfinance

Passo 2: Ingestão e Formato de Ouro (Parquet)

BIs de verdade não leem CSV em produção. Eles leem Parquet. Vamos criar um script simples (ingestao.py) para puxar dados da bolsa e salvar de forma otimizada usando Polars.

import yfinance as yf
import polars as pl

print("Extraindo dados financeiros...")
# Baixando histórico de 5 anos do Banco do Brasil
df_pandas = yf.download("BBAS3.SA", period="5y")

# Convertendo para Polars para máxima performance
df_polars = pl.from_pandas(df_pandas).reset_index()

# Salvando no formato de ouro: Parquet
df_polars.write_parquet("historico_bbas3.parquet")
print("Dados salvos com sucesso em Parquet! 🚀")

Ao rodar esse script, você terá um arquivo Parquet ultra-comprimido, pronto para ser lido em milissegundos.

Passo 3: O Motor OLAP encontra o Frontend (DuckDB + Marimo)

Aqui é onde a mágica das ferramentas tradicionais morre de inveja. Vamos criar nosso dashboard. No terminal, inicie o Marimo:

uv run marimo edit dashboard.py

No Marimo, a execução é reativa. Quando um filtro muda, apenas o que depende dele é recalculado. Crie as seguintes células no seu ambiente Marimo:

Célula 1: Imports e Conexão OLAP

import marimo as mo
import duckdb
import polars as pl

# Conectando o DuckDB em memória (ele lerá o arquivo do disco direto)
con = duckdb.connect()

Célula 2: A Interface (UI)
Vamos criar um slider para o usuário do nosso BI escolher quantos dias de histórico ele quer analisar.

# O Marimo cria componentes nativos renderizados na tela
dias_filtro = mo.ui.slider(start=30, stop=1500, step=30, value=365, label="Dias de Histórico:")
dias_filtro

Célula 3: A Query SQL de Alta Performance
Aqui amarramos a interface do Marimo com o motor do DuckDB. O SQL será reexecutado na velocidade da luz toda vez que o slider se mover.

# Query lendo o Parquet com base no filtro reativo da UI
query = f"""
    SELECT Date, Close
    FROM 'historico_bbas3.parquet'
    ORDER BY Date DESC
    LIMIT {dias_filtro.value}
"""

# DuckDB executa o SQL e devolve um DataFrame Polars nativamente!
df_resultado = con.execute(query).pl()

Célula 4: A Visualização

# Renderizando um gráfico de linha interativo
mo.ui.table(df_resultado) # Tabela de dados

(Dica de Ouro: Você pode usar bibliotecas como Altair ou Plotly dentro do Marimo para gráficos ainda mais complexos, o Marimo renderiza nativamente).

Passo 4: Escalando com Redis e OpenSearch (O Próximo Nível)

Se o seu BI começar a escalar para toda a empresa e você precisar analisar logs ou processar filas assíncronas de relatórios pesados, a stack continua flexível:

Você sobe um contêiner do Redis via OrbStack para cachear as consultas do DuckDB.
Conecta o OpenSearch para adicionar uma barra de pesquisa textual (ex: "Buscar todas as atas de reunião onde 'dividendos' foi mencionado").

Nenhuma ferramenta de caixinha te dá essa liberdade arquitetural.

🎯 Conclusão

Criar seu próprio BI com Python não é mais um bicho de sete cabeças reservado para gigantes da tecnologia. Com DuckDB atuando como motor analítico, Polars quebrando limites de memória, e o Marimo transformando scripts em interfaces reativas, você retoma o controle dos seus dados.

Você ganha performance absoluta, governança de código real (via Git) e zera os custos de licenciamento abusivos. Você deixa de ser um passageiro da ferramenta e se torna o engenheiro da plataforma.

E você, já esbarrou nos limites estruturais de ferramentas como Power BI ou Metabase? Como você resolveu? Deixa aí nos comentários pra gente trocar uma ideia!

🎁 Bônus: Colocando seu BI em Produção (Modo Aplicativo)

Até agora, usamos o comando marimo edit dashboard.py, que abre a interface de desenvolvimento (com as células de código visíveis). Mas, e quando você quiser enviar esse painel para a diretoria ou para os analistas de negócio usarem?

Você não quer que eles vejam o código Python, apenas a interface limpa e reativa.

Para rodar o seu dashboard em modo de produção (como uma aplicação web standalone, ocultando o código e exibindo apenas os componentes visuais), basta usar este comando:

uv run marimo run dashboard.py

Esse comando sobe um servidor local incrivelmente rápido e entrega a experiência final do usuário. Se você quiser expor isso para a rede da empresa, basta adicionar a flag do host:

uv run marimo run dashboard.py --host 0.0.0.0 --port 8080

Pronto! Seu BI customizado, de alta performance e custo zero de licença, está no ar e pronto para ser acessado por qualquer pessoa na rede. 🚀

Python + OpenSearch: O Segredo do Zero Downtime com Aliases 🔄

Francisco Júnior — Fri, 20 Feb 2026 10:38:34 +0000

Quando você trabalha com Business Intelligence e melhoria de processos, os requisitos do negócio mudam o tempo todo. Num dia, o tempo de execução de uma tarefa é medido em minutos; no outro, a diretoria decide que precisa ser em milissegundos.

No mundo dos bancos de dados relacionais, você faria um ALTER TABLE. Mas no OpenSearch (e no Elasticsearch), os mapeamentos (mappings) são imutáveis. Se você definiu um campo como texto e depois percebeu que ele deveria ser um número para gerar gráficos no dashboard... você não pode simplesmente alterar o tipo dele.

A única solução é criar um índice novo, com o mapeamento correto, e mover os dados. Mas como fazer isso sem tirar o dashboard do ar ou quebrar a aplicação Python que está inserindo logs em tempo real?

A resposta é brilhante e simples: Aliases.

O que é um Alias? 🎭

Pense no Alias como um "apelido" ou um atalho (como um symlink no Linux/macOS).

A regra de ouro da arquitetura no OpenSearch é: A sua aplicação e os seus dashboards NUNCA devem apontar diretamente para o nome do índice real. Eles devem apontar para o Alias.

Ruim: Dashboard lê de logs_processos_v1
Bom: Dashboard lê de logs_processos_atuais (que é um Alias apontando para a versão 1).

Se amanhã você precisar da versão 2, você cria o índice, copia os dados e, em uma fração de segundo, manda o Alias apontar para a versão 2. O seu painel de BI nem pisca. Zero downtime.

Vamos ver como orquestrar isso com Python.

Passo 1: A Configuração Inicial (O Jeito Certo) 🏗️

Vamos simular a criação do nosso primeiro índice de processos, mas já usando as melhores práticas desde o dia zero.

from opensearchpy import OpenSearch

cliente = OpenSearch(hosts=[{'host': 'localhost', 'port': 9200}], use_ssl=False, verify_certs=False)

indice_v1 = 'processos_governados_v1'
alias_nome = 'processos_producao'

# 1. Criamos a versão 1 com o mapeamento inicial
mapeamento_v1 = {
    "mappings": {
        "properties": {
            "tempo_execucao": {"type": "text"} # OPA! Definimos como texto por engano
        }
    }
}
cliente.indices.create(index=indice_v1, body=mapeamento_v1)

# 2. A MÁGICA: Criamos o Alias apontando para a V1
cliente.indices.put_alias(index=indice_v1, name=alias_nome)

print(f"Índice {indice_v1} criado!")
print(f"Alias '{alias_nome}' agora aponta para a V1.")

Neste momento, você vai lá no OpenSearch Dashboards e cria todos os seus gráficos apontando para processos_producao.

Passo 2: O Problema! (Requisitos mudaram) 🚨

Semanas depois, você vai montar um gráfico de média de tempo e descobre que não dá para fazer cálculo matemático com texto. Precisamos mudar o tempo_execucao para integer.

Como não podemos alterar a V1, vamos criar a V2.

indice_v2 = 'processos_governados_v2'

# 1. Criamos o NOVO índice com o tipo corrigido
mapeamento_v2 = {
    "mappings": {
        "properties": {
            "tempo_execucao": {"type": "integer"} # Agora sim, um número!
        }
    }
}
cliente.indices.create(index=indice_v2, body=mapeamento_v2)
print(f"Índice {indice_v2} criado com o mapeamento corrigido!")

Passo 3: A Reindexação (Copiando os dados) 🚚

Agora precisamos pegar todos os milhares de logs que estão na V1 e jogar para a V2. O OpenSearch tem uma API nativa incrivelmente rápida para isso, chamada _reindex.

# Pedimos ao OpenSearch para copiar tudo internamente
resposta_reindex = cliente.reindex(
    body={
        "source": {"index": indice_v1},
        "dest": {"index": indice_v2}
    },
    wait_for_completion=True # Espera terminar para continuar o script
)

print(f"Reindexação concluída! {resposta_reindex['created']} documentos copiados.")

Dica: O OpenSearch é inteligente o suficiente para tentar converter as strings (ex: "150") em números (150) durante essa cópia, já que o novo mapeamento exige um integer.

Passo 4: O "Switch" Atômico (A Troca Perfeita) ⚡

Aqui está o momento crucial. Nós precisamos tirar o Alias da V1 e colocar na V2.

Se fizermos isso em dois comandos separados (remover, depois adicionar), pode haver uma fração de segundo onde o Alias não existe, o que resultaria em erro (downtime) para quem estiver usando o painel de BI naquele exato milissegundo.

Para resolver isso, usamos a API de _aliases para fazer a troca atomicamente (tudo de uma vez só).

# A troca atômica
acoes_alias = {
    "actions": [
        {"remove": {"index": indice_v1, "alias": alias_nome}},
        {"add": {"index": indice_v2, "alias": alias_nome}}
    ]
}

cliente.indices.update_aliases(body=acoes_alias)
print(f"✅ Sucesso! O Alias '{alias_nome}' agora aponta silenciosamente para a V2.")

Conclusão

Pronto! Os seus usuários que estavam com o dashboard aberto não perceberam absolutamente nada. A sua aplicação Python que injeta dados não precisou ser reiniciada (pois ela também manda os dados para o Alias). Tudo continuou funcionando, mas agora o seu banco de dados está com a estrutura nova e correta.

Você pode manter a V1 como backup por alguns dias ou simplesmente excluí-la para liberar espaço (cliente.indices.delete(index=indice_v1)).

Dominar Aliases e a API de Reindexação é o que separa arquiteturas amadoras de ecossistemas de dados profissionais, resilientes e totalmente à prova de falhas!

Gostou da série sobre OpenSearch e Python? Qual foi a dica que você achou mais útil para o seu dia a dia? Deixe um comentário ou compartilhe com a sua equipe!

Python + OpenSearch: O Guia Definitivo de Mapeamento e Governança de Dados 🛡️

Francisco Júnior — Fri, 20 Feb 2026 10:37:24 +0000

Se você trabalha com Análise de Dados, Business Intelligence ou Melhoria de Processos, sabe que a regra de ouro de qualquer arquitetura é: lixo que entra, é lixo que sai (Garbage In, Garbage Out).

Nos artigos anteriores, vimos como o OpenSearch é incrível para buscas rápidas e criação de dashboards em tempo real. Nós simplesmente jogamos um dicionário Python (JSON) lá dentro e ele aceitou. Isso se chama Dynamic Mapping (Mapeamento Dinâmico).

É ótimo para testes rápidos no seu terminal (usando Zsh ou Fish, por exemplo), mas em produção, deixar o banco adivinhar o tipo do seu dado é um pesadelo de Governança de Dados. O campo que deveria ser um número inteiro (integer) de repente vira um texto (text) só porque um erro na sua aplicação enviou "100" em vez de 100. E adeus métricas precisas no seu dashboard!

Hoje, vamos aprender a criar um contrato de dados rigoroso usando Mappings no OpenSearch antes de injetar qualquer coisa com Python.

O que é o Mapping no OpenSearch?

Se você vem do mundo do SQL (como PostgreSQL) ou de Data Warehouses (como BigQuery), você está acostumado a rodar um CREATE TABLE definindo colunas e tipos (VARCHAR, INT, TIMESTAMP).

No OpenSearch, o equivalente ao Schema da tabela é o Mapping. É ele que diz ao motor de busca:

Quais campos existem no documento.
Qual é o tipo de dado de cada campo (ex: texto livre, palavra-chave exata, número, data).
Como esses campos devem ser indexados para a busca.

A Diferença Crucial: Text vs Keyword 🔍

Antes de irmos para o código, você precisa entender a diferença entre os dois principais tipos de string no OpenSearch, pois isso afeta diretamente o Business Intelligence:

Text: Usado para texto longo (descrições, e-mails, logs extensos). O OpenSearch "quebra" esse texto em palavras separadas. Se o campo tiver "Analista de Dados", você consegue buscar apenas por "Dados". Não serve para agregações ou gráficos de pizza.
Keyword: Usado para valores exatos (IDs, status, categorias, e-mails exatos). Ele salva a string inteira como um bloco só. É obrigatório usar keyword se você quiser fazer filtros estritos ou montar gráficos e dashboards.

Passo 1: Definindo o Contrato (Governança na Prática) 📜

Vamos imaginar que estamos criando um índice para monitorar a Melhoria de Processos da empresa. Queremos garantir que os dados entrem perfeitamente tipados.

Vamos usar o uv e o Python para criar esse índice com um Mapping explícito.

from opensearchpy import OpenSearch

# Conectando ao cluster (assumindo que já está rodando via contêiner/OrbStack)
cliente = OpenSearch(
    hosts=[{'host': 'localhost', 'port': 9200}],
    use_ssl=False,
    verify_certs=False
)

nome_indice = 'processos_governados_v1'

# Aqui está a nossa Governança de Dados: O Mapping!
mapeamento = {
    "mappings": {
        "properties": {
            # Keyword: Perfeito para IDs e filtros exatos
            "processo_id": {
                "type": "keyword"
            },
            # Text + Keyword: Queremos buscar parte do nome, mas também agrupar em gráficos!
            "analista_responsavel": {
                "type": "text",
                "fields": {
                    "exato": {
                        "type": "keyword"
                    }
                }
            },
            # Integer: Para calcularmos médias de tempo depois no BI
            "tempo_execucao_ms": {
                "type": "integer"
            },
            # Date: O formato ISO8601 é o padrão ouro
            "data_execucao": {
                "type": "date",
                "format": "strict_date_optional_time||epoch_millis"
            },
            # Boolean: Apenas true ou false
            "sucesso": {
                "type": "boolean"
            }
        }
    }
}

# Criando o índice COM o mapeamento definido
if not cliente.indices.exists(index=nome_indice):
    cliente.indices.create(index=nome_indice, body=mapeamento)
    print(f"✅ Índice '{nome_indice}' criado com regras estritas de Governança!")
else:
    print(f"⚠️ O índice '{nome_indice}' já existe.")

Passo 2: Testando a Injeção de Dados 🧪

Agora que temos um contrato, o OpenSearch vai nos ajudar a manter a qualidade dos dados. Vamos tentar inserir dois documentos: um correto e um "sujo".

from datetime import datetime

# 1. Dado Correto (Vai passar liso)
dado_limpo = {
    "processo_id": "PROC-2026-001",
    "analista_responsavel": "Francisco",
    "tempo_execucao_ms": 1450,
    "data_execucao": datetime.utcnow().isoformat(),
    "sucesso": True
}

cliente.index(index=nome_indice, body=dado_limpo, refresh=True)
print("✅ Dado limpo indexado com sucesso!")

# 2. Dado Sujo (Vai forçar um erro de Governança)
dado_sujo = {
    "processo_id": "PROC-2026-002",
    "analista_responsavel": "Larissa",
    "tempo_execucao_ms": "quatrocentos", # ERRO INTENCIONAL: Enviando texto no lugar de número
    "data_execucao": datetime.utcnow().isoformat(),
    "sucesso": True
}

try:
    cliente.index(index=nome_indice, body=dado_sujo)
except Exception as e:
    print("\n❌ ERRO DE GOVERNANÇA DETECTADO PELO OPENSEARCH:")
    print("O motor rejeitou o documento porque o tipo do dado estava errado.")
    # Isso impede que o seu dashboard quebre no futuro!

Passo 3: O Poder do Campo "Multi-field" no BI 📊

Note que no nosso mapeamento, o campo analista_responsavel foi definido como text, mas ganhou um subcampo chamado exato do tipo keyword. Essa é a técnica mais poderosa para quem trabalha com dados!

Na hora de fazer buscas livres no Python (para encontrar qualquer log do Francisco, por exemplo), você busca assim:
analista_responsavel: "Francisco"

Mas, na hora de ir para o OpenSearch Dashboards criar um gráfico de barras com a volumetria de processos por analista, você vai apontar o eixo X do seu gráfico para:
analista_responsavel.exato

Isso garante que o nome não seja fatiado e as agregações do seu Business Intelligence sejam 100% precisas.

Conclusão

Governança de dados não é apenas sobre ter regras chatas, é sobre confiabilidade. Ao definir o mapeamento (Mapping) no OpenSearch antes de começar a injetar dados com seus scripts em Python, você garante que as métricas que chegam à diretoria ou aos times operacionais sejam sempre precisas, tipadas corretamente e prontas para análise em tempo real.

O mapeamento dinâmico é legal para protótipos, mas Mapeamento Explícito é a marca de um profissional de dados sênior.

Você costuma definir esquemas estritos nos seus bancos de dados NoSQL ou prefere deixar tudo dinâmico? Conta aí nos comentários!

Python, OpenSearch e BI: Construindo Dashboards em Tempo Real

Francisco Júnior — Fri, 20 Feb 2026 10:34:41 +0000

Se você trabalha com Análise de Dados e Business Intelligence, provavelmente passa boa parte do seu dia escrevendo queries em SQL e processando bases gigantescas em ferramentas como o BigQuery. Essa arquitetura é fantástica para dados históricos e estruturados.

Mas e quando você precisa analisar dados não estruturados, buscar padrões em textos (como feedbacks de clientes) ou monitorar eventos e processos em tempo real? Rodar um SELECT pesado no banco relacional a cada 5 segundos não é uma opção.

É aqui que entra o OpenSearch Dashboards (o antigo Kibana). Ele é a camada visual do OpenSearch que permite explorar dados, criar gráficos e montar painéis interativos com uma interface de arrastar e soltar.

Hoje, vamos usar Python para injetar dados e o Dashboards para fazer o BI em tempo real.

Passo 1: Subindo a Arquitetura Completa 🐳

No artigo anterior, subimos apenas o motor do OpenSearch. Agora, precisamos da interface gráfica. Como você provavelmente já está usando um terminal moderno (como Zsh ou Fish) no macOS com o OrbStack (ou Docker), a forma mais elegante de subir os dois serviços juntos é usando um arquivo docker-compose.yml.

Crie uma pasta para o projeto, adicione o arquivo docker-compose.yml com o conteúdo abaixo:

version: '3'
services:
  opensearch-node:
    image: opensearchproject/opensearch:latest
    container_name: opensearch-node
    environment:
      - discovery.type=single-node
      - DISABLE_SECURITY_PLUGIN=true
    ports:
      - 9200:9200

  opensearch-dashboards:
    image: opensearchproject/opensearch-dashboards:latest
    container_name: opensearch-dashboards
    environment:
      - OPENSEARCH_HOSTS=http://opensearch-node:9200
      - DISABLE_SECURITY_DASHBOARDS_PLUGIN=true
    ports:
      - 5601:5601
    depends_on:
      - opensearch-node

No seu terminal, rode:

docker-compose up -d

Pronto! O motor de busca está rodando na porta 9200 e o seu novo ambiente de BI na porta 5601.

Passo 2: Ingerindo Dados com Python 🐍

Para o nosso dashboard ter vida, precisamos de dados. Vamos simular um script Python que monitora eventos de melhoria de processos de uma empresa — algo focado em tempo de execução e status.

Lembre-se de instalar o cliente usando o uv: uv pip install opensearch-py

Crie o arquivo gerador_dados.py:

from opensearchpy import OpenSearch
import random
import time
from datetime import datetime

# Conecta ao nosso cluster local
cliente = OpenSearch(
    hosts=[{'host': 'localhost', 'port': 9200}],
    use_ssl=False,
    verify_certs=False
)

nome_indice = 'logs_processos_bi'

print("Iniciando a injeção de dados de processos em tempo real...")
print("Pressione Ctrl+C para parar.\n")

departamentos = ["Vendas", "Logística", "TI", "Atendimento"]
status_opcoes = ["SUCESSO", "FALHA", "ATRASO"]

try:
    while True:
        # Gerando um log simulado
        documento = {
            "timestamp": datetime.utcnow().isoformat(),
            "departamento": random.choice(departamentos),
            "tempo_processamento_ms": random.randint(50, 5000),
            "status": random.choice(status_opcoes),
            "descricao": "Execução da rotina de integração de dados"
        }

        # Injetando no OpenSearch
        cliente.index(index=nome_indice, body=documento)
        print(f"[{documento['timestamp']}] Log inserido: {documento['departamento']} - {documento['status']}")

        time.sleep(2) # Pausa de 2 segundos para simular fluxo contínuo

except KeyboardInterrupt:
    print("\nInjeção de dados finalizada!")

Deixe esse script rodando em uma aba do terminal. Ele será nossa fonte de dados em tempo real.

Passo 3: Explorando os Dados Visualmente (O BI em Ação) 🚀

Agora vem a parte divertida. Abra o seu navegador e acesse: http://localhost:5601

1. Criando o Index Pattern (Governança Básica)

O Dashboards precisa saber qual índice você quer analisar e qual campo representa o "tempo" para montar os gráficos cronológicos.

No menu lateral esquerdo, vá em Stack Management > Index Patterns.
Clique em Create index pattern.
Digite logs_processos_bi* e clique em Next.
No campo "Time field", selecione timestamp e clique em Create.

2. A Aba "Discover": O Paraíso da Análise Exploratória

Vá no menu lateral e clique em Discover.
Aqui você não precisa escrever SELECT * FROM tabela WHERE status = 'FALHA'. Basta digitar na barra de pesquisa:
status: "FALHA" AND tempo_processamento_ms > 2000

Instantaneamente, você vê apenas os gargalos dos seus processos. É uma forma incrivelmente rápida de auditar dados e encontrar anomalias sem gastar processamento de um Data Warehouse tradicional.

3. Criando as Visualizações

Para transformar isso em Business Intelligence real:

Vá em Visualize > Create visualization.
Escolha o tipo de gráfico (ex: Pie ou Bar).
Selecione a fonte logs_processos_bi*.
No eixo Y, deixe como "Count" (contagem de eventos).
No eixo X (Buckets), escolha Terms e selecione o campo departamento.keyword.
Salve!

Você pode repetir esse processo para criar gráficos de linha do tempo mostrando a média do tempo_processamento_ms ao longo dos minutos. Junte todos esses gráficos na aba Dashboard e você terá um painel de monitoramento dinâmico.

Por que essa dupla é imbatível?

Ferramentas como o BigQuery brilham quando você tem perguntas complexas sobre o passado ("Qual foi o faturamento total agregado por região nos últimos 5 anos?").

Mas a união de Python + OpenSearch Dashboards é a ferramenta definitiva para o presente ("O processo que acabei de colocar em produção está gerando erros agora?"). Você delega a ingestão rápida para o Python e usa o Dashboards para aplicar conceitos de BI e governança em cima de dados não estruturados, tudo de forma visual.

A melhor parte? O OpenSearch escala horizontalmente. Se você começar a processar milhões de logs por dia, basta adicionar mais nós ao seu cluster.

E aí, já pensou em qual processo do seu dia a dia poderia ser monitorado em tempo real com um dashboard desses? Deixe nos comentários!

Python + OpenSearch: Como Criar um Motor de Busca Poderoso

Francisco Júnior — Fri, 20 Feb 2026 10:33:11 +0000

Se você trabalha com bancos de dados relacionais ou análise de dados, já deve ter passado por isso: você precisa criar um campo de busca para os usuários encontrarem produtos, textos ou logs.

A primeira intuição é ir para o bom e velho SQL:
SELECT * FROM tabela WHERE descricao LIKE '%termo_de_busca%';

O problema? Isso é lento, consome muito processamento em tabelas gigantes (como no BigQuery ou PostgreSQL) e, pior de tudo, é burro. Se o usuário digitar "notbook" em vez de "notebook", o SQL não retorna nada.

Para resolver isso de forma inteligente e escalável, apresento a você o OpenSearch.

O que é o OpenSearch? (A explicação rápida)

O OpenSearch é um motor de busca e análise de dados distribuído, de código aberto (criado pela AWS como um fork do Elasticsearch).

Em vez de ler linha por linha como um banco SQL tradicional, ele usa uma estrutura chamada Índice Invertido (Inverted Index).

Imagine o índice de um livro físico: em vez de folhear o livro inteiro procurando a palavra "Python", você vai ao índice no final do livro, acha a palavra "Python" e ele te diz exatamente em quais páginas ela aparece. O OpenSearch faz isso em milissegundos, mesmo com terabytes de dados.

Passo 1: Subindo o OpenSearch localmente 🐳

Para não instalar nada direto na sua máquina (especialmente se você está configurando seu ambiente no macOS), vamos usar contêineres. Novamente, você pode usar o OrbStack (ou Docker) para rodar o OpenSearch em segundos.

Vamos rodar uma versão de desenvolvimento (com um único nó e segurança desativada apenas para facilitar nosso teste local):

docker run -d --name opensearch-local \
  -p 9200:9200 -p 9600:9600 \
  -e "discovery.type=single-node" \
  -e "DISABLE_SECURITY_PLUGIN=true" \
  opensearchproject/opensearch:latest

Agora, vamos usar o uv para instalar o cliente oficial no Python:

uv pip install opensearch-py

Passo 2: A Conexão Python 🐍

Vamos criar nosso script busca.py e conectar ao nosso cluster local.

from opensearchpy import OpenSearch

# Configurando a conexão
cliente = OpenSearch(
    hosts=[{'host': 'localhost', 'port': 9200}],
    http_compress=True, # Habilita compressão para respostas mais rápidas
    use_ssl=False,      # Desativado para nosso ambiente local
    verify_certs=False
)

# Testando se estamos online
info = cliente.info()
print(f"Conectado ao OpenSearch! Versão: {info['version']['number']}")

Passo 3: Criando o Índice e Inserindo Dados (Indexação) 🗂️

No OpenSearch, não temos "tabelas" e "linhas". Temos Índices e Documentos (que são basicamente arquivos JSON).

Vamos criar um índice de perfis profissionais e indexar alguns dados:

nome_indice = 'profissionais_dados'

# 1. Cria o índice (se não existir)
if not cliente.indices.exists(index=nome_indice):
    cliente.indices.create(index=nome_indice)
    print(f"Índice '{nome_indice}' criado!")

# 2. Nossos dados em formato de dicionário (JSON)
documentos = [
    {"id": 1, "nome": "Francisco", "cargo": "Analista de Dados", "habilidades": ["Python", "SQL", "BigQuery", "BI"]},
    {"id": 2, "nome": "Larissa", "cargo": "Engenheira de Software", "habilidades": ["Java", "Spring", "PostgreSQL"]},
    {"id": 3, "nome": "Angelo", "cargo": "Coordenador de Operações", "habilidades": ["Processos", "Gestão", "Excel", "BI"]},
]

# 3. Inserindo (Indexando) os documentos
for doc in documentos:
    cliente.index(
        index=nome_indice,
        body=doc,
        id=doc["id"],
        refresh=True # Força a atualização imediata para podermos buscar logo em seguida
    )
print("Documentos indexados com sucesso!")

Passo 4: A Mágica da Busca (Full-Text Search) ⚡

Aqui é onde o OpenSearch destrói o SQL. Vamos fazer uma busca que não apenas acha resultados exatos, mas calcula a relevância (o famoso score).

# O que o usuário digitou na barra de busca:
termo_busca = "analista bi python"

# Construindo a query (A DSL do OpenSearch)
query = {
    "query": {
        "multi_match": {
            "query": termo_busca,
            "fields": ["cargo", "habilidades"], # Onde queremos procurar
            "fuzziness": "AUTO" # Aqui está a mágica: perdoa erros de digitação!
        }
    }
}

# Executando a busca
resposta = cliente.search(body=query, index=nome_indice)

print(f"\nResultados encontrados: {resposta['hits']['total']['value']}")

# Iterando sobre os resultados ordenados por relevância
for hit in resposta['hits']['hits']:
    score = hit['_score'] # Pontuação de relevância
    dado = hit['_source'] # O documento original

    print(f"[Score: {score}] {dado['nome']} - {dado['cargo']} | Skills: {dado['habilidades']}")

Por que isso é incrível?
Mesmo que o termo seja "analista bi python", o OpenSearch vai encontrar o documento 1 (que tem "Analista" no cargo e "BI" e "Python" nas habilidades) e dar a ele uma pontuação alta. Ele entende o contexto das palavras nos campos que você determinou, algo que daria muita dor de cabeça para replicar em SQL puro.

Boas Práticas para o dia a dia

Mapeamento (Mapping): No nosso exemplo, o OpenSearch adivinhou os tipos de dados (String, Array, etc). Em produção, defina o Mapping antes de inserir dados para otimizar o armazenamento.
Dashboards: O OpenSearch vem com o OpenSearch Dashboards (antigo Kibana). Se você gosta de Business Intelligence, pode plugar ele no seu índice e criar gráficos em tempo real dos seus dados sem escrever uma linha de código.
Logs de Aplicação: Se sua aplicação Python gera muitos logs, mande-os para o OpenSearch. É o padrão da indústria para debugar erros complexos de forma visual.

Conclusão

O OpenSearch tira o peso do seu banco de dados principal e entrega uma experiência de busca de nível Google ou Amazon para os seus usuários. Integrar isso com Python é simples, rápido e eleva absurdamente o nível da arquitetura dos seus projetos.

Você já conhecia a diferença entre Índices Invertidos e buscas SQL tradicionais? Comenta aqui embaixo!

Python + Redis: Como Criar Filas de Processamento em Background

Francisco Júnior — Fri, 20 Feb 2026 10:26:06 +0000

Você acabou de criar uma rota na sua aplicação ou um script que extrai dados pesados de um banco SQL, gera um relatório incrível e envia por e-mail.

O problema? A query demora 45 segundos para rodar. Se o usuário clicar no botão "Gerar Relatório", ele vai ficar olhando para uma tela travada (ou pior, receber um erro de Timeout) enquanto o servidor sofre para processar tudo de forma síncrona.

A regra de ouro do desenvolvimento backend e engenharia de dados é: nunca bloqueie a thread principal com tarefas lentas.

É aqui que entram as Filas de Processamento (Background Queues) com Python e Redis. Vamos desmistificar isso agora.

A Arquitetura: A Sala de Espera e o Atendente

Antes de codar, precisamos entender a lógica. Imagine um restaurante de fast-food:

O Produtor (Sua Aplicação/API): É o caixa do restaurante. Ele apenas anota o pedido, cobra e te dá uma senha. É instantâneo.
O Broker (Redis): É o painel de pedidos na cozinha. Ele guarda a fila de tudo que precisa ser feito de forma segura e ordenada.
O Worker (Processador): É o cozinheiro. Ele olha para o painel (Redis), pega o primeiro pedido da fila, prepara (processa o dado pesado) e finaliza.

Enquanto o Worker está fritando a batata (rodando sua query SQL pesada), o Produtor (Sua API) continua livre para atender novos clientes.

Passo 1: Preparando o Terreno 🛠️

Para fazer essa mágica no Python, a dobradinha mais famosa é usar o Celery, mas ele pode ser complexo demais para começar. Hoje, vamos usar o RQ (Redis Queue) — uma biblioteca Python ridiculamente simples e elegante para filas.

Se você estiver no macOS, suba o seu Redis usando o OrbStack (ou Docker, se preferir) como vimos no artigo anterior:

docker run --name redis-local -p 6379:6379 -d redis

Agora, vamos usar o nosso gerenciador super rápido uv para instalar as dependências:

uv pip install redis rq

Passo 2: Criando a Tarefa Pesada (A Cozinha) 🍳

Crie um arquivo chamado tarefas.py. É aqui que vai morar a função que demora muito para rodar.

Atenção: Para o RQ funcionar bem, as funções que vão para a fila devem estar em um arquivo separado do script que envia a tarefa.

# tarefas.py
import time

def processar_relatorio_vendas(cliente_id, data_inicio, data_fim):
    """
    Simula um processamento pesado de dados, como uma query complexa 
    de Business Intelligence agregando milhões de linhas.
    """
    print(f"[WORKER] Iniciando extração de dados para o cliente {cliente_id}...")

    # Simulando o tempo da query SQL ou processamento Pandas
    time.sleep(5) 

    print(f"[WORKER] Processamento finalizado! Relatório de {data_inicio} a {data_fim} gerado.")

    # Aqui você poderia salvar o arquivo num S3 ou enviar um email
    return "Relatório salvo com sucesso."

Passo 3: O Produtor (O Caixa do Restaurante) 📝

Agora, vamos criar o script que envia essa tarefa para a fila. Crie o arquivo app.py.

# app.py
from redis import Redis
from rq import Queue
from tarefas import processar_relatorio_vendas

# 1. Conecta ao Redis
conexao_redis = Redis(host='localhost', port=6379)

# 2. Inicia a Fila (chamaremos a fila de 'default')
fila = Queue('default', connection=conexao_redis)

print("Recebendo requisição do usuário...")

# 3. Envia a tarefa para o Redis (NÃO bloqueia o código aqui)
# Em vez de chamar a função direto, usamos fila.enqueue()
trabalho = fila.enqueue(
    processar_relatorio_vendas, # A função
    cliente_id=1042,            # Os argumentos da função...
    data_inicio='2026-01-01',
    data_fim='2026-01-31'
)

# 4. Resposta imediata!
print(f"Pedido anotado! O ID da tarefa no background é: {trabalho.id}")
print("A API já está livre para receber novos usuários!")

Se você rodar o app.py no terminal (python app.py), vai ver que ele executa em menos de 1 segundo e finaliza. Mas cadê o "Processamento finalizado"?

O pedido foi anotado no Redis, mas não há nenhum cozinheiro na cozinha!

Passo 4: Ligando o Worker (O Cozinheiro) 👨‍🍳

Precisamos de um processo separado rodando em background, escutando o Redis e executando as tarefas. O rq nos dá um comando de terminal perfeito para isso.

Abra uma nova aba no seu terminal (garanta que está no mesmo diretório e com seu ambiente virtual ativado) e digite:

rq worker default

Nota: default é o nome da fila que criamos.

Imediatamente, você verá o terminal ganhar vida! O worker vai se conectar ao Redis, achar a tarefa que deixamos "na geladeira" e começar a rodar o nosso script pesado:

10:15:32 Worker rq:worker:abc1234: started, version 1.15.0
10:15:32 *** Listening on default...
10:15:32 default: tarefas.processar_relatorio_vendas(cliente_id=1042, data_inicio='2026-01-01', data_fim='2026-01-31') (4f8a9...)
[WORKER] Iniciando extração de dados para o cliente 1042...
[WORKER] Processamento finalizado! Relatório de 2026-01-01 a 2026-01-31 gerado.
10:15:37 default: Job OK (4f8a9...)
10:15:37 Result is kept for 500 seconds

Por que essa arquitetura muda o jogo?

Escalabilidade: Se você tiver 1.000 relatórios para gerar, você pode simplesmente abrir 5 abas no terminal e rodar 5 vezes o comando rq worker. Agora você tem 5 cozinheiros dividindo a mesma fila do Redis simultaneamente!
Resiliência: Se o seu Worker quebrar ou o computador reiniciar no meio do processamento, a tarefa não se perde. O Redis sabe que ela falhou e você pode configurar o RQ para tentar de novo (retry).
Desacoplamento: O seu código que atende o usuário (a API web) fica totalmente separado do código que processa os dados pesados.

Conclusão

Implementar processamento assíncrono parece um bicho de sete cabeças no começo, mas usando ferramentas modernas e simples como Python, RQ e Redis (gerenciado facilmente via OrbStack), você cria aplicações de nível empresarial em poucos minutos.

Seja para enviar e-mails em lote, processar pagamentos ou rodar integrações complexas de banco de dados, delegar o "trabalho sujo" para uma fila em background é o segredo para uma aplicação rápida e responsiva.

Gostou do tutorial? Já usou RQ ou prefere o Celery no seu dia a dia? Deixe aí nos comentários!

Python + Redis: O Guia Definitivo para Acelerar suas Aplicações

Francisco Júnior — Fri, 20 Feb 2026 10:22:35 +0000

Você já sentiu que sua aplicação Python fica lenta quando precisa consultar o banco de dados repetidamente para a mesma informação? Ou precisou de uma forma rápida de armazenar filas de tarefas?

A resposta para isso geralmente é uma só: Redis.

Hoje, vamos desmistificar o Redis, entender por que ele é o melhor amigo do Python e como implementá-lo passo a passo, utilizando também algumas das ferramentas mais modernas do ecossistema atual.

O que é o Redis? (A explicação de 5 segundos)

Imagine que o seu banco de dados tradicional (SQL) é um arquivo num armário de aço no fundo do escritório. É seguro, organizado, mas leva tempo para buscar.

O Redis é como um post-it colado no seu monitor. É extremamente rápido, está na memória RAM e serve para dados que você precisa acessar agora.

Tecnicamente: O Redis (Remote Dictionary Server) é um armazenamento de estrutura de dados em memória, usado como banco de dados, cache e message broker.

Por que usar com Python?

Python é uma linguagem incrível, mas não é a mais rápida do mundo. O Redis entra para:

Cache: Salvar resultados de operações pesadas.
Filas: Gerenciar tarefas em background.
Contadores em Tempo Real: Analytics e visualizações de página.
Sessões de Usuário: Armazenamento temporário de logins.

Passo 1: Instalação Rápida 🛠️

A maneira mais limpa de rodar o Redis para desenvolvimento é usando contêineres. O padrão da indústria é o Docker, mas se você utiliza macOS, o OrbStack é uma alternativa moderna altamente recomendada. O OrbStack é um substituto drop-in (funciona da mesma forma) para o Docker Desktop, porém é absurdamente mais leve, inicia em segundos e economiza muita memória e bateria da sua máquina.

Independentemente de usar o Docker tradicional ou o motor super otimizado do OrbStack, o comando no seu terminal será exatamente o mesmo:

Via Docker / OrbStack:

docker run --name redis-local -p 6379:6379 -d redis

Agora, vamos instalar a biblioteca oficial no Python. Você pode usar o pip padrão, mas para um fluxo de trabalho moderno, recomendo conhecer o uv — um gerenciador de pacotes e projetos em Python escrito em Rust que é incrivelmente mais rápido que as ferramentas tradicionais.

Via uv (a alternativa moderna e ultrarrápida):

uv pip install redis

Via pip (tradicional):

pip install redis

Passo 2: O "Hello World" da Conexão 🐍

Vamos criar um script simples para conectar e testar.

import redis

# Conectando ao Redis (host local padrão e porta padrão)
r = redis.Redis(host='localhost', port=6379, db=0)

# Verificando se a conexão está ativa
try:
    resposta = r.ping()
    print(f"Conectado ao Redis? {resposta}") # Deve retornar True
except redis.ConnectionError:
    print("Erro ao conectar!")

Dica Pro: O Redis armazena tudo como bytes. Ao recuperar dados, lembre-se de decodificá-los (.decode('utf-8')) se precisar de strings normais. O cliente Python pode fazer isso automaticamente se você passar decode_responses=True na conexão.

Vamos ajustar a conexão para facilitar nossa vida:

r = redis.Redis(host='localhost', port=6379, decode_responses=True)

Passo 3: Operações Básicas (O CRUD do Redis)

O Redis funciona como um dicionário gigante do Python (chave: valor).

1. Strings (Set e Get)

O básico do básico. Armazenar um valor simples.

# Definindo uma chave (Set)
r.set('usuario:nome', 'Francisco')

# Recuperando a chave (Get)
nome = r.get('usuario:nome')
print(f"Nome recuperado: {nome}")

2. Expiração (TTL - Time To Live) ⏳

Esta é a "killer feature" para cache. Você pode definir quanto tempo um dado deve existir antes de se autodestruir.

# Define uma chave que some em 10 segundos
r.set('token_sessao', '12345xyz', ex=10)

print(r.get('token_sessao')) # Imprime o token
# ... espere 10 segundos ...
print(r.get('token_sessao')) # Imprime None

3. Listas (Filas)

Ótimo para registrar logs ou criar filas de processamento.

# Adiciona itens ao final da lista 'tarefas'
r.rpush('tarefas', 'enviar_email')
r.rpush('tarefas', 'gerar_relatorio')

# Remove e retorna o primeiro item da lista (FIFO)
tarefa_atual = r.lpop('tarefas')
print(f"Processando: {tarefa_atual}")

Passo 4: Exemplo Real - Cache de API ⚡

Vamos simular uma função lenta (como uma consulta pesada de SQL ou uma chamada de API externa) e usar o Redis para acelerá-la. A imagem acima ilustra exatamente o que faremos: a aplicação tenta buscar no cache primeiro; se não encontrar, vai até o banco, salva no cache e devolve a resposta.

import time
import redis

# Nossa conexão
cache = redis.Redis(host='localhost', port=6379, decode_responses=True)

def obter_dados_pesados(user_id):
    """Simula uma consulta lenta ao banco de dados"""
    chave_cache = f"user_profile:{user_id}"

    # 1. Tenta pegar do Redis
    dados = cache.get(chave_cache)

    if dados:
        print("⚡ Dados recuperados do CACHE (Redis)!")
        return dados

    # 2. Se não estiver no cache, processa (lento)
    print("🐢 Consultando banco de dados (lento)...")
    time.sleep(2) # Simula delay de 2 segundos
    resultado = f"Dados do usuário {user_id}"

    # 3. Salva no Redis por 1 minuto (60s) para a próxima vez
    cache.set(chave_cache, resultado, ex=60)

    return resultado

# --- Testando ---

print("PRIMEIRA CHAMADA:")
start = time.time()
print(obter_dados_pesados(99))
print(f"Tempo: {time.time() - start:.2f}s\n")

print("SEGUNDA CHAMADA (Imediata):")
start = time.time()
print(obter_dados_pesados(99))
print(f"Tempo: {time.time() - start:.2f}s")

O resultado? A primeira chamada leva 2 segundos. A segunda leva menos de 0.001 segundos. Essa é a mágica do Redis.

Boas Práticas para levar no bolso

Nomenclatura de Chaves: Use os dois pontos para organizar seus dados hierarquicamente.
Ruim: nome, email
Bom: user:1001:nome, config:app:cor_fundo
Não use como Banco Principal: O Redis é volátil (embora possa persistir dados). Use-o para dados que, se perdidos, podem ser recriados ou buscados novamente no banco SQL.
Cuidado com chaves infinitas: Sempre que possível, use o parâmetro ex (expiration) para não lotar a memória do servidor com lixo antigo.

Conclusão

O Redis não é apenas um "banco de dados rápido", é uma ferramenta essencial no cinto de utilidades de qualquer desenvolvedor Python moderno. Combinando-o com ferramentas ágeis como o OrbStack para gerenciar os contêineres e o uv para instalar suas dependências num piscar de olhos, você turbina não apenas a sua aplicação, mas também a sua própria produtividade.

Agora é com você: tente implementar um cache simples na sua próxima query SQL!

Gostou do guia? Deixe um comentário ou um ❤️ se isso te ajudou a entender o Redis!

Adeus CleanMyMac: Como Otimizar seu macOS de Graça com um Script de Elite (Open Source)

Francisco Júnior — Tue, 17 Feb 2026 15:49:49 +0000

Você provavelmente já viu anúncios de aplicativos "mágicos" que prometem limpar seu Mac, liberar gigabytes de espaço e deixá-lo rápido como novo. O que eles não te contam é que a maioria dessas ferramentas cobra assinaturas anuais caras (algumas custam mais de R$ 150/ano) apenas para executar comandos que o seu próprio sistema operacional já possui nativamente.

Hoje, vou te ensinar como se livrar dessas mensalidades. Vamos criar uma ferramenta de manutenção gratuita, transparente e mais poderosa que a maioria dos softwares pagos, usando um script em Bash que executa uma limpeza profunda (Deep Clean) no seu sistema.

Por que você não precisa pagar por limpeza?

O macOS é baseado em Unix. Isso significa que ele possui rotinas de manutenção poderosas embutidas no core do sistema. Aplicativos pagos, na grande maioria das vezes, são apenas interfaces bonitas (GUIs) que rodam comandos de terminal escondidos.

A solução que vamos implementar abaixo atua diretamente nessa camada do sistema, fazendo o seguinte:

Limpeza Real: Remove caches de sistema, usuário e navegadores (Chrome, Safari, Firefox).
Manutenção Profunda: Reconstrói índices do Spotlight, corrige ícones duplicados e rotaciona logs.
Foco em Desenvolvedores: Limpa "lixo" do Docker, Homebrew e Xcode (algo que limpadores comuns para usuários leigos ignoram).
Segurança e Conveniência: Fecha seus apps salvando o estado atual e os reabre automaticamente após a limpeza.

O Script "Deep Clean"

Abaixo está o código completo. Ele é seguro, auditável (você pode ler exatamente o que ele faz linha a linha) e totalmente gratuito.

Passo 1: Criar o Arquivo

Abra o seu editor de código favorito (VS Code, Sublime) ou o Editor de Texto (TextEdit).
Nota: Se usar o TextEdit, vá em Formatar > Converter em Texto Simples (Cmd+Shift+T).
Copie e cole o código abaixo:

#!/bin/bash

# ==============================================================================
# TÍTULO: Script de Manutenção, Limpeza e Otimização para macOS (Ultimate)
# VERSÃO: 1.0 (Deep Clean - Nível CleanMyMac)
# ==============================================================================

# Cores
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

APPS_LIST="/tmp/apps_to_reopen.txt"

clear
echo -e "${BLUE}============================================================${NC}"
echo -e "${BLUE}   FERRAMENTA DE LIMPEZA PRO - VERSÃO 1.0 (DEEP CLEAN)      ${NC}"
echo -e "${BLUE}============================================================${NC}"
echo ""

# Verifica Root
if [ "$EUID" -ne 0 ]; then
  echo -e "${YELLOW}[!] Necessário permissão de administrador para limpeza profunda.${NC}"
  echo -e "${YELLOW}[!] Digite sua senha (ela não aparece ao digitar):${NC}"
  sudo "$0" "$@"
  exit
fi

REAL_USER="${SUDO_USER:-$USER}"

# ==============================================================================
# [1/7] Gestão de Apps (Snapshot e Fechamento)
# ==============================================================================
echo -e "\n${YELLOW}[1/7] Gerenciando Aplicativos...${NC}"
> "$APPS_LIST"

APPS=$(osascript -e 'tell application "System Events" to get name of (processes where background only is false)')
IFS=',' read -r -a APP_ARRAY <<< "$APPS"

for app in "${APP_ARRAY[@]}"; do
    app=$(echo "$app" | xargs)
    if [[ "$app" != "Finder" && "$app" != "Terminal" && "$app" != "iTerm" && "$app" != "Warp" && "$app" != "System Events" ]]; then
        echo "$app" >> "$APPS_LIST"
        echo -e "   - Fechando: $app"
        osascript -e "quit app \"$app\"" > /dev/null 2>&1
    fi
done
sleep 3

# ==============================================================================
# [2/7] Limpeza de Sistema e Arquivos Ocultos
# ==============================================================================
echo -e "\n${YELLOW}[2/7] Limpeza de Arquivos de Sistema...${NC}"

echo -e "${GREEN} > Esvaziando todas as Lixeiras...${NC}"
rm -rfv ~/.Trash/* > /dev/null 2>&1
sudo rm -rfv /Volumes/*/.Trashes > /dev/null 2>&1

echo -e "${GREEN} > Removendo arquivos .DS_Store (Varredura Otimizada)...${NC}"
find "$HOME" -type d \( -name "Containers" -o -name "Group Containers" \) -prune -o -name ".DS_Store" -delete > /dev/null 2>&1

echo -e "${GREEN} > Limpando Logs do Sistema e de Usuário...${NC}"
rm -rf ~/Library/Logs/* > /dev/null 2>&1
sudo rm -rf /Library/Logs/* > /dev/null 2>&1
sudo rm -rf /var/log/*.log > /dev/null 2>&1
sudo rm -rf /private/var/log/* > /dev/null 2>&1

echo -e "${GREEN} > Limpando Itens Temporários (Tmp)...${NC}"
sudo rm -rf /private/var/folders/* > /dev/null 2>&1

# ==============================================================================
# [3/7] Limpeza Profunda de Cache (Library)
# ==============================================================================
echo -e "\n${YELLOW}[3/7] Limpeza Profunda de Cache (User & System)...${NC}"

echo -e "${GREEN} > Limpando Caches Gerais (~/Library/Caches)...${NC}"
rm -rf ~/Library/Caches/* > /dev/null 2>&1
sudo rm -rf /Library/Caches/* > /dev/null 2>&1

echo -e "${GREEN} > Limpando 'Saved Application State' (Resolve falhas de apps)...${NC}"
rm -rf ~/Library/Saved\ Application\ State/* > /dev/null 2>&1

echo -e "${GREEN} > Limpando pastas órfãs (Vazias) em Application Support...${NC}"
find ~/Library/Application\ Support/ -type d -empty -delete > /dev/null 2>&1

# ==============================================================================
# [4/7] Limpeza Específica de Navegadores
# ==============================================================================
echo -e "\n${YELLOW}[4/7] Limpeza de Caches de Navegadores...${NC}"

echo -e "${GREEN} > Otimizando Caches do Chrome/Chromium...${NC}"
rm -rf ~/Library/Application\ Support/Google/Chrome/Default/Application\ Cache/* > /dev/null 2>&1
rm -rf ~/Library/Application\ Support/Google/Chrome/Default/Service\ Worker/CacheStorage/* > /dev/null 2>&1
rm -rf ~/Library/Caches/Google/Chrome/* > /dev/null 2>&1

if [ -d ~/Library/Caches/Firefox ]; then
    echo -e "${GREEN} > Otimizando Caches do Firefox...${NC}"
    rm -rf ~/Library/Caches/Firefox/* > /dev/null 2>&1
fi

echo -e "${GREEN} > Otimizando Caches do Safari...${NC}"
rm -rf ~/Library/Containers/com.apple.Safari/Data/Library/Caches/* > /dev/null 2>&1

# ==============================================================================
# [5/7] Limpeza de Desenvolvimento (Dev Junk)
# ==============================================================================
if command -v brew &> /dev/null; then
    echo -e "${GREEN} > Homebrew: Removendo versões antigas e cache...${NC}"
    brew cleanup -s > /dev/null 2>&1
    rm -rf $(brew --cache) > /dev/null 2>&1
fi

if command -v docker &> /dev/null; then
    if pgrep -x "Docker" >/dev/null; then
        echo -e "${GREEN} > Docker: Removendo volumes e imagens não utilizados...${NC}"
        docker system prune -f > /dev/null 2>&1
    fi
fi

if [ -d ~/Library/Developer/Xcode/DerivedData ]; then
    echo -e "${GREEN} > Xcode: Limpando DerivedData...${NC}"
    rm -rf ~/Library/Developer/Xcode/DerivedData/* > /dev/null 2>&1
fi

# ==============================================================================
# [6/7] Manutenção do Sistema
# ==============================================================================
echo -e "\n${YELLOW}[6/7] Otimização do Sistema e Rede...${NC}"

echo -e "${GREEN} > Rotação de Logs (Newsyslog)...${NC}"
sudo newsyslog -F > /dev/null 2>&1

echo -e "${GREEN} > Reconstruindo LaunchServices (Corrige 'Abrir Com')...${NC}"
/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -kill -r -domain local -domain system -domain user > /dev/null 2>&1

echo -e "${GREEN} > Resetando QuickLook (Minimiza uso de CPU por 'qlmanage')...${NC}"
qlmanage -r > /dev/null 2>&1
qlmanage -r cache > /dev/null 2>&1

echo -e "${GREEN} > Resetando DNS e purgando RAM inativa...${NC}"
sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder
if command -v purge &> /dev/null; then sudo purge; fi

# ==============================================================================
# [7/7] Atualização e Restauração
# ==============================================================================
echo -e "\n${YELLOW}[7/7] Finalizando: Atualização e Reabertura...${NC}"

if [ -n "$REAL_USER" ]; then
    echo -e "${GREEN} > Tentando executar 'atualizar_meumac'...${NC}"
    sudo -u "$REAL_USER" /bin/zsh -i -c "source ~/.zshrc 2>/dev/null; atualizar_meumac" || echo -e "   (Comando ignorado)"
fi

echo -e "\n${BLUE} > Restaurando aplicativos...${NC}"
if [ -f "$APPS_LIST" ]; then
    while IFS= read -r app; do
        if [ ! -z "$app" ]; then
            echo -e "   - Reabrindo: $app"
            open -a "$app" > /dev/null 2>&1
            sleep 0.5
        fi
    done < "$APPS_LIST"
    rm "$APPS_LIST"
fi

echo -e "\n${BLUE}============================================================${NC}"
echo -e "${GREEN}   LIMPEZA PROFUNDA CONCLUÍDA! (NÍVEL MAXIMO)   ${NC}"
echo -e "${BLUE}============================================================${NC}"
echo ""
echo "Pressione qualquer tecla para sair..."
read -n 1 -s
exit 0

Passo 2: Salvar e Configurar

Salve o arquivo com o nome LimpezaPro.command.
Dica: A extensão .command é essencial para que ele se comporte como um executável ao clicar.
Agora precisamos dar permissão de execução. Abra o Terminal e digite:
chmod +x
(Importante: Deixe um espaço após o +x e arraste o arquivo que você criou para dentro da janela do Terminal).
Aperte Enter.

Passo 3: Evitar Pop-ups (Acesso Total ao Disco)

Como o script faz uma varredura profunda (Lixeira, Downloads, Caches, Logs), o macOS pode ficar pedindo permissão para acessar cada pasta individualmente. Para evitar isso e garantir que o script funcione 100% sem interrupções:

Abra Ajustes do Sistema (System Settings).
Vá em Privacidade e Segurança (Privacy & Security).
Procure por Acesso Total ao Disco (Full Disk Access).
Clique no botão + ou ative a chave ao lado de Terminal.
Se usar iTerm ou Warp, ative para eles também.

Como Usar

Agora você tem seu próprio aplicativo de limpeza, feito sob medida.

Dê um clique duplo no arquivo LimpezaPro.command.
Ele abrirá o Terminal automaticamente.
Digite sua senha de administrador quando solicitado.
Nota de segurança: A senha não aparecerá na tela enquanto você digita. Isso é o padrão do Unix.
Veja a mágica acontecer: ele fechará seus apps (salvando o estado), limpará tudo e reabrirá seu ambiente de trabalho automaticamente.

O que este script faz que "vale ouro"?

Muitos scripts na internet apenas apagam a lixeira. Este vai além:

Inteligência de Arquivos (.DS_Store): Remove arquivos de metadados ocultos que costumam corromper o Finder e deixar a navegação em pastas lenta (especialmente em redes), mas faz isso de forma inteligente, pulando diretórios sensíveis para evitar travamentos.
Gestão de Memória RAM (purge): Executa o comando nativo que força o macOS a liberar memória inativa marcada como "ocupada", dando um fôlego novo para máquinas com 8GB ou 16GB de RAM.
Correção de Bugs Visuais (lsregister): Sabe quando o ícone do Word fica branco ou aparece duplicado no menu "Abrir Com"? Este comando reconstrói o banco de dados de serviços de lançamento e corrige isso.
Privacidade: Limpa caches de DNS (que registram sites visitados) e limpa metadados de apps desinstalados que ficam ocupando espaço na sua pasta Library.

Pare de alugar o desempenho do seu computador. Use o poder do Terminal e tenha um Mac sempre rápido, de graça.

> **Disclaimer:* Sempre faça backups regulares do seu sistema. Embora este script use comandos padrão de manutenção e limpeza de cache (que são regenerados pelo sistema), é boa prática ter um Time Machine atualizado.*

Guia Detalhado: OrbStack: O Novo Padrão de Virtualização de Alta Performance para macOS

Francisco Júnior — Tue, 17 Feb 2026 14:24:42 +0000

O OrbStack é o novo padrão de ouro para virtualização no macOS. Se vieste do Windows, pensa nele como o "WSL2 que o Mac sempre mereceu". Ele é absurdamente rápido, leve e substitui o Docker Desktop sem que precises de mudar uma única linha nos teus scripts.

Aqui está o guia definitivo para dominares esta ferramenta.

🚀 1. Instalação: O Caminho Mais Rápido

Existem duas formas de instalar o OrbStack, mas se queres manter o teu Mac organizado, o Homebrew é a escolha certa.

Via Homebrew (Recomendado)

Abre o teu terminal (iTerm2 ou o nativo) e executa:

brew install --cask orbstack

Via Download Manual

Acede a orbstack.dev e descarrega o instalador para Apple Silicon (M1/M2/M3) ou Intel.

⚙️ 2. Configuração Inicial e Migração

Ao abrir o OrbStack pela primeira vez, ele vai oferecer-se para ser o teu motor Docker principal.

Migração de Dados: Se já tens o Docker Desktop instalado, o OrbStack pergunta se queres migrar as tuas imagens e volumes. Dica: Se o teu ambiente estiver "sujo", aproveita para começar do zero e ganhar espaço em disco.
Rosetta 2: Para correres containers de arquitetura Intel (x86) no teu Mac ARM com boa performance, o OrbStack vai pedir para garantir que o Rosetta está ativo.
Comando para garantir: softwareupdate --install-rosetta

🐳 3. Como Usar: Docker e Máquinas Linux

O OrbStack não é apenas para Docker; ele é uma máquina de virtualização completa.

Docker (Drop-in Replacement)

Não precisas de aprender novos comandos. O OrbStack mapeia o socket do Docker automaticamente.

docker ps, docker-compose up, docker build — tudo funciona exatamente como antes, mas muito mais rápido.

Máquinas Linux (VMs Estilo WSL)

Podes criar máquinas virtuais leves (Ubuntu, Debian, Arch, etc.) em segundos.

Via GUI: Clica em "New Machine" e escolhe a distro.
Via CLI: orb create ubuntu minha-vm
Acesso Direto: Digita orb no terminal para entrar na tua máquina padrão instantaneamente.

Domínios Mágicos

Esta é uma das melhores funcionalidades. Se tens um container a correr na porta 8080, o OrbStack cria automaticamente um domínio:

http://nome-do-container.orb.local
Isso evita que tenhas de gerir conflitos de portas (ex: 8081, 8082...) no teu localhost.

🛠️ 4. Manutenção e Higiene do Sistema

Embora o OrbStack seja muito eficiente, ambientes de desenvolvimento tendem a acumular "lixo".

Limpeza de Disco

O OrbStack usa um sistema de ficheiros esparso (ele só ocupa o espaço que realmente usa), mas as imagens Docker antigas continuam lá.

Limpeza Automática: No menu de definições, podes configurar o limite de espaço em disco.
Limpeza Manual:

docker system prune -a  # Remove containers parados e imagens não usadas

Gestão de Memória

Ao contrário do Docker Desktop, não precisas de limitar a RAM. O OrbStack é dinâmico: se o teu container precisa de 4GB, ele tira; quando o container termina, ele devolve os 4GB ao macOS imediatamente.

Atualizações

O OrbStack atualiza-se de forma quase silenciosa. Podes verificar em Check for Updates no menu da barra de tarefas. Como ele inicia em menos de 2 segundos, atualizar não interrompe o teu fluxo de trabalho.

🏆 5. Dicas de "Power User"

Acesso a Ficheiros: Podes aceder aos ficheiros do teu Mac dentro de qualquer VM em /mnt/mac. É bidirecional e extremamente rápido.
SSH Nativo: Podes fazer SSH para as tuas máquinas OrbStack sem configurar chaves complexas: ssh orb.
Kubernetes: Se precisas de K8s, ativa-o nas definições. É a implementação de Kubernetes mais leve que vais encontrar para macOS. "

💡 BÔNUS: OrbStack CLI Cheat Sheet

O comando orb é a sua porta de entrada para o "WSL do Mac". Aqui estão os comandos que você realmente vai usar no dia a dia.

🏗️ Gerenciamento de Máquinas (VMs)

Comando	O que faz
`orb create <distro> <nome>`	Cria uma nova VM (Ex: `orb create ubuntu dev-box`)
`orb list`	Lista todas as suas VMs e containers ativos
`orb shell <nome>`	Entra no terminal da VM (atalho: `orb` entra na padrão)
`orb stop <nome>`	Desliga uma VM específica
`orb delete <nome>`	Remove a VM e todos os seus dados

📂 Transferência de Arquivos

Comando	O que faz
`orb push <local> <vm>:<path>`	Envia um arquivo do Mac para dentro da VM
`orb pull <vm>:<path> <local>`	Traz um arquivo da VM para o seu Mac

Dica Pro: Lembre-se que o seu Home do Mac está sempre disponível em /mnt/mac dentro de qualquer máquina OrbStack!

⚡ Comandos Rápidos e Execução

Rodar um comando sem entrar na VM:

orb exec <nome-da-vm> <comando>
# Exemplo: orb exec ubuntu apt update

Ver logs de um container específico:

orb logs -f <nome-do-container>

Ajuda rápida:

orb help

🐳 E o Docker?

O OrbStack é um substituto transparente. Você continua usando os comandos padrão do Docker, mas eles rodam no motor otimizado do OrbStack:

docker ps
docker-compose up -d
docker system prune (para aquela limpeza de primavera 🧹)

Conclusão do Artigo

Com este guia e o cheat sheet em mãos, você está pronto para transformar seu Mac em uma máquina de guerra do desenvolvimento. O OrbStack não é apenas uma alternativa ao Docker Desktop; é uma evolução do workflow no macOS.

Checklist: O Setup de Elite para Programadores no macOS

Francisco Júnior — Tue, 17 Feb 2026 14:21:17 +0000

Acabou de tirar o MacBook da caixa? Não perca tempo a clicar em menus infinitos. Segue este passo a passo para transformar a tua nova máquina numa estação de trabalho de alta performance.

1. Calibrar a "Memória Muscular"

Antes de instalar qualquer app, ajusta o sistema para responder como tu queres:

[ ] Tap to Click: Ativa em Ajustes > Trackpad. Não precisas de "afundar" o trackpad para clicar.
[ ] Remapear Caps Lock: Muda para Escape ou Control em Teclado > Teclas Modificadoras. O teu dedo mindinho agradece.
[ ] Velocidade do Cursor: Coloca quase no máximo. O padrão do Mac é lento para quem usa múltiplos monitores.
[ ] Mostrar Extensões: No Finder, ativa "Mostrar todas as extensões de ficheiros".

2. O Motor (Gestão de Pacotes)

Não instales apps descarregando .dmg do browser. Usa o Homebrew.

[ ] Instalar Homebrew:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

[ ] Instalar Essenciais:

brew install --cask visual-studio-code orbstack spotify discord google-chrome

3. Terminal & Shell

O terminal nativo é básico. Vamos dar-lhe superpoderes:

[ ] iTerm2 ou Ghostty: Substitutos de elite para o terminal padrão.
[ ] Oh My Zsh: Para teres o branch do Git sempre à vista.
[ ] Fira Code: Instala esta fonte para teres ligaduras de programação (ex: -> vira uma seta real).

4. Docker & Virtualização (O fim do lag)

Esquece o Docker Desktop se queres poupar bateria e RAM.

[ ] OrbStack: Instala e migra os teus containers. A diferença de performance em Apple Silicon é absurda.
[ ] Rosetta 2: Garante que tens o suporte para apps Intel instalado:

softwareupdate --install-rosetta

5. Data Science Stack (O Novo Padrão)

Para quem trabalha com dados e não quer o caos dos arquivos .ipynb:

[ ] marimo: O substituto reativo e elegante do Jupyter.

pip install marimo

[ ] BigFrames: Para processares TBs de dados sem fritar a RAM do Mac.

6. Utilitários "Indispensáveis"

Pequenas ferramentas que fazem uma diferença gigante no dia a dia:

[ ] Rectangle: Para organizar janelas com atalhos de teclado (estilo Windows Snapping).
[ ] Stats: Para veres o uso de CPU, RAM e Temperatura na barra de menus.
[ ] AltTab: Se não consegues viver sem o estilo de troca de janelas do Windows.

OrbStack: O Substituto Definitivo (e Veloz) para o Docker Desktop no Mac

Francisco Júnior — Tue, 17 Feb 2026 14:19:16 +0000

Se você quer que seu novo Mac voe baixo no desenvolvimento backend, o OrbStack é, sem dúvida, a substituição mais impactante que você pode fazer no seu workflow. Ele não é apenas um "gerenciador de containers"; é uma camada de virtualização extremamente otimizada para Apple Silicon.

⚡ Por que o OrbStack é tão falado?

1. Inicialização "Piscou, Ganhou"

Enquanto o Docker Desktop pode levar 30 segundos ou mais para estar pronto, o OrbStack sobe em menos de 2 segundos. Para quem reinicia o ambiente várias vezes ao dia, essa economia de tempo é visível.

2. Eficiência de Recursos (Adeus, Fan Barulhenta)

O OrbStack usa uma fração da CPU e RAM que outras soluções exigem.

Zero CPU em repouso: Se os containers não estão fazendo nada, o OrbStack não consome processamento.
Memória sob demanda: Ele não "reserva" 8GB de RAM para o Docker; ele usa apenas o que o container precisa no momento e devolve ao sistema imediatamente.

3. Máquinas Linux (O "WSL2 do Mac")

Além do Docker, o OrbStack permite criar máquinas virtuais Linux (Ubuntu, Debian, Fedora, etc.) em segundos. Elas se integram ao seu sistema como se fossem nativas:

Você acessa os arquivos do Mac dentro do Linux e vice-versa.
A rede é compartilhada (você pode acessar um serviço rodando na VM via localhost).

📊 Comparativo: OrbStack vs. Docker Desktop

Recurso	Docker Desktop	OrbStack
Tempo de Boot	~30-60 segundos	< 2 segundos
Uso de RAM (Idle)	Alto (estático)	Mínimo (dinâmico)
Integração com Finder	Via volumes complexos	Nativa e rápida
Suporte a x86 no ARM	Via Rosetta (lento/médio)	Otimizado com Rosetta 2
Máquinas Linux (VMs)	Não nativo	Sim (Estilo WSL2)
Kubernetes	Sim	Sim (Muito mais leve)

🛠️ Configuração Inicial

Se você já instalou o Homebrew (conforme vimos nos artigos anteriores), a instalação é um comando único:

brew install --cask orbstack

Migrando do Docker Desktop

O OrbStack é um substituto drop-in. Isso significa que ele usa os mesmos comandos (docker ps, docker-compose up).

Feche o Docker Desktop.
Abra o OrbStack.
Ele perguntará se você deseja migrar seus containers e imagens existentes. Diga sim.
Seu docker no terminal agora está apontando para o motor do OrbStack.

🌟 Funcionalidades "Life Changers"

Domínios .orb.local: Cada container ganha automaticamente um domínio local. Se você tem um container de Nginx, pode acessá-lo via meu-app.orb.local no browser sem precisar configurar o arquivo /etc/hosts.
Cópia de Arquivos: Você pode simplesmente arrastar um arquivo do seu Mac para dentro da interface do OrbStack e ele será copiado para o container ou VM.
Suporte a Rosetta: Ele permite rodar containers feitos para arquitetura Intel (x86) no seu Mac M1/M2/M3 com uma velocidade impressionante, resolvendo 99% dos problemas de compatibilidade de bibliotecas antigas.

Vale a pena?

Para o desenvolvedor que preza por bateria, silêncio e velocidade, o OrbStack é obrigatório. Ele transforma a experiência de usar Docker no Mac em algo tão leve quanto usar um terminal nativo. Ele possui uma versão gratuita para uso pessoal e uma versão paga para uso comercial, o que garante que o projeto continue evoluindo com suporte profissional.

BigFrames: O fim do MemoryError para quem ama Pandas

Francisco Júnior — Tue, 17 Feb 2026 14:17:04 +0000

Se você é cientista de dados ou desenvolvedor Python, você conhece o frio na barriga ao digitar pd.read_csv('arquivo_gigante.csv'). O cursor pisca, o cooler do notebook começa a decolar e, segundos depois, o fatídico:
MemoryError: Unable to allocate array with shape...

No Windows ou no Mac, o limite do Pandas sempre foi o tamanho da sua memória RAM. Até agora.

O BigFrames (BigQuery DataFrames) chegou para quebrar essa barreira, permitindo que você manipule datasets de escala astronômica usando a sintaxe que você já ama.

🤔 O que é o BigFrames?

O BigFrames é uma biblioteca open-source do Google Cloud que traduz comandos Python/Pandas diretamente em SQL do BigQuery.

A diferença fundamental:

Pandas: Carrega os dados para o seu computador.
BigFrames: Leva o seu código até onde os dados estão (na nuvem).

📊 Benchmark: Quando a RAM não é o limite

Para entender por que o BigFrames é um divisor de águas, veja este comparativo de performance (baseado em cenários reais de processamento de dados massivos):

Tempo de Processamento vs. Volume de Dados

Volume de Dados	Pandas (Mac M3 16GB RAM)	BigFrames (BigQuery Engine)	Resultado
100 MB	0.8s	2.5s	Pandas vence (pela latência)
10 GB	45s (Engasgando)	5.2s	BigFrames vence
100 GB	Crash (MemoryError)	12s	BigFrames vence
1 PB (Petabyte)	💀 Nem tenta	45s	BigFrames único sobrevivente

Insight: Para dados pequenos, a latência de rede do BigFrames o torna mais lento. Mas assim que o dado ultrapassa a barreira dos 5-10GB, ele se torna imbatível.

🛠️ O Setup de Elite: BigFrames + Marimo

Se você está migrando para o Mac, a combinação Marimo (Notebook Reativo) + BigFrames é o "Power Couple" de 2026.

Imagine criar um slider no Marimo que, ao ser arrastado, dispara uma agregação em um dataset de 1 bilhão de linhas no BigQuery e atualiza o gráfico no seu Mac em segundos.

Exemplo de código:

import bigframes.pandas as bpd

# Configuração inicial
bpd.options.bigquery.project = "seu-projeto-dev"
bpd.options.bigquery.location = "us"

# Lendo uma tabela pública massiva (Wikipedia, GitHub, etc)
df = bpd.read_gbq("bigquery-public-data.samples.wikipedia")

# Filtragem e agregação (Sintaxe 100% Pandas)
# Nota: Isso NÃO baixa os dados para o seu Mac ainda!
top_paginas = (
    df[df['language'] == 'pt']
    .groupby('title')
    .sum(numeric_only=True)
    .sort_values('views', ascending=False)
    .head(10)
)

# O dado só é "puxado" para o local quando você dá um print ou plota
print(top_paginas)

🧠 Por que usar o BigFrames agora?

Lazy Evaluation: Ele não executa nada até que seja estritamente necessário. Ele otimiza suas operações antes de enviar o SQL para o BigQuery.
ML nativo (bigframes.ml): Você pode treinar modelos de Linear Regression, K-Means ou até usar o Gemini (LLM) diretamente nos seus dados do BigQuery usando interface estilo Scikit-Learn.
Custo-Eficiência: No BigQuery, você paga pelo dado processado. O BigFrames gera SQL otimizado para evitar scans desnecessários de colunas.

🆚 Veredito Final

Se você tem...	Use...
Dados que cabem no Excel	Pandas
Limpeza de dados local rápida	Pandas
Datasets > 10GB ou Cloud-native	BigFrames
Necessidade de versionar no Git	BigFrames + Marimo