¿Que es docker y como usarlo para ejecutar contenedores?

Docker es hoy el estándar para empaquetar y ejecutar aplicaciones en contenedores. En esta guía aprenderás qué es Docker, por qué usarlo, cómo instalarlo y cómo ejecutar tus primeros contenedores usando Dockerfile, docker run, docker-compose.yml y volúmenes persistentes. Al final tendrás un entorno reproducible para desarrollo o producción, con buenas prácticas y comandos esenciales.

¿Qué es Docker?

Docker es una plataforma de containerización que empaqueta tu app + dependencias en una imagen. A partir de esa imagen, ejecutas uno o más contenedores que se comportan igual en cualquier máquina con Docker (Linux, Windows, macOS). Así evitas el clásico “en mi PC funciona”.

• Imagen: plantilla inmutable (capas) con SO base + librerías + tu app.
• Contenedor: instancia en ejecución de una imagen (aislada, efímera).
• Registro: repositorio de imágenes (Docker Hub, GitHub Container Registry, etc.).

Beneficios clave

1. Portabilidad: mismo comportamiento en cualquier host con Docker.
2. Aislamiento: cada contenedor tiene sus propias dependencias.
3. Escalabilidad: replicas horizontales fáciles de orquestar.
4. Velocidad: imágenes ligeras, despliegues rápidos (capas cacheadas).
5. Versionado: etiqueta tus imágenes (tags) y realiza rollbacks simples.

Sistemas operativos compatibles

• Linux: soporte nativo (kernel namespaces/cgroups).
• Windows 10/11 y Windows Server 2019+: con Docker Desktop (usa WSL2).
• macOS (Intel/Apple Silicon): con Docker Desktop (máquina ligera Linux).

Flujo básico de trabajo

El ciclo típico es: 1) escribir un Dockerfile, 2) construir una imagen, 3) ejecutar un contenedor con docker run o varios con docker compose, 4) persistir datos con volúmenes.

1) Crear un Dockerfile

Ejemplo mínimo para una app Node.js (servidor HTTP en app.js):

# Dockerfile
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]

Build de la imagen:

docker build -t my-app:1.0.0 .

2) Ejecutar un contenedor

Mapea un puerto del host al contenedor (host:contenedor):

docker run -d --name my-app -p 8080:3000 my-app:1.0.0

Ahora abre http://localhost:8080 para probar tu servicio.

3) Docker Compose (múltiples servicios)

Con docker-compose.yml defines varios contenedores (web + DB), redes y volúmenes en un solo archivo.

# docker-compose.yml
version: "3.9"
services:
  web:
    build: .
    image: my-app:1.0.0
    container_name: web
    ports:
      - "8080:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=mysql://user:pass@db:3306/appdb
    depends_on:
      - db
  db:
    image: mysql:8.0
    container_name: db
    ports:
      - "3306:3306"
    environment:
      - MYSQL_DATABASE=appdb
      - MYSQL_USER=user
      - MYSQL_PASSWORD=pass
      - MYSQL_ROOT_PASSWORD=rootpass
    volumes:
      - db_data:/var/lib/mysql
volumes:
  db_data:

Arranca todo en segundo plano:

docker compose up -d

4) Volúmenes persistentes

Los datos dentro del contenedor son efímeros. Usa volúmenes para persistirlos más allá del ciclo de vida del contenedor (ideal para bases de datos, uploads, etc.).

# Crear un volumen
docker volume create my_data

# Montarlo al arrancar un contenedor
docker run -d --name mysql \
  -e MYSQL_ROOT_PASSWORD=rootpass \
  -v my_data:/var/lib/mysql \
  -p 3306:3306 mysql:8.0

Ejemplo real: PHP 8 + Apache + extensiones

Este Dockerfile prepara un entorno PHP con Apache, extensiones y módulos listos para apps típicas (MySQL, GD, Zip, reescrituras):

# Dockerfile (PHP + Apache)
FROM php:8.0-apache

ARG DEBIAN_FRONTEND=noninteractive

# Extensiones PHP
RUN docker-php-ext-install mysqli

# Paquetes del sistema
RUN apt-get update && apt-get install -y \
    sendmail libpng-dev libzip-dev zlib1g-dev libonig-dev \
  && rm -rf /var/lib/apt/lists/*

# Más extensiones
RUN docker-php-ext-install zip mbstring gd

# Habilitar mod_rewrite
RUN a2enmod rewrite

# Copia de tu app (public) a /var/www/html si aplica
# COPY ./public/ /var/www/html

Variables de entorno con .env

Guarda secretos y configuraciones en un archivo .env (no lo subas al repositorio). Ejemplo:

# .env (ejemplo)
DATABASE_CLIENT=mysql
DATABASE_HOST=db
DATABASE_PORT=3306
DATABASE_NAME=appdb
DATABASE_USERNAME=user
DATABASE_PASSWORD=pass
NODE_ENV=production
APP_ENVIRONMENT=production

En docker-compose.yml puedes referenciarlo así:

environment:
  - DATABASE_URL=mysql://${DATABASE_USERNAME}:${DATABASE_PASSWORD}@${DATABASE_HOST}:${DATABASE_PORT}/${DATABASE_NAME}

Comandos imprescindibles

# Listar contenedores en ejecución
docker ps

# Listar TODOS (incluye detenidos)
docker ps -a

# Ver logs de un contenedor
docker logs -f NOMBRE

# Entrar a un contenedor (shell)
docker exec -it NOMBRE sh   # o bash

# Parar, arrancar, eliminar
docker stop NOMBRE
docker start NOMBRE
docker rm NOMBRE

# Compose: levantar y bajar
docker compose up -d
docker compose down

Buenas prácticas y seguridad

• Usa imágenes oficiales o de confianza y fija versiones (tags) concretos.
• Minimiza la imagen (por ejemplo, alpine) y elimina cachés en el build.
• No guardes secretos en imágenes; usa variables/secretos del orquestador.
• Expón solo los puertos necesarios y limita permisos de usuario.
• Haz backup de tus volúmenes si contienen datos críticos (DB, uploads).

Conclusión

Docker simplifica el desarrollo y despliegue: empaquetas una vez y ejecutas en cualquier lugar. Con Dockerfile, compose y volúmenes persistentes puedes levantar entornos completos en minutos, reproducibles y escalables. Integra estos conceptos a tu flujo de trabajo y notarás mejoras inmediatas en velocidad, consistencia y portabilidad.

Repositorio de ejemplo: Docker + WordPress