0Pricing
PHP Academy · Lección

Docker Compose para entornos locales

Ejecute PHP, una base de datos y una caché juntos en local

Docker Compose para entornos locales es una lección gratuita de PHP Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de PHP Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de PHP Academy incluye 4 lecciones en total.

Stacks locales con Compose

Las aplicaciones PHP reales nunca son solo PHP: necesitan una base de datos, una caché y, a veces, una cola y un capturador de correo. Docker Compose declara todos estos componentes como servicios en un solo archivo y los conecta a una red compartida para que puedan encontrarse por nombre.

En esta lección creará un stack local completo: PHP-FPM + nginx + MySQL + Redis, con volúmenes, comprobaciones de estado y orden de dependencias.

Estructura básica de los servicios

Un archivo de Compose enumera los servicios bajo services:. Cada uno puede compilarse mediante build a partir de un Dockerfile o descargar una image. Compose crea una red predeterminada en la que cada servicio está disponible mediante su clave: su aplicación PHP se conecta a MySQL usando el host db, no localhost.

services:
  app:
    build:
      context: .
      target: dev          # multi-stage dev target
    volumes:
      - ./:/app            # live code mount
    depends_on:
      db:
        condition: service_healthy
  db:
    image: mysql:8.4
  redis:
    image: redis:7-alpine

nginx delante de FPM

FPM se comunica mediante FastCGI por el puerto 9000, no mediante HTTP. nginx termina las conexiones HTTP y reenvía las solicitudes .php a app:9000. La configuración de nginx hace referencia al servicio PHP mediante su nombre de Compose.

# docker/nginx/default.conf
server {
  listen 80;
  root /app/public;
  index index.php;

  location / {
    try_files $uri /index.php?$query_string;
  }

  location ~ \.php$ {
    fastcgi_pass app:9000;       # service name from compose
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include fastcgi_params;
  }
}

Configuración del servicio web

El servicio nginx monta el mismo código, para resolver SCRIPT_FILENAME, y la configuración; publica el puerto 80 y depende de app. Ambos comparten /app para que las rutas coincidan a ambos lados de FastCGI.

services:
  web:
    image: nginx:1.27-alpine
    ports:
      - "8080:80"
    volumes:
      - ./:/app:ro
      - ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - app

Volúmenes persistentes

Los sistemas de archivos de los contenedores son efímeros. Los volúmenes con nombre conservan los archivos de la base de datos después de ejecutar docker compose down. Los bind mounts (./:/app) sincronizan en tiempo real el código del host durante el desarrollo. Use volúmenes con nombre para los datos con estado y bind mounts para el código fuente.

services:
  db:
    image: mysql:8.4
    environment:
      MYSQL_DATABASE: app
      MYSQL_USER: app
      MYSQL_PASSWORD: secret
      MYSQL_ROOT_PASSWORD: rootsecret
    volumes:
      - dbdata:/var/lib/mysql

volumes:
  dbdata:        # survives `down`, removed only by `down -v`

Comprobaciones de estado y depends_on

depends_on por sí solo solo espera a que el contenedor se inicie, no a que MySQL acepte conexiones. Añada un healthcheck y use condition: service_healthy para que su aplicación espere hasta que la base de datos esté realmente lista.

services:
  db:
    image: mysql:8.4
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-prootsecret"]
      interval: 5s
      timeout: 3s
      retries: 10
  app:
    build: .
    depends_on:
      db:
        condition: service_healthy   # waits for healthcheck pass

Entorno y .env

Compose carga automáticamente un archivo .env contiguo para interpolar variables, y permite pasar la configuración de la aplicación mediante environment o env_file. Mantenga los secretos fuera del archivo de Compose confirmado en el repositorio; haga referencia a variables en su lugar.

services:
  app:
    build: .
    env_file:
      - .env
    environment:
      DATABASE_URL: "mysql://app:secret@db:3306/app"
      REDIS_URL: "redis://redis:6379"
# .env (gitignored) provides ${...} substitutions
#   MYSQL_PASSWORD=secret

Conexión desde PHP

Dentro de la red, los nombres de host son los nombres de los servicios. Su código PHP se conecta directamente a db y redis. Este fragmento analiza un DSN como lo haría una capa de configuración y muestra cómo el nombre del servicio de Compose llega a la cadena de conexión.

<?php
$dsn = 'mysql://app:secret@db:3306/app';
$p = parse_url($dsn);

printf("driver: %s\n", $p['scheme']);
printf("host:   %s\n", $p['host']);   // 'db' resolves via compose DNS
printf("port:   %d\n", $p['port']);
printf("db:     %s\n", ltrim($p['path'], '/'));

$pdoDsn = sprintf('mysql:host=%s;port=%d;dbname=%s', $p['host'], $p['port'], ltrim($p['path'], '/'));
echo $pdoDsn . PHP_EOL;
?>

Xdebug para desarrollo local

Monte la configuración de Xdebug solo localmente, mediante el destino de compilación dev. Apunte client_host a host.docker.internal para que el depurador pueda llegar a su IDE en el host. Nunca incluya Xdebug en producción: reduce drásticamente el rendimiento.

; docker/php/xdebug.ini  (mounted only in dev)
zend_extension=xdebug
xdebug.mode=debug
xdebug.start_with_request=yes
xdebug.client_host=host.docker.internal
xdebug.client_port=9003

Ejecución de comandos puntuales

docker compose run inicia un contenedor efímero para migraciones, pruebas o Composer; exec ejecuta comandos dentro de un servicio que ya está en ejecución. Use run --rm para estas tareas, de modo que el contenedor desechable se elimine al terminar.

# Run migrations against the running db
docker compose exec app php bin/console doctrine:migrations:migrate

# One-off: install deps without a long-lived container
docker compose run --rm app composer install

# Tail logs of just the web service
docker compose logs -f web

Archivos de override

Compose combina automáticamente docker-compose.yml con docker-compose.override.yml. Mantenga los valores predeterminados orientados a producción en el archivo base y coloque los volúmenes, puertos y Xdebug exclusivos de desarrollo en el override; así, CI utiliza el archivo base y los desarrolladores obtienen extras automáticamente.

# docker-compose.override.yml (auto-merged, dev only)
services:
  app:
    volumes:
      - ./docker/php/xdebug.ini:/usr/local/etc/php/conf.d/xdebug.ini:ro
    environment:
      APP_ENV: dev
# CI runs: docker compose -f docker-compose.yml up  (no override)

Comprobación rápida

¿Por qué no es suficiente un depends_on: [db] simple antes de ejecutar las migraciones?

Resumen

Ensambló un stack local con Compose: PHP-FPM detrás de nginx, con FastCGI hacia app:9000; MySQL y Redis disponibles mediante el nombre del servicio; volúmenes con nombre para la persistencia; comprobaciones de estado que condicionan depends_on; configuración basada en variables de entorno; Xdebug en un override exclusivo de desarrollo; y comandos puntuales mediante run/exec.

Recuerde: los nombres de servicio son nombres de host DNS, los archivos de override mantienen los extras de desarrollo fuera de CI y las comprobaciones de estado son mejores que un orden de inicio ingenuo.

Preguntas frecuentes

¿La lección «Docker Compose para entornos locales» es gratis?

Sí — el texto completo de «Docker Compose para entornos locales» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de PHP Academy, actualiza a CoddyKit PRO. El curso de PHP Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Docker Compose para entornos locales»?

Ejecute PHP, una base de datos y una caché juntos en local Practicas PHP Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar PHP Academy?

No se requiere experiencia previa. PHP Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Docker Compose para entornos locales»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de PHP Academy?

Sí. Cada lección de PHP Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Contenerización de una aplicación PHP
  2. Compilaciones multietapa y optimización
  3. Docker Compose para entornos locales
  4. CI/CD con GitHub Actions
← Volver a PHP Academy