Wie man Drupal mit Docker auf Ubuntu 22.04 installiert
Drupal ist ein in PHP geschriebenes Open-Source Content Management System (CMS). Viele Organisationen auf der ganzen Welt nutzen es, um Blogs, Regierungsseiten, Unternehmenswebseiten und vieles mehr zu erstellen. Es verfügt über eine wachsende Anzahl von Funktionen und Modulen, mit denen du jede beliebige Website erstellen kannst.
In diesem Tutorial lernst du, wie du Drupal mit Docker auf einem Ubuntu 22.04 Server installierst. Drupal funktioniert mit PHP 8.2 und MySQL. Seit Version 9 wird auch PostgreSQL unterstützt, aber es gibt noch einige Bugs. Deshalb werden wir uns in unserem Tutorial auf MySQL beschränken. Wir werden Docker Compose verwenden, um Drupal mit Nginx und dem Tool Certbot zu verbinden und eine Drupal-Website über das sichere HTTPS-Protokoll zu betreiben.
Voraussetzungen
- Ein Server mit Ubuntu 22.04 und mindestens 1 GB RAM für kleinere Communities. Für größere Communities solltest du dir einen Server mit mindestens 2 GB RAM oder mehr zulegen.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Einen vollständig qualifizierten Domainnamen (FQDN), der auf deinen Server zeigt. Für unsere Zwecke verwenden wir
example.comals Domänennamen. - Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update
- Installiere grundlegende Hilfspakete. Einige von ihnen sind vielleicht schon installiert.
$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Ubuntu wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.
Überprüfe, ob die Firewall aktiv ist.
$ sudo ufw status
Du solltest die folgende Ausgabe erhalten.
Status: inactive
Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.
$ sudo ufw allow OpenSSH
Lasse auch HTTP- und HTTPS-Ports zu.
$ sudo ufw allow http $ sudo ufw allow https
Aktiviere die Firewall
$ sudo ufw enable Command may disrupt existing ssh connections. Proceed with operation (y|n)? y Firewall is active and enabled on system startup
Überprüfe den Status der Firewall erneut.
$ sudo ufw status
Du solltest eine ähnliche Ausgabe sehen.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6)
Schritt 2 – Installiere Docker und Docker Compose
Ubuntu 22.04 wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, importiere zunächst den Docker GPG-Schlüssel.
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
Erstelle eine Docker-Repository-Datei.
$ echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Aktualisiere die Liste der System-Repositorys.
$ sudo apt update
Installiere die neueste Version von Docker.
$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin
Überprüfe, ob sie läuft.
$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Sat 2023-01-14 10:41:35 UTC; 2min 1s ago
TriggeredBy: ? docker.socket
Docs: https://docs.docker.com
Main PID: 2054 (dockerd)
Tasks: 52
Memory: 22.5M
CPU: 248ms
CGroup: /system.slice/docker.service
?? 2054 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
Standardmäßig benötigt Docker Root-Rechte. Wenn du vermeiden willst, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.
$ sudo usermod -aG docker $(whoami)
Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden oder den folgenden Befehl verwenden.
$ su - ${USER}
Bestätige, dass dein Benutzer der Docker-Gruppe hinzugefügt wurde.
$ groups navjot wheel docker
Schritt 3 – Docker Compose-Datei für Drupal erstellen
Erstelle das Verzeichnis für Drupal.
$ mkdir ~/drupal
Wechsle in das Verzeichnis.
$ cd ~/drupal
Erstelle und öffne die Datei docker-compose.yml zur Bearbeitung.
$ nano docker-compose.yml
Füge den folgenden Code in die Datei ein.
services:
mysql:
image: mysql:8.0
container_name: mysql
restart: unless-stopped
env_file: .env
volumes:
- db-data:/var/lib/mysql
networks:
- internal
drupal:
image: drupal:10-fpm-alpine
container_name: drupal
depends_on:
- mysql
restart: unless-stopped
networks:
- internal
- external
volumes:
- drupal-data:/var/www/html
webserver:
image: nginx:1.22.1-alpine
container_name: webserver
depends_on:
- drupal
restart: unless-stopped
ports:
- 80:80
volumes:
- drupal-data:/var/www/html
- ./nginx-conf:/etc/nginx/conf.d
- certbot-etc:/etc/letsencrypt
networks:
- external
certbot:
depends_on:
- webserver
image: certbot/certbot
container_name: certbot
volumes:
- certbot-etc:/etc/letsencrypt
- drupal-data:/var/www/html
command: certonly --webroot --webroot-path=/var/www/html --email sammy@your_domain --agree-tos --no-eff-email --staging -d example.com -d www.example.com
networks:
external:
driver: bridge
internal:
driver: bridge
volumes:
drupal-data:
db-data:
certbot-etc:
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Gehen wir nun die einzelnen Dienste durch, die in der obigen Datei definiert sind.
MySQL Docker-Dienst
Hier ziehen wir das neueste mysql:8.0 Image aus dem Docker Hub. Wir verwenden die Version 8.x, anstatt das neueste Tag zu verwenden. Auf diese Weise können wir uns an die stabile und getestete Version von MySQL halten, die mit Drupal funktioniert. Wir haben einen Namen für den Container festgelegt, der mit Docker-Befehlen zum Stoppen, Starten und Anzeigen von Protokollen verwendet werden kann. Der Container läuft weiter, bis er manuell gestoppt wird. Wir haben eine .env Datei definiert, die wir mit den MySQL-Anmeldedaten füllen werden. Außerdem haben wir ein benanntes Volume db-data in das Verzeichnis /var/lib/mysql des Containers eingebunden. Der MySQL-Dienst wird ein internes Netzwerk verwenden, um sich mit Drupal zu verbinden.
Drupal-Dienst
Wir verwenden das Alpine-Image von Drupal 10. Alpine-Docker-Images sind kleiner. Dieses Image enthält auch PHP-FPM für die PHP-Verarbeitung. Es arbeitet mit Nginx zusammen, um die Website zu bedienen. Mit der Option depends_on wird Drupal angewiesen, sich mit dem MySQL-Dienst zu verbinden. Sie stellt außerdem sicher, dass der Drupal-Container immer nach dem MySQL-Container gestartet wird. Drupal nutzt das interne Netzwerk, um sich mit MySQL zu verbinden, und das externe Netzwerk, um sich anderen Containern mitzuteilen. Wir haben auch ein benanntes Volume für Drupal erstellt, das auf das Verzeichnis /var/www/html im Container zeigt.
Nginx-Dienst
Wir verwenden ein Alpine-Image für Nginx. Es stellt den Port 80 für den Host zur Verfügung. Wir verwenden zwei benannte Volumes, eines für das öffentliche Verzeichnis von Drupal und das andere für die Speicherung von Let’s Encrypt SSL-Zertifikaten. Das dritte Volume ist ein Bind-Mount für das Nginx-Konfigurationsverzeichnis auf dem Host, das wir später definieren werden. Nginx stellt außerdem eine Verbindung zu einem externen Docker-Netzwerk her, damit die Drupal-Website funktioniert.
Certbot-Dienst
Zu guter Letzt ziehen wir das Certbot-Image, um SSL-Zertifikate zu installieren. Es teilt sich seine Volumes mit dem Nginx-Dienst für die Zertifikate und die Webroot-Definition. Wir haben auch einen Befehl eingefügt, der ausgeführt wird, wenn der Container erstellt wird. Hier verwendet der Befehl das --staging Flag, um zum ersten Mal einen Testserver zu erhalten. Wir brauchen Nginx, um die Zertifikate zu validieren, aber Nginx wird nicht starten, wenn die Zertifikate fehlen. Deshalb erstellen wir ein Staging-Zertifikat, verwenden dieses, um Nginx zu starten, und erstellen dann die echten Zertifikate.
Schritt 4 – Nginx-Konfiguration erstellen
Erstelle das Verzeichnis für die Nginx-Konfiguration.
$ mkdir nginx-conf
Erstelle und öffne die Datei für Nginx.
$ nano nginx-conf/drupal.conf
Füge den folgenden Code in die Datei ein.
server {
listen 80;
listen [::]:80;
server_name drupal.example.com;
index index.php 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;
}
rewrite ^/core/authorize.php/core/authorize.php(.*)$ /core/authorize.php$1;
location ~ \.php$ {
try_files $uri =404;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass drupal: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;
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
In dieser Datei fügen wir einen Server-Block mit Direktiven für unseren Servernamen und unser Dokumentenstammverzeichnis sowie Standortblöcke ein, um die Anfragen des Certbot-Clients für Zertifikate, PHP-Verarbeitung und statische Assets zu steuern. Vorerst wird Nginx nur auf Port 80 lauschen, damit Certbot das Staging-Zertifikat anfordern kann, indem es eine temporäre Datei im Verzeichnis /var/www/html/.well-known/acme-challenge ablegt, um den DNS zu validieren. So können wir Certbot mit dem Webroot-Plugin verwenden.
Schritt 5 – SSL-Zertifikate generieren
Um SSL-Zertifikate zu erzeugen, starten wir unsere Container. Die richtigen Staging-Zertifikate werden im Ordner /etc/letsencrypt/live im Nginx-Container zur Verfügung stehen.
$ docker compose up -d
Überprüfe den Status der Dienste.
$ docker compose ps NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS certbot certbot/certbot "certbot certonly --…" certbot 6 minutes ago Exited (1) 5 minutes ago drupal drupal:10-fpm-alpine "docker-php-entrypoi…" drupal 6 minutes ago Up 6 minutes 9000/tcp mysql mysql:8.0 "docker-entrypoint.s…" mysql 6 minutes ago Up 6 minutes 3306/tcp, 33060/tcp webserver nginx:1.22.1-alpine "/docker-entrypoint.…" webserver 6 minutes ago Up 6 minutes 0.0.0.0:80->80/tcp, :::80->80/tcp
Der Certbot-Container wird nach der Generierung des Zertifikats erfolgreich beendet. Überprüfe den Speicherort der Zertifikate im Nginx-Container.
$ docker compose exec webserver ls -la /etc/letsencrypt/live
Du erhältst die folgende Ausgabe.
total 16 drwx------ 3 root root 4096 Jan 17 09:15 . drwxr-xr-x 9 root root 4096 Jan 17 09:15 .. -rw-r--r-- 1 root root 740 Jan 17 09:15 README drwxr-xr-x 2 root root 4096 Jan 17 09:15 drupal.example.com
Dies bestätigt, dass alles erfolgreich war. Der nächste Schritt besteht darin, die eigentlichen Zertifikate zu erzeugen.
Öffne die Datei docker-compose.yml zum Bearbeiten.
$ nano docker-compose.yml
Ersetze die Flagge --staging im Abschnitt Certbot-Dienst durch die Flagge --force-renewal. Dadurch wird Certbot angewiesen, neue Zertifikate für deine Domain anzufordern. Das Flag renewal wird verwendet, weil es von nun an für die Erneuerung der Zertifikate verwendet wird.
certbot:
depends_on:
- webserver
image: certbot/certbot
container_name: certbot
volumes:
- certbot-etc:/etc/letsencrypt
- drupal-data:/var/www/html
command: certonly --webroot --webroot-path=/var/www/html --email name@example.com --agree-tos --no-eff-email --staple-ocsp --force-renewal -d drupal.example.com
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Führe den Befehl docker compose up erneut aus, um den Certbot-Container neu zu erstellen. Das Flag --no-deps weist Certbot an, den Container webserver nicht zu starten, da er bereits läuft.
$ docker compose up --force-recreate --no-deps certbot
Du wirst die folgende Ausgabe erhalten.
[+] Running 1/0 ? Container certbot Recreated 0.1s Attaching to certbot certbot | Saving debug log to /var/log/letsencrypt/letsencrypt.log certbot | Account registered. certbot | Renewing an existing certificate for drupal.example.com certbot | certbot | Successfully received certificate. certbot | Certificate is saved at: /etc/letsencrypt/live/drupal.example.com/fullchain.pem certbot | Key is saved at: /etc/letsencrypt/live/drupal.example.com/privkey.pem certbot | This certificate expires on 2023-04-17. certbot | These files will be updated when the certificate renews. certbot | NEXT STEPS: certbot | - The certificate will need to be renewed before it expires. Certbot can automatically renew the certificate in the background, but you may need to take steps to enable that functionality. See https://certbot.org/renewal-setup for instructions. certbot | certbot | - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - certbot | If you like Certbot, please consider supporting our work by: certbot | * Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate certbot | * Donating to EFF: https://eff.org/donate-le certbot | - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - certbot exited with code 0
Schritt 6 – Nginx für SSL konfigurieren
Jetzt, da unsere Zertifikate aktiv sind, müssen wir Nginx so konfigurieren, dass es sie ausliefert und HTTP-Anfragen auf HTTPS umleitet.
Beende den Nginx-Server.
$ docker stop webserver
Erstelle eine neue Nginx-Datei für die SSL-Konfiguration und öffne sie zum Bearbeiten.
$ nano nginx-conf/drupal-ssl.conf
Füge den folgenden Code in die Datei ein.
server {
listen 80;
listen [::]:80;
server_name drupal.example.com;
location ~ /.well-known/acme-challenge {
allow all;
root /var/www/html;
}
location / {
rewrite ^ https://$host$request_uri? permanent;
}
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name drupal.example.com;
index index.php index.html index.htm;
root /var/www/html;
server_tokens off;
ssl_certificate /etc/letsencrypt/live/drupal.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/drupal.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/drupal.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_prefer_server_ciphers off;
ssl_ecdh_curve secp384r1;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
# OCSP stapling
ssl_stapling on;
ssl_stapling_verify on;
resolver 8.8.8.8 8.8.4.4 valid=300s;
resolver_timeout 5s;
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Referrer-Policy "no-referrer-when-downgrade" always;
add_header Content-Security-Policy "default-src * data: 'unsafe-eval' 'unsafe-inline'" always;
location / {
try_files $uri $uri/ /index.php$is_args$args;
}
rewrite ^/core/authorize.php/core/authorize.php(.*)$ /core/authorize.php$1;
location ~ \.php$ {
try_files $uri =404;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass drupal: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;
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Der HTTP-Block gibt den Speicherort für das Webroot-Plugin von Certbot an und leitet jede HTTP-Anfrage auf HTTPS um.
Im nächsten Schritt musst du sicherstellen, dass der Nginx-Container auf Port 443 hört. Öffne die Datei docker-compose.yml zur Bearbeitung.
$ nano docker-compose.yml
Im Abschnitt Nginx der Datei nimmst du Änderungen vor, um 443 freizugeben und SSL zu aktivieren (siehe unten).
webserver:
image: nginx:1.22.1-alpine
container_name: webserver
depends_on:
- drupal
restart: unless-stopped
ports:
- 80:80
- 443:443
volumes:
- drupal-data:/var/www/html
- ./nginx-conf:/etc/nginx/conf.d
- certbot-etc:/etc/letsencrypt
- /etc/ssl/certs/dhparam.pem:/etc/ssl/certs/dhparam.pem
networks:
- external
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Nachdem wir nun die SSL-Konfiguration für Nginx aktiviert und hinzugefügt haben, kannst du die ältere HTTP-Konfigurationsdatei löschen.
$ rm nginx-conf/drupal.conf
Bevor wir Nginx neu starten, müssen wir ein Diffie-Hellman-Gruppenzertifikat erstellen, das wir bereits oben konfiguriert haben.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Erstelle den Nginx-Container neu.
$ docker compose up -d --force-recreate --no-deps webserver
Überprüfe den Status des Containers.
$ docker compose ps NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS certbot certbot/certbot "certbot certonly --…" certbot 3 hours ago Exited (0) 3 hours ago drupal drupal:10-fpm-alpine "docker-php-entrypoi…" drupal 3 hours ago Up 3 hours 9000/tcp mysql mysql:8.0 "docker-entrypoint.s…" mysql 3 hours ago Up 3 hours 3306/tcp, 33060/tcp webserver nginx:1.22.1-alpine "/docker-entrypoint.…" webserver 15 seconds ago Up 13 seconds 0.0.0.0:80->80/tcp, :::80->80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp
Schritt 7 – Drupal Web Installer starten
Es ist an der Zeit, den Drupal-Web-Installer zu starten. Öffne die URL https://drupal.example.com in deinem Browser und du wirst den folgenden Bildschirm sehen.
Klicke auf die Schaltfläche Speichern und weiter, um zur Seite mit dem Installationsprofil zu gelangen.
Wir entscheiden uns für das Profil Standard. Klicke auf die Schaltfläche Speichern und fort fahren, um zur Seite für die Datenbankkonfiguration zu gelangen.
Gib die Zugangsdaten für die Datenbank ein, die wir in der Umgebungsdatei verwendet haben, erweitere den Abschnitt Erweiterte Optionen und gib mysql als Datenbankhost ein. Dies entspricht dem Namen des MySQL-Dienstes in unserer Docker-Kompositionsdatei, mit dem sich Drupal verbinden muss.
Klicke auf die Schaltfläche Speichern und fortfahren, um fortzufahren. Drupal beginnt nun mit der Installation der Standardmodule und -themen.
Als Nächstes wirst du auf die Drupal-Konfigurationsseite weitergeleitet. Gib den Namen der Website, die E-Mail-Adresse, den Benutzernamen, das Passwort und die regionalen Einstellungen ein. Klicke auf die Schaltfläche Speichern und fortfahren, wenn du fertig bist.
Schließlich wirst du zum Drupal-Dashboard weitergeleitet. Jetzt kannst du Drupal für die Erstellung deiner Website verwenden.
Schritt 8 – Drupal konfigurieren
Dieser Schritt ist optional, hilft aber dabei, die Leistung von Drupal zu verbessern. Der erste Schritt ist die Einstellung des MySQL Transaction Isolation Levels. Die Standard-Transaktionsisolationsebene für MySQL, MariaDB und ähnliche Datenbanken ist „REPEATABLE READ“. Diese Einstellung kann bei Drupal zu Deadlocks in Tabellen führen, was dazu führt, dass die Website sehr langsam wird oder gar nicht mehr reagiert. Die empfohlene Transaktionsisolationsebene für Drupal-Sites ist „READ COMMITTED“.
Melde dich in der SSH-Shell des MySQL-Containers an.
$ docker exec -it mysql bash
Öffne die MySQL-Shell mit dem Benutzer root.
bash-4.4# mysql -u root -p Enter password:
Führe den folgenden Befehl aus, um den Transaktionslevel global zu ändern.
mysql> SET GLOBAL TRANSACTION ISOLATION LEVEL READ COMMITTED;
Beende die MySQL-Shell und den Container, indem du zweimal exit eingibst.
Im nächsten Schritt musst du deine Domain als vertrauenswürdigen Host eintragen, um dich vor HTTP HOST Header-Angriffen zu schützen. Dazu müssen wir die Datei /var/www/html/sites/default/settings.php innerhalb des Drupal-Containers bearbeiten. Da wir ein benanntes Volume für Drupal-Dateien verwenden, empfiehlt es sich, die Datei aus dem Container auf den Host zu kopieren, sie zu bearbeiten und dann wieder in den Container zu kopieren. Das kannst du mit jeder Datei machen, die du innerhalb der Drupal-Installation ändern musst.
Kopiere die Einstellungsdatei aus dem Container auf den Host.
$ docker cp drupal:/var/www/html/sites/default/settings.php settings.php
Die Datei ist schreibgeschützt. Gib ihr Schreibrechte.
$ chmod+w settings.php
Öffne die Datei zum Bearbeiten.
$ nano settings.php
Finde den folgenden Abschnitt in der Datei.
#$settings['trusted_host_patterns'] = [ # '^www\.example\.com$', #];
Hebe die Kommentare auf, indem du das Rautenzeichen entfernst und deine Drupal-Domain hinzufügst (siehe unten).
$settings['trusted_host_patterns'] = [ '^drupal\.example\.com$', ];
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Entferne die Schreibrechte wieder.
$ chmod -w settings.php
Kopiere die Datei zurück in den Container.
$ docker cp settings.php drupal:/var/www/html/sites/default
Schritt 9 – Drupal sichern
Wir verwenden die Kommandozeile, um ein Backup der Drupal-Datenbank zu erstellen. Wechsle in das Drupal-Verzeichnis.
$ cd ~/drupal
Erstelle das Verzeichnis für Backups.
$ mkdir backup-data
Verwende den folgenden Befehl, um ein Backup der Drupal-Datenbank zu erstellen. Du wirst nach deinem MySQL-Root-Passwort gefragt.
$ docker compose exec mysql sh -c "exec mysqldump drupal -uroot -p" | tee backup-data/data_`date +%d-%m-%Y"_"%H_%M_%S`.sql >/dev/null Enter password: root_password
Mit dem obigen Befehl wird die SQL-Sicherung im Verzeichnis ~/drupal/backup-data erstellt.
Überprüfe den Inhalt des Verzeichnisses.
$ ls -al backup-data total 6716 drwxrwxr-x 2 navjot navjot 4096 Jan 19 13:59 . drwxrwxr-x 4 navjot navjot 4096 Jan 19 13:35 .. -rw-rw-r-- 1 navjot navjot 6868325 Jan 19 13:37 data_19-01-2023_13_36_58.sql
Du kannst die gesicherte Datenbank in diesem Verzeichnis sehen. Du kannst diese Datenbank mit dem Tool phpMyAdmin oder mit dem folgenden Befehl wiederherstellen.
$ docker compose exec mysql sh -c "exec mysql -uroot -p" < backup-data/data_19-01-2023_13_36_58.sql
Du kannst einen Cron-Job erstellen, um die Datenbank regelmäßig zu sichern.
Erstelle das Backup-Skript im Verzeichnis /etc/cron.daily und öffne es zur Bearbeitung.
$ sudo nano /etc/cron.daily/drupalbackup.sh
Füge den folgenden Code in die Datei ein.
#!/bin/bash cd /home/navjot/drupal/ /usr/bin/docker compose exec mysql sh -c "exec mysqldump drupal -uroot -p" | tee backup-data/data_`date +%d-%m-%Y"_"%H_%M_%S`.sql >/dev/null
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Mache das Skript ausführbar.
$ sudo chmod +x /etc/cron.daily/drupalbackup.sh
Jetzt wird deine Datenbank täglich gesichert.
Schritt 10 – Drupal aktualisieren
Der erste Schritt beim Upgrade von Drupal besteht darin, die Drupal-Datenbank mit dem Befehl aus Schritt 9 zu sichern.
Dann wechselst du in das Verzeichnis.
$ cd ~/drupal
Stoppe die Containers.
$ docker compose down
Ziehe die neuesten Container-Images.
$ docker compose pull drupal:10-fpm-alpine
Wenn du auf die nächste Hauptversion upgraden willst, musst du den Namen des Images entsprechend anpassen und die Versionshinweise von Drupal durchgehen, um nach Problemen zu suchen.
Nimm alle Änderungen vor, die du auf docker-compose.yml vornehmen möchtest. Die übrigen Images kannst du aktualisieren, indem du ihre Definition in der Docker-Compose-Datei änderst.
Starte die Drupal-Container neu. Dadurch werden auch die neuesten Images für kleinere Versionen der anderen Pakete gezogen.
$ docker compose up -d
Fazit
Damit ist unsere Anleitung zur Installation von Drupal mit Docker auf einem Ubuntu 22.04 Server abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.