Docker Laravel · 8 min read · Nov 25, 2025

Dockerisierung von Laravel mit Nginx MySQL und Docker Compose auf Ubuntu 18.04 LTS

Laravel ist ein kostenloses und Open-Source-PHP-Framework, das das MVC (Model-View-Controller) Designmuster implementiert. Es ist benutzerfreundlich gestaltet und ermöglicht Entwicklern, sowohl einfache als auch komplexe Anwendungen in kürzester Zeit zu erstellen. Laravel wurde 2011 von Taylor Otwell als Versuch geschaffen, eine fortschrittliche Alternative zum CodeIgniter (CI) Framework anzubieten. Im Jahr 2011 wurden die Version 1 und Version 2 von Laravel veröffentlicht, und die neueste Version 5.6 bietet mehr und verbesserte Funktionen wie die Unterstützung der Befehlszeile (CLI) namens ‘artisan’, Unterstützung für verschiedene Datenbanksysteme, Verbesserungen bei Routen usw.

In diesem Leitfaden zeigen wir Ihnen, wie Sie das Laravel-Projekt mit PHP-FPM, MySQL-Datenbank und dem Nginx-Webserver unter Verwendung von Docker Compose auf dem Ubuntu-Server 18.04 dockerisieren. Wir werden ein neues Docker-Image für das Laravel-Projekt erstellen und dann das docker-compose.yml-Skript erstellen, das einige Dienste enthält, einschließlich der App/Laravel selbst, des Nginx-Webservers und der MySQL-Datenbank.

Voraussetzungen

  • Ubuntu 18.04
  • Root-Rechte

Was wir tun werden:

  1. Docker und Docker Compose installieren
  2. Laravel herunterladen und Abhängigkeiten installieren
  3. Dockerisierung des Laravel-Projekts - Laravel-App-Dienst definieren
  • Nginx-HTTP-Dienst definieren
  • MySQL-Datenbankdienst definieren
  • Nginx-virtuellen Host für Laravel erstellen
  • Dockerfile für die Laravel-App erstellen
  1. Das Laravel-Projekt erstellen
  2. Laravel-Nachinstallation

Schritt 1 - Docker und Docker Compose installieren

Zunächst werden wir die Docker- und Docker Compose-Pakete auf dem Ubuntu-System installieren. Und wir werden Docker-Pakete aus dem offiziellen Ubuntu-Repository verwenden.

Bevor wir fortfahren, müssen wir die Repositories auf dem Ubuntu-System aktualisieren. Führen Sie einfach den folgenden Befehl aus.

sudo apt update

Jetzt installieren Sie Docker und Docker Compose-Pakete mit dem folgenden apt-Befehl.

sudo apt install docker.io -y  
sudo apt install docker-compose -y

Die Docker- und Docker Compose-Pakete sollten jetzt auf dem System installiert sein, überprüfen Sie dies mit den folgenden Befehlen.

docker version  
docker-compose version

Als Ergebnis erhalten Sie die Version von Docker und Docker Compose auf dem System.

Überprüfen Sie die Docker-Version

Als nächstes müssen wir den Nicht-Root-Benutzer der Docker-Gruppe zuweisen, um den Docker-Container für Nicht-Root-Benutzer auszuführen.

In diesem Fall werden wir den Benutzer ‘hakase’ zur Docker-Gruppe hinzufügen, indem wir den folgenden Befehl ausführen.

usermod -a -G docker hakase

Und danach melden Sie sich bei der Shell des Benutzers ‘hakase’ an und führen Sie den Docker-Befehl ‘hello-world’ aus.

su - hakase  
docker run hello-world

Jetzt wird Ihnen die ‘Hello World’-Nachricht von Docker angezeigt, und die Docker-Installation ist abgeschlossen.

Docker-Benutzer hinzufügen

Schritt 2 - Laravel herunterladen und Abhängigkeiten installieren

In diesem Schritt werden wir das Laravel-Web-Framework in das Home-Verzeichnis von ‘hakase’ herunterladen und dann die Laravel-Abhängigkeiten mit dem PHP ‘composer’-Docker-Image installieren. Stellen Sie sicher, dass Sie als Nicht-Root-Benutzer auf dem Server angemeldet sind.

Laden Sie das Laravel-Projekt in das Verzeichnis ‘myapp’ herunter und wechseln Sie in dieses Verzeichnis.

git clone https://github.com/laravel/laravel.git myapp/  
cd myapp/

Führen Sie jetzt den folgenden Docker-Befehl aus, um die Laravel-Abhängigkeiten zu installieren.

docker run --rm -v $(pwd):/app composer install

Mit dem obigen Befehl werden wir einen neuen temporären Docker-Container ausführen und das Verzeichnis des ‘myapp’-Projekts im Container im Verzeichnis ‘/app’ einhängen. Der Container basiert auf dem ‘composer’-Docker-Image, und wir installieren die Laravel-Abhängigkeiten mit dem ‘composer’-Befehl innerhalb dieses temporären Containers.

Laravel-Framework abrufen

Sobald die Installation der Laravel-Abhängigkeiten abgeschlossen ist, müssen wir den Besitzer des Verzeichnisses ‘myapp’ mit dem folgenden sudo-Befehl ändern.

sudo chown -R $USER:$USER ~/myapp

Besitzer des Anwendungsverzeichnisses ändern

Schritt 3 - Dockerisierung des Laravel-Projekts

Nachdem wir Laravel heruntergeladen und seine Abhängigkeiten installiert haben, werden wir ein neues docker-compose.yml-Skript erstellen und ein neues Dockerfile für das Laravel-Projekt erstellen.

cd myapp/  
vim docker-compose.yml

- Definieren Sie den Laravel-App-Dienst

Zunächst werden wir das Laravel-Projekt selbst definieren und das Docker-Image für das Laravel-Projekt mit dem Dockerfile erstellen.

Fügen Sie das Docker-Compose-Skript ein.

version: '3'  
services:  
  
  #Laravel App  
  app:  
    build:  
      context: .  
      dockerfile: Dockerfile  
    image: hakase-labs/laravel  
    container_name: app  
    restart: unless-stopped  
    tty: true  
    environment:  
      SERVICE_NAME: app  
      SERVICE_TAGS: dev  
    working_dir: /var/www/html  
    volumes:  
      - ./:/var/www/html  
    networks:  
      - mynet

Details des Laravel-Containerdienstes:

  • Der Laravel-Containerdienst wird als ‘app’ benannt. Er basiert auf unserem benutzerdefinierten Docker-Image, das mit unserem ‘Dockerfile’ erstellt wird, und das neue Image wird als ‘hakase-labs/laravel’ benannt.
  • Wir möchten das Verzeichnis des ‘myapp’-Projekts im Containerdienst im Verzeichnis ‘/var/www/html’ einhängen.
  • Wir verwenden das benutzerdefinierte Docker-Netzwerk für unser Setup, das Netzwerk wird als ‘mynet’ benannt.

- Definieren Sie den Nginx-HTTP-Dienst

Jetzt werden wir den Nginx-Containerdienst definieren.

Fügen Sie die folgende Konfiguration nach der Zeile des ‘app’-Containerdienstes ein.

  #Nginx-Dienst  
  nginx:  
    image: nginx:alpine  
    container_name: nginx  
    restart: unless-stopped  
    tty: true  
    ports:  
      - "80:80"  
      - "443:443"  
    volumes:  
      - ./:/var/www/html  
      - ./nginx/conf.d/:/etc/nginx/conf.d/  
      - ./nginx/ssl/:/etc/nginx/ssl/  
    networks:  
      - mynet

Konfigurationsdetails des Nginx-Containerdienstes:

  • Wir möchten einen neuen Container mit dem Namen ‘nginx’ basierend auf dem Docker-Image ‘nginx:alpine’ erstellen.
  • Der Containerdienst wird die HTTP- und HTTPS-Ports öffnen.
  • Der Container wird drei verschiedene Volumes einhängen. Das ‘myapp’-Projektverzeichnis in das Verzeichnis ‘/var/www/html’, die Nginx-virtuelle Hostkonfiguration ‘nginx/conf.d/‘ in das Verzeichnis ‘/etc/nginx/conf.d’ und die Zertifikatsdateien ‘nginx/ssl/‘ in das Verzeichnis ‘/etc/nginx/ssl’ im Container.
  • Der Containerdienst wird dasselbe Netzwerk namens ‘mynet’ verwenden.

- Definieren Sie den MySQL-Datenbankdienst

Und zuletzt definieren wir den MySQL-Datenbankdienst.

Fügen Sie die folgende Konfiguration nach der Zeile des ‘nginx’-Containerdienstes ein.

  #MySQL-Dienst  
  db:  
    image: mysql:5.7  
    container_name: db  
    restart: unless-stopped  
    tty: true  
    ports:  
      - "3306:3306"  
    environment:  
      MYSQL_DATABASE: laraveldb  
      MYSQL_USER: laravel  
      MYSQL_PASSWORD: laravelpassworddb  
      MYSQL_ROOT_PASSWORD: rootpasswordmysql  
    volumes:  
      - mysqldata:/var/lib/mysql/  
    networks:  
      - mynet  
  
#Docker-Netzwerke  
etworks:  
  mynet:  
    driver: bridge  
#Volumes  
volumes:  
  mysqldata:  
    driver: local

Speichern und schließen Sie die Konfiguration.

Details des MySQL-Containerdienstes:

  • Der MySQL-Containerdienst wird als ‘db’ benannt und basiert auf dem Docker-Image ‘mysql:5.7’.
  • Der ‘db’-Dienst wird den Standardport ‘3306’ für MySQL öffnen.
  • Das Laravel-Projekt wird die Datenbank, den Benutzer und das Passwort basierend auf der Umgebungsvariable des ‘db’-Dienstes verwenden.
  • Der MySQL ‘db’-Dienst wird das Volume mit dem Namen ‘mysqldata’ einhängen und dasselbe Netzwerk ‘mynet’ haben.
  • Und wir definieren das benutzerdefinierte Netzwerk ‘mynet’ mit dem ‘bridge’-Treiber, und das ‘mysqldata’-Volume wird den ‘local’-Treiber verwenden.

Unten finden Sie die vollständige Konfiguration von ‘docker-compose.yml’:

version: '3'
services:

  #Laravel App
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: hakase-labs/laravel
    container_name: app
    restart: unless-stopped
    tty: true
    environment:
      SERVICE_NAME: app
      SERVICE_TAGS: dev
    working_dir: /var/www/html
    volumes:
      - ./:/var/www/html
    networks:
      - mynet

  #Nginx-Dienst
  nginx:
    image: nginx:alpine
    container_name: nginx
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./:/var/www/html
      - ./nginx/conf.d/:/etc/nginx/conf.d/
      - ./nginx/ssl/:/etc/nginx/ssl/
    networks:
      - mynet

  #MySQL-Dienst
  db:
    image: mysql:5.7
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laraveldb
      MYSQL_USER: laravel
      MYSQL_PASSWORD: laravelpassworddb
      MYSQL_ROOT_PASSWORD: rootpasswordmysql
    volumes:
      - mysqldata:/var/lib/mysql/
    networks:
      - mynet

#Docker-Netzwerke
networks:
  mynet:
    driver: bridge
#Volumes
volumes:
  mysqldata:
    driver: local

- Erstellen Sie einen Nginx-virtuellen Host für Laravel

Innerhalb des ‘myapp’-Projektverzeichnisses erstellen Sie ein neues Verzeichnis namens ‘nginx’, das zwei weitere Verzeichnisse ‘conf.d’ und ‘ssl’ enthalten wird. Erstellen Sie dann eine neue Nginx-virtuelle Hostkonfiguration ‘laravel.conf’ im Verzeichnis ‘conf.d’.

Führen Sie den folgenden Befehl aus.

mkdir -p nginx/{conf.d,ssl}  
vim nginx/conf.d/laravel.conf
server {
    listen 80;
    server_name laravel.hakase-labs.io;

    return 301 https://laravel.hakase-labs.io$request_uri;
}


server {
    listen 443 ssl http2;
    server_name laravel.hakase-labs.io;

    ssl_certificate /etc/nginx/ssl/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/privkey.pem;

    # Protokolldateien für Debug
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;

    # Laravel-Web-Stammverzeichnis
    root /var/www/html/public;
    index index.php index.html;

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

    # Nginx leitet Anfragen an PHP-FPM weiter
    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.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;
    }
}

Speichern und schließen Sie.

Danach kopieren Sie Ihre SSL-Zertifikatdatei in das Verzeichnis ‘nginx/ssl/‘.

sudo cp /path/to/ssl/fullchain.pem nginx/ssl/  
sudo cp /path/to/ssl/privkey.pem nginx/ssl/

- Erstellen Sie ein Dockerfile für die Laravel-App

Als nächstes erstellen Sie ein neues Dockerfile für das Laravel-Projekt.

Führen Sie den folgenden Befehl aus.

vim Dockerfile

Fügen Sie die folgende Konfiguration ein.

# Setzen Sie das Master-Image
FROM php:7.2-fpm-alpine

# Kopieren Sie composer.lock und composer.json
COPY composer.lock composer.json /var/www/html/

# Arbeitsverzeichnis festlegen
WORKDIR /var/www/html

# Zusätzliche Abhängigkeiten installieren
RUN apk update && apk add --no-cache \
    build-base shadow vim curl \
    php7 \
    php7-fpm \
    php7-common \
    php7-pdo \
    php7-pdo_mysql \
    php7-mysqli \
    php7-mcrypt \
    php7-mbstring \
    php7-xml \
    php7-openssl \
    php7-json \
    php7-phar \
    php7-zip \
    php7-gd \
    php7-dom \
    php7-session \
    php7-zlib

# Fügen Sie PHP-PDO-Erweiterungen hinzu und aktivieren Sie sie
RUN docker-php-ext-install pdo pdo_mysql
RUN docker-php-ext-enable pdo_mysql

# Installieren Sie PHP Composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

# Cache entfernen
RUN rm -rf /var/cache/apk/*

# UID '1000' zu www-data hinzufügen
RUN usermod -u 1000 www-data

# Berechtigungen des vorhandenen Anwendungsverzeichnisses kopieren
COPY --chown=www-data:www-data . /var/www/html

# Aktuellen Benutzer auf www ändern
USER www-data

# Port 9000 freigeben und PHP-FPM-Server starten
EXPOSE 9000
CMD ["php-fpm"]

Speichern und schließen Sie die Konfiguration.

Und wir sind bereit, das ‘myapp’ Laravel-Projekt zu erstellen und die Container-Dienste auszuführen, die wir definiert haben.

Schritt 4 - Laravel mit Nginx und MySQL-Diensten erstellen

Erstellen Sie das benutzerdefinierte Docker-Image für unser Laravel-Projekt mit dem folgenden Befehl.

docker-compose build

Laravel mit Nginx und MySQL-Diensten erstellen

Führen Sie dann erneut den folgenden Befehl aus.

docker-compose up -d

Es werden alle Docker-Images heruntergeladen, die wir benötigen, und dann werden die Container-Dienste basierend auf der Konfiguration ‘docker-compose.yml’ erstellt.

Docker-Images herunterladen

Wenn es abgeschlossen ist, überprüfen Sie dies mit dem Docker-Compose-Befehl unten.

docker-compose ps

Und als Ergebnis erhalten Sie, dass die drei Container-Dienste aktiv und betriebsbereit sind. Der ‘app’-Dienst läuft auf dem Standardport ‘9000’ PHP-FPM, der Dienst ‘nginx’ auf den HTTP- und HTTPS-Ports und der MySQL ‘db’-Dienst auf dem Standardport ‘3306’.

Überprüfen Sie danach erneut alle verfügbaren Docker-Images und die offenen Ports auf dem System.

docker-compose images  
netstat -plntu

Sie erhalten das benutzerdefinierte Docker-Image ‘hakase-labs/laravel’ in der Liste, und die HTTP- und HTTPS-Ports befinden sich im Status ‘LISTEN’.

Docker-Setup mit netstat überprüfen

Schritt 5 - Laravel-Nachinstallation

Bis zu diesem Punkt ist das Laravel-Projekt als Docker-Container aktiv und betriebsbereit. Und jetzt werden wir eine neue ‘.env’-Datei erstellen, den Schlüssel generieren und die Laravel-Daten mit der Laravel-Befehlszeile ‘artisan’ migrieren.

Kopieren Sie das Beispiel der ‘.env’-Datei und bearbeiten Sie es innerhalb des Containers.

cp .env.example .env  
docker-compose exec app vim .env

Ändern Sie die Datenbankkonfiguration wie folgt.

DB_CONNECTION=mysql  
DB_HOST=db  
DB_PORT=3306  
DB_DATABASE=laraveldb  
DB_USERNAME=laravel  
DB_PASSWORD=laravelpassworddb

Speichern und schließen Sie.

Als nächstes generieren Sie den Laravel-Anwendungsschlüssel und leeren den Cache der Konfiguration.

docker-compose exec app php artisan key:generate  
docker-compose exec app php artisan config:cache

Danach migrieren Sie die Datenbank mit dem folgenden Befehl.

docker-compose exec app php artisan migrate

Stellen Sie sicher, dass keine Fehler auftreten.

Laravel-Nachinstallation

Öffnen Sie jetzt Ihren Webbrowser und geben Sie den Domainnamen Ihres Projekts ein.

http://laravel.hakase-labs.io/

Und Sie werden auf die sichere HTTPS-Verbindung umgeleitet und die Standard-Startseite von Laravel wird wie folgt angezeigt.

Laravel mit Docker erfolgreich installiert

Schließlich wurde die Dockerisierung des Laravel-Projekts mit dem Nginx-Webserver und der MySQL-Datenbank erfolgreich abgeschlossen.

Share: X/Twitter LinkedIn
#Docker Laravel

Erhalte neue Beiträge in deinem Posteingang.

Kein Spam. Jederzeit abmelden.