L’auto-hébergement est une pratique qui consiste à héberger ses services Internet personnels sur ses propres machines, chez soi. Il permet d’avoir le contrôle et la responsabilité de ses propres données, par exemple :
Il s’oppose à l’utilisation de services d’hébergements chez un prestataire et garantit donc votre indépendance, surtout si l’offre est gratuite (et que vos données sont donc le produit…).
En pratique, il s’agit d’installer et de configurer un ordinateur (serveur) chez soi, que l’on branche sur sa box Internet et que l’on laisse allumé en permanence.
NextCloud est une solution complète permettant de faire avant tout de l’hébergement de fichiers. Vous pouvez ainsi sauvegarder et synchroniser des fichiers depuis vos différents appareils (ordinateur de bureau, smartphone ou tablette). Il est également possible d’installer des applications, étendant ses fonctionnalités, comme :
On trouve sur cette page quelques éléments permettant d’auto-héberger un serveur de fichiers NextCloud, c’est-à-dire :
cloud.
d’un nom de domaine.Avant de poursuivre, il est important de rappeler que la gestion de ces services demande quelques compétences techniques et peut vite devenir chronophage.
Dans tout le guide, on préfixe par $
les commandes
exécutées par un utilisateur lambda et par #
celles
exécutées par un administrateur (compte root
). On essaie
autant que possible de préciser la machine sur laquelle sont exécutées
les commandes s’il peut y avoir une ambigüité.
Pour la suite, on utilise les variables :
${PUBLIC_IP} # votre IP publique, celle de votre box
${MONDOMAINE} # votre nom de domaine
${PRIVATE_IP} # l'IP privée de votre serveur
${ADMIN} # le nom de l'administrateur
Pour utiliser Nextcloud, possiblement à côté d’autres services personnels, il est recommandé de disposer d’un nom de domaine, idéalement court et mémorable. Pour cela, vous pouvez :
prendre un nom de domaine chez un registraire de nom de domaine (ou bureau d’enregistrement), par exemple gandi ;
renseigner votre IP publique, obtenue avec
$ curl -s ipecho.net/plain;echo
Le registraire est responsable de la maintenance de la base de données des noms de domaine réservés auprès de lui dont dépend le fonctionnement du DNS (Domain Name System pour « système des noms de domaine ») qui résout chaque nom de domaine en adresse IP.
Pour installer Nextcloud, il est nécessaire d’avoir une machine 64 bits, avec une distributions récente avec notamment :
Pour le détail des configurations matérielles et logicielles, voir la page.
La dernière
version de Nextcloud est la
29.0.2
du 06/06/2024.
La dernière version compatible avec un système 32 bits était la
24.0.12
et elle n’est plus maintenue depuis mai 2023 (EOL
32 bits nextcloud).
Je suis un adepte de Debian/GNU Linux depuis des années, tant pour serveur que pour desktop. On choisira donc comme système d’exploitation pour le serveur la dernière version stable, Debian 12 bookworm à la date de rédaction.
Télécharger une image iso minimale, par exemple :
$ wget https://cdimage.debian.org/debian-cd/current/amd64/iso-cd/debian-12.5.0-amd64-netinst.iso
qui nécessite pour l’installation une connexion internet ;
vérifier son intégrité
$ wget https://cdimage.debian.org/debian-cd/current/amd64/iso-cd/SHA512SUMS
$ sha512sum -c SHA512SUMS
Pour une version plus complète avec environnement de bureau, voir la liste des versions live.
copier l’image ISO sur une clé USB bootable de façon à démarrer
dessus avec Etcher en mode
graphique ou, à l’ancienne, avec dd
. Pour cela :
lister les disques pour trouver la clé USB
$ df -h
ou
$ lsblk
On considère pour la suite que la clé USB est sur
/dev/sda1
, à adapter donc ;
démonter la clé en root (avec sudo en préfixe)
$ sudo umount /dev/sda1
formater la clé en FAT32 en root
$ sudo mkfs.vfat -F 32 /dev/sda1
copier l’image iso sur le disque complet (et non pas sur une
partition, c’est-à-dire sur /dev/sda
et non pas
/dev/sda1
) :
$ sudo dd if=debian-12.5.0-amd64-netinst.iso \
of=/dev/sda status=progress bs=4M && sync
insérer la clé USB dans la machine hôte et booter dessus après avoir sélectionné la clé USB comme disque d’amorçage ;
choisir les différents paramètres, dont le partionnement du disque ;
ne rien installer, sauf serveur SSH, aussi faisable après avec
# apt install openssh-server
enlever la clé USB quand proposé puis redémarrer et se connecter
au compte utilisateur, ouvrir un terminal et se connecter en
root
:
$ su -
Pour toute question d’administration, voir le debian handbook.
éditer le fichier /etc/apt/sources.list
avec
vi
# vi /etc/apt/sources.list
en ajoutant à la fin de chaque ligne contrib non-free
,
de sorte à avoir les lignes actives :
deb http://deb.debian.org/debian/ bookworm main non-free-firmware contrib non-free
deb-src http://deb.debian.org/debian/ bookworm main non-free-firmware contrib non-free
deb http://deb.debian.org/debian/ bookworm-updates main non-free-firmware contrib non-free
deb-src http://deb.debian.org/debian/ bookworm-updates main non-free-firmware contrib non-free
deb http://security.debian.org/debian-security bookworm-security main non-free-firmware contrib non-free
deb-src http://security.debian.org/debian-security bookworm-security main non-free-firmware contrib non-free
mettre à jour les paquets :
# apt update && apt full-upgrade
et nettoyer (purger les paquets télécharger, les résidus de configuration et supprimer les paquets obsolètes)
# apt clean && apt autoclean && apt autoremove
Il peut être utile de créer une commande maintenance
avec
# cd ~
# echo "apt update && apt full-upgrade -y && apt clean \
&& apt autoclean && apt autoremove" > maintenance
où l’option -y
de apt full-upgrade
répond
automatiquement « oui » à la demande d’application des mises à jour. On
peut ensuite lancer cette succession de commandes une fois connecté en
root
$ su -
avec
# ./maintenance
# systemctl mask sleep.target suspend.target \
hibernate.target hybrid-sleep.target
# systemctl daemon-reload
Notez que pour restaurer la mise en veille, il suffit d’enlever ce masque :
# systemctl unmask sleep.target suspend.target \
hibernate.target hybrid-sleep.target
# systemctl daemon-reload
on installe sudo
pour garder une trace des commandes
superutilisateur
# apt install sudo
ajouter un utilisateur au groupe sudo
# /sbin/adduser <username> sudo
éditeur de texte : je suis de ceux qui utilisent Vim (plutôt qu’emacs)
# apt install vim
Voir mon tuto si
besoin. On peut aussi utiliser gedit
…
le définir comme éditeur de texte par défaut avec
# update-alternatives --config editor
installer (si oublié) un serveur SSH
# apt install openssh-server
logiciels de sauvegarde :
# apt install rsync borgbackup
${PRIVATE_IP}
;Voir les recommandations de l’ANSII relatives à la mise en œuvre d’un site Web.
Une connexion SSH permet d’accéder à distance au serveur en garantissant l’identité (authentification) des deux parties ainsi que la confidentialité de la communication (chiffrement asymétrique). Si j’ai l’habitude de suivre les recommandations de l’ANSSI, celles-ci datent de 2015 et il est supputé que ECDSA soit backdooré par la NSA. On privilégiera donc Ed25519 pour la génération des clés.
Voir le guide Mozilla pour une configuration « moderne », en particulier :
root
, il est impératif de désactiver la connexion
root
par SSH ;Pour ce faire :
sur votre machine d’administration, créer une paire de clés SSH :
$ ssh-keygen -t ed25519
et choisir le chemin et nom du fichier pour stocker les clés, par
exemple /home/$(whoami)/.ssh/${KEY}
/
sur le serveur, ajouter un utilisateur
${ADMIN}
:
# useradd -m ${ADMIN}
# passwd ${ADMIN}
copier la clé publique sur le serveur depuis la machine d’administration :
$ ssh-copy-id -i /home/$(whoami}/.ssh/${KEY} ${ADMIN}@${PRIVATE_IP}
sur le serveur, désactiver la connexion avec mot de passe pour
l’utilisateur ${ADMIN}
:
# usermod -L ${ADMIN}
éditer le fichier /etc/sudoers
(nécessite
sudo
) :
# visudo /etc/sudoers
pour ajouter la ligne
${ADMIN} ALL=(ALL) NOPASSWD:ALL
ajuster le shell pour bash
# chsh ${ADMIN} -s /usr/bin/bash
éditer ensuite le fichier de configuration de SSH :
# vim /etc/ssh/sshd_config
avec les lignes :
# Supported HostKey algorithms by order of preference.
HostKey /etc/ssh/ssh_host_ed25519_key
HostKey /etc/ssh/ssh_host_rsa_key
HostKey /etc/ssh/ssh_host_ecdsa_key
KexAlgorithms curve25519-sha256@libssh.org,ecdh-sha2-nistp521,ecdh-sha2-nistp384,ecdh-sha2-nistp256,diffie-hellman-group-exchange-sha256
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com,aes256-ctr,aes192-ctr,aes128-ctr
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512,hmac-sha2-256,umac-128@openssh.com
# Password based logins are disabled - only public key based logins are allowed.
AuthenticationMethods publickey
# LogLevel VERBOSE logs user's key fingerprint on login. Needed to have a clear audit track of which key was using to log in.
LogLevel VERBOSE
# Log sftp level file access (read/write/etc.) that would not be easily logged otherwise.
Subsystem sftp /usr/lib/ssh/sftp-server -f AUTHPRIV -l INFO
# Root login is not allowed for auditing reasons.
PermitRootLogin No
puis de relancer le service :
# service sshd restart
Avec ce paramétrage par clés SSH, il n’est pas nécessaire d’utiliser de mot de passe. La sécurité est simplement basée sur un jeu de clés en cryptographie asymétrique pour chiffrer de façon robuste la connexion.
Les connexions SSH « connues » sont stockées dans le fichier
/home/$(whoami)/.ssh/known_hosts
. Pour connaitre la ligne
associée à un serveur d’adresse IP <IP>
, il faut
exécuter la commande :
$ ssh-keygen -F <IP>
Si besoin, éditer le fichier pour supprimer la ligne en cas de changement de clé du serveur.
Un pare-feu, est un système permettant de protéger un ordinateur ou
un réseau d’ordinateurs des intrusions provenant d’un réseau tiers
(notamment Internet). Il permet de filtrer les paquets de données
échangés avec le réseau. On utilise UFW, acronyme de
Uncomplicated FireWall, qui est une interface pour
iptables
permettant de simplifier le processus de
configuration d’un pare-feu.
Installer le pare-feu
# apt install ufw
Autoriser les connexions SSH
# ufw allow ssh
Activer le pare-feu et le rendre actif à chaque démarrage
# ufw enable
Voir le statut du pare-feu et vérifier les règles actives
# ufw status
On parle de reverse-proxy pour désigner une application placée en frontal (directement en contact avec les utilisateurs du web) et qui joue le rôle d’intermédiaire avec des applications placées en backend (sans contact direct avec les utilisateurs web).
Dans un contexte d’auto-hébergement, le reverse proxy va
vous permettre d’héberger autant de services que vous voulez sur autant
de machines que vous voulez sur une seule adresse IP publique. C’est le
proxy qui va décider en fonction de l’URL que le visiteur veut joindre
vers quel service il va le rediriger. Par exemple, on peut envisager que
si vos utilisateurs arrivent sur ${MONDOMAINE}
, ils seront
redirigés sur le serveur web situé à l’adresse 192.168.1.X mais s’ils
tapent cloud.${MONDOMAINE}
, ils seront redirigés vers le
serveur qui gère le cloud, par exemple :
https://${PRIVATE_IP}:7868
Pour le reverse proxy, on utilise ici NGINX.
Installer NGINX
# apt install nginx
autoriser NGINX dans le pare-feu
# ufw allow 'Nginx HTTP'
# ufw allow 'Nginx HTTPs'
et vérifier le status
# ufw status
démarrer le service
# systemctl start nginx
puis le rendre actif à chaque démarrage
# systemctl enable nginx
Afin de sécuriser le protocole HTTP avec une couche de chiffrement SSL/TLS et garder privées les communications entre les utilisateurs et le serveur, on utilisera par défaut le HTTPS, en écoute du port TCP 443.
On se réfère aux recommandations de la fondation mozilla qui ne sont pas en contradiction avec celles de l’ANSSI. On utilise en particulier le générateur sur lequel on renseigne la version de NGINX, obtenue avec :
$ nginx -v
et celle de openssl
$ openssl version
Pour intégrer ces recommandations, il faut :
générer dhparam.pem
nécessaire à la configuration
SSL avec NGINX
# openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096
éditer le fichier /etc/nginx/nginx.conf
pour
TLSv1
et
TLSv1.1
sur la ligne ssl_protocols
pour ne
garder que TLSv1.2
et TLSv1.3
;ssl_prefer_server_ciphers
pour
off
;et donc avoir les lignes :
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-RSA-CHACHA20-POLY1305;
ssl_prefer_server_ciphers off;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
# HSTS (ngx_http_headers_module is required) (63072000 seconds)
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains;preload" always;
# OCSP stapling
ssl_stapling on;
ssl_stapling_verify on;
relancer NGINX
# systemctl reload nginx
# service nginx restart
On se base sur les recommandations de l’ANSII et sur l’article pour durcir les réponses HTTP du serveur, notamment :
iframes
;Pour cela, éditer le fichier de configuration :
# vim /etc/nginx/nginx.conf
en ajoutant les lignes :
server{
...
add_header Content-Security-Policy "default-src https: data: 'unsafe-inline' 'unsafe-eval'" always;
add_header Permissions-Policy "accelerometer=(), camera=(), geolocation=(), gyroscope=(), magnetometer=(), microphone=(), payment=(), usb=()";
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Xss-Protection "1; mode=block" always;
add_header X-Content-Type-Options "nosniff" always;
add_header 'Referrer-Policy' 'origin';
add_header X-Robots-Tag "noindex, nofollow" always;
...
}
puis relancer NGINX :
# service nginx restart
Vérifier ensuite votre configuration en faisant analyser votre site.
Voir les sollicitations des ressources et les processus
# apt install htop
qui fournit une jolie interface avec :
# htop
Contrôler les connexions actives sur votre système
# apt install netstat-nat
puis les voir avec :
# netstat-nat -L
Surveiller des logs des services du serveur :
# apt install rsyslog fail2ban
et le configurer
# cp /etc/fail2ban/jail.{conf,local}
# vim $_
en rajoutant, par exemple, dans la section [sshd]
enabled = true
maxretry = 3
bantime = 1200
pour baisser le nombre d’erreurs à 3 et pour doubler la durée de bannissement, puis relancer le service
# service fail2ban restart
Voir son état :
# fail2ban-client status
On utilise le travail d’Antonio Russo, et en particulier son tutoriel.
Ajouter la ligne
deb https://repo.aerusso.net/apt bullseye main
à votre fichier /etc/apt/sources.list
, mettre à jour
puis installer nextcloud-server
# apt install apt-transport-https
# wget -q -O - https://www.antonioerusso.com/public-key.asc \
| gpg --dearmor -o /etc/apt/trusted.gpg.d/antonioerusso.gpg
# apt update
# apt install nextcloud-server
Créer un lien symbolique avec le fichier de configuration créé :
# ln -s /etc/nginx/sites-available/nextcloud /etc/nginx/sites-enabled/.
Cette suite de commandes à permis d’installer le serveur Nextcloud et notamment la commande
nextcloud-server
. Il s’agit maintenant de configurer le
serveur :
# nextcloud-server preconfigure
# nextcloud-server start
se connecter à l’interface WEB
https://cloud.${MONDOMAINE}
en tant que
admin
;
ajouter les plugins :
Calendar
Tasks
Cospend
ajouter les paramètres defaut local
et
default phone region
en éditant le fichier
# vim /etc/nextcloud/config.php
avec les lignes :
...
'default_locale' => 'fr_FR',
'default_phone_region' => 'fr',
);
éditer le fichier de configuration
# vim /etc/nginx/sites-enabled/nextcloud
en ajoutant la ligne
server{
...
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
...
}
et autoriser les fichiers .mjs
avec
include mime.types;
types {
text/javascript js mjs;
}
Le système de cache permet de stocker en mémoire RAM (ou en SWAP si trop de RAM utilisée) certaines informations régulièrement sollicitées, évitant ainsi de passer par la base de données et donc en augmentant significativement les performances. On s’appuie sur la documentation de Nextcloud pour l’optimiser. Pour cela :
passer en mode maintenance :
# nextcloud-server occ maintenance:mode --on
Le memcache REDIS est normalement activé si en éditant le fichier
# vim /etc/nextcloud/config.php
vous voyez les lignes :
'memcache.locking' => '\\OC\\Memcache\\Redis',
'memcache.local' => '\\OC\\Memcache\\APCu',
'memcache.distributed' => '\\OC\\Memcache\\Redis',
'maintenance' => 'false',
activer PHP OPcache en éditant le fichier :
# vim /etc/php/8.2/fpm/php.ini
avec les lignes :
opcache.save_comments = 1
opcache.revalidate_freq = 60
opcache.validate_timestamps = 0
opcache.interned_strings_buffer=16
puis relancer le service :
# service php8.2-fpm restart
désactiver la maintenance
# nextcloud-server occ maintenance:mode --off
Les données des utilisateurs sont stockées dans le répertoire
/var/lib/nextcloud-server/data
.
Il est possible de créer les utilisateurs et les groupes depuis
l’interface Web, connecté en admin
ou avec les
commandes :
$ nextcloud-server occ group:add <group>
$ nextcloud-server occ user:add <user>
Voir toutes
les commandes occ
.
Pour les contacts et l’agenda, il est nécessaire :
Contacts
pour utiliser le
Carnet d'adresses DAVx5
puis dans l’onglet
Gestion des contacts
, sélectionner
Stockage par défaut
pour pointer sur le
Carnet d'adresses DAVx5
;Pour les tâches, installez OpenTasks, qui se synchronise directement avec DAVx5.
Pour les comptes partagés, installez MoneyBuster,
qui permet d’interagir avec le plugin Cospend
de NextCloud.
On trouve librement dans F-Droid. Bref, tout est fait pour vous simplifier la vie !
Si vous êtes fan des applications graphiques, ajoutez votre compte NextCloud à Gnome, section « Online accounts ». Contacts et agenda seront immédiatement intégrés à ceux de Gnome. Sinon :
installer le client
# apt install nextcloud-desktop
installer
# apt vdirsyncer
puis configurer en éditant le fichier
~/.vdirsyncer/config
avec
[general]
status_path = "~/.vdirsyncer/status/"
[pair calendar]
a = "local_calendar"
b = "nextcloud_calendar"
collections = ["personal", "work"]
conflict_resolution = "b wins"
metadata = ["displayname", "color"]
[storage local_calendar]
type = "filesystem"
path = "~/Calendars/nextcloud/"
fileext = ".ics"
[storage nextcloud_calendar]
type = "caldav"
username = <MOI>
password = <MONMOTDEPASSE>
url = "https://${MONDOMAINE}/remote.php/dav/calendars/<MOI>/"
[pair contacts]
a = "local_contacts"
b = "nextcloud_contacts"
collections = ["from a", "from b"]
conflict_resolution = "a wins"
metadata = ["displayname", "color"]
[storage local_contacts]
type = "filesystem"
path = "~/Contacts/nextcloud/"
fileext = ".vcf"
[storage nextcloud_contacts]
type = "carddav"
username = <MOI>
password = <MONMOTDEPASSE>
url = "https://${MONDOMAINE}/remote.php/dav/addressbook/<MOI>/personnal"
On notera qu’il est évidemment plus raisonnable d’utiliser le gestionnaire de mots de passe pass avec une commande du type :
password.fetch = ["command", "pass", "nextcloud"]
plutôt que la ligne :
password = ...
Le plus simple pour tenir à jour son serveur est d’avoir sur sa machine d’administration un script du genre :
#!/usr/bin/env bash
ping -q -w 1 -c 1 ${PRIVATE_IP} > /dev/null \
&& ssh -t ${ADMIN}@${PRIVATE_IP} "( \
sudo apt update && \
sudo apt full-upgrade && \
sudo apt clean && \
sudo apt autoclean && \
sudo apt autoremove \
)" \
&& echo -e "\n *** Server up to date. *** \n" \
|| return 1
que l’on doit exécuter idéalement tous les jours. L’avantage par rapport à une tâche automatique est la présence et donc la veille de l’administrateur en cas de casse d’un paquet, voire du système.
Les mises à jour de NextCloud ne peuvent pas se faire directement par l’interface Web mais doivent être faites depuis le serveur. Il est toujours nécessaire de monter graduellement de version. En cas de doute, utilisez la version renseignée sur l’interface. Exemple de montée de versions :
# nextcloud-server upgrade 28.0.3
# nextcloud-server upgrade 29.0.1
# nextcloud-server upgrade 29.0.2
La dernière
version de Nextcloud est la
29.0.3
du 06/06/2024.
Vous pouvez vérifier l’état de mise à jour et la sécurisation de
votre instance nextcloud à partir de l’interface de gestion, section
Vue d'ensemble
ou en utilisant le test de sécurité de nextcloud
pour lequel vous devez avoir un résultat A+
.
Voir cette page pour les commandes de gestion ou de maintenance, par exemple :
ajouter les index de BDD
# nextcloud-server occ db:add-missing-indices
convertir en big int
# nextcloud-server occ db:convert-filecache-bigint
Lors de l’installation de NextCloud, les certificats HTTPS sont générés avec Let’s Encrypt et son application certbot que l’on peut installer comme :
# apt install certbot
Pour générer des certificats SSL, il faut :
arrêter NGINX
# service nginx stop
générer les certificats
# certbot certonly --standalone -d ${MONDOMAINE}
qui va créer deux fichiers :
/etc/letsencrypt/live/${MONDOMAINE}/fullchain.pem
/etc/letsencrypt/live/${MONDOMAINE}/privkey.pem
puis relancer NGINX.
# service nginx start
Les certificats pour votre sous-domaine
cloud.${MONDOMAINE}
sont générés à l’installation de NextCloud. Comme tous les certificats
Let’s Encrypt, la question de
leur renouvellement se pose tous les trois mois. Pour voir les
certificats :
# certbot certificates
Pour renouveler les certificats en fin de vie, il faut :
# service nginx stop
# certbot renew
# service nginx start
Pour vérifier tout changement de l’IP publique, on peut comparer l’adresse précédente de l’actuelle trouvée avec
curl -s https://ipecho.net/plain;echo
Pour gérer les changements intempestifs d’adresses IP de certains FAI, vous pouvez vous inspirer de mon tuto.
La documentation de NextCloud
n’étant pas des plus claires sur ce point, notamment lorsque la base de
données MariaDB
tourne dans un socket, on préfère
aller librement. On s’inspire toutefois un peu de ce
script, mais d’assez loin tant les différences sont nombreuses.
Pour réaliser les sauvegardes, on utilise un script « maison » nextcloud_backup.sh. Le principe est de réaliser successivement :
une sauvegarde de la base de données utilisée par NextCloud, avec la commande :
# mysqldump --single-transaction --default-character-set=utf8mb4 \
-h localhost --protocol=socket --socket ${DB_HOST} \
-u root -p${DB_PASSWORD} ${DB_NAME} > ${DUMP_DIR}/${DUMP_FILE}
de créer le backup incrémental dédupliqué avec borgbackup :
# borg create --verbose --filter AME --list --stats --show-rc \
--compression lz4 \
--exclude-caches --exclude 'home/*/.cache/*' --exclude 'var/tmp/*' \
${BACKUPS_HD}/${BACKUPS_DIR}::${ARCHIVE} \
/etc /home /opt /root /srv /usr /var
Comme on sauvegarde sur un disque dur externe, on s’assure évidemment au début de toute exécution qu’il soit monté et sinon on encourage l’administrateur à le brancher au serveur et à relancer la commande.
Télécharger le fichier nextcloud_backup.sh
# wget nmesnier.free.fr/files/nextcloud_backup.sh
le copier dans le répertoire ~/
;
# cp -t ~ nextcloud_backup.sh
le rendre exécutable :
# chmod +x ~/nextcloud_backup.sh
éditer le script nextcloud_backup.sh
, pour ajuster
les paramètres suivants :
DB_HOST
Hôte de la base de donnée, fixé à
"/run/mysqld/mysqld.sock"
;
DB_NAME
Nom de la base de données, fixé à "nextcloud"
;
DB_USER
Nom de l’utilisateur de la base de données, fixé à
"nextcloud"
;
DB_PASSWORD
Mot de passe de l’utilisateur de la base de données, contenu dans
/etc/nextcloud/dbpasswd
;
DUMP_DIR
Répertoire pour stockage temporaire des dumps de la base de données,
fixé à "/var/mysqldump"
;
DUMP_FILE
Nom du fichier de dump de la base de données, fixé à
"nextcloud-db_$(date +%Y-%m-%d).sql"
. Par exemple pour le
27/06/2023, on crée le fichier :
nextcloud-db_2023-06-27.sql
BACKUPS_HD
Point de montage du disque dur externe pour réaliser les sauvegardes,
fixé à "/mnt/backup_HD"
;
BACKUPS_DIR
Répertoire de stockage des données de sauvegardes avec borgbackup, fixé à
"myserver-backups"
;
ARCHIVE
Nom de l’archive permettant de reconstruire l’image du serveur à la
date de sauvegarde, fixé à "myserver_$(date +%Y-%m-%d)"
.
Par exemple pour le 27/06/2023, on crée l’archive :
myserver_2023-06-27
BORG_PASSPHRASE
La phrase de passe du chiffrement de la sauvegarde avec borgbackup.
Il est possible de réaliser une sauvegarde manuellement avec la commande :
# ./nextcloud_backup.sh
qui démontera automatiquement votre disque dur externe de sauvegarde une fois cette dernière effectuée.