So richten Sie Laravel, Nginx und MySQL mit Docker Compose ein

Der Autor hatThe FreeBSD Foundation ausgewählt, um eine Spende im Rahmen desWrite for DOnations-Programms zu erhalten.

Einführung

In den letzten Jahren hat sichDocker zu einer häufig verwendeten Lösung für die Bereitstellung von Anwendungen entwickelt, da es das Ausführen und Bereitstellen von Anwendungen in kurzlebigencontainers vereinfacht. Wenn Sie einen LEMP-Anwendungsstapel verwenden, z. B. mitPHP,Nginx,MySQL und demLaravel-Framework, kann Docker den Einrichtungsprozess erheblich optimieren.

Docker Compose hat den Entwicklungsprozess weiter vereinfacht, indem Entwickler ihre Infrastruktur, einschließlich Anwendungsdienste, Netzwerke und Volumes, in einer einzigen Datei definieren können. Docker Compose bietet eine effiziente Alternative zum Ausführen mehrererdocker container create- unddocker container run-Befehle.

In diesem Lernprogramm erstellen Sie eine Webanwendung mit dem Laravel-Framework, wobei Nginx als Webserver und MySQL als Datenbank in Docker-Containern enthalten sind. Sie definieren die gesamte Stapelkonfiguration in einerdocker-compose-Datei sowie Konfigurationsdateien für PHP, MySQL und Nginx.

Voraussetzungen

Bevor Sie beginnen, benötigen Sie:

Ein Ubuntu 18.04-Server und ein Nicht-Root-Benutzer mitsudo-Berechtigungen. Befolgen Sie das Tutorial vonInitial Server Setup with Ubuntu 18.04, um dies einzurichten.
Docker installiert, gemäß den Schritten 1 und 2 vonHow To Install and Use Docker on Ubuntu 18.04.
Docker Compose installiert, gemäß Schritt 1 vonHow To Install Docker Compose on Ubuntu 18.04.

[[Schritt-1 - Herunterladen von Laravel und Installieren von Abhängigkeiten]] == Schritt 1 - Herunterladen von Laravel und Installieren von Abhängigkeiten

In einem ersten Schritt erhalten wir die neueste Version von Laravel und installieren die Abhängigkeiten für das Projekt, einschließlichComposer, dem Paketmanager auf Anwendungsebene für PHP. Wir werden diese Abhängigkeiten mit Docker installieren, um zu vermeiden, dass Composer global installiert werden muss.

Überprüfen Sie zunächst, ob Sie sich in Ihrem Home-Verzeichnis befinden, und klonen Sie die neueste Laravel-Version in ein Verzeichnis mit dem Namenlaravel-app:

cd ~
git clone https://github.com/laravel/laravel.git laravel-app

Wechseln Sie in das Verzeichnislaravel-app:

cd ~/laravel-app

Verwenden Sie als Nächstes Dockerscomposer image, um die Verzeichnisse bereitzustellen, die Sie für Ihr Laravel-Projekt benötigen, und vermeiden Sie den Aufwand für die globale Installation von Composer:

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

Wenn Sie die Flags-v und--rm mitdocker run verwenden, wird ein kurzlebiger Container erstellt, der vor dem Entfernen an Ihr aktuelles Verzeichnis gebunden wird. Dadurch wird der Inhalt des Verzeichnisses von~/laravel-appin den Container kopiert und sichergestellt, dass der von Composer im Container erstellte Ordnervendorin Ihr aktuelles Verzeichnis kopiert wird.

Legen Sie als letzten Schritt die Berechtigungen für das Projektverzeichnis so fest, dass es dem Benutzer Ihres Nicht-rootgehört:

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

Dies ist wichtig, wenn Sie in Schritt 4 die Docker-Datei für Ihr Anwendungsimage schreiben, da Sie damit mit Ihrem Anwendungscode arbeiten und Prozesse in Ihrem Container als Benutzer ohnerootausführen können.

Mit Ihrem Anwendungscode können Sie fortfahren, um Ihre Dienste mit Docker Compose zu definieren.

[[Schritt-2 -—- Erstellen der Docker-Compose-Datei]] == Schritt 2 - Erstellen der Docker-Compose-Datei

Das Erstellen Ihrer Anwendungen mit Docker Compose vereinfacht die Einrichtung und Versionierung Ihrer Infrastruktur. Um unsere Laravel-Anwendung einzurichten, schreiben wir einedocker-compose-Datei, die unsere Webserver-, Datenbank- und Anwendungsdienste definiert.

Öffne die Datei:

nano ~/laravel-app/docker-compose.yml

In der Dateidocker-compose definieren Sie drei Dienste:app,webserver unddb. Fügen Sie der Datei den folgenden Code hinzu, und ersetzen Sie das KennwortrootfürMYSQL_ROOT_PASSWORD, das unter dem Dienstdbalsenvironment variable definiert ist, durch ein sicheres Kennwort Ihrer Wahl ::

~/laravel-app/docker-compose.yml

version: '3'
services:

  #PHP Service
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: digitalocean.com/php
    container_name: app
    restart: unless-stopped
    tty: true
    environment:
      SERVICE_NAME: app
      SERVICE_TAGS: dev
    working_dir: /var/www
    networks:
      - app-network

  #Nginx Service
  webserver:
    image: nginx:alpine
    container_name: webserver
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    networks:
      - app-network

  #MySQL Service
  db:
    image: mysql:5.7.22
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: your_mysql_root_password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    networks:
      - app-network

#Docker Networks
networks:
  app-network:
    driver: bridge

Die hier definierten Dienstleistungen umfassen:

app: Diese Dienstdefinition enthält die Laravel-Anwendung und führt ein benutzerdefiniertes Docker-Imagedigitalocean.com/php aus, das Sie in Schritt 4 definieren werden. Außerdem werden dieworking_dir im Container auf/var/www gesetzt.
webserver: Diese Dienstdefinition ziehtnginx:alpine image aus Docker und macht die Ports80 und443 verfügbar.
db: Diese Dienstdefinition ruft diemysql:5.7.22 image aus Docker ab und definiert einige Umgebungsvariablen, einschließlich einer Datenbank mit dem Namenlaravel für Ihre Anwendung und des Kennwortsroot für die Datenbank. Sie können die Datenbank beliebig benennen undyour_mysql_root_password durch Ihr eigenes sicheres Kennwort ersetzen. Diese Dienstdefinition ordnet auch Port3306 auf dem Host Port3306 auf dem Container zu.

Jedecontainer_name-Eigenschaft definiert einen Namen für den Container, der dem Namen des Dienstes entspricht. Wenn Sie diese Eigenschaft nicht definieren, weist Docker jedem Container einen Namen zu, indem es den Namen einer historisch bekannten Person mit einem durch einen Unterstrich getrennten zufälligen Wort kombiniert.

Um die Kommunikation zwischen Containern zu erleichtern, sind die Dienste mit einem Brückennetzwerk namensapp-network verbunden. Ein Bridge-Netzwerk verwendet eine Software-Bridge, über die mit demselben Bridge-Netzwerk verbundene Container miteinander kommunizieren können. Der Brückentreiber installiert automatisch Regeln auf dem Hostcomputer, sodass Container in verschiedenen Brückennetzwerken nicht direkt miteinander kommunizieren können. Dies schafft ein höheres Maß an Sicherheit für Anwendungen und stellt sicher, dass nur verwandte Dienste miteinander kommunizieren können. Dies bedeutet auch, dass Sie mehrere Netzwerke und Dienste definieren können, die mit verwandten Funktionen verbunden sind: Front-End-Anwendungsdienste können beispielsweise einfrontend-Netzwerk verwenden, und Back-End-Dienste können einbackend-Netzwerk verwenden.

Schauen wir uns an, wie Sie Volumes hinzufügen und Bereitstellungen an Ihre Service-Definitionen binden, um Ihre Anwendungsdaten zu erhalten.

[[Schritt 3 - Beständige Daten]] == Schritt 3 - Beständige Daten

Docker verfügt über leistungsstarke und praktische Funktionen zum Speichern von Daten. In unserer Anwendung verwenden wirvolumes undbind mounts, um die Datenbank sowie Anwendungs- und Konfigurationsdateien beizubehalten. Volumes bieten Flexibilität für Sicherungen und Persistenz über den Lebenszyklus eines Containers hinaus, während Bindungsbereitstellungen Codeänderungen während der Entwicklung erleichtern und Änderungen an Ihren Hostdateien oder Verzeichnissen sofort in Ihren Containern verfügbar machen. Unser Setup wird beides nutzen.

[.warning] #Warning: Mithilfe von Bindungs-Mounts können Sie das Host-Dateisystem durch Prozesse ändern, die in einem Container ausgeführt werden, einschließlich des Erstellens, Änderns oder Löschens wichtiger Systemdateien oder -verzeichnisse. Dies ist eine leistungsstarke Funktion mit Auswirkungen auf die Sicherheit und kann sich auf Nicht-Docker-Prozesse auf dem Hostsystem auswirken. Gehen Sie vorsichtig mit Bindehalterungen um.
#

Definieren Sie in der Dateidocker-compose ein Volume mit dem Namendbdata unter der Dienstdefinitiondb, um die MySQL-Datenbank beizubehalten:

~/laravel-app/docker-compose.yml

...
#MySQL Service
db:
  ...
    volumes:
      - dbdata:/var/lib/mysql
    networks:
      - app-network
  ...

Das benannte Volumedbdata behält den Inhalt des Ordners/var/lib/mysql im Container bei. Auf diese Weise können Sie den Dienstdbtoppen und neu starten, ohne Daten zu verlieren.

Fügen Sie am Ende der Datei die Definition für das Volumen vondbdatahinzu:

~/laravel-app/docker-compose.yml

...
#Volumes
volumes:
  dbdata:
    driver: local

Mit dieser Definition können Sie dieses Volume dienstübergreifend verwenden.

Fügen Sie als Nächstes dem Dienstdbeinen Bind-Mount für die MySQL-Konfigurationsdateien hinzu, die Sie in Schritt 7 erstellen:

~/laravel-app/docker-compose.yml

...
#MySQL Service
db:
  ...
    volumes:
      - dbdata:/var/lib/mysql
      - ./mysql/my.cnf:/etc/mysql/my.cnf
  ...

Diese Bindungsmontage bindet~/laravel-app/mysql/my.cnf an/etc/mysql/my.cnf im Container.

Fügen Sie als Nächstes dem DienstwebserverBindungs-Mounts hinzu. Es gibt zwei: eine für Ihren Anwendungscode und eine für die Nginx-Konfigurationsdefinition, die Sie in Schritt 6 erstellen:

~/laravel-app/docker-compose.yml

#Nginx Service
webserver:
  ...
  volumes:
      - ./:/var/www
      - ./nginx/conf.d/:/etc/nginx/conf.d/
  networks:
      - app-network

Der erste Bind Mount bindet den Anwendungscode im Verzeichnis~/laravel-app an das Verzeichnis/var/www im Container. Die Konfigurationsdatei, die Sie zu~/laravel-app/nginx/conf.d/ hinzufügen, wird auch zu/etc/nginx/conf.d/ im Container bereitgestellt, sodass Sie den Inhalt des Konfigurationsverzeichnisses nach Bedarf hinzufügen oder ändern können.

Fügen Sie abschließend dem Dienstappdie folgenden Bindungs-Mounts für den Anwendungscode und die Konfigurationsdateien hinzu:

~/laravel-app/docker-compose.yml

#PHP Service
app:
  ...
  volumes:
       - ./:/var/www
       - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
  networks:
      - app-network

Der Dienstappbindet den Ordner~/laravel-app, der den Anwendungscode enthält, an den Ordner/var/www im Container. Dies beschleunigt den Entwicklungsprozess, da alle an Ihrem lokalen Anwendungsverzeichnis vorgenommenen Änderungen sofort im Container wiedergegeben werden. Sie binden auch Ihre PHP-Konfigurationsdatei~/laravel-app/php/local.ini an/usr/local/etc/php/conf.d/local.ini im Container. Sie erstellen die lokale PHP-Konfigurationsdatei in Schritt 5.

Ihredocker-compose-Datei sieht nun folgendermaßen aus:

~/laravel-app/docker-compose.yml

version: '3'
services:

  #PHP Service
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: digitalocean.com/php
    container_name: app
    restart: unless-stopped
    tty: true
    environment:
      SERVICE_NAME: app
      SERVICE_TAGS: dev
    working_dir: /var/www
    volumes:
      - ./:/var/www
      - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
    networks:
      - app-network

  #Nginx Service
  webserver:
    image: nginx:alpine
    container_name: webserver
    restart: unless-stopped
    tty: true
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./:/var/www
      - ./nginx/conf.d/:/etc/nginx/conf.d/
    networks:
      - app-network

  #MySQL Service
  db:
    image: mysql:5.7.22
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: your_mysql_root_password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - dbdata:/var/lib/mysql/
      - ./mysql/my.cnf:/etc/mysql/my.cnf
    networks:
      - app-network

#Docker Networks
networks:
  app-network:
    driver: bridge
#Volumes
volumes:
  dbdata:
    driver: local

Speichern Sie die Datei und schließen Sie den Editor, wenn Sie mit den Änderungen fertig sind.

Wenn Ihredocker-compose-Datei geschrieben ist, können Sie jetzt das benutzerdefinierte Image für Ihre Anwendung erstellen.

[[Schritt-4 - Erstellen der Docker-Datei]] == Schritt 4 - Erstellen der Docker-Datei

Mit Docker können Sie die Umgebung innerhalb einzelner Container mit einemDockerfile angeben. Mit einer Docker-Datei können Sie benutzerdefinierte Images erstellen, mit denen Sie die für Ihre Anwendung erforderliche Software installieren und die Einstellungen Ihren Anforderungen entsprechend konfigurieren können. Sie können die von Ihnen erstellten benutzerdefinierten Bilder anDocker Hub oder eine beliebige private Registrierung senden.

UnsereDockerfile befinden sich in unserem~/laravel-app-Verzeichnis. Erstellen Sie die Datei:

nano ~/laravel-app/Dockerfile

MitDockerfile wird das Basisimage festgelegt und die erforderlichen Befehle und Anweisungen zum Erstellen des Laravel-Anwendungsimages angegeben. Fügen Sie der Datei den folgenden Code hinzu:

~/laravel-app/php/Dockerfile

FROM php:7.2-fpm

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

# Set working directory
WORKDIR /var/www

# Install dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    mysql-client \
    libpng-dev \
    libjpeg62-turbo-dev \
    libfreetype6-dev \
    locales \
    zip \
    jpegoptim optipng pngquant gifsicle \
    vim \
    unzip \
    git \
    curl

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

# Install extensions
RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl
RUN docker-php-ext-configure gd --with-gd --with-freetype-dir=/usr/include/ --with-jpeg-dir=/usr/include/ --with-png-dir=/usr/include/
RUN docker-php-ext-install gd

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

# Add user for laravel application
RUN groupadd -g 1000 www
RUN useradd -u 1000 -ms /bin/bash -g www www

# Copy existing application directory contents
COPY . /var/www

# Copy existing application directory permissions
COPY --chown=www:www . /var/www

# Change current user to www
USER www

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

Zunächst erstellt die Docker-Datei ein Bild über denphp:7.2-fpm Docker image. Dies ist ein Debian-basiertes Image, auf dem die PHP FastCGI-ImplementierungPHP-FPMinstalliert ist. Die Datei installiert auch die erforderlichen Pakete für Laravel:mcrypt,pdo_mysql,mbstring undimagick mitcomposer.

Die AnweisungRUN gibt die Befehle zum Aktualisieren, Installieren und Konfigurieren der Einstellungen im Container an, einschließlich des Erstellens eines dedizierten Benutzers und einer Gruppe mit dem Namenwww. Die AnweisungWORKDIR gibt das Verzeichnis/var/www als Arbeitsverzeichnis für die Anwendung an.

Durch das Erstellen eines dedizierten Benutzers und einer Gruppe mit eingeschränkten Berechtigungen wird die inhärente Sicherheitsanfälligkeit beim Ausführen von Docker-Containern verringert, die standardmäßig alsroot ausgeführt werden. Anstatt diesen Container alsroot auszuführen, haben wir den Benutzerwwwerstellt, der dank der AnweisungCOPY Lese- / Schreibzugriff auf den Ordner/var/wwwhat Verwenden Sie das Flag--chown, um die Berechtigungen des Anwendungsordners zu kopieren.

Schließlich macht der BefehlEXPOSE einen Port im Container9000 für den Serverphp-fpm verfügbar. CMD gibt den Befehl an, der ausgeführt werden soll, sobald der Container erstellt wurde. Hier gibtCMD"php-fpm" an, wodurch der Server gestartet wird.

Speichern Sie die Datei und schließen Sie den Editor, wenn Sie mit den Änderungen fertig sind.

Sie können nun mit der Definition Ihrer PHP-Konfiguration fortfahren.

[[Schritt-5 - Konfigurieren von PHP]] == Schritt 5 - Konfigurieren von PHP

Nachdem Sie Ihre Infrastruktur in der Dateidocker-composedefiniert haben, können Sie den PHP-Dienst so konfigurieren, dass er als PHP-Prozessor für eingehende Anforderungen von Nginx fungiert.

Um PHP zu konfigurieren, erstellen Sie die Dateilocal.ini im Ordnerphp. Dies ist die Datei, die Sie in Schritt 2 an/usr/local/etc/php/conf.d/local.ini im Container gebunden haben. Durch das Erstellen dieser Datei können Sie die Standarddateiphp.iniüberschreiben, die PHP beim Start liest.

Erstellen Sie das Verzeichnisphp:

mkdir ~/laravel-app/php

Öffnen Sie als Nächstes die Dateilocal.ini:

nano ~/laravel-app/php/local.ini

Um zu demonstrieren, wie PHP konfiguriert wird, fügen wir den folgenden Code hinzu, um Größenbeschränkungen für hochgeladene Dateien festzulegen:

~/laravel-app/php/local.ini

upload_max_filesize=40M
post_max_size=40M

Die Anweisungenupload_max_filesize undpost_max_size legen die maximal zulässige Größe für hochgeladene Dateien fest und zeigen, wie Sie die Konfigurationen vonphp.iniaus Ihrerlocal.ini-Datei festlegen können. Sie können jede PHP-spezifische Konfiguration, die Sie überschreiben möchten, in die Dateilocal.inieinfügen.

Speichern Sie die Datei und beenden Sie Ihren Editor.

Wenn Ihre PHPlocal.ini-Datei vorhanden ist, können Sie mit der Konfiguration von Nginx fortfahren.

[[Schritt-6 - Konfigurieren von Nginx]] == Schritt 6 - Konfigurieren von Nginx

Wenn der PHP-Dienst konfiguriert ist, können Sie den Nginx-Dienst so ändern, dass PHP-FPM als FastCGI-Server für die Bereitstellung dynamischer Inhalte verwendet wird. Der FastCGI-Server basiert auf einem Binärprotokoll zur Anbindung interaktiver Programme an einen Webserver. Weitere Informationen finden Sie in diesem Artikel zuUnderstanding and Implementing FastCGI Proxying in Nginx.

Um Nginx zu konfigurieren, erstellen Sie eineapp.conf-Datei mit der Dienstkonfiguration im Ordner~/laravel-app/nginx/conf.d/.

Erstellen Sie zunächst das Verzeichnisnginx/conf.d/:

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

Erstellen Sie als Nächstes die Konfigurationsdatei vonapp.conf:

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

Fügen Sie der Datei den folgenden Code hinzu, um Ihre Nginx-Konfiguration anzugeben:

~/laravel-app/nginx/conf.d/app.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;
    }
}

server block definiert die Konfiguration für den Nginx-Webserver mit den folgenden Anweisungen:

listen: Diese Anweisung definiert den Port, an dem der Server eingehende Anforderungen abhört.
error_log undaccess_log: Diese Anweisungen definieren die Dateien zum Schreiben von Protokollen.
root: Diese Anweisung legt den Pfad des Stammordners fest und bildet den vollständigen Pfad zu jeder angeforderten Datei im lokalen Dateisystem.

Im Standortblockphp gibt die Anweisungfastcgi_pass an, dass der Dienstappeinen TCP-Socket an Port9000 überwacht. Dadurch lauscht der PHP-FPM-Server über das Netzwerk und nicht über einen Unix-Socket. Ein Unix-Socket hat zwar einen kleinen Geschwindigkeitsvorteil gegenüber einem TCP-Socket, verfügt jedoch nicht über ein Netzwerkprotokoll und überspringt daher den Netzwerkstapel. In Fällen, in denen sich Hosts auf einem Computer befinden, kann ein Unix-Socket sinnvoll sein. In Fällen, in denen Dienste auf verschiedenen Hosts ausgeführt werden, bietet ein TCP-Socket den Vorteil, dass Sie eine Verbindung zu verteilten Diensten herstellen können. Da unserapp-Container auf einem anderen Host als unserwebserver-Container ausgeführt wird, ist ein TCP-Socket für unsere Konfiguration am sinnvollsten.

Speichern Sie die Datei und schließen Sie den Editor, wenn Sie mit den Änderungen fertig sind.

Dank des in Schritt 2 erstellten Bind-Mount werden alle Änderungen, die Sie im Ordnernginx/conf.d/vornehmen, direkt im Containerwebserverangezeigt.

Schauen wir uns als nächstes unsere MySQL-Einstellungen an.

[[Schritt-7 - Konfigurieren von MySQL]] == Schritt 7 - Konfigurieren von MySQL

Wenn PHP und Nginx konfiguriert sind, können Sie MySQL als Datenbank für Ihre Anwendung aktivieren.

Um MySQL zu konfigurieren, erstellen Sie die Dateimy.cnf im Ordnermysql. Dies ist die Datei, die Sie in Schritt 2 an/etc/mysql/my.cnf im Container gebunden haben. Mit diesem Bindungs-Mount können Sie die Einstellungen vonmy.cnfbei Bedarf überschreiben.

Um zu demonstrieren, wie dies funktioniert, fügen wir dermy.cnf-Datei Einstellungen hinzu, die das allgemeine Abfrageprotokoll aktivieren und die Protokolldatei angeben.

Erstellen Sie zunächst das Verzeichnismysql:

mkdir ~/laravel-app/mysql

Als nächstes erstellen Sie diemy.cnf-Datei:

nano ~/laravel-app/mysql/my.cnf

Fügen Sie in der Datei den folgenden Code hinzu, um das Abfrageprotokoll zu aktivieren und den Speicherort der Protokolldatei festzulegen:

~/laravel-app/mysql/my.cnf

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

Diesemy.cnf-Datei aktiviert Protokolle und definiert die Einstellunggeneral_log als1, um allgemeine Protokolle zuzulassen. Die Einstellunggeneral_log_file gibt an, wo die Protokolle gespeichert werden.

Speichern Sie die Datei und beenden Sie Ihren Editor.

Unser nächster Schritt wird sein, die Container zu starten.

[[Schritt 8 - Ausführen der Container und Ändern der Umgebungseinstellungen] == Schritt 8 - Ausführen der Container und Ändern der Umgebungseinstellungen

Nachdem Sie alle Ihre Dienste in derdocker-compose-Datei definiert und die Konfigurationsdateien für diese Dienste erstellt haben, können Sie die Container starten. Als letzten Schritt erstellen wir jedoch eine Kopie der.env.example-Datei, die Laravel standardmäßig enthält, und benennen die Kopie.env, die die Datei ist, von der Laravel erwartet, dass sie ihre Umgebung definiert:

cp .env.example .env

Wir werden die spezifischen Details unseres Setups in dieser Datei konfigurieren, sobald wir die Container gestartet haben.

Wenn alle Ihre Dienste in derdocker-compose-Datei definiert sind, müssen Sie nur einen einzigen Befehl ausgeben, um alle Container zu starten, die Volumes zu erstellen und die Netzwerke einzurichten und zu verbinden:

docker-compose up -d

Wenn Siedocker-compose up zum ersten Mal ausführen, werden alle erforderlichen Docker-Images heruntergeladen. Dies kann eine Weile dauern. Sobald die Bilder heruntergeladen und auf Ihrem lokalen Computer gespeichert wurden, erstellt Compose Ihre Container. Das-d-Flag dämonisiert den Prozess und führt Ihre Container im Hintergrund aus.

Verwenden Sie nach Abschluss des Vorgangs den folgenden Befehl, um alle ausgeführten Container aufzulisten:

docker ps

Sie sehen die folgende Ausgabe mit Details zu Ihren Containernapp,webserver unddb:

OutputCONTAINER ID        NAMES               IMAGE                             STATUS              PORTS
c31b7b3251e0        db                  mysql:5.7.22                      Up 2 seconds        0.0.0.0:3306->3306/tcp
ed5a69704580        app                 digitalocean.com/php              Up 2 seconds        9000/tcp
5ce4ee31d7c0        webserver           nginx:alpine                      Up 2 seconds        0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp

DieCONTAINER ID in dieser Ausgabe sind eine eindeutige Kennung für jeden Container, währendNAMES den jedem zugeordneten Dienstnamen auflistet. Sie können beide Bezeichner verwenden, um auf die Container zuzugreifen. IMAGE definiert den Bildnamen für jeden Container, währendSTATUS Informationen zum Status des Containers enthält: ob er ausgeführt, neu gestartet oder gestoppt wird.

Sie können jetzt die Datei.envim Containerappo ändern, dass sie bestimmte Details zu Ihrem Setup enthält.

Öffnen Sie die Datei mitdocker-compose exec, damit Sie bestimmte Befehle in Containern ausführen können. In diesem Fall öffnen Sie die Datei zur Bearbeitung:

docker-compose exec app nano .env

Suchen Sie den Block, derDB_CONNECTION angibt, und aktualisieren Sie ihn, um die Besonderheiten Ihres Setups widerzuspiegeln. Sie werden die folgenden Felder ändern:

DB_HOST ist der Datenbankcontainer Ihresdb.
DB_DATABASE ist dielaravel-Datenbank.
DB_USERNAME ist der Benutzername, den Sie für Ihre Datenbank verwenden. In diesem Fall verwenden wirlaraveluser.
DB_PASSWORD ist das sichere Passwort, das Sie für dieses Benutzerkonto verwenden möchten.

/var/www/.env

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laraveluser
DB_PASSWORD=your_laravel_db_password

Speichern Sie Ihre Änderungen und schließen Sie den Editor.

Legen Sie als Nächstes den Anwendungsschlüssel für die Laravel-Anwendung mit dem Befehlphp artisan key:generate fest. Dieser Befehl generiert einen Schlüssel und kopiert ihn in die Datei.env, um sicherzustellen, dass Ihre Benutzersitzungen und verschlüsselten Daten sicher bleiben:

docker-compose exec app php artisan key:generate

Sie haben jetzt die Umgebungseinstellungen, die zum Ausführen Ihrer Anwendung erforderlich sind. Führen Sie Folgendes aus, um diese Einstellungen in einer Datei zwischenzuspeichern, die die Ladegeschwindigkeit Ihrer Anwendung erhöht:

docker-compose exec app php artisan config:cache

Ihre Konfigurationseinstellungen werden in/var/www/bootstrap/cache/config.php auf dem Container geladen.

Besuchen Sie als letzten Schritthttp://your_server_ip im Browser. Sie sehen die folgende Homepage für Ihre Laravel-Anwendung:

Laravel Home Page

Wenn Ihre Container ausgeführt werden und Ihre Konfigurationsinformationen vorhanden sind, können Sie mit der Konfiguration Ihrer Benutzerinformationen für die Datenbanklaravelauf dem Containerdbfortfahren.

[[Schritt 9 - Erstellen eines Benutzers für MySQL]] == Schritt 9 - Erstellen eines Benutzers für MySQL

Bei der Standardinstallation von MySQL wird nur das Administratorkonto vonrooterstellt, das über unbegrenzte Berechtigungen auf dem Datenbankserver verfügt. Im Allgemeinen ist es besser, die Verwendung des Administratorkontos vonrootbei der Interaktion mit der Datenbank zu vermeiden. Erstellen wir stattdessen einen dedizierten Datenbankbenutzer für die Laravel-Datenbank unserer Anwendung.

Um einen neuen Benutzer zu erstellen, führen Sie eine interaktive Bash-Shell für den Containerdbmitdocker-compose exec aus:

docker-compose exec db bash

Melden Sie sich im Container beim Administratorkonto von MySQLrootan:

mysql -u root -p

Sie werden aufgefordert, das Kennwort einzugeben, das Sie während der Installation in der Dateidocker-composefür das Konto von MySQLrootfestgelegt haben.

Suchen Sie zunächst nach der Datenbanklaravel, die Sie in Ihrerdocker-compose-Datei definiert haben. Führen Sie den Befehlshow databases aus, um nach vorhandenen Datenbanken zu suchen:

show databases;

In der Ausgabe wird die Datenbanklaravelaufgelistet:

Output+--------------------+
| Database           |
+--------------------+
| information_schema |
| laravel            |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.00 sec)

Erstellen Sie als Nächstes das Benutzerkonto, das auf diese Datenbank zugreifen darf. Unser Benutzername lautetlaraveluser. Sie können ihn jedoch durch einen anderen Namen ersetzen, wenn Sie dies bevorzugen. Stellen Sie nur sicher, dass Ihr Benutzername und Ihr Passwort hier mit den Details übereinstimmen, die Sie im vorherigen Schritt in Ihrer.env-Datei festgelegt haben:

GRANT ALL ON laravel.* TO 'laraveluser'@'%' IDENTIFIED BY 'your_laravel_db_password';

Bereinigen Sie die Berechtigungen, um den MySQL-Server über die Änderungen zu informieren:

FLUSH PRIVILEGES;

Beenden Sie MySQL:

EXIT;

Zum Schluss verlassen Sie den Container:

exit

Sie haben das Benutzerkonto für Ihre Laravel-Anwendungsdatenbank konfiguriert und können nun Ihre Daten migrieren und mit der Tinker-Konsole arbeiten.

[[Schritt 10 - Migrieren von Daten und Arbeiten mit der Bastelkonsole] == Schritt 10 - Migrieren von Daten und Arbeiten mit der Bastelkonsole

Während Ihre Anwendung ausgeführt wird, können Sie Ihre Daten migrieren und mit dem Befehltinker experimentieren, wodurch einePsySH-Konsole mit vorinstalliertem Laravel initiiert wird. PsySH ist eine Laufzeit-Entwicklerkonsole und ein interaktiver Debugger für PHP, und Tinker ist eine REPL speziell für Laravel. Mit dem Befehltinker können Sie über die Befehlszeile in einer interaktiven Shell mit Ihrer Laravel-Anwendung interagieren.

Testen Sie zunächst die Verbindung zu MySQL, indem Sie den Befehl Laravelartisan migrateausführen, mit dem aus dem Container heraus eine Tabellemigrationsin der Datenbank erstellt wird:

docker-compose exec app php artisan migrate

Dieser Befehl migriert die Standard-Laravel-Tabellen. Die Ausgabe, die die Migration bestätigt, sieht folgendermaßen aus:

Output
Migration table created successfully.
Migrating: 2014_10_12_000000_create_users_table
Migrated:  2014_10_12_000000_create_users_table
Migrating: 2014_10_12_100000_create_password_resets_table
Migrated:  2014_10_12_100000_create_password_resets_table

Nach Abschluss der Migration können Sie mit dem Befehltinker eine Abfrage ausführen, um zu überprüfen, ob Sie ordnungsgemäß mit der Datenbank verbunden sind:

docker-compose exec app php artisan tinker

Testen Sie die MySQL-Verbindung, indem Sie die soeben migrierten Daten abrufen:

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

Sie werden eine Ausgabe sehen, die so aussieht:

Output=> Illuminate\Support\Collection {#2856
     all: [
       {#2862
         +"id": 1,
         +"migration": "2014_10_12_000000_create_users_table",
         +"batch": 1,
       },
       {#2865
         +"id": 2,
         +"migration": "2014_10_12_100000_create_password_resets_table",
         +"batch": 1,
       },
     ],
   }

Sie könnentinker verwenden, um mit Ihren Datenbanken zu interagieren und mit Diensten und Modellen zu experimentieren.

Mit Ihrer Laravel-Anwendung können Sie weiterentwickelt und experimentiert werden.

Fazit

Auf Ihrem Server wird jetzt eine LEMP-Stapelanwendung ausgeführt, die Sie getestet haben, indem Sie auf die Laravel-Begrüßungsseite zugegriffen und MySQL-Datenbankmigrationen erstellt haben.

Der Schlüssel zur Einfachheit dieser Installation ist Docker Compose, mit dem Sie mit einem einzigen Befehl eine Gruppe von Docker-Containern erstellen können, die in einer einzigen Datei definiert sind. Wenn Sie mehr darüber erfahren möchten, wie Sie CI mit Docker Compose ausführen, sehen Sie sichHow To Configure a Continuous Integration Testing Environment with Docker and Docker Compose on Ubuntu 16.04 an. Wenn Sie Ihren Bereitstellungsprozess für Laravel-Anwendungen optimieren möchten, istHow to Automatically Deploy Laravel Applications with Deployer on Ubuntu 16.04 eine relevante Ressource.

TOC

So richten Sie Laravel, Nginx und MySQL mit Docker Compose ein

Einführung

Voraussetzungen

Fazit

Related