Curso de Docker 2026

Este curso de Docker reúne todas las lecciones necesarias para comenzar con contenedores y avanzar progresivamente hasta Docker Compose, seguridad, producción y CI/CD.

El curso de Docker está organizado como una ruta de aprendizaje práctica. Puedes seguir las lecciones en orden o acceder directamente al tema que necesites consultar.

🔍 ¿Por qué aprender Docker en 2026?

Docker es una herramienta fundamental para:

Crear entornos de desarrollo reproducibles.
Empaquetar y distribuir aplicaciones.
Automatizar procesos de CI/CD.
Trabajar con Kubernetes y OpenShift.
Desplegar aplicaciones en servidores y plataformas cloud.

🎯 Características del curso de Docker

✅ 100 % gratuito
✅ Enfoque práctico
✅ Contenido actualizado para 2026
✅ Desde nivel principiante hasta avanzado
✅ Aprende a tu propio ritmo dentro de un curso de Docker ordenado por módulos.

📚 Temario del curso de Docker

Fundamentos esenciales

1. Introducción a Docker

2. Instalación y primeros pasos

Cómo instalar Docker en Linux
Cómo instalar Docker en Windows
Cómo instalar Docker en Mac
Configuración inicial recomendada de Docker
Configuracion inicial avanzada de docker
Cómo verificar que Docker funciona
Creando tu primer contenedor
Cómo ejecutar un contenedor
Contenedores en modo interactivo
Contenedores en segundo plano
Ciclo de vida de un contenedor
Docker Permission Denied

Administración de contenedores

3. Gestión básica de contenedores

Cómo listar contenedores
Cómo nombrar contenedores
Cómo iniciar contenedores
Cómo detener contenedores
Cómo reiniciar contenedores
Cómo eliminar contenedores
Cómo ejecutar una imagen propia
Cómo ejecutar comandos dentro de un contenedor
Cómo entrar dentro de un contenedor
Cómo entrar a un contenedor para depurar

4. Logs, inspección y recursos

Cómo ver logs de un contenedor
Cómo leer logs de contenedores
Cómo inspeccionar un contenedor
Cómo inspeccionar la configuración de contenedores
Docker Inspect: cómo ver todos los detalles de un contenedor
Cómo revisar el consumo de recursos
Cómo limitar los recursos de un contenedor
Cómo configurar políticas de reinicio en Docker
Cómo actualizar la configuración de un contenedor

5. Procesos dentro de los contenedores

Qué es el proceso principal de un contenedor
Qué es el PID 1 dentro de un contenedor
Por qué un contenedor se apaga cuando termina su proceso
Cómo funcionan las señales en Docker
Qué ocurre cuando ejecutas docker stop
Cómo realizar un apagado limpio
Diferencias entre shell form y exec form
Cuándo utilizar la opción –init
Qué es STOPSIGNAL

Imágenes y registries

6. Imágenes Docker

Imágenes Docker: qué son, para qué sirven y cómo usarlas
Cómo funcionan las capas de una imagen Docker
Cómo descargar imágenes
Cómo listar imágenes locales
Cómo eliminar imágenes
Cómo usar imágenes ya construidas
Cómo elegir una buena imagen base
Qué son las imágenes Alpine
Cómo usar imágenes oficiales de forma segura
Buenas prácticas para imágenes Docker

8. Docker Hub y registries

Qué es Docker Hub
Docker Hub: qué es, cómo funciona y buenas prácticas
Cómo iniciar sesión en Docker Hub
Cómo subir una imagen a Docker Hub
Qué es un Docker Registry
Qué son los registries privados
Cómo descargar imágenes desde un registry
GitHub Container Registry
GitLab Container Registry
AWS ECR
Azure ACR
Google Artifact Registry

Dockerfile y construcción de imágenes

9. Fundamentos de Dockerfile

Qué es un Dockerfile
Estructura básica de un Dockerfile
Flujo básico: Dockerfile, imagen y contenedor
Cómo construir una imagen Docker
Cómo ejecutar una imagen propia
Qué es el contexto de construcción
Qué significa el punto en docker build
Cómo utilizar contextos locales, Git y URL
Cómo utilizar contextos de construcción con nombre

10. Instrucciones de Dockerfile

Instrucción FROM
Instrucción RUN
Instrucción COPY
Instrucción ARG
Instrucción ENV
Instrucción EXPOSE
Instrucción WORKDIR
Instrucción USER
Instrucción CMD
Instrucción ENTRYPOINT
Instrucción LABEL
Instrucción VOLUME
Instrucción HEALTHCHECK
Instrucción STOPSIGNAL
Instrucción SHELL
Instrucción ONBUILD
Diferencia entre CMD y ENTRYPOINT
Diferencia entre COPY y ADD
Cómo utilizar heredocs en un Dockerfile
Cómo crear un usuario dentro del contenedor
Cómo validar un Dockerfile
Cómo ejecutar tests dentro de Docker

11. Caché y optimización

Cómo funciona la caché de Docker
Cómo aprovechar mejor la caché
Cómo invalidar la caché
Cómo crear imágenes más rápidas de construir
Qué es .dockerignore
Cómo usar .dockerignore correctamente
Cómo evitar archivos innecesarios
Cómo instalar solo las dependencias necesarias
Cómo separar las dependencias del código
Cómo reducir el tamaño de una imagen Docker
Qué es un multi-stage build
Buenas prácticas para Dockerfile
Errores comunes al construir imágenes

12. BuildKit y Buildx

Qué es Docker BuildKit
Qué es Docker Buildx
Diferencias entre docker build y docker buildx build
Cómo crear un builder
Cómo administrar builders
Cómo inspeccionar un builder
Cómo utilizar cache mounts
Cómo utilizar bind mounts durante una construcción
Cómo compartir la caché entre builds
Cómo utilizar caché externa
Cómo reutilizar la caché en CI/CD
Cómo construir imágenes multiarquitectura
Cómo crear imágenes para AMD64 y ARM64
Cómo publicar imágenes multiarquitectura
Cómo utilizar Docker Buildx Bake

13. Secretos durante la construcción

Por qué no utilizar ARG para guardar contraseñas
Cómo usar secretos durante un Docker Build
Cómo utilizar RUN –mount=type=secret
Cómo utilizar claves SSH durante un build
Cómo descargar dependencias privadas de forma segura
Cómo evitar guardar credenciales en las capas

Redes Docker

14. Fundamentos de red

Cómo funciona la red en Docker
Qué es una red bridge
Qué es una red host
Qué es una red none
Cómo crear una red Docker
Cómo conectar contenedores entre sí
Comunicación entre contenedores por nombre
DNS interno de Docker
Cómo conectar un contenedor a varias redes
Errores comunes de red en Docker

15. Puertos en Docker

Diferencias entre EXPOSE y publicar un puerto
Puerto del host y puerto del contenedor
Cómo publicar puertos con -p
Cómo publicar puertos automáticamente con -P
Diferencias entre TCP y UDP
Cómo publicar un puerto solo en localhost
Cómo evitar exponer puertos innecesarios
Qué hacer si un puerto está ocupado

Almacenamiento y persistencia

16. Volúmenes y bind mounts

Por qué los contenedores no guardan datos por defecto
Qué es un volumen Docker
Qué es un bind mount
Qué es un montaje tmpfs
Diferencias entre volumen y bind mount
Cuándo utilizar volumen, bind mount o tmpfs
Cómo crear volúmenes
Cómo montar volúmenes en contenedores
Cómo montar el código local dentro del contenedor
Qué hacer si un volumen no funciona

17. Backups y migración de datos

Cómo hacer una copia de seguridad de un volumen
Cómo restaurar un volumen Docker
Cómo migrar volúmenes entre servidores
Cómo verificar una copia de seguridad
Cómo hacer backups de bases de datos
Cómo eliminar volúmenes de forma segura

Docker Compose

18. Fundamentos de Docker Compose

Qué es Docker Compose
Qué es un archivo Compose YAML
Qué son los servicios en Compose
Comandos básicos de Docker Compose
Cómo levantar y apagar un entorno con Compose
Cómo definir puertos en Compose
Cómo definir variables de entorno en Compose
Cómo definir volúmenes en Compose
Cómo usar archivos .env
Cómo usar depends_on
Cómo utilizar healthchecks
Cómo configurar restart
Cómo configurar logs
Cómo usar imágenes ya construidas

19. Docker Compose avanzado

Cómo usar Compose Override
Cómo combinar varios archivos Compose
Cómo dividir una aplicación en varios archivos
Cómo usar include en Docker Compose
Cómo utilizar Profiles
Cómo utilizar secrets
Cómo utilizar configs
Cómo validar un archivo con docker compose config
Cómo utilizar Docker Compose Dry Run
Cómo escalar servicios con Docker Compose
Cómo configurar recursos en Compose
Cómo gestionar variables por entorno

20. Docker Compose en desarrollo

Cómo usar Docker Compose en desarrollo
Cómo usar hot reload con Docker
Cómo utilizar Docker Compose Watch
Diferencias entre Compose Watch y bind mounts
Entorno de desarrollo con frontend y backend
Cómo montar el código local
Cómo utilizar overrides en desarrollo
Diferencias entre Compose en desarrollo y producción

21. Docker Compose en producción

Docker Compose para producción
Cómo preparar Compose para producción
Cómo gestionar variables de producción
Cómo gestionar secretos en producción
Cómo preparar SSL para producción
Cómo usar Nginx como reverse proxy
Cómo configurar healthchecks
Cómo limitar CPU y memoria
Cómo configurar la rotación de logs
Estrategias de deploy con Docker
Cómo realizar un rollback

Administración de Docker Engine

22. Configuración del daemon

Cómo configurar Docker mediante daemon.json
Cómo validar daemon.json
Dónde guarda Docker las imágenes y los contenedores
Cómo cambiar data-root
Cómo configurar un proxy para Docker Engine
Cómo configurar DNS en Docker
Cómo configurar registry mirrors
Cómo configurar registros inseguros
Qué es live restore
Cómo reiniciar Docker correctamente

23. Logs y observabilidad

Qué son los logging drivers
Diferencias entre json-file y local
Cómo configurar la rotación de logs
Cómo configurar logs por contenedor
Cómo configurar el logging driver global
Cómo utilizar journald
Cómo enviar logs a syslog
Cómo utilizar Fluentd
Cómo evitar que los logs llenen el disco
Cómo monitorizar contenedores con docker stats

24. Mantenimiento y limpieza

Cómo comprobar el espacio utilizado por Docker
Cómo utilizar docker system df
Cómo liberar espacio con docker system prune
Cómo limpiar imágenes sin utilizar
Cómo limpiar contenedores detenidos
Cómo limpiar redes sin utilizar
Cómo limpiar volúmenes de forma segura
Cómo limpiar la caché de BuildKit
Diferencias entre prune y eliminación manual

25. Administración remota

Qué son los Docker Contexts
Cómo listar contextos
Cómo crear un contexto
Cómo cambiar de contexto
Cómo inspeccionar un contexto
Cómo conectarse a Docker mediante SSH
Cómo proteger el acceso remoto al daemon
Cómo exportar e importar contextos

Seguridad en Docker

26. Seguridad básica

Buenas prácticas de seguridad en Docker
Por qué no usar root en contenedores
Cómo crear un usuario dentro del contenedor
Cómo evitar exponer puertos innecesarios
Cómo gestionar secretos
Cómo usar imágenes oficiales de forma segura
Cómo escanear imágenes Docker
Cómo mantener actualizadas las imágenes base
Cómo reducir la superficie de ataque

27. Seguridad avanzada

Qué es Docker Rootless
Diferencias entre USER y Docker Rootless
Por qué el grupo docker concede privilegios elevados
Cómo proteger el socket de Docker
Riesgos de montar docker.sock
Qué son las Linux capabilities
Cómo eliminar capabilities innecesarias
Cómo funciona Seccomp
Cómo funcionan AppArmor y SELinux
Cómo utilizar un sistema de archivos de solo lectura
Cómo utilizar no-new-privileges
Riesgos de utilizar –privileged

28. Seguridad de las imágenes

Cómo generar un SBOM
Qué es la procedencia de una imagen
Qué son las attestations de BuildKit
Cómo adjuntar un SBOM durante la construcción
Cómo firmar imágenes Docker
Cómo verificar la firma de una imagen
Diferencias entre escanear, firmar y generar un SBOM
Cómo fijar dependencias mediante digests

Docker y CI/CD

29. Automatización

Qué papel tiene Docker en CI/CD
Cómo construir imágenes automáticamente
Pipeline básico con GitHub Actions
Pipeline básico con GitLab CI
Cómo subir imágenes a un registry desde CI/CD
Cómo reutilizar la caché de BuildKit
Cómo utilizar secretos en el pipeline
Cómo construir imágenes multiarquitectura
Cómo generar un SBOM desde CI/CD
Cómo escanear una imagen antes de publicarla
Cómo versionar imágenes automáticamente
Cómo realizar un rollback

Solución de problemas

30. Troubleshooting de Docker

Docker Permission Denied
Qué hacer si hay problemas de permisos
Qué hacer si un contenedor se apaga solo
Qué hacer si un puerto está ocupado
Qué hacer si un volumen no funciona
Qué hacer si una base de datos no conecta
Errores comunes al construir imágenes
Errores comunes de red en Docker
Cómo diagnosticar problemas de DNS
Cómo investigar un contenedor detenido
Cómo diagnosticar un Docker Engine que no arranca
Cómo revisar problemas de espacio
Cómo solucionar errores de Docker Compose

Guarda esta página como índice principal del curso de Docker y vuelve a ella cada vez que quieras continuar con el siguiente bloque de aprendizaje.