Saltar al contenido principal

Preparación del entorno de desarrollo

Contar con un entorno de desarrollo que refleje el de producción es crucial para garantizar que las aplicaciones funcionen correctamente una vez desplegadas. Aquí es donde Docker y Docker Compose juegan un papel fundamental.

Introducción a Docker y Docker Compose​

Docker es una plataforma que permite empaquetar aplicaciones y sus dependencias en contenedores, asegurando que se ejecuten de manera consistente en cualquier entorno. Docker Compose es una herramienta que simplifica la ejecución de aplicaciones multicontenedor mediante la definición de servicios en un archivo de configuración.

Instalación y configuración de Docker​

Para instalar Docker:

  1. Descargue e instale Docker Desktop desde el sitio web oficial para su sistema operativo.

  2. Tras la instalación, verifique que Docker funciona correctamente ejecutando en la terminal:

    docker --version

    Debería mostrar la versión instalada de Docker.

Creación de contenedores con Docker Compose​

Para ejecutar contenedores con Docker Compose, el punto de partida siempre es un fichero compose.yml, que es el fichero que contiene las instrucciones para la ejecución de los contenedores. Se trata de un fichero YAML, por lo que la identación es muy importante. También se puede nombrar docker-compose.yml.

LAMP​

Vamos a levantar un entorno LAMP con Docker Compose. Para ello, debemos crear un fichero compose.yml con el siguiente contenido:

services:
  # https://hub.docker.com/_/php/
  php:
    image: php:8.3.12-apache-bullseye
    restart: unless-stopped
    volumes:
      - ./www:/var/www/html
    ports:
      - 80:80
    depends_on:
      - mysql

  # https://hub.docker.com/_/mysql
  mysql:
    image: mysql:9.0.1
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: app
      MYSQL_USER: user
      MYSQL_PASSWORD: abc123.
      MYSQL_ROOT_PASSWORD: abc123.
    volumes:
      - mysql_data:/var/lib/mysql
    ports: 
      - 3306:3306
  
  # https://hub.docker.com/_/phpmyadmin
  phpmyadmin:
    image: phpmyadmin:5.2.1-apache
    restart: unless-stopped
    links:
      - mysql
    depends_on:
      - mysql
    ports:
      - 8000:80
    environment:
      PMA_HOST: mysql
      PMA_PORT: 3306
      PMA_ARBITRARY: 1

volumes:
  mysql_data:

A continuación, ejecutamos el siguiente comando para iniciar los servicios:

docker compose up -d

Este compose.yml define un entorno de desarrollo con los siguientes servicios:

  • PHP: Utiliza la imagen php:8.3.12-apache-bullseye, expone el puerto 80 para acceder vía HTTP, y monta un volumen local para los archivos de la aplicación PHP (los ficheros .php se deben colocar en el directorio www). Depende de MySQL.
  • MySQL: Usa la imagen mysql:9.0.1 y monta un volumen mysql_data para persistir los datos de MySQL. Expone el puerto 3306.
  • phpMyAdmin: Interfaz gráfica web para gestionar MySQL, expuesta en el puerto 8000. Depende de MySQL.

Node.js​

No es requisito definir más de un contenedor en un compose.yml. Podemos definir uno solo y, también, opcionalmente combinarlo con un Dockerfile.

Si queremos ejecutar un servidor Node.js, podemos definir los siguientes ficheros (deben estar en el mismo directorio):

Dockerfile
FROM node:20.18-bullseye
WORKDIR /app
COPY . .
RUN npm install -g nodemon
EXPOSE 3000
CMD ["nodemon", "server.js"]
compose.yml
services:
  # https://hub.docker.com/_/node
  node:
    build: .
    volumes:
      - ./app:/app
    environment:
      - NODE_ENV=development
    ports:
      - 3000:3000

A continuación, ejecutamos el siguiente comando para levantar el servicio:

docker compose up -d --build

Python​

Si queremos ejecutar un servidor en Python, podemos definir los siguientes ficheros (deben estar en el mismo directorio):

Dockerfile
FROM python:3.13.0-bullseye
WORKDIR /app
RUN pip install watchdog
EXPOSE 4000
CMD ["watchmedo", "auto-restart", "--patterns=*.py", "--recursive", "--", "python3", "/app/server.py"]
compose.yml
services:
  # https://hub.docker.com/_/python
  python:
    build: .
    volumes:
      - ./app:/app
    ports:
      - 4000:4000

A continuación, ejecutamos el siguiente comando para levantar el servicio:

docker compose up -d --build

Java​

Si queremos ejecutar un servidor en Java, podemos definir un fichero compose.yml:

compose.yml
services:
  # https://hub.docker.com/_/openjdk
  java:
    image: openjdk:24
    volumes:
      - ./app:/app
    working_dir: /app
    command: bash -c "javac Server.java && java Server" 
    ports:
      - 5000:5000

A continuación, ejecutamos el siguiente comando para levantar el servicio:

docker compose up -d

Cómo usar Docker Compose​

Configuración del entorno de desarrollo​

Los volúmenes definidos permiten que trabajes en tu máquina local (host), pero los cambios se reflejan inmediatamente dentro de los contenedores. Esto significa que puedes editar archivos PHP o Node.js en tu editor y ver los resultados de inmediato, sin necesidad de reiniciar los contenedores.

Arrancar los servicios​

Para arrancar los servicios definidos en un compose.yml, en el mismo directorio donde se encuentra, ejecutamos:

docker compose up
Versiones antiguas de Docker Compose

En las versiones antiguas de Docker Compose, el comando lleva un guión medio. Es decir, sería el siguiente:

docker-compose up

Este comando iniciará todos los servicios y tendremos nuestro stack listo para el desarrollo, pero tiene un problema. Si cerramos la terminal, todos los servicios se detendrán. Por lo tanto, lo que buscamos es que los contenedores corran en segundo plano. Para ello, podemos añadir la opción -d:

docker compose up -d

Este será el comando que utilizaremos de forma más habitual.

Si el stack incluye un fichero Dockerfile, este se debe interpretar para la construcción de una imagen. Esto sólo se hará la primera vez, pero no las siguientes veces que se levanten servicios. Si queremos forzar que siempre se realice la construcción de la imagen, debemos ejecutar el siguiente comando:

docker compose up -d --build

Detener los servicios​

Podemos detener los contenedores con:

docker compose down

Esto detendrá y eliminará los contenedores, pero preservará los datos que estén almacenados en volúmenes o en los directorios locales del alfitrión (host).