agence66-borgmatic/docs/SSH-SETUP.md

# Configuration SSH pour Borgmatic

Guide complet pour configurer l'authentification SSH par clé pour les backups distants.

## Pourquoi utiliser des clés SSH ?

- **Automatisation** : Pas de mot de passe à saisir manuellement
- **Sécurité** : Plus sécurisé qu'un mot de passe
- **Requis** : Nécessaire pour que le timer systemd fonctionne automatiquement

## Configuration étape par étape

### 1. Générer une clé SSH

```bash
# Se connecter en root
sudo su -

# Générer une clé Ed25519 (recommandé)
ssh-keygen -t ed25519 -C "borgmatic-backup@$(hostname)"

# Ou RSA si Ed25519 n'est pas supporté
ssh-keygen -t rsa -b 4096 -C "borgmatic-backup@$(hostname)"
```

**Réponses aux questions** :

```
Enter file in which to save the key (/root/.ssh/id_ed25519): [Entrée]
Enter passphrase (empty for no passphrase): [Entrée - laisser vide]
Enter same passphrase again: [Entrée]
```

**Important** : Laissez la passphrase **vide** pour permettre l'automatisation.

### 2. Vérifier que la clé a été créée

```bash
ls -la /root/.ssh/
# Vous devriez voir :
# id_ed25519      (clé privée - à garder secrète)
# id_ed25519.pub  (clé publique - à copier sur le serveur)
```

### 3. Copier la clé sur le serveur distant

#### Méthode automatique (recommandée)

```bash
# Syntaxe générale
ssh-copy-id -p PORT user@backup-server.com

# Exemples
ssh-copy-id -p 22 backup@backup.example.com
ssh-copy-id -p 2222 user@192.168.1.100
```

Saisissez le mot de passe du serveur **une dernière fois**.

#### Méthode manuelle

Si `ssh-copy-id` ne fonctionne pas :

```bash
# 1. Afficher votre clé publique
cat /root/.ssh/id_ed25519.pub

# 2. Se connecter au serveur distant
ssh -p PORT user@backup-server.com

# 3. Sur le serveur distant, ajouter la clé
mkdir -p ~/.ssh
chmod 700 ~/.ssh
echo "VOTRE_CLE_PUBLIQUE_ICI" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys
exit
```

### 4. Tester la connexion

```bash
# Tester sans mot de passe
ssh -p PORT user@backup-server.com

# Si ça fonctionne, vous êtes connecté directement !
# Tapez 'exit' pour revenir
```

**Si on vous demande toujours un mot de passe** :
- Vérifiez les permissions : `chmod 600 /root/.ssh/id_ed25519`
- Vérifiez le serveur : `ssh -v -p PORT user@backup-server.com` (mode verbeux)

## Cas spécifiques

### Serveurs avec interface web

Certains fournisseurs de stockage backup proposent une interface web pour gérer les clés SSH :

1. Connectez-vous à l'interface web de votre fournisseur
2. Cherchez la section "SSH Keys" ou "Authentification"
3. Cliquez sur "Add SSH key" ou équivalent
4. Collez le contenu de `/root/.ssh/id_ed25519.pub`
5. Sauvegardez

### Serveur VPS/Dédié

Pour un serveur standard avec accès SSH :

```bash
# Copie standard avec ssh-copy-id
sudo ssh-copy-id -p 22 user@backup-server.com

# Ou méthode manuelle
ssh -p PORT user@backup-server.com
mkdir -p ~/.ssh
chmod 700 ~/.ssh
echo "VOTRE_CLE_PUBLIQUE" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys
exit
```

## Configuration avancée

### Utiliser une clé SSH spécifique

Si vous voulez utiliser une clé dédiée uniquement pour Borgmatic :

```bash
# 1. Générer une clé dédiée
ssh-keygen -t ed25519 -f /root/.ssh/borgmatic_ed25519 -C "borgmatic-only"

# 2. Copier cette clé spécifique
ssh-copy-id -i /root/.ssh/borgmatic_ed25519.pub -p PORT user@backup-server.com

# 3. Configurer dans /etc/borgmatic/.env
echo 'BORG_RSH="ssh -i /root/.ssh/borgmatic_ed25519"' >> /etc/borgmatic/.env
```

### Config SSH personnalisée

Créez `/root/.ssh/config` :

```
Host backup-server
    HostName backup.example.com
    Port 22
    User backupuser
    IdentityFile /root/.ssh/borgmatic_ed25519
    StrictHostKeyChecking accept-new
```

Puis dans votre repository :

```yaml
repositories:
    - path: ssh://backup-server/./backups
      label: serveur
```

## Vérification et troubleshooting

### Vérifier que tout fonctionne

```bash
# 1. Test SSH
ssh -p PORT user@backup-server.com
# ✅ Doit se connecter SANS demander de mot de passe

# 2. Test Borg
source /etc/borgmatic/.env
borg list $BORG_REPO
# ✅ Doit lister les archives SANS demander de mot de passe

# 3. Test Borgmatic
make dry-run
# ✅ Doit fonctionner SANS demander de mot de passe
```

### Problèmes courants

**"Permission denied (publickey)"**

```bash
# Vérifier les permissions de la clé privée
chmod 600 /root/.ssh/id_ed25519

# Vérifier que la clé est bien copiée sur le serveur
ssh -v -p PORT user@backup-server.com 2>&1 | grep "Offering public key"
```

**"Host key verification failed"**

```bash
# Ajouter le serveur aux known hosts
ssh-keyscan -p PORT backup-server.com >> /root/.ssh/known_hosts
```

**Borgmatic demande toujours le mot de passe**

```bash
# Vérifier que SSH fonctionne bien sans mot de passe
ssh -p PORT user@backup-server.com

# Vérifier les variables d'environnement
sudo cat /etc/borgmatic/.env | grep BORG_RSH
```

## Sécurité

### Bonnes pratiques

1. **Clé dédiée** : Utilisez une clé SSH spécifique pour les backups
2. **Restrictions** : Limitez la clé aux commandes Borg uniquement (côté serveur)
3. **Rotation** : Changez les clés régulièrement (annuellement)
4. **Backup** : Sauvegardez votre clé privée en lieu sûr

### Limiter les commandes autorisées (serveur)

Sur le serveur de backup, dans `~/.ssh/authorized_keys` :

```bash
command="borg serve --restrict-to-path /path/to/repo",restrict ssh-ed25519 AAAAC3... borgmatic-backup
```

Cela limite la clé SSH à **uniquement** exécuter Borg sur ce chemin spécifique.

## Automatisation avec le timer systemd

Une fois la clé SSH configurée, le timer systemd fonctionnera automatiquement :

```bash
# Le service systemd utilisera automatiquement la clé SSH de root
systemctl status borgmatic.timer

# Les backups s'exécuteront à 3h du matin sans intervention
```

✅ **Configuration terminée !** Les backups automatiques peuvent maintenant fonctionner sans intervention manuelle.