So installierst du den LEMP-Stack (Nginx, PHP und MariaDB) unter Debian 12
Der Linux LEMP-Stack ist ein beliebtes Software-Paket für die Entwicklung und das Hosting von Webanwendungen. Es besteht aus vier Hauptkomponenten: Linux, Nginx (ausgesprochen „Engine-X“), MySQL oder MariaDB (eine relationale Datenbank) und PHP (eine beliebte Webprogrammiersprache). In diesem System ist Linux das Betriebssystem und Nginx der Webserver, der HTTP-Anfragen bearbeitet und statische Inhalte wie Bilder und CSS-Dateien bereitstellt. Als Datenbanksystem wird MySQL, oder in unserem Fall MariaDB, verwendet. PHP ist die Skriptsprache, die verwendet wird, um Webinhalte zu erstellen und dynamisch mit der Datenbank zu interagieren. Diese Komponenten bilden eine robuste und skalierbare Umgebung zum Erstellen und Bereitstellen von Websites und Webanwendungen.
In dieser Anleitung lernst du, wie du einen LEMP-Stack auf einem Debian 12 (Bookworm) Server installierst, der vor ein paar Tagen veröffentlicht wurde. Du wirst auch lernen, Anwendungen wie phpMyAdmin zu installieren.
Voraussetzungen
- Ein Server mit Debian 12.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein vollständig qualifizierter Domainname (FQDN) wie
example.com, der auf den Server zeigt. - Die Uncomplicated Firewall (UFW) ist aktiviert und läuft.
- Alles ist auf dem neuesten Stand.
$ sudo apt update && sudo apt upgrade
- Einige wenige Pakete, die dein System benötigt.
$ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring unzip -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – Firewall konfigurieren
Der erste Schritt vor der Installation der Pakete ist die Konfiguration der Firewall, um HTTP- und HTTPS-Verbindungen zuzulassen.
Überprüfe den Status der Firewall.
$ sudo ufw status
Du solltest etwas wie das Folgende sehen.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6)
Erlaube HTTP- und HTTPs-Ports.
$ sudo ufw allow http $ sudo ufw allow https
Überprüfe den Status zur Bestätigung noch einmal.
$ sudo ufw status Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443/tcp ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443/tcp (v6) ALLOW Anywhere (v6)
Schritt 2 – Installiere PHP
Debian 12 wird standardmäßig mit PHP 8.2 ausgeliefert. Du kannst es installieren, indem du den folgenden Befehl ausführst.
$ sudo apt install php-fpm php-cli php-mysql php-mbstring php-xml php-gd
Wir haben die PHP-Erweiterungen MySQL, CLI, GD, Mbstring und XML installiert. Du kannst alle weiteren Erweiterungen nach deinen Bedürfnissen installieren.
Um immer die neueste PHP-Version zu haben oder wenn du mehrere PHP-Versionen installieren willst, füge Ondrejs PHP-Repository hinzu.
Importiere zunächst den PHP-GPG-Schlüssel aus Surys Repository.
$ sudo curl -sSLo /usr/share/keyrings/deb.sury.org-php.gpg https://packages.sury.org/php/apt.gpg
Füge das PHP-Repository von Ondrej Sury hinzu.
$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/deb.sury.org-php.gpg] https://packages.sury.org/php/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/php.list'
Aktualisiere die Liste der System-Repositorys.
$ sudo apt update
Jetzt kannst du eine beliebige PHP-Version installieren.
$ sudo apt install php8.1-fpm php8.1-cli
Überprüfe die installierte Version von PHP.
$ php --version
PHP 8.2.7 (cli) (built: Jun 9 2023 19:37:27) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.2.7, Copyright (c) Zend Technologies
with Zend OPcache v8.2.7, Copyright (c), by Zend Technologies
Schritt 3 – MariaDB installieren
Debian 12 wird standardmäßig nicht mit MySQL ausgeliefert und es wurde noch kein offizielles Paket dafür veröffentlicht. Deshalb werden wir MariaDB dafür verwenden. Auch für MariaDB gibt es kein offizielles Paket für Debian 12, aber es wird mit Debian ausgeliefert. Deshalb installierst du es mit dem folgenden Befehl.
$ sudo apt install mariadb-server
Überprüfe die Version von MySQL.
$ mysql --version mysql Ver 15.1 Distrib 10.11.3-MariaDB, for debian-linux-gnu (x86_64) using EditLine wrapper
Führe das MariaDB-Skript zur sicheren Installation aus.
$ sudo mysql_secure_installation
Du wirst nach dem Root-Passwort gefragt. Drücke die Eingabetaste, denn wir haben kein Passwort dafür festgelegt.
NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
SERVERS IN PRODUCTION USE! PLEASE READ EACH STEP CAREFULLY!
In order to log into MariaDB to secure it, we'll need the current
password for the root user. If you've just installed MariaDB, and
haven't set the root password yet, you should just press enter here.
Enter current password for root (enter for none):
Als nächstes wirst du gefragt, ob du zur Unix-Socket-Authentifizierungsmethode wechseln möchtest. Mit dem Plugin unix_socket kannst du deine Betriebssystem-Zugangsdaten verwenden, um dich mit dem MariaDB-Server zu verbinden. Da du bereits ein geschütztes Root-Konto hast, gibst du n ein, um fortzufahren.
OK, successfully used password, moving on... Setting the root password or using the unix_socket ensures that nobody can log into the MariaDB root user without the proper authorisation. You already have your root account protected, so you can safely answer 'n'. Switch to unix_socket authentication [Y/n] n
Als nächstes wirst du gefragt, ob du dein Root-Passwort ändern möchtest. Unter Debian 12 ist das Root-Passwort eng mit der automatischen Systemwartung verknüpft, daher solltest du es nicht ändern. Gib n ein, um fortzufahren.
... skipping. You already have your root account protected, so you can safely answer 'n'. Change the root password? [Y/n] n
Als nächstes werden dir einige Fragen gestellt, um die Sicherheit von MariaDB zu verbessern. Gib Y ein, um anonyme Benutzer zu entfernen, Remote-Root-Logins zu verbieten, die Testdatenbank zu entfernen und die Berechtigungstabellen neu zu laden.
... skipping. By default, a MariaDB installation has an anonymous user, allowing anyone to log into MariaDB without having to have a user account created for them. This is intended only for testing, and to make the installation go a bit smoother. You should remove them before moving into a production environment. Remove anonymous users? [Y/n] y ... Success! Normally, root should only be allowed to connect from 'localhost'. This ensures that someone cannot guess at the root password from the network. Disallow root login remotely? [Y/n] y ... Success! By default, MariaDB comes with a database named 'test' that anyone can access. This is also intended only for testing, and should be removed before moving into a production environment. Remove test database and access to it? [Y/n] y - Dropping test database... ... Success! - Removing privileges on test database... ... Success! Reloading the privilege tables will ensure that all changes made so far will take effect immediately. Reload privilege tables now? [Y/n] y ... Success! Cleaning up... All done! If you've completed all of the above steps, your MariaDB installation should now be secure. Thanks for using MariaDB!
Du kannst die MariaDB-Shell aufrufen, indem du sudo mysql oder sudo mariadb in die Befehlszeile eingibst.
Schritt 4 – MariaDB konfigurieren
Melde dich in der MariaDB-Shell an.
$ sudo mysql
Erstelle eine Beispieldatenbank.
MariaDB> CREATE DATABASE exampledb;
Erstelle ein SQL-Benutzerkonto.
MariaDB> CREATE USER 'exampleuser'@'localhost' IDENTIFIED BY 'YourPassword2!';
Erteile dem Benutzer alle Rechte für die Datenbank.
MariaDB> GRANT ALL PRIVILEGES ON exampledb.* TO 'exampleuser'@'localhost';
Da wir den Root-Benutzer nicht ändern, solltest du einen weiteren SQL-Benutzer für administrative Aufgaben anlegen, die eine Passwortauthentifizierung erfordern. Wähle ein sicheres Passwort für diesen Benutzer.
MariaDB> GRANT ALL ON *.* TO 'navjot'@'localhost' IDENTIFIED BY 'Yourpassword32!' WITH GRANT OPTION;
Lösche die Benutzerrechte.
MariaDB> FLUSH PRIVILEGES;
Beende die Shell.
MariaDB> exit
Melde dich mit dem neu angelegten Benutzer erneut in der MySQL-Shell an.
$ sudo mysql -u exampleuser -p
Erstelle eine Testtabelle.
MariaDB> CREATE TABLE exampledb.name_list ( sno INT AUTO_INCREMENT, content VARCHAR(255), PRIMARY KEY(sno) );
Füge Testdaten ein.
MariaDB> INSERT INTO exampledb.name_list (content) VALUES ("Navjot");
Wiederhole den obigen Befehl mehrere Male, um weitere Einträge hinzuzufügen. Führe den folgenden Befehl aus, um den Inhalt der Tabelle zu überprüfen.
MariaDB> SELECT * FROM exampledb.name_list;
Du wirst die folgende Ausgabe erhalten.
+-----+---------+ | sno | content | +-----+---------+ | 1 | Navjot | | 2 | Adam | | 3 | Josh | | 4 | Peter | +-----+---------+ 4 rows in set (0.00 sec)
Beende die MySQL-Shell.
MariaDB> exit
Schritt 5 – Nginx installieren
Debian 12 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Importiere den Signierschlüssel von Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Füge das Repository für die stabile Version von Nginx hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/debian `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Aktualisiere die System-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation. Auf Debian-Systemen funktioniert der folgende Befehl nur mit sudo.
$ sudo nginx -v nginx version: nginx/1.24.0
Starte Nginx.
$ sudo systemctl start nginx
Überprüfe den Status des Dienstes.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
Active: active (running) since Thu 2023-06-15 16:33:46 UTC; 1s ago
Docs: https://nginx.org/en/docs/
Process: 2257 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 2258 (nginx)
Tasks: 2 (limit: 1108)
Memory: 1.8M
CPU: 6ms
CGroup: /system.slice/nginx.service
??2258 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??2259 "nginx: worker process"
Schritt 6 – PHP-FPM konfigurieren
Öffne php.ini zum Bearbeiten.
$ sudo nano /etc/php/8.2/fpm/php.ini
Um die Datei-Upload-Größen festzulegen, ändere die Werte der Variablen upload_max_filesize und post_max_size.
upload_max_filesize = 50M ... post_max_size = 50M
Konfiguriere das Speicherlimit von PHP je nach den Ressourcen und Anforderungen deines Servers.
memory_limit = 256M
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Du kannst auch die folgenden Befehle verwenden, um die Änderungen vorzunehmen, ohne die Datei öffnen zu müssen.
$ sudo sed -i 's/post_max_size = 8M/post_max_size = 50M/' /etc/php/8.2/fpm/php.ini $ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 50M/' /etc/php/8.2/fpm/php.ini $ sudo sed -i 's/memory_limit = 128M/memory_limit = 256M/' /etc/php/8.2/fpm/php.ini
Öffne die Datei /etc/php/8.0/fpm/pool.d/www.conf.
$ sudo nano /etc/php/8.2/fpm/pool.d/www.conf
Wir müssen den Unix-Benutzer/die Unix-Gruppe der PHP-Prozesse auf nginx setzen. Finde die Zeilen user=www-data und group=www-data in der Datei und ändere sie in nginx.
... ; Unix user/group of processes ; Note: The user is mandatory. If the group is not set, the default user's group ; will be used. user = nginx group = nginx ...
Finde auch die Zeilen listen.owner=www-data und listen.group=www-data in der Datei und ändere sie in nginx.
listen.owner = nginx listen.group = nginx
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den PHP-fpm-Prozess neu.
$ sudo systemctl restart php8.2-fpm
Schritt 7 – Installiere phpMyAdmin
Lade die Archivdatei von phpMyAdmin für die englische Sprache herunter. Hol dir den Link für die neueste Version von der phpMyAdmin Download-Seite.
$ wget https://files.phpmyadmin.net/phpMyAdmin/5.2.1/phpMyAdmin-5.2.1-english.tar.gz
Erstelle ein öffentliches Verzeichnis für deine Website.
$ sudo mkdir /var/www/html/example.com -p
Entpacke das Archiv in das öffentliche Verzeichnis.
$ sudo tar -xzf phpMyAdmin-5.2.1-english.tar.gz -C /var/www/html/example.com
Wechsle in das öffentliche Verzeichnis.
$ cd /var/www/html/example.com
Benenne das entpackte Verzeichnis in etwas Unbekanntes um, um die Sicherheit zu erhöhen.
$ sudo mv phpMyAdmin-5.2.1-english sm175
Schritt 8 – phpMyAdmin konfigurieren
Kopiere die Beispielkonfigurationsdatei.
$ sudo cp sm175/config.sample.inc.php sm175/config.inc.php
Öffne die Konfigurationsdatei zum Bearbeiten.
$ sudo nano sm175/config.inc.php
Suche die Zeile $cfg['blowfish_secret'] = ''; und gib eine 32-stellige Zufallszeichenfolge für die Cookie-basierte Authentifizierung ein.
Du kannst den Online-Blowfish-Generator von phpSolved verwenden oder ihn über die Kommandozeile eingeben.
Kopiere den Wert und füge ihn wie gezeigt ein.
$cfg['blowfish_secret'] = 'Tc/HfLPBOAPxJ-rhQP}HJoZEK69c3j:m';
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Ändere den Eigentümer der Website und von phpMyAdmin auf den Nginx-Server.
$ sudo chown -R nginx:nginx /var/www/html/example.com
Lösche das phpMyAdmin Setup-Verzeichnis.
$ sudo rm -rf /var/www/html/example.com/sm175/setup
Schritt 9 – Opcache konfigurieren
Opcache ist das Caching-System von PHP. Es speichert vorkompilierten Skript-Bytecode im Speicher, so dass eine Seite bei jedem Besuch schneller geladen wird. Opcache ist standardmäßig installiert. Um das zu überprüfen, überprüfe die PHP-Version.
$ php --version
PHP 8.2.7 (cli) (built: Jun 9 2023 19:37:27) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.2.7, Copyright (c) Zend Technologies
with Zend OPcache v8.2.7, Copyright (c), by Zend Technologies
Das zeigt uns, dass Opcache installiert und verfügbar ist. Falls er hier nicht angezeigt wird, kannst du ihn manuell installieren, indem du den folgenden Befehl ausführst.
$ sudo apt install php-opcache
Um die Opcache-Einstellungen zu ändern, öffne die Datei /etc/php/8.2/fpm/conf.d/10-opcache.ini zur Bearbeitung.
$ sudo nano /etc/php/8.2/fpm/conf.d/10-opcache.ini
Die folgenden Einstellungen sollten dir den Einstieg in die Nutzung von Opcache erleichtern und werden im Allgemeinen für eine gute Leistung empfohlen. Du kannst ihn aktivieren, indem du die folgenden Zeilen am Ende hinzufügst.
opcache.enable_cli=1 opcache.memory_consumption=128 opcache.interned_strings_buffer=8 opcache.max_accelerated_files=4000 opcache.revalidate_freq=60
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte PHP-FPM neu.
$ sudo systemctl restart php8.2-fpm
Schritt 10 – Certbot für SSL installieren
Wir müssen Certbot installieren, um die von Let’s Encrypt angebotenen kostenlosen SSL-Zertifikate zu generieren.
Du kannst Certbot entweder über das Repository von Debian installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Debian 12 ist Snapd noch nicht installiert. Installiere das Snapd-Paket.
$ sudo apt install snapd
Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core $ sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe, ob Certbot ordnungsgemäß funktioniert.
$ certbot --version certbot 2.6.0
Schritt 11 – Teste eine Demo-Site
Erstelle die Seite
Erstelle und öffne eine Testseite zum Bearbeiten.
$ sudo nano /var/www/html/example.com/index.php
Füge den folgenden Code in die Seite ein.
<?php
$user = "exampleuser";
$password = "YourPassword2!";
$database = "exampledb";
$table = "name_list";
try {
$db = new PDO("mysql:host=localhost;dbname=$database", $user, $password);
echo "<h2>Members List</h2><ol>";
foreach($db->query("SELECT content FROM $table") as $row) {
echo "<li>" . $row['content'] . "</li>";
}
echo "</ol>";
} catch (PDOException $e) {
print "Error!: " . $e->getMessage() . "<br/>";
die();
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle ein SSL-Zertifikat
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erstellen.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Überprüfe den Certbot-Erneuerungsplanerdienst.
$ sudo systemctl list-timers
Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.
NEXT LEFT LAST PASSED UNIT ACTIVATES ..... Sun 2023-02-26 06:32:00 UTC 9h left Sat 2023-02-25 18:04:05 UTC 2h 59min ago snap.certbot.renew.timer snap.certbot.renew.service Sun 2023-02-26 06:43:20 UTC 9h left Sat 2023-02-25 10:49:23 UTC 10h ago apt-daily-upgrade.timer apt-daily-upgrade.service Sun 2023-02-26 09:00:06 UTC 11h left Sat 2023-02-25 20:58:06 UTC 5min ago apt-daily.timer apt-daily.service
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Nginx konfigurieren
Erstelle und öffne die Datei /etc/nginx/conf.d/example.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/example.conf
Füge den folgenden Code in die Datei ein.
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name example.com;
access_log /var/log/nginx/example.com.access.log;
error_log /var/log/nginx/example.com.error.log;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
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;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
root /var/www/html/example.com;
index index.php index.html;
location / {
try_files $uri $uri/ /index.php?$query_string;
}
# Pass PHP Scripts To FastCGI Server
location ~ \.php$ {
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass unix:/run/php/php8.2-fpm.sock; #depends on PHP versions
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
location ~ /\.(?!well-known).* {
deny all;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name example.com;
return 301 https://$host$request_uri;
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne die Datei /etc/nginx/nginx.conf zur Bearbeitung.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe deine Nginx-Konfiguration.
$ sudo nginx -t
Wenn du keine Fehler siehst, bist du startklar. Starte den Nginx-Server.
$ sudo systemctl start nginx
Rufe deine Website auf, indem du https://example.com in deinem Browser aufrufst. Du siehst dann die folgende Seite.
Du kannst auf deine phpMyAdmin-Installation zugreifen, indem du die URL https://example.com/sm175 in deinem Browser aufrufst. Du kannst entweder deinen administrativen Benutzer oder den zuvor erstellten Benutzer eingeben, um dich einzuloggen.
Fazit
Damit ist unser Tutorium abgeschlossen, in dem du gelernt hast, wie du einen LEMP-Stack auf einem Debian 12-Server einrichtest und eine Demoseite erstellst. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.