Docker para Principiantes: Desde Tu Primera Imagen hasta el Despliegue en Produccion

Docker cambio la forma en que construimos, distribuimos y ejecutamos software. En lugar de "funciona en mi maquina", Docker garantiza que tu aplicacion se ejecute de la misma manera en todas partes - en tu portatil, en la maquina de un colega, en CI/CD y en produccion. En esta guia, iremos desde cero hasta desplegar una aplicacion real.

Que es Docker?

Docker es una plataforma que empaqueta tu aplicacion y todas sus dependencias en una unidad estandarizada llamada contenedor. Un contenedor es un proceso aislado y ligero que comparte el kernel del sistema operativo anfitrion pero tiene su propio sistema de archivos, red y espacio de procesos.

Contenedores vs Maquinas Virtuales

Aspecto	Contenedores	Maquinas Virtuales
Inicio	Segundos	Minutos
Tamano	MBs	GBs
SO	Comparte kernel del anfitrion	SO invitado completo
Aislamiento	Nivel de proceso	Nivel de hardware
Rendimiento	Casi nativo	Sobrecarga del hypervisor
Densidad	Cientos por anfitrion	Decenas por anfitrion

Instalar Docker

# macOS
brew install --cask docker

# Ubuntu/Debian
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

# Verify installation
docker --version
docker run hello-world

Conceptos Fundamentales

Imagenes

Una imagen es una plantilla de solo lectura con instrucciones para crear un contenedor. Piensa en ella como una instantanea de tu aplicacion y su entorno.

# Pull an image from Docker Hub
docker pull node:20-alpine

# List local images
docker images

# Remove an image
docker rmi node:20-alpine

Contenedores

Un contenedor es una instancia en ejecucion de una imagen. Puedes crear, iniciar, detener y eliminar contenedores.

# Run a container
docker run -d --name my-app -p 3000:3000 node:20-alpine

# List running containers
docker ps

# List all containers (including stopped)
docker ps -a

# Stop a container
docker stop my-app

# Remove a container
docker rm my-app

# View logs
docker logs my-app

# Execute a command inside a running container
docker exec -it my-app sh

Escribir un Dockerfile

Un Dockerfile es un archivo de texto con instrucciones para construir una imagen. Cada instruccion crea una capa.

Dockerfile Basico para una App Node.js

# Use an official Node.js runtime as base image
FROM node:20-alpine

# Set working directory
WORKDIR /app

# Copy package files first (better caching)
COPY package.json package-lock.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application code
COPY . .

# Expose the port the app runs on
EXPOSE 3000

# Command to run the application
CMD ["node", "server.js"]

Construir y Ejecutar

# Build the image
docker build -t my-node-app .

# Run the container
docker run -d -p 3000:3000 my-node-app

# Visit http://localhost:3000

Builds Multi-Stage

Los builds multi-stage mantienen tus imagenes de produccion pequenas separando el entorno de construccion del de ejecucion.

# Stage 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:20-alpine AS runner
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
EXPOSE 3000
CMD ["node", "dist/server.js"]

Esto produce una imagen con solo la salida compilada y las dependencias de produccion - sin codigo fuente, sin dependencias de desarrollo, sin herramientas de construccion.

Ejemplo Multi-Stage para Next.js

FROM node:20-alpine AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci

FROM node:20-alpine AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
EXPOSE 3000
CMD ["node", "server.js"]

Volumenes: Datos Persistentes

Por defecto, los datos dentro de un contenedor se pierden cuando el contenedor se elimina. Los volumenes resuelven esto.

# Create a named volume
docker volume create my-data

# Run with a volume
docker run -d -v my-data:/app/data my-app

# Bind mount (map host directory to container)
docker run -d -v $(pwd)/data:/app/data my-app

# List volumes
docker volume ls

Redes

Docker crea redes aisladas para que los contenedores se comuniquen.

# Create a custom network
docker network create my-network

# Run containers on the same network
docker run -d --name api --network my-network my-api
docker run -d --name db --network my-network postgres:16

# Containers can reach each other by name
# From "api" container: postgres://db:5432

Docker Compose

Docker Compose te permite definir y ejecutar aplicaciones multi-contenedor con un solo archivo YAML.

docker-compose.yml

services:
  api:
    build: ./api
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  pgdata:

Comandos

# Start all services
docker compose up -d

# View logs
docker compose logs -f

# Stop all services
docker compose down

# Rebuild and restart
docker compose up -d --build

# Scale a service
docker compose up -d --scale api=3

.dockerignore

Como .gitignore, este archivo evita que archivos innecesarios se copien en la imagen.

node_modules
.git
.env
*.md
.next
dist
coverage

Mejores Practicas para Produccion

1. Usa Imagenes Base Pequenas

# Bad: 1GB+
FROM node:20

# Good: ~180MB
FROM node:20-alpine

2. No Ejecutar como Root

FROM node:20-alpine
RUN addgroup -S app && adduser -S app -G app
USER app
WORKDIR /home/app
COPY --chown=app:app . .

3. Usa Tags de Imagen Especificos

# Bad: can change unexpectedly
FROM node:latest

# Good: pinned version
FROM node:20.11-alpine3.19

4. Aprovecha la Cache de Build

Ordena las instrucciones de tu Dockerfile de las que cambian menos a las que cambian con mas frecuencia:

FROM node:20-alpine
WORKDIR /app

# These change rarely - cached
COPY package.json package-lock.json ./
RUN npm ci --only=production

# This changes often - not cached
COPY . .

5. Health Checks

HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget -qO- http://localhost:3000/health || exit 1

6. Usa Variables de Entorno

ENV NODE_ENV=production
ENV PORT=3000

Hoja de Referencia de Comandos Docker Comunes

# Images
docker build -t name:tag .        # Build image
docker images                      # List images
docker rmi image_name              # Remove image
docker image prune                 # Remove unused images

# Containers
docker run -d -p 3000:3000 image   # Run detached
docker ps                          # List running
docker stop container_name         # Stop
docker rm container_name           # Remove
docker logs -f container_name      # Follow logs
docker exec -it container sh       # Shell into container

# Compose
docker compose up -d               # Start services
docker compose down                # Stop services
docker compose logs -f             # Follow all logs
docker compose ps                  # List services

# Cleanup
docker system prune -a             # Remove everything unused

De Docker a Kubernetes

Docker gestiona contenedores individuales. Cuando necesitas orquestar cientos de contenedores en multiples servidores, necesitas Kubernetes. Docker y Kubernetes son complementarios:

1. Docker: construye y ejecuta contenedores
2. Kubernetes: orquesta contenedores a escala (planificacion, escalado, auto-reparacion)

Si te interesa el siguiente paso, consulta mi articulo sobre Introduccion a Kubernetes.

Conclusion

Docker es una habilidad fundamental para los desarrolladores modernos. Elimina las inconsistencias de entorno, simplifica el despliegue y es la base de la orquestacion de contenedores con Kubernetes. Comienza con un simple Dockerfile, pasa a Docker Compose para aplicaciones multi-servicio, y adopta builds multi-stage y mejores practicas de seguridad a medida que crezcas.

La mejor forma de aprender Docker es containerizar un proyecto en el que ya estes trabajando. Empieza hoy.