10M tokens equivale a aproximadamente:
Mas atenção: latência cresce não-linearmente com contexto. Em testes internos no laboratório:
Contexto Latência média (p95)
4K 820 ms
32K 1.4 s
128K 4.8 s
512K 18 s
2M 76 s
Para a maioria dos casos, RAG bem feito com 32K de contexto ainda bate carregar 2M de tokens “para garantir”. O ganho é em casos específicos: análise de codebase inteira, processamento de documentos legais longos, debugging de logs corporativos.
O grande salto não é “aceita imagem” — isso o GPT-4 já fazia. É que o modelo raciocina nativamente sobre o conteúdo visual e textual no mesmo passe. Em prática:
Output tokens caíram 60%. Input tokens caíram só 25%. Para workloads que são input-heavy (RAG, busca semântica), o ganho é menor do que parece. Para output-heavy (geração de código, escrita longa), o ganho é real.
A regra prática que estamos usando: se 70%+ do custo do seu pipeline está em output tokens, migre para GPT-5 hoje. Se está em input, espere o GPT-5 Mini sair em julho.
GPT-5 é evolução, não revolução. Mas a economia de output + multimodal nativo justifica a migração para a maioria dos pipelines do laboratório. Migramos 3 dos nossos 7 pipelines até agora — os outros 4 ficam no GPT-4o ou Claude até a próxima geração.
]]># ===== Stage 1: build =====
FROM python:3.12-slim AS builder
WORKDIR /build
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt
# ===== Stage 2: runtime =====
FROM python:3.12-slim
WORKDIR /app
# Non-root user
RUN useradd -m -u 1000 -s /bin/bash app
# Copy installed deps from builder
COPY --from=builder /root/.local /home/app/.local
ENV PATH=/home/app/.local/bin:$PATH
# Copy app code
COPY --chown=app:app . .
USER app
EXPOSE 8000
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD curl -f http://localhost:8000/health || exit 1
CMD ["gunicorn", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", \
"--bind", "0.0.0.0:8000", "--access-logfile", "-", \
"main:app"]
Resultado: imagem final de ~92MB.
O truque do multi-stage é instalar dependências em um stage descartável (builder), e copiar apenas o resultado para o stage final. Sem isso, sua imagem carrega gcc, headers do Python, cache do pip — tudo desnecessário em runtime.
| Approach | Tamanho final |
|---|---|
python:3.12 + pip install |
980 MB |
python:3.12-slim + pip install |
280 MB |
python:3.12-slim + multi-stage |
92 MB |
python:3.12-alpine + multi-stage |
68 MB ⚠️ |
Alpine é menor, mas dá problemas com libs que dependem de glibc (numpy, scipy, pandas). Para APIs simples, vale. Para data-science, fique no slim.
gunicorn + uvicorn workers?FastAPI é ASGI (async). Uvicorn é o servidor ASGI de referência. Mas em produção:
UvicornWorker: gunicorn gerencia, uvicorn executa o async.A combinação dá robustez de process manager + performance async. É o padrão recomendado pela própria documentação do FastAPI.
@app.get("/health")
async def health():
# 1. Processo está respondendo? Sim (a função executou)
# 2. Conexão com banco está ok?
try:
await db.execute("SELECT 1")
except Exception:
return Response(status_code=503)
return {"status": "ok"}
Esse /health é usado tanto pelo HEALTHCHECK do Dockerfile quanto pelo liveness/readiness do Kubernetes. Não retorne sempre 200: o healthcheck precisa falhar se o banco cair, senão o orchestrator nunca remove o pod doente do load balancer.
import logging, json
class JSONFormatter(logging.Formatter):
def format(self, record):
return json.dumps({
"ts": self.formatTime(record),
"level": record.levelname,
"msg": record.getMessage(),
"module": record.module,
})
handler = logging.StreamHandler()
handler.setFormatter(JSONFormatter())
logging.basicConfig(level=logging.INFO, handlers=[handler])
Logs JSON são indispensáveis para qualquer ferramenta de observability (CloudWatch, Datadog, Grafana Loki) extrair campos.
from contextlib import asynccontextmanager
@asynccontextmanager
async def lifespan(app):
# startup
yield
# shutdown: close connections, flush logs
await db.close()
app = FastAPI(lifespan=lifespan)
Sem isso, ao escalar para baixo, conexões DB ficam abertas no servidor, requests em vôo são abortadas.
Imagem final pronta para:
E roda em qualquer plataforma sem mudança.
]]>Chegue cedo. Antes das 7h, antes de pensar em café. O mercado externo do antigo Tsukiji ainda funciona, e é ali que você prova um sushi de atum que reconfigura sua escala interna de qualidade. Aposte em Sushi Dai ou Daiwa Sushi — se a fila assustar, ande mais uns 200 metros: tem sempre um balcão menor com peixe igualmente fresco.
Não existe “o melhor ramen de Tóquio”. Existe o ramen que você prova nessa noite específica, depois de 14 km de caminhada e duas garrafas de chu-hi. Para começar, Fuunji (tsukemen) e Menya Musashi (tonkotsu). Vá com fome e roupa que não te incomode no calor do vapor.
Pegue um trem para Yanaka. Caminhe sem destino. Você vai encontrar:
O segredo de Tóquio não está na lista de restaurantes premiados. Está em virar uma esquina e descobrir uma soba house de quatro lugares que existe há 70 anos.
Tóquio é a capital silenciosa do café de especialidade. Glitch Coffee (Kanda), Koffee Mameya (Omotesando) e Bear Pond Espresso (Shimokitazawa) são paradas obrigatórias. Reserve o dia: cada um é uma experiência longa.
O bairro de Shinjuku conhecido como Golden Gai concentra ~200 bares em vielas estreitas. Muitos cabem seis pessoas. Pague o cover, peça uma highball, converse com o dono. É o adeus que Tóquio merece.
Gastos médios por dia (jan/2026):
- Refeições: ¥ 4.500 – 8.000
- Transporte: ¥ 800 – 1.200
- Atrações: ¥ 1.000 – 3.000
Total: R$ 350 – 600/dia
Não é hype. É decisão técnica.
Memória sem garbage collector. Lambda precisa de cold start de < 100ms — GC pause de Go (mesmo do Go 1.21+) pode estourar isso em workloads sensíveis.
Concorrência sem data races em compile-time. O borrow checker do Rust impede que você compile código com race condition. Em sistemas distribuídos críticos (S3 servindo milhões de req/s), isso elimina uma classe inteira de bugs.
Performance C/C++, segurança Java. Sem segfault, sem buffer overflow, sem dangling pointer — e com o mesmo overhead de runtime que C.
| Aspecto | Go | Rust |
|---|---|---|
| Tempo para um eng. virar produtivo | 2 semanas | 3-6 meses |
| Linhas de código (mesma funcionalidade) | 1.0x | 1.3x |
| Tempo de compilação | 5s | 90s |
| Bugs em produção (memória/concorrência) | médio | quase zero |
Rust é mais caro de escrever. A AWS aceita esse custo porque o ganho operacional (menos pages às 3 da manhã) compensa em escala.
Se você tem 5 engineers e está escrevendo uma API CRUD, Rust é a escolha errada. A produtividade cai mais do que o ganho de performance compensa.
Se você está escrevendo:
…Rust passa a fazer sentido econômico.
Estamos migrando um único serviço para Rust: o API gateway interno que processa autenticação de todos os pipelines de ML. Volume: ~50k req/s no pico. Razão: o serviço atual em Node consome 8 GB de RAM em pico e o cold start em deploy custa 2-3 min de degradação.
Resultado parcial (semana 3 de 12):
Rust não é “o novo Go”. É a linguagem certa para sistemas onde overhead e correctness importam mais do que velocidade de desenvolvimento. Para o resto, Python/Go/TypeScript seguem sendo as escolhas certas.
A AWS migra porque a conta fecha. Para a maioria dos times, ainda não fecha.
]]>Depois de seis meses morando entre Lagoa, Centro e Campeche, montamos uma lista honesta dos seis cafés que viraram nossa base de operações.
O clássico. Wi-fi rápido, mesa grande comunal e um cold brew que segura uma manhã inteira. Pode ficar lotado no fim de semana, mas das 9h às 11h em dia útil, é praticamente um co-working com bolo de cenoura.
Mais tradicional, com menos tomadas, mas com o melhor pão de queijo da ilha. Ideal para reuniões curtas de 1-2 horas.
Quem é fissurado em coado vai amar. Trabalham com grão de origem mapeada e tem um barista que sabe nome de fazenda da Mantiqueira de cor.
Não é exatamente um café — é um café-bar dentro do Mercado. Mas tem mesa, tomada e um cortado bem feito. Funciona até as 18h.
Próximo da UFSC, lotado de estudantes, mas com pelo menos quatro mesas reservadas para quem leva notebook. Atmosfera de biblioteca-com-cheiro-de-grão.
O mais escondido. Cardápio menor, mas o espresso tem corpo de cinema. Vai cedo: ele fecha às 14h.
]]>Critério principal: tomada acessível ao lado da mesa. Café bom sem energia não dura uma standup matinal.
Se você tem menos de 4 microserviços ou não tem time dedicado de plataforma, comece em serverless. Migre para K8s só quando a conta da serverless ficar maior que o custo de manter um cluster.
Esse é o ponto onde a maioria dos times decide errado — começa em K8s “porque é o futuro”, passa 6 meses configurando ingress, secrets, monitoring, helm, e nunca chega a entregar o produto.
Lambda Cloud Run K8s (EKS)
1 req/s $0.20/mês $0.50/mês $73/mês (cluster)
100 req/s $20/mês $35/mês $73/mês
10k req/s $2000/mês $1200/mês $400/mês (3 nodes)
100k req/s $20k/mês $8k/mês $1200/mês
O ponto de inflexão fica entre 1k e 5k req/s dependendo do payload. Abaixo disso, serverless ganha. Acima, K8s ganha.
| Workload | Tolera cold start? |
|---|---|
| Webhook receiver | ✅ sim, raro |
| API pública pra usuário | ⚠️ depende (300ms tolerável, 3s não) |
| Processamento batch | ✅ totalmente |
| Inferência de IA em tempo real | ❌ K8s/SageMaker |
| Conexão WebSocket persistente | ❌ K8s |
Serverless não mantém estado entre invocações. Se você precisa:
K8s é o caminho. Lambda + ElastiCache + DynamoDB resolve, mas com mais glue code.
Setup mínimo para K8s saudável:
- 1 SRE/Platform engineer dedicado
- CI/CD configurado (ArgoCD ou Flux)
- Observability stack (Prometheus + Grafana + Loki)
- Política de RBAC + secrets management
- Backup/disaster recovery do etcd
Setup mínimo para Lambda saudável:
- AWS SAM ou Serverless Framework
- CloudWatch alarms básicos
Tempo de setup inicial: 2-4 semanas K8s vs 1 dia Lambda.
Serverless = lock-in alto. AWS Lambda + API Gateway + DynamoDB é difícil migrar pra GCP.
K8s = portável (em teoria). Na prática, manifests rodam em qualquer cluster, mas operadores específicos (AWS Load Balancer Controller, EFS CSI driver, etc.) prendem ao cloud.
Escolha: Lambda + SQS. Cold start de 800ms é irrelevante quando o job inteiro leva 2 minutos. Custo cai pra ~$3/mês fora dos picos.
Escolha: EKS + nodes com GPU. Modelos carregados em memória, sem cold start.
Escolha: Cloud Run. Auto-scaling até zero quando ninguém está chamando, paga só pelo que usa.
Escolha: Cloud Run (free tier cobre tudo). K8s seria caro pra esse volume.
Não existe escolha “futura-prova”. Existe escolha certa para o estágio atual do produto e tamanho do time. Comece simples, migre quando a conta ou a complexidade da serverless exceder o custo de operar um cluster.
]]>Esse roteiro de 7 dias tenta fugir disso.
Faça a turistada inicial, mas antes das 10h. Praça do Comércio, Rua Augusta, Chiado. Almoce na Cantinho do Avillez (reservar) ou no Time Out Market (sem reserva).
Alfama de manhã é Disneylândia. De noite, depois das 21h, vira o que sempre foi: bairro de gente que mora ali, fado nas tascas e luz de poste no calçamento. Vá ao A Baiuca e peça o vinho da casa.
Sim. Vá ao Mosteiro dos Jerónimos, à Torre de Belém, ao MAAT. E coma o pastel na Manteigaria mesmo (no Chiado) — tem gente que prefere. Diferença é mínima e a fila é zero.
Manhã na LX Factory (bookshop Ler Devagar vale a viagem). Almoço/tarde no Time Out Market.
Pegue um Uber, não o trem. Saia das 8h. Faça Quinta da Regaleira primeiro (poço inverso!), depois Palácio da Pena. Volte tomando vinho na Quinta da Cevada.
Praia. Marisco. Final de viagem. Setúbal tem o melhor choco frito do planeta. Cascais é mais fácil de chegar.
Custo médio total (7 dias, casal):
- Hospedagem (Alfama, Airbnb): R$ 4.500
- Comida + bebida: R$ 4.000
- Transporte: R$ 1.200
Total: R$ 9.700
Modelo: Llama-3.2-3B quantizado para 4-bit Tarefa: classificar tickets de suporte em 12 categorias Volume: ~80k requests/dia
Trade-off claro: 5% menos preciso, 30x mais barato, 7x mais rápido. Para classificação de ticket onde o humano revisa de qualquer jeito, vale demais.
Modelo: all-MiniLM-L6-v2 (22 MB após quantização)
Tarefa: busca semântica em um catálogo de 5k itens
Onde roda: direto no navegador do usuário, via WebAssembly
IntersectionObserver na busca, não na home.Modelo: Llama-3.2-1B quantizado em 4-bit (700 MB) Tarefa: assistant para o sistema de monitoramento de sensores do lab Onde roda: Raspberry Pi 5 8GB conectado direto aos sensores, sem internet
Em 11 meses se paga. Útil para cenários air-gapped (laboratórios sensíveis, ambientes sem internet).
Se respondeu sim em 3+, faça um POC de 1 semana.
Edge AI é tecnologia real e útil — mas apenas em casos específicos onde o trade-off de precisão por latência/custo/privacidade compensa. Para 80% dos workloads, chamar OpenAI ainda é a escolha certa.
A pergunta correta não é “podemos colocar IA na borda?” mas “esse caso específico paga o custo operacional de manter modelo na borda?”
]]>Em Bolonha, pasta seca é coisa de gente apressada. A pasta de verdade é fresca, feita ovo + farinha 00, esticada à mão ou com cilindro manual. As sfogline (mulheres que fazem pasta em vitrines de rua) são uma instituição local — você passa e vê tagliatelle nascendo na sua frente.
Esqueça espaguete à bolonhesa. Em Bolonha, o ragù é servido com tagliatelle (massa larga, que carrega o molho) ou em lasanha verde. Os ingredientes não incluem alho. Incluem:
Quem coloca alho em ragù em Bolonha é deportado simbolicamente.
O outro prato-bandeira. Tortellini minúsculos recheados de mortadela, lombo, parmigiano e noz-moscada, servidos em um caldo de carne claro e perfeito. É comida de inverno, comida de domingo, comida de avó.
A pizza é napolitana. Bolonha tem piadina — pão fino, achatado, recheado com mortadela e squacquerone. Não é pizza, mas resolve.
Tip prático:
Reserve sempre antes das 13h ou 20h.
Bolonha almoça no horário, jantar começa 19h30.
package main
import (
"net/http"
"github.com/go-chi/chi/v5"
)
func main() {
r := chi.NewRouter()
r.Get("/users/{id}", getUser)
http.ListenAndServe(":8080", r)
}
func getUser(w http.ResponseWriter, r *http.Request) {
id := chi.URLParam(r, "id")
// ... lógica de fetch user
w.Write([]byte(`{"id":"` + id + `","name":"Maria"}`))
}
Funcional, mas cego. Vamos instrumentar.
slog (10 min)A stdlib Go ganhou log/slog em 1.21 — não precisa mais de Zap, Logrus, etc.
import (
"log/slog"
"os"
)
func init() {
logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
Level: slog.LevelInfo,
}))
slog.SetDefault(logger)
}
func getUser(w http.ResponseWriter, r *http.Request) {
id := chi.URLParam(r, "id")
slog.Info("user fetch",
"user_id", id,
"method", r.Method,
"path", r.URL.Path,
)
// ...
}
Output:
{"time":"2026-05-02T10:00:00Z","level":"INFO","msg":"user fetch","user_id":"42","method":"GET","path":"/users/42"}
Já consumível por CloudWatch, Loki, Datadog sem parser custom.
import "github.com/prometheus/client_golang/prometheus/promhttp"
import "github.com/prometheus/client_golang/prometheus"
var (
requestsTotal = prometheus.NewCounterVec(
prometheus.CounterOpts{
Name: "http_requests_total",
Help: "Total de requests HTTP",
},
[]string{"method", "endpoint", "status"},
)
requestDuration = prometheus.NewHistogramVec(
prometheus.HistogramOpts{
Name: "http_request_duration_seconds",
Buckets: []float64{0.01, 0.05, 0.1, 0.3, 1, 3, 10},
},
[]string{"endpoint"},
)
)
func init() {
prometheus.MustRegister(requestsTotal, requestDuration)
}
// Middleware
func metricsMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
ww := &statusWriter{ResponseWriter: w, status: 200}
next.ServeHTTP(ww, r)
requestsTotal.WithLabelValues(r.Method, r.URL.Path, fmt.Sprintf("%d", ww.status)).Inc()
requestDuration.WithLabelValues(r.URL.Path).Observe(time.Since(start).Seconds())
})
}
// main()
r.Use(metricsMiddleware)
r.Handle("/metrics", promhttp.Handler())
Agora curl :8080/metrics retorna formato Prometheus pronto pra scrape.
import (
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
"go.opentelemetry.io/otel/sdk/resource"
semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
)
func initTracer(ctx context.Context) (*sdktrace.TracerProvider, error) {
exporter, err := otlptracegrpc.New(ctx,
otlptracegrpc.WithEndpoint("localhost:4317"),
otlptracegrpc.WithInsecure(),
)
if err != nil { return nil, err }
tp := sdktrace.NewTracerProvider(
sdktrace.WithBatcher(exporter),
sdktrace.WithResource(resource.NewWithAttributes(
semconv.SchemaURL,
semconv.ServiceName("users-api"),
)),
)
otel.SetTracerProvider(tp)
return tp, nil
}
func main() {
ctx := context.Background()
tp, _ := initTracer(ctx)
defer tp.Shutdown(ctx)
r := chi.NewRouter()
r.Use(metricsMiddleware)
r.Method("GET", "/users/{id}",
otelhttp.NewHandler(http.HandlerFunc(getUser), "users.get"),
)
http.ListenAndServe(":8080", r)
}
func getUser(w http.ResponseWriter, r *http.Request) {
ctx, span := otel.Tracer("users").Start(r.Context(), "fetch_from_db")
defer span.End()
// ... fetch user, e cada query passa ctx pra trazer no trace
}
Spans aparecem em qualquer backend OTel: Jaeger, Tempo, Datadog APM, Honeycomb.
services:
prometheus:
image: prom/prometheus
ports: ["9090:9090"]
volumes: ["./prometheus.yml:/etc/prometheus/prometheus.yml"]
grafana:
image: grafana/grafana
ports: ["3000:3000"]
tempo:
image: grafana/tempo
command: ["-config.file=/etc/tempo.yaml"]
ports: ["4317:4317"]
Em 1 hora você tem:
Observability não é luxo. É o que te avisa antes do usuário reclamar. Em Go, com a stack acima, o custo de instrumentar é ~200 linhas pra um serviço médio — e o ganho é noites dormindo durante incidentes.
]]>