# Installation d'un serveur de sauvegarde

Ajouter les backports bullseye dans `/etc/apt/source.list.d/` :
```
echo "deb http://ftp.fr.debian.org/debian/ bullseye-backports main" > /etc/apt/sources.list.d/backports.list
```

Installer les paquets nécessaires :
```
apt update
apt install -t bullseye-backports borgmatic borgbackup
apt install rsync gawk bc 
```

Désactiver le lancement quotidien de Borgmatic :
```
systemctl stop borgmatic.timer
```

Créer un utilisateur dédié `borg` :
```
adduser --disabled-password --system --group --home /srv/borg/ --shell /bin/bash borg
```

Créer des clés `ssh` pour l'utilisateur `root` (si besoin) :
```
ssh-keygen -t ed25519
```

Récupérer les scripts et modèles :
```
cd ~borg/
mkdir bin models
URL=https://git.a-lec.org/a-lec/commissions/infrastructure/sauvegardes/-/raw/main/Plan%20Borg/
cd bin
wget -nv $URL/bin/countbackups
wget -nv $URL/bin/dobackup-server
wget -nv $URL/bin/dobackup-remote
wget -nv $URL/bin/dobackup-rsync
wget -nv $URL/bin/dobackups
wget -nv $URL/bin/dochecks
wget -nv $URL/bin/dochecksb
wget -nv $URL/bin/doinit
wget -nv $URL/bin/doprunes
wget -nv $URL/bin/doprunesb
wget -nv $URL/bin/lastbackups
cd ../models
wget -nv $URL/models/cron
wget -nv $URL/models/excludes
wget -nv $URL/models/model-conf-local.yaml
wget -nv $URL/models/model-conf-remote.yaml
#wget -nv $URL/models/model-conf-remote-client.yaml
#wget -nv $URL/models/model-conf-rsync.yaml
wget -nv $URL/models/retention.yaml
cd .. ; find
```

Déployer la configuration générique de Borgmatic :
```
mkdir -p /etc/borgmatic/ /etc/borgmatic.d/
cp /srv/borg/models/retention.yaml /etc/borgmatic/
cp /srv/borg/models/excludes /etc/borgmatic/
```
Définir une passphrase générique : 
```
echo "XXXXXXXXXXXXXXXXXXXXXXXXXXX" > ~borg/.borg-passphrase
```

Ajouter la ligne suivante dans `/root/.bashrc` (facilite la commande `borg` directe même si normalement on fait tout avec la commande `borgmatic`) :
```
export BORG_PASSCOMMAND="cat /srv/borg/.borg-passphrase"
```

Créer un dossier dédié aux sauvegardes du plan Borg :
```
mkdir -p /var/backups/borg
chown borg /var/backups/borg
```

Configurer le `cron` dans `/etc/cron.d/backups` :
```
cp /srv/borg/models/cron /etc/cron.d/backups
cd /srv/borg/
ln -s /etc/cron.d/backups cron
```

# Configurer la sauvegarde du serveur de sauvegarde

Initialiser le contexte Borgmatic :
```
/srv/borg/bin/doinit-local
```

Lancer la première sauvegarde locale (dure moins d'une minutes) :
```
time /srv/borg/bin/dobackup-local
```

Afficher les informations du dépôt :
```
borgmatic -c /etc/borgmatic.d/$(hostname).yaml info
```

Afficher la liste des sauvegardes du dépôt :
```
borgmatic -c /etc/borgmatic.d/$(hostname).yaml list
```

Afficher le contenu de la sauvegarde :
```
borgmatic -c /etc/borgmatic.d/$(hostname).yaml list --archive $(borgmatic -c /etc/borgmatic.d/$(hostname).yaml list --short | tail -1)
```

Ajouter le déclenchement de la sauvegarde dans `/srv/borg/bin/dobackups` :
```
/srv/borg/bin/dobackup-local
```

# Configurer la sauvegarde d'une machine en remote

C'est le cas nominal. Le principe consiste à configurer le serveur de sauvegarde pour déclencher l'action de sauvegarde sur la machine à sauvegarder.

## Côté machine à sauvegarder

Script expérimental (s'arrêtant à l'ajout de la passphrase, reprendre à ce moment ci-dessous) :
```
wget -O /tmp/deploy-remote https://forge.a-lec.org/cominfra/sauvegardes/raw/branch/main/bin/deploy-remote
bash /tmp/deploy-remote
```

Sinon, mode manuel ci-après.

Installer les paquets nécessaires :
```
apt update
apt install -t bullseye-backports borgmatic borgbackup
```

Par défaut, le service Systemd de Borgmatic n'a pas d'action en paramètre et cela déclenche une série d'actions : `prune`, `create…` Le prune est lancé côté serveur donc il faut forcer l'action `create`. De même, des actions de restrictions de permissions y sont activées donc il faut les désactiver. Ces changements sont à faire dans `/usr/lib/systemd/system/borgmatic.service` :

```
sed -i s#/usr/bin/borgmatic#/usr/bin/borgmatic\ create# /usr/lib/systemd/system/borgmatic.service
sed -i 's/CapabilityBoundingSet/#CapabilityBoundingSet/' /usr/lib/systemd/system/borgmatic.service
systemctl daemon-reload
```

Créer des clés `ssh` pour l'utilisateur `root` (si besoin) :
```
ssh-keygen -t ed25519
```

Créer et peupler le dossier de configuration de Borgmatic :
```
mkdir -p /etc/borgmatic
cd /etc/borgmatic
URL=https://git.a-lec.org/a-lec/commissions/infrastructure/sauvegardes/-/raw/main/Plan%20Borg/
wget -nv $URL/models/excludes
wget -nv $URL/models/model-conf-remote-client.yaml -O /etc/borgmatic/config.yaml
mkdir -p /etc/borgmatic/hooks/
cd /etc/borgmatic/hooks
wget -nv $URL/bin/dumps
wget -nv $URL/bin/dump-msql
wget -nv $URL/bin/dump-psql
wget -nv $URL/bin/dump-influx
chmod u+x /etc/borgmatic/hooks/dump*
```

Configurer la passphrase dans `/etc/borgmatic/config.yaml` :
```
     encryption_passphrase: 'XXXXXXXXXXXXXX'
```

Vérifier que la configuration Borgmatic est valide :
```
validate-borgmatic-config
```

Si besoin, suivant les particularité de la machine à sauvegarder, ajouter des entrées dans le fichier `/etc/borgmatic/excludes`.


## Côté serveur de sauvegarde

Initialiser le contexte Borgmatic :
```
/srv/borg/bin/doinit-remote foo.bar.org
```

Ajouter un accès ssh restreint dans `/srv/borg/.ssh/authorized_keys` :
```
command="export BORG_PASSCOMMAND=/srv/borg/.borg-passphrase; borg serve --restrict-to-path /var/backups/borg/foo.bar.org.repo/ --restrict-to-repository /var/backups/borg/foo.bar.org.repo --append-only",restrict ssh-rsa AAAAZZZZZ root666@foo.bar.org
```

## Tester côté marchine à sauvegarder

Valider les clés des serveurs de sauvegarde (ignorer l'erreur) :
```
ssh -p222 borg@sauvkipeu.libre-en-communs.org
ssh -p222 borg@gardefou.libre-en-communs.org
```

Lancer une première sauvegarde (prévoir 2 min) :
```
systemctl start borgmatic
```

## Tester côté serveur

~~Lancer une sauvegarde : `time /srv/borg/bin/dobackup-remote foo.bar.org`.~~

Afficher les informations du dépôt :
```
borgmatic -c /etc/borgmatic.d/foo.bar.org.yaml info
```

Afficher la liste des sauvegardes du dépôt :
```
borgmatic -c /etc/borgmatic.d/foo.bar.org.yaml list
```

Afficher le contenu de la sauvegarde :
```
borgmatic -c /etc/borgmatic.d/foo.bar.org.yaml list --archive 2023-XX-XXTXX:XX
```

~~Ajouter~~ **Ne pas ajouter** le lancement de la sauvegarde dans `/srv/borg/bin/dobackups` :
```
 /srv/borg/bin/dobackup-remote foo.bar.org
```

# Configurer la sauvegarde d'une machine en rsync (OpenWRT)

Le principe de cette sauvegarde consiste en deux étapes :
- création d'un miroir de la machine à sauvegarder ;
- sauvegarde borgmatic du miroir.

C'est notamment adapté aux cas des routeurs OpenWRT où le logiciel Borgmatic n'est pas déployable.

## Côté machine à sauvegarder (OpenWRT)

Prérequis : installer rsync.

Recommandation d'exporter quotidiennement la configuration Luci en ajoutant dans `/etc/crontabs/root` :
```
54 23 * * *  /sbin/sysupgrade --create-backup /root/backup-config-${HOSTNAME}.tgz
```

Bizarrement, dans `/etc/dropbear/`, on trouve les clés privés de la machine mais sans les clés publiques /o\ Pour contourner le problème, on va créer une paire de clé dédiées à la sauvegarde. On va la stocker à l'endroit habituel `/root/.ssh/` où viendra également le fichier `known_hosts`.

Créer des clés `ssh` dédiées à la sauvegarde pour l'utilisateur `root` :
```
mkdir ~/.ssh 
chmod go-rwx .ssh/
dropbearkey -t ed25519 -f ~/.ssh/backup_ssh_key
Generating 256 bit ed25519 key, this may take a while...
Public key portion is:
ssh-ed25519 AAAA5555555555555555555555555555555555555555555555555555555555555555 root@leparc
Fingerprint: sha1!! 55:55:55:55:55:55:55:55:55:55:55:55:55:55:55:55:55:55:55:55
```
Copier la clé publique ci-dessus (toute la ligne « ssh-ed25519 AAAA… ») dans le fichier `~/.ssh/backup_ssh_key.pub`.

Récupérer le script de synchronisation :
```
mkdir -p /root/bin/
cd /root/bin
URL=https://git.a-lec.org/a-lec/commissions/infrastructure/sauvegardes/-/raw/main/Plan%20Borg/
wget -nv $URL/bin/push-mirror
chmod u+x /root/bin/push-mirror
```

Ajouter l'appel dans `/etc/crontabs/root` :
```
55 23 * * *  /root/bin/push-mirror
```

## Côté serveur de sauvegarde

Initialiser le contexte Borgmatic :
```
/srv/borg/bin/doinit-rsync foo.bar.org
```

Ajouter un accès ssh restreint dans `/srv/borg/.ssh/authorized_keys` :
```
command="/usr/bin/rrsync -wo /var/backups/borg/mirrors/foo.bar.org/",restrict ssh-ed25519 AAAAXXXXXXXXXXXX root@foo.bar.org
```

Ajouter le lancement de la sauvegarde dans `/srv/borg/bin/dobackups` :
```
/srv/borg/bin/dobackup-rsync foo.bar.org
```

## Tester côté marchine à sauvegarder

Valider les clés des serveurs de sauvegarde (ignorer l'erreur) :
```
ssh -p222 sauvkipeu.libre-en-communs.org
ssh -p222 gardefou.libre-en-communs.org
```

Lancer une première synchronisation du miroir :
```
/root/bin/push-mirror
```

## Tester côté serveur

Lancer une sauvegarde :
```
borgmatic -c /etc/borgmatic.d/foo.bar.org create --verbosity 1
```

Afficher les informations du dépôt :
```
borgmatic -c /etc/borgmatic.d/foo.bar.org.yaml info
```

Afficher la liste des sauvegardes du dépôt :
```
borgmatic -c /etc/borgmatic.d/foo.bar.org.yaml list
```

Afficher le contenu de la sauvegarde :
```
borgmatic -c /etc/borgmatic.d/foo.bar.org.yaml list --archive 2023-XX-XXTXX:XX
```