Gnuragist.es

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
# Borgmatic

Mettre en place un serveur accessible en `ssh` et disposant d'un espace de stockage qui pourra accueillir les sauvegardes de différentes machines appartenant à l'un ou l'autre compte.

Les sauvegardes seront réalisées avec [borgmatic](https://torsion.org/borgmatic/) qui facilite la mise en place de [borg](https://borgbackup.readthedocs.io/en/stable/index.html).

```
NOM_DU_COMPTE   = Une personne ou une assoss
NOM_DE_MACHINE  = Une machine appartenant à NOM_DU_COMPTE
SERVEUR_BORG    = Le serveur qui accueillera les sauvegarder
STOCKAGE_BORG   = L'espace disque prévu pour les sauvegardes sur SERVEUR_BORG
PHRASE_DE_PASSE = La phrase de passe pour chiffrer et déchiffrer les sauvegardes d'une NOM_DE_MACHINE
CLE_SSH         = Chemin vers une clé privée SSH
```

## Serveur

Le serveur peut-être un Debian récent disposant d'un accès `ssh`.  Merci de veiller à ce que `root` ne puisse pas se connecter directement et de mettre en place un utilisateur qui aura un accès par clé ssh //(ed25519 si possible ou RSA4096)//.  Cet utilisateur n'aura pas d'accès par mot de passe et n'aura pas le droit d'utiliser `sudo`.

### Installation

Borg est disponible dans les dépôts sur Debian.

```
apt install borgmatic
```

### Créer un compte

Le dossier `home` de chaque nouveau compte devrait se trouver sur `STORAGE`.

```
adduser --home /media/STORAGE/NOM_DU_COMPTE NOM_DU_COMPTE
```

### R/W sur storage pour l'utilisateur uniquement

Pour limiter les accès au `STORAGE` de `NOM_DU_COMPTE`.

```
chmod 700 /media/STORAGE/NOM_DU_COMPTE
```

## Machine

Un `NOM_DU_COMPTE` peut avoir plusieurs `NOM_DE_MACHINE` virtuelles ou non dont les sauvegardes seraient envoyées sur `NOM_DU_COMPTE@SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_DE_MACHINE`.  Chacune de ces destinations /(repository ou repo)/ étant initiée avec son propre mot de passe et sa propre clé de chiffrement.

Depuis chaque `NOM_DE_MACHINE` c'est `root` qui se connectera sur `NOM_DE_COMPTE@SERVEUR_BORG` et il est donc nécessaire de générer une clé ssh /(ed25519 de préférence ou bien RSA 4096)* qui sera copiée sur le `SERVEUR_BORG` pour son `NOM_DE_COMPTE`.

### Faire une clé ecd25219 sans mot de passe

```
ssh-keygen -t ed25519 -C ""
et ne pas mettre de phrase de passe
```

### La copier sur le serveur borg

```
ssh-copy-id NOM_DU_COMPTE@SERVEUR_BORG
```

### Configurer le client SSH

Pour indiquer à SSH comment se connecter à `SERVEUR_BORG`

```
# nano ~/.ssh/config
Host SERVEUR_BORG
User NOM_DU_COMPTE
IdentityFile ~/.ssh/CLE_SSH
PreferredAuthentications publickey,password
```

### Installer borgmatic

```
apt install borgmatic
```

### Générer une config de base

```
generate-borgmatic-config
```

### Initier le repo sur le serveur

#### Sans chiffrement

Déconseillé.

#### Avec chiffrement

Voir [la documentation](https://borgbackup.readthedocs.io/en/stable/usage/init.html#borg-init)

```
# borg init --encryption=repokey-blake2 SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE
Passe phrase : PHRASE_DE_PASSE
```

```
# borg key export SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE /dev/stdout
BORG_KEY f6dc3da161fa259ad8c79380b2593d4996e4fb3c3efd802c88d996dd93b5f250
hqlhbGdvcml0aG2mc2hhMjU2pGRhdGHaAZ6DIeXAqvfULdYvWU6QooZHvmEaUvP3yzjQj9
l2I7xiDA/5rOjlP8kUFpefFtlMgo0gVcG8NQzqlZu8LQ/yFE3y52ldLc692D9Hr/rmrF+t
9wo7gvy33BaQmh+MrmbabipuJfm6p+u0lso11OJOwoX/GBXghL1lpazQnlERU1PqZZfiDe
ct6R1B67vdvQZXhVOuuYuLH9BNDMpq0eSc+9VHV3M/wFygmQtXfpcPTW2GekuQfSp9sk3D
a2pSFZs+wOMSZrx432DG5l/dbMXZgwmYgsMuixR2b+d/dNjSheMPy8tju2qCWL+ChbAm9A
oETPxAAOdBWUzxGgXPpnmuLxrjHf+XMpnt8E0fW6cqd/hdi2yuZJ0f7daZTVSM0KphHcP2
61JM+elY+xBFur8ibVekYllMC3Ot94DU/SYdAATxv8+X99tyB2UreGYxlwhCXUHNGba2XO
WWaDVNciAc1xc3sAX1gBVihEpZV4EbTPWkNj9DD3sWks9O0OeqTHdnhMVD1fpkKw2GDhfs
qb77w6DSwVZRnpgK58QwYDiTogukaGFzaNoAIIjMp6rDyIGoH+kxvLmOMq7w7/vzIL7PfO
wQvKVucuWuqml0ZXJhdGlvbnPOAAGGoKRzYWx02gAg0tq+i2wceA8guVTmn4AzKJsJRDb8
ueHXWCC+xBNhDNKndmVyc2lvbgE=
```
Et la coller dans le `password-store` du NOM_DU_COMPTE dans borg_sur_SERVEUR en tant que commentaire repokey-blake2 = "coller la clé".

### Éditer la config

```
nano /etc/borgmatic/config.yaml
# ceci est un exemple
location:
    source_directories:
        - /
    repositories:
        - SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE
    exclude_patterns:
        - /dev
        - /proc
        - /sys
        - /tmp
        - /run
        - /lost+found
        - /swapfile
        - /var/cache/apt
        - /mnt/mmcboot
storage:
    encryption_passcommand: secret-tool lookup borg-repository repo-name
    encryption_passphrase: "PHRASE_DE_PASSE"
    compression: lz4
retention:
    keep_daily: 7
    keep_monthly: 2
```

### Borg info

Depuis le client

```
borg info SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE
Et donner la PHRASE_DE_PASSE
```


Depuis le serveur

```
borg info /media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE
Et donner la PHRASE_DE_PASSE
```

### Borg mount

Depuis le serveur

```
mkdir /tmp/test
borg mount /media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE
```

### Cron

```
nano /etc/cron.d/borgmatic
Et mettre :
42 0 * * * root /usr/bin/borgmatic --create --prune
42 1 * * 0 root /usr/bin/borgmatic --check
```


## Pour tator et les briques

Pour mettre en pratique ce qui est expliqué plus haut, voici ce qui se fait pour un cas particulier de **mabrique** et de **tator** qui sont deux Olimex LIME1 dans une cave connectées à Internet.

**mabrique** dispose d'une IP publique grâce à un [vpn de Neutrinet](https://neutrinet.be) et **tator** est sur le même réseaulocal //(LAN)//.

D'autre [briques internet](https://labriqueinter.net) viennent déposer leur sauvegardes `borgmatic` en passant //(jump)// par **mabrique** pour atteindre **tator**.

### Sur mon ordi

Créer un `password-store` avec [GoPass](https://woile.github.io/gopass-cheat-sheet/).

```
pass init --store NOM_DU_COMPTE
```

Et dans ce `password-store`:

* créer un mot de passe pour `NOM_DU_COMPTE_sur_mabrique` dans `misc` avec comme commentaire `username = NOM_DU_COMPTE`.
* créer un mot de passe pour `NOM_DU_COMPTE_sur_tator` dans `misc` avec comme commentaire `username = NOM_DU_COMPTE`.
* créer un mot de passe pour `NOM_DEMACHINE_sur_tator` dans `misc` avec comme commentaire `repokey-blake2 = comming soon` pour y coller **plus tard** la clé obtenue depuis `NOM_DE_MACHINE` avec la commande `borg key export NOM_DU_COMPTE@SERVEUR_BORG:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE FICHIER_TEMP` /(voir plus haut)/.

### Sur mabrique

Créer un utilisateur pour `NOM_DU_COMPTE` avec le mot de passe créé précédemment.

```
adduser NOM_DU_COMPTE
```

Ce `NOM_DU_COMPTE` recevra la clé publique de `root` d'une `NOM_DE_MACHINE` /(cf. plus haut)/ qui devra envoyer ses sauvegardes.

Modifier la configuration de `ssh` pour autoriser le `saut ssh` vers `tator`.  :!: Yunohost gère la configuration de `ssh`, donc cela va lever un warning pour le diagnostic automatique de Yunohost qui signalera que la configuration a changé.

```
nano /etc/ssh/sshd_config
…
Match User admin,root,NOM_DU_COMPTE, AUTRE_NOM_DU_COMPTE, etc.
    AllowTcpForwarding yes
    AllowStreamLocalForwarding yes
    PermitUserRC yes
…
service ssh reload
```

### Sur tator

Il faut créer un utilisateur `NOM_DU_COMPTE` pour accueillir la clé de `root` de chaque `NOM_DE_MACHINE` ce qui permettra un accès `ssh` sans mot de passe.

```
adduser --home /media/STORAGE/NOM_DU_COMPTE NOM_DU_COMPTE
```

Et changer les droits du `home` pour ce NOM_DU_COMPTE.

```
chmod 700 /media/STORAGE/NOM_DU_COMPTE
```

### Sur une machine

Faire une clé ssh pour `root` sans mot de passe sur `NOM_DE_MACHINE` qui sera sauvegardée.

```
root@NOM_DE_MACHINE:/root# ssh-keygen -t ed25519
Generating public/private ed25519 key pair.
Enter file in which to save the key (/root/.ssh/id_ed25519): 
Created directory '/root/.ssh'.
Enter passphrase (empty for no passphrase): -ne rien mettre-
Enter same passphrase again: -ne rien mettre-
```

Ajouter `tator` et `mabrique` dans le `/root/.ssh/config` pour le proxy jump ssh.

```
# nano /root/.ssh/config
Host tierce
  Hostname tierce.nohost.me
  User NOM_DU_COMPTE  

Host tator
  Hostname 192.168.1.9
  User NOM_DU_COMPTE
  ProxyJump tierce
```
Copier la clé de `root` sur ma brique.

```
ssh-copy-id tierce
```

Copier la clé de `root` sur tator.

```
ssh-copy-id tator
```

Installer `borgmatic`.

```
apt install borgmatic
```

Créer une config de base pour borgmatic.

```
generate-borgmatic-config
```

Vérifier ce qui est monté pour éventuellement l'exclure des sauvegardes puisque ce qui sera sauvegardé c'est `/` /(tout le système)/ et que parfois, pour les briques qui sont sur un disque SATA ou USB par exemple, la carte SD avec l'ancien système est montée sur `/media/mmcboot`.

```
mount
et/ou bien:
df
et/ou bien:
ls /mnt
et/ou bien:
ls /media
```
Modifier le fichier de config de borgmatic.

```
nano /etc/borgmatic/config.yaml #voir exemple plus haut
```

Initier le repo borg pour NOM_DE_MACHINE.

```
borg init --encryption=repokey-blake2 tator:/media/STORAGE/NOM_DU_COMPTE/NOM_DE_MACHINE
```

Copier la clé de chiffrement dans le password store du client sur mon ordinateur.

```
# borg key export tator:/media/STORAGE/NOM_DU_COMPTE/NOM_MACHINE /dev/stdout
BORG_KEY f6dc3da161fa259ad8c79380b2593d4996e4fb3c3efd802c88d996dd93b5f250
hqlhbGdvcml0aG2mc2hhMjU2pGRhdGHaAZ6DIeXAqvfULdYvWU6QooZHvmEaUvP3yzjQj9
l2I7xiDA/5rOjlP8kUFpefFtlMgo0gVcG8NQzqlZu8LQ/yFE3y52ldLc692D9Hr/rmrF+t
9wo7gvy33BaQmh+MrmbabipuJfm6p+u0lso11OJOwoX/GBXghL1lpazQnlERU1PqZZfiDe
ct6R1B67vdvQZXhVOuuYuLH9BNDMpq0eSc+9VHV3M/wFygmQtXfpcPTW2GekuQfSp9sk3D
a2pSFZs+wOMSZrx432DG5l/dbMXZgwmYgsMuixR2b+d/dNjSheMPy8tju2qCWL+ChbAm9A
oETPxAAOdBWUzxGgXPpnmuLxrjHf+XMpnt8E0fW6cqd/hdi2yuZJ0f7daZTVSM0KphHcP2
61JM+elY+xBFur8ibVekYllMC3Ot94DU/SYdAATxv8+X99tyB2UreGYxlwhCXUHNGba2XO
WWaDVNciAc1xc3sAX1gBVihEpZV4EbTPWkNj9DD3sWks9O0OeqTHdnhMVD1fpkKw2GDhfs
qb77w6DSwVZRnpgK58QwYDiTogukaGFzaNoAIIjMp6rDyIGoH+kxvLmOMq7w7/vzIL7PfO
wQvKVucuWuqml0ZXJhdGlvbnPOAAGGoKRzYWx02gAg0tq+i2wceA8guVTmn4AzKJsJRDb8
ueHXWCC+xBNhDNKndmVyc2lvbgE=
```

Simuler une sauvegarde

```
borgmatic -n -v2
```

Planifier la sauvegarde.

```
nano /etc/cron.d/borgmatic
et coller:
42 0 * * * root /usr/bin/borgmatic --create --prune #ou 42 est la minute et 00 l'heure de début * * * étant chaque jour, chaque mois, chaque jour de la semaine
42 1 * * 0 root /usr/bin/borgmatic --check
```

----


## À suivre

### ?? stockage chiffré monté au boot

### ?? postgress

### ?? mysql

### ?? alertes

### ?? log / cron 

Ça va avec les alertes.

### ?? accès sans terminal

Actuellement un NOM_DU_COMPTE dispose d'un accès `ssh` au serveur de sauvegardes.