Escalando APIs REST: Benchmark de Latência e Throughput

Introdução

Em ambientes de marketing digital, a velocidade de resposta de um serviço web pode ser a diferença entre converter um visitante ou perdê‑lo para a concorrência. Cada milissegundo conta quando se trata de chamadas de API que alimentam landing pages, sistemas de recomendação ou plataformas de automação de campanha.

Este post explora como identificar gargalos, aplicar técnicas de otimização e validar resultados com benchmarks reais. Vamos analisar métricas como latência média, pico de throughput, uso de CPU e consumo de memória, além de mostrar como reproduzir os testes em sua própria infraestrutura.

Desenvolvimento

1. Arquitetura de referência

Para fins de demonstração, utilizaremos uma API REST simples escrita em Python com o framework FastAPI. A aplicação será servida por Uvicorn em modo ASGI, atrás de um balanceador NGINX que faz terminção TLS e distribui requisições entre múltiplas instâncias via Round‑Robin.

A pilha completa fica assim:

2. Métricas essenciais

Essas métricas serão coletadas com o wrk (gerador de carga) e visualizadas no Grafana.

3. Estratégias de otimização

3.1. Uso de conexão keep‑alive

Desativar o fechamento da conexão TCP reduz o overhead de handshake. No NGINX, basta habilitar:

nginx keepalive_timeout 65; keepalive_requests 1000;

3.2. Compactação de resposta

Ativar gzip diminui o tamanho do payload, especialmente útil para respostas JSON.

nginx gzip on; gzip_types application/json;

3.3. Cache de consultas frequentes

Para endpoints que retornam dados estáticos (ex.: catálogos de produtos), armazenar o resultado no Redis elimina chamadas ao banco.

python import aioredis

redis = await aioredis.create_redis_pool('redis://redis:6379')

@router.get('/catalog') async def get_catalog(): cached = await redis.get('catalog') if cached: return JSONResponse(content=json.loads(cached)) # consulta ao DB (simulada) data = await fetch_catalog_from_db() await redis.set('catalog', json.dumps(data), expire=60) return JSONResponse(content=data)

3.4. Índices no banco de dados

Um SELECT mal indexado pode elevar a latência de 5 ms para mais de 200 ms. Considere o exemplo abaixo usando PostgreSQL:

sql -- antes: varredura completa da tabela EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 12345;

-- depois: criação de índice B‑Tree CREATE INDEX idx_orders_customer ON orders(customer_id);

3.5. Parallelismo de workers

O Uvicorn pode ser escalado com múltiplos workers. A regra geral: workers = 2 * núm_cores + 1.

bash uvicorn app.main:app --host 0.0.0.0 --port 8000
--workers 5 --log-level info

Exemplos Práticos

1. Deploy com Docker‑Compose

yaml version: '3.8' services: api: image: tiangolo/uvicorn-gunicorn-fastapi:python3.11 container_name: fastapi environment: - MODULE_NAME=app.main - VARIABLE_NAME=app ports: - "8000:80" depends_on: - redis nginx: image: nginx:stable-alpine ports: - "443:443" volumes: - ./nginx.conf:/etc/nginx/nginx.conf:ro depends_on: - api redis: image: redis:7-alpine ports: - "6379:6379"

Passo a passo

1. Salve o docker-compose.yml e o nginx.conf (exemplo acima) no mesmo diretório.
2. Execute docker compose up -d.
3. A API ficará disponível em https://localhost/api/v1/....

2. Gerando carga com wrk

bash

30 segundos, 8 conexões, 200 threads, 1000 RPS

wrk -t8 -c200 -d30s -R1000 https://localhost/api/v1/catalog

A saída típica inclui Latency, Requests/sec e Transfer/sec. Salve o relatório em benchmark.txt para análise posterior.

3. Comparativo de resultados (antes vs depois)

Observação: O salto de 124 ms para 28 ms representa +5.6x de melhoria na experiência do usuário.

4. Visualizando no Grafana

Importe o dashboard abaixo (JSON) no Grafana para acompanhar em tempo real:

{ "dashboard": { "title": "API Performance", "panels": [ {"type":"graph","title":"Latência média","targets":[{"expr":"histogram_quantile(0.5, sum(rate(http_request_duration_seconds_bucket[1m])) by (le)"}]}, {"type":"graph","title":"Throughput","targets":[{"expr":"sum(rate(http_requests_total[1m]))"}]}, {"type":"graph","title":"Uso de CPU","targets":[{"expr":"avg(rate(process_cpu_seconds_total[1m]))"}]} ] } }

Conclusão

A otimização de performance e escalabilidade não é um esforço pontual, mas um ciclo contínuo de medição, ajuste e validação. Ao aplicar as práticas descritas — keep‑alive, compressão, cache, índices e workers — você pode reduzir a latência de centenas de milissegundos para poucos, ao mesmo tempo em que aumenta o throughput em múltiplas ordens de magnitude.

Próximos passos recomendados:

1. Automatizar testes de carga em pipelines CI/CD (ex.: GitHub Actions + k6).
2. Implementar circuit breaker para proteger serviços downstream.
3. Adotar observabilidade avançada (OpenTelemetry) para rastrear latência por chamada.
4. Explorar edge computing com CDN para servir conteúdo estático ainda mais próximo do usuário.

Com esses pilares, sua equipe de marketing digital terá a base necessária para oferecer experiências ultra‑rápidas, melhorar a taxa de conversão e sustentar o crescimento de tráfego sem interrupções.