Categories: Anleitungen

Wie installiere ich Nginx mit PHP und MySQL (LEMP Stack) auf Ubuntu 22.04

Der LEMP-Software-Stack ist eine Gruppe von Open-Source-Software, die es einem Server ermöglicht, dynamische Websites und in PHP geschriebene Anwendungen zu hosten. Es ist ein Akronym für Linux, Nginx (ausgesprochen als Engine-X), MySQLund PHP.

Diese Anleitung zeigt dir, wie du einen LEMP Stack auf einem Ubuntu 22.04 Server installierst. Außerdem lernst du, wie du Anwendungen wie phpMyAdmin installierst.

Voraussetzungen

  • Ein Server mit Ubuntu 22.04.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Die Uncomplicated Firewall(UFW) ist aktiviert und läuft.
  • Alles ist auf dem neuesten Stand.
    $ sudo apt update && sudo apt upgrade
    

Schritt 1 – Firewall konfigurieren

Der erste Schritt vor der Installation der Pakete besteht darin, die Firewall so zu konfigurieren, dass HTTP- und HTTPS-Verbindungen zugelassen werden.

Ü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

Ubuntu 22.04 wird standardmäßig mit PHP 8.1 ausgeliefert. Du kannst es installieren, indem du den folgenden Befehl ausführst.

$ sudo apt install php-fpm php-cli php-mysqlnd 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.

Wenn du immer die neueste PHP-Version haben möchtest oder mehrere PHP-Versionen installieren willst, füge Ondrejs PHP-Repository hinzu.

Füge Ondrejs PHP-Repository hinzu.

$ sudo add-apt-repository ppa:ondrej/php

Jetzt kannst du jede PHP-Version installieren.

$ sudo apt install php8.0-fpm php8.0-cli

Überprüfe die installierte Version von PHP.

$ php --version
PHP 8.1.2 (cli) (built: Jun 13 2022 13:52:54) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies
    with Zend OPcache v8.1.2, Copyright (c), by Zend Technologies

Schritt 3 – Installiere MySQL

Ubuntu 22.04 wird mit der neuesten Version von MySQL ausgeliefert. Du kannst sie mit einem einzigen Befehl installieren.

$ sudo apt install mysql-server

Überprüfe die Version von MySQL.

$ mysql --version
mysql  Ver 8.0.29-0ubuntu0.22.04.2 for Linux on x86_64 ((Ubuntu))

Dieser Schritt ist für die MySQL-Versionen 8.0.28 und höher notwendig. Rufe die MySQL-Shell auf.

$ sudo mysql

Führe den folgenden Befehl aus, um das Passwort für deinen Root-Benutzer festzulegen. Achte darauf, dass es eine Mischung aus Zahlen, Groß- und Kleinbuchstaben und Sonderzeichen enthält.

mysql> ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'YourPassword12!';

Beende die Shell.

mysql> exit

Führe das Skript MySQL secure install aus.

$ sudo mysql_secure_installation

Du wirst aufgefordert, die Validate Password Component zu installieren. Sie prüft die Stärke der in MySQL verwendeten Passwörter. Drücke Y, um sie zu installieren.

Als Nächstes wirst du aufgefordert, die Stufe der Passwortüberprüfung festzulegen. Wähle 2, da dies die stärkste Stufe ist.

Als nächstes gibst du dein Root-Passwort ein. Drücke N, um es nicht zu ändern.

Drücke Y, um anonyme Benutzer zu entfernen, Remote-Root-Logins zu verbieten, die Testdatenbank zu entfernen und die Berechtigungstabellen neu zu laden.

Schritt 4 – MySQL konfigurieren

Melde dich in der MySQL-Shell an. Gib dein Root-Passwort ein, wenn du dazu aufgefordert wirst.

$ sudo mysql -u root -p

Erstelle eine Beispieldatenbank.

mysql> CREATE DATABASE exampledb;

Erstelle ein SQL-Benutzerkonto.

mysql> CREATE USER 'exampleuser'@'localhost' IDENTIFIED BY 'YourPassword2!';

Erteile dem Benutzer alle Rechte für die Datenbank.

mysql> GRANT ALL PRIVILEGES ON exampledb.* TO 'exampleuser'@'localhost';

Lösche die Benutzerrechte.

mysql> FLUSH PRIVILEGES;

Beende die Shell.

mysql> exit

Melde dich mit dem neu angelegten Benutzer erneut in der MySQL-Shell an.

$ sudo mysql -u exampleuser -p

Erstelle eine Testtabelle.

mysql> CREATE TABLE exampledb.name_list ( sno INT AUTO_INCREMENT, content VARCHAR(255), PRIMARY KEY(sno) );

Füge Testdaten ein.

mysql> 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.

mysql> 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.

mysql> exit

Schritt 5 – Nginx installieren

Ubuntu 22.04 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 arch=amd64] \
http://nginx.org/packages/ubuntu `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.

$ nginx -v
nginx version: nginx/1.22.0

Schritt 6 – PHP-FPM konfigurieren

Öffne php.ini zum Bearbeiten.

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

Ändere die Werte der Variablen upload_max_filesize und post_max_size, um die Datei-Upload-Größen festzulegen.

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.

Öffne die Datei /etc/php/8.0/fpm/pool.d/www.conf.

$ sudo nano /etc/php/8.0/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.1-fpm

Schritt 7 – Installiere phpMyAdmin

Lade die Archivdatei von phpMyAdmin für die englische Sprache herunter.

$ wget https://files.phpmyadmin.net/phpMyAdmin/5.2.0/phpMyAdmin-5.2.0-english.tar.gz

Erstelle ein öffentliches Verzeichnis für die Website.

$ sudo mkdir /var/www/html/example.com -p

Entpacke das Archiv in das öffentliche Verzeichnis.

$ sudo tar -xzvf phpMyAdmin-5.2.0-english.tar.gz -C /var/www/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.0-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 Setup-Verzeichnis von phpMyAdmin.

$ 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.1.2 (cli) (built: Jun 13 2022 13:52:54) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.1.2, Copyright (c) Zend Technologies
    with Zend OPcache v8.1.2, 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.1/fpm/conf.d/10-opcache.ini zur Bearbeitung.

$ sudo nano /etc/php/8.1/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 eine Konfiguration aktivieren, indem du sie auskommentierst, indem du das Semikolon vor der Konfiguration entfernst.

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.

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 aus dem Ubuntu-Repository installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. 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

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 darin 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 --standalone --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 -out /etc/ssl/certs/dhparam.pem 4096

Öffne die Datei /etc/letsencrypt/renewal/example.com.conf zur Bearbeitung.

$ sudo nano /etc/letsencrypt/renewal/example.com.conf

Füge den folgenden Code am Ende der Datei ein.

pre_hook = systemctl stop nginx
post_hook = systemctl start nginx

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Wir haben das SSL-Zertifikat mit der Standalone-Option von Certbot erstellt. Es lässt seinen Webserver laufen, um das Zertifikat zu erstellen, was bedeutet, dass Nginx während der Erneuerung abgeschaltet sein sollte. Die Befehle pre_hook und post_hook werden vor und nach der Erneuerung ausgeführt, um den Nginx-Server automatisch abzuschalten und neu zu starten, sodass kein manuelles Eingreifen erforderlich ist.

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf des Prozesses durch.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, ist alles in Ordnung. 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.1-fpm.sock;
        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 Root-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 Ubuntu 22.04-Server einrichtest und eine Demoseite erstellst. Wenn du Fragen hast, schreibe sie unten in die Kommentare.

howtoforge

Recent Posts

So installierst du das Datenbankverwaltungstool Adminer unter Ubuntu 22.04

Adminer (ehemals phpMinAdmin) ist ein voll funktionsfähiges Datenbankverwaltungstool, das sowohl RDBMS (Relational Database Management System)…

53 Jahren ago

So installierst du das Cacti Monitoring Tool auf Ubuntu 22.04

Cacti ist ein in PHP geschriebenes Open-Source-Tool zur Netzwerküberwachung und Erstellung von Grafiken. In diesem…

53 Jahren ago

So installierst du Apache Tomcat unter Ubuntu 22.04

Apache Tomcat oder "Tomcat" ist ein freier und quelloffener Java-Servlet-Container für Java-Code und -Anwendungen. In…

53 Jahren ago

So richtest du die MariaDB Master-Master-Replikation unter Debian 11 ein

In diesem Tutorial wird erklärt, wie man die MariaDB Master-Master-Replikation auf Debian 11-Servern einrichtet. Außerdem…

53 Jahren ago

So installierst du Joomla mit Apache und kostenlosem Let’s Encrypt SSL auf Alma Linux 8

Joomla ist ein kostenloses, quelloffenes und eines der beliebtesten Content Management Systeme. In diesem Lernprogramm…

53 Jahren ago

Wie man eine Website in ISPConfig hinzufügt

ISPConfig ist ein Hosting-Kontrollpanel für Linux-Server, das Funktionen zur Verwaltung von Websites, Datenbanken, FTP- und…

53 Jahren ago