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.com als 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 [email protected]_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 [email protected] --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.

Drupal Installer Home

Klicke auf die Schaltfläche Speichern und weiter, um zur Seite mit dem Installationsprofil zu gelangen.

Drupal Installationsprofil

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.

Drupal Datenbank Konfiguration

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.

Drupal Modul und Theme Installer

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.

Drupal Website Konfiguration

Schließlich wirst du zum Drupal-Dashboard weitergeleitet. Jetzt kannst du Drupal für die Erstellung deiner Website verwenden.

Drupal Dashboard

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.

Das könnte dich auch interessieren …