Suivez ces instructions et créez votre propre serveur Nextcloud, basé sur Debian 10, NGINX, TLSv1.3, PHP 7.3, PostgreSQL 11.5, Redis, UFW et Fail2ban.

Préparation et installation du serveur Web Nginx

Installez les packages logiciels suivants qui sont requis comme base pour le fonctionnement du serveur :

apt install curl gnupg2 git lsb-release ssl-cert ca-certificates apt-transport-https tree locate software-properties-common dirmngr screen htop net-tools zip unzip curl ffmpeg ghostscript libfile-fcntllock-perl -y

Ajoutez les sources logicielles au système afin de pouvoir installer les versions actuelles des packages respectifs :

cd /etc/apt/sources.list.d
echo "deb [arch=amd64,arm64] http://nginx.org/packages/mainline/ubuntu $(lsb_release -cs) nginx" | tee nginx.list
echo "deb [arch=amd64,arm64] http://ppa.launchpad.net/ondrej/php/ubuntu $(lsb_release -cs) main" | tee php.list

Rajoutez les clés correspondantes :

curl -fsSL https://nginx.org/keys/nginx_signing.key | sudo apt-key add -
apt-key adv --recv-keys --keyserver hkps: //keyserver.ubuntu.com: 443 4F4EA0AAE5267A6C
apt-key adv --recv-keys --keyserver hkps: //keyserver.ubuntu.com: 443 0xF1656F24C74CD1D8

Metttez à jour le système, puis générez des certificats auto-signés, qui sont ensuite remplacés par des certificats complets de Let's Encrypt :

apt update && apt upgrade -y
make-ssl-cert generate-default-snakeoil -y

Pour garantir qu'aucun résidu des installations précédentes n'interfère avec le fonctionnement du serveur Web, supprimez les :

apt remove nginx nginx-extras nginx-common nginx-full -y --allow-change-held-packages

Assurez vous  également que l'homologue (Apache2) du serveur Web nginx n'est ni actif ni installé :

systemctl stop apache2.service && systemctl disable apache2.service

Les préparatifs pour l'installation du serveur Web sont maintenant terminés et nous pouvons installer le logiciel avec la commande suivante :

apt install nginx -y

Puis on l'active :

systemctl enable nginx.service

On va sauvegarder, puis modifier la configuration standard avec nos éléments :

mv /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak && touch /etc/nginx/nginx.conf
nano /etc/nginx/nginx.conf

Il faut copier tout le contenu suivant dans le fichier et remplacez les valeurs IP en fonction de votre système :

user www-data;
worker_processes auto;
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.3-fpm.sock;
}
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log warn;
set_real_ip_from 127.0.0.1;
set_real_ip_from IP/32;
# c'est la plage IP de votre réseau privé / d'entreprise
real_ip_header X-Forwarded-For;
real_ip_recursive on;
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;
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 127.0.0.53 valid=30s;
# il s'agit de l'IP du serveur DNS local ou global
resolver_timeout 5s;
include /etc/nginx/conf.d/*.conf;
}

Enregistrez le fichier et fermez-le pour redémarrer le serveur Web :

service nginx restart

En préparation des certificats SSL et des répertoires Web, nous créerons quatre dossiers et définissons les autorisations appropriées :

mkdir -p / var / nc_data / var / www / letsencrypt
chown -R www-data: www-data / var / nc_data / var / www

Installation et configuration de PHP 7.3

Les sources PHP ont déjà été configurées et activées dans le chapitre précédent afin que nous puissions commencer par l'installation :

apt update && apt install php7.3-fpm php7.3-gd php7.3-mysql php7.3-curl php7.3-xml php7.3-zip php7.3-intl php7.3-mbstring php7.3-json php7.3-bz2 php7.3-ldap php-apcu imagemagick php-imagick php-smbclient -y

Définissez le format de date correct pour permettre une journalisation correcte :

timedatectl set-timezone Europe / Paris

Avant de commencer à optimiser PHP, nous enregistrons les fichiers de configuration :

cp /etc/php/7.3/fpm/pool.d/www.conf /etc/php/7.3/fpm/pool.d/www.conf.bak
cp /etc/php/7.3/cli/php.ini /etc/php/7.3/cli/php.ini.bak
cp /etc/php/7.3/fpm/php.ini /etc/php/7.3/fpm/php.ini.bak
cp /etc/php/7.3/fpm/php-fpm.conf /etc/php/7.3/fpm/php-fpm.conf.bak
cp /etc/ImageMagick-6/policy.xml /etc/ImageMagick-6/policy.xml.bak

Effectuez maintenant toutes les optimisations suivantes :

sed -i "s /; env \ [HOSTNAME \] = / env [HOSTNAME] = /" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s /; env \ [TMP \] = / env [TMP] = /" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s /; env \ [TMPDIR \] = / env [TMPDIR] = /" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s /; env \ [TEMP \] = / env [TEMP] = /" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s /; env \ [PATH \] = / env [PATH] = /" /etc/php/7.3/fpm/pool.d/www.conf
sed -i "s / output_buffering =. * / output_buffering = 'Off' /" /etc/php/7.3/cli/php.ini
sed -i "s / max_execution_time =. * / max_execution_time = 3600 /" /etc/php/7.3/cli/php.ini
sed -i "s / max_input_time =. * / max_input_time = 3600 /" /etc/php/7.3/cli/php.ini
sed -i "s / post_max_size =. * / post_max_size = 10240M /" /etc/php/7.3/cli/php.ini
sed -i "s / upload_max_filesize =. * / upload_max_filesize = 10240M /" /etc/php/7.3/cli/php.ini
sed -i "s /; date.timezone. * / date.timezone = Europe \ / \ Paris /" /etc/php/7.3/cli/php.ini
sed -i "s / memory_limit = 128M / memory_limit = 512M /" /etc/php/7.3/fpm/php.ini
sed -i "s / output_buffering =. * / output_buffering = 'Off' /" /etc/php/7.3/fpm/php.ini
sed -i "s / max_execution_time =. * / max_execution_time = 3600 /" /etc/php/7.3/fpm/php.ini
sed -i "s / max_input_time =. * / max_input_time = 3600 /" /etc/php/7.3/fpm/php.ini
sed -i "s / post_max_size =. * / post_max_size = 10240M /" /etc/php/7.3/fpm/php.ini
sed -i "s / upload_max_filesize =. * / upload_max_filesize = 10240M /" /etc/php/7.3/fpm/php.ini
sed -i "s /; date.timezone. * / date.timezone = Europe \ / \ Paris /" /etc/php/7.3/fpm/php.ini
sed -i "s /; session.cookie_secure. * / session.cookie_secure = True /" /etc/php/7.3/fpm/php.ini
sed -i "s /; opcache.enable =. * / opcache.enable = 1 /" /etc/php/7.3/fpm/php.ini
sed -i "s /; opcache.enable_cli =. * / opcache.enable_cli = 1 /" /etc/php/7.3/fpm/php.ini
sed -i "s /; opcache.memory_consumption =. * / opcache.memory_consumption = 128 /" /etc/php/7.3/fpm/php.ini
sed -i "s /; opcache.interned_strings_buffer =. * / opcache.interned_strings_buffer = 8 /" /etc/php/7.3/fpm/php.ini
sed -i "s /; opcache.max_accelerated_files =. * / opcache.max_accelerated_files = 10000 /" /etc/php/7.3/fpm/php.ini
sed -i "s /; opcache.revalidate_freq =. * / opcache.revalidate_freq = 1 /" /etc/php/7.3/fpm/php.ini
sed -i "s /; opcache.save_comments =. * / opcache.save_comments = 1 /" /etc/php/7.3/fpm/php.ini

sed -i '$ aapc.enable_cli = 1' /etc/php/7.3/mods-available/apcu.ini

sed -i "s / rights = \" none \ "pattern = \" PS \ "/ rights = \" read | write \ "pattern = \" PS \ "/" /etc/ImageMagick-6/policy.xml
sed -i "s / rights = \" none \ "pattern = \" EPI \ "/ rights = \" read | write \ "pattern = \" EPI \ "/" /etc/ImageMagick-6/policy.xml
sed -i "s / rights = \" none \ "pattern = \" PDF \ "/ rights = \" read | write \ "pattern = \" PDF \ "/" /etc/ImageMagick-6/policy.xml
sed -i "s / rights = \" none \ "pattern = \" XPS \ "/ rights = \" read | write \ "pattern = \" XPS \ "/" /etc/ImageMagick-6/policy.xml

Redémarrez maintenant les deux services, nginx et PHP :

service php7.3-fpm restart
service nginx restart

Installation et configuration de PostgreSQL 11.5

PostgreSQL va s'installer avec cette commande :

apt update && apt install postgresql postgresql-contrib -y

Vous pouvez maintenant vous connecter à postgreSQL avec :

sudo -u postgres psql

Vous pouvez obtenir des informations sur la connexion avec :

postgres = # \ conninfo
postgres- # \ q

Avant d'installer Nextcloud, nous devons d'abord créer une base de données dans postgreSQL.

Pour ce faire, nous exécutons les commandes suivantes :

sudo -u postgres psql

Puis exécutez :

CREATE USER nextcloud WITH PASSWORD 'your-password';
CREATE DATABASE nextcloud TEMPLATE template0 ENCODING 'UNICODE';
ALTER DATABASE nextcloud OWNER TO nextcloud;
GRANT ALL PRIVILEGES ON DATABASE nextcloud TO nextcloud;
\q

Installation et configuration de Redis

Pour augmenter les performances, on installe Redis car il réduit la charge sur la base de données :

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

Ajustez la configuration du redist en enregistrant les commandes suivantes :

cp /etc/redis/redis.conf /etc/redis/redis.conf.bak
sed -i "s / port 6379 / port 0 /" /etc/redis/redis.conf
sed -is / \ # \ 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 -aG redis www-data
cp /etc/sysctl.conf /etc/sysctl.conf.bak
sed -i '$ avm.overcommit_memory = 1' /etc/sysctl.conf

Il est recommandé de redémarrer le serveur à ce stade.

Installation et optimisation de Nextcloud (y compris SSL)

Nous configurons maintenant divers vhost, c'est-à-dire les fichiers de configuration du serveur, et modifions le fichier vhost standard de manière permanente. Puisque le système a été redémarré auparavant, nous enregistrons le nom de fichier vhost standard default.conf et créons un fichier vide.

[ -f /etc/nginx/conf.d/default.conf ] && mv /etc/nginx/conf.d/default.conf /etc/nginx/conf.d/default.conf.bak
touch /etc/nginx/conf.d/default.conf

Cela garantit que même lorsque le serveur Web nginx est mis à jour ultérieurement, cette configuration standard n'est pas affectée.

Créons le fichier vhost pour Nextcloud :

nano /etc/nginx/conf.d/nextcloud.conf

Copiez toutes les lignes suivantes dans le fichier nextcloud.conf et ajustez les valeurs your.domain.tld en fonction de votre système :

server {
server_name your.domain.tld;
listen 80 default_server;
listen [::]:80 default_server;
location ^~ /.well-known/acme-challenge {
proxy_pass http://127.0.0.1:81;
proxy_set_header Host $host;
}
location / {
return 301 https://$host$request_uri;
}
}
server {
server_name your.domain.tld;
listen 443 ssl http2 default_server;
listen [::]:443 ssl http2 default_server;
root /var/www/nextcloud/;
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;
}
#SOCIAL app enabled? Please uncomment the following row
#rewrite ^/.well-known/webfinger /public.php?service=webfinger last;
#WEBFINGER app enabled? Please uncomment the following two rows.
#rewrite ^/.well-known/host-meta /public.php?service=host-meta last;
#rewrite ^/.well-known/host-meta.json /public.php?service=host-meta-json last;
client_max_body_size 10240M;
location / {
rewrite ^ /index.php;
}
location ~ ^/(?:build|tests|config|lib|3rdparty|templates|data)/ {
deny all;
}
location ~ ^/(?:\.|autotest|occ|issue|indie|db_|console) {
deny all;
}
location ^~ /apps/rainloop/app/data {
deny all;
}
location ~ \.(?:flv|mp4|mov|m4a)$ {
mp4;
mp4_buffer_size 100M;
mp4_max_buffer_size 1024M;
fastcgi_split_path_info ^(.+?.php)(\/.*|)$;
set $path_info $fastcgi_path_info;
try_files $fastcgi_script_name =404;
include fastcgi_params;
include php_optimization.conf;
}
location ~ ^\/(?:index|remote|public|cron|core\/ajax\/update|status|ocs\/v[12]|updater\/.+|oc[ms]-provider\/.+).php(?:$|\/) {
fastcgi_split_path_info ^(.+?.php)(\/.*|)$;
set $path_info $fastcgi_path_info;
try_files $fastcgi_script_name =404;
include fastcgi_params;
include php_optimization.conf;
}
location ~ ^\/(?:updater|oc[ms]-provider)(?:$|\/) {
try_files $uri/ =404;
index index.php;
}
location ~ \.(?:css|js|woff2?|svg|gif|map|png|html|ttf|ico|jpg|jpeg)$ {
try_files $uri /index.php$request_uri;
access_log off;
expires 360d;
}
}

Enregistrez et fermez ce fichier, puis créez le fichier vhost supplémentaire letsencrypt.conf :

nano /etc/nginx/conf.d/letsencrypt.conf

Copiez toutes les lignes dans le fichier :

server
{
server_name 127.0.0.1;
listen 127.0.0.1:81 default_server;
charset utf-8;
location ^~ /.well-known/acme-challenge
{
default_type text/plain;
root /var/www/letsencrypt;
}
}

Enregistrez et fermez ce fichier, puis créez un autre fichier vhost ssl.conf :

nano /etc/nginx/ssl.conf

Copiez toutes les lignes dans le fichier :

ssl_certificate /etc/ssl/certs/ssl-cert-snakeoil.pem;
ssl_certificate_key /etc/ssl/private/ssl-cert-snakeoil.key;
ssl_trusted_certificate /etc/ssl/certs/ssl-cert-snakeoil.pem;
#ssl_certificate /etc/letsencrypt/rsa-certs/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/rsa-certs/privkey.pem;
#ssl_certificate /etc/letsencrypt/ecc-certs/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/ecc-certs/privkey.pem;
#ssl_trusted_certificate /etc/letsencrypt/ecc-certs/chain.pem;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
ssl_session_timeout 1d; ssl_session_cache partagé: SSL: 50m;
ssl_session_tickets off; ssl_protocols TLSv1.3 TLSv1.2;
ssl_ciphers 'TLS-CHACHA20-POLY1305-SHA256: TLS-AES-256-GCM-SHA384: ECDHE-RSA-AES256-GCM-SHA512: DHE-RSA-AES256-GCM-SHA512: ECDHE-RSA-AESA386-GC DHE-RSA-AES256 GCM-SHA384 « ;
ssl_ecdh_curve X448: secp521r1: secp384r1: prime256v1;
ssl_prefer_server_ciphers on;
ssl_stapling on;
ssl_stapling_verify on;

Enregistrez et fermez ce fichier, puis créez un autre fichier vhost proxy.conf :

nano /etc/nginx/proxy.conf

Copiez toutes les lignes dans le fichier :

proxy_set_header host $ host;
proxy_set_header X-Real-IP $ remote_addr;
proxy_set_header X-Forwarded-Host $ hôte;
proxy_set_header X-Forwarded-Protocol $ schéma;
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;

Enregistrez et fermez ce fichier, puis créez un autre fichier vhost header.conf :

nano /etc/nginx/header.conf

Copiez toutes les lignes dans le fichier :

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 "no-referrer" always;
add_header X-Frame-Options "SAMEORIGIN";

Enregistrez et fermez ce fichier, puis créez un autre fichier vhost optimization.conf :

nano /etc/nginx/optimization.conf

Copiez toutes les lignes dans le fichier :

fastcgi_hide_header X-Powered-By;
fastcgi_read_timeout 3600;
fastcgi_send_timeout 3600;
fastcgi_connect_timeout 3600;
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]\.";

Enregistrez et fermez ce fichier, puis créez un autre fichier vhost php_optimization.conf :

nano /etc/nginx/php_optimization.conf

Copiez toutes les lignes dans le fichier :

fastcgi_param SCRIPT_FILENAME $ racine_document $ fastcgi_script_name;
fastcgi_param PATH_INFO $ path_info;
fastcgi_param HTTPS activé;
fastcgi_param modHeadersAvailable true;
fastcgi_param front_controller_active true;
gestionnaire php fastcgi_pass;
fastcgi_intercept_errors on;
fastcgi_request_buffering off;
fastcgi_cache_valid 404 1m;
fastcgi_cache_valid any 1h;
fastcgi_cache_methods GET HEAD;

Enregistrez et fermez ce fichier.

Étendez maintenant la sécurité du serveur et du système par la possibilité d'un échange de clé sécurisé à l'aide d'une clé Diffie-Hellman (Dhparam.pem) :

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

Soyez patient, la génération peut prendre de quelques minutes à une heure selon les performances du système. Dès que la génération est terminée, nous activons SSL dans le serveur Web Nginx et le redémarrons :

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

Nous commençons maintenant l'installation du logiciel Nextcloud et configurons les certificats SSL de Let's Encrypt en utilisant acme.

Changez de répertoire :

cd /usr/local/src

Téléchargez la version actuelle de Nextcloud :

wget https://download.nextcloud.com/server/releases/latest.tar.bz2

Décompressez le logiciel Nextcloud dans le répertoire Web, puis définissez l'autorisation appropriée et supprimez le téléchargement :

tar -xjf latest.tar.bz2 -C / var / www && chown -R www-data: www-data / var / www / && rm -f latest.tar.bz2

Veuillez vous assurer que votre serveur est accessible de l'extérieur via le port 80 / TCP ainsi que via le port 443 / TCP :

nmap IP du serveur

Nous créons maintenant un utilisateur dédié pour la gestion des certificats et l'ajoutons au groupe www-data :

adduser acmeuser
usermod -a -G www-data acmeuser

Pour renouveler le certificat ultérieurement :

visudo
acmeuser ALL=NOPASSWD: /bin/systemctl reload nginx.service

Enregistrez et fermez ce fichier.

Passez au shell du nouvel utilisateur pour installer le certificat et quittez à nouveau ce shell :

su - acmeuser
curl https://get.acme.sh | sh
exit

Créez trois répertoires avec les autorisations appropriées pour pouvoir y enregistrer les nouveaux certificats :

mkdir -p /var/www/letsencrypt/.well-known/acme-challenge /etc/letsencrypt/rsa-certs /etc/letsencrypt/ecc-certs
chmod -R 775 /var/www/letsencrypt /etc/letsencrypt && chown -R www-data:www-data /var/www/ /etc/letsencrypt

Basculez à nouveau vers le shell du nouvel utilisateur :

su - acmeuser

et générez les certificats SSL. Remplacez your.domain.tld par votre domaine :

acme.sh --issue -d your.domain.tld --keylength 4096 -w /var/www/letsencrypt --key-file /etc/letsencrypt/rsa-certs/privkey.pem --ca-file /etc/letsencrypt/rsa-certs/chain.pem --cert-file /etc/letsencrypt/rsa-certs/cert.pem --fullchain-file /etc/letsencrypt/rsa-certs/fullchain.pem

acme.sh --issue -d your.domain.tld --keylength ec-384 -w /var/www/letsencrypt --key-file /etc/letsencrypt/ecc-certs/privkey.pem --ca-file /etc/letsencrypt/ecc-certs/chain.pem --cert-file /etc/letsencrypt/ecc-certs/cert.pem --fullchain-file /etc/letsencrypt/ecc-certs/fullchain.pem

Quittez le shell du nouvel utilisateur :

exit

Puis créez un script qui vérifie et corrige les autorisations à l'avenir ( permissions.sh) :

nano /root/permissions.sh

Copiez toutes les lignes dans le fichier :

#!/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 /var/nc_data/
chmod 0644 /var/www/nextcloud/.htaccess
chmod 0644 /var/www/nextcloud/.user.ini
chmod 600 /etc/letsencrypt/rsa-certs/fullchain.pem
chmod 600 /etc/letsencrypt/rsa-certs/privkey.pem
chmod 600 /etc/letsencrypt/rsa-certs/chain.pem
chmod 600 /etc/letsencrypt/rsa-certs/cert.pem
chmod 600 /etc/letsencrypt/ecc-certs/fullchain.pem
chmod 600 /etc/letsencrypt/ecc-certs/privkey.pem
chmod 600 /etc/letsencrypt/ecc-certs/chain.pem
chmod 600 /etc/letsencrypt/ecc-certs/cert.pem
chmod 600 /etc/ssl/certs/dhparam.pem
exit 0

Rendez le script exécutable puis exécutez-le directement :

chmod + x /root/permissions.sh
/root/permissions.sh

Supprimez vos certificats auto-signés précédemment utilisés de Nginx et activez les certificats SSL Let's Encrypt nouveaux, complets et déjà valides :

sed -i '/ ssl-cert-snakeoil / d' /etc/nginx/ssl.conf
sed -is / \ # \ ssl / \ ssl / g /etc/nginx/ssl.conf

service nginx restart

Afin de renouveler automatiquement les certificats SSL et de lancer le redémarrage du serveur Web nécessaire, nous créons le script de renouvellement suivant :

nano /root/renewal.sh

#!/bin/bash
sudo -u acmeuser "/home/acmeuser/.acme.sh"/acme.sh --cron --home "/home/acmeuser/.acme.sh"
/usr/sbin/service nginx stop
/usr/sbin/service postgresql restart
/usr/sbin/service redis-server restart
/usr/sbin/service php7.3-fpm restart
/usr/sbin/service nginx restart
exit 0

Enregistrez ce script et marquez-le comme "exécutable".

chmod + x /root/renewal.sh

Il faut maintenant créer une nouvelle CRON :

crontab -e

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

À partir de maintenant, la recherche de certificats SSL renouvelables est effectuée chaque semaine et s'il y a un renouvellement de certificat possible, les certificats SSL sont mis à jour et le serveur Web redémarré, entièrement automatiquement !

Attendez la fin de l'installation du Nextcloud puis ajustez le fichier de configuration central du Nextcloud "config.php" en tant qu'utilisateur Web www-data.

Ajoutez votre domaine en tant que domaine de confiance, en ajoutant your.domain.tld avec votre domaine dédié :

sudo -u www-data php /var/www/nextcloud/occ config:system:set trusted_domains 0 --value=your.domain.tld

Définissez votre domaine comme overwrite.cli.url , complétez your.domain.tld avec votre domaine dédié :

sudo -u www-data php / var / www / nextcloud / occ config: system: set overwrite.cli.url --value = https: // your.domain.tld

Maintenant, nous allons étendre la configuration de Nextcloud.

Pour ce faire, enregistrez d'abord le fichier config.php existant, puis exécutez les lignes suivantes dans un bloc :

sudo -u www-data cp /var/www/nextcloud/config/config.php /var/www/nextcloud/config/config.php.bak 
sudo -u www-data sed -i 's / ^ [] * //' /var/www/nextcloud/config/config.php
sudo -u www-data sed -i '/); / d' /var/www/nextcloud/config/config.php
sudo -u www-data cat <<EOF >>/var/www/nextcloud/config/config.php
'activity_expire_days' => 14,
'auth.bruteforce.protection.enabled' => true,
'blacklisted_files' => 
array (
0 => '.htaccess',
1 => 'Thumbs.db',
2 => 'thumbs.db',
),
'cron_log' => true,
'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',
),
'filesystem_check_changes' => 0,
'filelocking.enabled' => 'true',
'htaccess.RewriteBase' => '/',
'integrity.check.disabled' => false,
'knowledgebaseenabled' => false,
'logfile' => '/var/nc_data/nextcloud.log',
'loglevel' => 2,
'logtimezone' => 'Europe/Paris',
'log_rotate_size' => 104857600,
'maintenance' => false,
'memcache.local' => '\OC\Memcache\APCu',
'memcache.locking' => '\OC\Memcache\Redis',
'overwriteprotocol' => 'https',
'preview_max_x' => 1024,
'preview_max_y' => 768,
'preview_max_scale_factor' => 1,
'redis' => 
array (
'host' => '/var/run/redis/redis-server.sock',
'port' => 0,
'timeout' => 0.0,
),
'quota_include_external_storage' => false,
'share_folder' => '/Shares',
'skeletondirectory' => '',
'theme' => '',
'trashbin_retention_obligation' => 'auto, 7',
'updater.release.channel' => 'stable',
);
EOF
sudo -u www-data sed -i "s/.*dbhost.*/\'dbhost\' \=\>\ \'localhost\:\/var\/run\/mysqld\/mysqld\.sock\'\,/g" /var/www/nextcloud/config/config.php

Modifiez le ".user.ini" :

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

Nextcloud est désormais pleinement opérationnel, optimisé et sécurisé.

Redémarrez tous les services concernés :

service nginx stop
service php7.3-fpm stop
service postgresql restart
service php7.3-fpm restart
service redis-server restart
service nginx restart

Configurer un cronjob pour Nextcloud en tant qu'utilisateur "www-data" :

crontab -u www-data -e

Insérez cette ligne :

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

Ensuite, enregistrez et fermez le fichier et configurez de "Ajax" à "Cron" en utilisant le CLI de Nextcloud :

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

Sécurité (Fail2ban et UFW)

Nous installons d'abord Fail2ban pour protéger le serveur contre les attaques par force brute et les tentatives de connexion incorrectes :

apt update && apt install fail2ban -y

Créer un nouveau fichier de filtre :

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

et copiez-y toutes les lignes suivantes :

[Definition]
failregex=^{"reqId":".*","remoteAddr":".*","app":"core","message":"Login failed: '.*' \(Remote IP: ''\)","level":2,"time":".*"}$
          ^{"reqId":".*","level":2,"time":".*","remoteAddr":".*","user,:".*","app":"no app in context".*","method":".*","message":"Login failed: '.*' \(Remote IP: ''\)".*}$
          ^{"reqId":".*","level":2,"time":".*","remoteAddr":".*","user":".*","app":".*","method":".*","url":".*","message":"Login failed: .* \(Remote IP: \).*}$

Enregistrez et fermez ce fichier et créez un nouveau fichier de jail :

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

Copiez-y toutes les lignes suivantes :

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

[nginx-http-auth]
enabled = true  

Redémarrez Fail2ban et vérifiez son état :

service fail2ban restart
fail2ban-client status nextcloud

À partir de maintenant, les adresses IP qui ont eu plus de 10 tentatives de connexion incorrectes sont bloquées pendant 36000 secondes (un jour) et votre serveur est ainsi protégé contre d'autres attaques.

Enfin, nous installons un pare-feu, connu sous le nom d'UFW :

apt install ufw -y
ufw allow 80/tcp
ufw allow 443/tcp
ufw allow 22/tcp

Définissez la journalisation du pare-feu sur "moyen" et empêchez les connexions entrantes non définies.

ufw logging medium
ufw default deny incoming

Activez le pare-feu et redémarrez-le :

ufw enable
service ufw restart

L'installation et la sécurisation de votre serveur Nextcloud est terminée et j'espère que vous apprécierez vos données dans votre cloud privé.