LEMP Stack – der perfekte Webserver

Update: 27.04.2018

Hinweis: Neben den Anleitungen im Rahmen dieser Serie habe ich mittlerweile fertige Shell Scripte erstellt, die quasi voll automatisch die Installation eines Servers für euch übernehmen. Ihr findet das Ganze auf github.de, wobei ihr entweder den ganzen Server per Script aufsetzen und konfigurieren lassen könnt, oder eben jeden einzelnen Schritt, wie  z.B. das Absichern des Servers, oder das Installieren eines LEMP Stacks, mit Hilfe der jeweiligen Scripte erledigen könnt. Die Scripte entsprechen quasi 1:1 zu den Tutorials.

LEMP

Zugegeben, es ist schon wieder ein bissen mehr Zeit verstrichen, seit ich den letzten Teil zum perfekten Server veröffentlicht habe, aber wie heißt es so schön, besser spät als nie! Im Grund genommen ist dies hier ja auch nur eine Art Nachschlagewerk, gefüllt mit meinen persönlichen Empfehlungen.

Ich hatte letztes Jahr eigentlich schon mal einen relativ ausführlichen Artikel zum Thema LEMP verfasst, mich nach anfänglichem Überlegen dann aber doch dazu entschieden einen neuen Artikel zu verfassen – wobei ich hier ein bisschen weiter ins Detail gehen werde, bzw. wir einen Teil selbst compilieren werden. Wer nur eine schnelle und simple Anleitung sucht, der kann sich ja noch mal das alte Tutorial angucken.

Als Grundlage für unseren LEMP Server bzw. unser LEMP Stack dienen Debian, NGiNX, PHP und MariaDB.

Ich hatte zwischenzeitlich mal Testszenarien mit HHVM statt php, bzw. HHVM und php als Fallback laufen, bzw. MySQL oder MungoDB statt MariaDB im Einsatz. Mit allen Kombinationen war ich eher weniger zufrieden, weswegen ich mich eben für oben genannte Komponenten entschieden habe.

So dann wollen wir mal, immer schön der Reihe nach.

System vorbereiten

Auch wenn wir unser System gerade erst aufgesetzt haben, kann es nicht schaden es zu Beginn zu updaten – gerade wenn man eine CD als Installationsmedium verwendet, oder fertige Images vom Hoster.

apt-get update && apt-get upgrade
apt-get install -y vim

Standardmäßig kommt Debian mit dem Texteditor Nano daher, da ich aber kein großer Fan von Nano bin und quasi mit Vim aufgewachsen bin, installieren wir an dieser Stelle schnell noch Vim. Theoretisch sollte den meisten Usern eigentlich auch vim reichen, die vim-nox Version kommt mit zusätzlichem Support von tcl, ruby, Lua und perl daher – je nachdem, was man noch so vorhat.

nginxInstallation Nginx

Für die Installation von nginx gibt es zwei Möglichkeiten. Die Erste ist sicherlich die bequemere, aber in meinen Augen nicht gleich bessere Variante. Außerdem ist die zweite Möglichkeit die einzige, um zusätzlich Module zu installieren. Wobei nginx hier mittlerweile auch immer offener für das nachträglich integrieren von Modulen wird, wie z.B. das GeoIP Modul.

Installation via APT

wget //nginx.org/keys/nginx_signing.key
apt-key add nginx_signing.key
echo 'deb //nginx.org/packages/debian/ $(lsb_release -sc) nginx' >> /etc/apt/sources.list
echo 'deb-src //nginx.org/packages/debian/ $(lsb_release -sc) nginx' >> /etc/apt/sources.list
apt-get update && apt-get install nginx

Die Installation via APT ist sicherlich eine feine Sache, nur leider installieren wir damit nicht wirklich die neuste Version, sondern die letzte ’stable‘, d.h stabil laufende Version. Mittlerweile ist man hierbei immerhin schon bei der Version 1.12.2 angekommen. Wer auf Nummer Sicher gehen will, der kann hier beruhigt die stable Version installieren – profitiert aber damit leider nicht von aktuellen Neuerungen der ‚mainline‘ Version.

Installation via Source

Da wir in unserem Fall die mainline Version von nginx installieren wollen, müssen wir ein wenig mehr Hand anlegen. Belohnt werden wir dafür aber mit den neusten Funktionen und Features. Die mainline Version wird eigentlich in der Regel ziemlich oft upgedatet und weiterentwickelt. Aktuelle Version wäre hier die 1.13.10.

Zunächst benötigen wir die passenden Werkzeuge, um nginx selbst aus den source files zu kompilieren, d.h. auf unserem System nach unseren Wünschen zusammen zu bauen.

apt-get install -y gcc build-essential zlib1g-dev libpcre3 libpcre3-dev libbz2-dev libssl-dev tar unzip

Ähnlich wie bei der Installation via APT müssen wir das passende Repository hinzufügen und die Daten herunterladen.

wget http://nginx.org/keys/nginx_signing.key 
apt-key add nginx_signing.key
echo 'deb http://nginx.org/packages/mainline/debian/ $(lsb_release -sc) nginx' >> /etc/apt/sources.list
echo 'deb-src http://nginx.org/packages/mainline/debian/ $(lsb_release -sc) nginx' >> /etc/apt/sources.list
apt-get update

Anschließend laden wir die passenden Files herunterladen und wechseln in den Ordner.

apt-get build-dep nginx
apt-get source nginx
cd nginx-*

Jetzt sind wir eigentlich schon fast am Ende des Datensammelns angelangt.

Ich für meinen Teil installiere aber gerne immer noch das Cache Purge Modul von FRiCKLE. Das ist zwar schon ein wenig älter, erfüllt aber dennoch bestens seinen Zweck, speziell im Zusammenspiel mit WordPress und dem Nginx Helper Plugin. Besonders praktisch, wenn ihr öfters Artikel auf WordPress und Co veröffentlicht, oder bearbeitet. Dank nginx eigenem Cache spart man sich eigentlich sämtliche Cache Plugins, die die WordPressinstallation eh nur noch langsamer werden lassen. Mittlerweile gibt es aber auch mit dem Nginx Cache Plugin die Möglichkeit nginx hauseigenen cache ohne zusätzliches Modul zu ‚purgen‘.

Beide Plugins erfüllen ihren Zweck, von daher werde ich im nächsten Schritt auch auf beide Möglichkeiten nginx zu compilieren eingehen, mit und ohne zusätzliches Modul.

Option 1: Zusätzliche Module hinzufügen

Wie im letzten Schritt bereits beschrieben, werden wir ein zusätzliches Modul, das Cache Purge Modul, herunterladen und vor der eigentlichen Installation in unser selbst compiliertes Installationspaket einfügen. Dafür erstellen wir zunächst einen neuen Modul Ordner, laden das passende Modul herunter, entpacken es und benennen den Ordner anschließend um, da wir am Ende sonst einen ziemlich langen, unschönen Namen haben – haha. Die heruntergeladenen Zip files werden anschließend nicht mehr benötigt und gelöscht.

cd debian
mkdir modules && cd modules
wget -q --no-check-certificate https://github.com/FRiCKLE/ngx_cache_purge/zipball/master -O "ngx_cache_purge.zip"  
unzip ngx_cache_purge.zip
mv FR* ngx_cache_purge
rm ngx_cache_purge.zip

Wenn ihr zusätzlich andere Module, wie z.B. das PageSpeed Modul von google – welches ich nach längerem Test für nutzlos befunden habe – installieren wollt, dann könnt ihr genau so vorgehen und die passenden Files in den Modul Ordner kopieren.

Nun müsst ihr nur noch die nginx Installation anpassen, da nginx ja nicht riechen kann, dass ihr noch zusätzliche Module installieren wollt. Ebenfalls ändere ich die Rechte Debian-typisch auf www-data. Da ich relativ faul bin und die config files nicht einzeln von Hand öffnen möchte, machen wir das ganze per sed (stream editor). Achtet hierbei bitten genau auf eure eigenen Pfadangabe, bzw., da wir sed zum editieren benutzen, auch darauf, im letzten Befehl mit Hilfe von „\“ jedes „/“ auszukommentieren, aber nur innerhalb der „“!

sed -ie s/--user=nginx/--user=www-data/g <pfad auf eurem system/nginx-1.13.10>/debian/rules
sed -ie s/--group=nginx/--group=www-data/g <pfad auf eurem system/nginx-1.13.10>/debian/rules
sed -i s"/--with-file-aio/--with-file-aio --add-module=<pfad auf eurem system\/nginx-1.13.10\/nginx-1.13.10>\/debian\/modules\/ngx_cache_purge/g" /root/test/nginx-1.13.10/debian/rules

Für den Fall, dass ihr keine Lust habt, das ganze mit sed zu editieren, könnt ihr die /nginx-1.13.10/debian/rules auch von Hand editieren, per sftp Client, oder mit Hilfe von nano, vim, etc. Das Ganze sollte dann so aussehen, wobei ihr den letzten Eintrag auch ignorieren könnt, wenn ihr nicht gerade später die debug Version installieren wollt.

config.status.nginx: config.env.nginx
	cd $(BUILDDIR_nginx) && \
	CFLAGS="" ./configure --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=www-data --group=www-data --with-compat --with-file-aio --add-module=/root/test/nginx-1.13.10/debian/modules/ngx_cache_purge --with-threads --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_realip_module --with-stream_ssl_module --with-stream_ssl_preread_module --with-cc-opt="$(CFLAGS)" --with-ld-opt="$(LDFLAGS)"
	touch $@

config.status.nginx_debug: config.env.nginx_debug
	cd $(BUILDDIR_nginx_debug) && \
	CFLAGS="" ./configure --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=www-data --group=www-data --with-compat --with-file-aio --add-module=/root/test/nginx-1.13.10/debian/modules/ngx_cache_purge --with-threads --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_realip_module --with-stream_ssl_module --with-stream_ssl_preread_module --with-cc-opt="$(CFLAGS)" --with-ld-opt="$(LDFLAGS)" --with-debug
	touch $@

Option 2: Ohne zusätzliche Module

Ohne zusätzliche Module spart ihr euch quasi den ersten Schritt aus dem vorherigen Teil, bzw. den letzten Schritt am Ende. Alles was ihr benötigt ist folgender Befehl:

sed -ie s/--user=nginx/--user=www-data/g <pfad auf eurem system/nginx-1.13.10>/debian/rules
sed -ie s/--group=nginx/--group=www-data/g <pfad auf eurem system/nginx-1.13.10>/debian/rules

Oder eben die von Hand editierte rules

config.status.nginx: config.env.nginx
	cd $(BUILDDIR_nginx) && \
	CFLAGS="" ./configure --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=www-data --group=www-data --with-compat --with-file-aio --with-threads --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_realip_module --with-stream_ssl_module --with-stream_ssl_preread_module --with-cc-opt="$(CFLAGS)" --with-ld-opt="$(LDFLAGS)"
	touch $@

config.status.nginx_debug: config.env.nginx_debug
	cd $(BUILDDIR_nginx_debug) && \
	CFLAGS="" ./configure --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=www-data --group=www-data --with-compat --with-file-aio --with-threads --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_realip_module --with-stream_ssl_module --with-stream_ssl_preread_module --with-cc-opt="$(CFLAGS)" --with-ld-opt="$(LDFLAGS)" --with-debug
	touch $@

Installationspaket erstellen

Soooo, fast geschafft, jetzt basteln wir uns aus den source files und unseren optionalen Modulen eine passende Installationsdatei.

cd .. && cd .. [ihr solltet jetzt wieder hier sein: <pfad auf eurem system/nginx-1.13.10>]
dpkg-buildpackage -b

Das kann jetzt einen Moment dauern. Wir erhalten in der Regel nicht nur ein File, sondern eine ganze Hand voll Files. Diese könnt ihr nun nach Belieben installieren. Eine Auflistung erhalte ihr mit „ls„

cd .. && ls

In unserem Fall wären das z.B. für die reine nginx Installation inkl. unserer selbst eingebauten Module.

dpkg -i nginx_1.13.10-1~stretch_amd64.deb

Das hätten wir geschafft. nginx sollte nun eigentlich erfolgreich auf eurem Server laufen.

Einige Module lassen sich Gott sei dank mittlerweile bequem nachträglich per APT installieren, wie z.B. das GeoIP Modul

apt-get install -y nginx-module-geoip

Zu guter Letzt schließen wir noch unsere mühevoll von Hand installiere nginx Version von automatischen Updates via APT und Co aus. Es kann sonst nämlich passieren, dass euch APT sonst einfach die stable Version drüber bügelt und all eure Module flöten gehen – selbst schon passiert, also Vorsicht!

echo nginx hold | dpkg --set-selections 
aptitude hold nginx

Konfiguration Nginx

Kommen wir nun zur Konfiguration von nginx. Hier kommt es sicherlich auf persönliche Vorlieben an, was die Ordnerstruktur etc. angeht, also seht das Ganz nicht so eng, sondern nutzt es evtl. als Leitfaden.

Zunächst erstelle ich mir einen Ordner wo ich später sämtliche Files für den Webserver ablege, und setzte die passenden Berechtigungen.

mkdir /var/www
chown -R www-data:www-data /var/www

Als nächstes erstelle ich mir gerne vier Ordner. Einen für alle gängigen config files, einen für alle vhost Konfigurationen, einen für die aktivierten vhosts und einen für alle Cache files.

mkdir /etc/nginx/cfg
mkdir /etc/nginx/sites-available
mkdir /etc/nginx/sites-enabled
mkdir /etc/nginx/cache
chown -R www-data:www-data /etc/nginx/cache

In den cfg Ordner kommen alle meine configs, ganz gleich, ob ich sie verwende, oder nicht. Diese importiere ich dann quasi bei Bedarf in der Hauptkonfiguration.

Im Ordner sites-available landen alle vhost files und im Ordner sites-enabled lediglich symlinks, d.h. Verlinkungen. Somit kann es mir nicht passieren, dass ich aus Versehen irgendwelche Files lösche, bzw, habe ich so die Möglichkeit schnell Änderungen vorzunehmen, oder bei Bedarf bestimmte configs zu aktivieren bzw. deaktivieren, ohne dabei immer wieder die Hauptkonfiguration anzupassen.

Die Hauptkonfiguration – nginx.conf ist somit immer schön schlank und übersichtlich.

Das Ganze sieht dann in etwa so aus:

load_module "modules/ngx_http_geoip_module.so";

user www-data;
worker_processes auto;
worker_rlimit_nofile        36384;
pid /run/nginx.pid;

events {
    worker_connections      18342;
    use                     epoll;
    multi_accept            on;
}

http {

        
        include mime.types;  

        ## Core HTTP config files
        include /etc/nginx/cfg/basics.conf;

        ## Hash configs
        include /etc/nginx/cfg/hashes.conf;

        # Open Files Cache
        include /etc/nginx/cfg/openfc.conf;

        # Log configuration
        # include /etc/nginx/cfg/log.conf;

        # Access Logging
        # include /etc/nginx/cfg/access_log_name.conf;

        # Search engine and other bots
        include /etc/nginx/cfg/bot_req.conf;
        include /etc/nginx/cfg/bot_ua.conf;

        # Gzip
        include /etc/nginx/cfg/gzip.conf;

        # Headers to be sent / added or removed
        include /etc/nginx/cfg/headers.conf;

        # Request zone
        include /etc/nginx/cfg/zone.conf;

        # Fastcgi
        include /etc/nginx/cfg/fcgi.conf;

        # GEO IP 
        include /etc/nginx/cfg/geoip.conf;

        # SSL global config - Disable if you dont use SSL, which you should...
        include /etc/nginx/cfg/ssl.conf;

        proxy_cache_path                /var/cache/nginx levels=1:2
                                        keys_zone=STATIC:75m
                                        inactive=24h
                                        max_size=512m;


        proxy_temp_path                                 /var/tmp;


	
	include /etc/nginx/sites-enabled/*;
}

Und hier mal ein paar Configs aus dem cfg Ordner, damit ihr ein Gefühl für die Struktur bekommt.

 gzip.cfg

gzip on; 
gzip_buffers 4 8k; 
gzip_disable "msie6"; 
gzip_vary on; 
# gzip_static on;
# gzip_proxied any;
gzip_proxied expired no-cache no-store private auth; 
gzip_comp_level 5; 
gzip_min_length 256;

gzip_types 
application/atom+xml
application/javascript
application/json
application/ld+json
application/manifest+json
application/rdf+xml
application/rss+xml
application/schema+json
application/vnd.geo+json
application/vnd.ms-fontobject
application/x-font-ttf
application/x-javascript
application/x-web-app-manifest+json
application/xhtml+xml
application/xml
font/eot
font/opentype
image/bmp
image/svg+xml
image/vnd.microsoft.icon
image/x-icon
text/cache-manifest
text/css
text/javascript
text/plain
text/vcard
text/vnd.rim.location.xloc
text/vtt
text/x-component
text/x-cross-domain-policy
text/xml
;

Natürlich sind das alles nur Beispiele. Jedem steht natürlich frei, seinen Webserver einzurichten, wie er mag. Auf der Seite des Herstellers findet man z.B. auch einige gut erklärte Beispiele. Bzw. eine Sammlung verschiedener meiner configs findet ihr auch hier.

Zu guter Letzt starten wir nginx neu, damit alle Änderungen übernommen werden. Keine Sorge, wenn ihr hier irgendwas falsch gemacht habt, startet nginx gar nicht erst, wirklich was kaputt machen könnt ihr also nicht. Bzw. am Besten testet ihr die Config vorher einmal kurz mit nginx -t.

nginx -t
service nginx restart

Vhost einrichten

Richtig, wie ihr sicherlich bemerkt habt, gibt es bis hierhin noch keine wirkliche Erklärung zum Thema vhost, bzw. der Konfiguration einzelner Websites. Das möchte ich an dieser Stelle auch so belassen. An anderer Stelle, zum Thema WordPress Installation, oder Nextcloud findet ihr dann auch einen vollständigen vhost.

Der Übersicht halber hier nur kurz das Standard Beispiel vom Hersteller.

server {
        listen   80; ## listen for ipv4; this line is default and implied
        #listen   [::]:80 default ipv6only=on; ## listen for ipv6

        root /var/www/example.com/public_html;
        index index.html index.htm;

        # Make site accessible from http://localhost/
        server_name example.com;
}

Eine Datei mit dem Inhalt speichert ihr nun im Ordner sites-available ab und erstellt einen symlink zum Ordner sites-enabled. Danach müsst ihr nginx wieder neustarte.

ln -s /etc/nginx/sites-available/<vhost file> /etc/nginx/sites-enabled/
/etc/init.d/nginx restart

php7Installation PHP 7.2

Hier können wir wieder bequem auf APT zurückgreifen! Installiert wird aber nicht direkt php 7.2, sondern php7.2-fpm – PHP FastCGI Process Manager, php läuft also als eigener Prozess.

Da wir die neuste Version installieren wollen, müssen wir noch das passende Repository hinzufügen. Aktueller wäre natürlich, wenn wir das Ganze, ähnlich wie nginx aus dem source selbst kompilieren, aber da hier keine besonders großen Versionssprünge zu erwarten sind, überlassen wir diese Arbeit wem anders.

apt-get install -y apt-transport-https lsb-release ca-certificates 
wget -O /etc/apt/trusted.gpg.d/php.gpg https://packages.sury.org/php/apt.gpg 
echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" | tee /etc/apt/sources.list.d/php.list 
apt-get update

Jetzt können wir bequem mit Hilfe von APT PHP-FPM und alles, was wir später sonst noch so gebrauchen können, installieren.

apt-get install -y php7.2-fpm > $out 2>&1
apt-get install -y php7.2-gd php7.2-mysql php7.2-curl php7.2-opcache php7.2-dev 
apt-get install -y php7.2-xml php7.2-zip php7.2-intl php7.2-mbstring php7.2-bz2 
apt-get install -y libmcrypt-dev libreadline-dev

Nur was die Konfiguration, falls gewünscht, angeht ist mal wieder Handarbeit gefragt. In diesem Beispiel erhöhe ich die Maximalgröße von Uplaods bzw. deaktiviere das Ausführen von externen php Scripten.

sed -i 's/^upload_max_filesize .*/'"upload_max_filesize = 10M/g" /etc/php/7.0/fpm/php.ini
sed -i 's/^post_max_size .*/'"post_max_size = 12M/g" /etc/php/7.0/fpm/php.ini
sed -i 's/^allow_url_fopen .*/'"allow_url_fopen = Off/g" /etc/php/7.0/fpm/php.ini
service php7.2-fpm restart

Seht ihr, das ging doch schon mal wesentlich fixer. Damit ist php 7 auch schon einsatzbereit!

mariadbInstallation MariaDB

MariaDB lässt sich Gott sei Dank auch relativ einfach und unkompliziert via APT installieren, wobei wir hier auch zuerst das passende Repo hinzufügen müssen.

apt-get install -y software-properties-common dirmngr 
apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 0xF1656F24C74CD1D8 
echo "deb [arch=amd64,i386,ppc64el] http://ftp.hosteurope.de/mirror/mariadb.org/repo/10.2/debian $(lsb_release -sc) main" | tee /etc/apt/sources.list.d/MariaDB.list 
apt-get update
apt-get install -y -q mariadb-server

Die Konfiguration ist, wie bei php, ebenfalls ziemlich schnell erledigt. Hierbei unterbinde ich ebenfalls, wie bei php, Zugriffe von Außerhalb.

sed -i 's/^bind-address.*/'"#bind-address = 127.0.0.1/g" /etc/mysql/my.cnf
sed -i '/^#bind-address.*/a\skip-networking\' /etc/mysql/my.cnf
service mysql restart

Damit wäre MariaDB eigentlich schon einsatzbereit. Ich empfehle dennoch kurz zur Absicherung den letzten Schritt:

mysql_secure_installation

So geschafft, das wars dann auch schon. Euer LEMP Webserver sollte nun ohne Probleme laufen!

phpmyadminphpMyAdmin

Die Installation von PHPmyAdminist zwar nicht zwingend notwendig, für mich gehört es aber zu den nützlichsten webbased Tools überhaupt! Mit Hilfe von PHPmyAdmin könnt ihr ganz bequem via Browser auf euren SQL Server zugreifen. Hierbei gilt, ähnlich wie bei nginx. Die Version direkt vom Anbieter ist aktueller, als via APT.

git clone --depth=1 --branch=STABLE https://github.com/phpmyadmin/phpmyadmin.git /usr/share/phpmyadmin 
ln -s /usr/share/phpmyadmin /var/www/
chown -R www-data:www-data /var/www/phpmyadmin
randomBlowfishSecret=`openssl rand -base64 32`; 
sed -e "s|cfg\['blowfish_secret'\] = ''|cfg['blowfish_secret'] = '$randomBlowfishSecret'|" /usr/share/phpmyadmin/config.sample.inc.php > /usr/share/phpmyadmin/config.inc.php
service nginx restart 

curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer 
cd /usr/share/phpmyadmin
composer update --no-dev

Was machen wir genau? Wir clonen die neuste Version direkt von Github, erstellen einen sicheren Schlüssel, der später vom Webinterface benötigt wird und installieren alles mit Hilfe von Composer. Da ich nicht davon ausgehe, dass Composer bis jetzt auf dem System läuft, laden wir dieses Tool vorab herunter.

Zu guter Letzt erstellen wir uns eben noch schnell ein Update Script, um auch diese Version immer up-to-date zu halten. Wer nicht unbedingt wöchentlich updaten möchte, kann das Ganze auch im cron.monthly statt cron.weekly Ordner ablegen.

cat > /etc/cron.weekly/pma_update <<EOF
#!/bin/bash
cd /usr/share/phpmyadmin
git pull -q origin STABLE
composer update --no-dev
EOF

chmod +x /etc/cron.weekly/pma_update

Viel Spaß mit eurem neuen Webserver!

Bei Fragen stehe ich natürlich nach wie vor gerne zur Verfügung.

Verwandte ArtikelMehr vom Autor

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein