Une autre manière de sauvegarder/restaurer Paperless depuis un nas synology vers un Raspberry Pi

Vous hébergez Paperless-ngx sur votre NAS Synology via Docker Compose et vous souhaitez le transférer sur un Raspberry Pi, peut-être pour dédier une machine à cette tâche ou pour optimiser la consommation énergétique ? Vous êtes au bon endroit ! Ce guide détaillé vous expliquera, étape par étape, comment migrer votre instance Paperless-ngx complète – configuration, documents, base de données – de votre Synology vers un Raspberry Pi, en utilisant la puissance de Docker Compose et une simple archive.

Nous avons récemment effectué cette migration avec succès, et voici la méthode éprouvée.

Prérequis

Avant de commencer, assurez-vous d’avoir :

Paperless-ngx fonctionnel sur votre Synology via docker-compose.yml.
Les données persistantes de Paperless (documents, base de données, etc.) stockées dans des sous-dossiers à l’intérieur du répertoire principal de votre docker-compose.yml sur le Synology (par exemple, ./data/paperless_media/, ./data/paperless_pgdata/). C’est la configuration la plus simple pour cette méthode.
Un accès SSH fonctionnel aux deux machines (Synology et Raspberry Pi), utilisant le port SSH standard (22).
Docker et Docker Compose (ou docker compose v2) installés et fonctionnels sur les deux machines. Sur le Raspberry Pi, une version compatible ARM est nécessaire.
Une connaissance basique de la ligne de commande Linux.
Note Importante : Ce guide suppose que votre docker-compose.yml sur le Synology utilise des chemins relatifs (ex: ./data) pour les volumes. Si vous utilisez des chemins absolus, vous devrez les adapter manuellement sur le Raspberry Pi.

Notre Configuration de Référence

Sur le Synology : Le répertoire de Paperless est /volume1/docker/paperless/.

Les données sont structurées ainsi :

/volume1/docker/paperless/
├── docker-compose.yml
├── .env  (optionnel, pour les variables d'environnement)
├── consume/
└── data/
    ├── paperless_data/
    ├── paperless_media/
    ├── paperless_pgdata/    (pour PostgreSQL)
    └── paperless_redisdata/ (pour Redis)

Sur le Raspberry Pi : Le répertoire cible sera /home/user/docker/paperless/. L’utilisateur sur le RPi sera user (dont l’UID/GID est typiquement 1000, à vérifier avec id user).

Étape 1 : Exportation depuis le Synology NAS

L’objectif ici est de créer une archive complète de votre installation Paperless.

Connectez-vous en SSH à votre Synology NAS :
```
ssh utilisateur_syno@IP_DU_SYNO
```
Naviguez jusqu’au répertoire de Paperless et arrêtez les conteneurs :
L’arrêt des conteneurs garantit la cohérence des données pendant la sauvegarde.
```
cd /volume1/docker/paperless
sudo docker-compose down
```
Créez une archive complète du répertoire Paperless :
Placez-vous dans le répertoire parent (/volume1/docker/) pour que l’archive contienne le dossier paperless/ lui-même. L’utilisation de sudo est cruciale ici pour s’assurer que tous les fichiers, y compris ceux de la base de données (souvent propriété d’un utilisateur système comme postgres), soient inclus.
```
cd /volume1/docker/
sudo tar -cvzf paperless_backup.tar.gz paperless/
```
Cette commande crée une archive compressée paperless_backup.tar.gz dans /volume1/docker/.

Étape 2 : Transfert de l’archive vers le Raspberry Pi

Maintenant, nous allons copier cette archive sur votre Raspberry Pi.

Connectez-vous en SSH à votre Raspberry Pi :
```
ssh user@IP_DU_RPI
```
Créez le répertoire de destination sur le RPi (s’il n’existe pas) :
```
mkdir -p /home/user/docker/
cd /home/user/docker/
```
(Note : L’utilisateur user devrait avoir les droits pour créer des dossiers dans son propre répertoire /home/user/, donc sudo n’est pas toujours nécessaire pour mkdir ici, mais ne fait pas de mal s’il l’est).
Transférez l’archive depuis le Synology vers le Raspberry Pi :
Depuis le Raspberry Pi, utilisez scp pour récupérer l’archive. Nous supposons ici que votre Synology utilise le port SSH standard (22).
```
scp utilisateur_syno@IP_DU_SYNO:/volume1/docker/paperless_backup.tar.gz .
```
Entrez le mot de passe de votre utilisateur Synology. Le . à la fin signifie « copier dans le répertoire courant » (/home/user/docker/ dans notre exemple).
Extraire l’archive sur le Raspberry Pi :
```
tar -xvzf paperless_backup.tar.gz
```
Cela devrait créer un dossier /home/user/docker/paperless/ avec tout le contenu du Synology. sudo n’est pas nécessaire ici si l’utilisateur user est propriétaire du répertoire /home/user/docker/.

Étape 3 : Configuration et Démarrage sur le Raspberry Pi

C’est l’étape la plus délicate, où nous adaptons la configuration pour le RPi.

Naviguez dans le répertoire Paperless extrait :
```
cd /home/user/docker/paperless
```
Vous devriez y trouver votre docker-compose.yml, le dossier data/, etc.
Adaptez le fichier docker-compose.yml :
Ouvrez-le avec un éditeur de texte (par exemple, nano) :
```
nano docker-compose.yml
```
(Si l’utilisateur user n’a pas les droits d’écriture, utilisez sudo nano docker-compose.yml).
Apportez les modifications suivantes :
- Architecture des Images Docker : Le Raspberry Pi utilise une architecture ARM. Les images Docker pour x86_64 (Synology) ne fonctionneront pas. Assurez-vous que vos images sont multi-architecture ou spécifiquement pour ARM.
  - Paperless-ngx : ghcr.io/paperless-ngx/paperless-ngx:latest (est multi-architecture)
  - PostgreSQL : postgres:latest ou une version spécifique comme postgres:15 (sont multi-architecture)
  - Redis : redis:latest ou redis:alpine (sont multi-architecture)
    Si vous aviez des tags spécifiques à amd64, changez-les pour :latest ou le tag ARM approprié.
- Chemins des Volumes : Si votre docker-compose.yml original utilisait des chemins relatifs (ex: ./data/paperless_media:/usr/src/paperless/media), aucune modification de chemin n’est nécessaire ici ! Ils sont relatifs à l’emplacement du docker-compose.yml et pointeront correctement vers les données que vous venez d’extraire. C’est la beauté de cette méthode. Si vous aviez des chemins absolus, vous devez les mettre à jour pour pointer vers /home/user/docker/paperless/data/….
- Variables d’Environnement (.env ou section environment:) :
  - Vérifiez particulièrement USERMAP_UID et USERMAP_GID (s’ils existent dans votre configuration Paperless). Il est recommandé de les définir avec l’UID et le GID de l’utilisateur user sur le RPi (souvent 1000). Pour connaître l’UID/GID de votre utilisateur sur le RPi : id user.
  - Vérifiez PAPERLESS_URL si vous l’aviez défini, pour qu’il pointe vers l’IP de votre RPi.
  - Assurez-vous que les identifiants de base de données (POSTGRES_USER, POSTGRES_PASSWORD, PAPERLESS_DBUSER, PAPERLESS_DBPASS) sont corrects et correspondent à ce qui était utilisé sur le Synology (ils devraient être dans votre fichier .env ou directement dans le docker-compose.yml transféré).
Sauvegardez les modifications (Ctrl+O, Entrée, puis Ctrl+X dans nano).
Ajustez les permissions des fichiers (TRÈS IMPORTANT) :
Les conteneurs Paperless ont besoin des droits d’écriture sur les dossiers de données. Attribuez la propriété de tous les fichiers dans /home/user/docker/paperless/ à l’utilisateur/groupe spécifié par USERMAP_UID/USERMAP_GID (ou à votre utilisateur user sur le RPi si USERMAP n’est pas utilisé, généralement UID/GID 1000).
Exécutez cette commande depuis /home/user/docker/paperless/ :
```
# En supposant UID=1000 et GID=1000 pour l'utilisateur 'user'
sudo chown -R 1000:1000 .
```
Le . s’applique au répertoire courant (/home/user/docker/paperless/) et à tout son contenu.
Téléchargez les images Docker pour ARM :
Cette commande va lire votre docker-compose.yml et télécharger les versions correctes (ARM) des images si elles ne sont pas déjà présentes.
```
docker-compose pull
```
(Utilisez sudo docker-compose pull si votre utilisateur user n’est pas dans le groupe docker).
Démarrez les conteneurs Paperless :
```
docker-compose up -d
```
(Utilisez sudo docker-compose up -d si votre utilisateur user n’est pas dans le groupe docker). L’option -d lance les conteneurs en arrière-plan.

Étape 4 : Vérification

Il est temps de vérifier si tout fonctionne comme prévu !

Consultez les logs des conteneurs :
```
docker-compose logs -f
```
(Ou sudo docker-compose logs -f).
Recherchez les messages clés suivants :
- Pour le service de base de données (db_1 ou postgres_1) :
  PostgreSQL Database directory appears to contain a database; Skipping initialization
  database system is ready to accept connections
  Cela confirme que PostgreSQL a trouvé et utilise vos données existantes.
- Pour le service Paperless (webserver_1 ou paperless_1) :
  [init-migrations] Apply database migrations… Running migrations: No migrations to apply.
  Cela indique que Paperless a trouvé une base de données avec le schéma correct et n’a pas besoin d’en créer une nouvelle ou d’appliquer de nombreuses migrations.
  [INFO] Listening at: http://:::8000 (ou le port que vous avez configuré)
- Les services Redis, Gotenberg, Tika devraient également démarrer sans erreurs majeures. Un avertissement « Memory overcommit » pour Redis est courant et peut généralement être ignoré au début.
Accédez à l’interface Web de Paperless :
Ouvrez votre navigateur et allez à http://IP_DE_VOTRE_RPI:8000 (remplacez par l’IP et le port corrects).
Vous devriez voir votre interface Paperless familière, avec tous vos documents, tags, correspondants, etc. !

Conclusion

Félicitations ! Vous avez migré avec succès votre instance Paperless-ngx de votre Synology NAS vers votre Raspberry Pi. Cette méthode, basée sur l’archivage complet du répertoire Docker Compose et l’utilisation de chemins relatifs pour les volumes, s’avère robuste et relativement simple, surtout grâce à la gestion multi-architecture des images Docker officielles.

N’hésitez pas à laisser un commentaire si vous avez des questions ou si vous souhaitez partager votre propre expérience de migration !