Installation von Bolt CMS mit Nginx, MySQL, PHP und HTTPS unter Ubuntu 20.04

Bolt ist ein kostenloses und quelloffenes Content-Management-System, das auf dem Symfony-PHP-Framework basiert. Es richtet sich an mittelgroße Webseiten und eignet sich sowohl für Redakteure als auch für Entwickler. Diese Anleitung beschreibt die Einrichtung von Bolt auf einem Ubuntu-20.04-Server mit Nginx als Webserver, MySQL als Datenbank und PHP. Zudem wird die Konfiguration einer kostenlosen TLS-Verschlüsselung mit einem Let’s Encrypt Zertifikat behandelt.

Systemanforderungen und erste Schritte

Bevor du mit der Installation beginnst, sollten folgende Voraussetzungen erfüllt sein:

• Starte eine Cloud-Instanz mit Ubuntu 20.04.
• Richte einen Benutzer mit sudo-Rechten ein, der nicht root ist.
• Installiere alle aktuellen Systemupdates.
• Konfiguriere die Firewall so, dass die Ports 80 (HTTP), 443 (HTTPS) und 22 (SSH) geöffnet sind.
• Stelle sicher, dass ein vollqualifizierter Domainname (FQDN), z. B. bolt.example.com, auf die IP-Adresse deines Servers zeigt. Dies ist notwendig, damit die Authentifizierung funktioniert.
• Melde dich mit dem nicht-root Benutzer am Server an.

In allen Befehlen musst du bolt.example.com durch den tatsächlichen Domainnamen deines Servers ersetzen.

Schritt 1: Wichtige Systempakete für Bolt CMS installieren

Damit Bolt CMS reibungslos funktioniert, müssen zunächst einige grundlegende Softwarekomponenten installiert werden:

• Ein Webserver wie Nginx
• Eine relationale Datenbank wie MySQL
• PHP in Version 7.2.9 oder höher, mit mindestens 32 MB Speicher
• Folgende PHP-Erweiterungen:
  • Erforderlich: curl, exif, fileinfo, gd, json, mysqlnd (für MySQL), openssl, pdo, posix, xml, zip
  • Optional, aber empfohlen: intl, mbstring, opcache

Nginx Webserver installieren

Führe den folgenden Befehl aus, um Nginx zu installieren:

$ sudo apt -y install nginx

MySQL 8.0 einrichten

Installiere und konfiguriere MySQL 8.0 entsprechend den Anweisungen aus der offiziellen Dokumentation.

PHP 8.0 über das Ondřej Surý Repository aktivieren

Um Zugriff auf PHP 8.0 zu erhalten, füge das bewährte Community-Repository ppa:ondrej/php hinzu:

$ sudo LC_ALL=C.UTF-8 add-apt-repository -y ppa:ondrej/php

PHP 8.0 und benötigte Erweiterungen installieren

Installiere PHP 8.0 inklusive aller erforderlichen Module mit folgendem Befehl:

$ sudo apt -y install php8.0-cli php8.0-curl php8.0-fpm php8.0-gd php8.0-intl php8.0-mbstring php8.0-mysql php8.0-xml php8.0-zip

Unzip-Dienstprogramm installieren

Installiere unzip, um ZIP-Archive verarbeiten zu können:

$ sudo apt -y install unzip

Schritt 2: PHP für Bolt CMS einrichten und konfigurieren

Wähle zunächst eine von deinem System unterstützte Zeitzone aus. Navigiere mit den Pfeiltasten (↑, ↓, Bild↑, Bild↓) durch die Liste und beende die Anzeige mit Q:

$ timedatectl list-timezones

Wähle eine passende Zeitzone wie z. B. America/New_York und stelle sie auf deinem Server ein:

$ sudo timedatectl set-timezone America/New_York

Bearbeite anschließend die Hauptkonfigurationsdatei von PHP, um die Zeitzone einzutragen:

$ sudo nano /etc/php/8.0/fpm/php.ini

Suche nach der Zeile ;date.timezone =, entferne das Semikolon und trage deine Zeitzone ein:

date.timezone = America/New_York

Optional kannst du folgende Werte anpassen:

• max_execution_time
• memory_limit
• post_max_size
• upload_max_filesize

Speichere und schließe die Datei nach deinen Änderungen.

Benutzer für die Verwaltung von Bolt anlegen

Lege einen neuen Benutzer namens bolt an, der den Quellcode der Website verwalten soll:

$ sudo adduser bolt

Wechsle künftig zu diesem Benutzer, wenn du Änderungen am Quellcode vornimmst.

PHP-FPM für den Bolt-Benutzer konfigurieren

Kopiere die Standardkonfiguration von PHP-FPM und erstelle eine eigene Konfigurationsdatei für Bolt:

$ sudo cp /etc/php/8.0/fpm/pool.d/www.conf /etc/php/8.0/fpm/pool.d/bolt.conf

Benenne die Standardkonfiguration um, um sie zu deaktivieren:

$ sudo mv /etc/php/8.0/fpm/pool.d/www.conf /etc/php/8.0/fpm/pool.d/www.conf.default

Bearbeite die neue Konfigurationsdatei für den Benutzer bolt:

$ sudo nano /etc/php/8.0/fpm/pool.d/bolt.conf

Ändere darin folgende Einstellungen:

• [www] ersetzen durch [bolt]
• user = www-data ändern zu user = bolt
• group = www-data ändern zu group = bolt (die Zeile listen.group = www-data bleibt unverändert)
• Stelle sicher, dass listen = /run/php/php8.0-fpm.sock nicht auskommentiert ist

Füge am Ende der Datei folgenden Block hinzu, um Fehlerprotokolle und Sitzungsdaten korrekt zu speichern:

catch_workers_output = yes
php_flag[display_errors] = off
php_admin_flag[log_errors] = on
php_admin_value[error_log] = /var/log/php-fpm/bolt/error.log

php_admin_value[session.save_path] = /var/lib/php/sessions/bolt

Diese Einstellungen sorgen dafür, dass Fehler nicht im Browser angezeigt, sondern in /var/log/php-fpm/bolt/error.log gespeichert werden. Die Sessions werden in /var/lib/php/sessions/bolt abgelegt.

Verzeichnisse für Logs und Sessions erstellen

Lege die benötigten Verzeichnisse mit folgendem Befehl an:

$ sudo mkdir -p /var/log/php-fpm/bolt
$ sudo mkdir -p /var/lib/php/sessions/bolt

Vergib nun die passenden Berechtigungen und Eigentümerrechte:

$ sudo chown bolt:bolt /var/log/php-fpm/bolt
$ sudo chmod 700 /var/log/php-fpm/bolt
$ sudo chown bolt:bolt /var/lib/php/sessions/bolt
$ sudo chmod 700 /var/lib/php/sessions/bolt

PHP-FPM-Konfiguration prüfen und neu starten

Teste die neue PHP-FPM-Konfiguration auf Syntaxfehler:

$ sudo php-fpm8.0 -t

Starte PHP-FPM neu, damit die Änderungen aktiv werden:

$ sudo systemctl restart php8.0-fpm.service

Schritt 3: MySQL-Datenbank für Bolt CMS einrichten

Beginne damit, dich als Root-Benutzer in die MySQL-Datenbank einzuloggen:

$ sudo mysql

Erstelle in der MySQL-Konsole eine neue Datenbank für Bolt. Ersetze db_name durch deinen gewünschten Datenbanknamen:

mysql> CREATE DATABASE db_name;

Erstelle anschließend einen Benutzer db_user mit vollständigen Zugriffsrechten auf diese Datenbank. Ersetze db_password durch ein sicheres Passwort deiner Wahl:

mysql> CREATE USER 'db_user'@'localhost' IDENTIFIED BY 'db_password';
mysql> GRANT ALL PRIVILEGES on db_name.* to 'db_user'@'localhost';
mysql> FLUSH PRIVILEGES;

Verlasse anschließend die MySQL-Konsole:

mysql> exit

Schritt 4: Bolt CMS mit Composer installieren

Die schnellste und empfohlene Methode zur Installation von Bolt ist die Verwendung von Composer, einem Paketmanager für PHP-Abhängigkeiten.

Composer installieren

Beginne mit dem Herunterladen von Composer:

$ curl -sS https://getcomposer.org/installer | php

Verschiebe die heruntergeladene Datei in ein globales Verzeichnis, damit Composer systemweit verfügbar ist:

$ sudo mv composer.phar /usr/local/bin/composer

[/dm_code_snippet>
Projektverzeichnis für Bolt erstellen
Erstelle ein Zielverzeichnis für die Bolt-Quellcodes:

			

                

                    

                        

                        

                        

                    
                    

                        
                        Copy Code
                        Copied
                        Use a different Browser
                    
                
                

			
        
$ sudo mkdir /var/www/bolt

Ändere den Besitzer des Verzeichnisses auf den Benutzer bolt:

$ sudo chown bolt:bolt /var/www/bolt

Bolt mit Composer herunterladen

Wechsle zum Benutzer bolt, um den Download durchzuführen:

$ sudo su - bolt

Gehe in das zuvor erstellte Verzeichnis für den Quellcode:

$ cd /var/www/bolt

Installiere Bolt CMS und alle Abhängigkeiten. Der Vorgang kann einige Minuten in Anspruch nehmen:

$ composer create-project bolt/project .

Wenn die Frage Do you want to continue the setup now? (Y/n) erscheint, drücke N und dann Enter, um die SQLite-Einrichtung zu überspringen.

Datenbankverbindung und Umgebung konfigurieren

Erstelle eine Umgebungsdatei mit lokalen Einstellungen:

$ nano .env.local

Füge folgenden Inhalt ein und ersetze db_user, db_password und db_name durch deine Datenbank-Zugangsdaten:

APP_ENV=prod # production environment
DATABASE_URL=mysql://db_user:"db_password"@localhost:3306/db_name

Speichere die Datei und schließe den Editor.

Umgebungsdatei optimieren

Generiere eine vorkompilierte Umgebungsdatei, um die Performance zu verbessern:

$ composer dump-env prod

Datenbank initialisieren und Beispieldaten importieren

Lege das notwendige Datenbankschema an. Die Warnung, dass dies nicht für Produktionsumgebungen empfohlen ist, kannst du ignorieren:

$ bin/console doctrine:schema:create

Importiere Beispieldaten in die Datenbank. Gib yes ein, wenn du dazu aufgefordert wirst:

$ bin/console doctrine:fixtures:load

Administrationskonto anlegen

Lege ein erstes Administrator-Konto an. Ersetze die Platzhalter durch deine gewünschten Angaben:

$ bin/console bolt:add-user 'username' 'password' 'email' 'display-name' --admin

Wenn du fertig bist, verlasse die bolt-Sitzung und kehre zum sudo-Nutzer zurück, um mit der Konfiguration von Nginx fortzufahren:

$ exit

Schritt 5: Nginx für deine Bolt-CMS-Seite konfigurieren

Erstelle zunächst eine neue Konfigurationsdatei für Nginx, die speziell für deine Bolt-Installation vorgesehen ist:

$ sudo nano /etc/nginx/sites-available/bolt-http.conf

Füge den folgenden Inhalt in den Editor ein. Ersetze bolt.example.com durch deinen tatsächlichen Domainnamen:

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

    server_name bolt.example.com; # Domain deiner Seite

    ## Logging aktivieren (optional)
    # access_log /var/log/nginx/bolt.example.com.access.log;
    # error_log /var/log/nginx/bolt.example.com.error.log;

    root /var/www/bolt/public; # Pfad zum Webverzeichnis
    index index.php;

    # Maximale Uploadgröße anpassen (mindestens wie PHP post_max_size)
    client_max_body_size 16m;

    # Standardweiterleitung aller Anfragen
    location / {
        try_files $uri $uri/ /index.php$is_args$args;
    }

    # Zugriff auf das Bolt-Backend
    location = /bolt {
        try_files $uri /index.php$is_args$args;
    }
    location ^~ /bolt/ {
        try_files $uri /index.php$is_args$args;
    }

    # Thumbnails zwischenspeichern
    location ^~ /thumbs {
        try_files $uri /index.php;

        access_log off;
        log_not_found off;
        expires max;
        add_header Pragma public;
        add_header Cache-Control "public, mustrevalidate, proxy-revalidate";
        add_header X-Koala-Status sleeping;
    }

    # Assets cachen, aber nicht loggen
    location ~* ^.+\.(atom|bmp|bz2|css|doc|eot|exe|gif|gz|ico|jpe?g|jpeg|jpg|js|map|mid|midi|mp4|ogg|ogv|otf|png|ppt|rar|rtf|svg|svgz|tar|tgz|ttf|wav|woff|xls|zip)$ {
        access_log off;
        log_not_found off;
        expires max;
        add_header Pragma public;
        add_header Cache-Control "public, mustrevalidate, proxy-revalidate";
        add_header X-Koala-Status eating;
    }

    # Zugriff auf sensible Dateien in Theme-Ordnern blockieren
    location ~ theme\/.+\.(?!(html?|css|js|jpe?g|png|gif|svg|pdf|avif|webp|mp3|mp?4a?v?|woff2?|txt|ico|zip|tgz|otf|ttf|eot|woff|woff2)$)[^\.]+?$ {
        deny all;
    }

    # index.php aus der URL entfernen
    location ~ /index.php/(.*) {
        rewrite ^/index.php/(.*) /$1 permanent;
    }

    location ~ [^/]\.php(/|$) {
        try_files /index.php =404;

        fastcgi_split_path_info ^(.+?\.php)(/.*)$;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

        # Sicherheit gegen httpoxy-Angriffe
        fastcgi_param HTTP_PROXY "";

        # HTTPS-Header setzen
        fastcgi_param HTTPS $https if_not_empty;

        fastcgi_pass unix:/run/php/php8.0-fpm.sock;

        # FastCGI-Parameter einbinden
        include fastcgi_params;
    }

    # Versteckte Dateien sperren (außer Let's Encrypt)
    location ~ /\.(?!well-known) {
        deny all;
    }

    # Zugriff auf Markdown-, Twig- und YAML-Dateien unterbinden
    location ~* /.+\.(markdown|md|twig|yaml|yml)$ {
        deny all;
    }
}

Speichere die Datei und schließe den Editor, wenn du die Bearbeitung abgeschlossen hast.

Nginx-Konfiguration aktivieren und anwenden

Erstelle einen symbolischen Link, um die neue Konfigurationsdatei für Nginx zu aktivieren:

$ sudo ln -s /etc/nginx/sites-available/bolt-http.conf /etc/nginx/sites-enabled/bolt-http.conf

Füge den Benutzer www-data zur Gruppe bolt hinzu, damit Nginx Zugriff auf das Verzeichnis erhält:

$ sudo usermod -aG bolt www-data

Prüfe anschließend, ob die Konfiguration fehlerfrei ist:

$ sudo nginx -t

Aktualisiere Nginx mit den neuen Einstellungen:

$ sudo systemctl reload nginx.service

Um die Sicherheit weiter zu erhöhen, fahre mit dem nächsten Schritt fort und aktiviere HTTPS für deine Bolt-Installation.

Schritt 6 (optional): HTTPS mit Let’s Encrypt für Bolt CMS aktivieren

Certbot installieren und kostenloses TLS-Zertifikat erhalten

Folge zunächst der Anleitung zur Installation von Certbot über Snap, um die Umgebung einzurichten.

Nginx für HTTPS vorbereiten

Benenne die bestehende HTTP-Konfigurationsdatei um, um sie als Grundlage für die HTTPS-Konfiguration zu verwenden:

$ sudo mv /etc/nginx/sites-available/bolt-http.conf /etc/nginx/sites-available/bolt-https.conf

Erstelle eine neue Nginx-Konfigurationsdatei, die nur HTTP-Anfragen verarbeitet:

$ sudo nano /etc/nginx/sites-available/bolt-http.conf

Füge folgenden Inhalt in die Datei ein und ersetze bolt.example.com mit deinem echten Domainnamen:

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

    server_name bolt.example.com; # Domain deiner Website

    root /var/www/bolt/public;

    location / {
        return 301 https://$server_name$request_uri;
    }

    location /.well-known/acme-challenge/ {}
}

Diese Konfiguration sorgt dafür, dass alle HTTP-Anfragen – mit Ausnahme der Let’s-Encrypt-Validierung – automatisch per 301-Weiterleitung zu HTTPS umgeleitet werden.

Konfiguration prüfen und übernehmen

Überprüfe, ob die neue Nginx-Konfiguration fehlerfrei ist:

$ sudo nginx -t

Starte Nginx neu, damit die Änderungen aktiv werden:

$ sudo systemctl reload nginx.service

Let’s-Encrypt-Zertifikat mit Certbot anfordern

Fordere dein SSL-Zertifikat mit Certbot an. Ersetze admin@bolt.example.com durch deine E-Mail-Adresse und bolt.example.com durch deine Domain:

$ sudo certbot certonly --webroot -w /var/www/bolt/public -d bolt.example.com -m admin@bolt.example.com --agree-tos --no-eff-email --non-interactive

Nach erfolgreicher Einrichtung speichert Certbot die Zertifikatsdateien im Verzeichnis /etc/letsencrypt/archive/bolt.example.com und erstellt symbolische Links unter /etc/letsencrypt/live/bolt.example.com zur einfacheren Nutzung.

Du kannst die Links mit folgendem Befehl auflisten:

$ sudo ls /etc/letsencrypt/live/bolt.example.com

Die Ausgabe sollte folgende Dateien enthalten:

• cert.pem
• chain.pem
• fullchain.pem
• privkey.pem
• README

Diese symbolischen Links werden im nächsten Schritt zur Vervollständigung der SSL-Konfiguration verwendet.

Schritt 7: Bolt CMS mit einem SSL-Zertifikat in Nginx absichern

DH-Parameter für stärkere Verschlüsselung erzeugen

Erstelle eine Diffie-Hellman-Parameterdatei mit der empfohlenen Schlüssellänge von 2048 Bit. Der Vorgang kann einige Minuten dauern:

$ sudo openssl dhparam -out /etc/nginx/dhparam.pem 2048

HTTPS-Konfiguration in Nginx anpassen

Bearbeite die bestehende Nginx-Konfigurationsdatei für HTTPS:

$ sudo nano /etc/nginx/sites-available/bolt-https.conf

Suche die folgenden Zeilen:

listen 80;
listen [::]:80;

Ersetze sie durch diesen Block, um HTTPS mit starker Verschlüsselung zu aktivieren. Ersetze bolt.example.com durch deinen echten Domainnamen:

listen 443 ssl http2;
listen [::]:443 ssl http2;

ssl_certificate /etc/letsencrypt/live/bolt.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/bolt.example.com/privkey.pem;

ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;  # etwa 40.000 Sessions

# DH-Parameter-Datei
ssl_dhparam /etc/nginx/dhparam.pem;

# Empfohlene Protokolle und Cipher Suites
ssl_protocols TLSv1.2;
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;

# HSTS aktivieren (optional)
# Nur aktivieren, wenn deine Seite vollständig HTTPS nutzt
# add_header Strict-Transport-Security "max-age=63072000" always;

# OCSP-Stapling
ssl_stapling on;
ssl_stapling_verify on;

# Vertrauenskette für OCSP-Validierung
ssl_trusted_certificate /etc/letsencrypt/live/bolt.example.com/chain.pem;

# DNS-Resolver von Cloudflare
resolver 1.1.1.1;

Speichere die Datei und beende den Editor.

HTTPS-Konfiguration aktivieren und anwenden

Erstelle einen symbolischen Link, um die HTTPS-Konfiguration zu aktivieren:

$ sudo ln -s /etc/nginx/sites-available/bolt-https.conf /etc/nginx/sites-enabled/bolt-https.conf

Teste die Konfiguration, um sicherzustellen, dass keine Fehler vorhanden sind:

$ sudo nginx -t

Lade den Nginx-Dienst neu, damit die Einstellungen übernommen werden:

$ sudo systemctl reload nginx.service

Schritt 8: TLS-Zertifikat für Bolt CMS automatisch verlängern

Die von Let’s Encrypt ausgestellten SSL-Zertifikate sind nur 90 Tage gültig. Du solltest daher sicherstellen, dass die Erneuerung mindestens einmal pro Quartal erfolgt. Glücklicherweise wird bei der Installation von Certbot automatisch ein systemd-Timer eingerichtet, der diese Aufgabe übernimmt.

Prüfen, ob der Certbot-Timer aktiv ist

Führe den folgenden Befehl aus, um zu überprüfen, ob der Timer korrekt läuft:

$ sudo systemctl list-timers | grep 'certbot\|ACTIVATES'

Hook-Skript erstellen, um Nginx nach der Verlängerung neu zu laden

Lege ein Skript im Verzeichnis renewal-hooks/deploy an, damit Nginx nach der automatischen Zertifikatserneuerung neu gestartet wird:

$ sudo nano /etc/letsencrypt/renewal-hooks/deploy/reload-nginx.sh

Füge folgenden Inhalt in die Datei ein:

#!/bin/bash

/usr/bin/systemctl reload nginx.service

Speichere das Skript und mache es ausführbar, damit Certbot es nach erfolgreicher Erneuerung ausführen kann:

$ sudo chmod +x /etc/letsencrypt/renewal-hooks/deploy/reload-nginx.sh

Testlauf der Zertifikatserneuerung durchführen

Starte einen Testlauf der Erneuerung, um sicherzustellen, dass alle Prozesse korrekt eingerichtet sind:

$ sudo certbot renew --dry-run

Fazit

Mit dieser Schritt-für-Schritt-Anleitung hast du erfolgreich Bolt CMS auf einem Ubuntu 20.04 Server eingerichtet. Die Installation beinhaltet eine performante LEMP-Umgebung mit Nginx, MySQL und PHP 8 sowie eine sichere HTTPS-Konfiguration mit einem kostenlosen TLS-Zertifikat von Let’s Encrypt.

Von der Servervorbereitung und Benutzerverwaltung über die PHP- und Datenbankkonfiguration bis hin zur Composer-Installation und automatisierten SSL-Erneuerung deckt dieser Leitfaden alle notwendigen Schritte für einen produktionsbereiten Einsatz ab.

Mit der aktivierten TLS-Verschlüsselung und der automatisierten Verlängerung bist du außerdem langfristig vor Sicherheitslücken geschützt. Bolt CMS bietet dir nun eine zuverlässige und flexible Plattform, um deine Website sicher und effizient zu betreiben.