Creación del archivo docker-compose.yml

Este tutorial guía la creación del archivo docker-compose.yml para orquestar múltiples servicios (contenedores) que trabajarán juntos en el proyecto Laravel.

📁 Pasos principales

1. Corrección de errores en el Dockerfile

Se detecta un error de sintaxis (falta un guion en apt-get)
Se corrige y guarda el archivo Dockerfile

2. Creación del archivo docker-compose.yml

Se crea el archivo con:
bash
```
nano docker-compose.yml
```

3. Especificación de la versión

Se define la versión del archivo de composición:
yaml
```
version: '3'
```

4. Definición de servicios

Se crea la sección services para listar los contenedores

5. Configuración del servicio de la aplicación (app)

Nombre del servicio: app
Construcción de la imagen:
- Se especifican los argumentos user y uid (obtenidos con id -u):
  yaml
```
args:
  user: udemy
  uid: 1000
```
- Se indica el contexto (directorio actual) y el Dockerfile a usar
- Se asigna un nombre a la imagen: laravel-app
Política de reinicio:
- restart: unless-stopped (reinicia si se detiene por error)
Directorio de trabajo:
- working_dir: /var/www

6. Configuración de volúmenes (bind mounts)

Se comparte el directorio local con el contenedor:
yaml
```
volumes:
  - ./:/var/www
```
Esto permite que los cambios en el código local se reflejen automáticamente en el contenedor

7. Configuración de red

Se define una red tipo bridge llamada laravel
Se asigna el servicio app a esa red:
yaml
```
networks:
  - laravel
```

8. Definición de la red

Se declara la red con el driver bridge:
yaml
```
networks:
  laravel:
    driver: bridge
```
Esto permite la comunicación entre contenedores (app, MySQL, Nginx)

✅ Puntos más importantes destacados

Se crea el archivo docker-compose.yml para gestionar múltiples contenedores de forma orquestada.
Se pasan argumentos al Dockerfile (user y uid) desde el docker-compose para crear el usuario dentro del contenedor.
Se crea un volumen compartido (bind mount) entre el directorio local y /var/www en el contenedor, para sincronizar el código.
Se configura una red tipo bridge para que los contenedores puedan comunicarse entre sí (app, base de datos, servidor web).
Se establece el directorio de trabajo en /var/www, que es donde estará el proyecto Laravel.
El contenedor se reiniciará automáticamente si se detiene inesperadamente (unless-stopped).

El tutorial finaliza indicando que en el siguiente vídeo se probará el funcionamiento del docker-compose y se comenzará con la instalación de Laravel

Crear el Archivo docker-compose.yml para el Entorno Laravel

En este tutorial vamos a crear el archivo docker-compose.yml que orquestará todos los servicios necesarios para nuestro proyecto Laravel. Este archivo definirá cómo construir la imagen personalizada de PHP, qué volúmenes compartir, cómo se comunicarán los contenedores y las políticas de reinicio.

Objetivo: Tener un archivo docker-compose.yml funcional y actualizado que sirva como base para levantar el entorno completo (PHP-FPM, Nginx, MySQL).

Requisitos Previos

Tener Docker y Docker Compose (plugin) instalados y funcionando.
Tener el archivo Dockerfile creado en el directorio laravel/.
Conocer el UID de tu usuario en el sistema host (lo usaremos para mapear permisos).

Paso 1: Obtener el UID del Usuario del Host

Dentro del contenedor, crearemos un usuario con el mismo UID que tu usuario en el sistema host para evitar problemas de permisos con los archivos compartidos.

Ejecuta en tu máquina virtual (o local, según donde estés trabajando):

id -u

O bien:

echo $UID

Anota este número. En el ejemplo del video era 1000, pero puede variar.

Paso 2: Crear el Archivo docker-compose.yml

Dentro del directorio laravel/ (donde está tu Dockerfile), crea el archivo de composición:

nano docker-compose.yml

A continuación, copia y pega el siguiente contenido. Lee las explicaciones para entender cada sección.

Contenido de docker-compose.yml (Versión Mejorada)

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        USER: laravel        # Cambia por tu usuario si es diferente
        UID: 1000            # Reemplaza con el UID de tu usuario host
    image: laravel-app:latest
    container_name: laravel_app
    restart: unless-stopped
    working_dir: /var/www
    volumes:
      - ./src:/var/www    # Monta el código fuente de Laravel
    networks:
      - laravel-network

  # (Opcional) Aquí se añadirán después Nginx y MySQL

networks:
  laravel-network:
    driver: bridge

Explicación Línea por Línea

Línea / Bloque	Instrucción	Explicación
`services:`	Inicio de los servicios	Define los contenedores que se van a levantar.
`app:`	Nombre del servicio	Es el servicio principal que contiene nuestra aplicación PHP-FPM.
`build:`	Configuración de construcción	Indica cómo construir la imagen a partir del Dockerfile.
`context: .`	Contexto de construcción	El directorio actual (donde está el `Dockerfile`) es el contexto de construcción.
`dockerfile: Dockerfile`	Archivo a usar	Especifica el nombre del Dockerfile (por defecto ya es `Dockerfile`, pero se deja explícito).
`args:`	Argumentos de construcción	Pasa variables al Dockerfile (en este caso, `USER` y `UID`).
`image: laravel-app:latest`	Nombre de la imagen	Asigna un nombre y etiqueta a la imagen resultante.
`container_name: laravel_app`	Nombre del contenedor	Opcional, pero útil para referirse al contenedor por nombre.
`restart: unless-stopped`	Política de reinicio	Reinicia el contenedor a menos que se detenga explícitamente.
`working_dir: /var/www`	Directorio de trabajo	Se sobreescribe si ya está definido en el Dockerfile (pero es buena práctica dejarlo).
`volumes:`	Volúmenes compartidos	Mapea el directorio local `./src` (código fuente) al directorio de trabajo del contenedor `/var/www`.
`networks:`	Redes	Conecta el contenedor a la red definida abajo.
`networks:` (global)	Definición de redes	Crea una red de tipo `bridge` llamada `laravel-network` para que los contenedores se comuniquen.

Nota sobre ./src: Asegúrate de que el directorio src exista en tu máquina (o créalo con mkdir src). Ahí colocarás el código de Laravel.

Paso 3: (Opcional) Ampliar con Más Servicios

En el siguiente paso del curso se añadirán servicios como Nginx y MySQL. Para que tengas una visión más completa, aquí te muestro cómo se vería el archivo con esos servicios (lo veremos en detalle más adelante):

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        USER: laravel
        UID: 1000
    image: laravel-app:latest
    container_name: laravel_app
    restart: unless-stopped
    working_dir: /var/www
    volumes:
      - ./src:/var/www
    networks:
      - laravel-network

  nginx:
    image: nginx:alpine
    container_name: laravel_nginx
    restart: unless-stopped
    ports:
      - "80:80"
    volumes:
      - ./src:/var/www
      - ./nginx/conf.d:/etc/nginx/conf.d
    networks:
      - laravel-network

  mysql:
    image: mysql:8.0
    container_name: laravel_mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: laravel
      MYSQL_USER: laravel
      MYSQL_PASSWORD: secret
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - laravel-network

volumes:
  db_data:

networks:
  laravel-network:
    driver: bridge

Paso 4: Verificar la Sintaxis del Archivo

Antes de levantar los contenedores, es recomendable validar que la sintaxis del archivo YAML sea correcta:

docker compose config

Este comando muestra la configuración compilada y te avisará de errores de sintaxis.

Paso 5: Construir y Levantar el Contenedor (Prueba)

Para construir la imagen y levantar el contenedor app (en modo detached):

docker compose up -d app

Comando actual: Usamos docker compose (con espacio) en lugar del antiguo docker-compose (con guion). Esto se debe a que ahora es un plugin integrado en Docker.

Si todo funciona correctamente, verás que la imagen se construye y el contenedor se inicia.

Para verificar el estado:

docker compose ps

Para ver los logs del contenedor:

docker compose logs app

Paso 6: Detener y Eliminar los Contenedores (si es necesario)

Para detener el servicio sin eliminarlo:

docker compose stop app

Para detener y eliminar el contenedor (y la red si no se usa):

docker compose down

Novedades y Actualizaciones con Respecto al Video Original

El archivo del video presentaba algunos aspectos que han evolucionado. Aquí las diferencias clave:

Aspecto	En el video (original)	Práctica actual / Mejora
Comando de Compose	`docker-compose` (con guion)	`docker compose` (plugin integrado, sin guion). Es el estándar desde Docker 20.10+.
Versión del archivo	`version: '3'` (obligatoria)	Se omite la versión. Docker Compose V2 ya no la requiere; usa el formato más moderno sin declaración de versión.
Definición de redes	Se usa `networks` con driver `bridge` explícito.	Es correcto, aunque se puede omitir `driver` ya que `bridge` es el predeterminado.
Política de reinicio	`unless-stopped`	Válido y recomendado. También se usa `always` o `on-failure`.
Manejo de variables	`USER` y `UID` pasados como `args`.	Correcto. Se puede mejorar usando un archivo `.env` para pasar estas variables.
Nombre del contenedor	No se especifica.	Se recomienda usar `container_name` para identificar fácilmente el contenedor.
Volumen de código	Se monta el directorio actual (`.:/var/www`).	Se recomienda usar `./src:/var/www` para separar el código fuente del proyecto de los archivos de configuración de Docker.
Validación	No se valida.	Ahora se puede usar `docker compose config` para verificar la sintaxis.
Inicio del servicio	No se muestra.	Se usa `docker compose up -d` para iniciar en segundo plano.

Otras Buenas Prácticas

Variables de entorno: Puedes usar un archivo .env para definir variables como UID y USER, y referenciarlas en el docker-compose.yml con ${UID}.
Redes externas: Si necesitas conectar contenedores de diferentes proyectos, define la red como external: true.
Healthchecks: Añade verificaciones de salud a tus servicios para monitorear su estado.
Perfiles: Usa perfiles para servicios que solo quieras levantar en desarrollo o producción.

Comandos Útiles y Actualizados

Acción	Comando antiguo	Comando actual (plugin)
Construir servicios	`docker-compose build`	`docker compose build`
Levantar servicios	`docker-compose up -d`	`docker compose up -d`
Ver logs	`docker-compose logs -f`	`docker compose logs -f`
Detener servicios	`docker-compose stop`	`docker compose stop`
Eliminar servicios	`docker-compose down`	`docker compose down`
Ejecutar comando en contenedor	`docker-compose exec app bash`	`docker compose exec app bash`

Próximos Pasos

Con este archivo docker-compose.yml ya tienes la base para orquestar tu entorno Laravel. En el siguiente paso del curso añadirás los servicios de Nginx y MySQL, y podrás levantar todo el stack completo con un solo comando.

¡Ya tienes un archivo docker-compose.yml moderno y funcional, preparado para tu proyecto Laravel con Docker

Buscar este blog

SOTELO-DOCKER

10 Crear Archivo Docker Compose Parte 1