Physical Address

304 North Cardinal St.
Dorchester Center, MA 02124

Ubuntu 24.04: LEMP-Stack installieren

Ubuntu 24.04: LEMP-Stack installieren
Navigation

In dieser Anleitung führe ich dich Schritt für Schritt durch die Installation und Konfiguration eines LEMP-Stacks (Linux, Nginx, MySQL/MariaDB, PHP) auf Ubuntu 24.04 LTS. Zusätzlich werden wir weitere nützliche Tools und Sicherheitsmaßnahmen einrichten, um eine robuste und leistungsfähige Webserver-Umgebung zu schaffen.

Als Anfänger ist es wichtig zu verstehen, dass jeder Schritt sorgfältig ausgeführt werden sollte. Wir werden jeden Befehl und jede Konfiguration erklären, damit du nicht nur die Schritte befolgst, sondern auch verstehst, warum wir sie durchführen

Grundvoraussetzungen

Bevor wir beginnen, stelle sicher, dass du Folgendes hast:

  • Einen Server oder virtuellen Server mit Ubuntu 24.04 LTS
  • Root-Zugriff oder einen Benutzer mit sudo-Rechten
  • Eine stabile Internetverbindung

Systemaktualisierung

ShellScript
sudo apt-get update
sudo apt-get upgrade -y

Installation wichtiger Pakete

ShellScript
sudo apt-get install -y fail2ban ufw curl wget htop nano ssh snapd

Diese Befehle aktualisieren dein System und installieren wichtige Tools:

  • fail2ban: Schützt vor Brute-Force-Angriffen
  • ufw: Eine benutzerfreundliche Firewall
  • curl und wget: Zum Herunterladen von Dateien
  • htop: Ein interaktiver Prozess-Viewer
  • nano: Ein einfacher Texteditor
  • ssh: Für sichere Fernzugriffe
  • snapd: Paketmanager für Snap-Pakete
Weitere Basis Pakete installieren
ShellScript
apt-get install -y build-essential curl nano wget lftp unzip bzip2 arj nomarch lzop htop openssl gcc git binutils libmcrypt4 libpcre3-dev make python3 python3-pip supervisor unattended-upgrades whois zsh imagemagick uuid-runtime net-tools zip dirmngr apt-transport-https

Nginx installieren und konfigurieren

Nginx ist unser Webserver. Die Installation erfolgt mit folgendem Befehl:

ShellScript
sudo apt install nginx -y
sudo systemctl start nginx
sudo systemctl enable nginx
Konfiguriere Nginx für bessere Leistung:
ShellScript
sudo nano /etc/nginx/nginx.conf

Ändere folgende Zeilen:

Nginx
user www-data;
worker_processes auto;
gzip on;
server_tokens off;

# Am Ende der Datei hinzufügen:
include /etc/nginx/conf.d/*.conf;
include /etc/nginx/sites-enabled/*;

Diese Änderungen optimieren Nginx für bessere Leistung und Sicherheit.

Gzip für Nginx konfigurieren

Gzip-Komprimierung verbessert die Übertragungsgeschwindigkeit:

ShellScript
sudo nano /etc/nginx/conf.d/gzip.conf

Füge folgenden Inhalt hinzu:

ShellScript
gzip_comp_level 5;
gzip_min_length 256;
gzip_proxied any;
gzip_vary on;

gzip_types
application/atom+xml
application/javascript
application/json
application/rss+xml
application/vnd.ms-fontobject
application/x-web-app-manifest+json
application/xhtml+xml
application/xml
font/otf
font/ttf
image/svg+xml
image/x-icon
text/css
text/plain;
Nginx SSL-Sicherheit verbessern

Generiere eine stärkere Diffie-Hellman-Gruppe für SSL:

ShellScript
sudo openssl dhparam -out /etc/nginx/dhparams.pem 2048

Dies verbessert die SSL-Sicherheit deines Nginx-Servers.

Nginx-Einstellungen optimieren

Passe die Nginx-Konfiguration für bessere Leistung an:

YAML
sudo sed -i "s/worker_processes.*/worker_processes auto;/" /etc/nginx/nginx.conf
sudo sed -i "s/# multi_accept.*/multi_accept on;/" /etc/nginx/nginx.conf
sudo sed -i "s/# server_names_hash_bucket_size.*/server_names_hash_bucket_size 128;/" /etc/nginx/nginx.conf
sudo sed -i "s/# server_tokens off/server_tokens off/" /etc/nginx/nginx.conf

Diese Änderungen optimieren Nginx für bessere Leistung und Sicherheit.

Nginx Neustarten
ShellScript
sudo systemctl restart nginx

PHP installieren und konfigurieren

PHP ist unsere Skriptsprache:

ShellScript
apt install -y php8.3-cli php8.3-dev php8.3-pgsql php8.3-sqlite3 php8.3-gd php8.3-curl php8.3-memcached php8.3-imap php8.3-mysql php8.3-mbstring php8.3-xml php8.3-imagick php8.3-zip php8.3-bcmath php8.3-soap php8.3-intl php8.3-readline php8.3-common php8.3-pspell php8.3-tidy php8.3-xsl php8.3-opcache php8.3-apcu

Konfiguriere PHP für bessere Leistung und Sicherheit:

ShellScript
sudo nano /etc/php/8.3/fpm/php.ini

Ändere folgende Zeilen:

PHP
error_reporting = E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED
display_errors = Off
memory_limit = 512M
upload_max_filesize = 256M
post_max_size = 256M
date.timezone = Europe/Budapest

Optimiere PHP-FPM-Pool-Einstellungen:

ShellScript
sudo nano /etc/php/8.3/fpm/pool.d/www.conf

Ändere folgende Zeilen:

YAML
listen.mode = 0666
request_terminate_timeout = 60
pm.max_children = 70
pm.start_servers = 20
pm.min_spare_servers = 20
pm.max_spare_servers = 35
pm.max_requests = 500
PHP-FPM-Einstellungen optimieren

Passe die PHP-FPM-Einstellungen für Produktionsumgebungen an:

YAML
sudo sed -i "s/error_reporting = .*/error_reporting = E_ALL \& ~E_NOTICE \& ~E_STRICT \& ~E_DEPRECATED/" /etc/php/8.3/fpm/php.ini
sudo sed -i "s/display_errors = .*/display_errors = Off/" /etc/php/8.3/fpm/php.ini
sudo sed -i "s/memory_limit = .*/memory_limit = 512M/" /etc/php/8.3/fpm/php.ini
sudo sed -i "s/upload_max_filesize = .*/upload_max_filesize = 256M/" /etc/php/8.3/fpm/php.ini
sudo sed -i "s/post_max_size = .*/post_max_size = 256M/" /etc/php/8.3/fpm/php.ini
sudo sed -i "s/;date.timezone.*/date.timezone = UTC/" /etc/php/8.3/fpm/php.ini

Diese Einstellungen optimieren PHP für Produktionsumgebungen, indem sie Fehlerausgaben unterdrücken und Ressourcenlimits erhöhen.

 PHP-FPM-Pool-Einstellungen anpassen

Optimiere die PHP-FPM-Pool-Konfiguration:

YAML
sudo sed -i "s/;listen\.mode =.*/listen.mode = 0666/" /etc/php/8.3/fpm/pool.d/www.conf
sudo sed -i "s/;request_terminate_timeout =.*/request_terminate_timeout = 60/" /etc/php/8.3/fpm/pool.d/www.conf
sudo sed -i "s/pm\.max_children =.*/pm.max_children = 70/" /etc/php/8.3/fpm/pool.d/www.conf
sudo sed -i "s/pm\.start_servers =.*/pm.start_servers = 20/" /etc/php/8.3/fpm/pool.d/www.conf
sudo sed -i "s/pm\.min_spare_servers =.*/pm.min_spare_servers = 20/" /etc/php/8.3/fpm/pool.d/www.conf
sudo sed -i "s/pm\.max_spare_servers =.*/pm.max_spare_servers = 35/" /etc/php/8.3/fpm/pool.d/www.conf
sudo sed -i "s/;pm\.max_requests =.*/pm.max_requests = 500/" /etc/php/8.3/fpm/pool.d/www.conf

Denk daran, nach diesen Änderungen die betroffenen Dienste neu zu starten:

ShellScript
sudo systemctl restart php8.3-fpm
sudo systemctl restart nginx

Nginx für PHP konfigurieren

Erstelle eine Nginx-Konfiguration für PHP:

ShellScript
sudo nano /etc/nginx/sites-available/default

Ersetze den Inhalt durch:

Nginx
server {
    listen 80 default_server;
    listen [::]:80 default_server;
    root /var/www/html;
    index index.php index.html index.htm;
    server_name _;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        fastcgi_pass unix:/var/run/php/php8.3-fpm.sock;
        fastcgi_index index.php;
        include fastcgi_params;
    }

    location ~ /\.ht {
        deny all;
    }
}

Memcached installieren

Memcached verbessert die Performance durch Caching:

ShellScript
sudo apt install memcached libmemcached-tools -y
sudo sed -i 's/-l 0.0.0.0/-l 127.0.0.1/' /etc/memcached.conf
sudo systemctl restart memcached

Node.js installieren

Node.js wird oft für moderne Webanwendungen benötigt:

ShellScript
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash
source ~/.bashrc
nvm install 20

phpMyAdmin installieren

phpMyAdmin erleichtert die Datenbankverwaltung:

ShellScript
cd /var/www
sudo composer create-project phpmyadmin/phpmyadmin
sudo cp /var/www/phpmyadmin/config.sample.inc.php /var/www/phpmyadmin/config.inc.php
sudo mysql -u root -p < /var/www/phpmyadmin/sql/create_tables.sql
sudo sed -i "s/\$cfg\['blowfish_secret'\] = '';.*/\$cfg\['blowfish_secret'\] = '$(uuidgen | tr -d -)';/" /var/www/phpmyadmin/config.inc.php
sudo mkdir /var/www/phpmyadmin/tmp
sudo chown www-data:www-data /var/www/phpmyadmin/tmp
sudo ln -s /var/www/phpmyadmin/ /var/www/html/phpmyadmin

MongoDB installieren (optional)

Für NoSQL-Datenbanken:

ShellScript
curl -fsSL https://pgp.mongodb.com/server-7.0.asc | sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg --dearmor
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
sudo apt update
sudo apt install -y mongodb-org
sudo pecl install mongodb
echo "extension=mongodb.so" | sudo tee /etc/php/8.3/fpm/conf.d/30-mongodb.ini
echo "extension=mongodb.so" | sudo tee /etc/php/8.3/cli/conf.d/30-mongodb.ini

Redis installieren

Redis ist ein schneller In-Memory-Datenspeicher:

ShellScript
sudo apt install redis-server -y
sudo sed -i "s/supervised.*/supervised systemd/" /etc/redis/redis.conf
sudo systemctl restart redis.service

Let’s Encrypt Certbot installieren

Let’s Encrypt ist ein kostenloser, automatisierter und offener Zertifizierungsdienst, der vonder gemeinnützigen Internet Security Research Group (ISRG) bereitgestellt wird. Certbot ist ein Tool, das die Beantragung und Erneuerung von Let’s Encrypt-Zertifikatenautomatisiert.

Installiere Certbot über Snap:
ShellScript
sudo snap install --classic certbot

Der --classic Parameter erlaubt Certbot, außerhalb der üblichen Snap-Einschränkungen zu arbeiten.

Erstelle einen symbolischen Link, damit Certbot systemweit verfügbar ist:

ShellScript
sudo ln -s /snap/bin/certbot /usr/bin/certbot
Beantrage ein SSL-Zertifikat für deine Domain (ersetze "deine-domain.com" durch deine tatsächliche Domain):
ShellScript
sudo certbot --nginx -d deine-domain.com -d www.deine-domain.com

Dieser Befehl wird dich durch den Prozess der Zertifikatsbeantragung führen und Nginx automatisch für die Verwendung des Zertifikats konfigurieren.

Teste die automatische Erneuerung:

ShellScript
sudo certbot renew --dry-run

Dieser Befehl simuliert den Erneuerungsprozess, ohne tatsächlich Änderungen vorzunehmen.

Konfiguriere einen Cronjob
ShellScript
sudo crontab -e

Füge folgende Zeile hinzu:

CoffeeScript
0 12 * * * /usr/bin/certbot renew --quiet

Dies versucht täglich um 12 Uhr mittags, das Zertifikat zu erneuern, falls es in weniger als 30 Tagen abläuft.

Überprüfe die Nginx-Konfiguration für SSL:
ShellScript
sudo nano /etc/nginx/sites-available/default

Stelle sicher, dass folgende Zeilen vorhanden sind:

Nginx
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
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;

Aktiviere OCSP Stapling für verbesserte Leistung und Privatsphäre:

Nginx
ssl_stapling on;
ssl_stapling_verify on;
resolver 8.8.8.8 8.8.4.4 valid=300s;
resolver_timeout 5s;

Konfiguriere HSTS (HTTP Strict Transport Security) für zusätzliche Sicherheit:

Nginx
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

Starte Nginx neu, um die Änderungen zu übernehmen:

ShellScript
sudo systemctl restart nginx

FTP-Server einrichten (Pure-FTPd)

FTP ermöglicht den sicheren Dateitransfer. Wir installieren und konfigurieren Pure-FTPd direkt aus dem Quellcode, da die offiziellen Ubuntu-Pakete veraltet sind.

Generiere TLS-Zertifikate für sicheren FTP-Zugang:

ShellScript
sudo openssl dhparam -out /etc/ssl/private/pure-ftpd-dhparams.pem 2048
sudo openssl req -x509 -days 36500 -nodes -newkey rsa:2048 -sha256 -keyout /etc/ssl/private/pure-ftpd.pem -out /etc/ssl/private/pure-ftpd.pem
sudo chmod 600 /etc/ssl/private/*.pem

Lade Pure-FTPd herunter, kompiliere und installiere es:

ShellScript
wget https://download.pureftpd.org/pub/pure-ftpd/releases/pure-ftpd-1.0.50.tar.gz -O /tmp/pure-ftpd-1.0.50.tar.gz
cd /tmp; tar -xf pure-ftpd-1.0.50.tar.gz; cd pure-ftpd-1.0.50;
./configure --prefix=/usr --with-everything --with-tls --with-certfile=/etc/ssl/private/pure-ftpd.pem
make
sudo make install
cd /tmp; rm -rf ./pure-*

Konfiguriere Pure-FTPd:

ShellScript
sudo sed -i "s/BrokenClientsCompatibility .*/BrokenClientsCompatibility yes/" /etc/pure-ftpd.conf
sudo sed -i "s/NoAnonymous .*/NoAnonymous yes/" /etc/pure-ftpd.conf
sudo sed -i "s/# PureDB  /PureDB/" /etc/pure-ftpd.conf
sudo sed -i "s/MinUID .*/MinUID 33/" /etc/pure-ftpd.conf
sudo sed -i "s/# TLS /TLS /" /etc/pure-ftpd.conf
sudo sed -i "s/# PassivePortRange .*/PassivePortRange 50000 50099/" /etc/pure-ftpd.conf
sudo touch /etc/pureftpd.passwd
sudo pure-pw mkdb

Diese Einstellungen deaktivieren anonyme Logins, erlauben Benutzern in der www-data-Gruppe den Zugriff, aktivieren TLS und setzen den Portbereich für passive Verbindungen.

Erstelle den systemd-Service für Pure-FTPd:

ShellScript
sudo cat > /etc/systemd/system/pure-ftpd.service << EOF
[Unit]
Description=Pure-FTPd FTP server
After=network-online.target

[Service]
Type=forking
ExecStart=/usr/sbin/pure-ftpd /etc/pure-ftpd.conf
PIDFile=/var/run/pure-ftpd.pid
Restart=always
RestartSec=1

[Install]
WantedBy=multi-user.target
EOF

Aktiviere und starte den Pure-FTPd-Dienst:

ShellScript
sudo systemctl --system daemon-reload
sudo systemctl enable pure-ftpd
sudo systemctl start pure-ftpd

Diese erweiterte Konfiguration bietet eine sichere und aktuelle FTP-Lösung. Beachte, dass die Verwendung von selbstsignierten Zertifikaten zu Warnungen in FTP-Clients führen kann. In einer Produktionsumgebung solltest du erwägen, ein vertrauenswürdiges SSL-Zertifikat zu verwenden.

Firewall einrichten

Eine korrekt konfigurierte Firewall ist entscheidend für die Sicherheit deines Servers. Wir verwenden UFW (Uncomplicated Firewall), eine benutzerfreundliche Schnittstelle füriptables.

Stelle sicher, dass UFW installiert ist:

ShellScript
ufw status

Falls nicht installiert:

ShellScript
sudo apt install ufw -y

Setze die Standardregeln:

ShellScript
sudo ufw default deny incoming
sudo ufw default allow outgoing

Diese Regeln blockieren standardmäßig allen eingehenden und erlauben allen ausgehenden Verkehr.

Erlaube SSH-Verbindungen (wichtig, um nicht ausgesperrt zu werden):

ShellScript
sudo ufw allow 22/tcp

Erlaube HTTP und HTTPS:

ShellScript
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

Wenn du FTP verwendest, erlaube die entsprechenden Ports:

ShellScript
sudo ufw allow 21/tcp
sudo ufw allow 50000:50099/tcp

# Erlaube ausgehenden FTP-Datenverkehr

sudo ufw allow out 20/tcp

Wenn du andere Dienste wie MySQL von außen zugänglich machen möchtest (was normalerweise nicht empfohlen wird), füge die entsprechenden Regeln hinzu:

ShellScript
sudo ufw allow 3306/tcp
Aktiviere die Firewall:
ShellScript
sudo ufw enable

Überprüfe den Status der Firewall:

ShellScript
sudo ufw status verbose
Konfiguriere Logging

Optional, aber empfohlen für die Überwachung:

ShellScript
sudo ufw logging on

Für zusätzliche Sicherheit kannst du Rate-Limiting für SSH-Verbindungen einrichten:

ShellScript
sudo ufw limit ssh/tcp

Dies begrenzt die Anzahl der SSH-Verbindungsversuche und hilft, Brute-Force-Angriffe zu verhindern.

Wenn dein Server IPv6 unterstützt, stelle sicher, dass UFW für IPv6 konfiguriert ist:

ShellScript
sudo nano /etc/default/ufw

Setze IPV6=yes in dieser Datei.

Konfiguriere fail2ban
ShellScript
# Falls fail2ban noch nicht installiert ist

sudo apt install fail2ban -y
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

Erstelle eine benutzerdefinierte fail2ban-Konfiguration für SSH:

ShellScript
sudo nano /etc/fail2ban/jail.local

Füge folgende Konfiguration hinzu:

ShellScript
[sshd]
enabled = true
port = ssh
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 3600
Fail2Ban für Pure-FTPd aktivieren
ShellScript
sudo cat > /etc/fail2ban/jail.d/pure-ftpd.conf << EOF
[pure-ftpd]
enabled=true
maxretry=5
EOF

Starte fail2ban neu:

ShellScript
sudo systemctl restart fail2ban

Diese erweiterte Firewall-Konfiguration bietet eine solide Grundlage für die Sicherheit deines Servers. Sie erlaubt nur den notwendigen Datenverkehr, schützt vor häufigen Angriffsversuchen und gibt dir die Flexibilität, bei Bedarf weitere Regeln hinzuzufügen.

Denk daran, die Firewall-Regeln regelmäßig zu überprüfen und anzupassen, besonders wenn du neue Dienste hinzufügst oder Änderungen an deiner Serverinfrastruktur vornimmst. Die Kombination von UFW und fail2ban bietet eine robuste Verteidigungslinie gegen viele gängige Netzwerkangriffe.

Logrotate für Nginx-Logs

ShellScript
sudo nano /etc/logrotate.d/vhost

Füge folgenden Inhalt hinzu:

YAML
/var/www/logs/*.log {
 rotate 10
 daily
 compress
 delaycompress
 sharedscripts
 
 postrotate
 systemctl reload nginx > /dev/null
 endscript
}

Unbeaufsichtigte Sicherheitsupdates

ShellScript
sudo nano /etc/apt/apt.conf.d/10periodic

Füge folgenden Inhalt hinzu:

ShellScript
APT::Periodic::Update-Package-Lists "1";
APT::Periodic::Download-Upgradeable-Packages "1";
APT::Periodic::AutocleanInterval "7";
APT::Periodic::Unattended-Upgrade "1";

Überprüfungen und Neustart

Überprüfe alle Konfigurationen auf Fehler und starte dann deinen Server neu:

ShellScript
sudo reboot

Nach dem Neustart, überprüfe den Status aller Dienste:

ShellScript
sudo systemctl --failed
sudo netstat -tulpn

Abschluss

Glückwunsch! Du hast erfolgreich einen umfassenden LEMP-Stack auf Ubuntu 24.04 LTS installiert und konfiguriert. Dein Server ist nun bereit für das Hosting von Webanwendungen, mit einer robusten Konfiguration für Leistung und Sicherheit.

Denk daran, regelmäßig Backups durchzuführen und dein System auf dem neuesten Stand zu halten. Überwache die Leistung und Sicherheit deines Servers kontinuierlich und passe die Konfigurationen bei Bedarf an.

Diese detaillierte Anleitung bietet dir eine solide Grundlage für deine Webhosting-Bedürfnisse. Bei Fragen oder Problemen zögere nicht, die Dokumentation der jeweiligen Software zu konsultieren oder professionelle Hilfe in Anspruch zu nehmen.

Schlagwörter

Ähnliche Beiträge

Kommentar verfassen