Laravel Docker · 17 min read · Sep 23, 2025
Wie man Laravel mit Docker auf Ubuntu 22.04 installiert
Laravel ist ein kostenloses und Open-Source-PHP-Framework, das eine Reihe von Tools und Ressourcen bietet, um moderne PHP-Anwendungen zu erstellen. Mit einer Vielzahl kompatibler Pakete und Erweiterungen hat Laravel an Popularität gewonnen, und viele Entwickler haben es als ihr bevorzugtes Framework übernommen. Laravel bietet leistungsstarke Datenbanktools, einschließlich eines ORM (Object Relational Mapper) namens Eloquent und integrierte Mechanismen zur Erstellung von Datenbankmigrationen. Es wird mit einem Befehlszeilenwerkzeug namens Artisan geliefert, mit dem Entwickler neue Modelle, Controller und andere Anwendungsbestandteile erstellen können, was die gesamte Anwendungsentwicklung beschleunigt.
Die Containerisierung einer Anwendung bezieht sich auf den Prozess, eine Anwendung und ihre Komponenten so anzupassen, dass sie in leichten Umgebungen, die als Container bekannt sind, ausgeführt werden kann. Diese Anleitung verwendet Docker Compose, um eine Laravel-Anwendung für die Entwicklung zu containerisieren.
Wir werden drei Docker-Container für unsere Laravel-Anwendung erstellen.
- Ein
app-Dienst, der PHP 8.2-FPM ausführt - Ein
db-Dienst, der MySQL 8.0 ausführt - Ein
nginx-Dienst, der denapp-Dienst verwendet, um PHP-Code zu parsen, bevor die Laravel-Anwendung dem Benutzer bereitgestellt wird
Wir werden auch ein SSL-Zertifikat für unsere Laravel-Website mit Let’s Encrypt erstellen.
Voraussetzungen
- Ein Server, der Ubuntu 22.04 ausführt.
- Ein Nicht-Root-Benutzer mit Sudo-Rechten.
- Ein vollständig qualifizierter Domainname (FQDN), der auf Ihren Server zeigt. Für unsere Zwecke verwenden wir
example.comals Domainnamen. - Stellen Sie sicher, dass alles aktualisiert ist.
$ sudo apt update - Installieren Sie grundlegende Dienstprogramme. Einige davon sind möglicherweise bereits installiert.
$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
Schritt 1 - Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Ubuntu wird standardmäßig mit ufw (Uncomplicated Firewall) geliefert.
Überprüfen Sie, ob die Firewall aktiv ist.
$ sudo ufw status
Sie sollten die folgende Ausgabe erhalten.
Status: inactive
Erlauben Sie den SSH-Port, damit die Firewall die aktuelle Verbindung beim Aktivieren nicht unterbricht.
$ sudo ufw allow OpenSSH
Erlauben Sie auch die HTTP- und HTTPS-Ports.
$ sudo ufw allow http
$ sudo ufw allow https
Aktivieren Sie die Firewall
$ sudo ufw enable
Befehl kann bestehende SSH-Verbindungen stören. Mit der Operation fortfahren (y|n)? y
Firewall ist aktiv und beim Systemstart aktiviert
Überprüfen Sie den Status der Firewall erneut.
$ sudo ufw status
Sie sollten eine ähnliche Ausgabe sehen.
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
80/tcp ALLOW Anywhere
443 ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
80/tcp (v6) ALLOW Anywhere (v6)
443 (v6) ALLOW Anywhere (v6)
Schritt 2 - SSL installieren
Bevor wir fortfahren, lassen Sie uns zuerst ein SSL-Zertifikat für unsere Domain erstellen. Wir werden dies außerhalb von Docker erstellen, da es einfach zu warten ist. Wir werden später die Zertifikate mit dem Container synchronisieren, die regelmäßig erneuert und aktualisiert werden.
Wir müssen Certbot installieren, um das SSL-Zertifikat zu generieren. Sie können Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Ubuntu 22.04 wird standardmäßig mit Snapd installiert. Führen Sie die folgenden Befehle aus, um sicherzustellen, dass Ihre Version von Snapd auf dem neuesten Stand ist. Stellen Sie sicher, dass Ihre Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core
$ sudo snap refresh core
Installieren Sie Certbot.
$ sudo snap install --classic certbot
Verwenden Sie den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt wird, indem Sie einen symbolischen Link zum Verzeichnis /usr/bin erstellen.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Führen Sie den folgenden Befehl aus, um ein SSL-Zertifikat zu generieren.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d example.com
Der obige Befehl lädt ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/example.com auf Ihrem Server herunter.
Generieren Sie ein Diffie-Hellman-Gruppen-Zertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Führen Sie einen Testlauf des Prozesses durch, um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn Sie keine Fehler sehen, sind Sie bereit. Ihr Zertifikat wird automatisch erneuert.
Nach der Einrichtung von Docker und der Installation von Laravel muss der Erneuerungsprozess geändert werden. Wir werden dies in einem späteren Abschnitt behandeln.
Schritt 3 - Docker und Docker Compose installieren
Ubuntu 22.04 wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, importieren Sie zuerst den Docker GPG-Schlüssel.
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
Erstellen Sie eine Docker-Repository-Datei.
$ 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
Aktualisieren Sie die System-Repository-Liste.
$ sudo apt update
Installieren Sie die neueste Version von Docker.
$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin
Überprüfen Sie, ob es läuft.
$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Sat 2023-01-14 10:41:35 UTC; 2min 1s ago
TriggeredBy: ? docker.socket
Docs: https://docs.docker.com
Main PID: 2054 (dockerd)
Tasks: 52
Memory: 22.5M
CPU: 248ms
CGroup: /system.slice/docker.service
?? 2054 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
Standardmäßig benötigt Docker Root-Rechte. Wenn Sie vermeiden möchten, bei jedem Ausführen des docker-Befehls sudo zu verwenden, fügen Sie Ihren Benutzernamen zur docker-Gruppe hinzu.
$ sudo usermod -aG docker $(whoami)
Sie müssen sich von dem Server abmelden und wieder anmelden, um diese Änderung zu aktivieren, oder den folgenden Befehl verwenden.
$ su - ${USER}
Bestätigen Sie, dass Ihr Benutzer zur Docker-Gruppe hinzugefügt wurde.
$ groups
navjot wheel docker
Schritt 4 - Laravel herunterladen und Abhängigkeiten installieren
Der erste Schritt besteht darin, die neueste Version von Laravel herunterzuladen und die Abhängigkeiten, einschließlich Composer, dem PHP-Paketmanager, zu installieren.
Erstellen Sie das Verzeichnis für die Laravel-Anwendung.
$ mkdir ~/laravel
Wechseln Sie in das Verzeichnis.
$ cd ~/laravel
Klonen Sie die neueste Laravel-Version in das Verzeichnis. Vergessen Sie nicht das . am Ende des Befehls, was bedeutet, dass Git die Dateien in das aktuelle Verzeichnis klonen wird.
$ git clone https://github.com/laravel/laravel.git .
Verwenden Sie das Docker-Compose-Image, um die Verzeichnisse zu mounten, die Sie für Ihr Laravel-Projekt benötigen. Dies vermeidet die Notwendigkeit, Composer global zu installieren.
$ docker run --rm -v $(pwd):/app composer install
Der obige Befehl erstellt einen temporären Container, der an Ihr aktuelles Verzeichnis gebunden ist, bevor er entfernt wird. Er kopiert den Inhalt Ihres Laravel-Verzeichnisses in den Container und stellt sicher, dass der vendor-Ordner, den Composer im Container erstellt, zurück in das aktuelle Verzeichnis kopiert wird.
Setzen Sie die Berechtigungen für das Laravel-Verzeichnis so, dass es dem aktuell angemeldeten Benutzer gehört.
$ sudo chown -R $USER:$USER ~/laravel
Schritt 5 - Erstellen Sie die Docker-Compose-Datei
Erstellen Sie die Docker-Compose-Datei und öffnen Sie sie zur Bearbeitung.
$ nano docker-compose.yml
Fügen Sie den folgenden Code ein. Hier definieren wir drei Dienste: app, webserver und db. Ersetzen Sie MYSQL_ROOT_PASSWORD unter dem db-Dienst durch ein starkes Passwort Ihrer Wahl.
services:
app:
build:
context: .
dockerfile: Dockerfile
image: howtoforge/app
container_name: app
restart: unless-stopped
tty: true
environment:
SERVICE_NAME: app
SERVICE_TAGS: dev
working_dir: /var/www
volumes:
- ./:/var/www
- ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
networks:
- app-network
webserver:
container_name: webserver
image: nginx:alpine
restart: unless-stopped
tty: true
ports:
- 80:80
- 443:443
volumes:
- ./:/var/www
- ./nginx/conf.d:/etc/nginx/conf.d
- ./nginx/logs:/var/log/nginx
- /etc/ssl/certs/dhparam.pem:/etc/ssl/certs/dhparam.pem
- /etc/letsencrypt:/etc/letsencrypt
logging:
options:
max-size: "10m"
max-file: "3"
networks:
- app-network
db:
image: mysql:latest
container_name: db
restart: unless-stopped
tty: true
ports:
- "3306:3306"
environment:
MYSQL_DATABASE: laravel
MYSQL_ROOT_PASSWORD: MYSQL_ROOT_PASSWORD
MYSQL_USER: laraveluser
MYSQL_PASSWORD: password
SERVICE_TAGS: dev
SERVICE_NAME: mysql
volumes:
- dbdata:/var/lib/mysql
- ./mysql/my.cnf:/etc/mysql/my.cnf
networks:
- app-network
volumes:
dbdata:
driver: local
networks:
app-network:
driver: bridge
Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.
Lassen Sie uns die Dienste im Detail durchgehen.
app- Dieser Dienst definiert die Laravel-Anwendung und verwendet ein benutzerdefiniertes Docker-Image mit dem Titelhowtoforge/app. Wir werden dieses Image im nächsten Schritt erstellen. Das Arbeitsverzeichnis für Laravel im Container ist auf/var/wwwfestgelegt, das mit dem aktuellen Verzeichnis auf dem Host verknüpft ist. Wir mounten auch eine PHP-Konfigurationsdatei, die in den PHP-Container kopiert wird. Wir werden dies in einem späteren Schritt konfigurieren.webserver- Dieser Dienst erstellt einen Container mit dem Nginx-Docker-Image und öffnet die Ports 80 und 443 für den Host. Wir mounten auch Volumes für Nginx-Protokolle, benutzerdefinierte Konfiguration, das Laravel-Anwendungsverzeichnis und SSL-Zertifikate.db- Dieser Dienst erstellt einen Container mit dem MySQL-Docker-Image und definiert Umgebungsvariablen zur Einrichtung des Datenbanknamens und des MySQL-Root-Passworts. Sie können die Datenbank nach Belieben benennen undMYSQL_ROOT_PASSWORDdurch ein starkes Passwort Ihrer Wahl ersetzen. Setzen Sie auch den MySQL-Benutzernamen (MYSQL_USER_NAME) und das Passwort (MYSQL_USER_PASSWORD), die Zugriff auf die von Ihnen gewählte Datenbank haben. Dieser Dienst mappt auch den Port 3306 vom Container auf den Port 3306 des Hosts. Wir mounten auch ein Volume für die benutzerdefinierte MySQL-Konfiguration und ein lokales Volume für MySQL-Daten. Dies ermöglicht es Ihnen, dendb-Dienst neu zu starten, ohne die Daten zu verlieren.
Um die Kommunikation zwischen den Diensten zu ermöglichen, haben wir ein Docker-Netzwerk namens app-network erstellt. Es ist als Bridge-Netzwerk konfiguriert. Es ermöglicht Containern, die damit verbunden sind, miteinander zu kommunizieren. Der Bridge-Netzwerktreiber installiert Regeln auf der Hostmaschine, sodass Container in verschiedenen Bridge-Netzwerken nicht direkt miteinander kommunizieren können.
Schritt 6 - Erstellen Sie die Dockerfile
Eine Dockerfile wird verwendet, um benutzerdefinierte Images zu erstellen. Es gibt kein Standard-Image für Laravel, weshalb wir eine Dockerfile definieren müssen, um ein benutzerdefiniertes Image für Laravel zu erstellen. Es enthält Befehle zur Installation von Paketen und zur Konfiguration der Linux-Umgebung, abhängig von den Anforderungen Ihrer Anwendung. Sie können Ihr benutzerdefiniertes Image auch auf Docker Hub oder in ein privates Docker-Registry veröffentlichen. Weitere Informationen finden Sie in unserem Dockerfile-Tutorial.
Erstellen Sie die Dockerfile und öffnen Sie sie zur Bearbeitung.
$ nano Dockerfile
Fügen Sie den folgenden Code ein.
FROM php:8.2-fpm
# Kopiere composer.lock und composer.json
COPY composer.lock composer.json /var/www/
# Arbeitsverzeichnis festlegen
WORKDIR /var/www
# Abhängigkeiten installieren
RUN apt-get update && apt-get install -y \
build-essential \
libpng-dev \
libjpeg62-turbo-dev \
libfreetype6-dev \
locales \
zip \
jpegoptim optipng pngquant gifsicle \
vim \
libzip-dev \
unzip \
git \
curl \
libonig-dev
# Cache leeren
RUN apt-get clean && rm -rf /var/lib/apt/lists/*
# Erweiterungen installieren
RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl
RUN docker-php-ext-configure gd --enable-gd --with-freetype --with-jpeg
RUN docker-php-ext-install gd
# Composer installieren
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
# Bestehende Anwendungsinhaltsverzeichnisse in das Arbeitsverzeichnis kopieren
COPY . /var/www
# Berechtigungen des Arbeitsverzeichnisses dem www-data-Benutzer zuweisen
RUN chown -R www-data:www-data \
/var/www/storage \
/var/www/bootstrap/cache
# Schreibberechtigungen für Protokolle und Framework-Verzeichnisse zuweisen
RUN chmod 775 storage/logs \
/var/www/storage/framework/sessions \
/var/www/storage/framework/views
# Port 9000 freigeben und php-fpm-Server starten
EXPOSE 9000
CMD ["php-fpm"]
Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.
Lassen Sie uns sehen, was hier passiert. Zuerst erstellen wir unser benutzerdefiniertes Image auf der Grundlage des php:8.2-fpm-Docker-Images. Dies ist ein Debian-basiertes Image, das PHP 8.2-FPM installiert hat. Die Dockerfile verwendet verschiedene Direktiven, um Operationen durchzuführen. Die RUN-Direktive gibt die Befehle an, um Einstellungen im Container zu aktualisieren, zu installieren und zu konfigurieren, die COPY-Direktive, um Dateien in den Container zu kopieren, die EXPOSE-Direktive, um einen Port im Container freizugeben, und die CMD-Direktive, um einen Befehl auszuführen.
Zuerst kopieren wir die Composer-Dateien aus dem Laravel-Verzeichnis auf dem Host in den Container in das Verzeichnis /var/www. Wir setzen auch das Arbeitsverzeichnis für den Container auf /var/www. Dann installieren wir verschiedene Voraussetzungen und Pakete, die erforderlich sind, damit Laravel funktioniert, einschließlich PHP-Erweiterungen wie mbstring, gd, exif, zip, pdo_mysql und pcntl. Danach installieren wir den Composer-Paketmanager.
Als nächstes kopieren wir alle Dateien aus dem Laravel-Verzeichnis in den Container und setzen die Berechtigungen für das Arbeitsverzeichnis für den www-data-Benutzer. Dies ist der Benutzer, den PHP standardmäßig auf der Debian-Plattform verwendet. Schließlich geben wir den 9000-Port für den PHP-FPM-Dienst frei, der vom Nginx-Server verwendet wird, und führen den PHP-Befehl aus, um den Container zu starten.
Schritt 7 - PHP konfigurieren
Erstellen Sie das PHP-Verzeichnis.
$ mkdir ~/laravel/php
Erstellen Sie die Datei local.ini zur Bearbeitung.
$ nano local.ini
Fügen Sie den folgenden Code ein.
upload_max_filesize=40M
post_max_size=40M
Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben. Diese Direktiven setzen die maximale Größe für hochgeladene Dateien. Ändern Sie den Wert nach Ihren Anforderungen. Sie können jede PHP-spezifische Konfiguration hinzufügen, um die Standarddirektiven zu überschreiben.
Schritt 8 - Nginx konfigurieren
Erstellen Sie das Nginx-Verzeichnis für die Site-Konfiguration.
$ mkdir ~/laravel/nginx/conf.d -p
Wir müssen eine Nginx-Konfigurationsdatei erstellen, um PHP-FPM als FastCGI-Server zu verwenden, um Laravel bereitzustellen.
Erstellen Sie die Datei app.conf zur Bearbeitung.
$ nano ~/laravel/nginx/conf.d/app.conf
Fügen Sie den folgenden Code ein.
server {
# Leite alle http-Anfragen zu https um
listen 80;
listen [::]:80;
server_name example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
index index.php index.html;
error_log /var/log/nginx/error.log;
access_log /var/log/nginx/access.log;
root /var/www/public;
client_max_body_size 40m;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_prefer_server_ciphers off;
ssl_ecdh_curve secp384r1;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
# OCSP-Stapling
ssl_stapling on;
ssl_stapling_verify on;
resolver 8.8.8.8 8.8.4.4 valid=300s;
resolver_timeout 5s;
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;
}
location / {
try_files $uri $uri/ /index.php?$query_string;
gzip_static on;
}
}
Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.
Die obige Datei konfiguriert Nginx, um sowohl die HTTP- als auch die HTTPS-Version der Laravel-Website bereitzustellen und automatisch jede HTTP-Anfrage auf HTTPS umzuleiten. Stellen Sie sicher, dass der Wert der Variablen client_max_body_size mit der im vorherigen Schritt festgelegten Upload-Größe übereinstimmt.
Im PHP-Standortblock gibt die fastcgi_pass-Direktive an, dass der app-Dienst auf einem TCP-Socket auf Port 9000 lauscht. Der PHP-FPM-Server kann auch auf einem Unix-Socket lauschen, was einen Vorteil gegenüber einem TCP-Socket hat. Aber es funktioniert nicht, wenn die Dienste auf verschiedenen Hosts ausgeführt werden, was hier der Fall ist, da der app-Container auf einem anderen Host als Ihr webserver-Container ausgeführt wird.
Schritt 9 - MySQL konfigurieren
Wir werden MySQL konfigurieren, um das allgemeine Abfrageprotokoll zu aktivieren und die entsprechende Protokolldatei anzugeben.
Erstellen Sie das MySQL-Verzeichnis.
$ mkdir ~/laravel/mysql
Erstellen Sie die Datei my.cnf zur Bearbeitung.
$ nano ~/laravel/my.cnf
Fügen Sie den folgenden Code ein.
[mysqld]
general_log = 1
general_log_file = /var/lib/mysql/general.log
Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.
Schritt 10 - Einrichten der Umgebungsdatei
Jetzt, da wir alle Dienste erstellt und konfiguriert haben, ist es Zeit, die Container zu starten. Aber bevor wir das tun, müssen wir die Umgebungsvariablen für Laravel konfigurieren. Laravel kommt mit einer Standard-Umgebungsdatei, .env.example.
Erstellen Sie eine Kopie der Beispiel-Umgebungsdatei.
$ cp .env.example .env
Öffnen Sie die .env-Datei zur Bearbeitung.
$ nano .env
Suchen Sie den Block, der mit DB_CONNECTION beginnt, und aktualisieren Sie die Werte der Variablen gemäß Ihren Anforderungen.
DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laraveluser
DB_PASSWORD=your_laravel_db_password
Der Wert von DB_HOST wird der db-Dienst sein. Die Werte von DB_NAME, DB_USERNAME und DB_PASSWORD werden der Datenbankname, der Benutzername und das Passwort sein, die Sie im Schritt 4 in der Docker-Compose-Datei gewählt haben.
Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.
Schritt 11 - Starten Sie die Container und schließen Sie die Laravel-Installation ab
Es ist endlich Zeit, die Container zu starten.
$ docker compose up -d
Dieser Befehl wird beim ersten Ausführen die Nginx-, MySQL-Images herunterladen und das app-Image mit der Dockerfile, die wir erstellt haben, erstellen. Sobald der Prozess abgeschlossen ist, können Sie den Status Ihrer Container mit dem folgenden Befehl überprüfen.
$ docker ps
Sie werden eine ähnliche Ausgabe sehen.
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a57be976c0fa mysql:latest "docker-entrypoint.s…" 6 hours ago Up 6 hours 0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp db
85e515c4a404 howtoforge/app "docker-php-entrypoi…" 6 hours ago Up 6 hours 9000/tcp app
8418bbc83bd3 nginx:alpine "/docker-entrypoint.…" 6 hours ago Up 6 hours 0.0.0.0:80->80/tcp, :::80->80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp webserver
Sobald die Container laufen, ist es Zeit, die Laravel-Installation mit dem Befehl docker compose exec abzuschließen, um Befehle im Container auszuführen.
Generieren Sie einen Anwendungsschlüssel und kopieren Sie ihn in Ihre .env-Datei, um Benutzersitzungen zu sichern und Benutzerdaten zu verschlüsseln.
$ docker compose exec app php artisan key:generate
Erstellen Sie den Cache der Laravel-Anwendung.
$ docker compose exec app php artisan config:cache
Dieser Befehl lädt die Konfigurationseinstellungen in die Datei /var/www/bootstrap/cache/config.php.
Besuchen Sie https://example.com in Ihrem Browser und Sie werden die folgende Seite sehen, die die erfolgreiche Installation von Laravel impliziert.
Schritt 12 - Konfigurieren Sie die SSL-Erneuerung
Jetzt, da die Laravel-Website aktiv ist, ist es Zeit, die SSL-Einstellungen zu überprüfen, um die Erneuerung zu konfigurieren. Dazu müssen wir Skripte erstellen, um den webserver-Dienst vor dem Start der Erneuerung zu stoppen und den Dienst erneut zu starten, sobald das Zertifikat erneuert wurde. Certbot bietet zwei Hooks, pre_hook und post_hook, für diesen Zweck.
Erstellen Sie das SSL-Verzeichnis, um die Skripte zu speichern.
$ mkdir ~/laravel/ssl
Erstellen Sie das Skript server-stop.sh.
$ sh -c 'printf "#!/bin/sh\ndocker stop webserver\n" > ~/laravel/ssl/server-stop.sh'
Erstellen Sie das Skript server-start.sh.
$ sh -c 'printf "#!/bin/sh\ndocker start webserver\n" > ~/laravel/ssl/server-start.sh'
Machen Sie die Skripte ausführbar.
$ chmod +x ~/laravel/ssl/server-*.sh
Jetzt müssen wir Certbot mitteilen, diese Skripte zu verwenden. Öffnen Sie die Datei /etc/letsencrypt/renewal/example.com.conf zur Bearbeitung.
$ sudo nano /etc/letsencrypt/renewal/example.com.conf
Fügen Sie die folgenden Zeilen am Ende der Datei ein.
pre_hook = /home//laravel/ssl/server-stop.sh
post_hook = /home//laravel/ssl/server-start.sh
Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.
Testen Sie den Zertifikatserneuerungsprozess, indem Sie einen Testlauf durchführen.
$ sudo certbot renew --dry-run
Sie erhalten eine ähnliche Ausgabe, die den Erfolg bestätigt.
Saving debug log to /var/log/letsencrypt/letsencrypt.log
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Processing /etc/letsencrypt/renewal/example.com.conf
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Account registered.
Hook 'pre-hook' ran with output:
webserver
Simulating renewal of an existing certificate for example.com
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Congratulations, all simulated renewals succeeded:
/etc/letsencrypt/live/example.com/fullchain.pem (success)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Hook 'post-hook' ran with output:
webserver
Ihre SSL-Zertifikate werden nun automatisch erneuert und vom Docker-Container verwendet, um Ihre Laravel-Anwendung bereitzustellen.
Schritt 13 - Datenmigration und Tinker-Konsole
Jetzt, da die Anwendung läuft, können Sie Ihre Daten migrieren und mit dem Befehl tinker experimentieren. Tinker ist eine REPL (Read-Eval-Print Loop) für Laravel. Der Befehl tinker startet eine PsySH-Konsole mit vorinstalliertem Laravel. PsySH ist eine Laufzeit-Entwicklerkonsole und ein interaktiver Debugger für PHP. Der Befehl tinker ermöglicht es Ihnen, mit der Laravel-Anwendung über die Befehlszeile in einer interaktiven Shell zu interagieren.
Testen Sie die MySQL-Verbindung mit dem Befehl artisan migrate im Container. Dadurch wird eine migrations-Tabelle in der Datenbank erstellt.
$ docker compose exec app php artisan migrate
Sie erhalten die folgende Ausgabe.
INFO Preparing database.
Creating migration table .............................................................................................. 32ms DONE
INFO Running migrations.
2014_10_12_000000_create_users_table .................................................................................. 184ms DONE
2014_10_12_100000_create_password_resets_table ......................................................................... 259ms DONE
2019_08_19_000000_create_failed_jobs_table ............................................................................ 102ms DONE
2019_12_14_000001_create_personal_access_tokens_table .................................................................. 46ms DONE
Starten Sie als nächstes die PsySH-Konsole mit dem Befehl tinker.
$ docker compose exec app php artisan tinker
Sie erhalten die folgende Eingabeaufforderung.
Psy Shell v0.11.10 (PHP 8.2.1 — cli) by Justin Hileman
>
Testen Sie die MySQL-Verbindung, indem Sie die Daten abrufen, die Sie gerade migriert haben, indem Sie den folgenden Befehl an der Konsoleneingabeaufforderung ausführen.
> \DB::table('migrations')->get();
Sie erhalten die folgende Ausgabe.
= Illuminate\Support\Collection {#3670
all: [
{#3679
+"id": 1,
+"migration": "2014_10_12_000000_create_users_table",
+"batch": 1,
},
{#3681
+"id": 2,
+"migration": "2014_10_12_100000_create_password_resets_table",
+"batch": 1,
},
{#3682
+"id": 3,
+"migration": "2019_08_19_000000_create_failed_jobs_table",
+"batch": 1,
},
{#3683
+"id": 4,
+"migration": "2019_12_14_000001_create_personal_access_tokens_table",
+"batch": 1,
},
],
}
Geben Sie exit ein, um die Konsole zu verlassen.
> exit
INFO Goodbye.
Sie können tinker verwenden, um mit Ihren Datenbanken zu interagieren und mit Diensten und Modellen zu experimentieren. Sie können nun mit der weiteren Entwicklung in Laravel beginnen.
Fazit
Damit schließen wir unser Tutorial ab, in dem Sie die Laravel-Anwendung mit Docker, MySQL und PHP containerisiert und installiert haben. Sie haben die Anwendung auch auf einem sicheren Domainnamen bereitgestellt. Wenn Sie Fragen haben, posten Sie diese bitte in die Kommentare unten.
Erhalte neue Beiträge in deinem Posteingang.
Kein Spam. Jederzeit abmelden.