"En mi máquina funciona" deja de ser una excusa cuando el entorno de producción se describe en código. Docker empaqueta la aplicación con sus dependencias y Nginx la sirve de forma rápida y predecible. Este es el esquema que uso para desplegar aplicaciones PHP y Laravel de forma fiable, paso a paso.
1. Separa los servicios
Un contenedor por responsabilidad: la aplicación (PHP-FPM), el servidor web (Nginx), la base de datos y, si hace falta, Redis y un worker de colas. Así puedes actualizar, escalar o reiniciar cada pieza sin tocar las demás, y los registros de cada servicio quedan separados.
2. Una imagen de aplicación reproducible
La imagen debe construirse siempre igual: versión de PHP fijada, extensiones explícitas y dependencias instaladas desde composer.lock. Copiar primero los ficheros de Composer aprovecha la caché de capas y acelera mucho las construcciones:
FROM php:8.3-fpm-alpine AS app
RUN apk add --no-cache icu-dev libzip-dev \
&& docker-php-ext-install intl pdo_mysql zip opcache
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
WORKDIR /var/www/html
COPY composer.json composer.lock ./
RUN composer install --no-dev --no-scripts --prefer-dist --no-interaction
COPY . .
RUN composer dump-autoload --optimize \
&& chown -R www-data:www-data storage bootstrap/cache
3. Nginx delante de PHP-FPM
Nginx sirve los ficheros estáticos directamente y pasa a PHP solo lo que tiene que ejecutarse. Una configuración base para Laravel:
server {
listen 80;
server_name ejemplo.com;
root /var/www/html/public;
index index.php;
client_max_body_size 20M;
gzip on;
gzip_types text/css application/javascript application/json image/svg+xml;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
location ~ \.php$ {
fastcgi_pass app:9000;
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
include fastcgi_params;
}
location ~* \.(css|js|webp|png|jpg|svg|woff2)$ {
expires 30d;
access_log off;
}
}
4. Configuración y secretos fuera de la imagen
La imagen no debe contener contraseñas ni el fichero .env. Pásalos como variables de entorno o ficheros montados en el servidor, y usa la misma imagen en pruebas y en producción cambiando solo la configuración.
5. Datos persistentes en volúmenes
Base de datos, ficheros subidos por los usuarios y storage van en volúmenes, no dentro del contenedor. Un contenedor tiene que poder destruirse y recrearse sin perder nada. Y los volúmenes necesitan copias de seguridad automáticas y probadas: una copia que nunca se ha restaurado no es una copia.
6. Un despliegue en pocos comandos
El despliegue tiene que ser un script, no una lista de pasos que alguien recuerda. Un ejemplo sencillo:
#!/usr/bin/env bash
set -euo pipefail
git pull --ff-only
docker compose build app
docker compose up -d --no-deps app nginx
docker compose exec -T app php artisan migrate --force
docker compose exec -T app php artisan optimize
docker compose exec -T app php artisan queue:restart
Con migraciones compatibles hacia atrás y healthchecks en los contenedores, el corte durante el despliegue es mínimo. Si necesitas cero interrupciones, el siguiente paso es levantar la nueva versión en paralelo y cambiar el tráfico cuando esté sana.
7. Observa lo que pasa en producción
- Registros de cada contenedor centralizados y con rotación.
- Alertas de disco, memoria y caídas de servicio.
- HTTPS automatizado y renovación de certificados vigilada.
- Actualizaciones periódicas de la imagen base por seguridad.
Errores habituales
- Usar
latestcomo versión de las imágenes. - Guardar ficheros subidos dentro del contenedor.
- Desplegar a mano y sin script.
- No probar nunca la restauración de una copia.
Si quieres pasar tus aplicaciones a contenedores o hacer más fiables tus despliegues, cuéntame cómo trabajas ahora y te propongo un plan por pasos. También puedes ver mis servicios de desarrollo Laravel.