Wie installiere ich Laravel mit Docker auf Ubuntu 22.04

Laravel ist ein freies und quelloffenes PHP-Framework, das eine Reihe von Tools und Ressourcen für die Entwicklung moderner PHP-Anwendungen bereitstellt. Mit einer Vielzahl von kompatiblen Paketen und Erweiterungen ist Laravel so beliebt, dass viele Entwickler es zu ihrem bevorzugten Framework gemacht haben. Laravel bietet leistungsstarke Datenbankwerkzeuge, darunter ein ORM (Object Relational Mapper) namens Eloquent und integrierte Mechanismen zur Erstellung von Datenbankmigrationen. Laravel wird mit dem Kommandozeilen-Tool Artisan ausgeliefert, mit dem Entwickler neue Modelle, Controller und andere Anwendungskomponenten booten können, was die gesamte Anwendungsentwicklung beschleunigt.

Als Containerisierung einer Anwendung wird der Prozess bezeichnet, bei dem eine Anwendung und ihre Komponenten so angepasst werden, dass sie in leichtgewichtigen Umgebungen, so genannten Containern, ausgeführt werden können. In diesem Leitfaden wird Docker Compose verwendet, um eine Laravel-Anwendung für die Entwicklung zu containerisieren.

Wir werden drei Docker-Container für unsere Laravel-Anwendung erstellen.

• Einen app Dienst, auf dem PHP 8.2-FPM läuft
• Einen db Dienst, auf dem MySQL 8.0 läuft
• Einen nginx Dienst, der den app Dienst nutzt, um den PHP-Code zu parsen, bevor er die Laravel-Anwendung an den Nutzer ausliefert

Außerdem werden wir ein SSL-Zertifikat für unsere Laravel-Website mit Let’s Encrypt erstellen.

Voraussetzungen

• Ein Server, auf dem Ubuntu 22.04 läuft.
• Ein Nicht-Root-Benutzer mit sudo-Rechten.
• Ein vollständig qualifizierter Domainname (FQDN), der auf deinen Server verweist. Für unsere Zwecke werden wir example.com als Domänennamen verwenden.
• Stelle sicher, dass alles auf dem neuesten Stand ist.

  $ sudo apt update
  

• Installiere grundlegende Hilfspakete. Einige von ihnen sind vielleicht schon 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) ausgeliefert.

Überprüfe, ob die Firewall aktiv ist.

$ sudo ufw status

Du solltest die folgende Ausgabe erhalten.

Status: inactive

Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.

$ sudo ufw allow OpenSSH

Lasse auch HTTP- und HTTPS-Ports zu.

$ sudo ufw allow http
$ sudo ufw allow https

Aktiviere die Firewall

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Überprüfe den Status der Firewall erneut.

$ sudo ufw status

Du solltest 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, müssen wir zunächst ein SSL-Zertifikat für unsere Domain erstellen. Wir werden es außerhalb von Docker erstellen, da es einfach zu verwalten ist. Später werden wir die Zertifikate mit dem Container synchronisieren, damit sie regelmäßig erneuert werden können.

Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Ubuntu-Repository installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist. Vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core
$ sudo snap refresh core

Installiere Certbot.

$ sudo snap install --classic certbot

Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt wird, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d example.com

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, bist du bereit. Dein 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, musst du zunächst den Docker GPG-Schlüssel importieren.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Erstelle 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

Aktualisiere die Liste der System-Repositorys.

$ sudo apt update

Installiere die neueste Version von Docker.

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Überprüfe, ob sie 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 du vermeiden möchtest, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.

$ sudo usermod -aG docker $(whoami)

Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden oder den folgenden Befehl verwenden.

$ su - ${USER}

Bestätige, dass dein Benutzer der Docker-Gruppe hinzugefügt wurde.

$ groups
navjot wheel docker

Schritt 4 – Herunterladen von Laravel und Installieren der Abhängigkeiten

Der erste Schritt besteht darin, die neueste Version von Laravel herunterzuladen und die Abhängigkeiten zu installieren, einschließlich Composer, dem PHP-Paketmanager.

Erstelle das Laravel-Anwendungsverzeichnis.

$ mkdir ~/laravel

Wechsle in das Verzeichnis.

$ cd ~/laravel

Klone die neueste Laravel-Version in das Verzeichnis. Vergiss nicht das . am Ende des Befehls, das bedeutet, dass Git die Dateien in das aktuelle Verzeichnis klont.

$ git clone https://github.com/laravel/laravel.git .

Verwende das Compose-Image von Docker, um die Verzeichnisse zu mounten, die du für dein Laravel-Projekt brauchst. So musst du Composer nicht global installieren.

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

Der obige Befehl erstellt einen ephemeren Container, der in dein aktuelles Verzeichnis gemountet wird, bevor er wieder entfernt wird. Er kopiert den Inhalt deines Laravel-Verzeichnisses in den Container und stellt sicher, dass der Ordner vendor, den Composer innerhalb des Containers erstellt, zurück in das aktuelle Verzeichnis kopiert wird.

Lege die Berechtigungen für das Laravel-Verzeichnis so fest, dass es dem aktuell angemeldeten Benutzer gehört.

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

Schritt 5 – Erstellen der Docker Compose-Datei

Erstelle und öffne die Docker Compose-Datei zur Bearbeitung.

$ nano docker-compose.yml

Füge den folgenden Code in die Datei ein. Hier definieren wir drei Dienste: app, webserver, und db. Ersetze MYSQL_ROOT_PASSWORD unter dem Dienst db durch ein starkes Passwort deiner 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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Schauen wir uns die Dienste im Detail an.

• app – Dieser Dienst definiert die Laravel-Anwendung und führt ein Kunden-Docker-Image mit dem Namen howtoforge/app aus. Wir werden dieses Image im nächsten Schritt erstellen. Das Arbeitsverzeichnis für Laravel innerhalb des Containers wird auf /var/www gesetzt, das auf das aktuelle Verzeichnis auf dem Host abgebildet wird. Wir hängen auch eine PHP-Konfigurationsdatei ein, die in den PHP-Container kopiert wird. Wir werden diese in einem späteren Schritt konfigurieren.
• webserver – Dieser Dienst erstellt einen Container mit dem Nginx-Docker-Image und gibt die Ports 80 und 443 für den Host frei. Außerdem binden wir Volumes für Nginx-Protokolle, die benutzerdefinierte Konfiguration, das Laravel-Anwendungsverzeichnis und SSL-Zertifikate ein.
• db – Dieser Dienst erstellt einen Container mit dem MySQL-Docker-Image und definiert Umgebungsvariablen, in denen der Datenbankname und das MySQL-Root-Passwort festgelegt werden. Du kannst die Datenbank benennen, wie du willst, und MYSQL_ROOT_PASSWORD durch ein starkes Passwort deiner Wahl ersetzen. Lege auch den MySQL-Benutzernamen (MYSQL_USER_NAME) und das Passwort (MYSQL_USER_PASSWORD) fest, die Zugriff auf die von dir gewählte Datenbank haben werden. Dieser Dienst ordnet auch den Port 3306 des Containers dem Port 3306 auf dem Host zu. Wir binden auch ein Volume für die benutzerdefinierte MySQL-Konfiguration und ein lokales Volume für die MySQL-Daten ein. So kannst du den Dienst db neu starten, ohne die Daten zu verlieren.

Damit die Dienste miteinander kommunizieren können, haben wir ein Docker-Netzwerk namens app-network erstellt. Es ist als Bridge-Netzwerk eingerichtet. Es ermöglicht den daran angeschlossenen Containern, miteinander zu kommunizieren. Der Bridge-Netzwerktreiber installiert Regeln auf dem Host-Rechner, damit Container in verschiedenen Bridge-Netzen nicht direkt miteinander kommunizieren können.

Schritt 6 – Erstellen des Dockerfiles

Ein Dockerfile wird verwendet, um eigene Images zu erstellen. Es gibt kein Standard-Image für Laravel, deshalb müssen wir ein Dockerfile definieren, um ein eigenes Image für Laravel zu erstellen. Es enthält Befehle zur Installation von Paketen und zur Konfiguration der Linux-Umgebung je nach den Anforderungen deiner Anwendung. Du kannst dein benutzerdefiniertes Image auch auf Docker Hub oder einer privaten Docker-Registry veröffentlichen. Mehr dazu erfährst du in unserem Dockerfile-Anleitung.

Erstelle und öffne das Dockerfile zum Bearbeiten.

$ nano Dockerfile

Füge den folgenden Code in die Datei ein.

FROM php:8.2-fpm

# Copy composer.lock and composer.json
COPY composer.lock composer.json /var/www/

# Set working directory
WORKDIR /var/www

# Install dependencies
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

# Clear cache
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

# Install extensions
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

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

# Copy existing application directory contents to the working directory
COPY . /var/www

# Assign permissions of the working directory to the www-data user
RUN chown -R www-data:www-data \
        /var/www/storage \
        /var/www/bootstrap/cache

# Assign writing permissions to logs and framework directories
RUN chmod 775 storage/logs \
        /var/www/storage/framework/sessions \
        /var/www/storage/framework/views

# Expose port 9000 and start php-fpm server
EXPOSE 9000
CMD ["php-fpm"]

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Lass uns sehen, was hier passiert. Zuerst erstellen wir unser eigenes Image auf dem php:8.2-fpm Docker-Image. Dies ist ein Debian-basiertes Image, auf dem PHP 8.2-FPM installiert ist. Das Dockerfile verwendet verschiedene Direktiven, um Operationen auszuführen. Die Direktive RUN gibt die Befehle zum Aktualisieren, Installieren und Konfigurieren von Einstellungen innerhalb des Containers an, die Direktive COPY zum Kopieren von Dateien in den Container, die Direktive EXPOSE zum Freigeben eines Ports im Container und die Direktive CMD zum Ausführen eines Befehls.

Zuerst kopieren wir die Composer-Dateien aus dem Laravel-Verzeichnis auf dem Host in das Verzeichnis /var/www. Außerdem setzen wir das Arbeitsverzeichnis des Containers auf /var/www. Dann installieren wir verschiedene Voraussetzungen und Pakete, die Laravel benötigt, um zu funktionieren, darunter die PHP-Erweiterungen mbstring, gd, exif, zip, pdo_mysql und pcntl. Dann 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 Benutzer www-data. Dies ist der Benutzer, den PHP standardmäßig auf der Debian-Plattform verwendet. Als Nächstes setzen wir die korrekten Schreibrechte für die Verzeichnisse Laravel logs, sessions und views.

Schließlich geben wir den Port 9000 für den PHP-FPM-Dienst frei, der vom Nginx-Server verwendet wird, und starten den PHP-Befehl, um den Container zu starten.

Schritt 7 – PHP konfigurieren

Erstelle das PHP-Verzeichnis.

$ mkdir ~/laravel/php

Erstelle und öffne die Datei local.ini zum Bearbeiten.

$ nano local.ini

Füge den folgenden Code in die Datei ein.

upload_max_filesize=40M
post_max_size=40M

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Diese Direktiven legen die maximale Größe für hochgeladene Dateien fest. Ändere den Wert entsprechend deinen Anforderungen. Du kannst jede PHP-spezifische Konfiguration einfügen, um die Standarddirektiven zu überschreiben.

Schritt 8 – Nginx konfigurieren

Erstelle das Nginx-Verzeichnis für die Konfiguration der Website.

$ mkdir ~/laravel/nginx/conf.d -p

Wir müssen eine Nginx-Konfigurationsdatei erstellen, um PHP-FPM als FastCGI-Server für Laravel zu verwenden.

Erstelle und öffne die Datei app.conf zum Bearbeiten.

$ nano ~/laravel/nginx/conf.d/app.conf

Füge den folgenden Code in die Datei ein.

server {
    # Redirect any http requests to https
    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;
    }
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Die obige Datei konfiguriert Nginx so, dass es sowohl die HTTP- als auch die HTTPS-Version der Laravel-Website bedient und jede HTTP-Anfrage automatisch auf HTTPS umleitet. Vergewissere dich, dass der Wert der Variable client_max_body_size mit der im vorherigen Schritt eingestellten Uploadgröße übereinstimmt.

Im PHP-Location-Block gibt die Direktive fastcgi_pass an, dass der Dienst app an einem TCP-Socket auf Port 9000 lauscht. Der PHP-FPM-Server kann auch an einem Unix-Socket lauschen, was einen Vorteil gegenüber einem TCP-Socket hat. Das funktioniert aber nicht, wenn die Dienste auf verschiedenen Hosts laufen, was hier der Fall ist, da der app Container auf einem anderen Host läuft als dein webserver Container.

Schritt 9 – MySQL konfigurieren

Wir konfigurieren MySQL, um das allgemeine Abfrageprotokoll zu aktivieren und die entsprechende Protokolldatei anzugeben.

Erstelle das MySQL-Verzeichnis.

$ mkdir ~/laravel/mysql

Erstelle und öffne die Datei my.cnf zum Bearbeiten.

$ nano ~/laravel/my.cnf

Füge den folgenden Code in die Datei ein.

[mysqld]
general_log = 1
general_log_file = /var/lib/mysql/general.log

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Schritt 10 – Einrichten der Umgebungsdatei

Nachdem wir nun alle Dienste erstellt und konfiguriert haben, ist es an der Zeit, die Container zu starten. Doch vorher müssen wir die Umgebungsvariablen für Laravel konfigurieren. Laravel wird mit einer Standard-Umgebungsdatei geliefert: .env.example.

Erstelle eine Kopie der Beispiel-Umgebungsdatei.

$ cp .env.example .env

Öffne die Datei .env zum Bearbeiten.

$ nano .env

Suche den Block, der mit DB_CONNECTION beginnt und ändere die Werte der Variablen entsprechend deinen 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. DB_NAME , DB_USERNAME und DB_PASSWORD sind der Name der Datenbank, der Benutzername und das Passwort, die du in Schritt 4 in der Docker Compose-Datei gewählt hast.

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Schritt 11 – Starte die Container und schließe die Laravel-Installation ab

Nun ist es an der Zeit, die Container zu starten.

$ docker compose up -d

Wenn du diesen Befehl zum ersten Mal ausführst, werden die Images Nginx und MySQL geladen und das Image app mit der von uns erstellten Dockerdatei erstellt. Sobald der Prozess abgeschlossen ist, kannst du den Status deiner Container mit dem folgenden Befehl überprüfen.

$ docker ps

Du wirst 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 an der Zeit, die Installation von Laravel mit dem Befehl docker compose exec abzuschließen, um Befehle innerhalb des Containers auszuführen.

Erstelle einen Anwendungsschlüssel und kopiere ihn in deine .env Datei, um Benutzersitzungen zu sichern und Benutzerdaten zu verschlüsseln.

$ docker compose exec app php artisan key:generate

Erstelle den Laravel-Anwendungscache.

$ docker compose exec app php artisan config:cache

Mit diesem Befehl werden die Konfigurationseinstellungen in die Datei /var/www/bootstrap/cache/config.php geladen.

Rufe https://example.com in deinem Browser auf und du wirst die folgende Seite sehen, die die erfolgreiche Installation von Laravel anzeigt.

Schritt 12 – SSL-Erneuerung konfigurieren

Jetzt, wo die Laravel-Website aktiv ist, ist es an der Zeit, die SSL-Einstellungen erneut zu überprüfen und die Erneuerung zu konfigurieren. Dazu müssen wir Skripte erstellen, um den Dienst webserver vor der Erneuerung anzuhalten und den Dienst wieder zu starten, sobald das Zertifikat erneuert wurde. Certbot bietet dafür zwei Hooks, pre_hook und post_hook.

Erstelle das SSL-Verzeichnis, um die Skripte zu speichern.

$ mkdir ~/laravel/ssl

Erstelle das Skript server-stop.sh.

$ sh -c 'printf "#!/bin/sh\ndocker stop webserver\n" > ~/laravel/ssl/server-stop.sh'

Erstelle das Skript server-start.sh.

$ sh -c 'printf "#!/bin/sh\ndocker start webserver\n" > ~/laravel/ssl/server-start.sh'

Mache die Skripte ausführbar.

$ chmod +x ~/laravel/ssl/server-*.sh

Nun müssen wir Certbot mitteilen, dass es diese Skripte verwenden soll. Öffne die Datei /etc/letsencrypt/renewal/example.com.conf zum Bearbeiten.

$ sudo nano /etc/letsencrypt/renewal/example.com.conf

Füge die folgenden Zeilen am Ende der Datei ein.

pre_hook = /home/<username>/laravel/ssl/server-stop.sh
post_hook = /home/<username>/laravel/ssl/server-start.sh

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Teste den Prozess der Zertifikatserneuerung, indem du einen Trockenlauf machst.

$ sudo certbot renew --dry-run

Du wirst eine ähnliche Ausgabe erhalten, 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

Deine SSL-Zertifikate werden nun automatisch erneuert und vom Docker-Container verwendet, um deine Laravel-Anwendung zu bedienen.

Schritt 13 – Datenmigration und Tinker-Konsole

Jetzt, wo die Anwendung läuft, kannst du deine 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. Mit dem Befehl tinker kannst du über die Kommandozeile in einer interaktiven Shell mit der Laravel-Anwendung interagieren.

Teste die MySQL-Verbindung mit dem Befehl artisan migrate im Container. Es wird eine Tabelle migrations in der Datenbank erstellt.

$ docker compose exec app php artisan migrate

Du wirst die folgende Ausgabe erhalten.

 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

Starte dann die PsySH-Konsole mit dem Befehl tinker.

$ docker compose exec app php artisan tinker

Du erhältst die folgende Eingabeaufforderung.

Psy Shell v0.11.10 (PHP 8.2.1 — cli) by Justin Hileman
>

Teste die MySQL-Verbindung, indem du die Daten abrufst, die du gerade migriert hast, indem du den folgenden Befehl in der Konsole eingibst.

> \DB::table('migrations')->get();

Du erhältst 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,
      },
    ],
  }

Gib exit ein, um die Konsole zu verlassen.

> exit
   INFO  Goodbye.

Du kannst tinker verwenden, um mit deinen Datenbanken zu interagieren und mit Diensten und Modellen zu experimentieren. Jetzt kannst du Laravel für die weitere Entwicklung nutzen.

Fazit

Damit ist unser Lernprogramm abgeschlossen. Du hast die Laravel-Anwendung mit Docker, MySQL und PHP containerisiert und installiert. Außerdem hast du die Anwendung unter einem sicheren Domainnamen bereitgestellt. Wenn du Fragen hast, schreibe sie unten in die Kommentare.