Docker Fastlane

🐳 ¿Qué es Docker?

Docker es una plataforma que permite empaquetar aplicaciones y todas sus dependencias en contenedores ligeros y portables. Un contenedor es como una "caja" autónoma que contiene todo lo necesario para que tu aplicación funcione: código, runtime, librerías y configuraciones.

¿Para qué sirve?

Docker resuelve el clásico problema de "en mi máquina funciona". Con Docker, tu aplicación funcionará exactamente igual en desarrollo, testing y producción, sin importar el sistema operativo o configuración del servidor.

⚡ ¿Por qué Docker es importante?

💡 Ejemplos de utilidad práctica

1. Desarrollo en equipo

# Nuevo developer en el equipo
git clone tu-proyecto
docker compose up
# ¡Listo! Sin instalar Node, PostgreSQL, Redis, etc.

Todo el equipo trabaja con versiones exactas de cada dependencia. Cero configuración manual.

2. Testing de múltiples versiones

# Probar tu app en diferentes versiones de Node
docker run --rm -v "$PWD":/app -w /app node:18 npm test
docker run --rm -v "$PWD":/app -w /app node:20 npm test
docker run --rm -v "$PWD":/app -w /app node:22 npm test

Cambia entre versiones sin desinstalar/reinstalar. Ideal para verificar compatibilidad.

3. Bases de datos temporales

# Levantar PostgreSQL temporal para pruebas
docker run --rm -e POSTGRES_PASSWORD=test -p 5432:5432 postgres:16
# Al detenerlo, desaparece todo sin dejar rastro

Perfecto para experimentar sin ensuciar tu sistema con instalaciones permanentes.

4. Microservicios complejos

# Levantar un stack completo con un comando
docker compose up
# Frontend + API + Base de datos + Cache + Cola de trabajos

Orquesta servicios complejos como si fueran uno solo. Todo sincronizado y conectado.

5. CI/CD y producción

# Build en CI
docker build -t miapp:v1.2.3 .
docker push miapp:v1.2.3

# Deploy en producción (cualquier servidor)
docker pull miapp:v1.2.3
docker run -d -p 80:3000 miapp:v1.2.3

Pipeline de deployment simplificado. La misma imagen pasa por todos los ambientes.

🔧 Instalación

brew install --cask docker
open -a Docker
# En settings: activar "Use Docker Compose V2"

# Ubuntu/Debian
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
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
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo $VERSION_CODENAME) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo usermod -aG docker $USER && newgrp docker

wsl --install -d Ubuntu
winget install -e --id Docker.DockerDesktop

📦 Imágenes

Construye artefactos inmutables a partir de un Dockerfile.

# construir una imagen
docker build -t miapp:1.0 .
# listar
docker images
# borrar
docker rmi miapp:1.0

Dockerfile base (Node)

FROM node:22-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:22-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
RUN adduser -D runner
USER runner
CMD ["node","dist/index.js"]
EXPOSE 3000

🐳 Contenedores

# ejecutar un contenedor efímero
docker run --rm -it alpine:3.20 sh
# nombrado y en segundo plano
docker run -d --name web -p 8080:80 nginx:alpine
# parar / iniciar / logs
docker stop web && docker start web && docker logs -f web

docker exec -it web sh

💾 Volúmenes

# volumen nombrado
docker volume create datos
# montar
docker run -d --name db -v datos:/var/lib/postgresql/data postgres:16
# bind mount (carpeta local)
docker run --rm -it -v "$PWD":/work -w /work node:22-alpine sh

🌐 Redes

docker network create appnet
# conectar servicios a la misma red
docker run -d --name redis --network appnet redis:7
# contenedores se resuelven por nombre (DNS interno)
# ej: app se conecta a host "redis"

⚙️ Docker Compose (stack completo)

Guarda esto como docker-compose.yml y ejecuta docker compose up -d.

services:
  web:
    image: nginx:alpine
    ports: ["8080:80"]
    volumes: ["./nginx.conf:/etc/nginx/conf.d/default.conf:ro"]
    depends_on: [api]
  api:
    build: ./api
    environment:
      - DATABASE_URL=postgres://postgres:postgres@db:5432/app
    ports: ["3000:3000"]
  db:
    image: postgres:16
    environment:
      - POSTGRES_PASSWORD=postgres
    volumes: ["pgdata:/var/lib/postgresql/data"]
  adminer:
    image: adminer
    ports: ["8081:8080"]
volumes:
  pgdata:

nginx.conf (reverse proxy simple)

server {
  listen 80;
  location / { proxy_pass http://api:3000; }
}

📋 Cheatsheet - Comandos Esenciales

Todos los comandos que necesitas en un solo lugar. Haz click en copiar y úsalos directamente.

🐳 Contenedores

# Listar contenedores activos
docker ps

# Listar todos (incluyendo detenidos)
docker ps -a

# Ejecutar contenedor interactivo
docker run -it ubuntu bash

# Ejecutar en segundo plano
docker run -d nginx

# Con nombre y puerto
docker run -d --name miapp -p 8080:80 nginx

# Detener contenedor
docker stop miapp

# Iniciar contenedor
docker start miapp

# Reiniciar contenedor
docker restart miapp

# Eliminar contenedor
docker rm miapp

# Eliminar contenedor en ejecución (forzar)
docker rm -f miapp

# Ver logs
docker logs miapp

# Seguir logs en tiempo real
docker logs -f miapp

# Ejecutar comando en contenedor activo
docker exec -it miapp bash

# Copiar archivos desde/hacia contenedor
docker cp miapp:/ruta/archivo.txt ./local.txt
docker cp ./local.txt miapp:/ruta/

📦 Imágenes

# Listar imágenes
docker images

# Buscar imagen en Docker Hub
docker search nginx

# Descargar imagen
docker pull nginx:alpine

# Construir imagen desde Dockerfile
docker build -t miapp:1.0 .

# Construir sin cache
docker build --no-cache -t miapp:1.0 .

# Etiquetar imagen
docker tag miapp:1.0 usuario/miapp:1.0

# Ver historial de capas
docker history miapp:1.0

# Eliminar imagen
docker rmi miapp:1.0

# Eliminar imágenes sin usar
docker image prune

# Guardar imagen en archivo
docker save -o miapp.tar miapp:1.0

# Cargar imagen desde archivo
docker load -i miapp.tar

💾 Volúmenes

# Crear volumen
docker volume create datos

# Listar volúmenes
docker volume ls

# Inspeccionar volumen
docker volume inspect datos

# Usar volumen en contenedor
docker run -v datos:/app/data miapp

# Bind mount (carpeta local)
docker run -v /ruta/local:/app/data miapp
docker run -v "$PWD":/app miapp

# Eliminar volumen
docker volume rm datos

# Eliminar volúmenes sin usar
docker volume prune

🌐 Redes

# Listar redes
docker network ls

# Crear red
docker network create mired

# Conectar contenedor a red
docker run -d --name app --network mired nginx

# Conectar contenedor existente a red
docker network connect mired app

# Desconectar de red
docker network disconnect mired app

# Inspeccionar red
docker network inspect mired

# Eliminar red
docker network rm mired

# Eliminar redes sin usar
docker network prune

⚙️ Docker Compose

# Iniciar servicios
docker compose up

# Iniciar en segundo plano
docker compose up -d

# Detener servicios
docker compose down

# Detener y eliminar volúmenes
docker compose down -v

# Ver logs
docker compose logs

# Seguir logs
docker compose logs -f

# Logs de servicio específico
docker compose logs -f api

# Reconstruir imágenes
docker compose build

# Reconstruir y reiniciar
docker compose up -d --build

# Listar servicios
docker compose ps

# Ejecutar comando en servicio
docker compose exec api sh

# Escalar servicio
docker compose up -d --scale api=3

🔍 Información y Debug

# Información del sistema
docker info

# Versión de Docker
docker version

# Uso de recursos en tiempo real
docker stats

# Uso de recursos de contenedor específico
docker stats miapp

# Inspeccionar contenedor (JSON)
docker inspect miapp

# Procesos de un contenedor
docker top miapp

# Eventos en tiempo real
docker events

# Uso de disco
docker system df

🧹 Limpieza

# Eliminar contenedores detenidos
docker container prune

# Eliminar imágenes sin usar
docker image prune

# Eliminar imágenes sin usar (todas)
docker image prune -a

# Eliminar volúmenes sin usar
docker volume prune

# Eliminar redes sin usar
docker network prune

# Limpieza completa del sistema
docker system prune

# Limpieza completa (incluye imágenes)
docker system prune -a

# Limpieza completa + volúmenes
docker system prune -a --volumes

🏷️ Registry

# Login a Docker Hub
docker login

# Login a registry privado
docker login registry.ejemplo.com

# Logout
docker logout

# Push imagen
docker push usuario/miapp:1.0

# Pull imagen privada
docker pull usuario/miapp-privada:1.0

# Tag para registry privado
docker tag miapp:1.0 registry.ejemplo.com/miapp:1.0

🏷️ Registries

# taggear y subir a Docker Hub
docker login
docker tag miapp:1.0 usuario/miapp:1.0
docker push usuario/miapp:1.0
# ejecutar desde cualquier máquina
docker run -p 3000:3000 usuario/miapp:1.0

🔍 Debug & logs

docker ps -a            # contenedores
docker images          # imágenes
docker stats           # recursos en vivo
docker logs -f api     # logs streaming
docker inspect api     # JSON detallado
# limpiar recursos colgados (¡cuidado!)
docker system prune -a

✨ Extras útiles

services:
  api:
    image: node:22-alpine
    working_dir: /app
    command: sh -c "npm ci && npm run dev"
    volumes:
      - ./:/app
      - /app/node_modules
    ports: ["3000:3000"]

docker buildx create --use
# ejemplo: linux/amd64 + linux/arm64
docker buildx build --platform linux/amd64,linux/arm64 -t usuario/miapp:1.0 --push .

🎯 Desafío rápido (10′)

1. Levanta el stack con docker compose up -d.
2. Abre localhost:8080 (Nginx→API) y localhost:8081 (Adminer).
3. Crea una tabla, inserta filas, y consulta desde la API.
4. Pushea la imagen a tu registry personal.

Si todo pasa en verde → ● ¡estás listo para contenerizar tu próximo proyecto!