Como rodar Node.js e Python em Docker na VPS: guia prático

Atualize o sistema e instale dependências:

sudo apt update
sudo apt install -y ca-certificates curl gnupg lsb-release

Essas dependências são pré-requisito pra adicionar o repositório com chave GPG verificada — não pulem essa etapa, senão apt recusa o repo.

Adicione a chave GPG oficial do Docker:

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

Configure o repositório e instale Docker Engine + Compose plugin:

echo "deb [arch=$(dpkg --print-architecture) \
  signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io \
  docker-buildx-plugin docker-compose-plugin

Adicione seu usuário ao grupo docker pra não precisar de sudo:

sudo usermod -aG docker $USER
newgrp docker
docker run --rm hello-world

O hello-world confirma que o daemon está rodando e seu usuário tem permissão. Se aparecer “Hello from Docker!”, está tudo certo.

No diretório raiz do seu projeto Node, crie o arquivo Dockerfile:

# Stage 1: build
FROM node:22-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .

# Stage 2: runtime
FROM node:22-alpine
WORKDIR /app
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodeapp -u 1001
COPY --from=builder --chown=nodeapp:nodejs /app /app
USER nodeapp
EXPOSE 3000
CMD ["node", "server.js"]

A imagem node:22-alpine pesa ~45 MB contra ~380 MB da node:22. O usuário não-root (nodeapp) é defense-in-depth — se a aplicação for comprometida, o atacante não tem root dentro do contêiner.

Crie um .dockerignore pra reduzir contexto de build:

node_modules
npm-debug.log
.git
.env
.env.*
dist
coverage
*.md

Sem isso, o Docker copia node_modules local (que pode ter 500 MB+) pra dentro do contexto, deixando o build lento e a imagem inchada.

Crie o Dockerfile no diretório do projeto Python:

FROM python:3.12-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt

FROM python:3.12-slim
WORKDIR /app
RUN useradd -m -u 1001 pyapp
COPY --from=builder /root/.local /home/pyapp/.local
COPY --chown=pyapp:pyapp . .
USER pyapp
ENV PATH=/home/pyapp/.local/bin:$PATH
ENV PYTHONUNBUFFERED=1
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

A flag PYTHONUNBUFFERED=1 força stdout/stderr a saírem sem buffer — sem isso, logs ficam presos em memória e só aparecem quando o processo morre, o que dificulta debug em produção.

Na raiz do diretório que contém ambas as aplicações, crie docker-compose.yml:

services:
  api-node:
    build: ./node-app
    container_name: api-node
    restart: unless-stopped
    networks:
      - backend
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://app:senha@db:5432/appdb
    depends_on:
      - db

  api-python:
    build: ./python-app
    container_name: api-python
    restart: unless-stopped
    networks:
      - backend
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://app:senha@db:5432/appdb
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    container_name: postgres-db
    restart: unless-stopped
    networks:
      - backend
    environment:
      - POSTGRES_USER=app
      - POSTGRES_PASSWORD=senha
      - POSTGRES_DB=appdb
    volumes:
      - postgres-data:/var/lib/postgresql/data

networks:
  backend:
    driver: bridge

volumes:
  postgres-data:

As duas aplicações compartilham a rede backend e resolvem o banco pelo nome db (DNS interno do Docker). Os volumes nomeados persistem dados de banco entre docker compose down e up.

Suba o stack inteiro:

docker compose up -d --build
docker compose ps
docker compose logs -f api-node

A flag -d roda em background, --build reconstrói imagens se os Dockerfiles mudaram. logs -f segue o output em tempo real — Ctrl+C sai do follow sem parar o contêiner.

Teste os endpoints HTTP da VPS:

curl -i http://localhost:3000/health
curl -i http://localhost:8000/health

Cada um deve retornar HTTP/1.1 200 OK com payload da sua aplicação. Se retornar Connection refused, o contêiner não está escutando na porta esperada — confira docker compose logs <serviço>.

Valide que tudo sobe sozinho após reboot:

sudo reboot

Após reconectar via SSH (espere 30-60s), rode docker compose ps. Os contêineres devem estar Up por causa do restart: unless-stopped. Se não, o serviço docker.service pode não estar habilitado no boot — corrija com sudo systemctl enable docker.