Installation und Einrichtung von Laravel mit Docker Compose unter Ubuntu 22.04 – Eine umfassende Anleitung

Wie installiere und richte ich Laravel mit Docker Compose unter Ubuntu 22.04 ein?

In diesem praktischen und technischen Leitfaden führen wir Sie Schritt für Schritt durch den Installations- und Konfigurationsprozess einer Anwendung. Laravel Verwendung Docker Compose Auf dem Server Ubuntu 22.04 Ziel dieses Artikels ist es, Entwicklern, DevOps-Teams und technischen Managern wiederholbare Richtlinien an die Hand zu geben, um eine sichere, skalierbare und wartungsfreundliche Produktionsumgebung zu schaffen.

Erste Checkliste

Bevor Sie beginnen, bereiten Sie bitte Folgendes vor:

• Ein Server Ubuntu 22.04 Mit Root-Zugriff oder einem Benutzer mit sudo-Rechten
• Docker (stabile Version) und Docker Compose (oder verwenden Sie das Docker Compose-Plugin)
• Offene Ports: 80/443 Fürs Web; falls erforderlich 3306 Oder 5432 Für die Datenbank (vorzugsweise beschränkt auf IPs)
• Ausreichend Festplattenspeicher (SSD empfohlen) und Zugriff auf mindestens einen Computer. 85 Standorte Global, wenn Cloud-Dienste genutzt werden
• Domainname und DNS-Eintrag, der auf die Server-IP verweist

Installation von Docker und Docker Compose auf Ubuntu 22.04

Führen Sie die folgenden Befehle auf dem Server aus, um Docker und das Docker Compose-Plugin zu installieren:

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

Dann melden Sie sich ab und wieder an oder newgrp docker Verwenden.

Um die Installation zu überprüfen:

docker --version
docker compose version

Vorgeschlagene Projektstruktur

Zur Vereinfachung von Wartung und Weiterentwicklung wird empfohlen, den Projektordner wie folgt zu organisieren:

• Projektverzeichnis/
  • Docker/
    • nginx/default.conf
    • php/Dockerfile
  • src/ — Laravel-Code (oder Mount)
  • docker-compose.yml
  • .env

Empfohlene Dockerfile für PHP-FPM (PHP 8.1)

Eine Datei mit einem Pfad docker/php/Dockerfile Erstellen Sie etwas Ähnliches wie im folgenden Beispiel:

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

docker-compose.yml Beispiel

Empfohlene Version docker-compose.yml Zum Ausführen der Anwendung, des Webservers, der Datenbank und von 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

Nginx-Konfigurationsdatei (docker/nginx/default.conf)

Beispiel einer Nginx-Konfiguration zum Weiterleiten von Anfragen an PHP-FPM (App):

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;
    }
}

Notiz: In Architekturen mit Reverse-Proxy oder mehreren Diensten kann Nginx auf der Load-Balancer- oder CDN-Ebene eingesetzt werden.

Code vorbereiten und Abhängigkeiten installieren

Falls Sie noch kein Laravel-Projekt besitzen, können Sie mit Composer ein neues erstellen:

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

Anschließend werden Container erstellt und ausgeführt:

docker compose build
docker compose up -d

So führen Sie Composer- und Artisan-Befehle innerhalb eines PHP-Containers aus:

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

Einrichten der .env-Datei für Docker

Beispiel einer mit docker-compose kompatiblen .env-Konfiguration:

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 und Let's Encrypt – Zwei einfache Wege

Es gibt zwei einfache Möglichkeiten, HTTPS zu aktivieren:

• Verwendung von Certbot auf dem Host: Stoppen Sie Nginx vorübergehend und legen Sie das ausgestellte Zertifikat in den Ordner ./certs und montieren Sie es am Behälter.
• Verwendung der automatisierten Lösung: Werkzeuge wie docker-letsencrypt-nginx-proxy-companion Oder Verkehr Sie eignen sich für die automatisierte Zertifikatsverwaltung.

Kurzes Beispiel mit 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

Beim Systemstart starten und den Dienst aufrechterhalten

Um sicherzustellen, dass die Dienste nach dem Neustart weiterhin funktionieren:

sudo systemctl enable docker

Zusätzlich, in docker-compose von Neustart: sofern nicht gestoppt Es wurde bereits verwendet. Bei Bedarf kann eine systemd-Unit für docker-compose erstellt werden.

Praktische Sicherheitstipps

• Verwendung eines Nicht-Root-Benutzers in einem PHP-Container (App-Benutzer (im obigen Dockerfile)
• Zugriff auf den Datenbankport mit einer Firewall (UFW) einschränken:

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

Weitere Empfehlungen:

• Regelmäßige Sicherung des Datenbank-Volumes (db_dataund die Speicherung außerhalb des Servers
• Aktivierung von HTTPS und HSTS
• Verwendung von Secrets oder Schlüsselverwaltungsdiensten zur Speicherung von Passwörtern (Docker Secrets oder Schlüsselverwaltungsdienste)
• Nutzen Sie Sicherheitstools wie fail2ban Und falls nötig, wie z. B. eine WAF ModSecurity
• Nutzen Sie ein CDN oder einen Anti-DDoS-Dienst, um den Datenverkehr zu schützen.

Leistungsoptimierung für Produktionsumgebungen

• OPcache aktivieren in php.ini:

  opcache.memory_consumption=256
  opcache.validate_timestamps=0

• php-fpm einrichten (pm = dynamisch oder bedarfsgesteuert) und erhöhen max_children Laut Serverspeicher
• Redis wird für Cache und Sitzungen verwendet.
• Verwendung eines CDN für statische Dateien
• Horizontale Skalierung: Betrieb mehrerer Instanzen des App-Dienstes mit einem Load Balancer (NGINX oder HAProxy)
• Verwenden Sie separate Mitarbeiter und Vorgesetzte bzw. Dienste für Echtzeitverarbeitung und Warteschlangen.

Warteschlangenmitarbeiter und Horizon

Fügen Sie in docker-compose einen separaten Dienst hinzu, um Warteschlangen-Worker auszuführen. Beispiel:

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

Für Laravel Horizon empfiehlt es sich, einen dedizierten Container mit installiertem PHP und Horizon zu verwenden und diesen hinter Nginx/Authentication zu platzieren.

Tipps zur Standort- und Rechenzentrumsauswahl

Praktische Tipps zur Standortwahl:

• Für die geringste Latenz wählen Sie einen Server in der Nähe Ihrer Endnutzer oder des Zielorts. Der Dienstanbieter ist mehr als 85 Standorte weltweit Das hat es.
• Für Gamer oder Händler empfiehlt sich ein Standort mit niedrigem Ping und einem optimierten BGP-Netzwerk.
• Verwenden Sie GPU-ausgestattete Server für die KI-Verarbeitung und das Rendering.
• Nutzen Sie Server und CDNs mit Anti-DDoS-Schutz, um DDoS-Angriffen entgegenzuwirken.

Datensicherung, Überwachung und Protokolle

• Containerprotokolle mit docker logs Sind zugänglich; verwenden Sie ELK oder Prometheus+Grafana für die zentrale Aggregation.
• Tägliche Datenbanksicherung und periodischer Wiederherstellungstest
• Überwachung von CPU-/RAM-Ressourcen, Anwendungs- und Fehlerverfolgung in CI/CD

Allgemeines Debugging

• 502 Bad Gateway-Fehler: Überprüfen Sie, ob php-fpm im Anwendungscontainer ausgeführt wird und ob fastcgi_pass auf die richtige Adresse gesetzt ist (App:9000) darauf hinzuweisen.
• Datenbankverbindungsproblem: Überprüfen Sie die .env-Variablen, das Docker-Netzwerk und die MySQL-Protokolle.
• Dateiberechtigungen: Im Falle von Berechtigungsfehlern müssen die Besitzrechte der Ordner „storage“ und „bootstrap/cache“ festgelegt werden:

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

Schlussfolgerung und abschließende Empfehlung

Die Verwendung von Docker Compose zum Ausführen von Laravel unter Ubuntu 22.04 vereinfacht die Entwicklung und Bereitstellung und macht sie wiederholbar und skalierbar. Mit dieser Anleitung können Sie eine sichere, schnelle und wartungsfreundliche Produktionsumgebung einrichten: PHP-FPM mit NginxMySQL/MariaDB oder PostgreSQL, Redis für Cache und Warteschlange sowie SSL-Einstellungen und -Überwachung.

Verwandte Dienstleistungen

Zur professionellen Umsetzung dieser Architektur können Sie folgende Dienstleistungen in Anspruch nehmen:

• Mehr als 85 Standorte weltweit Um die Latenz zu verringern und den Server näher an den Benutzer oder das Ziel zu bringen.
• Grafikserver (GPU) für KI-Berechnungen und Rendering
• VPS für Trading mit niedrigem Ping und optimiertem BGP-Netzwerk
• Gaming-VPS mit niedrigem Ping und Anti-DDoS
• Hosting- und Domainregistrierungsdienste, CDN, Netzwerk- und BGP-Lösungen
• Hochleistungsfähiger Cloud-Server und verwaltete Datensicherung

Häufig gestellte Fragen