LEMP-Stack auf Ubuntu 24.04 LTS einrichten: Nginx, MariaDB, PHP 8.3 & Let’s Encrypt

# Paketlisten aktualisieren und installierte Pakete upgraden
sudo apt update && sudo apt upgrade -y

# Nicht mehr benötigte Alt-Abhängigkeiten restlos entfernen
sudo apt autoremove --purge -y && sudo apt autoclean

# Festplattenplatz auf der Root-Partition prüfen
df -h /

# RAM-Verfügbarkeit und Swap-Status kontrollieren
free -h

# Zeitsynchronisation via NTP sicherstellen
timedatectl status

# UFW und Fail2ban installieren
sudo apt install ufw fail2ban -y

# Standardrichtlinien definieren
sudo ufw default deny incoming
sudo ufw default allow outgoing

# SSH zwingend vor Aktivierung freischalten (Port 22)
sudo ufw allow OpenSSH

# Firewall aktivieren und Status prüfen
sudo ufw --force enable
sudo ufw status verbose

# Bestehende Webserver-Dienste prüfen (z. B. Apache-Altlasten)
sudo ss -tuln | grep -E ':(80|443)' || echo "Ports 80 und 443 sind frei"

# Nginx aus den offiziellen Ubuntu-Repositories installieren
sudo apt install nginx -y

# Dienst für automatischen Systemstart registrieren und starten
sudo systemctl enable nginx
sudo systemctl start nginx

# HTTP (Port 80) und HTTPS (Port 443) in der Firewall freigeben
sudo ufw allow 'Nginx Full'
sudo ufw status

# Laufenden Status der Systemd-Unit prüfen
systemctl status nginx --no-pager

# Lokale HTTP-Antwort testen
curl -I http://127.0.0.1

┌─────────────────────────────────────────────────────────────┐
│                 Nginx Verzeichnisstruktur                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   /etc/nginx/                                               │
│   ├── nginx.conf          Globale Hauptkonfiguration        │
│   ├── conf.d/             Modulare Server-Konfigurationen   │
│   ├── sites-available/    VHost-Vorlagen (Inaktiv)          │
│   └── sites-enabled/      Aktive VHost-Symlinks             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# MariaDB Server und Client-Tools installieren
sudo apt install mariadb-server mariadb-client -y

# Dienst aktivieren und Status überprüfen
sudo systemctl enable mariadb
sudo systemctl status mariadb --no-pager

# Interaktiven Sicherheitsassistenten ausführen
sudo mariadb-secure-installation

┌─────────────────────────────────────────────────────────────┐
│                MariaDB Verzeichnisstruktur                  │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   /etc/mysql/                                               │
│   ├── my.cnf              Zentraler Inkludierungs-Symlink   │
│   └── mariadb.conf.d/     Server-Konfigurationen            │
│       ├── 50-server.cnf   Hauptkonfiguration des Daemon     │
│       └── 60-galera.cnf   Cluster- & Replikationsprofile    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# Konfiguration zur Bearbeitung öffnen
sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf

[mysqld]
# Netzwerkbindung strikt auf localhost beschränken
bind-address            = 127.0.0.1

# Performance und InnoDB Tuning
innodb_buffer_pool_size = 512M          # Bei 2 GB RAM; bei 4 GB+ auf 50-70% des RAMs setzen
innodb_log_file_size    = 128M          # Schreibt Transaktionen effizient ins Log
innodb_flush_log_at_trx_commit = 2     # Reduziert Disk-I/O bei Schreiblasten
innodb_file_per_table   = 1             # Erstellt eigene .ibd-Dateien pro Tabelle
max_connections         = 100           # Verhindert Überlastung durch zu viele Clients

# MariaDB-Konfiguration neu einlesen
sudo systemctl restart mariadb

# PHP 8.3-FPM sowie Datenbank-, Bild- und Optimierungsmodule installieren
sudo apt install -y php8.3-fpm php8.3-common php8.3-mysql php8.3-xml                     php8.3-curl php8.3-gd php8.3-mbstring php8.3-zip                     php8.3-opcache php8.3-intl

# Status von PHP-FPM kontrollieren
sudo systemctl status php8.3-fpm --no-pager

# Installierte PHP-Version und aktive Erweiterungen listen
php -v
php -m | grep -E '(mysqli|pdo_mysql|opcache|curl)'

┌─────────────────────────────────────────────────────────────┐
│                PHP 8.3 Verzeichnisstruktur                  │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   /etc/php/8.3/                                             │
│   ├── fpm/                                                  │
│   │   ├── php-fpm.conf    Globale Master-Settings           │
│   │   ├── php.ini         FPM-Laufzeitkonfiguration         │
│   │   └── pool.d/         Worker-Pools                      │
│   │       └── www.conf    Standard-Pool (www-data Socket)   │
│   └── cli/                                                  │
│       └── php.ini         CLI-Laufzeitkonfiguration         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

; /etc/php/8.3/fpm/pool.d/www.conf
[www]
user = www-data
group = www-data

; Kommunikation über lokalen Unix-Domain-Socket
listen = /run/php/php8.3-fpm.sock
listen.owner = www-data
listen.group = www-data
listen.mode = 0660

; Prozessmanagement
pm = dynamic
pm.max_children = 25
pm.start_servers = 4
pm.min_spare_servers = 2
pm.max_spare_servers = 8
pm.max_requests = 500

# Durchschnittlichen RAM-Bedarf aktiver PHP-FPM-Worker ermitteln (in MB)
ps --no-headers -o rss -C php-fpm8.3 | awk '{total+=$1; count++} END {if (count>0) print int(total/count/1024) " MB"; else print "60 MB (Standard-Richtwert)"}'

# Faustformel zur Berechnung von pm.max_children:
# max_children = (Verfügbarer RAM für PHP in MB) / (Durchschnittlicher RAM pro Worker in MB)

# Rechenbeispiel: 2048 MB zugewiesener RAM bei ca. 60 MB pro Worker
echo $(( 2048 / 60 ))
# Ergebnis: 34

# Nach Konfigurationsänderung den FPM-Dienst neu laden
sudo systemctl reload php8.3-fpm

┌─────────────────────────────────────────────────────────────┐
│                 Nginx & PHP-FPM Request-Flow                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Client-Anfrage (HTTP Port 80 / HTTPS Port 443)            │
│   ▼                                                         │
│   Nginx Webserver                                           │
│   ├── Statische Dateien  ──▶ Direkt ausgeliefert            │
│   └── location ~ \.php$  ──▶ FastCGI-Proxy-Pass             │
│                              │                              │
│                              ▼                              │
│                              Socket: php8.3-fpm.sock        │
│                              │                              │
│                              ▼                              │
│                              PHP-FPM Worker-Prozess         │
│                              │                              │
│                              ▼                              │
│   Client-Antwort         ◀── HTML / JSON Response           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# Neue Server-Block-Konfiguration anlegen
sudo nano /etc/nginx/sites-available/lemp.conf

server {
    listen 80;
    listen [::]:80;
    server_name deine-domain.de www.deine-domain.de;

    root /var/www/html;
    index index.php index.html index.htm;

    # Security Header gegen Clickjacking und MIME-Sniffing
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;

    # Statische Dateien und Verzeichnisabfragen
    location / {
        try_files $uri $uri/ =404;
    }

    # Dynamische Skripte an den PHP 8.3 FastCGI Unix-Socket leiten
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php8.3-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;

        # Buffer-Tuning für dynamische Antworten
        fastcgi_buffer_size 128k;
        fastcgi_buffers 4 256k;
        fastcgi_busy_buffers_size 256k;
    }

    # Zugriff auf versteckte Dateien (.git, .env, .htaccess) strikt blockieren
    location ~ /\. {
        deny all;
        access_log off;
        log_not_found off;
    }
}

# VHost über Symlink aktivieren
sudo ln -s /etc/nginx/sites-available/lemp.conf /etc/nginx/sites-enabled/

# Veralteten Standard-VHost deaktivieren
sudo rm -f /etc/nginx/sites-enabled/default

# Nginx-Syntax zwingend vor dem Reload prüfen
sudo nginx -t

# Nginx-Konfiguration ohne Downtime neu laden
sudo systemctl reload nginx

┌─────────────────────────────────────────────────────────────┐
│             End-to-End Test: Web, App & Datenbank           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   HTTP GET /db-test.php                                     │
│   ▼                                                         │
│   Nginx Server-Block                                        │
│   ▼                                                         │
│   PHP 8.3-FPM (Unix Domain Socket)                          │
│   ▼                                                         │
│   PDO MySQL Verbindung ────▶ MariaDB (127.0.0.1:3306)       │
│                              ├── UTF8mb4 Verbindung         │
│                              ├── Prepared Statement         │
│                              └── Testdaten verarbeiten      │
│   ▼                                                         │
│   Status-Rückmeldung ──────▶ 200 OK (Text/HTML)             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# In die MariaDB-Konsole einloggen
sudo mariadb -u root

CREATE DATABASE lemp_test CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'lemp_user'@'localhost' IDENTIFIED BY 'EinStrengGeheimesPasswort123!';
GRANT ALL PRIVILEGES ON lemp_test.* TO 'lemp_user'@'localhost';
FLUSH PRIVILEGES;
EXIT;

sudo nano /var/www/html/db-test.php

<?php
// /var/www/html/db-test.php - Nur für Verifikationszwecke!
declare(strict_types=1);

$dbConfig = [
    'host'    => '127.0.0.1',
    'dbname'  => 'lemp_test',
    'user'    => 'lemp_user',
    'pass'    => 'EinStrengGeheimesPasswort123!',
    'charset' => 'utf8mb4'
];

$options = [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    PDO::ATTR_EMULATE_PREPARES   => false,
    PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8mb4'
];

try {
    $dsn = "mysql:host={$dbConfig['host']};dbname={$dbConfig['dbname']};charset={$dbConfig['charset']}";
    $pdo = new PDO($dsn, $dbConfig['user'], $dbConfig['pass'], $options);

    // Testtabelle erzeugen
    $pdo->exec("CREATE TABLE IF NOT EXISTS health_check (
        id INT AUTO_INCREMENT PRIMARY KEY,
        checked_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    )");

    // Testdatensatz per Prepared Statement einfügen
    $stmt = $pdo->prepare("INSERT INTO health_check (checked_at) VALUES (NOW())");
    $stmt->execute();

    // Anzahl der Datensätze abrufen
    $count = (int) $pdo->query("SELECT COUNT(*) FROM health_check")->fetchColumn();

    header('Content-Type: text/plain; charset=utf-8');
    echo "LEMP-Stack Health Check: OK
";
    echo "PHP Version: " . PHP_VERSION . "
";
    echo "MariaDB Verbindung: Erfolgreich
";
    echo "Einträge in health_check: {$count}
";

} catch (PDOException $e) {
    http_response_code(500);
    header('Content-Type: text/plain; charset=utf-8');
    echo "LEMP-Stack Health Check: FEHLER
";
    echo "Grund: " . $e->getMessage() . "
";
}

# Dateirechte für den Webserver-Benutzer setzen
sudo chown www-data:www-data /var/www/html/db-test.php
sudo chmod 640 /var/www/html/db-test.php

# Test über die lokale CLI ausführen
curl -s http://localhost/db-test.php

LEMP-Stack Health Check: OK
PHP Version: 8.3.x
MariaDB Verbindung: Erfolgreich
Einträge in health_check: 1

┌─────────────────────────────────────────────────────────────┐
│            Produktionsreifer HTTPS-Request-Flow             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Client-Browser (HTTPS Port 443)                           │
│   ▼                                                         │
│   TLS 1.3 Handshake & Let’s Encrypt Zertifikatsprüfung      │
│   ▼                                                         │
│   Nginx Webserver mit HSTS & Security-Headern               │
│   ▼                                                         │
│   FastCGI Unix Socket (/run/php/php8.3-fpm.sock)            │
│   ▼                                                         │
│   PHP-FPM Worker-Prozess ──▶ MariaDB (127.0.0.1:3306)       │
│   ▼                                                         │
│   Gzip Komprimierung ──────▶ Antwort an Client-Browser      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# Snapd sicherstellen und Certbot klassisch installieren
sudo snap install core && sudo snap refresh core
sudo snap install --classic certbot

# Symlink im Standard-Pfad erzeugen
sudo ln -sf /snap/bin/certbot /usr/bin/certbot

# Zertifikat anfordern und VHost automatisch für HTTPS konfigurieren
sudo certbot --nginx -d deine-domain.de -d www.deine-domain.de

# Ergänzung im Server-Block (Port 443)
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers off;
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;

# HSTS (erzwingt 2 Jahre HTTPS im Browser inklusive Subdomains)
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;

# Konfiguration validieren und Nginx neu laden
sudo nginx -t && sudo systemctl reload nginx

# Automatische Zertifikatserneuerung im Trockenlauf testen
sudo certbot renew --dry-run