Cómo ejecutar Node.js y Python en Docker en VPS: guía práctica

Actualiza el sistema e instala dependencias:

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

Estas dependencias son prerrequisito para añadir el repositorio con clave GPG verificada — no saltes este paso, sino apt rechaza el repo.

Añade la clave GPG oficial de 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

Configura el repositorio e instala Docker Engine + plugin Compose:

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

Añade tu usuario al grupo docker para no necesitar sudo:

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

El hello-world confirma que el daemon está corriendo y tu usuario tiene permiso. Si aparece “Hello from Docker!”, todo está correcto.

En el directorio raíz de tu proyecto Node, crea el archivo 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"]

La imagen node:22-alpine pesa ~45 MB frente a ~380 MB de node:22. El usuario no root (nodeapp) es defense-in-depth — si la aplicación se ve comprometida, el atacante no tiene root dentro del contenedor.

Crea un .dockerignore para reducir el contexto de build:

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

Sin esto, Docker copia el node_modules local (que puede tener 500 MB+) hacia dentro del contexto, dejando el build lento y la imagen inflada.

Crea el Dockerfile en el directorio del proyecto 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"]

La flag PYTHONUNBUFFERED=1 fuerza a stdout/stderr a salir sin buffer — sin esto, los logs quedan atrapados en memoria y solo aparecen cuando el proceso muere, lo que dificulta el debug en producción.

En la raíz del directorio que contiene ambas aplicaciones, crea 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:

Las dos aplicaciones comparten la red backend y resuelven la base de datos por el nombre db (DNS interno de Docker). Los volúmenes nombrados persisten datos de base entre docker compose down y up.

Levanta el stack completo:

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

La flag -d ejecuta en background, --build reconstruye imágenes si los Dockerfiles cambiaron. logs -f sigue el output en tiempo real — Ctrl+C sale del follow sin parar el contenedor.

Testea los endpoints HTTP de la VPS:

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

Cada uno debe retornar HTTP/1.1 200 OK con payload de tu aplicación. Si retorna Connection refused, el contenedor no está escuchando en la puerta esperada — revisa docker compose logs <servicio>.

Valida que todo sube solo tras reboot:

sudo reboot

Tras reconectar vía SSH (espera 30-60s), ejecuta docker compose ps. Los contenedores deben estar Up debido al restart: unless-stopped. Si no, el servicio docker.service puede no estar habilitado en el boot — corrígelo con sudo systemctl enable docker.