HowtoForge

Wie man Nginx mit PHP und MariaDB (LEMP Stack) mit Opcache, Redis und Let’s Encrypt auf Ubuntu installiert

von ·

Das Akronym „LEMP“ steht für eine Gruppe von Software, die in der Regel zusammen installiert wird, damit ein Server dynamische Websites und Webanwendungen hosten kann. Der Begriff ist eigentlich ein Akronym, das für vier Hauptkomponenten steht:

  1. Linux: Das Betriebssystem. Linux ist ein beliebtes Open-Source-Betriebssystem, das als Grundlage für den Server dient.
  2. Engine-X(ausgesprochen als „nginx“): Der Webserver. Nginx ist ein hochleistungsfähiger Webserver, der für seine Stabilität, den großen Funktionsumfang, die einfache Konfiguration und den geringen Ressourcenverbrauch bekannt ist.
  3. MySQLoder MariaDB: Das Datenbanksystem. MySQL ist ein weit verbreitetes relationales Datenbankmanagementsystem, das die Daten für die Website oder Anwendung speichert und verwaltet. Beachten Sie, dass MySQL manchmal durch MariaDB ersetzt wird, einem verbesserten, vollständig quelloffenen und von der Community entwickelten Fork von MySQL.
  4. PHP: Die Programmiersprache. PHP ist eine serverseitige Skriptsprache, die für die Webentwicklung entwickelt wurde, aber auch als Allzweckprogrammiersprache verwendet wird.

Der LEMP-Stack ist eine beliebte Wahl für das Hosting von Websites, die eine Datenbank und serverseitige Verarbeitung benötigen, wie z. B. WordPress-Websites, E-Commerce-Plattformen und andere dynamische Webanwendungen. Er ist vergleichbar mit dem LAMP-Stack, bei dem Apache (dargestellt durch das „A“ in LAMP) anstelle von Nginx verwendet wird.

In dieser Anleitung wirst du einen LEMP-Stack auf einem Ubuntu 20.04-basierten Server installieren. Außerdem werden wir phpMyAdmin, Redis, Opcache und Let’s Encrypt SSL installieren.

Voraussetzungen

  • Ein Server mit Ubuntu 20.04.
  • Ein sudo-Benutzer ohne Root-Rechte.
  • Stelle sicher, dass alles auf dem neuesten Stand ist. 
    $ sudo apt update
$ sudo apt upgrade
  • Ein paar Pakete, die dein System braucht. 
    $ sudo apt install wget curl nano -y

    Einige dieser Pakete sind vielleicht schon auf deinem System installiert.

Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Ubuntu wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.

Überprüfe, ob die Firewall läuft.

$ sudo ufw status

Du solltest die folgende Ausgabe erhalten.

Status: inactive

Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.

$ sudo ufw allow OpenSSH

Lasse auch HTTP- und HTTPS-Ports zu.

$ sudo ufw allow 80
$ sudo ufw allow 443

Aktiviere die Firewall

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Überprüfe den Status der Firewall erneut.

$ sudo ufw status

Du solltest eine ähnliche Ausgabe sehen.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80                         ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80 (v6)                    ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Installiere PHP

Ubuntu 20.04 wird standardmäßig mit PHP 7.4 ausgeliefert, aber um ein aktuelles PHP-Repository zu haben, fügen wir das PHP-Repository von Ondrej hinzu.

Installiere Ondrejs PHP-Repository.

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

Installiere PHP 7.4 zusammen mit einigen zusätzlichen Paketen.

$ sudo apt install php-cli php-fpm php-mysql -y

Prüfe, ob PHP richtig funktioniert.

$ php --version

Du solltest eine ähnliche Ausgabe sehen.

PHP 7.4.5 (cli) (built: Apr 28 2020 14:49:23) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies
    with Zend OPcache v7.4.5, Copyright (c), by Zend Technologies

Installiere MariaDB

MariaDB ist ein direkter Ersatz für MySQL. Das bedeutet, dass die Befehle zum Ausführen und Betreiben von MariaDB die gleichen sind wie die für MySQL.

Ubuntu 20.04 wird standardmäßig mit MariaDB 10.3 ausgeliefert, das ein wenig veraltet ist. Um die neueste stabile Version von Mariadb zu erhalten, werden wir das offizielle Repository installieren.

Füge das offizielle Repository von Mariadb hinzu.

$ sudo apt-key adv --fetch-keys 'https://mariadb.org/mariadb_release_signing_key.asc'
$ sudo add-apt-repository 'deb [arch=amd64] http://mirror.lstn.net/mariadb/repo/10.4/ubuntu focal main'

Um MariaDB zu installieren, gib den folgenden Befehl ein.

$ sudo apt install mariadb-server -y

Überprüfe, ob MariaDB korrekt installiert wurde.

$ mysql --version

Du solltest die folgende Ausgabe sehen.

mysql  Ver 15.1 Distrib 10.4.13-MariaDB, for debian-linux-gnu (x86_64) using readline 5.2

Aktiviere den MariaDB-Dienst.

$ sudo systemctl enable mariadb

Führe den folgenden Befehl aus, um die Standardkonfiguration durchzuführen, z. B. ein Root-Passwort zu vergeben, anonyme Benutzer zu entfernen, den Root-Login aus der Ferne zu verbieten und Testtabellen zu löschen.

$ sudo mysql_secure_installation

Mit MariaDB 10.4 wirst du nun gefragt, ob du das Root-Passwort oder das unix_socket-Plugin verwenden möchtest. Mit dem unix_socket-Plugin kannst du dich mit deinen Linux-Benutzerdaten bei MariaDB anmelden. Es gilt als sicherer, obwohl du einen herkömmlichen Benutzernamen und ein Passwort benötigst, um Anwendungen von Drittanbietern wie phpMyAdmin zu nutzen. In diesem Tutorial werden wir uns auf das unix_socket Plugin beschränken. Du kannst phpMyAdmin trotzdem über einen beliebigen Benutzer verwenden, den du für deine Datenbanken angelegt hast.

Wenn du die Eingabetaste drückst, wählst du die Standardoption aus (diejenige, die groß geschrieben wird, in diesem Fall Y).

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): [PRESS ENTER]
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] [PRESS ENTER]
Enabled successfully!
Reloading privilege tables..
 ... Success!

You already have your root account protected, so you can safely answer 'n'.

Change the root password? [Y/n] [ANSWER n]
... 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] [PRESS ENTER]
 ... 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] [PRESS ENTER]
 ... 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] [PRESS ENTER]
 \- 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] [PRESS ENTER]
 ... 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!

Das war’s schon. Wenn du dich das nächste Mal bei MySQL anmelden willst, gibst du folgenden Befehl ein

$ sudo mysql

Gib dein Root-Passwort ein, wenn du dazu aufgefordert wirst.

Redis installieren

Verwende den folgenden Befehl, um Redis und die entsprechende PHP-Redis-Erweiterung zu installieren.

$ sudo apt install redis php-redis

Redis-Server konfigurieren

Lass uns einige grundlegende Konfigurationen auf dem Redis-Server vornehmen.

Öffne die Datei /etc/redis/redis.conf mit dem Nano-Editor.

$ sudo nano /etc/redis/redis.conf

In der Datei findest du die Direktive supervised. Mit dieser Direktive kannst du ein Init-System deklarieren, das Redis als Dienst verwaltet. Standardmäßig ist sie auf no gesetzt. Da wir Ubuntu verwenden, das das Init-System systemd benutzt, änderst du den Wert wie folgt von no auf systemd.

supervised systemd

Wenn du möchtest, dass sich Remote-Clients mit deiner Redis-Instanz verbinden können, dann suche die Zeile bind 127.0.0.1 und ändere sie wie folgt.

bind 0.0.0.0

Du kannst auch den Standard-Port, auf dem Redis lauscht, von 6379 auf einen Wert deiner Wahl ändern.

port 3458

Um Redis als Cache-Server zu konfigurieren, setzt du die folgenden Werte wie angegeben.

maxmemory 256mb
maxmemory-policy allkeys-lru

Damit wird Redis angewiesen, jeden Schlüssel mit dem LRU-Algorithmus zu entfernen, wenn der maximale Speicher von 256 MB erreicht ist. Du kannst den Speicherwert je nach deinen Anforderungen und dem von dir verwendeten Server einstellen.

Du kannst ein Passwort festlegen, damit jeder Client, der Redis benötigt, sich zuerst authentifizieren muss. Dazu kannst du mit der folgenden Direktive ein Passwort festlegen.

requirepass  <AuthPassword>

Weitere Direktiven, die du ändern kannst, findest du in der Konfigurationsdatei. Wenn du fertig bist, drücke Strg + X und gib Y ein, wenn du zum Speichern der Datei aufgefordert wirst.

Starte den Redis-Server neu, um die Änderungen zu übernehmen.

$ sudo systemctl restart redis

Wir müssen auch die Regel in unserer Firewall hinzufügen, wenn du möchtest, dass sich Remote-Clients mit ihm verbinden können. Ansonsten kannst du diesen Schritt überspringen.

$ sudo ufw allow 6379/tcp

Du musst den Wert im obigen Befehl so ändern, dass er dem Port entspricht, den du in der obigen Konfigurationsdatei ausgewählt hast.

Nginx installieren

Ubuntu 20.04 wird standardmäßig mit der neuesten Mainline-Version von Nginx ausgeliefert. (1.17.10). Wir werden jedoch auf das offizielle Stable Repository von Nginx umsteigen.

Installiere zuerst einige Voraussetzungen.

$ sudo apt install curl gnupg2 ca-certificates lsb-release

Einige von ihnen sind bereits auf deinem System installiert.

Füge das Repository von Nginx hinzu.

$ echo "deb [arch=amd64] http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" | sudo tee /etc/apt/sources.list.d/nginx.list
$ curl -fsSL https://nginx.org/keys/nginx_signing.key | sudo apt-key add -

Installiere Nginx.

$ sudo apt update
$ sudo apt install nginx -y

Prüfe, ob es richtig funktioniert.

$ nginx -v

Je nachdem, welche Version von Nginx du installiert hast, solltest du die folgende Ausgabe sehen.

nginx version: nginx/1.18.0

Starte und aktiviere Nginx.

$ sudo systemctl start nginx
$ sudo systemctl enable nginx

Öffne die IP-Adresse deines Servers in einem Browser, um die folgende Seite zu sehen. Das bedeutet, dass Nginx richtig funktioniert.

Nginx Standardseite

Nginx konfigurieren

Richte Verzeichnisse ein, in denen die Serverblöcke gespeichert werden sollen.

$ sudo mkdir /etc/nginx/sites-available
$ sudo mkdir /etc/nginx/sites-enabled

Erstelle das Verzeichnis, in dem sich deine Website befinden wird.

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

Mit der Direktive -p erstellst du übergeordnete Verzeichnisse, die vorher nicht existierten.

Führe den folgenden Befehl aus, um eine Konfigurationsdatei für deine Website hinzuzufügen.

$ sudo nano /etc/nginx/sites-available/example.com.conf

Füge den folgenden Code in den Editor ein.

server {
  listen          *:80;
  server_name     example.com;
  root            /var/www/example.com/html;
  index           index.php index.html;

  location / {
    try_files   $uri $uri/ =404;
  }
    
  access_log /var/log/nginx/example.com.access.log;
  error_log /var/log/nginx/example.com.error.log;

  location ~ \.php$ {
    try_files $uri =404;
    fastcgi_pass  unix:/run/php/php7.4-fpm.sock;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    fastcgi_index index.php;
    include  fastcgi_params;
  }
}

Drücke Strg + X, um den Editor zu schließen und drücke Y, wenn du zum Speichern der Datei aufgefordert wirst.

Diese Datei geht davon aus, dass wir example.com im Verzeichnis /var/www/html hosten werden. Wenn du keine Domain verwendest und deinen Server so konfigurierst, dass er nur über die IP-Adresse/den Localhost erreichbar ist, musst du die entsprechenden Einstellungen für den Serverblock aus der Datei nginx.conf entfernen, da sie sonst mit dem von dir erstellten Serverblock durcheinander kommen.

Aktiviere diese Konfigurationsdatei, indem du sie mit dem Verzeichnis sites-enabled verknüpfst.

$ sudo ln -s /etc/nginx/sites-available/example.com.conf /etc/nginx/sites-enabled/

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgenden Zeilen nach der Zeile include /etc/nginx/conf.d/*.conf

include /etc/nginx/sites-enabled/*.conf;
server_names_hash_bucket_size 64;
types_hash_max_size 4096;

Drücke Strg + X, um den Editor zu schließen und drücke Y, wenn du zum Speichern der Datei aufgefordert wirst. Teste die Nginx-Konfiguration.

$ sudo nginx -t

Du solltest die folgende Ausgabe sehen, die anzeigt, dass deine Konfiguration korrekt ist.

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Lade den Nginx-Dienst neu.

$ sudo systemctl reload nginx

PHP-FPM konfigurieren

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

$ sudo nano /etc/php/7.4/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.
; RPM: apache user chosen to provide access to the same directories as httpd
user = nginx
; RPM: Keep a group allowed to write in log dir.
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 php7.4-fpm

Um deine PHP-Einrichtung zu testen, erstelle eine Datei test.php im Ordner html.

$ sudo nano /var/www/example.com/html/test.php

Füge den folgenden Inhalt hinzu und speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

<?php phpinfo();

Starte http://<yourserverip>/test.php in deinem Webbrowser und du solltest folgendes sehen.

PHP-Informationen

phpMyAdmin installieren

Für unseren Lehrgang werden wir phpMyAdmin manuell installieren.

Zunächst müssen wir einige zusätzliche PHP-Pakete installieren, damit phpMyAdmin funktioniert.

$ sudo apt install php-mbstring php-zip php-gd php-json php-curl php-bz2 php-xml

Wechsle in das Verzeichnis /usr/share, um phpMyAdmin herunterzuladen und zu installieren.

$ cd /usr/share

Lade die phpMyAdmin-Dateien herunter. (Die neueste Version findest du auf der Website) Wir werden nur die englische Version installieren.

$ sudo wget https://files.phpmyadmin.net/phpMyAdmin/5.0.2/phpMyAdmin-5.0.2-english.tar.gz
$ tar xvzf phpMyAdmin-5.0.2-english.tar.gz
$ sudo mv phpMyAdmin-5.0.2-english /usr/share/phpmyadmin
$ sudo rm phpMyAdmin*.tar.gz

Gib dem phpMyAdmin-Ordner die richtigen Berechtigungen.

$ sudo chown -R nginx:nginx phpmyadmin 
$ sudo chmod -R 744 phpmyadmin

phpMyAdmin konfigurieren

Erstelle die Konfigurationsdatei aus der Beispieldatei, die dem Paket beiliegt.

$ sudo cp /usr/share/phpmyadmin/config.sample.inc.php /usr/share/phpmyadmin/config.inc.php

Wir müssen in der Konfigurationsdatei einen geheimen Wert für Cookies und Sicherheitszwecke hinzufügen. Verwende die folgenden Befehle, um den Code zu erzeugen und hinzuzufügen.

$ randomBlowfishSecret=$(openssl rand -base64 32)
$ sed -i "s|cfg\['blowfish_secret'\] = ''|cfg['blowfish_secret'] = '$randomBlowfishSecret'|" /usr/share/phpmyadmin/config.inc.php

Damit der Nginx-Webserver die phpMyAdmin-Dateien korrekt findet und ausliefert, müssen wir einen symbolischen Link von seinem eigentlichen Speicherort zum Stammverzeichnis von Nginx erstellen.

Dazu führst du den folgenden Befehl aus.

$ sudo ln -s /usr/share/phpmyadmin /var/www/example.com/html/phpmyadmin

Deine phpMyAdmin-Installation ist jetzt betriebsbereit. Um sie aufzurufen, öffne einfach http://example.com/phpmyadmin.

Dieser Standard-Speicherort sollte geändert werden, da er der häufigste Ort ist, an dem ein Hacker deine phpMyAdmin-Installation finden kann. Dazu führst du den folgenden Befehl aus.

$ sudo mv /var/www/example.com/html/phpmyadmin /var/www/example.com/html/sm123

Damit haben wir unseren phpMyAdmin-Speicherort in den Ordner sm123 verschoben. Um darauf zuzugreifen, musst du nun http://example.com/sm123 in deinem Browser öffnen.

Da wir hier unix_authentication mit MySQL verwenden, gibt es keinen Root-Benutzer, bei dem du dich über phpMyAdmin anmelden kannst. Um phpMyAdmin nutzen zu können, musst du zuerst einen MySQL-Benutzer anlegen und ihm Rechte für die Datenbanken geben.

Melde dich dazu in der MySQL-Shell an.

$ sudo mysql

Füge nun die folgenden Befehle ein, um einen neuen Benutzer zu erstellen und ihm alle Datenbankrechte zu erteilen.

CREATE USER 'user'@'localhost' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON *.* TO 'user'@'localhost';
FLUSH PRIVILEGES;
EXIT

Jetzt kannst du dich mit diesem Benutzer unter http://example.com/phpmyadmin anmelden.

Opcache konfigurieren

Wenn du diesen Lehrgang verfolgt hast, sollte Opcache bereits mit PHP installiert sein. Sollte das nicht der Fall sein, kannst du Opcache einfach mit dem folgenden Befehl installieren.

$ sudo apt install php7.4-opcache

Überprüfe, ob er installiert wurde.

$ php -v
PHP 7.4.5 (cli) (built: Apr 28 2020 14:49:23) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies
    with Zend OPcache v7.4.5, Copyright (c), by Zend Technologies

Um die Opcache-Einstellungen zu ändern, öffne die Datei /etc/php/7.4/fpm/conf.d/10-opcache.ini.

$ sudo nano /etc/php/7.4/fpm/conf.d/10-opcache.ini

Füge den folgenden Code am Ende der Datei ein. Die folgenden Einstellungen sollten dir den Einstieg in die Nutzung von Opcache erleichtern und werden im Allgemeinen für eine gute Leistung empfohlen.

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 deinen Server neu, um die Einstellungen zu übernehmen.

$ sudo systemctl restart php7.4-fpm

Installiere SSL über Let’s Encrypt

SSL ist zu einem wichtigen Bestandteil jeder Website geworden. Hier werden wir SSL mit dem Dienst Let’s Encrypt installieren.

Installiere dazu zunächst das Tool Certbot.

$ sudo apt install certbot python3-certbot-nginx

Erstelle die Zertifikate.

$ sudo certbot --nginx -d example.com

Wenn du Certbot zum ersten Mal auf deinem System ausführst, wirst du nach einer E-Mail-Adresse gefragt und musst den Nutzungsbedingungen zustimmen. Du wirst auch gefragt, ob du damit einverstanden bist, Daten mit der EFF-Stiftung zu teilen, was du mit Nein beantworten kannst. Nachdem du dies getan hast, kommuniziert certbot mit den Let’s Encrypt-Servern und führt eine Challenge durch, um deine Domains zu verifizieren.

Wenn dies erfolgreich war, wirst du gefragt, wie du HTTPS-Weiterleitungen behandeln willst.

Please choose whether HTTPS access is required or optional.
-------------------------------------------------------------------------------
1: Easy - Allow both HTTP and HTTPS access to these sites
2: Secure - Make all requests redirect to secure HTTPS access
-------------------------------------------------------------------------------
Select the appropriate number [1-2] then [enter] (press 'c' to cancel):

Wähle deine Wahl und drücke die Eingabetaste. Deine Zertifikate werden nun erstellt und deine Nginx-Konfigurationsdateien werden mit den SSL-Einstellungen aktualisiert.

Deine Zertifikate sind fertig und du kannst deine Website jetzt unter https://example.com öffnen.

SSL-Autoverlängerung überprüfen

Dies ist der letzte Schritt, bevor wir dieses Tutorial beenden.

Überprüfe den Erneuerungsprozess, indem du einen Trockenlauf durchführst.

$ sudo certbot renew --dry-run

Wenn du keine Fehler erhältst, bedeutet das, dass du bereit bist. Certbot wird deine Zertifikate automatisch für dich erneuern. Du erhältst eine E-Mail, die dich über den Ablauf des Zertifikats informiert.

Fazit

Das war’s mit diesem Tutorial. Deine LEMP-Einrichtung ist abgeschlossen und du kannst mit der Erstellung und dem Hosting deiner Websites und Anwendungen beginnen.

Das könnte dich auch interessieren …