Aprende Docker
desde cero

# Ver qué versión se instaló
docker --version
# Resultado esperado: Docker version 25.x.x, build xxxxxxx

# Ejecuta el contenedor de prueba oficial de Docker.
# Docker descargará una imagen pequeña, la ejecutará
# y te mostrará un mensaje de bienvenida.
docker run hello-world
# Si ves "Hello from Docker!" → ¡todo correcto! 🎉

# ── BUSCAR imágenes en Docker Hub ─────────────────────────────
docker search nginx             # Busca imágenes con "nginx" en el nombre

# ── DESCARGAR (pull) ──────────────────────────────────────────
# "pull" descarga la imagen a tu máquina sin ejecutarla todavía
docker pull nginx               # Descarga la última versión (latest)
docker pull nginx:1.25-alpine  # Una versión específica y variante
docker pull node:20            # Node.js versión 20
docker pull postgres:16       # PostgreSQL versión 16

# ── VER las imágenes descargadas ──────────────────────────────
docker images                   # Lista todas las imágenes en tu máquina
docker image ls                 # Mismo resultado, otra forma de escribirlo

# ── VER las capas de una imagen ───────────────────────────────
docker history nginx           # Muestra cómo se construyó la imagen paso a paso

# ── ELIMINAR imágenes ─────────────────────────────────────────
docker rmi nginx              # Elimina la imagen nginx
docker rmi nginx:1.24        # Elimina una versión específica
docker image prune             # Elimina imágenes que ya no usa ningún contenedor

# Formato: [registro/][usuario/]nombre[:tag]

nginx                    # Imagen oficial de Docker Hub, última versión
nginx:1.25               # Imagen oficial, versión 1.25 exacta
node:20-alpine           # Node 20 sobre Alpine Linux (imagen muy ligera)
miusuario/mi-app:1.0    # Imagen tuya subida a Docker Hub con etiqueta "1.0"

# Las variantes más habituales:
# :latest   → la más reciente (es la que se usa si no pones tag)
# :alpine   → basada en Alpine Linux, muy ligera (~5MB vs ~200MB)
# :slim     → versión recortada, más ligera que la completa

# Lo más básico: ejecutar nginx
docker run nginx
# Problema: esto bloquea tu terminal. Cuando la cierras, el contenedor muere.

# ── -d (detached) → ejecutar en segundo plano ────────────────
docker run -d nginx
# Ahora corre en segundo plano y te devuelve el control de la terminal.

# ── --name → ponerle nombre al contenedor ────────────────────
docker run -d --name mi-nginx nginx
# Sin nombre, Docker asigna uno aleatorio (tipo "loving_einstein").
# Con nombre puedes referirte a él fácilmente en los demás comandos.

# ── -p → abrir un puerto (host:contenedor) ───────────────────
docker run -d -p 8080:80 nginx
# Ahora al abrir localhost:8080 en tu navegador ves nginx.
# El 8080 es el puerto de tu máquina, el 80 es el del contenedor.

# ── -it → modo interactivo (entrar dentro del contenedor) ────
docker run -it ubuntu bash
# Entras dentro del contenedor con una terminal bash.
# Es como conectarte por SSH a un servidor. Para salir: exit

# ── --rm → eliminar el contenedor al terminar ────────────────
docker run --rm ubuntu echo "Hola"
# Ejecuta el comando y limpia el contenedor solo. Ideal para tareas puntuales.

# ── -e → pasar variables de entorno ──────────────────────────
# Las apps leen configuración de variables de entorno en lugar
# de tener contraseñas escritas en el código (mucho más seguro).
docker run -d \
  -e POSTGRES_USER=admin \
  -e POSTGRES_PASSWORD=secreto \
  postgres

# ── --env-file → cargar variables desde un archivo .env ──────
docker run --env-file .env mi-app
# Más limpio que poner muchos -e y no expone secretos en la terminal.

# ── Ejemplo real completo: PostgreSQL listo en segundos ──────
docker run -d \
  --name mi-postgres \
  -e POSTGRES_USER=admin \
  -e POSTGRES_PASSWORD=supersecret \
  -e POSTGRES_DB=miapp \
  -p 5432:5432 \
  -v pgdata:/var/lib/postgresql/data \
  postgres:16-alpine

# ── VER qué contenedores están en marcha ─────────────────────
docker ps                      # Solo los que están corriendo
docker ps -a                   # Todos, incluyendo los que están parados

# ── PARAR y ARRANCAR ─────────────────────────────────────────
docker stop mi-nginx           # Para el contenedor (puede volver a arrancarse)
docker start mi-nginx          # Lo arranca de nuevo
docker restart mi-nginx        # Para y arranca en un solo comando

# ── ELIMINAR un contenedor ───────────────────────────────────
docker rm mi-nginx             # Debe estar parado antes
docker rm -f mi-nginx          # -f fuerza la eliminación aunque esté corriendo
docker container prune         # Elimina todos los contenedores que estén parados

# ── VER los logs (mensajes que imprime la aplicación) ────────
docker logs mi-nginx           # Muestra todos los logs
docker logs -f mi-nginx        # -f (follow): sigue los logs en tiempo real
docker logs --tail 50 mi-nginx # Solo las últimas 50 líneas

# ── ENTRAR en un contenedor que ya está corriendo ────────────
docker exec -it mi-nginx bash  # Abre una terminal bash dentro
docker exec -it mi-nginx sh    # Usa "sh" si la imagen no tiene bash (ej. Alpine)
docker exec mi-nginx ls /etc   # Ejecuta un solo comando sin quedarte dentro

# ── VER cuánta CPU y RAM consume cada contenedor ─────────────
docker stats                   # Se actualiza en tiempo real. Ctrl+C para salir.

# ── COPIAR archivos entre tu máquina y el contenedor ─────────
docker cp mi-nginx:/etc/nginx/nginx.conf .       # Del contenedor a tu máquina
docker cp ./mi-config.conf mi-nginx:/etc/nginx/  # De tu máquina al contenedor

# ── --read-only → Sistema de archivos inmutable ──────────────
docker run -d --read-only mi-app
# Evita que un atacante pueda instalar malware dentro del contenedor
# si logra colarse, porque no podrá escribir en el disco.

# ── Escaneo de vulnerabilidades ──────────────────────────────
docker scout cves mi-app:1.0
# Docker Scout revisa tu imagen y te dice si las librerías
# o el sistema base que usas tienen agujeros de seguridad conocidos.

# Dependencias — se instalan dentro del contenedor
node_modules/
__pycache__/
.venv/

# Control de versiones — no hace falta dentro de la imagen
.git/
.gitignore

# Variables de entorno y secretos — NUNCA dentro de una imagen
.env
.env.*
*.key
*.pem

# Artefactos de desarrollo
*.log
coverage/

# El propio Dockerfile y compose no necesitan estar dentro
Dockerfile*
compose*.yaml
.dockerignore

# El punto (.) indica que el Dockerfile está en la carpeta actual
docker build -t mi-app:1.0 .

# Sin caché (cuando algo va mal y quieres empezar limpio)
docker build --no-cache -t mi-app .

# Ver el progreso detallado paso a paso
docker build --progress=plain -t mi-app .

# Subir tu imagen a Docker Hub
docker tag mi-app:1.0 miusuario/mi-app:1.0  # Renombrar para Docker Hub
docker login                                  # Autenticarse
docker push miusuario/mi-app:1.0             # Subir

# ── Crear y gestionar volúmenes ───────────────────────────────
docker volume create mis-datos   # Crea un volumen llamado "mis-datos"
docker volume ls                  # Lista todos los volúmenes
docker volume inspect mis-datos  # Ver detalles del volumen
docker volume rm mis-datos       # Elimina el volumen y sus datos
docker volume prune               # Elimina volúmenes que no usa ningún contenedor

# ── Volumen para persistir la base de datos ───────────────────
# Si eliminas y recreas el contenedor, los datos siguen en "pgdata".
docker run -d \
  --name mi-postgres \
  -v pgdata:/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=secreto \
  postgres:16

# ── Bind mount para desarrollo ────────────────────────────────
# $(pwd) es tu carpeta actual en Linux/Mac. En Windows PowerShell usa ${PWD}.
# Al cambiar código en tu editor, el contenedor lo ve de inmediato.
docker run -d \
  -v $(pwd):/app \
  -p 3000:3000 \
  mi-app-node

# ── Solo lectura (:ro) ────────────────────────────────────────
# El contenedor puede leer los archivos pero no modificarlos
docker run -v $(pwd)/config:/app/config:ro mi-app

# ── Crear y listar redes ──────────────────────────────────────
docker network create mi-red        # Crea una red llamada "mi-red"
docker network ls                    # Lista todas las redes existentes
docker network rm mi-red            # Elimina la red

# ── Ejemplo completo: app + base de datos ─────────────────────

# Paso 1: crear la red
docker network create app-network

# Paso 2: arrancar la base de datos en esa red
docker run -d --name db \
  --network app-network \
  -e POSTGRES_PASSWORD=secreto \
  postgres:16-alpine

# Paso 3: arrancar la app en la misma red
docker run -d --name backend \
  --network app-network \
  -e DATABASE_URL=postgresql://postgres:secreto@db:5432/miapp \
  -p 3000:3000 \
  mi-backend:latest

# En la URL de conexión usamos "db" como hostname.
# Docker resuelve "db" al contenedor que se llama "db" automáticamente.
# Sin la red personalizada, esto no funcionaría.

# 1. Crear la red
docker network create mi-red

# 2. Base de datos (se llama "db")
docker run -d --name db --network mi-red -e POSTGRES_PASSWORD=secreto postgres:16

# 3. Tu aplicación conecta a "db" en lugar de "localhost"
docker run -d --name app --network mi-red -e DATABASE_URL="postgresql://postgres:secreto@db:5432/bd" mi-app

# En lugar de usar localhost o 127.0.0.1:
# DATABASE_URL="postgresql://user:pass@localhost:5432/bd" ❌ MAL

# Usa host.docker.internal:
# DATABASE_URL="postgresql://user:pass@host.docker.internal:5432/bd" ✅ BIEN

docker run -d -e DATABASE_URL="postgresql://user:pass@host.docker.internal:5432/bd" mi-app

# Tu aplicación sale a internet de forma transparente
docker run -d -e DATABASE_URL="postgresql://usuario:pass@aws-rds-url.com:5432/bd" mi-app

# "services" es la lista de contenedores que quieres levantar
services:

  # ── Contenedor 1: tu aplicación backend ──────────────────────
  backend:
    build: .                   # Construye la imagen desde el Dockerfile de esta carpeta
    ports:
      - "3000:3000"
    env_file:
      - .env
    volumes:
      - ./src:/app/src          # Bind mount: editas el código y el contenedor lo ve al momento
    depends_on:
      - db                      # Espera a que el contenedor "db" esté en marcha antes de arrancar
      - redis
    restart: unless-stopped   # Se reinicia si falla, a menos que lo pares tú explícitamente

  # ── Contenedor 2: base de datos ───────────────────────────────
  db:
    image: postgres:16-alpine  # Usa esta imagen sin construir nada
    env_file:
      - .env               # ¡Seguridad! Las contraseñas van en un archivo .env aparte
    volumes:
      - pgdata:/var/lib/postgresql/data  # Volumen para que los datos persistan

  # ── Contenedor 3: Redis (caché en memoria) ────────────────────
  redis:
    image: redis:7-alpine

# Declaración de los volúmenes que se usan arriba
volumes:
  pgdata:

# ── ARRANCAR ─────────────────────────────────────────────────
docker compose up              # Arranca y muestra los logs en pantalla
docker compose up -d           # Arranca en segundo plano
docker compose up --build     # Reconstruye las imágenes antes de arrancar

# ── PARAR ────────────────────────────────────────────────────
docker compose down            # Para y elimina los contenedores
docker compose down -v        # También elimina los volúmenes (¡cuidado, pierdes datos!)
docker compose stop            # Solo para, sin eliminar (puedes arrancar de nuevo)

# ── VER ESTADO Y LOGS ────────────────────────────────────────
docker compose ps              # Estado de cada servicio
docker compose logs            # Logs de todos los servicios
docker compose logs -f backend # Seguir en tiempo real solo el backend

# ── EJECUTAR COMANDOS DENTRO ──────────────────────────────────
docker compose exec backend bash         # Abrir shell en el backend
docker compose exec db psql -U admin    # Conectar a la consola de PostgreSQL

# ── RECONSTRUIR ──────────────────────────────────────────────
docker compose build backend             # Reconstruye solo la imagen del backend

services:
  backend:
    image: mi-backend:1.0
    depends_on:
      db:
        condition: service_healthy  # Espera a que la BD esté 100% lista, no solo arrancada
    deploy:
      resources:
        limits:
          cpus: '0.5'               # Máximo 50% de un núcleo del servidor
          memory: 512M              # Si la app intenta consumir más, Docker la reinicia

  db:
    image: postgres:16-alpine
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U admin"]  # Comando para verificar que la BD responde
      interval: 10s                 # Cada cuánto tiempo hace la prueba
      timeout: 5s                   # Tiempo máximo que espera respuesta
      retries: 5                    # Intentos antes de declararla "unhealthy" (rota)

# 1. En tu ordenador (o en GitHub Actions): Construyes la imagen
docker build -t mi-app:v1.0 .

# 2. Le pones la etiqueta del registro privado de tu empresa
docker tag mi-app:v1.0 registry.empresa.com/mi-app:v1.0

# 3. La subes a la nube (AWS ECR, Google Artifact Registry...)
docker push registry.empresa.com/mi-app:v1.0

# 4. El servidor de Producción la descarga y la ejecuta
# (Esto suele hacerlo automáticamente Docker Compose o Kubernetes)
docker pull registry.empresa.com/mi-app:v1.0
docker run -d -p 80:3000 registry.empresa.com/mi-app:v1.0

# Si sabes Docker, ya sabes Podman. Los comandos son idénticos:
podman run -d -p 80:80 nginx
podman ps
podman build -t mi-app .