Skip to content

Latest commit

 

History

History
236 lines (194 loc) · 7.85 KB

docker.md

File metadata and controls

236 lines (194 loc) · 7.85 KB

Docker Cheatsheet — Labs 05-10

Conceptos Clave

Concepto Descripción
Imagen Template inmutable de solo-lectura (como una clase)
Contenedor Instancia ejecutable de una imagen (como un objeto)
Layer Diff inmutable creado por cada instrucción del Dockerfile
Named Volume Almacén de datos gestionado por Docker, persiste al borrar contenedor
Bind Mount Directorio del host montado dentro del contenedor
Bridge Network Red virtual aislada (default), cada contenedor recibe IP interna
Custom Network Red bridge con DNS automático (contenedores se encuentran por nombre)

Contenedores — Ciclo de Vida

docker run -d --name app -p 8080:80 nginx:alpine  # crear + arrancar (background)
docker run --rm alpine echo "hola"                 # ejecutar y auto-borrar
docker run -it alpine sh                           # shell interactivo

docker ps                                          # contenedores Running
docker ps -a                                       # TODOS (incluidos Exited)
docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'

docker stop app                                    # SIGTERM → 10s → SIGKILL
docker start app                                   # reanudar contenedor parado
docker restart app                                 # stop + start
docker kill app                                    # SIGKILL inmediato
docker rm app                                      # borrar contenedor parado
docker rm -f app                                   # stop + rm en uno

Ejecutar Dentro de Contenedores

docker exec app cat /etc/config       # comando puntual
docker exec -it app sh                # shell interactivo
docker exec -u root app whoami        # como root (diagnóstico)
docker exec app env | grep DB_        # ver variables de entorno

Logs

docker logs app                       # todo el historial
docker logs -f app                    # follow (tiempo real)
docker logs --tail 50 app             # últimas 50 líneas
docker logs --since 5m app            # últimos 5 minutos
docker logs -t app                    # con timestamps
docker logs app > app.log 2>&1        # guardar en archivo

Imágenes y Dockerfile

docker images                         # listar imágenes locales
docker pull nginx:alpine              # descargar imagen
docker history nginx:alpine           # ver layers de imagen
docker build -t app:v1 .              # construir imagen
docker build -f Dockerfile.prod -t app:v1 .  # Dockerfile alternativo
docker build --no-cache -t app:v2 .   # ignorar caché

Dockerfile — Instrucciones

FROM alpine:3.19           # base (SIEMPRE con tag específico)
WORKDIR /app               # directorio de trabajo (mkdir + cd)
COPY package.json .        # copiar del host → imagen
RUN apk add --no-cache curl # ejecutar durante build
ENV APP_PORT=8080          # variable de entorno
EXPOSE 8080                # documentar puerto (no lo abre)
USER appuser               # cambiar usuario (non-root)
CMD ["node", "app.js"]     # comando por defecto

Multi-stage Build (Java)

FROM maven:3.9-eclipse-temurin-17 AS build
WORKDIR /build
COPY pom.xml .
RUN mvn dependency:resolve
COPY src/ src/
RUN mvn package -DskipTests

FROM eclipse-temurin:17-jre-alpine AS runtime
WORKDIR /app
COPY --from=build /build/target/app.jar app.jar
CMD ["java", "-jar", "app.jar"]

Volúmenes

docker volume create datos            # crear named volume
docker volume ls                       # listar volúmenes
docker volume inspect datos            # metadata del volumen
docker volume rm datos                 # borrar volumen (DATOS PERDIDOS)
docker volume prune                    # borrar volúmenes sin contenedor (¡CUIDADO!)

# Montar named volume
docker run -v datos:/var/lib/mysql mysql:8.0

# Bind mount (desarrollo)
docker run -v ./src:/app/src app:v1

# Read-only
docker run -v config:/etc/app:ro app:v1

Networks

docker network ls                      # listar redes
docker network create app-net          # crear red custom (con DNS)
docker network inspect app-net         # detalle de red
docker network connect app-net web     # conectar contenedor a red
docker network disconnect app-net web  # desconectar
docker network rm app-net              # borrar red

# Contenedores en red custom (DNS por nombre)
docker run -d --network app-net --name web nginx
docker run -d --network app-net --name db mysql:8.0
# web puede hacer: ping db (DNS automático)

Port Mapping

-p 8080:80               # host:8080 → container:80 (público)
-p 127.0.0.1:8080:80     # solo localhost (más seguro)
-p 8080-8090:80-90       # rango de puertos

Docker Compose

docker compose up -d                   # crear + arrancar (background)
docker compose up -d --build           # rebuild + arrancar
docker compose down                    # parar + borrar (mantiene volúmenes)
docker compose down -v                 # parar + borrar + BORRAR VOLÚMENES
docker compose ps                      # estado de servicios
docker compose logs -f --tail 50       # follow desde últimas 50 líneas
docker compose logs web                # solo servicio "web"
docker compose exec web sh             # shell dentro de servicio
docker compose stop                    # parar sin borrar
docker compose start                   # reanudar servicios
docker compose restart                 # stop + start
docker compose config                  # YAML resuelto (variables expandidas)

docker-compose.yml — Estructura

services:
  app:
    image: app:v1             # o build: ./app
    ports: ["8080:8080"]
    environment:
      DB_HOST: db
    env_file: [./app.env]
    depends_on:
      db:
        condition: service_healthy
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 30s
    deploy:
      resources:
        limits: { memory: 256M, cpus: '0.50' }

  db:
    image: mysql:8.0
    volumes: [db-data:/var/lib/mysql]
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_PASS}

volumes:
  db-data:

Diagnóstico y Troubleshooting

# Workflow: ps → logs → stats → inspect → df
docker inspect --format '{{.State.Status}}' app
docker inspect --format '{{.State.ExitCode}}' app
docker inspect --format '{{.State.OOMKilled}}' app
docker inspect --format '{{.NetworkSettings.IPAddress}}' app
docker inspect --format '{{json .State}}' app | python3 -m json.tool

docker stats --no-stream              # snapshot CPU/RAM/NET/IO
docker system df                      # espacio usado por Docker
docker port app                       # mapeos de puertos

Exit Codes

Code Significado
0 Terminó correctamente
1 Error genérico de la app
126 Comando no ejecutable (permisos)
127 Comando no encontrado
137 SIGKILL / OOM Kill (128+9)
143 SIGTERM (shutdown limpio, 128+15)

Seguridad — Checklist

  • FROM con tag específico (no :latest)
  • Multi-stage build (JDK → JRE)
  • USER non-root
  • COPY --chown (ownership correcto)
  • .dockerignore (no enviar .env, .git, node_modules)
  • Resource limits (memory + CPU)
  • Healthcheck en cada servicio
  • DB sin port mapping (solo red interna)
  • Passwords en env_file, no inline en YAML
  • Log rotation (max-size + max-file)

Limpieza

docker container prune -f             # borrar contenedores Exited
docker image prune -f                 # borrar imágenes dangling
docker system prune -f                # contenedores + imágenes + redes
docker system prune -a -f             # + imágenes no usadas
docker builder prune -f               # build cache
docker volume prune -f                # CUIDADO: borra datos