Einführung
Continuous Integration (CI) und Continuous Deployment (CD) gehören derzeit zu den am meisten diskutierten Themen in der Softwareentwicklung. Um den CI/CD-Aspekt der Softwarearchitektur zu erreichen, nutzen Entwickler Container. Container sind leichtgewichtige, virtualisierte, portable, softwaredefinierte Umgebungen. In Containern kann die Software isoliert von anderer Software ausgeführt werden, die auf dem physischen Host-Rechner läuft. Der Schwerpunkt dieses Tutorials liegt auf der Nutzung der Container-Plattform Docker, um Webanwendungen bereitzustellen und auszuführen. Docker hilft dabei, den Einrichtungsprozess eines Webserver-Stacks zu rationalisieren. In diesem Tutorial werden wir den LEMP-Stack verwenden, um eine Laravel-Anwendung bereitzustellen.
Der LEMP-Stack kombiniert Linux als Betriebssystem, Nginx als Webserver, MySQL als Datenbank und PHP als Sprache für Skripting und dynamische Verarbeitung. Sie können unserem Tutorial zur Installation und Konfiguration eines LEMP-Stacks auf Ubuntu folgen. Laravel ist eines der führenden PHP-Frameworks für die Entwicklung von Webanwendungen.
Docker bietet ein Tool namens Docker Compose zur Definition des Einrichtungsprozesses eines Docker-Containers. Docker Compose ermöglicht es Entwicklern, die Infrastruktur ihrer Anwendung, Dienste, Volumes, Netzwerke und alle Abhängigkeiten in einer einzigen Datei namens docker-compose-Datei zu definieren. Es kann mehrere Docker-Container über seine Befehle wie docker container create, docker container run usw. verwalten.
In diesem Tutorial lernen Sie, wie Sie eine Laravel-Webanwendung mit Nginx und MySQL in einem Docker-Container bereitstellen. Die Konfigurationen für den gesamten Stack werden in einer docker-compose-Datei definiert, ebenso wie andere Konfigurationsdateien für PHP, MySQL und Nginx. Lassen Sie uns beginnen!
Das Wichtigste zuerst
- Da es sich um ein praktisches Tutorial handelt, sollten Sie eine Installation von Ubuntu 20.04 als Ihre anfängliche Betriebsumgebung haben. Sie sollten außerdem über einen Nicht-Root-Benutzer mit sudo-Rechten verfügen. Hier ist ein Schritt-für-Schritt-Tutorial, das Ihnen bei der Einrichtung Ihres Ubuntu-Servers hilft.
- . Sie müssen Docker installieren. Wir haben ein Tutorial darüber, wie man Docker auf Ubuntu 18.04 installiert und bedient.
- . Sie müssen Docker Compose gemäß dem Tutorial aus der offiziellen Docker-Dokumentation installieren.
Schritt 1: Laravel herunterladen und die Abhängigkeiten installieren
Der erste Schritt besteht darin, den Laravel-Code aus einem Repository zu beziehen. In realen Szenarien haben Sie Ihren Laravel-Code möglicherweise irgendwo in einem Repository, z. B. auf GitHub, Bitbucket, Gitlab usw. Für dieses Tutorial werden wir jedoch die neueste Version aus dem offiziellen Laravel-Repository auf GitHub klonen. Das Repository enthält eine Composer-Datei, einen Abhängigkeitsmanager auf Anwendungsebene für PHP. Da wir möchten, dass alles innerhalb des Docker-Containers läuft, werden wir die Abhängigkeiten mithilfe des Docker-composer-Images installieren. Dies hilft uns auch zu vermeiden, dass wir Composer global auf dem eigentlichen Host-Rechner installieren müssen. Starten Sie als Nächstes Ihr Terminal.
Wechseln Sie in Ihr Home-Verzeichnis:
|
1 |
cd ~ |
Geben Sie den folgenden Befehl ein, um das Repository in ein Verzeichnis namens laravel-web zu klonen. Sie können es beliebig benennen. Zum Zeitpunkt des Schreibens dieses Repositories zieht dieser Befehl die Laravel-Version 8. Wenn Sie den Befehl ausführen, werden Sie wahrscheinlich eine neuere Version vorfinden:
|
1 |
git clone https://github.com/laravel/laravel.git laravel-web |
Wechseln Sie dann in das Verzeichnis, in das Sie das Repository gerade geklont haben:
|
1 |
cd ~/laravel-web |
Geben Sie den folgenden Befehl ein, um die von Ihrer Laravel-App benötigten Verzeichnisse mithilfe des Docker-composer-Images zu mounten::
|
1 |
docker run --rm -v $(pwd):/app composer install |
Die -v und –rm Flags im Befehl docker run erstellen einen temporären Container, der vor dem Entfernen per Bind-Mount an das aktuelle Verzeichnis gebunden wird. Der Befehl kopiert den Inhalt von ~/laravel-web in den Container und stellt sicher, dass der vom Composer erstellte Vendor-Ordner wieder in das aktuelle Verzeichnis zurückkopiert wird.
Jetzt müssen Sie den Besitz des Verzeichnisses laravel-web auf den Nicht-Root-Benutzer übertragen. Dies ermöglicht es Ihnen, in den folgenden Schritten als Nicht-Root-Benutzer mit Ihrem Anwendungscode zu arbeiten und Prozesse innerhalb des Containers auszuführen. Geben Sie den folgenden Befehl ein, um den Besitz zu ändern:
|
1 |
sudo chown -R $USER:$USER ~/laravel-web |
Ihr Anwendungscode ist nun an Ort und Stelle. Das Verzeichnis gehört einem Nicht-Root-Benutzer, sodass Sie mit der Definition der Anwendungsdienste in der docker-compose-Datei fortfahren können.
Schritt 2: Erstellen der Docker Compose-Datei
Docker Compose vereinfacht den Prozess des Erstellens und Bereitstellens einer Anwendung. Sobald Sie die Konfigurationen und Dienste definiert haben, können Sie Ihre Anwendung problemlos auf jedem Host-Rechner bereitstellen, auf dem Docker und Docker Compose installiert sind, ohne sich um die Anwendungsabhängigkeiten kümmern zu müssen. Vor allem können Sie dies mit nur einem einzigen Docker Compose-Befehl tun, wie wir in Schritt 9.
In diesem Schritt definieren Sie eine Docker Compose-Datei mit Konfigurationen für den Webserver, die Datenbank und die Anwendungsdienste, die für die Bereitstellung einer Laravel-App erforderlich sind.
Docker Compose-Dateien sind YAML-Dateien, die mit der Endung .yml gespeichert werden. Bitte beachten Sie, dass für eine gültige Docker Compose-Datei eine korrekte Einrückung erforderlich ist. Geben Sie den folgenden Befehl ein, um die Datei zu erstellen und mit nano zur Bearbeitung zu öffnen:
|
1 |
nano ~/laravel-web/docker-compose.yml |
Als Nächstes definieren Sie in dieser Datei drei Dienste: app, webserver und db. Der Abschnitt db definiert die Datenbank-Anmeldedaten für Ihre Anwendung. Achten Sie also darauf, ein starkes mysql_root_password zu wählen und es in diesem Abschnitt zu ersetzen. Kopieren Sie den folgenden Code und fügen Sie ihn ein:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
version: '2.0' services: #PHP-Dienst app: build: context: . dockerfile: Dockerfile image: cloudsigma.com/php container_name: app restart: unless-stopped tty: true environment: SERVICE_NAME: app SERVICE_TAGS: dev working_dir: /var/www/html/ networks: - app-network #Nginx-Dienst webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" networks: - app-network #MySQL-Dienst db: image: mysql:5.7.32 container_name: db restart: unless-stopped tty: true ports: - "3306:3306" environment: MYSQL_DATABASE: laravel_web MYSQL_ROOT_PASSWORD: replace_mysql_root_password SERVICE_TAGS: dev SERVICE_NAME: mysql networks: - app-network #Docker-Netzwerke networks: app-network: driver: bridge |
Nachfolgend finden Sie Erklärungen zu den Dienstdefinitionen aus dem obigen Code:
- app: Definiert die Laravel-Anwendung und führt ein benutzerdefiniertes Docker-Image, cloudsigma.com/php, aus, das wir in Schritt 4 definieren werden. Es legt auch das working_dir im Container auf /var/www/html fest.
- webserver: Es zieht das nginx:alpine-Image von Docker und gibt die Ports 80 und 443.
- db: Es zieht das mysql:5.7.32-Image von Docker und definiert einige Umgebungsvariablen. Dazu gehört eine Datenbank namens laravel_web für die Anwendung und das Root-Passwort für die Datenbank. Sie können die Datenbank in einen Namen Ihrer Wahl umbenennen. Denken Sie daran, die Eigenschaft MYSQL_ROOT_PASSWORD durch ein starkes Passwort zu ersetzen. Dieser Dienst ordnet außerdem den Port 3306 auf dem Host dem Port 3306 auf dem Container zu.
Die Eigenschaft container_name in jedem Dienst definiert einen Namen für den Container, der dem Dienst entspricht. Wenn Sie die Eigenschaft nicht definieren, wählt Docker einen zufälligen Namen für jeden Container.
Die Eigenschaft networks definiert ein Bridge-Netzwerk namens app-network, das die Kommunikation zwischen Containern erleichtert. Ein Bridge-Netzwerk wird von einer Software-Bridge gesteuert, die nur die Kommunikation zwischen Containern auf derselben Netzwerkbrücke zulässt. Der Software-Controller der Bridge installiert Treiber, die verhindern, dass Container in verschiedenen Bridge-Netzwerken direkt miteinander kommunizieren. Dies gewährleistet ein hohes Maß an Sicherheit, da nur verwandte Dienste direkt kommunizieren können. Sie können sich dafür entscheiden, mehrere Dienste und Netzwerke zu definieren, die mit verwandten Funktionen verbunden sind.
Schritt 3: Wie man Daten persistiert
Ihre Webanwendung wird Daten verarbeiten und für Ihre Benutzer bereitstellen. In diesem Schritt führen wir Sie durch die Definition von Volumes und Bind Mounts für Ihre Dienstdefinitionen, um die Daten der Anwendung zu persistieren. Docker bietet unglaubliche Funktionen wie Bind Mounts und Volumes zur Persistierung von Daten und zum Speichern von Anwendungskonfigurationsdateien. Wir werden sie bei der Einrichtung unserer Laravel-App mit Docker verwenden.
Volumes werden aus verschiedenen Gründen bevorzugt, unter anderem weil sie Backups bieten und Daten über den Lebenszyklus eines Containers hinaus persistieren. Bind Mounts verweisen in der Regel auf ein tatsächliches Verzeichnis auf dem Host-Rechner. Wenn Sie ein Volume erstellen, wird ein neues Verzeichnis im Speicherverzeichnis von Docker erstellt, das von Docker verwaltet wird. Wenn Sie einen Bind Mount erstellen, wird eine Datei oder ein Verzeichnis auf dem Host-Rechner in einen Container gemountet (referenziert durch seinen absoluten Pfad). Dies ist für unsere Webanwendung von entscheidender Bedeutung, denn wenn Sie Änderungen am Code auf dem Host-Rechner vornehmen, stehen diese dem Container sofort zur Verfügung.
Seien Sie vorsichtig bei der Verwendung von Bind Mounts. Prozesse, die innerhalb des Docker-Containers ausgeführt werden, können Änderungen am Host-Dateisystem vornehmen und Nicht-Docker-Prozesse beeinträchtigen, die auf dem Host-System ausgeführt werden. Obwohl Docker-Mounts eine leistungsstarke Funktion sind, sollten Sie sich dieser Sicherheitsimplikationen bewusst sein.
Sehen wir uns nun an, wie wir diese beiden Funktionen in unserem Setup nutzen können. Zuerst definieren wir ein Volume zur Persistierung der MySQL-Datenbank. Fügen Sie in der von uns erstellten Docker Compose-Datei unter dem db-Dienst eine volumes-Eigenschaft hinzu, wie unten hervorgehoben:
|
1 2 3 4 5 6 7 8 |
#MySQL-Dienst db: ... volumes: - dbdata:/var/lib/mysql/ networks: - app-network ... |
Wie definiert, wird das Volume dbdata den Inhalt von /var/lib/mysql persistieren. Es erleichtert Backups und ermöglicht Dienst-Neustarts, ohne dass Daten verloren gehen. Als Nächstes sollten Sie die Definition der Volumes am Ende der Docker Compose-Datei hinzufügen, um sie dienstübergreifend verfügbar zu machen. Fügen Sie das folgende Code-Snippet am Ende der Datei ein:
|
1 2 3 4 |
#Volumes volumes: dbdata: driver: local |
Um eine Verbindung zu einer MySQL-Datenbank herzustellen, müssen Sie Anmeldedaten angeben. Definieren Sie dazu einen Bind Mount, indem Sie das folgende hervorgehobene Code-Snippet zum db-Dienst unter der Eigenschaft volumes hinzufügen:
|
1 2 3 4 5 6 7 |
#MySQL-Dienst db: ... volumes: - dbdata:/var/lib/mysql/ - ./mysql/my.cnf:/etc/mysql/my.cnf ... |
Der Code bindet ~/laravel-web/mysql/my.cnf an /etc/mysql/my.cnf im Container. Die gebundene Datei ist die MySQL-Konfigurationsdatei, die wir in Schritt 7.
Der Container muss den Nginx-Server verwenden, um Ihren Anwendungscode bereitzustellen. Daher definieren wir zu diesem Zweck zwei Bind Mounts (einen für die Nginx-Konfigurationsdatei und einen für den Anwendungscode) unter dem webserver-Dienst. Fügen Sie das folgende Code-Snippet für die Definition der Volumes unter dem webserver-Dienst hinzu:
|
1 2 3 4 5 6 7 8 |
#Nginx-Dienst webserver: ... volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network |
Diese Zeile – ./:/var/www/html bindet den Anwendungscode im Verzeichnis ~/laravel-web an das Verzeichnis /var/www/html im Container. Für den zweiten Bind-Mount wird eine Konfigurationsdatei für Nginx unter ~/laravel-web/nginx/conf.d/ erstellt. Sie wird nach /etc/nginx/conf.d/ im Container gemountet. Daher können Sie die Konfigurationsdatei auf dem Host-Rechner nach Bedarf aktualisieren. Wir werden die Nginx-Konfigurationsdatei in Schritt 6.
Damit Änderungen im Code automatisch im Container übernommen werden, binden wir den Anwendungscode per Bind-Mount an den Container. Dies beschleunigt den Bereitstellungsprozess. Fügen Sie daher das folgende hervorgehobene Code-Snippet zum app-Dienst hinzu:
|
1 2 3 4 5 6 7 8 |
#PHP-Dienst app: ... volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network |
Die zweite Zeile bindet eine PHP-Konfigurationsdatei, die wir in Schritt 5 in der Datei ~/laravel-web/php/laravel.ini an /usr/local/etc/php/conf.d/laravel.ini im Container binden.
Ihre vollständige Docker-Compose-Datei sollte nun wie folgt aussehen:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
version: '2.0' services: #PHP-Dienst app: build: context: . dockerfile: Dockerfile image: cloudsigma.com/php container_name: app restart: unless-stopped tty: true environment: SERVICE_NAME: app SERVICE_TAGS: dev working_dir: /var/www/html/ volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network #Nginx-Dienst webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network #MySQL-Dienst db: image: mysql:5.7.32 container_name: db restart: unless-stopped tty: true ports: - "3306:3306" environment: MYSQL_DATABASE: laravel_web MYSQL_ROOT_PASSWORD: replace_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-Netzwerke networks: app-network: driver: bridge #Volumes volumes: dbdata: driver: local |
Wenn alles in Ordnung aussieht, drücken Sie Strg + O, um die Datei zu speichern. Drücken Sie dann Strg + X, um den Editor zu verlassen. An diesem Punkt sollten Sie in der Lage sein, mit der Docker-Compose-Datei ein benutzerdefiniertes Docker-Image für Ihre Anwendung zu erstellen.
Schritt 4: Erstellen des Dockerfiles
Ein Dockerfile enthält Anweisungen, die Docker verwenden kann, um benutzerdefinierte Docker-Images zu erstellen. Es kann auch die erforderliche Software installieren und die notwendigen Einstellungen für Ihre Anwendung konfigurieren. Sie legen die Umgebung innerhalb eines Containers fest, in dem Ihr Anwendungscode gehostet wird. Sie können die von Ihnen erstellten Images an Docker Hub übertragen, um sie zu teilen, oder sie in anderen privaten Registries ablegen.
Wir erstellen ein Dockerfile, das die Anweisungen zum Erstellen des Laravel-Anwendungs-Images festlegt. Verwenden Sie nano, um das Dockerfile im Verzeichnis ~/laravel-web zu erstellen:
|
1 |
nano ~/laravel-web/Dockerfile |
Fügen Sie im geöffneten Editor den folgenden Code hinzu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
FROM php:7.4-fpm # Kopieren Sie composer.lock und composer.json in das Arbeitsverzeichnis COPY composer.lock composer.json /var/www/html/ # Arbeitsverzeichnis festlegen WORKDIR /var/www/html/ # Abhängigkeiten für die Betriebssystem-Software installieren RUN apt-get update && apt-get install -y \ build-essential \ libpng-dev \ libjpeg62-turbo-dev \ libfreetype6-dev \ locales \ zip \ jpegoptim optipng pngquant gifsicle \ vim \ libzip-dev \ unzip \ git \ libonig-dev \ curl # Cache leeren RUN apt-get clean && rm -rf /var/lib/apt/lists/* # Erweiterungen für PHP installieren RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl RUN docker-php-ext-configure gd --with-freetype --with-jpeg RUN docker-php-ext-install gd # Composer (PHP-Paketmanager) installieren RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer # Kopieren Sie den Inhalt des vorhandenen Anwendungsverzeichnisses in das Arbeitsverzeichnis COPY . /var/www/html # Berechtigungen des Arbeitsverzeichnisses dem www-data-Benutzer zuweisen RUN chown -R www-data:www-data \ /var/www/html/storage \ /var/www/html/bootstrap/cache # Port 9000 freigeben und php-fpm-Server starten (für FastCGI Process Manager) EXPOSE 9000 CMD ["php-fpm"] |
Das Dockerfile erstellt zunächst ein Image basierend auf dem php:7.4-fpm Docker-Image. Dies ist ein Debian-basiertes Image mit installierter PHP FastCGI-Implementierung (PHP-FPM ). Damit Laravel ordnungsgemäß ausgeführt werden kann, sind andere PHP-Erweiterungen wie mcrypt, pdo_mysql, mbstring und imagick erforderlich, die das Skript installiert. Anschließend wird der composer PHP-Paketmanager installiert. Der Container verwendet ihn, um die PHP-Abhängigkeiten von Laravel zu installieren.
Sie können die RUN-Direktive verwenden, um Befehle wie Installieren, Aktualisieren und Konfigurieren von Einstellungen innerhalb des Containers zu definieren. Sie weist auch Benutzerberechtigungen zu. Die WORKDIR-Direktive gibt das Arbeitsverzeichnis an, in diesem Fall /var/www/html. Das Skript führt den CHOWN-Befehl aus, um die Berechtigungen für das Verzeichnis /var/www/html dem www-data-Benutzer zuzuweisen.
Bevor das Image endgültig erstellt wird, muss ein Port freigegeben werden, um den Zugriff auf die im Container ausgeführte Anwendung zu ermöglichen. Der EXPOSE-Befehl gibt einen Port, 9000, für den php-fpm-Server frei. Der letzte auszuführende Befehl ist die CMD-Direktive. Sie führt php-fpm aus, um den Server zu starten.
Sie können nun Strg + O drücken, um die Datei zu speichern. Drücken Sie dann Strg + X, um den Editor zu verlassen.
Schritt 5: PHP konfigurieren
In diesem Schritt konfigurieren wir den php-Dienst so, dass er eingehende Anfragen von Nginx verarbeitet. Sie erstellen eine laravel.ini-Datei im php-Verzeichnis. Diese Datei enthält die PHP-Konfigurationen. Dies ist die Datei, die Sie per Bind-Mount an /usr/local/etc/php/conf.d/laravel.ini im Container in Schritt 3 gemountet haben. Die Konfigurationen in dieser Datei überschreiben die standardmäßige php.ini-Datei, die normalerweise von PHP beim Start gelesen wird. Geben Sie den folgenden Befehl ein, um das php-Verzeichnis zu erstellen:
|
1 |
mkdir ~/laravel-web/php |
Erstellen und öffnen Sie die Datei laravel.ini im php-Verzeichnis, indem Sie den folgenden Befehl eingeben:
|
1 |
nano ~/laravel-web/php/laravel.ini |
Die standardmäßige php.ini-Datei hat ein Upload-Limit von 2M. Als Beispiel zeigen wir Ihnen, wie Sie PHP-Konfigurationen anpassen und festlegen, indem Sie den Wert des zulässigen Upload-Limits ändern, falls Sie größere Dateien hochladen möchten. Geben Sie die folgenden Codezeilen in die Datei ein:
|
1 2 |
upload_max_filesize=80M post_max_size=80M |
Dies legt das Upload-Limit fest, sodass Sie Dateien mit einer Gesamtgröße von maximal 80 MB hochladen können. Sie können weitere PHP-Konfigurationen in der Datei laravel.ini hinzufügen, um die Standard-PHP-Konfigurationen zu überschreiben. Speichern und schließen Sie nun die Datei.
Schritt 6: Nginx konfigurieren
In diesem Schritt konfigurieren wir Nginx so, dass es den zuvor definierten php-Dienst verwendet. Es wird PHP-FPM als FastCGI-Server verwenden, um dynamische Inhalte bereitzustellen. Ein FastCGI-Server ist eine Software, die es interaktiven Programmen ermöglicht, mit einem Webserver zu kommunizieren.
Wie wir in der docker-compose-Datei in Schritt 3 definiert haben, erstellen wir die Nginx-Konfigurationsdatei app.conf im Verzeichnis ~/laravel-web/nginx/conf.d/. Geben Sie zuerst den folgenden Befehl ein, um das Verzeichnis zu erstellen:
|
1 |
mkdir -p ~/laravel-web/nginx/conf.d |
Erstellen und öffnen Sie als Nächstes die Datei app.conf mit nano, indem Sie den folgenden Befehl eingeben:
|
1 |
nano ~/laravel-web/nginx/conf.d/app.conf |
Fügen Sie den folgenden Nginx-Konfigurationscode in die Datei ein:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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/html/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; } } |
Nginx liest Konfigurationsdateien, die als Server-Blöcke bezeichnet werden, um zu wissen, welches Verzeichnis einem Website-Besucher basierend auf der URL bereitgestellt werden soll. Um mehr zu erfahren, lesen Sie über das Einrichten von Server-Blöcken in unserem tutorial on installing Nginx on Ubuntu 18.04. Die definierten Direktiven dienen folgenden Zwecken:
- listen – Definiert den Port, an dem der Server auf eingehende Anfragen lauscht, was normalerweise Port 80 ist.
- error_log & access_log – Definiert die Dateien zum Schreiben von Anwendungsprotokollen.
- root – Definiert den Webroot-Pfad, also das Verzeichnis, das alle Anfragen bedient, die aus dem Internet an den Server gerichtet werden.
Im Location-Block für php gibt die Direktive fastcgi_pass an, dass der app-Dienst an einem TCP-Socket auf Port 9000 lauscht (der im Dockerfile definiert wurde). Dies weist den PHP-FPM-Server an, über das Netzwerk und nicht über einen Unix-Socket zu lauschen. Während ein Unix-Socket gegenüber einem TCP-Socket einen leichten Geschwindigkeitsvorteil haben kann, fehlt ihm ein Netzwerkprotokoll, wodurch der Netzwerk-Stack umgangen wird.
Ein Unix-Socket wäre besser geeignet für Szenarien, in denen sich die Hosts auf derselben Maschine befinden. Wenn Sie jedoch Dienste auf verschiedenen Hosts ausführen, bietet ein TCP-Socket den Vorteil, verteilte Dienste miteinander zu verbinden. In unserem Fall läuft der App-Container auf einem anderen Host als unser Webserver-Container. Daher ist ein TCP-Socket für unsere Konfiguration am besten geeignet.
Sie können nun Strg + O drücken, um die Datei zu speichern, und dann Strg + X, um den Editor zu verlassen. Die im Verzeichnis nginx/conf.d/ vorgenommenen Änderungen werden dank des Bind-Mounts, den Sie in der Docker-Compose-Datei in Schritt 3.
Schritt 7: MySQL konfigurieren
Nachdem wir Nginx für die Zusammenarbeit mit PHP konfiguriert haben, können wir nun MySQL so konfigurieren, dass es dynamische Daten für PHP speichert und bereitstellt. Wir hatten die Docker-Compose-Datei bereits so eingestellt, dass die erforderlichen Erweiterungen für die PHP- und MySQL-Kommunikation installiert werden. Wir werden die MySQL-Konfigurationsdatei my.cnf im Ordner mysql erstellen, die an /etc/mysql/my.cnf gemountet wird (Bind-Mount), wie wir es im db-Dienstabschnitt von Docker Compose in Schritt 3.
Die MySQL-Konfigurationseinstellungen und -Änderungen können jederzeit in der Datei my.cnf vorgenommen werden. Sie sollten sofort im Container wirksam werden. Erstellen Sie zunächst das Verzeichnis, indem Sie den folgenden Befehl eingeben:
|
1 |
mkdir ~/laravel-web/mysql |
Erstellen und öffnen Sie als Nächstes nano, indem Sie den folgenden Befehl eingeben:
|
1 |
nano ~/laravel-web/mysql/my.cnf |
Geben Sie das folgende Code-Snippet ein, um das Abfrage-Protokoll zu aktivieren und den Speicherort der Protokolldatei anzugeben:
|
1 2 3 |
[mysqld] general_log = 1 general_log_file = /var/lib/mysql/general.log |
Indem Sie die Eigenschaft general_log auf 1 setzen, erlauben Sie allgemeine Protokolle. Die Eigenschaft general_log_file gibt den Speicherort der Protokolldatei an. Drücken Sie Strg + O, um die Datei zu speichern, und dann Strg + X, um den Editor zu verlassen.
Schritt 8: Laravel-Umgebungsvariablen festlegen
Bis zu diesem Punkt sind alle Dienste und Konfigurationseinstellungen abgeschlossen. Wir könnten also in der Lage sein, unsere Container bereitzustellen. Es gibt jedoch einen wichtigen Schritt, der erledigt werden muss, bevor unsere Webanwendung tatsächlich nutzbar ist – Umgebungsvariablen. Das Laravel-Framework erwartet eine Datei namens .env, mit der es seine Umgebung definiert. Standardmäßig wird Laravel mit der Datei .env.example ausgeliefert, die Sie nach .env kopieren und dann die Variablen mit Ihren tatsächlichen Daten anpassen können. Geben Sie den folgenden Befehl ein, um die Datei zu kopieren:
|
1 |
cp .env.example .env |
Sobald sie kopiert ist, öffnen Sie die Datei mit nano, um sie zu bearbeiten:
|
1 |
nano .env |
Hier ist ein Screenshot, wie die Datei aussehen könnte:
Der nächste Schritt in der Datei besteht darin, die Variablen unter dem Block DB_CONNECTION so zu ändern, wie Sie es in den bisherigen Konfigurationen festgelegt haben. Aktualisieren Sie wie folgt:
- DB_HOST ist der db Datenbankcontainer.
- DB_DATABASE ist die laravel_web.
- DB_USERNAME ist der Benutzername für die Datenbank. Wählen Sie einen Namen Ihrer Wahl, aber für dieses Tutorial nehmen wir laraveldocker.
- DB_PASSWORD ist ein starkes Passwort, das Ihr oben genannter Benutzer für die Anmeldung an der Datenbank verwenden wird, wählen Sie also ein starkes Passwort. In Schritt 10, werden wir diesen Benutzer mit dem von Ihnen hier gewählten Passwort erstellen.
Mit den aktualisierten Werten sollte Ihre DB_CONNECTION nun so aussehen:
Speichern und schließen Sie die Datei.
Schritt 9: Starten der Docker-Container
In dieser Phase sind alle Ihre Dienste und Konfigurationen in der Docker-Compose-Datei definiert. Es ist nur ein einziger Befehl erforderlich, um alle Container zu starten, die Volumes zu erstellen, die Netzwerke zu verbinden sowie Ihre Anwendung einzurichten und zu erstellen. Geben Sie den folgenden Befehl in Ihr Terminal ein:
|
1 |
docker-compose up -d |
Wenn Sie den Befehl docker-compose up zum ersten Mal ausführen, werden alle erforderlichen Docker-Images heruntergeladen. Wenn Sie die Infrastruktur auf Ihrem lokalen Computer einrichten, kann dies einige Zeit in Anspruch nehmen. Sobald die Images heruntergeladen wurden, erstellt Compose die Container. Das Flag -d weist Docker an, die Container im Hintergrund auszuführen. Wenn der Prozess erfolgreich abgeschlossen wird, sollten Sie in Ihrem Terminal etwas Ähnliches wie das hier sehen:
Geben Sie den folgenden Befehl in Ihrem Terminal ein, um alle laufenden Container aufzulisten:
|
1 |
docker ps |
Es sollte etwas Ähnliches wie der folgende Screenshot angezeigt werden, mit Details zu den Containern app, webserver und db:
- CONTAINER ID – Eine eindeutige Kennung für jeden Container.
- NAMES – Der jedem Container zugeordnete Dienstname, wie in der Docker Compose-Datei definiert. (Sie können entweder die Container-ID oder den Namen verwenden, um auf einen Container zuzugreifen).
- IMAGE – Der Image-Name für jeden Container.
- STATUS – Es zeigt Informationen über den Zustand des Containers an (er kann gestoppt sein, laufen oder neu starten).
- PORTS – Es zeigt die Ports an, die ein Container freigibt.
Docker Compose bietet einen Befehl namens exec, mit dem Sie Terminalbefehle ausführen oder auf die Befehlszeile innerhalb eines Containers zugreifen können. Wir möchten zuerst einige Befehle im app-Container ausführen, bei dem es sich um den Container handelt, auf dem die Laravel-App läuft.
Docker bietet einen Befehl für den Zugriff auf die Befehlszeile eines Containers. Seine Syntax lautet wie folgt: docker-compose exec container_name bash. Um auf die Befehlszeile des app-Containers zuzugreifen, geben Sie den folgenden Befehl ein:
|
1 |
docker-compose exec app bash |
Sobald Sie sich auf der Befehlszeile des Containers befinden, können Sie einige Laravel-Artisan-Konfigurationsbefehle ausführen. Geben Sie den folgenden Befehl ein, um den Laravel-Schlüssel zu generieren und in der .env-Datei zu speichern:
|
1 |
php artisan key:generate |
Sobald der Umgebungsschlüssel festgelegt ist, können Sie den folgenden Befehl ausführen, um die Konfigurationseinstellungen im Cache zu speichern:
|
1 |
php artisan config:cache |
Die Konfigurationen werden in der Datei /var/www/html/bootstrap/cache/config.php im Container gespeichert. Sie können Strg + D drücken, um das Container-Terminal zu verlassen.
Um zu bestätigen, dass die Laravel-App bereitgestellt wurde und läuft, rufen Sie die öffentliche IP Ihres Servers in Ihrem Browser auf (http://your_server_public_ip). Sie sollten die Willkommensseite für eine neue Laravel-Installation sehen:
Step 10: Configure a MySQL user
In diesem Schritt erstellen wir einen Datenbankbenutzer für die MySQL-Datenbank laravel_web, die wir in der docker-compose-Datei angegeben haben. Als Sie den Befehl zum Erstellen des Containers in Step 9 ausgeführt haben, wurde MySQL installiert, aber es wurde nur ein standardmäßiges Root-Administratorkonto erstellt, das unbegrenzte Rechte für die Datenbank besitzt. Um die Verwendung des Root-Benutzers zu vermeiden, erstellen wir einen dedizierten Benutzer, laraveldocker, der für die Anwendung verwendet wird. Dies ist der Benutzer, den Sie in den Umgebungsvariablen in Step 8 angegeben haben. Greifen Sie auf die Befehlszeile im Terminal zu, indem Sie den folgenden Befehl eingeben:
|
1 |
docker-compose exec db bash |
Sobald Sie sich im Container befinden, melden Sie sich bei MySQL an, indem Sie den folgenden Befehl eingeben:
|
1 |
mysql -u root -p |
Geben Sie bei der Aufforderung zur Passworteingabe das Passwort ein, das Sie im db-Dienst in der docker-compose-Datei in Step 2.
angegeben haben. Sobald Sie sich in der MySQL-Eingabeaufforderung angemeldet haben, überprüfen Sie, ob Sie die in der docker-compose-Datei angegebene Datenbank sehen können, indem Sie den folgenden SQL-Befehl eingeben:
|
1 |
show databases; |
Sie sollten die Datenbank laravel_web sehen, oder welchen Namen auch immer Sie für Ihr Setup angegeben haben:
Als Nächstes erstellen wir einen Benutzer und ein Passwort für die Datenbank laravel_web. Dies müssen dieselben Details sein, die Sie in der .env-Datei in Step 8 angegeben haben. Geben Sie den folgenden Befehl ein, um Benutzer und Passwort zu erstellen und diesem Benutzer alle Berechtigungen zu erteilen:
|
1 |
GRANT ALL ON laravel_web.* TO 'laraveldocker'@'%' IDENTIFIED BY 'your_strong_laravel_docker_password'; |
Damit die Änderungen sofort wirksam werden, geben Sie den folgenden Befehl ein, um die Berechtigungen neu zu laden:
|
1 |
FLUSH PRIVILEGES; |
Damit ist die MySQL-Benutzerkonfiguration abgeschlossen. Beenden Sie die MySQL-Eingabeaufforderung, indem Sie exit eingeben und die Eingabetaste drücken. Beenden Sie schließlich den db-Container, indem Sie Strg + D drücken.
Schritt 11: Testen der Kommunikation zwischen dem Laravel-Anwendungscode und der MySQL-Datenbank
Bis zu diesem Schritt hat alles gut funktioniert. Wir möchten jedoch bestätigen, dass der Laravel-Code im app-Container mit der MySQL-Datenbank im db-Container kommunizieren kann. Greifen Sie zunächst auf das Terminal des app-Containers zu, indem Sie den folgenden Befehl eingeben:
|
1 |
docker-compose exec app bash |
Als Nächstes führen Sie den Befehl Laravel-Migration aus, der die Tabellen erstellt:
|
1 |
php artisan migrate |
Sie sollten den Migrationsprozess in Ihrem Terminal sehen, während Laravel die Standardtabellen erstellt:
Als Nächstes testen wir, ob wir von Laravel aus auf die Datenbank zugreifen können. Laravel wird standardmäßig mit Tinker ausgeliefert, mit dem Sie über die Befehlszeile mit der gesamten Anwendung interagieren können, einschließlich des Zugriffs auf die Datenbank, des Ausführens von Jobs, Eloquent ORM und mehr. Wir können Tinker verwenden, um die Daten in der migrations-Tabelle anzuzeigen. Geben Sie den folgenden Befehl ein, um auf Tinker zuzugreifen:
|
1 |
php artisan tinker |
Sobald Sie sich in der Tinker-Eingabeaufforderung befinden, können Sie die durch den migrate-Befehl erstellten Tabellen auflisten, indem Sie Folgendes eingeben:
|
1 |
\DB::select('show tables'); |
Der folgende Screenshot zeigt die Ausgabe, bei der es sich um Tabellen handelt, die sich derzeit in der laravel_web-Datenbank befinden:
Sie können die Daten in einer Tabelle abrufen, indem Sie den Tabellennamen angeben. Beispielsweise können Sie die Daten in der migrations-Tabelle abrufen, indem Sie den folgenden Befehl eingeben:
|
1 |
\DB::table('migrations')->get(); |
Der Befehl gibt Folgendes aus:
Aus der obigen Ausgabe geht hervor, dass Ihre Laravel-Anwendung gut konfiguriert ist und mit der Datenbank kommunizieren kann. Sie können mit weiteren Befehlen experimentieren, wie dem Erstellen von Modellen, dem Ausführen von Jobs und mehr. Sie können die Tinker-Eingabeaufforderung beenden, indem Sie Strg + D drücken.
Fazit
In diesem Tutorial haben Sie eine Laravel-Anwendung mit LEMP-Stack in einem Docker-Container bereitgestellt. Sie haben die Anwendung getestet, indem Sie auf die Weboberfläche zugegriffen und über Laravel Tinker eine Verbindung zur Datenbank hergestellt haben. Sie konnten die Leistungsfähigkeit von Docker Compose erleben. Es ermöglicht Ihnen, eine Gruppe von Docker-Containern zu erstellen, die in einer einzigen Datei definiert sind und dann mit nur einem einzigen Befehl ausgeführt werden können.
Wenn Sie sich weiter mit Containern vertraut machen möchten, werfen Sie einen Blick auf unser Tutorial, das Ihnen zeigt, wie Sie Docker-Ressourcen – Images, Container und Volumes – bereinigen und unsere detaillierte Übersicht über das Kubernetes-Tool.
Sie können auch unseren Blog besuchen, um mehr über Docker und Continuous Integration und Continuous Deployment.
Viel Spaß beim Computing!
Kommentare
Noch keine Kommentare. Schreiben Sie den ersten.