Instalación y configuración de Laravel con Docker Compose en Ubuntu 22.04: una guía completa

¿Cómo instalar y configurar Laravel con Docker Compose en Ubuntu 22.04?

En esta guía práctica y técnica, lo guiaremos a través del proceso paso a paso de instalación y configuración de una aplicación. Laravel Usando Docker Compose En el servidor Ubuntu 22.04 El objetivo de este artículo es proporcionar pautas repetibles para que los desarrolladores, los equipos de DevOps y los gerentes técnicos creen un entorno de producción seguro, escalable y mantenible.

Lista de verificación inicial

Antes de comenzar, prepare lo siguiente:

• Un servidor Ubuntu 22.04 Con acceso root o un usuario con sudo
• Estibador (versión estable) y Docker Compose (o use el complemento Docker Compose)
• Puertos abiertos: 80/443 Para la web; si es necesario 3306 O 5432 Para base de datos (preferiblemente limitada a IP)
• Espacio en disco adecuado (se recomienda SSD) y acceso a uno o más de 85 ubicaciones Global si se utilizan servicios en la nube
• Nombre de dominio y registro DNS que apuntan a la IP del servidor

Instalación de Docker y Docker Compose en Ubuntu 22.04

Ejecute los siguientes comandos en el servidor para instalar Docker y el complemento Docker Compose:

sudo apt update && sudo apt upgrade -y
sudo apt install -y ca-certificates curl gnupg lsb-release
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmour -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
sudo usermod -aG docker $USER

Luego cierre la sesión y vuelva a iniciarla o nuevo grupo docker Usar.

Para comprobar la instalación:

docker --version
docker compose version

Estructura del proyecto propuesta

Se recomienda que la carpeta del proyecto se organice de la siguiente manera para facilitar el mantenimiento y el desarrollo:

• raíz del proyecto/
  • estibador/
    • nginx/default.conf
    • php/Dockerfile
  • fuente/ — Código de Laravel (o montaje)
  • docker-compose.yml
  • .env

Dockerfile recomendado para PHP-FPM (PHP 8.1)

Un archivo con una ruta docker/php/Dockerfile Crea algo como el siguiente ejemplo:

FROM php:8.1-fpm

# Install required tools and extensions
RUN apt-get update && apt-get install -y \
    git zip unzip libpng-dev libjpeg-dev libfreetype6-dev libonig-dev libxml2-dev \
    libzip-dev libpq-dev cron curl supervisor \
  && docker-php-ext-configure gd --with-freetype --with-jpeg \
  && docker-php-ext-install -j$(nproc) gd pdo pdo_mysql pdo_pgsql mbstring xml bcmath zip opcache \
  && pecl install redis && docker-php-ext-enable redis \
  && pecl install xdebug || true \
  && apt-get clean && rm -rf /var/lib/apt/lists/*

# Composer
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer

# Create non-root user
RUN useradd -G www-data,root -u 1000 -d /home/appuser appuser
WORKDIR /var/www/html
USER appuser

Ejemplo de docker-compose.yml

Versión sugerida docker-compose.yml Para ejecutar la aplicación, el servidor web, la base de datos y Redis:

version: "3.8"

services:
  app:
    build:
      context: .
      dockerfile: docker/php/Dockerfile
    image: laravel_app:latest
    container_name: laravel_app
    restart: unless-stopped
    volumes:
      - ./src:/var/www/html
      - ./docker/php/supervisord.conf:/etc/supervisor/conf.d/supervisord.conf
    environment:
      - APP_ENV=production
      - APP_DEBUG=false
    networks:
      - laravel-net

  web:
    image: nginx:alpine
    container_name: laravel_web
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./src:/var/www/html:ro
      - ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
      - ./certs:/etc/letsencrypt
    depends_on:
      - app
    networks:
      - laravel-net

  db:
    image: mysql:8.0
    container_name: laravel_db
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: laravel
      MYSQL_USER: laravel
      MYSQL_PASSWORD: secret
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - laravel-net

  redis:
    image: redis:6-alpine
    container_name: laravel_redis
    restart: unless-stopped
    volumes:
      - redis_data:/data
    networks:
      - laravel-net

volumes:
  db_data:
  redis_data:

networks:
  laravel-net:
    driver: bridge

Archivo de configuración de Nginx (docker/nginx/default.conf)

Ejemplo de configuración de Nginx para enrutar solicitudes a PHP-FPM (aplicación):

server {
    listen 80;
    server_name example.com;

    root /var/www/html/public;
    index index.php index.html;

    add_header X-Frame-Options "SAMEORIGIN";
    add_header X-Content-Type-Options "nosniff";

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

    location ~ \.php$ {
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }

    location ~ /\.ht {
        deny all;
    }
}

Nota: En arquitecturas con proxy inverso o múltiples servicios, puedes colocar Nginx en la capa de balanceador de carga o CDN.

Preparando el código e instalando dependencias

Si no tienes un proyecto Laravel, puedes crear uno nuevo con Composer:

composer create-project --prefer-dist laravel/laravel src

Luego, para construir y ejecutar contenedores:

docker compose build
docker compose up -d

Para ejecutar comandos Composer y Artisan dentro de un contenedor PHP:

docker exec -it laravel_app bash
composer install --no-dev --optimize-autoloader
php artisan key:generate
php artisan migrate --force
php artisan config:cache
php artisan route:cache
exit

Configuración del archivo .env para Docker

Ejemplo de configuración .env compatible con docker-compose:

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laravel
DB_PASSWORD=secret

CACHE_DRIVER=redis
REDIS_HOST=redis

APP_URL=https://example.com

SSL y Let's Encrypt: dos formas sencillas

Hay dos formas sencillas de habilitar HTTPS:

• Usando Certbot en el host: Detenga Nginx temporalmente, coloque el certificado emitido en la carpeta ./certificados y montarlo en el contenedor.
• Utilizando la solución automatizada: Herramientas como Compañero de proxy Nginx de Docker Letsencrypt O Tráfico Son adecuados para la gestión automatizada de certificados.

Ejemplo rápido con Certbot:

sudo apt install -y certbot
sudo docker compose down
sudo certbot certonly --standalone -d example.com --non-interactive --agree-tos -m [email protected]
# Copy certificates from /etc/letsencrypt/live/... to ./certs and then:
sudo docker compose up -d

Iniciar en el arranque y mantener el servicio

Para garantizar que los servicios se ejecuten después del reinicio:

sudo systemctl enable docker

Además, en docker-compose desde reiniciar: a menos que se detenga Se ha utilizado. Si es necesario, se puede crear una unidad systemd para docker-compose.

Consejos prácticos de seguridad

• Usar un usuario no root en un contenedor PHP (usuario de la aplicación en el Dockerfile de arriba)
• Restringir el acceso al puerto de la base de datos con firewall (UFW):

sudo ufw allow OpenSSH
sudo ufw allow 80,443/tcp
sudo ufw enable

Otras recomendaciones:

• Copia de seguridad periódica del volumen de la base de datos (datos de base de datos) y almacenarlo fuera del servidor
• Habilitación de HTTPS y HSTS
• Uso de secretos o servicios de gestión de claves para almacenar contraseñas (secretos de Docker o servicios de gestión de claves)
• Utilice herramientas de seguridad como falla2ban Y si es necesario WAF como ModSecurity
• Utilice una CDN o un servicio Anti-DDoS para proteger el tráfico

Optimización del rendimiento para entornos de producción

• Habilitación de OPcache en php.ini:

  opcache.memory_consumption=256
  opcache.validate_timestamps=0

• Configuración de php-fpm (pm = dinámico o bajo demanda) y aumento máximo_hijos Según la memoria del servidor
• Uso de Redis para caché y sesiones
• Uso de una CDN para archivos estáticos
• Escalamiento horizontal: ejecutar múltiples instancias del servicio de la aplicación con un balanceador de carga (NGINX o HAProxy)
• Utilice trabajadores y supervisores o servicios separados para tiempo real y colas.

Trabajadores de cola y Horizon

Agregue un servicio independiente en Docker-Compose para ejecutar trabajadores de cola. Ejemplo:

worker:
  build: ...
  command: php /var/www/html/artisan queue:work --sleep=3 --tries=3
  depends_on: [app, redis]
  restart: unless-stopped

Para Laravel Horizon, es mejor utilizar un contenedor dedicado con PHP y Horizon instalados y colocarlo detrás de Nginx/autenticación.

Consejos relacionados con la ubicación y selección del centro de datos

Consejos prácticos para elegir una ubicación:

• Para obtener la latencia más baja, elija un servidor en una ubicación cercana a sus usuarios finales o destino. El proveedor de servicios es más que... 85 ubicaciones globales Lo tiene.
• Para jugadores o comerciantes, elija una ubicación con un ping bajo y una red BGP optimizada.
• Utilice servidores equipados con GPU para el procesamiento y renderizado de IA.
• Utilice servidores y CDN con protección Anti-DDoS para resistir DDoS.

Copias de seguridad, supervisión y registros

• Registros de contenedores con registros de Docker Son accesibles; utilice ELK o Prometheus+Grafana para la agregación central.
• Copia de seguridad diaria de la base de datos y prueba de restauración periódica
• Monitoreo de recursos de CPU/RAM, aplicaciones y seguimiento de errores en CI/CD

Depuración común

• Error 502 de puerta de enlace incorrecta: Verifique que php-fpm se esté ejecutando en el contenedor de la aplicación y que fastcgi_pass esté configurado en la dirección correcta (aplicación:9000) para señalar.
• Problema de conexión a la base de datos: Verifique las variables .env, la red de Docker y los registros de MySQL.
• Permisos de archivo: En caso de errores de permisos, establezca la propiedad de las carpetas de almacenamiento y de arranque/caché:

sudo chown -R 1000:1000 src/storage src/bootstrap/cache

Conclusión y recomendación final

Usar Docker Compose para ejecutar Laravel en Ubuntu 22.04 simplifica el desarrollo y la implementación, haciéndolos repetibles y escalables. Siguiendo esta guía, podrá configurar un entorno de producción seguro, rápido y fácil de mantener: PHP-FPM con Nginx, MySQL/MariaDB o PostgreSQL, Redis para caché y cola, y configuración y monitoreo de SSL.

Servicios relacionados

Para implementar profesionalmente esta arquitectura, puede utilizar los siguientes servicios:

• Más que 85 ubicaciones globales Para reducir la latencia y acercar el servidor al usuario o destino
• Servidor de gráficos (GPU) para computación y renderizado de IA
• VPS para comercio con ping bajo y red BGP optimizada
• VPS para juegos con ping bajo y anti-DDoS
• Servicios de hosting y registro de dominios, CDN, soluciones de red y BGP
• Servidor en la nube de alto rendimiento y copia de seguridad administrada

Preguntas frecuentes