So installieren und konfigurieren Sie Laravel mit Docker Compose unter Ubuntu 22.04

Einführung

Zur Containerisierung Eine Anwendung bezieht sich auf den Prozess der Anpassung einer Anwendung und ihrer Komponenten, um sie in leichtgewichtigen Umgebungen, den sogenannten Containern, ausführen zu können. Solche Umgebungen sind isoliert und verfügbar und können zum Entwickeln, Testen und Bereitstellen von Anwendungen für die Produktion genutzt werden.

In diesem Leitfaden verwenden wir Docker Compose, um eine Laravel-Anwendung für die Entwicklung zu containerisieren. Wenn Sie fertig sind, haben Sie eine Laravel-Demoanwendung, die auf drei separaten Dienstcontainern ausgeführt wird:

• Eine app Dienst mit PHP7.4-FPM;
• Ein db Dienst, auf dem MySQL 5.7 ausgeführt wird;
• Ein nginx Dienst, der die app verwendet Dienst, um den PHP-Code zu parsen, bevor die Laravel-Anwendung dem Endbenutzer bereitgestellt wird.

Um einen optimierten Entwicklungsprozess zu ermöglichen und das Debuggen von Anwendungen zu erleichtern, halten wir Anwendungsdateien durch die Verwendung gemeinsam genutzter Volumes synchron. Wir werden auch sehen, wie man docker-compose exec verwendet Befehle zum Ausführen von Composer und Artisan in der app Behälter.

Voraussetzungen

• Zugriff auf einen lokalen Ubuntu 22.04-Computer oder Entwicklungsserver als Nicht-Root-Benutzer mit sudo-Berechtigungen. Wenn Sie einen Remote-Server verwenden, ist es ratsam, eine aktive Firewall installiert zu haben. Um diese einzurichten, lesen Sie bitte unseren Leitfaden zur Ersteinrichtung des Servers für Ubuntu 22.04.
• Docker auf Ihrem Server installiert, gemäß den Schritten 1 und 2 von So installieren und verwenden Sie Docker unter Ubuntu 22.04.
• Docker Compose auf Ihrem Server installiert, gemäß Schritt 1 von How To Install and Use Docker Compose on Ubuntu 22.04.

Schritt 1 – Abrufen der Demoanwendung

Zu Beginn holen wir die Laravel-Demoanwendung aus ihrem Github-Repository. Wir interessieren uns für tutorial-01 -Zweig, der die grundlegende Laravel-Anwendung enthält, die wir im ersten Leitfaden dieser Serie erstellt haben.

Um den Anwendungscode zu erhalten, der mit diesem Tutorial kompatibel ist, laden Sie die Version tutorial-1.0.1 herunter in Ihr Home-Verzeichnis mit:

cd ~
curl -L https://github.com/do-community/travellist-laravel-demo/archive/tutorial-1.0.1.zip -o travellist.zip

Wir brauchen den unzip Befehl zum Entpacken des Anwendungscodes. Falls Sie dieses Paket noch nicht installiert haben, tun Sie dies jetzt mit:

sudo apt update
sudo apt install unzip

Entpacken Sie nun den Inhalt der Anwendung und benennen Sie das entpackte Verzeichnis für einen einfacheren Zugriff um:

unzip travellist.zip
mv travellist-laravel-demo-tutorial-1.0.1 travellist-demo

Navigieren Sie zur travellist-demo Verzeichnis:

cd travellist-demo

Im nächsten Schritt erstellen wir eine .env Konfigurationsdatei zum Einrichten der Anwendung.

Schritt 2 – Einrichten der .env der Anwendung Datei

Die Laravel-Konfigurationsdateien befinden sich in einem Verzeichnis namens config , im Stammverzeichnis der Anwendung. Zusätzlich eine .env Datei wird verwendet, um eine umgebungsabhängige Konfiguration einzurichten, z. B. Anmeldeinformationen und alle Informationen, die zwischen Bereitstellungen variieren können. Diese Datei ist nicht in der Revisionskontrolle enthalten.

Warnung :Die Umgebungskonfigurationsdatei enthält vertrauliche Informationen über Ihren Server, einschließlich Datenbankanmeldeinformationen und Sicherheitsschlüssel. Aus diesem Grund sollten Sie diese Datei niemals öffentlich teilen.

Die in .env enthaltenen Werte Datei hat Vorrang vor den Werten, die in regulären Konfigurationsdateien in config festgelegt sind Verzeichnis. Jede Installation in einer neuen Umgebung erfordert eine maßgeschneiderte Umgebungsdatei, um unter anderem Dinge wie Datenbankverbindungseinstellungen, Debug-Optionen, Anwendungs-URL zu definieren, die je nach Umgebung, in der die Anwendung ausgeführt wird, variieren können.

Wir erstellen jetzt eine neue .env Datei, um die Konfigurationsoptionen für die Entwicklungsumgebung anzupassen, die wir einrichten. Laravel wird mit einem Beispiel.env geliefert Datei, die wir kopieren können, um unsere eigene zu erstellen:

cp .env.example .env

Öffnen Sie diese Datei mit nano oder den Texteditor Ihrer Wahl:

nano .env

Die aktuelle .env Datei aus der travellist Demo-Anwendung enthält Einstellungen zur Verwendung einer lokalen MySQL-Datenbank mit 127.0.0.1 als Datenbankhost. Wir müssen den DB_HOST aktualisieren -Variable, sodass sie auf den Datenbankdienst verweist, den wir in unserer Docker-Umgebung erstellen werden. In dieser Anleitung nennen wir unseren Datenbankdienst db . Fahren Sie fort und ersetzen Sie den aufgelisteten Wert von DB_HOST mit dem Datenbankdienstnamen:

.env

APP_NAME=Travellist
APP_ENV=dev
APP_KEY=
APP_DEBUG=true
APP_URL=http://localhost:8000

LOG_CHANNEL=stack

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=travellist
DB_USERNAME=travellist_user
DB_PASSWORD=password
...

Wenn Sie möchten, können Sie auch den Datenbanknamen, den Benutzernamen und das Passwort ändern. Diese Variablen werden in einem späteren Schritt genutzt, in dem wir docker-compose.yml einrichten Datei, um unsere Dienste zu konfigurieren.

Speichern Sie die Datei, wenn Sie mit der Bearbeitung fertig sind. Wenn Sie nano verwendet haben , können Sie dies tun, indem Sie Ctrl+x drücken , dann Y und Enter zu bestätigen.

Schritt 3 – Dockerfile der Anwendung einrichten

Obwohl sowohl unsere MySQL- als auch unsere Nginx-Dienste auf Standard-Images basieren, die vom Docker Hub bezogen werden, müssen wir dennoch ein benutzerdefiniertes Image für den Anwendungscontainer erstellen. Dafür erstellen wir ein neues Dockerfile.

Unsere Reiseliste image basiert auf php:7.4-fpm offizielles PHP-Image von Docker Hub. Zusätzlich zu dieser grundlegenden PHP-FPM-Umgebung installieren wir einige zusätzliche PHP-Module und das Abhängigkeitsverwaltungstool Composer.

Wir werden auch einen neuen Systembenutzer erstellen; dies ist notwendig, um artisan auszuführen und composer Befehle während der Entwicklung der Anwendung. Die uid Die Einstellung stellt sicher, dass der Benutzer innerhalb des Containers dieselbe UID hat wie Ihr Systembenutzer auf Ihrem Hostcomputer, auf dem Sie Docker ausführen. Auf diese Weise werden alle mit diesen Befehlen erstellten Dateien mit den richtigen Berechtigungen auf dem Host repliziert. Das bedeutet auch, dass Sie den Code-Editor Ihrer Wahl auf dem Hostcomputer verwenden können, um die Anwendung zu entwickeln, die in Containern ausgeführt wird.

Erstellen Sie ein neues Dockerfile mit:

nano Dockerfile

Kopieren Sie den folgenden Inhalt in Ihr Dockerfile:

Dockerfile

FROM php:7.4-fpm

# Arguments defined in docker-compose.yml
ARG user
ARG uid

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip

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

# Install PHP extensions
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

# Get latest Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Create system user to run Composer and Artisan Commands
RUN useradd -G www-data,root -u $uid -d /home/$user $user
RUN mkdir -p /home/$user/.composer && \
    chown -R $user:$user /home/$user

# Set working directory
WORKDIR /var/www

USER $user

Vergessen Sie nicht, die Datei zu speichern, wenn Sie fertig sind.

Unser Dockerfile beginnt mit der Definition des Basis-Images, das wir verwenden:php:7.4-fpm .

Nach der Installation von Systempaketen und PHP-Erweiterungen installieren wir Composer, indem wir den composer kopieren ausführbar von seinem neuesten offiziellen Image zu unserem eigenen Anwendungs-Image.

Anschließend wird ein neuer Systembenutzer angelegt und mit dem user eingerichtet und uid Argumente, die am Anfang des Dockerfiles deklariert wurden. Diese Werte werden von Docker Compose zur Build-Zeit eingefügt.

Schließlich legen wir das Standardarbeitsverzeichnis als /var/www fest und wechseln Sie zum neu erstellten Benutzer. Dadurch wird sichergestellt, dass Sie sich als normaler Benutzer verbinden und dass Sie sich im richtigen Verzeichnis befinden, wenn Sie composer ausführen und artisan Befehle im Anwendungscontainer.

Schritt 4 – Einrichten von Nginx-Konfigurations- und Datenbank-Dump-Dateien

Beim Erstellen von Entwicklungsumgebungen mit Docker Compose ist es oft notwendig, Konfigurations- oder Initialisierungsdateien mit Dienstcontainern zu teilen, um diese Dienste einzurichten oder zu booten. Diese Vorgehensweise erleichtert das Vornehmen von Änderungen an Konfigurationsdateien zur Feinabstimmung Ihrer Umgebung, während Sie die Anwendung entwickeln.

Wir richten jetzt einen Ordner mit Dateien ein, die zum Konfigurieren und Initialisieren unserer Dienstcontainer verwendet werden.

Um Nginx einzurichten, teilen wir eine travellist.conf Datei, die konfiguriert, wie die Anwendung bereitgestellt wird. Erstellen Sie docker-compose/nginx Ordner mit:

mkdir -p docker-compose/nginx

Öffnen Sie eine neue Datei namens travellist.conf innerhalb dieses Verzeichnisses:

nano docker-compose/nginx/travellist.conf

Kopieren Sie die folgende Nginx-Konfiguration in diese Datei:

docker-compose/nginx/travellist.conf

server {
    listen 80;
    index index.php index.html;
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    root /var/www/public;
    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;
    }
}

Diese Datei konfiguriert Nginx so, dass es auf Port 80 lauscht und verwenden Sie index.php als Standard-Indexseite. Es wird den Dokumentenstamm auf /var/www/public setzen , und konfigurieren Sie dann Nginx für die Verwendung der app Dienst auf Port 9000 um *.php zu verarbeiten Dateien.

Speichern und schließen Sie die Datei, wenn Sie mit der Bearbeitung fertig sind.

Um die MySQL-Datenbank einzurichten, teilen wir einen Datenbank-Dump, der importiert wird, wenn der Container initialisiert wird. Dies ist eine Funktion, die vom MySQL 5.7-Image bereitgestellt wird, das wir für diesen Container verwenden werden.

Erstellen Sie einen neuen Ordner für Ihre MySQL-Initialisierungsdateien innerhalb von docker-compose Ordner:

mkdir docker-compose/mysql

Öffnen Sie eine neue .sql Datei:

nano docker-compose/mysql/init_db.sql

Der folgende MySQL-Dump basiert auf der Datenbank, die wir in unserem Laravel on LEMP-Leitfaden eingerichtet haben. Es wird eine neue Tabelle mit dem Namen places erstellt . Dann wird die Tabelle mit einer Reihe von Beispielorten gefüllt.

Fügen Sie der Datei den folgenden Code hinzu:

docker-compose/mysql/db_init.sql

DROP TABLE IF EXISTS `places`;

CREATE TABLE `places` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
  `visited` tinyint(1) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

INSERT INTO `places` (name, visited) VALUES ('Berlin',0),('Budapest',0),('Cincinnati',1),('Denver',0),('Helsinki',0),('Lisbon',0),('Moscow',1),('Nairobi',0),('Oslo',1),('Rio',0),('Tokyo',0);

Die places Tabelle enthält drei Felder:id , name , und visited . Der visited field ist ein Flag, das verwendet wird, um die Orte zu kennzeichnen, die noch zu gehen sind . Fühlen Sie sich frei, die Beispielorte zu ändern oder neue hinzuzufügen. Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Wir haben das Dockerfile der Anwendung und die Dienstkonfigurationsdateien fertig eingerichtet. Als Nächstes richten wir Docker Compose so ein, dass diese Dateien beim Erstellen unserer Dienste verwendet werden.

Schritt 5 – Erstellen einer Multi-Container-Umgebung mit Docker Compose

Mit Docker Compose können Sie Umgebungen mit mehreren Containern für Anwendungen erstellen, die auf Docker ausgeführt werden. Es verwendet Dienstdefinitionen um vollständig anpassbare Umgebungen mit mehreren Containern zu erstellen, die Netzwerke und Datenvolumen gemeinsam nutzen können. Dies ermöglicht eine nahtlose Integration zwischen Anwendungskomponenten.

Um unsere Dienstdefinitionen einzurichten, erstellen wir eine neue Datei namens docker-compose.yml . Normalerweise befindet sich diese Datei im Stammverzeichnis des Anwendungsordners und definiert Ihre containerisierte Umgebung, einschließlich der Basis-Images, die Sie zum Erstellen Ihrer Container verwenden, und wie Ihre Dienste interagieren.

Wir werden drei verschiedene Dienste in unserer docker-compose.yml definieren Datei:app , db und nginx .

Die app Der Dienst erstellt ein Image namens travellist , basierend auf dem Dockerfile, das wir zuvor erstellt haben. Der von diesem Dienst definierte Container führt ein php-fpm aus Server, um den PHP-Code zu parsen und die Ergebnisse an nginx zurückzusenden Dienst, der auf einem separaten Container ausgeführt wird. Die mysql service definiert einen Container, auf dem ein MySQL 5.7-Server ausgeführt wird. Unsere Dienste teilen sich ein Brückennetzwerk namens travellist .

Die Anwendungsdateien werden sowohl auf der app synchronisiert und das nginx Dienste über bind mounts . Bind-Mounts sind in Entwicklungsumgebungen nützlich, da sie eine leistungsfähige bidirektionale Synchronisierung zwischen Host-Maschine und Containern ermöglichen.

Erstellen Sie eine neue docker-compose.yml Datei im Stammverzeichnis des Anwendungsordners:

nano docker-compose.yml

Eine typische docker-compose.yml Datei beginnt mit einer Versionsdefinition, gefolgt von einem services Knoten, unter dem alle Dienste definiert sind. Geteilte Netzwerke werden normalerweise am Ende dieser Datei definiert.

Kopieren Sie zunächst diesen Boilerplate-Code in Ihre docker-compose.yml Datei:

docker-compose.yml

version: "3.7"
services:


networks:
  travellist:
    driver: bridge

Wir bearbeiten jetzt die services -Knoten, um die app einzuschließen , db und nginx Dienste.

Die app Service

Die app Der Dienst richtet einen Container namens travellist-app ein . Es erstellt ein neues Docker-Image basierend auf einer Docker-Datei, die sich im selben Pfad wie docker-compose.yml befindet Datei. Das neue Bild wird lokal unter dem Namen travellist gespeichert .

Obwohl sich der als Anwendung bereitgestellte Dokumentstamm in der Datei nginx befindet Container benötigen wir die Anwendungsdateien irgendwo innerhalb der app Container, sodass wir Befehlszeilenaufgaben mit dem Laravel Artisan-Tool ausführen können.

Kopieren Sie die folgende Dienstdefinition unter Ihren services -Knoten innerhalb der docker-compose.yml Datei:

docker-compose.yml

  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: travellist
    container_name: travellist-app
    restart: unless-stopped
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - travellist

Diese Einstellungen bewirken Folgendes:

• build :Diese Konfiguration weist Docker Compose an, ein lokales Image für die app zu erstellen service, wobei der angegebene Pfad (Kontext) und Dockerfile für Anweisungen verwendet werden. Die Argumente user und uid werden in die Docker-Datei eingefügt, um Befehle zur Benutzererstellung während der Build-Zeit anzupassen.
• image :Der Name, der für das erstellte Image verwendet wird.
• container_name :Richtet den Containernamen für diesen Dienst ein.
• restart :Immer neu starten, es sei denn, der Dienst wird gestoppt.
• working_dir :Legt das Standardverzeichnis für diesen Dienst als /var/www fest .
• volumes :Erstellt ein freigegebenes Volume, das Inhalte aus dem aktuellen Verzeichnis nach /var/www synchronisiert innerhalb des Behälters. Beachten Sie, dass dies nicht Ihr Dokumentenstamm ist, da dieser sich in nginx befindet Behälter.
• networks :Richtet diesen Dienst so ein, dass er ein Netzwerk namens travellist verwendet .

Die db Service

Die db Der Dienst verwendet ein vorgefertigtes MySQL 8.0-Image von Docker Hub. Denn Docker Compose lädt automatisch .env Variablendateien, die sich im selben Verzeichnis wie docker-compose.yml befinden Datei können wir unsere Datenbankeinstellungen aus der Laravel .env beziehen Datei, die wir in einem vorherigen Schritt erstellt haben.

Fügen Sie die folgende Dienstdefinition in Ihre services ein -Knoten, direkt nach der app Dienst:

docker-compose.yml

  db:
    image: mysql:8.0
    container_name: travellist-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_USER: ${DB_USERNAME}
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - ./docker-compose/mysql:/docker-entrypoint-initdb.d
    networks:
      - travellist

Diese Einstellungen bewirken Folgendes:

• image :Definiert das Docker-Image, das für diesen Container verwendet werden soll. In diesem Fall verwenden wir ein MySQL 5.7-Image von Docker Hub.
• container_name :Richtet den Containernamen für diesen Dienst ein:travellist-db .
• restart :Starten Sie diesen Dienst immer neu, es sei denn, er wird explizit gestoppt.
• environment :Definiert Umgebungsvariablen im neuen Container. Wir verwenden Werte aus Laravel .env Datei, um unseren MySQL-Dienst einzurichten, der basierend auf den bereitgestellten Umgebungsvariablen automatisch eine neue Datenbank und einen neuen Benutzer erstellt.
• volumes :Erstellt ein Volume zum Freigeben einer .sql Datenbankauszug, der zum Initialisieren der Anwendungsdatenbank verwendet wird. Das MySQL-Image importiert automatisch .sql Dateien in /docker-entrypoint-initdb.d abgelegt Verzeichnis innerhalb des Containers.
• networks :Richtet diesen Dienst so ein, dass er ein Netzwerk namens travellist verwendet .

Der nginx Service

Die nginx Der Dienst verwendet ein vorgefertigtes Nginx-Image auf Alpine, einer leichten Linux-Distribution. Es erstellt einen Container namens travellist-nginx , und es verwendet die ports Definition, um eine Umleitung von Port 8000 zu erstellen auf dem Hostsystem auf Port 80 im Behälter.

Fügen Sie die folgende Dienstdefinition in Ihre services ein -Knoten, direkt nach db Dienst:

docker-compose.yml

  nginx:
    image: nginx:1.17-alpine
    container_name: travellist-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d
    networks:
      - travellist

Diese Einstellungen bewirken Folgendes:

• image :Definiert das Docker-Image, das für diesen Container verwendet werden soll. In diesem Fall verwenden wir das Alpine Nginx 1.17-Image.
• container_name :Richtet den Containernamen für diesen Dienst ein:travellist-nginx .
• restart :Starten Sie diesen Dienst immer neu, es sei denn, er wird explizit gestoppt.
• ports :Richtet eine Portumleitung ein, die einen externen Zugriff über Port 8000 ermöglicht an den Webserver, der auf Port 80 läuft im Behälter.
• volumes :Erstellt zwei freigegebene Volumes. Der erste synchronisiert Inhalte aus dem aktuellen Verzeichnis nach /var/www innerhalb des Behälters. Wenn Sie lokale Änderungen an den Anwendungsdateien vornehmen, werden diese auf diese Weise schnell in der Anwendung wiedergegeben, die von Nginx im Container bereitgestellt wird. Der zweite Band stellt sicher, dass unsere Nginx-Konfigurationsdatei unter docker-compose/nginx/travellist.conf zu finden ist , wird in den Nginx-Konfigurationsordner des Containers kopiert.
• networks :Richtet diesen Dienst so ein, dass er ein Netzwerk namens travellist verwendet .

Fertige docker-compose.yml Datei

So sieht unsere fertige docker-compose.yml aus Datei sieht so aus:

docker-compose.yml

version: "3.7"
services:
  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: travellist
    container_name: travellist-app
    restart: unless-stopped
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - travellist

  db:
    image: mysql:8.0
    container_name: travellist-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_USER: ${DB_USERNAME}
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - ./docker-compose/mysql:/docker-entrypoint-initdb.d
    networks:
      - travellist

  nginx:
    image: nginx:alpine
    container_name: travellist-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d/
    networks:
      - travellist

networks:
  travellist:
    driver: bridge

Stellen Sie sicher, dass Sie die Datei speichern, wenn Sie fertig sind.

Schritt 6 – Ausführen der Anwendung mit Docker Compose

Wir verwenden jetzt docker-compose Befehle, um das Anwendungs-Image zu erstellen und die Dienste auszuführen, die wir in unserem Setup angegeben haben.

Erstellen Sie die app Bild mit dem folgenden Befehl:

docker-compose build app

Die Ausführung dieses Befehls kann einige Minuten dauern. Sie sehen eine Ausgabe ähnlich der folgenden:

OutputBuilding app
Sending build context to Docker daemon  377.3kB
Step 1/11 : FROM php:7.4-fpm
 ---> 8c08d993542f
Step 2/11 : ARG user
 ---> e3ce3af04d87
Step 3/11 : ARG uid
 ---> 30cb921ef7df
Step 4/11 : RUN apt-get update && apt-get install -y     git     curl     libpng-dev     libonig-dev     libxml2-dev     zip     unzip
. . .
 ---> b6dbc7a02e95
Step 5/11 : RUN apt-get clean && rm -rf /var/lib/apt/lists/*
 ---> 10ef9dde45ad
. . .
Step 6/11 : RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd
. . .
 ---> 920e4f09ec75
Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
 ---> dbbcd44e44af
Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user
 ---> db98e899a69a
Step 9/11 : RUN mkdir -p /home/$user/.composer &&     chown -R $user:$user /home/$user
 ---> 5119e26ebfea
Step 10/11 : WORKDIR /var/www
 ---> 699c491611c0
Step 11/11 : USER $user
 ---> cf250fe8f1af
Successfully built cf250fe8f1af
Successfully tagged travellist:latest

Wenn der Build abgeschlossen ist, können Sie die Umgebung im Hintergrundmodus ausführen mit:

docker-compose up -d

OutputCreating travellist-db    ... done
Creating travellist-app   ... done
Creating travellist-nginx ... done

Dadurch werden Ihre Container im Hintergrund ausgeführt. Um Informationen über den Status Ihrer aktiven Dienste anzuzeigen, führen Sie Folgendes aus:

docker-compose ps

Sie sehen eine Ausgabe wie diese:

Output      Name                    Command              State                  Ports                
-----------------------------------------------------------------------------------------------
travellist-app     docker-php-entrypoint php-fpm   Up      9000/tcp                            
travellist-db      docker-entrypoint.sh mysqld     Up      3306/tcp, 33060/tcp                 
travellist-nginx   nginx -g daemon off;            Up      0.0.0.0:8000->80/tcp,:::8000->80/tcp

Ihre Umgebung ist jetzt einsatzbereit, aber wir müssen noch einige Befehle ausführen, um die Einrichtung der Anwendung abzuschließen. Sie können die docker-compose exec verwenden Befehl zum Ausführen von Befehlen in den Dienstcontainern, z. B. ls -l um detaillierte Informationen über Dateien im Anwendungsverzeichnis anzuzeigen:

docker-compose exec app ls -l

Outputtotal 256
-rw-r--r-- 1 sammy sammy    737 Apr 18 14:21 Dockerfile
-rw-r--r-- 1 sammy sammy    101 Jan  7  2020 README.md
drwxr-xr-x 6 sammy sammy   4096 Jan  7  2020 app
-rwxr-xr-x 1 sammy sammy   1686 Jan  7  2020 artisan
drwxr-xr-x 3 sammy sammy   4096 Jan  7  2020 bootstrap
-rw-r--r-- 1 sammy sammy   1501 Jan  7  2020 composer.json
-rw-r--r-- 1 sammy sammy 179071 Jan  7  2020 composer.lock
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 config
drwxr-xr-x 5 sammy sammy   4096 Jan  7  2020 database
drwxr-xr-x 4 sammy sammy   4096 Apr 18 14:22 docker-compose
-rw-r--r-- 1 sammy sammy   1017 Apr 18 14:29 docker-compose.yml
-rw-r--r-- 1 sammy sammy   1013 Jan  7  2020 package.json
-rw-r--r-- 1 sammy sammy   1405 Jan  7  2020 phpunit.xml
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 public
-rw-r--r-- 1 sammy sammy    273 Jan  7  2020 readme.md
drwxr-xr-x 6 sammy sammy   4096 Jan  7  2020 resources
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 routes
-rw-r--r-- 1 sammy sammy    563 Jan  7  2020 server.php
drwxr-xr-x 5 sammy sammy   4096 Jan  7  2020 storage
drwxr-xr-x 4 sammy sammy   4096 Jan  7  2020 tests
-rw-r--r-- 1 sammy sammy    538 Jan  7  2020 webpack.mix.js

Wir führen jetzt composer install aus So installieren Sie die Anwendungsabhängigkeiten:

docker-compose exec app rm -rf vendor composer.lock
docker-compose exec app composer install

Sie sehen eine Ausgabe wie diese:

OutputNo composer.lock file present. Updating dependencies to latest instead of installing from lock file. See https://getcomposer.org/install for more information.
. . .
Lock file operations: 89 installs, 0 updates, 0 removals
  - Locking doctrine/inflector (2.0.4)
  - Locking doctrine/instantiator (1.4.1)
  - Locking doctrine/lexer (1.2.3)
  - Locking dragonmantank/cron-expression (v2.3.1)
  - Locking egulias/email-validator (2.1.25)
  - Locking facade/flare-client-php (1.9.1)
  - Locking facade/ignition (1.18.1)
  - Locking facade/ignition-contracts (1.0.2)
  - Locking fideloper/proxy (4.4.1)
  - Locking filp/whoops (2.14.5)
. . .
Writing lock file
Installing dependencies from lock file (including require-dev)
Package operations: 89 installs, 0 updates, 0 removals
  - Downloading doctrine/inflector (2.0.4)
  - Downloading doctrine/lexer (1.2.3)
  - Downloading dragonmantank/cron-expression (v2.3.1)
  - Downloading symfony/polyfill-php80 (v1.25.0)
  - Downloading symfony/polyfill-php72 (v1.25.0)
  - Downloading symfony/polyfill-mbstring (v1.25.0)
  - Downloading symfony/var-dumper (v4.4.39)
  - Downloading symfony/deprecation-contracts (v2.5.1)
. . .
Generating optimized autoload files
> Illuminate\Foundation\ComposerScripts::postAutoloadDump
> @php artisan package:discover --ansi
Discovered Package: facade/ignition
Discovered Package: fideloper/proxy
Discovered Package: laravel/tinker
Discovered Package: nesbot/carbon
Discovered Package: nunomaduro/collision
Package manifest generated successfully.

Als Letztes müssen wir vor dem Testen der Anwendung einen eindeutigen Anwendungsschlüssel mit dem artisan generieren Laravel-Befehlszeilentool. Dieser Schlüssel wird verwendet, um Benutzersitzungen und andere sensible Daten zu verschlüsseln:

docker-compose exec app php artisan key:generate

OutputApplication key set successfully.

Gehen Sie nun zu Ihrem Browser und greifen Sie auf Port 8000 auf den Domainnamen oder die IP-Adresse Ihres Servers zu:

http://server_domain_or_IP:8000

Hinweis :Falls Sie diese Demo auf Ihrem lokalen Rechner ausführen, verwenden Sie http://localhost:8000 um über Ihren Browser auf die Anwendung zuzugreifen.

Sie sehen eine Seite wie diese:

Sie können die logs verwenden Befehl, um die von Ihren Diensten generierten Protokolle zu überprüfen:

docker-compose logs nginx

Attaching to travellist-nginx
. . .
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:49:16 +0000] "GET / HTTP/1.1" 200 627 "-" "curl/7.82.0"
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:51:27 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0"
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:51:27 +0000] "GET /favicon.ico HTTP/1.1" 200 0 "http://localhost:8000/" "Mozilla/5.0 (X11; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0"

Wenn Sie Ihre Docker Compose-Umgebung anhalten möchten, während der Status aller Dienste beibehalten wird, führen Sie Folgendes aus:

docker-compose pause

OutputPausing travellist-db    ... done
Pausing travellist-nginx ... done
Pausing travellist-app   ... done

Sie können Ihre Dienste dann fortsetzen mit:

docker-compose unpause

OutputUnpausing travellist-app   ... done
Unpausing travellist-nginx ... done
Unpausing travellist-db    ... done

Um Ihre Docker Compose-Umgebung herunterzufahren und alle ihre Container, Netzwerke und Volumes zu entfernen, führen Sie Folgendes aus:

docker-compose down

OutputStopping travellist-nginx ... done
Stopping travellist-db    ... done
Stopping travellist-app   ... done
Removing travellist-nginx ... done
Removing travellist-db    ... done
Removing travellist-app   ... done
Removing network travellist-laravel-demo_travellist

Eine Übersicht über alle Docker Compose-Befehle finden Sie in der Docker Compose-Befehlszeilenreferenz.

Schlussfolgerung

In diesem Leitfaden haben wir eine Docker-Umgebung mit drei Containern mit Docker Compose eingerichtet, um unsere Infrastruktur in einer YAML-Datei zu definieren.

Ab diesem Zeitpunkt können Sie an Ihrer Laravel-Anwendung arbeiten, ohne einen lokalen Webserver für Entwicklung und Tests installieren und einrichten zu müssen. Darüber hinaus arbeiten Sie mit einer Einwegumgebung, die einfach repliziert und verteilt werden kann, was bei der Entwicklung Ihrer Anwendung und auch beim Übergang zu einer Produktionsumgebung hilfreich sein kann.