Nextcloud Installationshandbuch

Nextcloud in weniger als 20 Minuten

oDroidC2, Ubuntu 16.04.03 LTS 64 Bit, NGINX 1.13.7, PHP 7.1.12, MariaDB, Redis, Nextcloud 12.0.4, zusätzlich abgesichert mit fail2ban.
(Bitte nur die rot markierten Werte (YOUR.DEDYN.IO und 192.168.2.x) anpassen)


  1. NGINX
  2. PHP
  3. MariaDB
  4. Redis
  5. Nextcloud (SSL aktiviert, A+)
  6. fail2ban

Aktualisiert: 13. Dezember 2017:
– header.conf korrigiert
– Video streaming Optimierungen in der Datei nextcloud.conf

Aktualisiert: 08. Dez. 2017:
– Automatische SSL-Zertifikatserneuerung

Aktualisiert: 03. Dez. 2017:
– chown -R www-data:root /usr/local/tmp/cache /usr/local/tmp/sessions


Dieses How-To dient der Installation und Inbetriebnahme eines Nextcloudservers unter Ubuntu 16.04.3 LTS inklusive der Einrichtung und Optimierung aller benötigten Komponenten wie PHP 7.1, MariaDB, Redis, fail2ban und dem A+ Prädikat von Qualys SSL Labs. Das dafür zugrundeliegende, kostenlose SSL Zertifikat erhalten wir im Verlauf dieses How-To von Let’s Encrypt.

Anforderungen und Voraussetzungen

Die Voraussetzungen für dieses How-To sind sehr gering. Wir benötigen entweder ein SBC (bspw. oDroid C2 oder oDroid HC1) oder einen Mini-Server (bspw. Intel NUC).

  • Portweiterleitungen (:80, :443) vom Router (bspw. FritzBox o. Speedport) zum Server
  • Ubuntu 16.04.3 LTS
  • Webserver NGINX ≥ 1.13.7
  • PHP ≥ 7.1.12
  • MariaDB ≥ 10.x
  • Nextcloud ≥ 12.0.4
  • SSL (Let’s Encrypt)
  • fail2ban ≥ 0.9.3

Installation des Webservers (NGINX) inkl. des ngx_cache_purge Moduls

Diese NGINX-Pakete setzen openssl 1.1.0g voraus – bitte stellen Sie diese openssl-Version sicher (how to upgrade to openssl 1.1.0g)!

Zuerst aktualisieren wir das System und laden dann den vorkompilierten Webserver NGINX 1.13.7 inkl. des ngx_cache_purge Moduls für die entsprechende Plattform herunter:

sudo -s
apt update && apt upgrade -y && apt install zip unzip screen curl ffmpeg libfile-fcntllock-perl -y
apt remove nginx nginx-common nginx-full -y --allow-change-held-packages

Download: NGINX 1.13.7 with ngx_cache_purge (ARM 64Bit)
Download: NGINX 1.13.7 with ngx_cache_purge (AMD 64Bit)

cd /usr/local/src
wget "https://wolke.c-rieger.de/index.php/s/AXZEnSIrM3VE9BA/download?path=%2F&files=nginx_1.13.7-1~xenial_arm64.deb" -O nginx_1.13.7-1~xenial_arm64.deb

Nun führen wir die Installation des Webservers durch

dpkg --install nginx_1.13.7-1~xenial_arm64.deb

und sorgen dafür, dass dieser (a) bei einem Serverneustart automatisch gestartet und (b) bei möglichen Aktualisierungen nicht ungewollt aktualisiert wird:

systemctl enable nginx.service && apt-mark hold nginx

Im nächsten Schritt optimieren wir den Webserver und erstellen dafür eine eigene Konfigurationsdatei:

mv /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak && vi /etc/nginx/nginx.conf

Wir kopieren den gesamten Inhalt in die neue, leere Datei. Passen Sie bitte den rot markierten Wert an Ihre Umgebung an. Dabei entspricht die IP ihrer Router-IP (bspw. FritzBox oder Speedport):

user www-data;
worker_processes auto;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
multi_accept on;
use epoll;
}
http {
server_names_hash_bucket_size 64;
upstream php-handler {
server unix:/run/php/php7.1-fpm.sock;
}
include /etc/nginx/mime.types;
#include /etc/nginx/proxy.conf;
#include /etc/nginx/ssl.conf;
#include /etc/nginx/header.conf;
#include /etc/nginx/optimization.conf;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for" '
'"$host" sn="$server_name" '
'rt=$request_time '
'ua="$upstream_addr" us="$upstream_status" '
'ut="$upstream_response_time" ul="$upstream_response_length" '
'cs=$upstream_cache_status' ;
access_log /var/log/nginx/access.log main;
sendfile on;
send_timeout 3600;
tcp_nopush on;
tcp_nodelay on;
open_file_cache max=500 inactive=10m;
open_file_cache_errors on;
keepalive_timeout 65;
reset_timedout_connection on;
server_tokens off;
resolver 192.168.2.1;
resolver_timeout 10s;
include /etc/nginx/conf.d/*.conf;
}

Nun starten wir den Webserver und erzeugen alle notwendigen Verzeichnisse für den Betrieb Ihrer eigenen Nextcloud:

service nginx restart
mkdir -p /var/nc_data /var/www/letsencrypt /usr/local/tmp/cache /usr/local/tmp/sessions /upload_tmp
chown -R www-data:www-data /upload_tmp /var/nc_data /var/www
chown -R www-data:root /usr/local/tmp/sessions /usr/local/tmp/cache

Die Installation des Webservers ist bereits abgeschlossen und wir fahren mit der Installation von PHP fort.

Installation von PHP 7.1.12

Um die aktuellste Version von PHP verwenden zu können fügen wir das Repository von Ondrej unserem System hinzu und verwenden somit stets die aktuellen PHP-Binaries.

sudo -s
apt install language-pack-en-base -y && sudo LC_ALL=en_US.UTF-8 add-apt-repository ppa:ondrej/php -y
apt update && apt install php7.1-fpm php7.1-gd php7.1-mysql php7.1-curl php7.1-xml php7.1-zip php7.1-intl php7.1-mcrypt php7.1-mbstring php-apcu php-imagick php7.1-json php7.1-bz2 php7.1-zip php-smb -y

Mit diesen drei Schritten ist PHP bereits auch schon erfolgreich installiert und wird nachfolgend nur noch für Nextcloud optimiert. Kopieren Sie dazu alle Befehle in Ihre Zwischenablage und führen dann alle Befehle in einem Durchgang aus:

cp /etc/php/7.1/fpm/pool.d/www.conf /etc/php/7.1/fpm/pool.d/www.conf.bak
cp /etc/php/7.1/cli/php.ini /etc/php/7.1/cli/php.ini.bak
cp /etc/php/7.1/fpm/php.ini /etc/php/7.1/fpm/php.ini.bak
cp /etc/php/7.1/fpm/php-fpm.conf /etc/php/7.1/fpm/php-fpm.conf.bak
sed -i "s/;env\[HOSTNAME\] = /env[HOSTNAME] = /" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/;env\[TMP\] = /env[TMP] = /" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/;env\[TMPDIR\] = /env[TMPDIR] = /" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/;env\[TEMP\] = /env[TEMP] = /" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/;env\[PATH\] = /env[PATH] = /" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/pm.max_children = .*/pm.max_children = 240/" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/pm.start_servers = .*/pm.start_servers = 20/" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/pm.min_spare_servers = .*/pm.min_spare_servers = 10/" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/pm.max_spare_servers = .*/pm.max_spare_servers = 20/" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/;pm.max_requests = 500/pm.max_requests = 500/" /etc/php/7.1/fpm/pool.d/www.conf
sed -i "s/output_buffering =.*/output_buffering = Off/" /etc/php/7.1/cli/php.ini
sed -i "s/max_execution_time =.*/max_execution_time = 1800/" /etc/php/7.1/cli/php.ini
sed -i "s/max_input_time =.*/max_input_time = 3600/" /etc/php/7.1/cli/php.ini
sed -i "s/post_max_size =.*/post_max_size = 10240M/" /etc/php/7.1/cli/php.ini
sed -i "s/;upload_tmp_dir =.*/upload_tmp_dir = \/upload_tmp/" /etc/php/7.1/cli/php.ini
sed -i "s/upload_max_filesize =.*/upload_max_filesize = 10240M/" /etc/php/7.1/cli/php.ini
sed -i "s/max_file_uploads =.*/max_file_uploads = 100/" /etc/php/7.1/cli/php.ini
sed -i "s/;date.timezone.*/date.timezone = Europe\/\Berlin/" /etc/php/7.1/cli/php.ini
sed -i "s/;session.cookie_secure.*/session.cookie_secure = True/" /etc/php/7.1/cli/php.ini
sed -i "s/;session.save_path =.*/session.save_path = \"\/usr\/local\/tmp\/sessions\"/" /etc/php/7.1/cli/php.ini
sed -i '$aapc.enable_cli = 1' /etc/php/7.1/cli/php.ini
sed -i "s/output_buffering =.*/output_buffering = Off/" /etc/php/7.1/fpm/php.ini
sed -i "s/max_execution_time =.*/max_execution_time = 1800/" /etc/php/7.1/fpm/php.ini
sed -i "s/max_input_time =.*/max_input_time = 3600/" /etc/php/7.1/fpm/php.ini
sed -i "s/post_max_size =.*/post_max_size = 10240M/" /etc/php/7.1/fpm/php.ini
sed -i "s/;upload_tmp_dir =.*/upload_tmp_dir = \/upload_tmp/" /etc/php/7.1/fpm/php.ini
sed -i "s/upload_max_filesize =.*/upload_max_filesize = 10240M/" /etc/php/7.1/fpm/php.ini
sed -i "s/max_file_uploads =.*/max_file_uploads = 100/" /etc/php/7.1/fpm/php.ini
sed -i "s/;date.timezone.*/date.timezone = Europe\/\Berlin/" /etc/php/7.1/fpm/php.ini
sed -i "s/;session.cookie_secure.*/session.cookie_secure = True/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.enable=.*/opcache.enable=1/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.enable_cli=.*/opcache.enable_cli=1/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.memory_consumption=.*/opcache.memory_consumption=128/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.interned_strings_buffer=.*/opcache.interned_strings_buffer=8/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.max_accelerated_files=.*/opcache.max_accelerated_files=10000/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.revalidate_freq=.*/opcache.revalidate_freq=1/" /etc/php/7.1/fpm/php.ini
sed -i "s/;opcache.save_comments=.*/opcache.save_comments=1/" /etc/php/7.1/fpm/php.ini
sed -i "s/;session.save_path =.*/session.save_path = \"\/usr\/local\/tmp\/sessions\"/" /etc/php/7.1/fpm/php.ini
sed -i "s/;emergency_restart_threshold =.*/emergency_restart_threshold = 10/" /etc/php/7.1/fpm/php-fpm.conf
sed -i "s/;emergency_restart_interval =.*/emergency_restart_interval = 1m/" /etc/php/7.1/fpm/php-fpm.conf
sed -i "s/;process_control_timeout =.*/process_control_timeout = 10s/" /etc/php/7.1/fpm/php-fpm.conf

Davon ausgehend, dass Ihr Server mindestens 2GB RAM zur Verfügung hat, lagern wir einige Verzeichnisse in eine sogenannte RAMDISK aus. Dazu erweitern wir die /etc/fstab. Kopieren Sie alle nachfolgenden Befehle in Ihre Zwischenablage und führen diese erneut auf einmal aus.

sed -i '$atmpfs /tmp tmpfs defaults,noatime,nosuid,nodev,noexec,mode=1777 0 0' /etc/fstab
sed -i '$atmpfs /var/tmp tmpfs defaults,noatime,nosuid,nodev,noexec,mode=1777 0 0' /etc/fstab
sed -i '$atmpfs /usr/local/tmp/cache tmpfs defaults,noatime,nosuid,nodev,noexec,mode=1777 0 0' /etc/fstab
sed -i '$atmpfs /usr/local/tmp/sessions tmpfs defaults,noatime,nosuid,nodev,noexec,mode=1777 0' /etc/fstab

Nun binden wir diese Laufwerke in den Server ein (mount) und starten sowohl den Webserver NGINX als auch PHP neu:

mount -a && service php7.1-fpm restart && service nginx restart

Die Installation, Konfiguration und Optimierung von PHP ist somit vollständig abgeschlossen und wir fahren mit der Installation des Datenbankservers MariaDB fort.

Installation und Konfiguration von MariaDB

Die Installation des Datenbankservers erfolgt direkt aus den Ubuntu-Repositories und bringt automatisch ein Sicherheits-Script mit, welches unmittelbar im Anschluss an die Installation des Datenbankservers ausgeführt wird.

sudo -s
apt update && apt install mariadb-server -y

Der Datenbankserver wurde bereits installiert und wird nun mittels mysql_secure_installation abgesichert. Richten Sie mittels des Tools ein DB-Rootpasswort ein und beantworten alle weiteren Fragen mit ‘Y’

mysql_secure_installation

Wir passen nun die Datenbankserverkonfiguration an.

mv /etc/mysql/my.cnf /etc/mysql/my.cnf.bak

Kopieren Sie den gesamten nachfolgenden Text in Ihre Zwischenablage

[server]
skip-name-resolve
innodb_buffer_pool_size = 128M
innodb_buffer_pool_instances = 1
innodb_flush_log_at_trx_commit = 2
innodb_log_buffer_size = 32M
innodb_max_dirty_pages_pct = 90
query_cache_type = 1
query_cache_limit = 2M
query_cache_min_res_unit = 2k
query_cache_size = 64M
tmp_table_size= 64M
max_heap_table_size= 64M
slow-query-log = 1
slow-query-log-file = /var/log/mysql/slow.log
long_query_time = 1

[client-server]
!includedir /etc/mysql/conf.d/
!includedir /etc/mysql/mariadb.conf.d/

[client]
default-character-set = utf8mb4

[mysqld]
character-set-server = utf8mb4
collation-server = utf8mb4_general_ci
binlog_format = MIXED
innodb_large_prefix=on
innodb_file_format=barracuda
innodb_file_per_table=1

und fügen diesen in die leere Datei my.cnf ein.

vi /etc/mysql/my.cnf

Wir stardten nun den Datenbankserver neu und erzeugen die notwendige Datenbank und den notwendigen Datenbankuser.

service mysql restart && mysql
CREATE DATABASE nextcloud CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
CREATE USER nextcloud@localhost identified by 'nextcloud';
GRANT ALL PRIVILEGES on nextcloud.* to nextcloud@localhost;
FLUSH privileges;
quit;

Somit wurde der Datenbankserver bereits installiert, optimiert, die Datenbank (nextcloud) und der Datenbankuser (nextcloud) erzeugt und der Datenbankserver erfolgreich neu gestartet. Wir fahren nun mit der Installation des Redis-Servers (file_lock) fort.

Installation des Redis-Server

Die Installation des Redis-Servers erfolgt ebenfalls aus den Ubuntu-Repositories und ergänzt die vorherige PHP-Installation um ein Modul.

sudo -s
apt update && apt install redis-server php-redis -y

Die Redis-Konfiguration wird nun angepasst und der redis-User der Webserver-Gruppe www-data hinzugefügt.

cp /etc/redis/redis.conf /etc/redis/redis.conf.bak
sed -i "s/port 6379/port 0/" /etc/redis/redis.conf
sed -i s/\#\ unixsocket/\unixsocket/g /etc/redis/redis.conf
sed -i "s/unixsocketperm 700/unixsocketperm 770/" /etc/redis/redis.conf
sed -i "s/# maxclients 10000/maxclients 512/" /etc/redis/redis.conf
usermod -a -G redis www-data

Des Weiteren wird für den Betrieb des Redis-Servers das Serversystem angepasst:

cp /etc/sysctl.conf /etc/sysctl.conf.bak && sed -i '$avm.overcommit_memory = 1' /etc/sysctl.conf
cp /etc/rc.local /etc/rc.local.bak && sed -i '$i \sysctl -w net.core.somaxconn=65535' /etc/rc.local

Um alle Installationen und Anpassungen zu überprüfen und zu aktivieren empfehlen wir an dieser Stelle den einmaligen Neustart des Servers

shutdown -r now

bevor wir mit der Einrichtung Ihrer persönlichen Nextcloud beginnen.

Nextcloud: Einrichten der virtuellen Hosts

Wir deaktivieren den Standard virtual Host und erzeugen uns den Nextcloud virtual Host namens /etc/nginx/conf.d/nextcloud.conf

mv /etc/nginx/conf.d/default.conf /etc/nginx/conf.d/default.conf.bak && touch /etc/nginx/conf.d/default.conf

Kopieren Sie den gesamten nachfolgenden Text in Ihre Zwischenablage

fastcgi_cache_path /usr/local/tmp/cache levels=1:2 keys_zone=NEXTCLOUD:100m inactive=60m;
map $request_uri $skip_cache {
default 1;
~*/thumbnail.php 0;
~*/apps/galleryplus/ 0;
~*/apps/gallery/ 0;
}
server {
listen 80 default_server;
server_name YOUR.DEDYN.IO;
location ^~ /.well-known/acme-challenge {
proxy_pass http://127.0.0.1:81;
}
location / {
return 301 https://$host$request_uri;
}
}
server {
listen 443 ssl http2 default_server;
server_name YOUR.DEDYN.IO;
root /var/www/nextcloud/;
access_log /var/log/nginx/nextcloud.access.log main;
error_log /var/log/nginx/nextcloud.error.log warn;
location = /robots.txt {
allow all;
log_not_found off;
access_log off;
}
location = /.well-known/carddav {
return 301 $scheme://$host/remote.php/dav;
}
location = /.well-known/caldav {
return 301 $scheme://$host/remote.php/dav;
}
client_max_body_size 10240M;
location / {
rewrite ^ /index.php$uri;
}
location ~ ^/(?:build|tests|config|lib|3rdparty|templates|data)/ {
deny all;
}
location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) {
deny all;
}
location ~* \.(?:flv|mp4|mov|m4a)$ {
mp4;
mp4_buffer_size 5m;
mp4_max_buffer_size 10m;
fastcgi_split_path_info ^(.+\.php)(/.*)$;
include fastcgi_params;
include php_optimization.conf;
fastcgi_pass php-handler;
fastcgi_param HTTPS on;
fastcgi_no_cache $skip_cache;
}
location ~ ^/(?:index|remote|public|cron|core/ajax/update|status|ocs/v[12]|updater/.+|ocs-provider/.+)\.php(?:$|/) {
fastcgi_split_path_info ^(.+\.php)(/.*)$;
include fastcgi_params;
include php_optimization.conf;
fastcgi_pass php-handler;
fastcgi_param HTTPS on;
fastcgi_cache_bypass $skip_cache;
fastcgi_no_cache $skip_cache;
fastcgi_cache NEXTCLOUD;
}
location ~ ^/(?:updater|ocs-provider)(?:$|/) {
try_files $uri/ =404;
index index.php;
}
location ~ \.(?:css|js|woff|svg|gif)$ {
try_files $uri /index.php$uri$is_args$args;
add_header Cache-Control "public, max-age=15778463";
access_log off;
expires 30d;
}
location ~ \.(?:png|html|ttf|ico|jpg|jpeg)$ {
try_files $uri /index.php$uri$is_args$args;
access_log off;
expires 30d;
}
}

und fügen diesen in die neue virtual Hostdatei nextcloud.conf ein

vi /etc/nginx/conf.d/nextcloud.conf

Ersetzen Sie erneut die rot dargestellte Domäne mit Ihrer DYNDNS-Adresse. Wir erzeugen nun eine Weitere, für Let’s Encrypt zwingend erforderliche, virtual Hostdatei namens /etc/nginx/conf.d/letsencrypt.conf:

vi /etc/nginx/conf.d/letsencrypt.conf

Kopieren Sie den nachfolgenden Text in die virtual Hostdatei namens letsencrypt.conf hinein:

server {
listen 127.0.0.1:81 default_server;
server_name 127.0.0.1;
charset utf-8;
access_log /var/log/nginx/le.access.log main;
error_log /var/log/nginx/le.error.log warn;
location ^~ /.well-known/acme-challenge {
default_type text/plain;
root /var/www/letsencrypt;
}
}

Somit wurden bereits beide notwendigen virtual Hostdateien erzeugt, so dass wir mit den zentralen Webserverkonfigurationsdateien fortfahren können. Wir erzeugen zuerst die SSL-Konfiguration, indem Sie den nachfolgenden Text in Ihre Zwischenablage kopieren

#ssl_certificate /etc/letsencrypt/live/YOUR.DEDYN.IO/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/live/YOUR.DEDYN.IO/privkey.pem;
#ssl_trusted_certificate /etc/letsencrypt/live/YOUR.DEDYN.IO/fullchain.pem;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
ssl_protocols TLSv1.2;
ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK:!AES128';
ssl_prefer_server_ciphers on;
ssl_ecdh_curve secp384r1;
ssl_stapling on;
ssl_stapling_verify on;

und in die Datei namens /etc/nginx/ssl.conf einfügen:

vi /etc/nginx/ssl.conf

Ersetzen Sie erneut die rot dargestellte Domäne mit Ihrer DYNDNS-Adresse. Auf gleiche Art und Weise erzeugen wir die Proxy-Konfiguration: kopieren Sie den nachfolgenden Text in Ihre Zwischenablage

proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Forwarded-Protocol $scheme;
proxy_set_header X-Forwarded-For $remote_addr;
proxy_set_header X-Forwarded-Port $server_port;
proxy_set_header X-Forwarded-Server $host;
proxy_connect_timeout 3600;
proxy_send_timeout 3600;
proxy_read_timeout 3600;
proxy_redirect off;
proxy_max_temp_file_size 0;

und fügen Sie diesen in die Datei /etc/nginx/proxy.conf ein.

vi /etc/nginx/proxy.conf

Auf gleiche Art und Weise erzeugen wir die Header-Konfiguration: kopieren Sie den nachfolgenden Text in Ihre Zwischenablage

add_header Strict-Transport-Security "max-age=15768000; includeSubDomains; preload;";
add_header X-Robots-Tag none;
add_header X-Download-Options noopen;
add_header X-Permitted-Cross-Domain-Policies none;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "same-origin" always;

und fügen Sie diesen in die Datei /etc/nginx/header.conf ein.

vi /etc/nginx/header.conf

Auf gleiche Art und Weise erzeugen wir die Optimierungs-Konfiguration: kopieren Sie den nachfolgenden Text in Ihre Zwischenablage

fastcgi_buffers 64 64K;
fastcgi_buffer_size 256k;
fastcgi_busy_buffers_size 3840K;
fastcgi_cache_key $http_cookie$request_method$host$request_uri;
fastcgi_cache_use_stale error timeout invalid_header http_500;
fastcgi_ignore_headers Cache-Control Expires Set-Cookie;
gzip on;
gzip_vary on;
gzip_comp_level 4;
gzip_min_length 256;
gzip_proxied expired no-cache no-store private no_last_modified no_etag auth;
gzip_types application/atom+xml application/javascript application/json application/ld+json application/manifest+json application/rss+xml application/vnd.geo+json application/vnd.ms-fontobject application/x-font-ttf application/x-web-app-manifest+json application/xhtml+xml application/xml font/opentype image/bmp image/svg+xml image/x-icon text/cache-manifest text/css text/plain text/vcard text/vnd.rim.location.xloc text/vtt text/x-component text/x-cross-domain-policy;
gzip_disable "MSIE [1-6]\.";

und fügen Sie diesen in die Datei /etc/nginx/optimization.conf ein.

vi /etc/nginx/optimization.conf

Auf gleiche Art und Weise erzeugen wir die PHP-Optimierungs-Konfiguration: kopieren Sie den nachfolgenden Text in Ihre Zwischenablage

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_param modHeadersAvailable true;
fastcgi_param front_controller_active true;
fastcgi_intercept_errors on;
fastcgi_request_buffering off;
fastcgi_cache_valid 404 1m;
fastcgi_cache_valid any 1h;
fastcgi_cache_methods GET HEAD;

und fügen Sie diesen in die Datei /etc/nginx/php_optimization.conf ein.

vi /etc/nginx/php_optimization.conf

Abschließend erhöhen wir die SSL-Sicherheit und erzeugen uns dafür einen Diffie-Hellmann Key zum sicheren Schlüsselaustausch via https:

openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096

In Abhängigkeit der Serverperformance kann dieser Vorgang sehr lange dauern. Möchte man diese Generierung im Hintergrund ablaufen lassen, so nutzt man screen dafür

screen -S dhparam
openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096

Mittels ‘STRG+a’ und einem anschließenden ‘d’ verlässt man diesen Prozess dann und lässt diesen im Hintergrund arbeiten. Mittels screen -R gelangt man zu diesem zurück.

Sobald dieser Vorgang abgeschlossen ist aktivieren wir die Konfigurationsdateien und starten den Webserver NGINX neu:

sed -i s/\#\include/\include/g /etc/nginx/nginx.conf && service nginx restart

Wir laden uns nun die derzeit aktuelle Nextcloud-Version 12.0.4 herunter, entpacken das Paket und setzen die notwendigen Berechtigungen durch nachfolgenden Befehl

cd /usr/local/src && wget https://download.nextcloud.com/server/releases/nextcloud-12.0.4.tar.bz2 && tar -xjf nextcloud-12.0.4.tar.bz2 -C /var/www && chown -R www-data:www-data /var/www/

Im Anschluss daran installieren wir let’s encrypt und requestieren die SSL-Zertifikate für unseren Server

add-apt-repository ppa:certbot/certbot -y && apt update
apt install letsencrypt -y letsencrypt certonly -a webroot --webroot-path=/var/www/letsencrypt --rsa-key-size 4096 -d YOUR.DEDYN.IO

Ersetzen Sie erneut die rot dargestellte Domäne mit Ihrer DYNDNS-Adresse. Mittels eines eigenen Skripts können wir in Zukunft alle notwendigen Berechtigungen auf sehr einfache Weise setzen. Kopieren Sie den nachfolgenden Text in Ihre Zwischenablage

#!/bin/bash
find /var/www/ -type f -print0 | xargs -0 chmod 0640
find /var/www/ -type d -print0 | xargs -0 chmod 0750
chown -R www-data:www-data /var/www/
chown -R www-data:www-data /upload_tmp/
chown -R www-data:www-data /var/nc_data/
chmod 0644 /var/www/nextcloud/.htaccess
chmod 0644 /var/www/nextcloud/.user.ini
chmod 600 /etc/letsencrypt/live/YOUR.DEDYN.IO/fullchain.pem
chmod 600 /etc/letsencrypt/live/YOUR.DEDYN.IO/privkey.pem
chmod 600 /etc/letsencrypt/live/YOUR.DEDYN.IO/chain.pem
chmod 600 /etc/letsencrypt/live/YOUR.DEDYN.IO/cert.pem
chmod 600 /etc/ssl/certs/dhparam.pem
exit 0

und fügen diesen in die neue Datei /root/berechtigungen.sh ein

vi /root/berechtigungen.sh

Machen Sie das Skript ausführbar

chmod +x /root/berechtigungen.sh

und führen es dann

/root/berechtigungen.sh

bei Bedarf aus. Nun aktivieren wir die letzten auskommentierten Zeilen in der /etc/nginx/ssl.conf-Datei und können dann den mittels SSL abgesicherten, mit A+ bewerteten NGINX-Webserver neu starten.

sed -i s/\#\ssl/\ssl/g /etc/nginx/ssl.conf && service nginx restart

Automatische SSL-Zertifikatserneuerung:

vi /root/renewal.sh

Fügen Sie die folgenden Zeilen ein

#!/bin/bash
cd /etc/letsencrypt
letsencrypt renew
result=$(find /etc/letsencrypt/live/ -type l -mtime -1 )
if [ -n "$result" ]; then
/usr/sbin/service nginx stop
/usr/sbin/service mysql restart
/usr/sbin/service redis-server restart
/usr/sbin/service php7.1-fpm restart
/usr/sbin/service postfix restart
/usr/sbin/service nginx restart
fi
exit 0

Machen Sie das Scipt ausführbar und erzeugen einen aufrufenden Cronjob:

chmod +x /root/renewal.sh && crontab -e

Fügen SIe folgende Zeile hinzu:

@monthly /root/renewal.sh 2>&1

Nun rufen Sie Nextcloud erstmalig zum Konfigurieren auf. Öffnen Sie dazu einen Browser ihrer Wahl (Empfehlung: Firefox ≥ 57) und rufen darin Ihre URL auf:

https://YOUR.DEDYN.IO

Geben Sie im Konfigurationsassistenten die folgenden Werte ein:

Username: Nextclouders_Root_Username
Password: Nextclouders_Root_Password!
Data folder: /var/nc_data
Datenbankuser: nextcloud
DB-Passwort: nextcloud
Datenbank-Name: nextcloud
Host: localhost

Beenden Sie die Installation im Browser und passen dann die Nextcloud Konfiguration /var/www/nextcloud/config/config.php als User www-data an:

sudo -u www-data cp /var/www/nextcloud/config/config.php /var/www/nextcloud/config/config.php.bak
sudo -u www-data vi /var/www/nextcloud/config/config.php

Passen Sie die config.php nach der Zeile ‘trusted_domains’ =>  wie nachfolgend dargestellt an:

<?php
 $CONFIG = array (
 'instanceid' => '...keep your values...',
 'passwordsalt' => '...keep your values...',
 'secret' => '...keep your values...',
 'trusted_domains' =>
 array (
 0 => 'YOUR.DEDYN.IO',
 ),
 'datadirectory' => '/var/nc_data',
 'dbtype' => 'mysql',
 'version' => '12.0.4.3',
 'dbname' => 'nextcloud',
 'dbhost' => 'localhost',
 'dbport' => '',
 'dbtableprefix' => 'oc_',
 'mysql.utf8mb4' => true,
 'dbuser' => 'nextcloud',
 'dbpassword' => 'nextcloud',
 'installed' => true,
 'htaccess.RewriteBase' => '/',
 'overwriteprotocol' => 'https',
 'loglevel' => 1,
 'logtimezone' => 'Europe/Berlin',
 'logfile' => '/var/nc_data/nextcloud.log',
 'log_rotate_size' => 104857600,
 'cron_log' => true,
 'filesystem_check_changes' => 1,
 'quota_include_external_storage' => false,
 'knowledgebaseenabled' => false,
 'memcache.local' => '\\OC\\Memcache\\APCu',
 'filelocking.enabled' => 'true',
 'memcache.locking' => '\\OC\\Memcache\\Redis',
 'redis' =>
 array (
 'host' => '/var/run/redis/redis.sock',
 'port' => 0,
 'timeout' => 0.0,
 ),
 'maintenance' => false,
 'theme' => '',
 'enable_previews' => true,
 'enabledPreviewProviders' =>
 array (
 0 => 'OC\\Preview\\PNG',
 1 => 'OC\\Preview\\JPEG',
 2 => 'OC\\Preview\\GIF',
 3 => 'OC\\Preview\\BMP',
 4 => 'OC\\Preview\\XBitmap',
 5 => 'OC\\Preview\\Movie',
 6 => 'OC\\Preview\\PDF',
 7 => 'OC\\Preview\\MP3',
 8 => 'OC\\Preview\\TXT',
 9 => 'OC\\Preview\\MarkDown',
 ),
 'preview_max_x' => 512,
 'preview_max_y' => 512,
 'preview_max_scale_factor' => 1,
 'auth.bruteforce.protection.enabled' => true,
 'trashbin_retention_obligation' => 'auto, 7',
 );

Dann passen wir die Datei /var/www/nextcloud.user.ini an, um PHP spezielle Informationen für den Betrieb der Nextcloud bereitzustellen:

sudo -u www-data sed -i "s/upload_max_filesize=.*/upload_max_filesize=10240M/" /var/www/nextcloud/.user.ini
sudo -u www-data sed -i "s/post_max_size=.*/post_max_size=10240M/" /var/www/nextcloud/.user.ini
sudo -u www-data sed -i "s/output_buffering=.*/output_buffering='Off'/" /var/www/nextcloud/.user.ini

Abschließend richten wir noch den Nextcloud Cron-Job ein, indem wir die folgende Zeilekopieren

*/15 * * * * php -f /var/www/nextcloud/cron.php > /dev/null 2>&1

und in die Crontab einfügen

crontab -u www-data -e

Als letzten Schritt stellen die Nextcloudmethode AJAX auf cron-Job um

sudo -u www-data php /var/www/nextcloud/occ background:cron

und können ab sofort unsere eigene, private und sichere Nextcloud nutzen!

Installation und Konfiguration von fail2ban

Da es sich oft um private, persönliche und somit sensible Daten handelt, empfehlen wir die Verwendung von fail2ban als zusätzlichen Schutzmechanismus für Ihre Nextcloud. Wir installieren daher fail2ban und richten es nachfolgend ein.

sudo -s apt update && apt install fail2ban -y

Nun richten wir einen fail2ban-Filter

vi /etc/fail2ban/filter.d/nextcloud.conf

Fügen Sie den nachfolgenden Text ein:

[Definition]
failregex=^{"reqId":".*","remoteAddr":".*","app":"core","message":"Login failed: '.*' \(Remote IP: '<HOST>'\)","level":2,"time":".*"}$
 ^{"reqId":".*","level":2,"time":".*","remoteAddr":".*","app":"core".*","message":"Login failed: '.*' \(Remote IP: '<HOST>'\)".*}$
ignoreregex =

sowie einen fail2ban-Jail für Nextcloud ein

vi /etc/fail2ban/jail.d/nextcloud.local

Fügen Sie den nachfolgenden Text ein:

[nextcloud]
backend = auto
enabled = true
port = 80,443
protocol = tcp
filter = nextcloud
maxretry = 3
bantime = 36000
findtime = 36000
logpath = /var/nc_data/nextcloud.log

Zu allerletzt starten wir nun fail2ban neu und sind am Ende einer sicheren Nextcloud-Installation angekommen:

service fail2ban restart

FERTIG! Viel Spaß mit Ihrer Nextcloud – sollten noch Fragen offen sein oder Fragen entstehen, so schreiben Sie mir diese bitte in den Kommentaren.


Carsten Rieger