Grenode peut fournir à ses membres un espace de stockage à des fin de sauvegarde. Ces espaces se trouvent sur la machine gaffe à Toulouse, chez Tetaneutral et sont accessibles en ssh.

Le nom DNS à utiliser pour faire des backups est backup.grenode.net.

  1. Caratéristiques
  2. Ajouter un compte de backup
    1. Via Ansible
    2. À la main
  3. Détails de configuration
  4. Backups avec borg
    1. Configuration initiale
    2. Initialisation et mise en place des sauvegardes (sur la machine à sauvegarder)

Caratéristiques

Le principe est de fournir deux comptes un pour réaliser les backups <user> l'autre pour les administrer <user>-admin. Le premier ayant des droits restreints.

  • Les comptes n'ont pas de mot de passe

  • Avec le compte <user>-admin, il est possible d'éxécuter n'importe quelle commande sous l'identité <user> via la commande :

    sudo -u <user> ma_comande

    Ainsi le compte <user>-admin peut changer les clés ssh du compte (et manipuler les fichiers à souhait).

  • Les connections ssh au compte <user> sont chrootées, et seul sftp est activé (pas de shell).

  • Le répertoire de données est /srv/backup/<user>/backups/ un lien symbolique pointe dessus dans le compte <user>-admin.

Ajouter un compte de backup

Via Ansible

Il faut lancer le playbook ansible backup-accounts.yml, en ayant préalablement renseigner dans le fichiers group_vars/backupservers.yml dans la partie backup_accounts :

  • name: le nom du compte
  • type: sftp ou borg
  • ssh_keys: listes des clefs ssh authorisées
  • borgversion: si les backups sont gérés avec borg

Ensuite, lancer le playbook :

ansible-playbook -K backup_accounts.yml

À la main

  • créer l'utilisateur et son home

    export BKP_USER=<user>
sudo adduser $BKP_USER --gecos $BKP_USER \
                       --home /srv/backup/$BKP_USER \
                       --no-create-home \
                       --disabled-password \
                       --shell /bin/false
sudo addgroup $BKP_USER backup-user
sudo mkdir /srv/backup/$BKP_USER/
sudo chown root:$BKP_USER /srv/backup/$BKP_USER/
sudo chmod 750  /srv/backup/$BKP_USER/

  • configurer ssh avec les clés nécessaires

    sudo mkdir /srv/backup/$BKP_USER/.ssh
sudo chown $BKP_USER: /srv/backup/$BKP_USER/.ssh
sudo chmod 550 /srv/backup/$BKP_USER/.ssh
echo "<CLE_SSH_PUBLIQUE>" | sudo tee -a /srv/backup/$BKP_USER/.ssh/authorized_keys
sudo chown $BKP_USER: /srv/backup/$BKP_USER/.ssh/authorized_keys
sudo chmod 440 /srv/backup/$BKP_USER/.ssh/authorized_keys

  • créer un utilisateur <user>-admin pour l'administration de ses backups (installation de cron, etc.).

    sudo adduser ${BKP_USER}-admin --gecos $BKP_USER \
                               --home /srv/backup/${BKP_USER}-admin \
                               --disabled-password
sudo adduser ${BKP_USER}-admin ${BKP_USER}
sudo adduser ${BKP_USER}-admin backup-admin


sudo chmod 770 /srv/backup/${BKP_USER}-admin

  • configurer ssh avec les clés nécessaires

    sudo mkdir /srv/backup/${BKP_USER}-admin/.ssh
sudo chown ${BKP_USER}-admin: /srv/backup/${BKP_USER}-admin/.ssh
sudo chmod 700 /srv/backup/${BKP_USER}-admin/.ssh
sudo su ${BKP_USER}-admin -c \
    "echo <CLE_SSH_PUBLIQUE> >> /srv/backup/${BKP_USER}-admin/.ssh/authorized_keys"

  • permettre au compte ${BKP_USER}-admin de modifier les clés ssh de ${BKP_USER}

    On utilise sudo en permetant à ${BKP_USER}-admin qui est membre du groupe ${BKP_USER} d'exécuter n'importe quelle commande en tant que ${BKP_USER} sans mot de passe. Pour cela il est possible de rajouter la ligne suivante :

    %${BKP_USER} ALL=($BKP_USER) NOPASSWD: ALL

  • créer le répertoire de données

    Le répertoire qui contient les données de sauvegarde, a le bit sticky activé : cela force a ce ce soit le prorpiétaire du fichier ou du répertoire qui puisse le supprimer ou de le renommer. Son propriétaire est ${BKP_USER}-admin et son groupe est ${BKP_USER}.

    sudo mkdir /srv/backup/$BKP_USER/backups
sudo chown ${BKP_USER}-admin:$BKP_USER /srv/backup/$BKP_USER/backups
sudo chmod 1770 /srv/backup/$BKP_USER/backups
sudo ln -s ../${BKP_USER}/backups /srv/backup/${BKP_USER}-admin/backups

    Cela permet par exemple, par un simple changement de propriétaire et de droit, d'interdire toute modification des sauvegardes par le compte ${BKP_USER} tout en lui permetant de les lire.

Détails de configuration

Les backups consistent à fournir un espace de stockage accessible en sftp. La partition stockant les données se trouve sur /srv/backup/<user>/. Chaque utilisateur dispose d'un compte unix dont le shell est /bin/false. OpenSSH permet de chrooter un utilisateur dans un environnement propre à un compte unix.

Les opérations faites :

  • ajout/modification dans le fichier /etc/ssh/sshd_config :

    Subsystem sftp internal-sftp


Match Group backup-user
    ChrootDirectory /srv/backup/%u
    ForceCommand internal-sftp
    AllowTCPForwarding no
    X11Forwarding no
    PubkeyAuthentication yes
    PasswordAuthentication no


Match Group backup-admin
    AllowTCPForwarding no
    X11Forwarding no
    PubkeyAuthentication yes
    PasswordAuthentication no


Match Group borgbackup-user
    AllowTCPForwarding no
    X11Forwarding no
    PubkeyAuthentication yes
    PasswordAuthentication no

    Le subsystem internal-sftp est nécessaire pour chrooté les environnements des utilisateurs.

  • créer le groupe backup-user et le group backup-admin

    sudo addgroup backup-user
sudo addgroup backup-admin
sudo addgroup borgbackup-user

Backups avec borg

Borg est une solution de sauvegarde permettant le chiffrement, la dé-duplication.

  • Pour quelques statistiques, Tetaneutral.net a fait quelques tests sur attic (la version avant le fork).

Configuration initiale

La configuration est la même que le début de cette documentation, à la seule différence que le $BKP_USER n'est pas dans le groupe backup-user mais borgbackup-user.

Sur le serveur de sauvegardes

Afin d'avoir une version homogène de borg sur les serveur à sauvegarder et sur le serveur de sauvegarde, on utilise une version binaire de borg, celle-ci est placé dans le répertoire bin de l'utilisateur $BKP_USER.

    export MACHINE=<machine.fqdn>
    sudo mkdir /srv/backup/$BKP_USER/bin
    sudo chown ${BKP_USER}-admin:$BKP_USER /srv/backup/$BKP_USER/bin
    sudo wget -nv https://github.com/borgbackup/borg/releases/download/1.0.9/borg-linux64 -O /srv/backup/$BKP_USER/bin/borg
    sudo echo 'PATH=$HOME/bin:$PATH' > /srv/backup/$BKP_USER/.bashrc

Borg dispose de signatures GPG (asc) qui permettent de vérifier les binaires de borg.

On pré-crée enfin le répertoire où seront stockés les sauvegardes de la machine source.

    sudo chown ${BKP_USER}: /srv/backup/$BKP_USER/backups/$MACHINE
    sudo chown 700 /srv/backup/$BKP_USER/backups/$MACHINE

Sur le serveur à sauvegarder

Pour la partie transport, nous utilisons SSH, il faut donc créer une clé sur la machine à sauvegarder, et ajouter cette clé sur le serveur de sauvegardes, on limite les commandes à effectuer via la directive command du authorized_keys.

    apt install borgbackup
    ssh-keygen -t rsa -b 4096 -C "Borgbackup $MACHINE"

Édition du fichier /srv/backup/$BKP_USER/.ssh/authorized_keys

    # $MACHINE
    command="borg serve --restrict-to-path $HOME/backups/$MACHINE" ssh-rsa AAAA…9Q== $MACHINE

Initialisation et mise en place des sauvegardes (sur la machine à sauvegarder)

Lors de cette phase, les fichiers nécessaires au fonctionnement de borg sont crées sur la machine de sauvegarde, il est aussi demandé une phrase de passe (pour chiffrer les sauvegardes)

    borg init $BKP_USER@backup.grenode.net:/srv/backup/$BKP_USER/backups/$MACHINE

Nous allons ensuite lancer manuellement la première sauvegarde, dans cet exemple nous sauvegardons uniquement les répertoires /etc, /srv et /var/backups, il est cependant tout à fait possible de sauvegarder toute la machine et d'exclure certaines fichiers (/dev et autres) via l'argument --exclude-from <fichier>.

    borg create -x $BKP_USER@backup.grenode.net:/srv/backup/$BKP_USER/backups/$MACHINE::{now:%Y-%m-%d} /etc /srv /var/backups

Enfin, pour automatiser les sauvegardes, nous pouvons mettre en place un cron tout bête, ou alors utiliser un système plus perfectionné comme backupninja, pour par exemple lancer des dump de bases de données avant de lancer la sauvegarde…

Les infos du point de sauvegarde ainsi que le mot de passe de celui-ci sont enregistré dans /etc/.borg afin de les partager avec checkmk (voir Supervision-checkmk)

    # /etc/.borg
    export BORG_PASSPHRASE='<phrase de passe>'
    export BORG_REPO='$BKP_USER@backup.grenode.net:/srv/backup/$BKP_USER/backups/$MACHINE'

On oublie pas de passer de restreindre les droits sur ce fichier.

    chmod 640 /etc/.borg
    chown root:check_mk_agent /etc/.borg

Dans la partie suivante, nous allons juste faire un cron simple dans /etc/cron.daily/borg, nous éditons donc le fichier.

    #!/bin/bash
    # /etc/cron.daily/borg
    source /etc/.borg
    borg create -x ::{now:%Y-%m-%d} /etc /srv /var/backups
    borg prune -d 7 -w 4 -m 6 -y 1

Enfin, on modifie les permissions sur le fichier cron.

    chmod 750 /etc/cron.daily/borg