Esse é meu primeiro post na plataforma e o primeiro a um bom tempo no geral. É um desafio compartilhar isso porque nunca parece estar bom o bastante, mas diz o ditado: "quem não é visto, não é lembrado".

A API em questão ainda está em desenvolvimento, e o aprendizado desse post só foi possível porque graças a um outro post no LinkedIn, onde uma pessoa se propôs a financiar uma VPS para o projeto.

💡 O Desafio

Há alguns meses, me deparei com um desafio interessante: como fazer deploy da minha primeira API completa em uma VPS de forma profissional, sem complicar demais as coisas?

Desenvolvi um sistema para gerenciar discursantes da igreja usando Node.js + TypeScript + PostgreSQL, mas quando chegou a hora de colocar em produção, me vi diante de uma pergunta: "Como vou orquestrar tudo?"

🏗️ Por que um Monólito?

Bom, eu comecei simples e direto ao ponto. Minha API tem:

Controllers para gerenciar requisições
Services para lógica de negócio
Models para acesso a dados
Validações robustas com Zod
Autenticação JWT completa

A separação de responsabilidades estava clara, mas tudo em um só projeto. Por que quebrar algo que já funcionava bem?

📦 Containerização Eficiente

Optei por usar Docker multi-stage para builds otimizados:

# Stage 1: Builder
FROM node:22-alpine AS builder
RUN npm ci --include=dev
RUN npm run build

# Stage 2: Production  
FROM node:22-alpine AS production
COPY --from=builder /app/dist /app/dist
COPY --from=builder /app/node_modules /app/node_modules

Resultado: Imagem final de apenas ~275MB, sem dependências de desenvolvimento!

🐳 Orquestração com Docker Swarm

E aqui entra o swarm! Como eu queria fazer algo próximo do utilizado no mercado, mas sem aumentar a curva de aprendizado usando ferramentas como K8S, descobri que o Swarm poderia ser uma opção para essa pequena demanda.

Então usei Docker Swarm para orquestrar meus containers (DB, API e Nginx):

services:
  api-production:
    image: speakers-report-api:1.0.0
    deploy:
      replicas: 1
      resources:
        limits:
          cpus: "1.0"
          memory: 2GB
      restart_policy:
        condition: on-failure
        max_attempts: 3

Alguns benefícios que o Docker Compose não poderia oferecer em produção:
✅ Resiliência automática - se a API cair, reinicia sozinha
✅ Escalabilidade horizontal - posso aumentar replicas facilmente
✅ Load balancing nativo do Swarm
✅ Rolling updates sem downtime

Dessa forma comecei a me expor nesse mundo DevOps, de maneira amadora, mas achei interessante e "fácil", afinal foi só ativar o swarm que é um recurso nativo do Docker.

🌐 Nginx como Reverse Proxy

Para SSL e roteamento, configurei o Nginx como reverse proxy. Aqui apanhei bastante, mas como precisava fazer um redirecionamento de forma mais alinhada às práticas do mercado, optei por encarar o desafio e francamente, preciso estudar mais essa parte.

location /api/ {
  proxy_pass http://api-production:3000/api/;
  proxy_set_header Host $host;
  proxy_set_header X-Real-IP $remote_addr;
  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}

Vantagens:
🔐 SSL/TLS com Let's Encrypt já com renovação automática dos certificados
🚀 Headers de segurança customizados
📊 Logs centralizados de acesso
🌐 Redirecionamento HTTP → HTTPS

🗄️ Banco Containerizado com Persistência

O PostgreSQL também foi containerizado com volumes persistentes no swarm:

volumes:
  - speakers-report-pg-data-prod:/var/lib/postgresql/data

Nessa etapa o que me chamou atenção foi a possibilidade de usar as secrets do swarm - uma forma de definir credenciais sem usar variáveis de ambiente, garantindo maior segurança em produção. Acabei usando até mesmo no serviço da API e gostei bastante.

Pontos importantes:
💾 Dados persistem mesmo se o container cair
🔄 Backups facilitados - só copiar o volume
🚀 Deploy independente - posso atualizar a API sem mexer no banco
📈 Monitoramento isolado - métricas específicas do banco
🔑 Secrets do Swarm - ótimo recurso para definir credenciais de forma segura

🎯 Vantagens da Arquitetura Monolítica Containerizada

Escalabilidade Horizontal

Posso rodar múltiplas instâncias da mesma API
Load balancer nativo do Swarm distribui a carga
Zero downtime durante deploys

Separação de Infraestrutura

Cada componente em seu container isolado
Recursos dedicados para cada serviço
Falhas isoladas - se a API cair, o banco continua

Deploy Independente

Atualizo a API sem derrubar o banco
Rollback rápido se algo der errado
Blue-green deployment possível no futuro

🧠 Aprendizados Principais

Comece simples - monólito bem estruturado é melhor que microserviços mal planejados
Containerize tudo - facilita deploy, monitoramento e manutenção
Use orquestração - Docker Swarm é simples e poderoso
Pense em persistência - volumes são essenciais para dados
Reverse proxy é vida - Nginx simplifica muito a configuração

🤔 E você?

Qual arquitetura você está usando em seus projetos?

Já tentou Docker Swarm ou prefere Kubernetes? Como faz deploy das suas APIs em produção?

Compartilha aí nos comentários! 👇

#NodeJS #TypeScript #Docker #DevOps #Backend #API #PostgreSQL #Nginx #DockerSwarm #ArquiteturaDeSoftware

💡 Dica: Às vezes a solução mais simples é a mais elegante. Monólito + containers pode ser o sweet spot para muitos projetos!

🚀 Arquitetura Monolítica Escalável: Do Desenvolvimento Local ao Docker Swarm em Produção