🐳 Docker Desde Cero - Guía Completa

¿Qué es Docker? Docker es una plataforma de código abierto que permite crear, desplegar y ejecutar aplicaciones en contenedores. Los contenedores son entornos ligeros y portables que incluyen todo lo necesario para ejecutar una aplicación.

Ventajas de Docker:

• Portabilidad: Funciona igual en cualquier entorno
• Isolamiento: Cada aplicación corre en su propio entorno
• Eficiencia: Comparte el kernel del sistema operativo
• Escalabilidad: Fácil de escalar horizontalmente

Historia de Docker:

Docker fue lanzado en 2013 por Solomon Hykes y rápidamente se convirtió en el estándar de la industria para la containerización de aplicaciones.

En Windows:

1. Descarga Docker Desktop desde docker.com
2. Ejecuta el instalador y sigue las instrucciones
3. Reinicia tu computadora si es necesario
4. Abre Docker Desktop y verifica la instalación

En macOS:

1. Descarga Docker Desktop para Mac
2. Arrastra Docker a la carpeta Aplicaciones
3. Abre Docker desde Aplicaciones

En Linux (Ubuntu/Debian):

# Actualizar paquetes
sudo apt-get update

# Instalar dependencias
sudo apt-get install apt-transport-https ca-certificates curl gnupg lsb-release

# Agregar repositorio oficial
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Instalar Docker
sudo apt-get install docker-ce docker-ce-cli containerd.io

Verificar instalación:

docker --version
docker run hello-world

Contenedor vs Máquina Virtual:

Componentes principales:

• Dockerfile: Archivo de texto con instrucciones para construir una imagen
• Imagen: Plantilla de solo lectura usada para crear contenedores
• Contenedor: Instancia ejecutable de una imagen
• Docker Hub: Repositorio público de imágenes

Trabajando con Imágenes:

# Buscar una imagen
docker search nginx

# Descargar una imagen
docker pull nginx:latest

# Listar imágenes locales
docker images

# Eliminar una imagen
docker rmi nginx:latest

Trabajando con Contenedores:

# Crear y ejecutar un contenedor
docker run -d -p 80:80 --name mi-web nginx

# Listar contenedores en ejecución
docker ps

# Listar todos los contenedores
docker ps -a

# Detener un contenedor
docker stop mi-web

# Iniciar un contenedor detenido
docker start mi-web

# Eliminar un contenedor
docker rm mi-web

Estructura de un Dockerfile:

# Imagen base
FROM node:18-alpine

# Directorio de trabajo
WORKDIR /app

# Copiar archivos
COPY package*.json ./

# Instalar dependencias
RUN npm install

# Copiar el resto del código
COPY . .

# Exponer puerto
EXPOSE 3000

# Comando de inicio
CMD ["npm", "start"]

Instrucciones comunes:

• FROM: Especifica la imagen base
• RUN: Ejecuta comandos durante el build
• COPY: Copia archivos al contenedor
• ENV: Establece variables de entorno
• EXPOSE: Expone un puerto
• CMD: Comando por defecto al iniciar

Construir y ejecutar:

# Construir la imagen
docker build -t mi-app .

# Ejecutar el contenedor
docker run -p 3000:3000 mi-app

Tipos de volúmenes:

1. Volúmenes con nombre:

# Crear volumen
docker volume create mi-volumen

# Usar volumen en contenedor
docker run -d -v mi-volumen:/data nginx

2. Bind mounts:

# Montar directorio local
docker run -d -v /ruta/local:/ruta/contenedor nginx

3. Volúmenes en Docker Compose:

version: '3.8'
services:
  db:
    image: postgres
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Tipos de redes:

• bridge: Red por defecto para contenedores
• host: El contenedor usa la red del host
• none: Sin conectividad de red
• overlay: Para comunicación entre hosts

Comandos de red:

# Crear red
docker network create mi-red

# Listar redes
docker network ls

# Conectar contenedor a red
docker network connect mi-red mi-contenedor

# Inspeccionar red
docker network inspect mi-red

Ejemplo de uso:

# Crear red para aplicación
docker network create app-network

# Ejecutar contenedores en la misma red
docker run -d --name web --network app-network nginx
docker run -d --name api --network app-network mi-api

Optimización de imágenes:

• Usa imágenes base pequeñas (Alpine)
• Minimiza el número de capas
• Usa .dockerignore
• Combina comandos RUN

Seguridad:

• No ejecutes como root
• Escanea imágenes con docker scan
• Usa secretos para datos sensibles
• Mantén imágenes actualizadas

Multi-stage builds:

# Build stage
FROM node:18 AS builder
WORKDIR /app
COPY . .
RUN npm run build

# Production stage
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html

¿Qué es Docker Compose?

Docker Compose es una herramienta para definir y ejecutar aplicaciones multi-contenedor usando archivos YAML.

Ejemplo completo:

version: '3.8'

services:
  web:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    depends_on:
      - db
    environment:
      - NODE_ENV=production

  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: miapp
    volumes:
      - pgdata:/var/lib/postgresql/data

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

volumes:
  pgdata:

Comandos esenciales:

# Iniciar servicios
docker-compose up -d

# Ver logs
docker-compose logs -f

# Detener servicios
docker-compose down

# Reconstruir
docker-compose up -d --build

Health Checks:

services:
  web:
    image: nginx
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

Restart Policies:

• no - No reiniciar automáticamente
• on-failure - Reiniciar solo si falla
• always - Siempre reiniciar
• unless-stopped - Reiniciar a menos que se detenga

Resource Limits:

services:
  app:
    image: mi-app
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

GitHub Actions ejemplo:

name: Docker CI/CD

on:
  push:
    branches: [ main ]

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Login to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      
      - name: Build and push
        uses: docker/build-push-action@v4
        with:
          push: true
          tags: user/app:latest

Beneficios:

• Builds reproducibles
• Entornos consistentes
• Deploy rápido y confiable

Arquitectura de microservicios con Docker:

version: '3.8'

services:
  api-gateway:
    image: nginx
    ports:
      - "80:80"
    depends_on:
      - user-service
      - order-service
      - product-service

  user-service:
    build: ./services/user
    environment:
      - DB_HOST=user-db

  order-service:
    build: ./services/order
    environment:
      - DB_HOST=order-db

  product-service:
    build: ./services/product

  user-db:
    image: postgres

  order-db:
    image: postgres

  product-db:
    image: mongodb

Ventajas:

• Despliegue independiente
• Escalabilidad por servicio
• Tolerancia a fallos