One place for hosting & domains

      Docker

      Installieren und Einrichten von Laravel mit Docker Compose unter Ubuntu 20.4


      Einführung

      Die Containerisierung einer Anwendung bezeichnet den Anpassungsprozess einer Anwendung und ihrer Komponenten, um sie in einfachen Umgebungen ausführen zu können, die als Container bekannt sind. Derartige Umgebungen sind isoliert und können gelöscht werden. Sie lassen sich zur Entwicklung, zum Testen und zur Bereitstellung von Anwendungen zu Produktionszwecken nutzen.

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

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

      Um einen gestrafften Entwicklungsprozess zu ermöglichen und das Debugging der Anwendung zu ermöglichen, halten wir Anwendungsdateien durch den Einsatz von gemeinsam genutzten Volumes synchron. Auch zeigen wir, wie Sie docker-compose exec-Befehle verwenden, um Composer und Artisan auf dem app-Container auszuführen.

      Voraussetzungen

      Schritt 1 – Erhalt der Demo-Anwendung

      Zu Beginn rufen wir die Demoversion der Laravel-Anwendung aus dem Github Repository ab. Wir sind an dem tutorial-01-Zweig interessiert, der die Laravel-Standardanwendung enthält, die wir im ersten Leitfaden dieser Serie erstellt haben.

      Um den mit diesem Tutorial kompatiblen Anwendungscode zu bekommen, laden Sie wie folgt tutorial-1.0.1 in Ihr Stammverzeichnis herunter:

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

      Den unzip-Befehl brauchen wir, um den Anwendungscode zu dekomprimieren. Wenn Sie dieses Paket noch nicht installiert haben, sollten Sie es jetzt wie folgt tun:

      • sudo apt update
      • sudo apt install unzip

      Dekomprimieren Sie nun den Inhalt der Anwendung und benennen Sie das entpackte Verzeichnis für leichteren Zugriff um:

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

      Navigieren Sie zum Verzeichnis travellist-demo:

      Im nächsten Schritt erstellen wir eine .env-Konfigurationsdatei, um die Anwendung einzurichten.

      Schritt 2 – Einrichten der .env-Datei der Anwendung

      Die Laravel-Konfigurationsdateien befinden sich im Verzeichnis config, das Sie im Stammverzeichnis der Anwendung finden. Zusätzlich wird eine .env-Datei verwendet, um eine umgebungsabhängige Konfiguration einzurichten, wie z. B. Anmeldedaten und Informationen, die sich zwischen Bereitstellungen ändern können. Diese Datei ist nicht Teil der Revisionskontrolle.

      Warnung: Die Umgebungs-Konfigurationsdatei enthält sensible Informationen über Ihren Server, einschließlich Anmeldedaten zur Datenbank und Sicherheitsschlüssel. Aus diesem Grund sollten Sie diese Datei nie öffentlich teilen.

      Die Werte in der .env-Datei haben Vorrang vor den Werten, die in regelmäßigen Konfigurationsdateien festgelegt sind, die sich im Verzeichnis config befinden. Jede Installation in einer neuen Umgebung erfordert eine maßgeschneiderte Umgebungsdatei, um Dinge wie Datenbank-Verbindungseinstellungen, Debug-Optionen, Anwendungs-URL und andere Objekte festzulegen, die je nach den Umgebungsbedingungen variieren können.

      Jetzt erstellen wir eine neue .env-Datei, um die Konfigurationsoptionen für die Entwicklungsumgebung anzupassen, die wir einrichten. Laravel wird mit einer .env-Musterdatei geliefert, die wir zur Erstellung unserer eigenen kopieren können:

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

      Die aktuelle .env-Datei aus der travellist Demo-Anwendung enthält Einstellungen zum Einsatz einer lokalen MySQL-Datenbank, wobei 127.0.0.1 der Datenbank-Host ist. Wir müssen die Variable DB_HOST aktualisieren, damit sie auf den Datenbankdienst verweist, den wir in unserer Docker-Umgebung erstellen. In diesem Leitfaden nennen wir unseren Datenbankdienst db. Ersetzen Sie also den aufgelisteten Wert von DB_HOST durch den 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
      ...
      

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

      Speichern Sie die Datei, wenn die Bearbeitung abgeschlossen ist. Wenn Sie nano verwendet haben, können Sie zur Bestätigung Strg+x, dann Y und die Eingabetaste drücken.

      Schritt 3 – Einrichten des Dockerfiles der Anwendung

      Obwohl unsere MySQL- und Nginx Dienste auf Standardimages basieren, die wir aus dem Docker Hub erhalten, müssen wir trotzdem ein benutzerdefiniertes Image für den Anwendungs-Container erstellen. Dafür erstellen wir ein neues Dockerfile.

      Unser travellist-Image basiert auf dem offiziellen PHP-Image php:7.4-fpm von Docker Hub. Über diese PHP-FPM-Umgebung hinaus installieren wir ein paar PHP-Extramodule und das Composer Abhängigkeitsmanagement-Tool.

      Außerdem erstellen wir einen neuen Systembenutzer; dies ist notwendig, um artisan– und composer– Befehle während der Entwicklung der Anwendung auszuführen. Die uid-Einstellung stellt sicher, dass der Benutzer im Container dieselbe UID wie der Systembenutzer auf Ihrem Host-Computer hat, auf dem Docker läuft. Auf diese Weise werden alle von diesen Befehlen erstellten Dateien mit den richtigen Berechtigungen im Host repliziert. Es bedeutet auch, dass Sie auf dem Host-Rechner den Code-Editor Ihrer Wahl verwenden können, um die Anwendung für die Container zu entwickeln.

      Erstellen Sie ein neues Dockerfile mit:

      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, indem Sie das Basisimage definieren, das wir verwenden: php:7.4-fpm.

      Nach Installation von Systempaketen und PHP-Erweiterungen installieren wir Composer, indem wir den ausführbaren composer aus dem letzten offiziellen Image in unser eigenes Anwendungsimage kopieren.

      Dann wird mit den Argumenten user und uid ein neuer Systembenutzer erstellt und eingerichtet. Diese Argumente wurden zu Beginn des Dockerfiles deklariert. Diese Werte werden von Docker Compose zur Buildzeit injiziert.

      Schließlich legen wir das Standardarbeitsverzeichnis als /var/www fest und wechseln auf den neu erstellten Benutzer. Somit gewährleisten Sie, dass Sie sich als regelmäßiger Benutzer verbinden und im richtigen Verzeichnis sind, wenn Sie composer– und artisan-Befehle im Anwendungs-Container ausführen.

      Schritt 4 – Einrichten der Nginx-Konfiguration und der Datenbank-Dump-Dateien

      Wenn Sie Entwicklungsumgebungen mit Docker Compose erstellen, müssen Sie die Konfigurations- oder Initialisierungsdateien häufig mit Dienst-Containern teilen, um diese Dienste einzurichten oder im Bootstrap-Verfahren zu laden. Diese Vorgehensweise ermöglicht die Änderung der Konfigurationsdateien, um Ihre Umgebung während der Anwendungsentwicklung genau einzustellen.

      Jetzt erstellen wir einen Ordner mit Dateien, die zur Konfiguration und Initialisierung unserer Dienst-Container verwendet werden.

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

      • mkdir -p docker-compose/nginx

      Öffnen Sie eine neue Datei namens travellist.conf in diesem Verzeichnis:

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

      Mit dieser Datei wird Nginx konfiguriert, um auf Port 80 zu lauschen und index.php als standardmäßige Index-Seite zu verwenden. Damit wird der Dokumentenstamm auf /var/www/public festgelegt und dann Nginx so konfiguriert, dass er den app-Dienst auf Port 9000 verwendet, um *.php-Dateien zu verarbeiten.

      Speichern und schließen Sie die Datei, wenn die Bearbeitung abgeschlossen ist.

      Um die MySQL-Datenbank einzurichten, teilen wir einen Datenbank-Dump, der bei Initialisierung des Containers importiert wird. Dies ist eine Eigenschaft, die vom MySQL 5.7-Image bereitgestellt wird, das wir in dem Container verwenden.

      Erstellen Sie einen neuen Ordner für Ihre MySQL-Initialisierung im Ordner docker-compose:

      • 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 Leitfaden zu Laravel mit LEMP eingerichtet haben. Damit wird eine neue Tabelle namens places erstellt. Dann füllt er die Tabelle mit einem Satz von Musterstellen.

      Fügen Sie den folgenden Code zur Datei 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 Tabelle places enthält drei Felder: id, name und visited. Das Feld visited ist ein Flag, das als Identifizierung der Stellen dient, die noch ausstehen. Stellen Sie diese Musterstellen nach Belieben um oder setzen Sie neue hinzu. Speichern und schließen Sie die Datei, wenn Sie fertig sind.

      Damit ist die Einrichtung des Dockerfiles der Anwendung und der Konfigurationsdateien des Dienstes abgeschlossen. Als Nächstes richten wir Docker Compose ein, damit es bei der Erstellung unserer Dienste diese Dateien verwendet.

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

      Docker Compose ermöglicht es Ihnen, Multi-Container-Umgebungen für auf Docker laufende Anwendungen zu erstellen. Er verwendet Dienst-Definitionen zum Aufbau voll anpassbarer Umgebungen mit mehreren Containern, die Netzwerke und Datenvolumes teilen können. Damit wird eine nahtlose Integration zwischen Anwendungskomponenten möglich.

      Um unsere Dienst-Definitionen einzurichten, erstellen wir eine neue Datei namens docker-compose.yml. Normalerweise befindet sich diese Datei im Stamm des Anwendungsordners und definiert die containerisierte Umgebung, einschließlich der Standardimages, die Sie zum Aufbau Ihrer Container verwenden, und der Art und Weise, wie Ihre Dienste interagieren.

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

      Der app-Dienst stellt ein Image mit der Bezeichnung travellist auf Basis des zuvor erstellten Dockerfiles zusammen. Der durch diesen Dienst definierte Container führt einen php-fpm-Server aus, um PHP-Code zu parsen und die Ergebnisse an den nginx-Dienst zurückzusenden, der in einem separaten Container läuft. Der mysql-Dienst definiert einen Container, der einen MySQL 5.7-Server ausführt. Unsere Dienste teilen ein Brückennetzwerk namens travellist.

      Die Anwendungsdateien werden in sowohl den app– als auch den nginx-Diensten über Bind-Bereitstellungen synchronisiert. Bind-Bereitstellungen sind in Entwicklungsumgebungen nützlich, weil sie eine performante zweispurige Synchronisierung zwischen Host-Rechner und Containern ermöglichen.

      Erstellen Sie eine neue docker-compose.yml-Datei im Stammverzeichnis der Anwendung:

      Eine typische docker-compose.yml-Datei beginnt mit einer Versionsdefinition gefolgt von einem services-Knoten, in dem alle Dienste definiert sind. Die geteilten Netzwerke werden normalerweise unten in der Datei definiert.

      Kopieren Sie zu Beginn diesen Standardcode in Ihre docker-compose.yml-Datei:

      docker-compose.yml

      version: "3.7"
      services:
      
      
      networks:
        travellist:
          driver: bridge
      

      Jetzt bearbeiten wir den services-Knoten, um die app-, db– und nginx-Dienste aufzunehmen.

      Der app-Dienst

      Der app-Dienst richtet einen Container namens travellist-app ein. Basierend auf einem Dockerfile mit dem gleichen Pfad wie die docker-compose.yml-Datei baut er ein neues Docker-Image auf. Das neue Image wird lokal unter dem Namen travellist gespeichert.

      Obwohl sich der als Anwendung dienende Dokumentenstamm im nginx-Container befindet, sollten auch die Anwendungsdateien irgendwo im app-Container vorhanden sein, damit wir Befehlszeilenvorgänge mit dem Laravel Artisan-Tool ausführen können.

      Kopieren Sie die folgende Dienst-Definition in Ihrem services-Knoten aus 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 den app-Dienst zu erstellen, wobei es den angegebenen Pfad (context) und das Dockerfile für Anweisungen verwendet. Die Argumente user und uid werden in das Dockerfile injiziert, um die Befehle zur Benutzereinrichtung zur Buildzeit anzupassen.
      • image: Der Name, der für das zusammengestellte Image verwendet wird.
      • container_name: Richtet den Container-Namen für diesen Dienst ein.
      • restart: Es wird immer ein Neustart durchgeführt, es sei denn, der Dienst wird angehalten.
      • working_dir: Richtet das Standardverzeichnis für diesen Dienst als /var/www ein.
      • volumes: Erstellt ein gemeinsam genutztes Volume, das den Inhalt des aktuellen Verzeichnisses auf /var/www im Container synchronisiert. Beachten Sie, dass es sich nicht um Ihren Dokumentenstamm handelt, da dieser sich im nginx-Container befinden wird.
      • networks: Richtet diesen Dienst auf Nutzung eines Netzwerks namens travellist ein.

      Der db-Dienst

      Der db-Dienst verwendet ein vorab zusammengestelltes MySQL 5.7-Image von Docker Hub. Da Docker Compose die .env-Variablendateien automatisch lädt, die sich im gleichen Verzeichnis wie die docker-compose.yml-Datei befinden, erhalten wir unsere Datenbankeinstellungen aus der Laravel .env-Datei, die wir im vorherigen Schritt erstellt haben.

      Setzen Sie die folgende Dienst-Definition in Ihrem services-Knoten direkt hinter den app-Dienst:

      docker-compose.yml

        db:
          image: mysql:5.7
          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 sollte. In diesem Fall verwenden wir ein MySQL 5.7-Image von Docker Hub.
      • container_name: Richtet den Container-Namen für diesen Dienst ein: travellist-db.
      • restart: Dieser Dienst wird immer neu gestartet, es sei denn, er wurde ausdrücklich angehalten.
      • environment: Definiert Umgebungsvariablen im neuen Container. Wir verwenden Werte aus der Laravel .env-Datei, um unseren MySQL-Dienst einzurichten. Damit werden automatisch, basierend auf den bereitgestellten Umgebungsvariablen, eine neue Datenbank und ein Benutzer erstellt.
      • volumes: Erstellt ein Volume, um einen .sql-Datenbank-Dump zu teilen, der zur Initialisierung der Anwendungsdatenbank verwendet wird. Das MySQL-Image importiert automatisch .sql-Dateien, die im Verzeichnis /docker-entrypoint-initdb.d im Container abgelegt werden.
      • networks: Richtet diesen Dienst auf Nutzung eines Netzwerks namens travellist ein.

      Der nginx-Dienst

      Der nginx-Dienst verwendet ein vorab zusammengestelltes Nginx-Image auf Alpine, einer einfachen Linux-Distribution. Damit wird ein Container namens travellist-nginx erstellt und die ports-Definition verwendet, um eine Umleitung von Port 8000 im Host-System auf Port 80 im Container zu schaffen.

      Setzen Sie die folgende Dienst-Definition in Ihrem services-Knoten direkt hinter den 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 sollte. In diesem Fall verwenden wir das Alpine Nginx 1.17-Image.
      • container_name: Richtet den Container-Namen für diesen Dienst ein: travellist-nginx.
      • restart: Dieser Dienst wird immer neu gestartet, es sei denn, er wurde ausdrücklich angehalten.
      • ports: Richtet eine Port-Umleitung ein, die den externen Zugriff über Port 8000 auf den Web-Server ermöglicht, der auf Port 80 im Container läuft.
      • volumes: Erstellt zwei gemeinsam genutzte Volumes. Das erste wird den Inhalt aus dem aktuellen Verzeichnis in /var/www im Container synchronisieren. Auf diese Weise werden bei lokalen Änderungen an den Anwendungsdateien diese schnell in der Anwendung widergespiegelt, die von Nginx im Container bereitgestellt wird. Das zweite Volume stellt sicher, dass unsere Nginx-Konfigurationsdatei, die sich auf docker-compose/nginx/travellist.conf befindet, in den Nginx-Konfigurationsordner des Containers kopiert wird.
      • networks: Richtet diesen Dienst auf Nutzung eines Netzwerks namens travellist ein.

      Fertiggestellte docker-compose.yml-Datei

      So sieht unsere fertiggestellte docker-compose.yml-Datei 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:5.7
          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
      

      Denken Sie daran, die Datei zu speichern, wenn Sie Ihre Bearbeitung abgeschlossen haben.

      Schritt 6 – Ausführung der Anwendung mit Docker Compose

      Jetzt verwenden wir docker-compose-Befehle, um das Anwendungsimage zu erstellen und die Dienste auszuführen, die wir in unserem Setup festgelegt haben.

      Erstellen Sie das app-Image mit dem folgenden Befehl:

      Dies kann einige Minuten dauern. Sie sehen eine Ausgabe, die dieser ähnelt:

      Output

      Building app Step 1/11 : FROM php:7.4-fpm ---> fa37bd6db22a Step 2/11 : ARG user ---> Running in f71eb33b7459 Removing intermediate container f71eb33b7459 ---> 533c30216f34 Step 3/11 : ARG uid ---> Running in 60d2d2a84cda Removing intermediate container 60d2d2a84cda ---> 497fbf904605 Step 4/11 : RUN apt-get update && apt-get install -y git curl libpng-dev libonig-dev ... Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer ---> e499f74896e3 Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user ---> Running in 232ef9c7dbd1 Removing intermediate container 232ef9c7dbd1 ---> 870fa3220ffa Step 9/11 : RUN mkdir -p /home/$user/.composer && chown -R $user:$user /home/$user ---> Running in 7ca8c0cb7f09 Removing intermediate container 7ca8c0cb7f09 ---> 3d2ef9519a8e Step 10/11 : WORKDIR /var/www ---> Running in 4a964f91edfa Removing intermediate container 4a964f91edfa ---> 00ada639da21 Step 11/11 : USER $user ---> Running in 9f8e874fede9 Removing intermediate container 9f8e874fede9 ---> fe176ff4702b Successfully built fe176ff4702b Successfully tagged travellist:latest

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

      Output

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

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

      Die Ausgabe sieht dann so aus:

      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 /docker-entrypoint.sh ngin ... Up 0.0.0.0:8000->80/tcp

      Jetzt ist Ihre Umgebung einsatzbereit, aber wir müssen noch ein paar Befehle ausführen, um das Setup der Anwendung abzuschließen. Sie können den Befehl docker-compose exec verwenden, um Befehle in den Dienst-Containern auszuführen, wie z. B. ls -l, der detaillierte Informationen über Dateien im Anwendungsverzeichnis anzeigt:

      • docker-compose exec app ls -l

      Output

      total 260 -rw-rw-r-- 1 sammy sammy 737 Jun 9 11:19 Dockerfile -rw-rw-r-- 1 sammy sammy 101 Jan 7 08:05 README.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 app -rwxr-xr-x 1 sammy sammy 1686 Jan 7 08:05 artisan drwxrwxr-x 3 sammy sammy 4096 Jan 7 08:05 bootstrap -rw-rw-r-- 1 sammy sammy 1501 Jan 7 08:05 composer.json -rw-rw-r-- 1 sammy sammy 179071 Jan 7 08:05 composer.lock drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 config drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 database drwxrwxr-x 4 sammy sammy 4096 Jun 9 11:19 docker-compose -rw-rw-r-- 1 sammy sammy 965 Jun 9 11:27 docker-compose.yml -rw-rw-r-- 1 sammy sammy 1013 Jan 7 08:05 package.json -rw-rw-r-- 1 sammy sammy 1405 Jan 7 08:05 phpunit.xml drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 public -rw-rw-r-- 1 sammy sammy 273 Jan 7 08:05 readme.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 resources drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 routes -rw-rw-r-- 1 sammy sammy 563 Jan 7 08:05 server.php drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 storage drwxrwxr-x 4 sammy sammy 4096 Jan 7 08:05 tests drwxrwxr-x 41 sammy sammy 4096 Jun 9 11:32 vendor -rw-rw-r-- 1 sammy sammy 538 Jan 7 08:05 webpack.mix.js

      Jetzt führen wir composer install aus, um die Anwendungsabhängigkeiten zu installieren:

      • docker-compose exec app composer install

      Die Ausgabe sieht dann so aus:

      Output

      Loading composer repositories with package information Installing dependencies (including require-dev) from lock file Package operations: 85 installs, 0 updates, 0 removals - Installing doctrine/inflector (1.3.1): Downloading (100%) - Installing doctrine/lexer (1.2.0): Downloading (100%) - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%) - Installing erusev/parsedown (1.7.4): Downloading (100%) - Installing symfony/polyfill-ctype (v1.13.1): Downloading (100%) - Installing phpoption/phpoption (1.7.2): Downloading (100%) - Installing vlucas/phpdotenv (v3.6.0): Downloading (100%) - Installing symfony/css-selector (v5.0.2): Downloading (100%) … Generating optimized autoload files > IlluminateFoundationComposerScripts::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 vor dem Anwendungstest verbleibt die Generierung eines eindeutigen Anwendungsschlüssels mit dem artisan Laravel-Tool auf Befehlszeilenebene. Dieser Schlüssel wird verwendet, um die Benutzersitzungen und andere sensible Daten zu verschlüsseln:

      • docker-compose exec app php artisan key:generate

      Output

      Application key set successfully.

      Gehen Sie jetzt in Ihren Browser und greifen Sie über Port 8000 auf den Domänenamen oder die IP-Adresse Ihres Servers zu:

      http://server_domain_or_IP:8000
      

      Anmerkung: Wenn Sie diese Demo auf Ihrem lokalen Rechner ausführen, verwenden Sie http://localhost:8000, um von Ihrem Browser aus auf die Anwendung zuzugreifen.

      Sie sehen in etwa folgende Seite:

      Demoversion der Laravel-Anwendung

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

      • docker-compose logs nginx
      Attaching to travellist-nginx
      …
      travellist-nginx | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
      travellist-nginx | /docker-entrypoint.sh: Configuration complete; ready for start up
      travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:34 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
      travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:35 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
      

      Wenn Sie Ihre Docker-Compose-Umgebung unter Beibehaltung des Zustandes aller Dienste anhalten möchten, führen Sie Folgendes aus:

      Output

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

      So können Sie dann Ihre Dienste wiederaufnehmen:

      Output

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

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

      Output

      Stopping 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 aller Docker-Compose-Befehle finden Sie in der Docker Compose Befehlszeilenreferenz.

      Zusammenfassung

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

      Ab jetzt können Sie in Ihrer Laravel-Anwendung arbeiten, ohne einen lokalen Webserver für die Entwicklung und Tests installieren und einrichten zu müssen. Außerdem arbeiten Sie mit einer löschbaren Testumgebung, die leicht repliziert und verteilt werden kann, was bei der Anwendungsentwicklung und auch beim Wechsel in eine Produktivumgebung hilfreich sein kann.



      Source link

      Cómo instalar y configurar Laravel con Docker Compose en Ubuntu 20.04


      Introducción

      Cuando se habla de disponer en contenedores una aplicación, se hace referencia al proceso de adaptación de una aplicación y sus componentes para poder ejecutarla en entornos ligeros conocidos como contenedores. Estos entornos están aislados, son desechables y se pueden utilizar para desarrollar, probar e implementar aplicaciones en la producción.

      En esta guía, usaremos Docker Compose con el propósito de disponer en contenedores una aplicación de Laravel para el desarrollo. Al finalizar, dispondrá de una aplicación Laravel de demostración funcional en tres contenedores de servicios separados:

      • un servicio app con PHP7.4-FPM;
      • un servicio db con MySQL 5.7;
      • un servicio nginx en el que se utilice el servicio app para analizar el código PHP antes de proporcionar la aplicación Laravel al usuario final.

      Para permitir un proceso de desarrollo simplificado y facilitar la depuración de aplicaciones, mantendremos sincronizados los archivos de la aplicación usando volúmenes compartidos. También veremos cómo usar comandos docker-compose exec para la ejecución de Composer y Artisan en el contenedor app.

      Requisitos previos

      Paso 1: Obtener la aplicación de demostración

      Para comenzar, obtendremos la aplicación Laravel de demostración de su repositorio de Github. Nos interesa la ramificación tutorial-01, que contiene la aplicación básica de Laravel que creamos en la primera guía de esta serie.

      Para obtener el código de la aplicación que es compatible con este tutorial, descargue la versión tutorial-1.0.1 en su directorio de inicio con lo siguiente:

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

      Necesitaremos el comando unzip para desempaquetar el código de la aplicación. En caso de que no haya instalado el paquete antes, hágalo ahora con lo siguiente:

      • sudo apt update
      • sudo apt install unzip

      Luego, descomprima el contenido de la aplicación y cambie el nombre del directorio desempaquetado para facilitar el acceso:

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

      Diríjase al directorio travellist-demo:

      En el siguiente paso, crearemos un archivo de configuración .env para configurar la aplicación.

      Paso 2: Configurar el archivo .env de la aplicación

      Los archivos de configuración de Laravel se encuentran en un directorio llamado config, dentro del directorio root de la aplicación. Además, un archivo .env se utiliza para establecer una configuración dependiente del entorno, como las credenciales y cualquier información que pueda variar entre las implementaciones. Este archivo no está incluido en el control de revisiones.

      Advertencia: En el archivo de configuración del entorno se encuentra información confidencial sobre su servidor, incluidas las credenciales de bases de datos y las claves de seguridad. Por ese motivo, nunca debe compartir públicamente este archivo.

      Los valores incluidos en el archivo .env tendrán prioridad sobre los valores establecidos en los archivos de configuración normales que se encuentran en el directorio config. Para cada instalación en un nuevo entorno se requiere un archivo de entorno personalizado a fin de definir elementos como las configuraciones de conexión de bases de datos, las opciones de depuración y las URL de aplicación, entre otros elementos que pueden variar dependiendo del entorno en el que se ejecute la aplicación.

      Ahora, crearemos un nuevo archivo .env para personalizar las opciones de configuración para el entorno de desarrollo que configuraremos. En Laravel se incluye un archivo .env de ejemplo que podemos copiar para crear el nuestro:

      Abra este archivo utilzando nano o el editor de texto que prefiera:

      En el archivo .env actual de la aplicación de demostración travellist se incluyen las configuraciones para usar una base de datos local de MySQL, con 127.0.0.1 como host de base de datos. Necesitamos actualizar la variable DB_HOST para que esta apunte al servicio de base de datos que crearemos en nuestro entorno de Docker. En esta guía, usaremos el nombre db para el servicio de nuestra base de datos. Sustituya el valor de la lista de DB_HOST por el nombre del servicio de la base de datos:

      .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
      ...
      

      Si lo desea, puede cambiar también el nombre, el nombre de usuario y la contraseña de la base de datos. Estas variables aprovecharán en un paso posterior en el que prepararemos el archivo docker-compose.yml para configurar nuestros servicios.

      Guarde el archivo cuando finalice la edición. Si utiliza nano, puede hacerlo presionando Ctrl+x, luego Y y Enter para confirmar.

      Paso 3: Configurar el Dockerfile de la aplicación

      Aunque ambos servicios de MySQL y Nginx se basarán en imágenes predeterminadas obtenidas de Docker Hub, debemos de todas formas crear una imagen personalizada para el contenedor de la aplicación. Crearemos un nuevo Dockerfile para ello.

      Nuestra imagen de travellist se basará en la imagen oficial de PHP php:7.4-fpm de Docker Hub. Además de ese entorno básico de PHP-FPM, instalaremos algunos módulos de PHP adicionales y la herramienta de administración de dependencias Composer.

      También crearemos un nuevo usuario de sistema; esto es necesario para ejecutar los comandos artisan y composer mientras se desarrolla la aplicación. En la configuración uid se garantiza que el usuario dentro del contenedor tenga el mismo uid que el usuario de su sistema en su equipo host, donde Docker está en ejecución. De esta manera, todos los archivos creados por estos comandos se replican en el host con los permisos correctos. Esto también significa que podrá usar su editor de código preferido en la máquina host para desarrollar la aplicación que está en ejecución dentro de los contenedores.

      Cree un nuevo Dockerfile con lo siguiente:

      Copie el siguiente contenido en su 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
      
      

      No olvide guardar el archivo cuando termine.

      Nuestro Dockerfile comienza definiendo la imagen base que usaremos: php:7.4-fpm.

      Después de instalar los paquetes del sistema y las extensiones de PHP, instalamos Composer copiando el ejecutable composer de su imagen oficial más reciente en la propia imagen de nuestra aplicación.

      A continuación, se crea un nuevo usuario de sistema y se configura usando los argumentos user y uid que se declararon al inicio del Dockerfile. Docker Compose insertará estos valores en el tiempo de compilación.

      Por último, fijaremos el directorio de trabajo predeterminado como /var/www y cambiaremos al usuario recién creado. Esto garantizará que se conecte como un usuario normal y que se encuentre en el directorio correcto, al ejecutar comandos de composer y artisan en el contenedor de la aplicación.

      Paso 4: Preparar archivos de configuración de Nginx y de volcado de bases de datos

      Cuando se crean entornos de desarrollo con Docker Compose, a menudo es necesario compartir archivos de configuración o de inicialización con contenedores de servicios para que se puedan configurar o aplicar estos servicios. Esta práctica facilita la aplicación de cambios en los archivos de configuración para ajustar el entorno mientras desarrolla la aplicación.

      Ahora crearemos una carpeta con archivos que se utilizarán para configurar e inicializar nuestros contenedores de servicios.

      Para configurar Nginx, compartiremos un archivo travellist.conf en el que se configurará la forma en que se proporciona la aplicación. Cree la carpeta docker-compose/nginx con lo siguiente:

      • mkdir -p docker-compose/nginx

      Abra un nuevo archivo llamado travellist.conf dentro de ese directorio:

      • nano docker-compose/nginx/travellist.conf

      Copie la siguiente configuración de Nginx en ese archivo:

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

      En este archivo se configurará Nginx para que escuche en el puerto 80 y utilice index.php como la página de índice predeterminada. Establecerá el documento root en /var/www/public y luego configurará Nginx para que en este se utilice el servicio app en el puerto 9000 a fin de procesar archivos *.php.

      Guarde y cierre el archivo cuando finalice la edición.

      Para configurar la base de datos de MySQL, compartiremos un volcado de base de datos que se importará cuando se inicialice el contenedor. Esta es una característica que se proporciona a través de la imagen de MySQL 5.7 y que usaremos en ese contenedor.

      Cree una nueva carpeta para sus archivos de inicialización de MySQL dentro de la carpeta docker-compose:

      • mkdir docker-compose/mysql

      Abra un nuevo archivo .sql:

      • nano docker-compose/mysql/init_db.sql

      El siguiente volcado de MySQL deriva de la base de datos que configuramos en nuestra guía sobre Laravel en LEMP. Se creará una nueva tabla llamada places. Luego, se completará la tabla con un conjunto de lugares de ejemplo.

      Añada el siguiente código al archivo:

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

      En la tabla places se incluyen tres campos: id, name y visited. El campo visited es un indicador utilizado para identificar los lugares que aún quedan por recorrer. Puede cambiar los lugares de ejemplo o incluir casos nuevos si lo desea. Guarde y cierre el archivo cuando termine.

      Terminamos de preparar el Dockerfile de la aplicación y los archivos de configuración del servicio. A continuación, configuraremos Docker Compose para que se utilicen estos archivos al crear nuestros servicios.

      Paso 5: Crear un entorno en varios contenedores con Docker Compose

      Docker Compose le permite crear entornos en varios contenedores para aplicaciones que se ejecuten en Docker. Se utilizan definiciones de servicio para crear entornos totalmente personalizables con varios contenedores que pueden compartir redes y volúmenes de datos. Esto permite una integración sin problemas entre los componentes de la aplicación.

      Para establecer nuestras definiciones de servicios, crearemos un nuevo archivo llamado docker-compose.yml. Normalmente, este archivo se encuentra en la carpeta root de la aplicación y define su entorno en contenedor, incluidas las imágenes de base que usará para crear sus contenedores y la forma en que interactuarán sus servicios.

      Definiremos tres servicios diferentes en nuestro archivo docker-compose.yml: app, db y nginx.

      En el servicio app se creará una imagen llamada travellist, basada en el Dockerfile que creamos previamente. En el contenedor definido por este servicio se ejecutará un servidor php-fpm para analizar el código PHP y enviar los resultados de vuelta al servicio nginx, que estará en ejecución en un contenedor separado. A través del servicio mysql, se define un contenedor en un servidor MySQL 5.7. En nuestros servicios se compartirá una red de puente llamada travellist.

      Los archivos de la aplicación se sincronizarán en los servicios app y nginx mediante montajes “bind”. Los montajes “bind” son útiles en los entornos de desarrollo porque en estos se permite una sincronización bidireccional estable entre el equipo host y los contenedores.

      Cree un nuevo archivo docker-compose.yml en la carpeta root de la aplicación:

      Un archivo típico de docker-compose.yml comienza con una definición de versión, a la que le sigue un nodo services, donde se definen todos los servicios. Las redes compartidas suelen definirse al final de ese archivo.

      Para comenzar, copie el siguiente código estándar a su archivo docker-compose.yml:

      docker-compose.yml

      version: "3.7"
      services:
      
      
      networks:
        travellist:
          driver: bridge
      

      Ahora, editaremos el nodo services para incluir los servicios app, db y nginx.

      El servicio app

      A través del servicio app se configurará un contenedor llamado travellist-app. Crea una nueva imagen de Docker basada en un Dockerfile ubicado en la misma ruta que el archivo docker-compose.yml. La nueva imagen se guardará a nivel local con el nombre travellist.

      Aunque el root de documentos que se proporciona como la aplicación se encuentra en el contenedor nginx, también necesitamos los archivos de la aplicación en algún lugar dentro del contenedor app para poder ejecutar tareas de línea de comandos con la herramienta Laravel Artisan.

      Copie la siguiente definición de servicio en su nodo services, dentro del archivo docker-compose.yml:

      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
      

      Estas configuraciones tienen los siguientes atributos:

      • build: en esta configuración indica a Docker Compose que cree una imagen local para el servicio app, y usa la ruta especificada (context) y Dockerfile para las instrucciones. Los argumentos user y uid se insertan en Dockerfile para personalizar los comandos de creación del usuario en el tiempo de compilación.
      • image: nombre que se usará para la imagen que se creará.
      • container_name: configura el nombre del contenedor para este servicio.
      • restart: siempre ejecuta un reinicio, a menos que se detenga el servicio.
      • working_dir: establece el directorio predeterminado para este servicio como /var/www.
      • volumes: crea un volumen compartido en el que se sincronizarán los contenidos del directorio actual con /var/www dentro del contenedor. Tenga en cuenta que esto no es su root de documentos, ya que este residirá en el contenedor nginx.
      • networks: configura este servicio para que se utilice una red llamada travellist.

      El servicio db

      En el servicio db se utiliza una imagen previamente creada de MySQL 5.7 de Docker Hub. Debido a que en Docker Compose se cargan automáticamente los archivos de variable .env ubicados en el mismo directorio que el archivo docker-compose.yml, podemos obtener la configuración de nuestra base de datos del archivo Laravel .env que creamos en un paso anterior.

      Incluya la siguiente definición de servicio en el nodo services, justo después del servicio app:

      docker-compose.yml

        db:
          image: mysql:5.7
          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
      

      Estas configuraciones hacen lo siguiente:

      • image: define la imagen de Docker que debe utilizarse para este contenedor. En este caso, usamos una imagen MySQL 5.7 de Docker Hub.
      • container_name: establece el nombre del contenedor para el servicio travellist-db.
      • restart: reinicie siempre este servicio, a menos que se detenga de forma explicita.
      • environment: define las variables de entorno en el nuevo contenedor. Usaremos valores obtenidos del archivo Laravel .env para establecer nuestro servicio de MySQL, que creará automáticamente una nueva base de datos y usuario basadas en las variables de entorno proporcionadas.
      • volumes: crea un volumen para compartir un volcado de base de datos .sql que se usará para inicializar la base de datos de la aplicación. En la imagen de MySQL se importarán automáticamente archivos .sql ubicados en el directorio /docker-entrypoint-initdb.d dentro del contenedor.
      • networks: configura este servicio para que se utilice una red llamada travellist.

      El servicio nginx

      En el servicio nginx se utiliza una imagen previamente creada de Nginx en la parte superior de Alpine, una distribución ligera de Linux. Se crea un contenedor llamado travellist-nginx y se utiliza la definición ports para crear un redireccionamiento del puerto 8000 en el sistema host al puerto 80 dentro del contenedor.

      Incluya la siguiente definición de servicio en su nodo services, justo después del servicio db:

      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
      

      Esta configuración hace lo siguiente:

      • image: define la imagen de Docker que debe utilizarse para este contenedor. En este caso, usaremos la imagen Alpine Nginx 1.17.
      • container_name: establece el nombre del contenedor para el servicio travellist-nginx.
      • restart: reinicie siempre este servicio, a menos que se detenga de forma explicita.
      • ports: establece un redireccionamiento de puerto que permitirá el acceso externo a través del puerto 8000 al servidor web que se ejecuta en el puerto 80 dentro del contenedor.
      • volumes: crea dos volúmenes compartidos. El primero sincronizará los contenidos del directorio actual con /var/www dentro del contenedor. De esta manera, cuando realice cambios locales en los archivos de la aplicación, se reflejarán rápidamente en la aplicación proporcionada por Nginx dentro del contenedor. En el segundo volumen, se asegurará que nuestro archivo de configuración de Nginx, ubicado en docker-compose/nginx/travellist.conf, se copie a la carpeta de configuración de Nginx del contenedor.
      • networks: configura este servicio para que se utilice una red llamada travellist.

      Archivo docker-compose.yml terminado

      Este es el aspecto de nuestro archivo docker-compose.yml terminado:

      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:5.7
          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
      

      Asegúrese de guardar el archivo cuando termine.

      Paso 6: Ejecutar la aplicación con Docker Compose

      Ahora, usaremos comandos docker-compose para crear la imagen de la aplicación y ejecutar los servicios que especificamos en nuestra configuración.

      Cree la imagen app con el siguiente comando:

      La aplicación de este comando puede tardar unos minutos en completarse. Verá un resultado similar a este:

      Output

      Building app Step 1/11 : FROM php:7.4-fpm ---> fa37bd6db22a Step 2/11 : ARG user ---> Running in f71eb33b7459 Removing intermediate container f71eb33b7459 ---> 533c30216f34 Step 3/11 : ARG uid ---> Running in 60d2d2a84cda Removing intermediate container 60d2d2a84cda ---> 497fbf904605 Step 4/11 : RUN apt-get update && apt-get install -y git curl libpng-dev libonig-dev ... Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer ---> e499f74896e3 Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user ---> Running in 232ef9c7dbd1 Removing intermediate container 232ef9c7dbd1 ---> 870fa3220ffa Step 9/11 : RUN mkdir -p /home/$user/.composer && chown -R $user:$user /home/$user ---> Running in 7ca8c0cb7f09 Removing intermediate container 7ca8c0cb7f09 ---> 3d2ef9519a8e Step 10/11 : WORKDIR /var/www ---> Running in 4a964f91edfa Removing intermediate container 4a964f91edfa ---> 00ada639da21 Step 11/11 : USER $user ---> Running in 9f8e874fede9 Removing intermediate container 9f8e874fede9 ---> fe176ff4702b Successfully built fe176ff4702b Successfully tagged travellist:latest

      Cuando se complete la compilación, podrá ejecutar el entorno en el modo de segundo plano con lo siguiente:

      Output

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

      Con esto, se ejecutarán sus contenedores en segundo plano. Para mostrar información sobre el estado de sus servicios activos, ejecute lo siguiente:

      Verá resultados como este:

      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 /docker-entrypoint.sh ngin ... Up 0.0.0.0:8000->80/tcp

      Su entorno ahora estárá configurado y en funcionamiento, pero aún debemos ejecutar algunos comandos para finalizar la configuración de la aplicación. Puede usar el comando docker-compose exec para ejecutar comandos en los contenedores de servicios, como ls -l. Este muestra información detallada sobre los archivos en el directorio de la aplicación:

      • docker-compose exec app ls -l

      Output

      total 260 -rw-rw-r-- 1 sammy sammy 737 Jun 9 11:19 Dockerfile -rw-rw-r-- 1 sammy sammy 101 Jan 7 08:05 README.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 app -rwxr-xr-x 1 sammy sammy 1686 Jan 7 08:05 artisan drwxrwxr-x 3 sammy sammy 4096 Jan 7 08:05 bootstrap -rw-rw-r-- 1 sammy sammy 1501 Jan 7 08:05 composer.json -rw-rw-r-- 1 sammy sammy 179071 Jan 7 08:05 composer.lock drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 config drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 database drwxrwxr-x 4 sammy sammy 4096 Jun 9 11:19 docker-compose -rw-rw-r-- 1 sammy sammy 965 Jun 9 11:27 docker-compose.yml -rw-rw-r-- 1 sammy sammy 1013 Jan 7 08:05 package.json -rw-rw-r-- 1 sammy sammy 1405 Jan 7 08:05 phpunit.xml drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 public -rw-rw-r-- 1 sammy sammy 273 Jan 7 08:05 readme.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 resources drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 routes -rw-rw-r-- 1 sammy sammy 563 Jan 7 08:05 server.php drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 storage drwxrwxr-x 4 sammy sammy 4096 Jan 7 08:05 tests drwxrwxr-x 41 sammy sammy 4096 Jun 9 11:32 vendor -rw-rw-r-- 1 sammy sammy 538 Jan 7 08:05 webpack.mix.js

      Ahora, ejecutaremos composer install para instalar las dependencias de la aplicación:

      • docker-compose exec app composer install

      Verá resultados como este:

      Output

      Loading composer repositories with package information Installing dependencies (including require-dev) from lock file Package operations: 85 installs, 0 updates, 0 removals - Installing doctrine/inflector (1.3.1): Downloading (100%) - Installing doctrine/lexer (1.2.0): Downloading (100%) - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%) - Installing erusev/parsedown (1.7.4): Downloading (100%) - Installing symfony/polyfill-ctype (v1.13.1): Downloading (100%) - Installing phpoption/phpoption (1.7.2): Downloading (100%) - Installing vlucas/phpdotenv (v3.6.0): Downloading (100%) - Installing symfony/css-selector (v5.0.2): Downloading (100%) … Generating optimized autoload files > IlluminateFoundationComposerScripts::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.

      Lo último que debemos hacer antes de probar la aplicación es generar una clave de aplicación única con la herramienta de línea de comandos de Laravel artisan. Esta clave se utiliza para cifrar las sesiones de los usuarios y otros datos confidenciales:

      • docker-compose exec app php artisan key:generate

      Output

      Application key set successfully.

      Ahora diríjase a su navegador y acceda al nombre de dominio o dirección IP de su servidor en el puerto 8000:

      http://server_domain_or_IP:8000
      

      Nota: En el caso de que esté ejecutando esta demo en su equipo local, utilice https://localhost:8000 para acceder a la aplicación desde su navegador.

      Verá una página como la siguiente:

      Aplicación de demostración de Laravel

      Puede usar el comando logs para verificar los registros generados por sus servicios:

      • docker-compose logs nginx
      Attaching to travellist-nginx
      …
      travellist-nginx | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
      travellist-nginx | /docker-entrypoint.sh: Configuration complete; ready for start up
      travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:34 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
      travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:35 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
      

      Si desea pausar su entorno de Docker Compose mientras mantiene el estado de todos sus servicios, ejecute lo siguiente:

      Output

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

      Luego podrá reanudar sus servicios con lo siguiente:

      Output

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

      Para cerrar su entorno de Docker Compose y eliminar por completo sus contenedores, redes y volúmenes, ejecute lo siguiente:

      Output

      Stopping 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

      Para acceder a una visión general de todos los comandos de Docker Compose, consulte la referencia de línea de comandos de Docker Compose.

      Conclusión

      A lo largo de esta guía, configuramos un entorno de Docker con tres contenedores usando Docker Compose para definir nuestra infraestructura en un archivo YAML.

      A partir de este punto, puede trabajar en su aplicación de Laravel sin necesidad de instalar y configurar un servidor web local para el desarrollo y las pruebas. Además, trabajará con un entorno disponible que se puede replicar y distribuir de forma sencilla, lo cual puede resultarle útil al desarrollar su aplicación y realizar la transición a un entorno de producción.



      Source link

      Comment installer et configurer Laravel avec Docker Compose sur Ubuntu 20.04


      Introduction

      Conteneuriser une application fait référence au processus d’adaptation d’une application et de ses composants afin de pouvoir l’exécuter dans des environnements légers appelés conteneurs. Ces environnements sont isolés et remplaçables et peuvent être exploités pour développer, tester et déployer des apps en production.

      Dans ce guide, nous utiliserons Docker Compose pour conteneuriser une application Laravel pour le développement. Lorsque vous aurez terminé, vous aurez une application Laravel de démonstration fonctionnant sur trois conteneurs de service distincts :

      • Un service app fonctionnant sous PHP7.4-FPM ;
      • Un service db fonctionnant sous MySQL 5.7 ;
      • Un service nginx qui utilise le service app pour analyser le code PHP avant de servir l’application Laravel à l’utilisateur final.

      Pour permettre un processus de développement simplifié et faciliter le débogage des apps, nous maintiendrons la synchronisation des fichiers d’application en utilisant des volumes partagés. Nous verrons également comment utiliser les commandes docker-compose exec pour exécuter Composer et Artisan sur le conteneur de l’application.

      Conditions préalables

      Étape 1 – Obtenez l’application de démonstration

      Pour commencer, nous irons chercher l’application de démonstration Laravel dans son répertoire Github. Nous sommes intéressés par la branche tutorial-01, qui contient l’application Laravel de base que nous avons créée dans le premier guide de cette série.

      Pour obtenir le code d’application compatible avec ce tutoriel, téléchargez la version tutorial-1.0.1 dans votre répertoire de base avec :

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

      Nous aurons besoin de la commande unzip pour décompresser le code d’application. Si vous n’avez pas encore installé ce package, faites-le maintenant avec :

      • sudo apt update
      • sudo apt install unzip

      Maintenant, décompressez le contenu de l’application et renommez le répertoire décompressé pour un accès plus facile :

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

      Naviguez vers le répertoire travellist-demo :

      Au cours de la prochaine étape, nous allons créer un fichier de configuration .env pour configurer l’application.

      Étape 2 – Configurez le fichier .env de l’application

      Les fichiers de configuration Laravel sont situés dans un répertoire appelé config, dans le répertoire root de l’application. En outre, un fichier .env est utilisé pour configurer environment-dependent configuration, telles que les références et toute information pouvant varier d’un déploiement à l’autre. Ce fichier n’est pas inclus dans la gestion de versions.

      Attention : le fichier de configuration de l’environnement contient des informations sensibles sur votre serveur, notamment les informations d’identification de la base de données et les clés de sécurité. Par conséquent, ne partagez jamais ce fichier en public.

      Les valeurs contenues dans le fichier .env auront la priorité sur les valeurs fixées dans les fichiers de configuration habituels situés dans le répertoire config. Chaque installation sur un nouvel environnement nécessite un fichier d’environnement personnalisé pour définir des éléments tels que les paramètres de connexion à la base de données, les options de débogage, l’URL de l’application, entre autres, qui peuvent varier en fonction de l’environnement dans lequel l’application est exécutée.

      Nous allons maintenant créer un nouveau fichier .env afin de personnaliser les options de configuration pour l’environnement de développement que nous configurons. Laravel contient un exemple de fichier .env que nous pouvons copier pour créer le nôtre :

      Ouvrez ce fichier en utilisant nano ou votre éditeur de texte préféré :

      Le fichier .env provenant de l’application de démonstration travellist contient des paramètres pour utiliser une base de données MySQL locale, avec 127.0.0.1 comme hôte de base de données. Nous devons mettre à jour la variable DB_HOST afin qu’il pointe vers le service de base de données que nous allons créer dans notre environnement Docker. Dans ce guide, nous appellerons notre service de base de données db. Commencez et remplacez la valeur listée de DB_HOST par le nom du service de base de données :

      .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
      ...
      

      N’hésitez pas à modifier également le nom de la base de données, le nom d’utilisateur et le mot de passe, si vous le souhaitez. Ces variables seront exploitées lors d’une étape ultérieure où nous mettrons en place le fichier docker-compose.yml pour configurer nos services.

      Enregistrez le fichier lorsque vous avez fini de le modifier. Si vous avez utilisé nano, vous pouvez le faire en appuyant sur CTRL+X, puis Y et ENTER pour confirmer.

      Étape 3 – Configurez le Dockerfile de l’application

      Bien que nos services MySQL et Nginx seront basés sur des images par défaut obtenues à partir de Docker Hub, nous devons encore construire une image personnalisée pour le conteneur de l’application. Bien que nos services MySQL et Nginx soient basés sur des images par défaut obtenues à partir de Docker Hub, nous devons malgré tout construire une image personnalisée pour le conteneur de l’application.

      Notre image travellist sera basée sur l’image PHP officielle php:7.4-fpm de Docker Hub. En plus de cet environnement PHP-FPM de base, nous allons installer quelques modules PHP supplémentaires et l’outil de gestion des dépendances Composer.

      Nous allons également créer un nouvel utilisateur système ; c’est nécessaire pour exécuter les commandes artisan et composer lors du développement de l’application. Le paramètre uid garantit que l’utilisateur à l’intérieur du conteneur a le même uid que l’utilisateur de votre système sur votre machine hôte, où vous exécutez Docker. Ainsi, tous les fichiers créés par ces commandes sont répliqués dans l’hôte avec les bonnes permissions. Cela signifie également que vous pourrez utiliser l’éditeur de code de votre choix dans la machine hôte pour développer l’application qui s’exécute dans les conteneurs.

      Créez un nouveau Dockerfile avec :

      Copiez le contenu suivant dans votre 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
      
      

      N’oubliez pas d’enregistrer le fichier lorsque vous avez terminé.

      Notre Dockerfile commence par définir l’image de base que nous utilisons : php:7.4-fpm.

      Après avoir installé les packages système et les extensions PHP, nous installons Composer en copiant le fichier exécutable composer depuis sa dernière image officielle vers notre propre image d’application.

      Un nouvel utilisateur système est alors créé et configuré en utilisant les arguments user et uid qui ont été déclarés au début du Dockerfile. Ces valeurs seront injectées par Docker Compose au moment de la construction.

      Enfin, nous avons défini le répertoire de travail par défaut comme /var/www et changé pour l’utilisateur nouvellement créé. Cela vous permettra de vous connecter comme un utilisateur régulier et de vous assurer que vous êtes dans le bon répertoire lorsque vous exécutez les commandes composer et artisan sur le conteneur de l’application.

      Étape 4 – Implémentez la configuration Nginx et les fichiers Dump de la base de données

      Lors de la création d’environnements de développement avec Docker Compose, il est souvent nécessaire de partager des fichiers de configuration ou d’initialisation avec des conteneurs de services, afin de mettre en place ou de démarrer ces services. Cette pratique facilite la modification des fichiers de configuration pour affiner votre environnement pendant que vous développez l’application.

      Nous allons maintenant créer un dossier avec des fichiers qui serviront à configurer et à initialiser nos conteneurs de services.

      Pour configurer Nginx, nous allons partager un fichier travellist.conf qui configurera la façon dont l’application est servie. Créez le dossier docker-compose/nginx avec :

      • mkdir -p docker-compose/nginx

      Ouvrez un nouveau fichier appelé travellist.conf dans ce répertoire :

      • nano docker-compose/nginx/travellist.conf

      Copiez la configuration Nginx suivante dans ce fichier :

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

      Ce fichier configurera Nginx pour écouter sur le port 80 et utilisera index.php comme page d’index par défaut. Il définira le document root comme /var/www/public, et configurera ensuite Nginx pour utiliser le service de l’application sur le port 9000 pour traiter les fichiers *.php.

      Enregistrez et fermez le fichier lorsque vous avez fini de le modifier.

      Pour mettre en place la base de données MySQL, nous allons partager un dump de base de données qui sera importé lors de l’initialisation du conteneur. C’est une fonctionnalité fournie par l’image MySQL 5.7 que nous utiliserons sur ce conteneur.

      Créez un nouveau dossier pour vos fichiers d’initialisation MySQL dans le dossier docker-compose :

      • mkdir docker-compose/mysql

      Ouvrez un nouveau fichier .sql :

      • nano docker-compose/mysql/init_db.sql

      La sauvegarde Dump MySQL suivante est basée sur la base de données que nous avons mise en place dans notre guide Laravel sur LEMP. Elle créera un nouveau tableau appelé places. Ensuite, elle remplira le tableau avec un ensemble de lieux d’échantillonnage.

      Ajoutez le code suivant au fichier :

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

      La table places contient trois champs : id, name, et visited. Le champ visited est un drapeau utilisé pour identifier les lieux qui doivent encore être visités. N’hésitez pas à modifier les échantillons de lieux ou à en inclure de nouveaux. Enregistrez et fermez le fichier lorsque vous avez fini de le modifier.

      Nous avons fini de mettre en place le Dockerfile de l’application et les fichiers de configuration du service. Ensuite, nous allons mettre en place Docker Compose pour utiliser ces fichiers lors de la création de nos services.

      Étape 5 – Créez un environnement multi-conteneurs avec Docker Compose

      Docker Compose permet de créer des environnements multi-conteneurs pour les apps s’exécutant sur Docker. Il utilise les définitions de services pour construire des environnements entièrement personnalisables avec plusieurs conteneurs qui peuvent échanger des réseaux et des volumes de données. Cela permet une intégration harmonieuse entre les composants de l’application.

      Pour configurer nos définitions de service, nous créerons un nouveau fichier appelé docker-compose.yml. Généralement, ce fichier est situé à la racine du dossier d’application et définit votre environnement conteneurisé, y compris les images de base que vous utiliserez pour construire vos conteneurs et la manière dont vos services interagiront.

      Nous définirons trois services différents dans notre fichiers docker-compose.yml : application, db et nginx.

      Le service application construira une image appelée travellist basée sur le Dockerfile que nous avons précédemment créé. Le conteneur défini par ce service exécutera un serveur php-fpm pour analyser le code PHP et renvoyer les résultats au service nginx, qui fonctionnera sur un conteneur séparé. Le service mysql définit un conteneur exécutant un serveur MySQL 5.7. Nos services partageront un pont de réseau appelé travellist.

      Les fichiers de l'application seront synchronisés à la fois sur l’application et sur le service nginx via bind mounts. Les bind mounts sont utiles dans les environnements de développement car ils permettent une synchronisation bidirectionnelle performante entre la machine hôte et les conteneurs.

      Créez un nouveau fichier docker-compose.yml à la racine du dossier de l’application :

      Un fichier docker-compose.yml classique débute par une définition de la version, suivie par un noeud de services qui définit l’ensemble des services. Les réseaux partagés sont généralement définis au bas de ce fichier.

      Pour commencer, copiez ce code standard dans votre fichier docker-compose.yml :

      docker-compose.yml

      version: "3.7"
      services:
      
      
      networks:
        travellist:
          driver: bridge
      

      Nous allons maintenant modifier le nœud de services pour inclure les services application, db et nginx.

      Le service application

      Le service application configurera un conteneur nommé travellist-application. Il construira une nouvelle image Docker basée sur un Dockerfile situé sur le même itinéraire que le fichier docker-compose.yml. La nouvelles image sera enregistrée localement sous le nom de travellist.

      Même si la racine du document qui sert d’application est située dans le conteneur nginx, nous avons également besoin des fichiers de l’application quelque part dans le conteneur application afin d’exécuter des tâches en ligne de commande avec l’outil Laravel Artisan.

      Copiez la définition de service suivante sous votre noeud de services, à l’intérieur du fichier docker-compose.yml :

      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
      

      Ces paramètres sont les suivants :

      • build : cette configuration indique à Docker Compose de construire une image locale pour le service application, en utilisant le chemin spécifié (contexte) et Dockerfile pour les instructions. Les arguments user et uid sont injectés dans le Dockerfile pour personnaliser les commandes de création utilisateurs lors de la construction.
      • image : le nom qui sera utilisé pour l’image en cours de construction.
      • container_name : définit le nom du conteneur pour ce service.
      • restart :indique qu’il faut toujours redémarrer, sauf si le service est arrêté.
      • working_dir : définit le répertoire par défaut pour ce service comme /var/www.
      • volumes : crée un volume partagé qui synchronisera le contenu du répertoire actuel avec /var/www dans le conteneur. Notez qu’il ne s’agit pas de la racine de votre document, puisqu’elle se trouve dans le conteneur nginx.
      • networks : configure ce service pour utiliser un réseau nommé travellist.

      Le service db

      Le service db utilise une image MySQL 5.7 préalablement construite depuis Docker Hub. Étant donné que Docker Compose charge automatiquement les fichiers variables .env situés dans le même répertoire que le fichier docker-compose.yml, nous pouvons obtenir nos paramètres de base de données depuis le fichier Laravel .env que nous avons créé dans une étape précédente.

      Incluez la définition de service suivante dans votre noeud de services, juste après le service application :

      docker-compose.yml

        db:
          image: mysql:5.7
          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
      

      Ces paramètres sont les suivants :

      • image : définit l’image Docker qui doit être utilisée pour ce conteneur. Dans ce cas, nous utilisons l’image MySQL 5.7 de Docker Hub.
      • container_name : définit le nom du conteneur pour ce service : travellist-db.
      • restart : indique qu’il faut toujours redémarrer ce service, sauf s’il est explicitement arrêté.
      • environment : définit les variables d’environnement dans le nouveau conteneur. Nous utilisons des valeurs obtenues par le fichier Laravel .env pour configurer notre service MySQL, qui créera automatiquement une nouvelle base de données et un nouvel utilisateur en fonction des variables d’environnement fournies.
      • volumes : crée un volume pour partager un dump de base de données .sql qui sera utilisé pour initialiser la base de données de l’application. L’image MySQL importera automatiquement les fichiers .sql placés dans le répertoire /docker-entrypoint-initdb.d dans le conteneur.
      • networks : configure ce service pour utiliser un réseau nommé travellist.

      Le service nginx

      Le service nginx utilise une image Nginx pré-construite sur Alpine, une distribution Linux légère. Il crée un conteneur nommé travellist-nginx et utilise la définition des ports pour créer une redirection depuis le port 8000 sur le système hôte jusqu’au port 80 dans le conteneur.

      Incluez la définition de service suivante dans votre noeud de services, juste après le service db :

      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
      

      Ces paramètres sont les suivants :

      • image : définit l’image Docker qui doit être utilisée pour ce conteneur. Dans ce cas, nous utilisons l’image Alpine Nginx 1.17.
      • container_name : définit le nom du conteneur pour ce service : travellist-nginx.
      • restart : indique qu’il faut toujours redémarrer ce service, sauf s’il est explicitement arrêté.
      • ports : configure une redirection des ports qui permettra un accès externe via le port 8000 au serveur web fonctionnant sur le port 80 dans le conteneur.
      • volumes : crée deux volumes partagés. Le premier synchronisera le contenu du répertoire actuel avec /var/www à l’intérieur du conteneur. Ainsi, lorsque vous apportez des modifications locales aux fichiers d’application, elles seront rapidement répercutées dans la demande servie par Nginx à l’intérieur du conteneur. Le deuxième volume s’assurera que notre fichier de configuration Nginx, situé à l'adresse docker-compose/nginx/travellist.conf, est copié dans le dossier de configuration Nginx du conteneur.
      • networks : configure ce service pour utiliser un réseau nommé travellist.

      Fichier docker-compose.yml terminé

      Notre fichier docker-compose.yml terminé ressemble à ça :

      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:5.7
          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
      

      Assurez-vous d’enregistrer le fichier lorsque vous avez terminé.

      Étape 6 – Exécutez l’application avec Docker Compose

      Nous allons maintenant utiliser les commandes docker-compose pour construire l’image de l’application et exécuter les services que nous avons spécifiés dans notre configuration.

      Construisez l’image de l'application avec la commande suivante :

      Cette commande peut prendre quelques minutes. Vous verrez une sortie similaire à celle-ci :

      Output

      Building app Step 1/11 : FROM php:7.4-fpm ---> fa37bd6db22a Step 2/11 : ARG user ---> Running in f71eb33b7459 Removing intermediate container f71eb33b7459 ---> 533c30216f34 Step 3/11 : ARG uid ---> Running in 60d2d2a84cda Removing intermediate container 60d2d2a84cda ---> 497fbf904605 Step 4/11 : RUN apt-get update && apt-get install -y git curl libpng-dev libonig-dev ... Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer ---> e499f74896e3 Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user ---> Running in 232ef9c7dbd1 Removing intermediate container 232ef9c7dbd1 ---> 870fa3220ffa Step 9/11 : RUN mkdir -p /home/$user/.composer && chown -R $user:$user /home/$user ---> Running in 7ca8c0cb7f09 Removing intermediate container 7ca8c0cb7f09 ---> 3d2ef9519a8e Step 10/11 : WORKDIR /var/www ---> Running in 4a964f91edfa Removing intermediate container 4a964f91edfa ---> 00ada639da21 Step 11/11 : USER $user ---> Running in 9f8e874fede9 Removing intermediate container 9f8e874fede9 ---> fe176ff4702b Successfully built fe176ff4702b Successfully tagged travellist:latest

      Lorsque la construction est terminée, vous pouvez exécuter l’environnement en mode arrière-plan avec :

      Output

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

      Cela fera tourner vos conteneurs en arrière-plan. Pour afficher des informations sur l’état de vos services actifs, exécutez :

      Vous verrez une sortie de ce type :

      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 /docker-entrypoint.sh ngin ... Up 0.0.0.0:8000->80/tcp

      Votre environnement est maintenant opérationnel, mais nous devons encore exécuter quelques commandes pour terminer la configuration de l’application. Vous pouvez utiliser la commande docker-compose exec pour exécuter les commandes dans les conteneurs de services, tels qu’un ls -l pour afficher les informations détaillées sur les fichiers dans le répertoire de l’application :

      • docker-compose exec app ls -l

      Output

      total 260 -rw-rw-r-- 1 sammy sammy 737 Jun 9 11:19 Dockerfile -rw-rw-r-- 1 sammy sammy 101 Jan 7 08:05 README.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 app -rwxr-xr-x 1 sammy sammy 1686 Jan 7 08:05 artisan drwxrwxr-x 3 sammy sammy 4096 Jan 7 08:05 bootstrap -rw-rw-r-- 1 sammy sammy 1501 Jan 7 08:05 composer.json -rw-rw-r-- 1 sammy sammy 179071 Jan 7 08:05 composer.lock drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 config drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 database drwxrwxr-x 4 sammy sammy 4096 Jun 9 11:19 docker-compose -rw-rw-r-- 1 sammy sammy 965 Jun 9 11:27 docker-compose.yml -rw-rw-r-- 1 sammy sammy 1013 Jan 7 08:05 package.json -rw-rw-r-- 1 sammy sammy 1405 Jan 7 08:05 phpunit.xml drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 public -rw-rw-r-- 1 sammy sammy 273 Jan 7 08:05 readme.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 resources drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 routes -rw-rw-r-- 1 sammy sammy 563 Jan 7 08:05 server.php drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 storage drwxrwxr-x 4 sammy sammy 4096 Jan 7 08:05 tests drwxrwxr-x 41 sammy sammy 4096 Jun 9 11:32 vendor -rw-rw-r-- 1 sammy sammy 538 Jan 7 08:05 webpack.mix.js

      Nous allons maintenant exécuter composer install pour installer les dépendances de l’application :

      • docker-compose exec app composer install

      Vous verrez une sortie de ce type :

      Output

      Loading composer repositories with package information Installing dependencies (including require-dev) from lock file Package operations: 85 installs, 0 updates, 0 removals - Installing doctrine/inflector (1.3.1): Downloading (100%) - Installing doctrine/lexer (1.2.0): Downloading (100%) - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%) - Installing erusev/parsedown (1.7.4): Downloading (100%) - Installing symfony/polyfill-ctype (v1.13.1): Downloading (100%) - Installing phpoption/phpoption (1.7.2): Downloading (100%) - Installing vlucas/phpdotenv (v3.6.0): Downloading (100%) - Installing symfony/css-selector (v5.0.2): Downloading (100%) … Generating optimized autoload files > IlluminateFoundationComposerScripts::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.

      La dernière chose que nous devons faire avant de tester l’application est de générer une clé d’application unique avec l’outil de ligne de commande Laravel, artisan. Cette clé est utilisée pour chiffrer les sessions des utilisateurs et d’autres données sensibles :

      • docker-compose exec app php artisan key:generate

      Output

      Application key set successfully.

      Ouvrez maintenant votre navigateur et accédez au nom de domaine ou à l’adresse IP de votre serveur sur le port 8000 :

      http://server_domain_or_IP:8000
      

      Note : Si vous exécutez cette démo sur votre machine locale, utilisez http://localhost:8000 pour accéder à l’application à partir de votre navigateur.

      Vous verrez une page comme celle-ci :

      application de démonstration Laravel

      Vous pouvez utiliser la commande logs pour consultez les journaux générés par vos services :

      • docker-compose logs nginx
      Attaching to travellist-nginx
      …
      travellist-nginx | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
      travellist-nginx | /docker-entrypoint.sh: Configuration complete; ready for start up
      travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:34 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
      travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:35 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36"
      

      Si vous voulez mettre en pause votre environnement Docker Compose tout en conservant l’état de tous ses services, exécutez :

      Output

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

      Vous pouvez alors reprendre vos services avec :

      Output

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

      Pour fermer votre environnement Docker Compose et retirer tous ses conteneurs, réseaux et volumes, exécutez :

      Output

      Stopping 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

      Pour un aperçu de toutes les commandes Docker Compose, veuillez consulter la référence de la ligne de commande Docker Compose.

      Conclusion

      Dans ce guide, nous avons mis en place un environnement Docker avec trois conteneurs en utilisant Docker Compose pour définir notre infrastructure dans un fichier YAML.

      À partir de ce moment, vous pouvez travailler sur votre application Laravel sans avoir besoin d’installer et de configurer un serveur web local pour le développement et les tests. De plus, vous travaillerez avec un environnement jetable qui peut être facilement reproduit et distribué, ce qui peut être utile lors du développement de votre application et aussi lors de la transition vers un environnement de production.



      Source link