Cliente open source da AWS para containers

O desenvolvimento de containers está no coração da computação moderna, e a AWS deu um passo ousado ao lançar o Finch—um cliente de linha de comando open source que facilita a criação, execução e publicação de containers Linux em ambientes locais.

O que é o Finch?

Finch é uma ferramenta leve e extensível que combina componentes open source como:

• Lima: para virtualização em macOS
• nerdctl: uma alternativa ao Docker CLI
• containerd: runtime de containers
• BuildKit: para construção eficiente de imagens

Inicialmente lançado para macOS, o Finch agora oferece suporte completo para Windows e Linux, tornando-se uma solução multiplataforma para desenvolvedores que desejam trabalhar com containers de forma local e integrada.

Funcionalidades principais

• Construção de imagens com Dockerfiles
• Execução de containers localmente
• Push/pull de imagens para registries
• Gerenciamento de redes e volumes
• Suporte a aplicações multi-container via finch compose

No Linux, o Finch interage diretamente com o kernel usando namespaces e cgroups, sem necessidade de camadas de virtualização. Já no Windows e macOS, ele utiliza WSL2 e Virtualization Framework, respectivamente.

Instalação

No Debian e derivados, segue:

1.Importe a chave GPG:

curl -fsSL https://artifact.runfinch.com/deb/GPG_KEY.pub | sudo gpg --dearmor -o /usr/share/keyrings/runfinch-finch-archive-keyring.gpg

2.Adicione o repositório APT:

Para sistemas AMD64:

echo "deb [signed-by=/usr/share/keyrings/runfinch-finch-archive-keyring.gpg arch=amd64] https://artifact.runfinch.com/deb noble main" | sudo tee /etc/apt/sources.list.d/runfinch-finch.list

3.Atualize os pacotes e instale o Finch:

sudo apt update
sudo apt install runfinch-finch

Por que a AWS criou o Finch?

Segundo a equipe da AWS, a ideia surgiu da necessidade de uma ferramenta simples e padronizada para desenvolvimento de containers em ambientes locais. Em vez de depender de soluções comerciais ou montar ferramentas fragmentadas, o Finch oferece uma experiência coesa e baseada em padrões da indústria.

Comunidade e contribuições

O Finch é licenciado sob Apache 2.0 e está aberto a contribuições. A AWS incentiva desenvolvedores a participar no repositório oficial .

Finch representa uma abordagem moderna e colaborativa para o desenvolvimento de containers. Se você busca uma alternativa leve, open source e integrada ao ecossistema da AWS, vale a pena experimentar.

Feito!

14 anos de blog

O blog está completando hoje, 21 de Agosto de 2025, 14 anos!

Gostaria de agradecer a todos pelo prestígio e a paciência de ler os posts que são publicados. Espero continuar compartilhando conhecimentos no blog para nossos leitores. Continuem prestigiando e divulgando o blog Mundo da Computação Integral, assim aumentamos nossa comunidade.

Manipulando arquivos gigantes com Python

Quando trabalhamos com Python no dia a dia, é comum lidarmos com arquivos CSV ou Excel relativamente pequenos. Porém, em cenários de Data Science e Big Data, não é raro recebermos um arquivo que ultrapassa a casa dos gigabytes. E aí surge o problema: carregar tudo na memória de uma só vez pode simplesmente derrubar a sua máquina.

A boa notícia é que o Python tem ferramentas que permitem processar esses arquivos de forma inteligente e incremental. Hoje, vamos falar sobre o conceito de chunks.

O que são chunks?

De forma simples, um chunk é um pedaço do arquivo.

Ao invés de ler um CSV inteiro com pandas.read_csv(), podemos instruir o Pandas a carregar n linhas por vez, processar, salvar o resultado parcial e liberar memória. Assim, conseguimos trabalhar com arquivos gigantes sem precisar de um supercomputador.

Exemplo prático

Imagine que temos um arquivo transacoes.csv com 100 milhões de linhas. Queremos somar o valor total de uma coluna chamada valor.

Solução tradicional (não funciona bem em arquivos grandes):

import pandas as pd
# Isso pode travar o computador!
df = pd.read_csv("transacoes.csv")
print("Total:", df["valor"].sum())

Se o arquivo for grande demais, sua memória RAM não vai aguentar.

Solução com chunks:

import pandas as pd
total = 0
# Lendo o arquivo em blocos de 1 milhão de linhas
for chunk in pd.read_csv("transacoes.csv", chunksize=10**6):
    total += chunk["valor"].sum()

print("Total:", total)

Nesse caso:

chunksize=10**6 significa que o Pandas vai ler 1 milhão de linhas por vez.

Cada pedaço é processado, somado e descartado da memória.

Ao final, temos o total consolidado sem sobrecarregar o sistema.

Vantagens do processamento em chunks

• Trabalhar com arquivos enormes sem precisar expandir a RAM.
• Possibilidade de processamento incremental (ex: salvar resultados parciais).
• Aplicável a diversas operações: filtros, agregações, limpeza de dados, exportação em lotes.

Onde isso aparece na prática?

• Relatórios financeiros de grandes empresas.
• Logs de servidores com milhões de registros.
• Bases públicas gigantes, como dados do IBGE ou Kaggle.

Considerações finais

Trabalhar com chunks é quase um rito de passagem para quem está saindo do Python intermediário e entrando em projetos de nível avançado, onde eficiência importa tanto quanto clareza do código.

Feito!

Automação de tarefas com Python e Pandas

Imagine o seguinte cenário: toda semana você recebe relatórios de vendas em formato CSV e precisa consolidá-los em uma única planilha para gerar um resumo.

Fazer isso manualmente pode levar horas. Mas com o Pandas, é questão de segundos.

O Pandas é uma das bibliotecas mais poderosas do ecossistema Python para análise, transformação e automação de dados.

Se você já lidou com planilhas no Excel, vai se sentir em casa, mas aqui, com muito mais poder e automação.

Preparando o ambiente

Como sempre, vamos manter nosso projeto isolado em um ambiente virtual.

python3 -m venv .venv

No Linux/macOS source .venv/bin/activate

No Windows source .venv\Scripts\activate

Instalando o Pandas

Abre o terminal:

pip install pandas openpyxl

pandas: biblioteca principal para análise de dados.

openpyxl: permite exportar para Excel (.xlsx).

Lendo um arquivo CSV

Vamos começar simples: carregar um relatório em CSV e inspecionar os dados.

relatorio-vendas.py

import pandas as pd

# Carregar o arquivo CSV
df = pd.read_csv("vendas.csv")

# Exibir as primeiras linhas
print(df.head())

Se o arquivo vendas.csv contiver algo como:

data,produto,quantidade,valor
01/08/2025,Notebook,3,3500
01/08/2025,Mouse,10,80
01/08/2025,Teclado,5,150

A saída será uma tabela organizada, semelhante a uma planilha.

python3 relatorio-vendas.py

         data   produto  quantidade  valor
0  01/08/2025  Notebook           3   3500
1  01/08/2025     Mouse          10     80
2  01/08/2025   Teclado           5    150

Filtrando e transformando dados

Agora vamos selecionar apenas vendas acima de R$ 1000.

filtro = df[df["valor"] > 1000]
print(filtro)

Resultado:

         data        produto   quantidade  valor
0        01/08/2025  Notebook     3        3500

Exportando para Excel

filtro = df
filtro.to_excel("vendas_filtradas.xlsx", index=False)
print("Relatório exportado para vendas_filtradas.xlsx")

Com isso, temos um arquivo pronto para ser compartilhado, sem precisar abrir o Excel manualmente.

Mini-projeto: Consolidando múltiplos relatórios

Imagine que você recebe vários arquivos CSV (vendas_jan.csv, vendas_fev.csv, etc.).

Podemos juntá-los em um único relatório com poucas linhas de código:

import pandas as pd
import glob

# Carregar todos os arquivos CSV
arquivos = glob.glob("vendas_*.csv")

# Concatenar em um único DataFrame
dfs = [pd.read_csv(arq) for arq in arquivos]
df_final = pd.concat(dfs, ignore_index=True)

# Salvar no Excel
df_final.to_excel("vendas_consolidadas.xlsx", index=False)
print("Relatório consolidado gerado com sucesso!")

Agora, em vez de copiar e colar manualmente dezenas de planilhas, você automatiza tudo em segundos.

Quando usar Pandas para automação

O Pandas é ideal para:

• Processar grandes volumes de dados de forma rápida.
• Automatizar tarefas repetitivas de ETL (Extract, Transform, Load).
• Transformar relatórios em insights prontos para análise.

Considerações finais

Com o Pandas, você elimina horas de trabalho repetitivo e ganha produtividade, transformando relatórios manuais em processos automáticos e confiáveis.

Feito!

Criando APIs REST com Python

Imagine que você precisa criar um serviço que permita que outros sistemas ou aplicações acessem seus dados de forma segura e padronizada. É aí que entram as APIs REST, uma das formas mais comuns de comunicação entre aplicações na web.

E, quando falamos de Python,um dos frameworks leve e eficientes para construir APIs é o FastAPI.

O que é o FastAPI?

O FastAPI é um framework web para Python, projetado para criar APIs de forma:

• Rápida:

otimizado para alta performance usando programação assíncrona.

• Segura:

valida automaticamente os dados recebidos.

• Produtiva:

gera documentação interativa automaticamente.

Ele é tão eficiente que já é usado em produção por empresas como Microsoft e Uber.

Por que usar o FastAPI?

Velocidade de desenvolvimento: você escreve menos código para fazer mais.

Validação automática: parâmetros e dados recebidos são verificados automaticamente.

Documentação integrada: acesso imediato à documentação interativa via Swagger UI e ReDoc.

Desempenho: comparável a frameworks rápidos como Node.js e Go.

Preparando o ambiente

Como nas postagens anteriores, vamos criar um ambiente virtual para manter as dependências isoladas.

python3 -m venv .venv

No Linux/macOS source .venv/bin/activate

No Windows source .venv\Scripts\activate

Instalando o FastAPI e o servidor Uvicorn

pip install fastapi uvicorn

fastapi: framework para criar a API.

uvicorn: servidor leve e rápido para rodar a aplicação.

Criando sua primeira API

Crie um arquivo chamado main.py

Executando a aplicação

No terminal:

uvicorn main:app --reload

main:app main é o nome do arquivo, app é a instância do FastAPI.

--reload reinicia automaticamente o servidor ao modificar o código.

Acesse no browser:

http://127.0.0.1:8000/api

Rota inicial.

http://127.0.0.1:8000/docs Documentação interativa (Swagger UI).

http://127.0.0.1:8000/redoc Documentação alternativa (ReDoc).

Desafio: API de To-Do List

Você pode ampliar este exemplo para criar um CRUD (Create, Read, Update, Delete) de tarefas:

POST /tarefas cria tarefa.

GET /tarefas lista tarefas.

PUT /tarefas/{id} atualiza tarefa.

DELETE /tarefas/{id} remove tarefa.

Essa base será extremamente útil para aplicações reais.

Considerações finais

O FastAPI combina velocidade, praticidade e robustez, sendo ideal para desenvolvedores que querem criar APIs modernas sem complicação.

Referências

https://fastapi.tiangolo.com

Feito!

Programação assíncrona no Python

No mundo real, um restaurante com apenas um cozinheiro pode atender vários clientes ao mesmo tempo: enquanto um prato assa no forno, o cozinheiro prepara outro. Isso é trabalho assíncrono.

No Python, a programação assíncrona nos permite executar múltiplas tarefas em paralelo (ou melhor, quase paralelo) sem precisar esperar que cada uma termine para começar a próxima — ideal para chamadas de API, consultas a banco de dados e processamento de arquivos.

O que é programação assíncrona?

Em um programa tradicional (síncrono), cada instrução só começa depois que a anterior termina.

Na programação assíncrona:

Algumas operações podem “esperar” (ex.: aguardar resposta de uma API).

Enquanto esperam, o Python pode executar outras tarefas.

Isso reduz tempo ocioso e aumenta a eficiência, principalmente em aplicações que fazem muitas operações de I/O.

O módulo asyncio

O asyncio é a biblioteca nativa do Python para lidar com programação assíncrona.

Com ele, você:

Declara funções assíncronas usando async def.

Aguarda resultados com await.

Executa múltiplas funções com asyncio.gather().

Criando um projeto prático

Neste exemplo, vamos simular o download de páginas web usando aiohttp para trabalhar de forma assíncrona.

Criar e ativar o ambiente virtual

python3 -m venv .venv

No Linux/macOS: source .venv/bin/activate

No Windows: .venv\Scripts\activate

Instalar dependências

pip install aiohttp

Código exemplo: Download assíncrono

Entendendo o código

async def : cria uma função assíncrona.

await : pausa a função até que o resultado esteja pronto, sem travar o resto do programa.

asyncio.gather() : executa várias tarefas ao mesmo tempo.

aiohttp : biblioteca otimizada para requisições HTTP assíncronas.

Comparando com o código síncrono

Se fizéssemos as requisições uma de cada vez, o tempo total seria a soma de todos os tempos individuais.

No modo assíncrono, todas começam juntas, reduzindo drasticamente o tempo de espera.

Quando usar programação assíncrona?

A programação assíncrona é especialmente útil quando seu código precisa:

• Fazer várias requisições HTTP.
• Ler ou gravar muitos arquivos.
• Processar grandes volumes de dados que dependem de I/O.

Para cálculos pesados (CPU-bound), a programação assíncrona não é a melhor opção — nesse caso, usar múltiplos processos (multiprocessing) ou threads pode ser mais eficiente.

Considerações finais

Com o asyncio, conseguimos transformar tarefas demoradas em operações rápidas e eficientes, aproveitando melhor o tempo de execução do programa.

Feito!

Criando e gerenciando ambientes virtuais com venv e pip-tools no Python

Imagine que você está desenvolvendo dois projetos diferentes em Python:

Um utiliza a biblioteca Django na versão 3.2.

Outro exige Django na versão 5.0.

Se você instalar ambas as versões diretamente no seu sistema, haverá conflitos e um dos projetos inevitavelmente deixará de funcionar. É aqui que entra o conceito de ambiente virtual.

O que é um ambiente virtual e por que usá-lo?

Um ambiente virtual no Python é como um “espaço isolado” onde você instala bibliotecas apenas para um determinado projeto, sem interferir no restante do sistema ou em outros projetos.

Essa prática traz benefícios claros:

• Isolamento:

cada projeto tem suas próprias dependências e versões.

• Reprodutibilidade:

você consegue recriar exatamente o mesmo ambiente em outra máquina.

• Organização:

evita instalar bibliotecas desnecessárias no Python global.

Em poucas palavras: o venv protege seu projeto de conflitos e garante consistência no desenvolvimento.

Criando um ambiente virtual com venv

O Python já vem com o módulo venv embutido, então você não precisa instalar nada para começar.

1. Abra o terminal no diretório do seu projeto.

2. Execute: python3 -m venv .venv

Aqui:

python3 -m venv Cria o ambiente virtual.

.venv é o nome da pasta que conterá o ambiente (você pode escolher outro nome).

Ativando o ambiente virtual

A ativação muda o terminal para usar o Python e as bibliotecas daquele ambiente.

Linux / macOS:

source .venv/bin/activate

Windows:

.venv\Scripts\activate

Ao ativar, você verá algo assim no terminal:

(.venv) $

Isso indica que o ambiente virtual está ativo.

Instalando pacotes

Com o ambiente ativo, instale pacotes normalmente:

pip install requests

Esses pacotes ficam armazenados dentro da pasta .venv, sem afetar o restante do sistema.

Gerenciando dependências com pip-tools

O pip-tools ajuda a manter um controle organizado das bibliotecas que seu projeto usa. Ele separa:

O que você pediu para instalar.

As dependências que foram instaladas automaticamente.

1. Instale o pip-tools:

pip install pip-tools

2. Crie um arquivo requirements.in:

requests
pandas

3. Compile para requirem ents.txt:

pip-compile

O requirements.txt gerado terá as versões exatas:

pandas==2.1.0
requests==2.31.0

4. Instale exatamente essas versões:

pip install -r requirements.txt

Para sair do ambiente virtual venv, execute: deactivate

Exportando dependências

Se quiser compartilhar seu projeto, basta enviar:

O código-fonte e o arquivo requirements.txt ou melhor o link do repositório do projeto de alguma das plataformas GitHub, Bitbucket, GitLab ou Azure DevOps

Em outra máquina, basta:

python3 -m venv .venv source .venv/bin/activate

OU no Windows

.venv\Scripts\activate

pip install -r requirements.txt

Pronto: ambiente recriado exatamente como no seu computador.

Considerações finais:

O uso de ambientes virtuais não é apenas uma boa prática: é fundamental para qualquer desenvolvedor Python que queira evitar problemas e manter seus projetos organizados.

O venv garante isolamento e o pip-tools ajuda a manter suas dependências claras e previsíveis.

Feito!