TOC

So installieren Sie WordPress mit Docker Compose

Einführung

WordPress ist ein kostenloses und quelloffenes Content Management System (CMS) basiert auf einer MySQL -Datenbank mit PHP -Verarbeitung. Dank der erweiterbaren Plugin-Architektur und des Templating-Systems sowie der Tatsache, dass der Großteil der Verwaltung über die Weboberfläche erfolgen kann, ist WordPress eine beliebte Wahl beim Erstellen verschiedener Arten von Websites, von Blogs über Produktseiten bis hin zu E-Commerce-Websites.

Zum Ausführen von WordPress muss normalerweise eine LAMP (Linux, Apache, MySQL und PHP) oder https://www.digitalocean.com installiert werden / community / tutorials / digitalocean-community-glossary # lemp [LEMP] (Linux, Nginx, MySQL und PHP), was zeitaufwändig sein kann. Mithilfe von Tools wie Docker und Docker Compose können Sie jedoch die Einrichtung Ihres bevorzugten Stacks und die Installation vereinfachen WordPress. Anstatt einzelne Komponenten manuell zu installieren, können Sie images verwenden, mit denen beispielsweise Bibliotheken, Konfigurationsdateien und Umgebungsvariablen standardisiert werden, und diese Images in containern ausführen, isolierten Prozessen, die auf einem gemeinsam genutzten Betriebssystem ausgeführt werden. Darüber hinaus können Sie mithilfe von Compose mehrere Container (z. B. eine Anwendung und eine Datenbank) koordinieren, um miteinander zu kommunizieren.

In diesem Tutorial erstellen Sie eine WordPress-Installation mit mehreren Containern. Ihre Container enthalten eine MySQL-Datenbank, einen Nginx-Webserver und WordPress selbst. Sie sichern Ihre Installation auch, indem Sie TLS / SSL-Zertifikate mit Let’s Encrypt für die Domain erhalten, die Sie Ihrer Site zuordnen möchten. Schließlich richten Sie eine https://www.digitalocean.com/community/tutorials/how-to-schedule-routine-tasks-with-cron-and-anacron-on-a-vps ein [+ cron +] Job, um Ihre Zertifikate zu erneuern, damit Ihre Domain sicher bleibt.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

  • Ein Server, auf dem Ubuntu 18.04 ausgeführt wird, zusammen mit einem Nicht-Root-Benutzer mit "+ sudo +" - Berechtigungen und einer aktiven Firewall. Anleitungen zum Einrichten finden Sie in dieser Initial Server Setup-Anleitung.

  • Docker wird auf Ihrem Server installiert. Befolgen Sie dazu die Schritte 1 und 2 unter How To Install and Verwenden Sie Docker unter Ubuntu 18.04.

  • Docker Compose wird auf Ihrem Server installiert. Befolgen Sie hierzu Schritt 1 von Installation von Docker Compose unter Ubuntu 18.04.

  • Ein registrierter Domainname. In diesem Tutorial wird durchgehend * example.com * verwendet. Sie können eine kostenlose Version unter Freenom herunterladen oder den Domain-Registrar Ihrer Wahl verwenden.

  • Die beiden folgenden DNS-Einträge wurden für Ihren Server eingerichtet. Unter https://www.digitalocean.com/community/tutorials/an-einführung-zu-digitalocean-dns finden Sie Informationen zum Hinzufügen zu einem DigitalOcean-Konto. wiederverwenden:

  • Ein A-Datensatz mit "++", der auf die öffentliche IP-Adresse Ihres Servers verweist.

  • Ein A-Eintrag mit "+ www. +" Verweist auf die öffentliche IP-Adresse Ihres Servers.

Schritt 1 - Definieren der Webserverkonfiguration

Bevor wir Container ausführen, müssen wir zunächst die Konfiguration für unseren Nginx-Webserver definieren. Unsere Konfigurationsdatei enthält einige WordPress-spezifische Speicherortblöcke sowie einen Speicherortblock, mit dem Let’s Encrypt-Überprüfungsanforderungen an den Certbot-Client zur automatischen Erneuerung von Zertifikaten weitergeleitet werden.

Erstellen Sie zunächst ein Projektverzeichnis für Ihr WordPress-Setup mit dem Namen "++" und navigieren Sie dorthin:

mkdir  && cd

Als nächstes legen Sie ein Verzeichnis für die Konfigurationsdatei an:

mkdir nginx-conf

Öffne die Datei mit + nano + oder deinem Lieblingseditor:

nano nginx-conf/nginx.conf

In dieser Datei fügen wir einen Serverblock mit Anweisungen für den Servernamen und den Dokumentenstamm sowie Standortblöcke hinzu, um die Anforderung des Certbot-Clients nach Zertifikaten, PHP-Verarbeitung und statischen Ressourcenanforderungen weiterzuleiten.

Fügen Sie den folgenden Code in die Datei ein. Achten Sie darauf, "++" durch Ihren eigenen Domainnamen zu ersetzen:

~ / wordpress / nginx-conf / nginx.conf

server {
       listen 80;
       listen [::]:80;

       server_name  www.;

       index  index.html index.htm;

       root /var/www/html;

       location ~ /.well-known/acme-challenge {
               allow all;
               root /var/www/html;
       }

       location / {
               try_files $uri $uri/ /index.php$is_args$args;
       }

       location ~ \.php$ {
               try_files $uri =404;
               fastcgi_split_path_info ^(.+\.php)(/.+)$;
               fastcgi_pass :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 ~ /\.ht {
               deny all;
       }

       location = /favicon.ico {
               log_not_found off; access_log off;
       }
       location = /robots.txt {
               log_not_found off; access_log off; allow all;
       }
       location ~* \.(css|gif|ico|jpeg|jpg|js|png)$ {
               expires max;
               log_not_found off;
       }
}

Unser Serverblock enthält folgende Informationen:

  • Richtlinien: *

  • + listen +: Dies weist Nginx an, den Port + 80 + abzuhören, wodurch wir das webroot plugin von Certbot für unsere Zertifikatsanforderungen verwenden können . Beachten Sie, dass wir den Port + 443 + noch nicht _einschließen - wir aktualisieren unsere Konfiguration, um SSL einzuschließen, sobald wir unsere Zertifikate erfolgreich erhalten haben.

  • + Servername +: Definiert Ihren Servernamen und den Serverblock, der für Anfragen an Ihren Server verwendet werden soll. Stellen Sie sicher, dass in dieser Zeile "++" durch Ihren eigenen Domainnamen ersetzt wird.

  • + index +: Die Anweisung + index + definiert die Dateien, die bei der Verarbeitung von Anfragen an Ihren Server als Indizes verwendet werden. Wir haben hier die Standardreihenfolge der Prioritäten geändert, indem wir "+ index.php " vor " index.html " verschoben haben, damit Nginx nach Möglichkeit Dateien mit der Bezeichnung " index.php +" priorisiert.

  • + root +: Unsere Direktive + root + benennt das Stammverzeichnis für Anfragen an unseren Server. Dieses Verzeichnis, + / var / www / html +, ist created as a mount point Zum Zeitpunkt der Erstellung gemäß den Anweisungen in unserer WordPress Dockerfile. Diese Dockerfile-Anweisungen stellen auch sicher, dass die Dateien aus der WordPress-Version auf diesem Volume bereitgestellt werden.

  • Location Blocks: *

  • + location ~ / .well-known / acme-challenge +: Dieser Location-Block behandelt Anfragen an das Verzeichnis + .well-known +, in dem Certbot eine temporäre Datei ablegt, um zu überprüfen, ob das DNS für unsere Domain in unser aufgelöst wird Server. Mit dieser Konfiguration können wir das Webroot-Plugin von Certbot verwenden, um Zertifikate für unsere Domain zu erhalten.

  • + location / +: In diesem Location-Block verwenden wir die Direktive + try_files +, um nach Dateien zu suchen, die mit einzelnen URI-Anforderungen übereinstimmen. Anstatt standardmäßig den Status 404 "+ Nicht gefunden " zurückzugeben, übergeben wir die Steuerung mit den Anforderungsargumenten an die Datei " index.php +" von WordPress.

  • + location ~ \ .php $ +: Dieser Location Block verarbeitet PHP und überträgt diese Anfragen an unseren + wordpress + Container. Da unser WordPress Docker-Image auf dem https://github.com/docker-library/php/blob/e63194a0006848edb13b7eff5a7f9d790d679428/7.2/alpine3.9/fpm/Dockerfile [+ php: fpm + image] basiert, werden wir es auch tun Fügen Sie Konfigurationsoptionen für das Protokoll FastCGI in diesen Block ein. Nginx benötigt einen unabhängigen PHP-Prozessor für PHP-Anfragen: In unserem Fall werden diese Anfragen vom "+ php-fpm " - Prozessor verarbeitet, der im " php: fpm " - Image enthalten ist. Darüber hinaus enthält dieser Speicherortblock FastCGI-spezifische Anweisungen, Variablen und Optionen, die Anforderungen an die WordPress-Anwendung weiterleiten, die in unserem Container " wordpress +" ausgeführt wird, den bevorzugten Index für den analysierten Anforderungs-URI festlegen und URI-Anforderungen analysieren.

  • + location ~ / \. ht +: Dieser Block behandelt + .htaccess + Dateien, da Nginx sie nicht bereitstellt. Die Direktive "+ deny_all " stellt sicher, dass " .htaccess +" - Dateien niemals an Benutzer geliefert werden.

  • + location = / favicon.ico,` + location = / robots.txt + : Diese Blöcke stellen sicher, dass Anforderungen an + / favicon.ico` und + / robots.txt + nicht protokolliert werden.

  • + location ~ * \. (css | gif | ico | jpeg | jpg | js | png) $ +: Dieser Block deaktiviert die Protokollierung für statische Asset-Anforderungen und stellt sicher, dass diese Assets in hohem Maße zwischengespeichert werden können, da sie normalerweise teuer sind Dienen.

Weitere Informationen zum FastCGI-Proxying finden Sie unter Understanding and Implementing FastCGI Proxying in Nginx. Informationen zu Server- und Standortblöcken finden Sie unter Understanding Nginx Server and Location Block Selection Algorithms.

Speichern und schließen Sie die Datei, wenn Sie mit der Bearbeitung fertig sind. Wenn Sie "+ nano " verwendet haben, drücken Sie " STRG + X ", " Y " und dann " ENTER +".

Mit Ihrer Nginx-Konfiguration können Sie Umgebungsvariablen erstellen, die zur Laufzeit an Ihre Anwendungs- und Datenbankcontainer übergeben werden.

Schritt 2 - Definieren von Umgebungsvariablen

Ihre Datenbank- und WordPress-Anwendungscontainer benötigen zur Laufzeit Zugriff auf bestimmte Umgebungsvariablen, damit Ihre Anwendungsdaten erhalten bleiben und für Ihre Anwendung zugänglich sind. Diese Variablen enthalten vertrauliche und nicht vertrauliche Informationen: vertrauliche Werte für Ihr MySQL * root * -Kennwort und den Benutzer und das Kennwort der Anwendungsdatenbank sowie nicht vertrauliche Informationen für den Namen und den Host Ihrer Anwendungsdatenbank.

Anstatt alle diese Werte in unserer Docker Compose-Datei festzulegen - der Hauptdatei, die Informationen zur Ausführung unserer Container enthält - können wir die vertraulichen Werte in einer + .env + -Datei festlegen und deren Verbreitung einschränken. Auf diese Weise wird verhindert, dass diese Werte in unsere Projektverzeichnisse kopiert und öffentlich zugänglich gemacht werden.

Öffnen Sie in Ihrem Hauptprojektverzeichnis "+ ~ / " eine Datei mit dem Namen " .env +":

nano .env

Zu den vertraulichen Werten, die wir in dieser Datei festlegen, gehören ein Kennwort für unseren MySQL * root * -Benutzer sowie ein Benutzername und ein Kennwort, mit denen WordPress auf die Datenbank zugreift.

Fügen Sie der Datei die folgenden Variablennamen und -werte hinzu. Denken Sie daran, für jede Variable * Ihre eigenen Werte * anzugeben:

~ / wordpress / .env

MYSQL_ROOT_PASSWORD=
MYSQL_USER=
MYSQL_PASSWORD=

Wir haben ein Kennwort für das Administratorkonto * root * sowie unseren bevorzugten Benutzernamen und das Kennwort für unsere Anwendungsdatenbank angegeben.

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

Da Ihre "+ .env " - Datei vertrauliche Informationen enthält, sollten Sie sicherstellen, dass diese in den " .gitignore " - und " .dockerignore +" - Dateien Ihres Projekts enthalten sind, die auf https://www.digitalocean.com/community verweisen / tutorials / how-to-use-git-a-reference-guide [Git] und Docker, welche Dateien * nicht * in Ihre Git-Repositorys bzw. Docker-Images kopiert werden sollen.

Wenn Sie mit Git zur Versionskontrolle arbeiten möchten, können Sie unter https://www.digitalocean.com/community/tutorials/how-to-use-git-a-reference-guide#set-up-and-initialization Ihre aktuelle Version initialisieren Arbeitsverzeichnis als Repository] mit + git init +:

git init

Dann öffne eine + .gitignore + Datei:

nano .gitignore

Fügen Sie der Datei + .env + hinzu:

~ / wordpress / .gitignore

.env

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

Ebenso ist es eine gute Vorsichtsmaßnahme, einer "+ .dockerignore " - Datei " .env +" hinzuzufügen, damit sie nicht in Ihren Containern landet, wenn Sie dieses Verzeichnis als Erstellungskontext verwenden.

Öffne die Datei:

nano .dockerignore

Fügen Sie der Datei + .env + hinzu:

~ / wordpress / .dockerignore

.env

Darunter können Sie optional Dateien und Verzeichnisse hinzufügen, die mit der Entwicklung Ihrer Anwendung verknüpft sind:

~ / wordpress / .dockerignore

.env
.git
docker-compose.yml
.dockerignore

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

Mit Ihren vertraulichen Informationen können Sie nun Ihre Dienste in einer "+ docker-compose.yml" -Datei definieren.

Schritt 3 - Definieren von Diensten mit Docker Compose

Ihre + docker-compose.yml + Datei enthält die Service-Definitionen für Ihr Setup. Ein service in Compose ist ein ausgeführter Container, und Servicedefinitionen geben Informationen darüber an, wie jeder Container ausgeführt wird.

Mit Compose können Sie verschiedene Dienste definieren, um Anwendungen mit mehreren Containern auszuführen, da Sie mit Compose diese Dienste mit gemeinsam genutzten Netzwerken und Volumes verknüpfen können. Dies ist hilfreich für unser aktuelles Setup, da wir verschiedene Container für unsere Datenbank, WordPress-Anwendung und unseren Webserver erstellen. Wir werden auch einen Container erstellen, in dem der Certbot-Client ausgeführt wird, um Zertifikate für unseren Webserver zu erhalten.

Öffnen Sie zunächst die Datei + docker-compose.yml +:

nano docker-compose.yml

Fügen Sie den folgenden Code hinzu, um Ihre Compose-Dateiversion und den Datenbankdienst + db + zu definieren:

~ / wordpress / docker-compose.yml

version: '3'

services:
 db:
   image: mysql:
   container_name: db
   restart: unless-stopped
   env_file: .env
   environment:
     - MYSQL_DATABASE=
   volumes:
     - dbdata:/var/lib/mysql
   command: '--default-authentication-plugin=mysql_native_password'
   networks:
     - app-network

Die Service-Definition "+ db +" enthält die folgenden Optionen:

  • + image +: Hiermit wird festgelegt, welches Bild zum Erstellen des Containers gezogen werden soll. Wir fixieren die https://github.com/docker-library/mysql/blob/130bd8e46a3da1adfc1732a08c70673e20aa5977/8.0/Dockerfile [+ mysql: + image] hier, um zukünftige Konflikte zu vermeiden, da das + mysql: latest + image weiterhin besteht bleibe auf dem Laufenden. Weitere Informationen zum Fixieren von Versionen und zum Vermeiden von Abhängigkeitskonflikten finden Sie in der Docker-Dokumentation unter Dockerfile Best Practices.

  • + container_name +: Gibt einen Namen für den Container an.

  • + restart +: Definiert die Container-Neustartrichtlinie. Die Standardeinstellung ist "+ no +", aber wir haben den Container so eingestellt, dass er neu gestartet wird, sofern er nicht manuell gestoppt wird.

  • + env_file +: Diese Option teilt Compose mit, dass wir Umgebungsvariablen aus einer Datei mit dem Namen + .env + in unserem Build-Kontext hinzufügen möchten. In diesem Fall ist der Build-Kontext unser aktuelles Verzeichnis.

  • + environment +: Mit dieser Option können Sie zusätzliche Umgebungsvariablen hinzufügen, die über die in Ihrer + .env + - Datei definierten hinausgehen. Wir setzen die Variable "+ MYSQL_DATABASE " gleich "+", um einen Namen für unsere Anwendungsdatenbank bereitzustellen. Da dies nicht vertrauliche Informationen sind, können wir sie direkt in die Datei + docker-compose.yml + aufnehmen.

  • + volume +: Hier mounten wir ein benanntes volume mit dem Namen + dbdata + in das Verzeichnis + / var / lib / mysql + des Containers . Dies ist das Standarddatenverzeichnis für MySQL auf den meisten Distributionen.

  • + command +: Diese Option gibt einen Befehl zum Überschreiben der Standardanweisung CMD für das Image an. In unserem Fall werden wir eine Option zum Standard-https://dev.mysql.com/doc/refman/8.0/en/mysqld.html [+ mysqld + - Befehl] des Docker-Images hinzufügen, mit der der MySQL-Server auf dem gestartet wird Container. Diese Option, "+ - default-authentication-plugin = mysql_native_password ", setzt die Systemvariable " - default-authentication-plugin " auf " mysql_native_password +" und gibt an, welcher Authentifizierungsmechanismus neue Authentifizierungsanforderungen an den Server regeln soll. Da PHP und damit unser WordPress-Image won’t support https://mysqlserverteam.com/upgrade-to-mysql-8-0-default- Überlegungen zu Authentifizierungs-Plugins / [MySQLs neuerer Authentifizierungsstandard], müssen wir diese Anpassung vornehmen, um den Benutzer unserer Anwendungsdatenbank zu authentifizieren.

  • + network +: Dies gibt an, dass Ihr Anwendungsdienst dem Netzwerk + app-network + beitritt, das wir unten in der Datei definieren.

Fügen Sie als nächstes unter Ihrer + db + Service-Definition die Definition für Ihren + wordpress + Application-Service hinzu:

~ / wordpress / docker-compose.yml

...
 wordpress:
   depends_on:
     - db
   image: wordpress:-fpm-alpine
   container_name: wordpress
   restart: unless-stopped
   env_file: .env
   environment:
     - WORDPRESS_DB_HOST=db:3306
     - WORDPRESS_DB_USER=$MYSQL_USER
     - WORDPRESS_DB_PASSWORD=$MYSQL_PASSWORD
     - WORDPRESS_DB_NAME=
   volumes:
     - wordpress:/var/www/html
   networks:
     - app-network

In dieser Service-Definition benennen wir unseren Container und definieren eine Neustart-Richtlinie, wie wir es mit dem Service "+ db +" getan haben. Wir fügen auch einige Optionen hinzu, die für diesen Container spezifisch sind:

  • + depend_on +: Diese Option stellt sicher, dass unsere Container in der Reihenfolge ihrer Abhängigkeit gestartet werden, wobei der Container + wordpress + nach dem Container + db + beginnt. Unsere WordPress-Anwendung ist von der Existenz unserer Anwendungsdatenbank und des Benutzers abhängig. Wenn Sie also diese Abhängigkeitsreihenfolge ausdrücken, kann unsere Anwendung ordnungsgemäß gestartet werden.

  • + image +: Für dieses Setup verwenden wir das https://github.com/docker-library/wordpress/blob/07958d19ed465fb7fe50626be740d88a2c2260a7/php7.2/fpm-alpine/Dockerfile [+ -fpm-alpine + WordPress-Bild ]. Wie in https://www.digitalocean.com/community/tutorials/how-to-install-wordpress-with-docker-compose#step-1-%E2%80%94-defining-the-web-server- beschrieben Konfiguration [Schritt 1]: Wenn Sie dieses Bild verwenden, wird sichergestellt, dass unsere Anwendung über den "+ php-fpm " - Prozessor verfügt, den Nginx für die PHP-Verarbeitung benötigt. Dies ist auch ein " alpine " - Image, das aus dem https://alpinelinux.org/[Alpine Linux project] stammt und dazu beiträgt, die Gesamtgröße des Images niedrig zu halten. Weitere Informationen zu den Vor- und Nachteilen der Verwendung von " alpine +" - Bildern und dazu, ob dies für Ihre Anwendung sinnvoll ist oder nicht, finden Sie in der ausführlichen Diskussion im Abschnitt "* Image Variants *" unter https://hub.docker.com/_. / wordpress [Docker Hub WordPress-Bildseite].

  • + env_file +: Auch hier geben wir an, dass wir Werte aus unserer + .env + - Datei ziehen möchten, da wir hier den Benutzer und das Kennwort für die Anwendungsdatenbank definiert haben.

  • "+ environment ": Hier verwenden wir die in unserer " .env " - Datei definierten Werte, weisen sie jedoch den Variablennamen zu, die das WordPress-Bild erwartet: " WORDPRESS_DB_USER " und " WORDPRESS_DB_PASSWORD ". Wir definieren auch ein " WORDPRESS_DB_HOST ", das der MySQL-Server ist, der auf dem " db " -Container läuft, auf den über MySQLs Standardport " 3306 " zugegriffen werden kann. Unser ` WORDPRESS_DB_NAME ` entspricht dem Wert, den wir in der MySQL-Service-Definition für unser ` MYSQL_DATABASE `: `+` angegeben haben.

  • + volume +: Wir mounten ein benanntes Volume namens + wordpress + an den Mountpoint https://github.com/docker-library/wordpress/blob/07958d19ed465fb7fe50626be740d88a2c2260a7/php7.2/ fpm-alpine / Dockerfile # L53 [erstellt mit dem WordPress-Image]. Wenn Sie auf diese Weise ein benanntes Volume verwenden, können Sie unseren Anwendungscode für andere Container freigeben.

  • + network +: Fügte auch den Container + wordpress zum Netzwerk` + app-network + `hinzu.

Fügen Sie als Nächstes unter der Anwendungsdienstdefinition "+ wordpress " die folgende Definition für Ihren " webserver +" - Nginx-Dienst hinzu:

~ / wordpress / docker-compose.yml

...
 webserver:
   depends_on:
     - wordpress
   image: nginx:-alpine
   container_name: webserver
   restart: unless-stopped
   ports:
     - "80:80"
   volumes:
     - wordpress:/var/www/html
     - ./nginx-conf:/etc/nginx/conf.d
     - certbot-etc:/etc/letsencrypt
   networks:
     - app-network

Auch hier benennen wir unseren Container und machen ihn in der Startreihenfolge vom "+ wordpress " - Container abhängig. Wir verwenden auch ein " alpines " Bild - das https://github.com/nginxinc/docker-nginx/blob/e5123eea0d29c8d13df17d782f15679458ff899e/mainline/stretch/Dockerfile [" -alpine +" Nginx-Bild].

Diese Service-Definition enthält auch die folgenden Optionen:

  • + ports +: Dies macht den Port + 80 + verfügbar, um die Konfigurationsoptionen zu aktivieren, die wir in der Datei + nginx.conf + in Link: [Schritt 1] definiert haben.

  • + Datenträger +: Hier definieren wir eine Kombination aus benannten Datenträgern und bind mounts:

  • + wordpress: / var / www / html +: Damit wird unser WordPress-Anwendungscode in das Verzeichnis + / var / www / html + geladen, das wir in unserem Nginx-Serverblock als + root + festgelegt haben.

  • +. / nginx-conf: / etc / nginx / conf.d +: Dies bindet das Nginx-Konfigurationsverzeichnis auf dem Host an das entsprechende Verzeichnis auf dem Container und stellt sicher, dass alle Änderungen an Dateien auf dem Host wirksam werden spiegelt sich im Container.

  • + certbot-etc: / etc / letsencrypt +: Damit werden die relevanten Let’s Encrypt-Zertifikate und -Schlüssel für unsere Domain in das entsprechende Verzeichnis im Container geladen.

Und wieder haben wir diesen Container zum Netzwerk "+ app-network +" hinzugefügt.

Fügen Sie schließlich unter Ihrer "+ Webserver" -Definition Ihre letzte Service-Definition für den "+ Certbot" -Dienst hinzu. Stellen Sie sicher, dass Sie die hier aufgelisteten E-Mail-Adressen und Domainnamen durch Ihre eigenen Angaben ersetzen:

~ / wordpress / docker-compose.yml

 certbot:
   depends_on:
     - webserver
   image: certbot/certbot
   container_name: certbot
   volumes:
     - certbot-etc:/etc/letsencrypt
     - wordpress:/var/www/html
   command: certonly --webroot --webroot-path=/var/www/html --email  --agree-tos --no-eff-email --staging -d  -d www.

Diese Definition weist Compose an, das https://hub.docker.com/r/certbot/certbot/ [+ certbot / certbot + image] von Docker Hub abzurufen. Außerdem werden benannte Volumes verwendet, um Ressourcen für den Nginx-Container freizugeben, einschließlich der Domänenzertifikate und des Schlüssels für "+ certbot-etc " und des Anwendungscodes für " wordpress +".

Wieder haben wir "+ depend_on " verwendet, um anzugeben, dass der " certbot " - Container gestartet werden soll, sobald der " webserver +" - Dienst ausgeführt wird.

Wir haben auch die Option "+ command " hinzugefügt, die einen Unterbefehl angibt, der mit dem Standardbefehl " certbot " des Containers ausgeführt werden soll. Die https://certbot.eff.org/docs/using.html#certbot-command-line-options [` certonly +` subcommand] erhalten ein Zertifikat mit den folgenden Optionen:

  • + - webroot +: Hiermit wird Certbot angewiesen, das webroot-Plugin zu verwenden, um Dateien zur Authentifizierung im webroot-Ordner abzulegen. Dieses Plugin hängt von der HTTP-01-Überprüfungsmethode ab, die mithilfe einer HTTP-Anforderung nachweist, dass Certbot auf Ressourcen zugreifen kann von einem Server, der auf einen bestimmten Domainnamen reagiert.

  • + - webroot-path +: Gibt den Pfad des webroot-Verzeichnisses an.

  • + - email +: Ihre bevorzugte E-Mail-Adresse für die Registrierung und Wiederherstellung.

  • + - Zustimmungserklärung +: Hiermit stimmen Sie der ACME’s Subscriber Agreement zu.

  • + - no-eff-email +: Hiermit wird Certbot mitgeteilt, dass Sie Ihre E-Mail-Adresse nicht an die Electronic Frontier Foundation (EFF) weitergeben möchten. Fühlen Sie sich frei, dies wegzulassen, wenn Sie es vorziehen würden.

  • + - staging +: Hiermit wird Certbot mitgeteilt, dass Sie die Staging-Umgebung von Let’s Encrypt verwenden möchten, um Testzertifikate abzurufen. Mit dieser Option können Sie Ihre Konfigurationsoptionen testen und mögliche Beschränkungen für Domänenanforderungen vermeiden. Weitere Informationen zu diesen Grenzwerten finden Sie in der rate limits documentation von Let’s Encrypt.

  • + -d +: Hier können Sie Domainnamen angeben, die Sie auf Ihre Anfrage anwenden möchten. In diesem Fall haben wir "+" und " www. +" Eingefügt. Stellen Sie sicher, dass Sie diese durch Ihre eigene Domain ersetzen.

Fügen Sie unterhalb der Service-Definition "+ certbot +" Ihre Netzwerk- und Volume-Definitionen hinzu:

~ / wordpress / docker-compose.yml

...
volumes:
 certbot-etc:
 wordpress:
 dbdata:

networks:
 app-network:
   driver: bridge

Unser "+ volume " - Schlüssel auf oberster Ebene definiert die Volumes " certbot-etc ", " wordpress " und " dbdata ". Wenn Docker Volumes erstellt, wird der Inhalt des Volumes in einem Verzeichnis auf dem Host-Dateisystem gespeichert, ` / var / lib / docker / volume / +`, das von Docker verwaltet wird. Der Inhalt jedes Volumes wird dann aus diesem Verzeichnis in jeden Container geladen, der das Volume verwendet. Auf diese Weise können Code und Daten zwischen Containern ausgetauscht werden.

Das benutzerdefinierte Bridge-Netzwerk "+ app-network " ermöglicht die Kommunikation zwischen unseren Containern, da sie sich auf demselben Docker-Daemon-Host befinden. Dies rationalisiert den Verkehr und die Kommunikation innerhalb der Anwendung, da alle Ports zwischen Containern im selben Brückennetz geöffnet werden, ohne dass Ports der Außenwelt ausgesetzt werden. Somit können unsere Container " db", "+ wordpress" und "+ web server" miteinander kommunizieren, und wir müssen nur den Port "+ 80 +" für den Front-End-Zugriff auf die Anwendung verfügbar machen.

Die fertige Datei + docker-compose.yml + sieht folgendermaßen aus:

~ / wordpress / docker-compose.yml

version: '3'

services:
 db:
   image: mysql:
   container_name: db
   restart: unless-stopped
   env_file: .env
   environment:
     - MYSQL_DATABASE=
   volumes:
     - dbdata:/var/lib/mysql
   command: '--default-authentication-plugin=mysql_native_password'
   networks:
     - app-network

 wordpress:
   depends_on:
     - db
   image: wordpress:-fpm-alpine
   container_name: wordpress
   restart: unless-stopped
   env_file: .env
   environment:
     - WORDPRESS_DB_HOST=db:3306
     - WORDPRESS_DB_USER=$MYSQL_USER
     - WORDPRESS_DB_PASSWORD=$MYSQL_PASSWORD
     - WORDPRESS_DB_NAME=
   volumes:
     - wordpress:/var/www/html
   networks:
     - app-network

 webserver:
   depends_on:
     - wordpress
   image: nginx:-alpine
   container_name: webserver
   restart: unless-stopped
   ports:
     - "80:80"
   volumes:
     - wordpress:/var/www/html
     - ./nginx-conf:/etc/nginx/conf.d
     - certbot-etc:/etc/letsencrypt
   networks:
     - app-network

 certbot:
   depends_on:
     - webserver
   image: certbot/certbot
   container_name: certbot
   volumes:
     - certbot-etc:/etc/letsencrypt
     - wordpress:/var/www/html
   command: certonly --webroot --webroot-path=/var/www/html --email  --agree-tos --no-eff-email --staging -d  -d www.

volumes:
 certbot-etc:
 wordpress:
 dbdata:

networks:
 app-network:
   driver: bridge

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

Mit Ihren Service-Definitionen können Sie die Container starten und Ihre Zertifikatanforderungen testen.

Schritt 4 - Beziehen von SSL-Zertifikaten und -Anmeldeinformationen

Wir können unsere Container mit dem Befehl https://docs.docker.com/compose/reference/up/[`docker-compose up + `] starten, der unsere Container in der angegebenen Reihenfolge erstellt und ausführt. Wenn unsere Domain-Anfragen erfolgreich sind, sehen wir den korrekten Exit-Status in unserer Ausgabe und die richtigen Zertifikate im Ordner " / etc / letsencrypt / live " im Container " webserver +".

Erstellen Sie die Container mit +docker-compose up + ` und dem Flag

Related