Partager un SSD USB entre un Raspberry Pi et un VPS avec WireGuard et NFS

Utiliser un SSD USB connecté à un Raspberry Pi comme espace de stockage distant, accessible depuis un VPS. La connexion passe par un tunnel WireGuard et le partage de fichiers utilise NFSv4.

Architecture

  • Raspberry Pi : héberge le SSD USB et exporte le répertoire via NFS.
  • VPS Debian : monte le partage NFS et accède aux fichiers distants.
  • WireGuard : assure la connectivité privée entre les deux machines.
  • ext4 : système de fichiers du SSD.

Adresses VPN utilisées :

Machine Adresse WireGuard
VPS 10.0.0.1
Raspberry Pi 10.0.0.3

Le VPS possède déjà une configuration WireGuard fonctionnelle. Le Raspberry Pi est ajouté comme pair supplémentaire, sans modifier les pairs existants.

1. Configurer WireGuard

Sur le Raspberry Pi, installer WireGuard et générer une paire de clés :

sudo apt update
sudo apt install wireguard
sudo sh -c 'umask 077; wg genkey | tee /etc/wireguard/pi_private.key | wg pubkey > /etc/wireguard/pi_public.key'

Créer /etc/wireguard/wg0.conf :

[Interface]
Address = 10.0.0.3/24
PrivateKey = <CLE_PRIVEE_DU_RASPBERRY_PI>

[Peer]
PublicKey = <CLE_PUBLIQUE_DU_VPS>
Endpoint = <IP_PUBLIQUE_DU_VPS>:50443
AllowedIPs = 10.0.0.1/32
PersistentKeepalive = 25

Sur le VPS, ajouter le Raspberry Pi comme nouveau pair dans la configuration existante :

[Peer]
PublicKey = <CLE_PUBLIQUE_DU_RASPBERRY_PI>
AllowedIPs = 10.0.0.3/32

Conserver les pairs déjà configurés sur le VPS. Autoriser le port UDP 50443 dans le pare-feu du VPS et dans le pare-feu réseau Scaleway si nécessaire.

Activer WireGuard sur le Raspberry Pi :

sudo systemctl enable --now wg-quick@wg0
sudo wg show
ping 10.0.0.1

Un handshake récent et des compteurs de transfert non nuls confirment que le tunnel fonctionne.

2. Monter le SSD sur le Raspberry Pi

Identifier la partition USB et son UUID :

lsblk -o NAME,SIZE,FSTYPE,LABEL,UUID,MOUNTPOINTS
sudo blkid

Créer le point de montage :

sudo mkdir -p /srv/nfs/disque
sudo nano /etc/fstab

Ajouter une entrée avec l’UUID réel :

UUID=<UUID_DU_SSD> /srv/nfs/disque ext4 defaults,nofail 0 2

Monter et vérifier :

sudo systemctl daemon-reload
sudo mount -a
findmnt -T /srv/nfs/disque
df -hT /srv/nfs/disque

Vérifier que la source est bien la partition USB (par exemple /dev/sda1) et non la carte microSD.

3. Exporter le répertoire avec NFS

Sur le Raspberry Pi :

sudo apt install nfs-kernel-server acl

Modifier /etc/exports :

/srv/nfs/disque 10.0.0.1(rw,sync,no_subtree_check,root_squash)

Appliquer et vérifier :

sudo exportfs -rav
sudo exportfs -v
sudo systemctl enable --now nfs-kernel-server

Cette règle autorise le VPS à accéder au partage en lecture et en écriture. root_squash empêche le compte root distant d’obtenir automatiquement les privilèges root sur le Raspberry Pi.

4. Monter le partage sur le VPS

Sur Debian :

sudo apt update
sudo apt install nfs-common
sudo mkdir -p /srv/nfs/disque

Monter le partage via WireGuard :

sudo mount -t nfs -o vers=4 10.0.0.3:/srv/nfs/disque /srv/nfs/disque

Vérifier le montage :

findmnt /srv/nfs/disque
df -hT /srv/nfs/disque

Pour le montage automatique au démarrage, ajouter dans /etc/fstab :

10.0.0.3:/srv/nfs/disque /srv/nfs/disque nfs4 defaults,_netdev,nofail 0 0

Tester avec sudo mount -a.

5. Créer le répertoire partagé

Sur le Raspberry Pi, créer un sous-répertoire dédié aux applications et aux transferts :

sudo mkdir -p /srv/nfs/disque/partage
sudo chown nobody:users /srv/nfs/disque/partage
sudo chmod 2775 /srv/nfs/disque/partage

Le bit setgid (2 dans 2775) favorise l’héritage du groupe du répertoire pour les nouveaux fichiers.

6. Configurer les ACL pour les utilisateurs

Sur le VPS, vérifier l’identité de l’utilisateur de déploiement :

id githubci

Dans cette configuration, githubci possède l’UID 1001 et appartient au groupe users (GID 100).

Sur le Raspberry Pi, appliquer une ACL explicite à githubci sur les fichiers et dossiers existants :

sudo setfacl -R -m u:1001:rwX /srv/nfs/disque/partage

Configurer les ACL par défaut pour les nouveaux fichiers et dossiers :

sudo find /srv/nfs/disque/partage -type d -exec setfacl -m d:u:1001:rwx,d:g:users:rwx,d:m:rwx {} +

Vérifier les ACL :

getfacl /srv/nfs/disque/partage

L’entrée user:1001:rwx accorde les droits à githubci. Les ACL par défaut permettent d’hériter des droits sur les nouveaux éléments créés dans les répertoires concernés.

L’utilisateur local chfloret, membre du groupe users, peut également accéder aux fichiers lorsque les permissions effectives du groupe le permettent. Les ACL ne remplacent pas les permissions Unix classiques : vérifier les droits effectifs si un accès échoue.

7. Tester l’écriture depuis le VPS

Avec l’utilisateur githubci :

sudo -u githubci touch /srv/nfs/disque/partage/test.txt
sudo -u githubci rm /srv/nfs/disque/partage/test.txt

Vérifier aussi la lecture et l’écriture avec chfloret, selon la manière dont cet utilisateur se connecte au VPS.

En cas d’échec, contrôler sur le Raspberry Pi :

getfacl /srv/nfs/disque/partage
sudo exportfs -v

Points de vigilance

  • IP domestique dynamique : le Raspberry Pi initie le tunnel vers le VPS. PersistentKeepalive aide à maintenir la connectivité à travers les routeurs NAT.
  • Dépendance réseau : le partage est indisponible lorsque le Raspberry Pi, le tunnel WireGuard ou le SSD est hors ligne.
  • Permissions : NFS utilise notamment les identifiants numériques des utilisateurs et groupes. Conserver root_squash.
  • Sécurité réseau : NFS doit être accessible uniquement sur le réseau privé WireGuard, jamais directement depuis Internet.
  • Sauvegardes : un SSD distant n’est pas une sauvegarde en soi. Prévoir une copie indépendante des données importantes.
  • Clés WireGuard : conserver les clés privées sur leurs machines respectives et ne jamais les partager.

Résultat

Le VPS accède au SSD USB du Raspberry Pi à travers WireGuard et NFSv4. Le stockage reste physiquement à domicile, tandis que les applications du VPS peuvent utiliser /srv/nfs/disque/partage comme espace de stockage distant.