La sintaxis en docker-compose.yml es:
volumes: - ./ruta/local:/ruta/en/contenedor

El . significa "busca el Dockerfile en la carpeta actual".

¿Qué hace - ./:/var/www/html?

./ es la carpeta actual de tu host (donde está el docker-compose.yml).
/var/www/html es la ruta dentro del contenedor.
Efecto: Todo lo que esté en ./ se ve dentro del contenedor en /var/www/html, y todo lo que se cree dentro del contenedor en /var/www/html aparecerá automáticamente en tu ./. Es una sincronización bidireccional y en tiempo real.

El "bind mount" (volumes: - ./:/var/www/html) es el corazón de la sincronización entre tu PC y el contenedor.

Creación del Dockerfile para Laravel

Este tutorial guía la creación de un Dockerfile personalizado para un proyecto Laravel 8, utilizando PHP 7.4 y configurando el entorno completo con todas las extensiones y dependencias necesarias.

📁 Pasos principales

1. Creación del directorio de trabajo

Se verifica la ruta actual con pwd
Se crea un directorio llamado laravel dentro del home del usuario
Se navega dentro de ese directorio

2. Creación del archivo Dockerfile

Se crea el archivo con:
bash
```
nano Dockerfile
```

3. Configuración de la imagen base

Se usa la imagen oficial de PHP 7.4-fpm:
dockerfile
```
FROM php:7.4-fpm
```

4. Definición de argumentos (variables)

Se definen dos argumentos que se pasarán al construir la imagen:
- user → nombre del usuario
- uid → ID del usuario

5. Instalación de paquetes del sistema

Se actualiza e instalan paquetes esenciales con apt-get:
- curl
- libpng-dev
- libonig-dev
- libxml2-dev
- zip
- unzip

6. Limpieza de caché para reducir el tamaño del contenedor

Se limpia el caché de apt-get:
bash
```
apt-get clean
```
Se eliminan archivos temporales de /var/lib/apt/lists/*

7. Instalación de extensiones de PHP necesarias para Laravel

Se instalan extensiones con docker-php-ext-install:

pdo_mysql (base de datos)
mbstring
exif
pcntl
bcmath
gd

8. Instalación de Composer

Se descarga la última versión de Composer desde Docker
Se copia el binario a /usr/bin/composer

9. Creación del usuario y grupo

Se crea un usuario con el nombre y UID pasados como argumento
Se agrega al grupo www-data y al grupo root
Se asigna el directorio home: /home/<usuario>

10. Asignación de permisos al directorio home

Se crea el directorio /home/<usuario>
Se cambia el propietario recursivamente con:
bash
```
chown -R <user>:<user> /home/<user>
```

11. Configuración del directorio de trabajo

Se establece el directorio de trabajo del contenedor:
dockerfile
```
WORKDIR /var/www
```
Se usa el usuario creado para ejecutar los comandos

✅ Puntos más importantes destacados

Se crea un Dockerfile personalizado desde cero para adaptarlo a Laravel.
Se usa PHP 7.4-fpm como imagen base (necesaria para Laravel 8).
Se instalan extensiones clave como pdo_mysql, mbstring, gd, etc.
Se limpia la caché para mantener el contenedor liviano.
Se instala Composer dentro del contenedor.
Se crea un usuario no root para mejorar la seguridad y buenas prácticas.
El directorio de trabajo es /var/www, donde estará el código de Laravel.

El tutorial finaliza indicando que en el siguiente vídeo se creará el archivo docker-compose.yml con configuraciones más avanzadas como Nginx y MySQL

*************************************

Crear un Dockerfile para un Proyecto Laravel con PHP

Este tutorial te guiará en la creación de un Dockerfile personalizado para ejecutar una aplicación Laravel en un contenedor. El archivo que vamos a construir define una imagen basada en PHP con todas las extensiones necesarias, Composer y un usuario no root para mayor seguridad.

Objetivo: Tener una imagen Docker lista para usar con Laravel, que luego integraremos con otros servicios (Nginx, MySQL) mediante Docker Compose.

Requisitos Previos

Tener Docker instalado y funcionando (siguiendo el tutorial anterior).
Conocimientos básicos de línea de comandos.
Editor de texto (nano, vim, etc.) disponible en el servidor.

Paso 1: Crear el Directorio de Trabajo

Vamos a organizar nuestro proyecto en un directorio específico. Desde tu sesión SSH (o consola de la máquina virtual), ejecuta:

# Verificar la ruta actual
pwd
# Salida esperada: /home/tu_usuario

# Crear el directorio del proyecto
mkdir laravel
cd laravel

Paso 2: Crear el Archivo Dockerfile

Dentro del directorio laravel, crea un archivo llamado Dockerfile (sin extensión):

nano Dockerfile

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

Contenido del Dockerfile (Versión Mejorada)

# 1. Imagen base: PHP 8.2 con FPM (recomendado para Laravel 10/11)
FROM php:8.2-fpm

# 2. Argumentos para el usuario (se pasan al construir la imagen)
ARG USER=laravel
ARG UID=1000

# 3. Instalar dependencias del sistema y extensiones de PHP
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# 4. Instalar extensiones de PHP necesarias para Laravel
RUN docker-php-ext-install \
    pdo_mysql \
    mbstring \
    exif \
    pcntl \
    bcmath \
    gd

# 5. Instalar Composer (globalmente)
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# 6. Crear un usuario no root (para seguridad)
RUN useradd -G www-data,root -u ${UID} -d /home/${USER} ${USER} \
    && mkdir -p /home/${USER}/.composer \
    && chown -R ${USER}:${USER} /home/${USER}

# 7. Establecer el directorio de trabajo
WORKDIR /var/www

# 8. Cambiar al usuario creado (a partir de aquí se ejecuta con ese usuario)
USER ${USER}

# 9. Comando por defecto (opcional, se puede sobrescribir en docker-compose)
CMD ["php-fpm"]

Versión con PHP 8.3 (Recomendado para Laravel 12)

FROM php:8.3-fpm

ARG user
ARG uid

# Instalación de dependencias del sistema
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip \
    libzip-dev \
    libpq-dev \
    libcurl4-openssl-dev \
    libssl-dev \
    && apt-get clean && rm -rf /var/lib/apt/lists/*

# Instalación de extensiones PHP necesarias para Laravel 12
RUN docker-php-ext-install \
    pdo_mysql \
    mysqli \
    mbstring \
    exif \
    pcntl \
    bcmath \
    gd \
    zip \
    && docker-php-ext-enable pdo_mysql

# Instalación de Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Creación de usuario
RUN useradd -G www-data,root -u $uid -d /home/$user $user
RUN mkdir -p /home/$user/.composer && \
    chown -R $user:$user /home/$user

# Establecer directorio de trabajo
WORKDIR /var/www

USER $user

Explicación Línea por Línea

Línea	Instrucción	Explicación
`FROM php:8.2-fpm`	Imagen base	Usamos la versión oficial de PHP 8.2 con FPM (FastCGI Process Manager). Es la versión recomendada para las últimas versiones de Laravel.
`ARG USER=laravel`	Argumento	Define el nombre de usuario que se creará dentro del contenedor. Por defecto `laravel`.
`ARG UID=1000`	Argumento	Define el UID (identificador de usuario) para mapear con el usuario del host.
`RUN apt-get update ...`	Instalación de paquetes	Actualiza la lista de paquetes e instala herramientas esenciales: `git`, `curl`, `libpng-dev` (para GD), `libonig-dev` (para mbstring), `libxml2-dev`, `zip` y `unzip`. Luego limpia la caché para reducir el tamaño de la imagen.
`RUN docker-php-ext-install ...`	Extensiones PHP	Instala las extensiones nativas de PHP requeridas por Laravel: `pdo_mysql` (conexión a MySQL), `mbstring` (manejo de cadenas), `exif` (metadatos de imágenes), `pcntl` (procesos), `bcmath` (matemáticas de precisión) y `gd` (manipulación de imágenes).
`COPY --from=composer:latest ...`	Instalar Composer	Copia el binario de Composer desde la imagen oficial de Composer. Es la forma más limpia y actualizada de instalar Composer sin necesidad de descargarlo manualmente.
`RUN useradd ...`	Crear usuario	Crea un usuario con el nombre y UID especificados, lo añade a los grupos `www-data` y `root`, y establece su directorio home. También crea el directorio `.composer` para almacenar la configuración de Composer y asigna los permisos adecuados.
`WORKDIR /var/www`	Directorio de trabajo	Todos los comandos posteriores (y el punto de montaje de volúmenes) se ejecutarán en `/var/www`. Es el directorio donde residirá el código de Laravel.
`USER ${USER}`	Cambiar de usuario	A partir de aquí, todos los comandos (incluso el CMD) se ejecutarán con el usuario no root, mejorando la seguridad.
`CMD ["php-fpm"]`	Comando por defecto	Inicia el proceso PHP-FPM. Este comando se puede sobrescribir en el archivo `docker-compose.yml`.

Paso 3: Guardar y Construir la Imagen

Guarda el archivo (en nano: Ctrl+O, Enter, Ctrl+X).
Construye la imagen con el siguiente comando (asegúrate de estar en el directorio laravel):

docker build -t laravel-php:latest .

El punto (.) indica que el contexto de construcción es el directorio actual. El flag -t asigna un nombre y etiqueta a la imagen.

Si deseas personalizar el usuario y UID, puedes pasarlos como argumentos:

docker build --build-arg USER=mi_usuario --build-arg UID=1001 -t laravel-php:latest .

Paso 4: Verificar la Imagen Creada

Lista las imágenes para confirmar que la nueva imagen existe:

docker images

Deberías ver laravel-php en la lista.

También puedes probar la imagen ejecutando un contenedor temporal y verificando la versión de PHP y Composer:

docker run --rm laravel-php:latest php -v
docker run --rm laravel-php:latest composer -V

Mejores Prácticas y Actualizaciones (Novedades)

El Dockerfile que hemos construido incorpora varias mejoras con respecto al enfoque del video original. Aquí están las principales diferencias y recomendaciones actuales:

Aspecto	En el video (original)	Mejora / Práctica actual
Versión de PHP	PHP 7.4 (obsoleto)	PHP 8.2 o 8.3, compatible con Laravel 10/11 y con mejor rendimiento.
Instalación de Composer	No se especifica (posiblemente descarga manual)	`COPY --from=composer:latest` – método oficial y más limpio.
Gestión de paquetes	`apt-get` sin `--no-install-recommends`	Se recomienda añadir `--no-install-recommends` para reducir paquetes innecesarios y `apt-get clean` y `rm -rf /var/lib/apt/lists/*` para minimizar el tamaño.
Comandos de instalación de extensiones	Usa `docker-php-ext-install` (correcto)	Se mantiene, pero se listan todas las extensiones en una sola línea para optimizar capas.
Creación de usuario	`useradd` con opciones, pero menos modular	Se utilizan `ARG` para UID y USER, lo que permite flexibilidad al construir.
Limpieza de caché	Se menciona `apt clean` y `rm -rf /var/lib/apt/lists/*`	Se incluye en el mismo `RUN` para mantener las capas pequeñas.
Usuario final	Se cambia a `USER` después de crear el directorio de trabajo	Se hace `USER` antes del `CMD`, y se establece el `WORKDIR` apropiadamente.
Seguridad	El usuario se añade al grupo `root`	Se añade a `www-data` y `root` (este último puede ser opcional). En entornos más seguros, solo se añade a `www-data`.
Multistage	No se utiliza	Se podría mejorar con un multistage build para separar la construcción de dependencias de la imagen final, pero para este caso es suficiente.
Uso de `apt` vs `apt-get`	Usa `apt-get` (válido)	Se puede usar `apt` (más amigable), pero `apt-get` es más estable para scripts.

Otras recomendaciones adicionales

Variables de entorno: Puedes definir variables de entorno para configuraciones de PHP (ej. upload_max_filesize) usando ENV en el Dockerfile o en el docker-compose.yml.
Healthcheck: Añadir un HEALTHCHECK para monitorear el estado de PHP-FPM.
Uso de docker-php-entrypoint: Si necesitas ejecutar scripts de inicialización, puedes usar el entrypoint oficial de PHP.
Optimización de capas: Agrupar comandos RUN relacionados para reducir el número de capas.

Próximos Pasos

Con esta imagen ya puedes usarla en un archivo docker-compose.yml junto con Nginx (o Apache) y MySQL para levantar todo tu entorno de desarrollo de Laravel. Eso es lo que se abordará en el siguiente paso.

¡Ya tienes un Dockerfile moderno y eficiente para tu proyecto Laravel! Recuerda que puedes ajustar las versiones y extensiones según las necesidades específicas de tu aplicación

Buscar este blog

SOTELO-DOCKER

9 Crear Archivo Dockerfile