Guia completo de deploy com Docker e Docker Compose

Como containerizar aplicações e orquestrar múltiplos serviços de forma simples e escalável

O que é Docker?

Docker é uma plataforma que permite empacotar sua aplicação e todas as suas dependências em containers. Com ele, conseguimos criar ambientes portáveis, previsíveis e fáceis de replicar em qualquer lugar, seja na máquina do dev, no servidor ou na nuvem.

Pensa no container como uma mini máquina virtual superleve e isolada, rodando apenas o necessário para sua aplicação funcionar.

Por que usar Docker?

Elimina o "na minha máquina funciona"

Padroniza ambientes de desenvolvimento, staging e produção

Facilita o CI/CD

Escala horizontalmente de forma controlada

Dockerizando sua aplicação

Vamos usar um exemplo básico de uma API Node.js + Express.

Pode usar a sua API que você desenvolveu em Node.js com Express

1. Estrutura de diretórios

/meu-projeto
│
├── Dockerfile
├── docker-compose.yml
├── package.json
└── src/
    └── index.js

2. Dockerfile

# Usa uma imagem base
FROM node:18-alpine

# Cria um diretório de trabalho
WORKDIR /app

# Copia os arquivos
COPY package*.json ./
RUN npm install

COPY . .

# Expõe a porta da aplicação
EXPOSE 3000

# Comando para iniciar o app
CMD ["node", "src/index.js"]

3. Docker Compose com MongoDB

version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    depends_on:
      - mongo
    environment:
      - MONGO_URL=mongodb://mongo:27017/meubanco

  mongo:
    image: mongo:6
    container_name: mongodb
    ports:
      - "27017:27017"
    volumes:
      - mongo-data:/data/db
  
  mongo-express:
    image: mongo-express
    container_name: mongo-express
    ports:
      - "8081:8081"
    environment:
      ME_CONFIG_MONGODB_SERVER: mongo
      ME_CONFIG_BASICAUTH_USERNAME: admin
      ME_CONFIG_BASICAUTH_PASSWORD: admin

volumes:
  mongo-data:

4. Subindo os serviços

No terminal, dentro do diretório do projeto:

docker-compose up -d --build

Pronto! Sua API e o Mongo estão executando em containers separados, mas se comunicando em rede.

Testando

Acesse: http://localhost:3000 no Postman ou Insonmia para testar os endpoints da sua API REST com Node.js e Express

e http://localhost:8081 para acessar o Mongo Express, que é o cliente do MongoDB

Dicas de produção

• Crie um .dockerignore para ignorar node_modules, .git, etc.
• Use variáveis de ambiente no docker-compose.yml com arquivos .env
• Utilize healthchecks para garantir que os serviços estejam realmente prontos
• Adicione nginx como proxy reverso e certbot para HTTPS
• Faça uso de volumes persistentes para bancos de dados
• Considere usar Docker Swarm ou Kubernetes em ambientes que exigem alta escalabilidade

.dockerignore

node_modules
npm-debug.log
.git
.env
Dockerfile*
docker-compose*

Dockerfile (Produção)

# Etapa de build
FROM node:18-alpine as builder

WORKDIR /app
COPY package*.json ./
RUN npm install --production

COPY . .

# Etapa final
FROM node:18-alpine

WORKDIR /app

# Copia apenas o que foi instalado/built na etapa anterior
COPY --from=builder /app /app

# Define variáveis de ambiente
ENV NODE_ENV=production

EXPOSE 3000
CMD ["node", "src/index.js"]

docker-compose.prod.yml

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "80:3000"
    env_file:
      - .env
    depends_on:
      - mongo
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000"]
      interval: 30s
      timeout: 10s
      retries: 3
    restart: always
    volumes:
      - .:/app
      - /app/node_modules # evita conflito com o host

  mongo:
    image: mongo:6
    container_name: mongodb
    restart: always
    ports:
      - "27017:27017"
    volumes:
      - mongo-data:/data/db
    healthcheck:
      test: ["CMD", "mongosh", "--eval", 
             "db.adminCommand('ping')"]
      interval: 30s
      timeout: 10s
      retries: 5

volumes:
  mongo-data:

.env

MONGO_URL=mongodb://mongo:27017/meubanco
PORT=3000
NODE_ENV=production

Considerações finais

Docker e Docker Compose transformaram a forma como lidamos com deploys. Com uma configuração simples, conseguimos orquestrar múltiplos serviços, versionar ambientes, simular produção localmente e escalar nossas aplicações com segurança.

Quer começar? Pegue um projeto seu e faça o primeiro Dockerfile. Depois adicione um banco com docker-compose. Em pouco tempo, isso torna-se parte do seu workflow natural.

Feito!