Nextcloud

Comment sauvegarder Nextcloud avec Portabase

Charles Gauthereau, Killian Larcher

15 juil. 2026 — 8 min de lecture

Comment sauvegarder Nextcloud avec Portabase

Héberger votre propre instance Nextcloud vous permet de garder un contrôle total sur vos fichiers, calendriers, contacts et autres données. En revanche, l’auto-hébergement implique également que vous êtes responsable de la protection de ces données.

Lorsque Nextcloud est déployé avec Docker, les conteneurs eux-mêmes sont jetables : ils peuvent être recréés à tout moment à partir de leurs images. La partie réellement importante du déploiement réside dans les données persistantes stockées dans les volumes Docker, notamment les données de l’application, la configuration, les bases de données et les fichiers des utilisateurs.

La sauvegarde de ces volumes persistants est donc essentielle pour pouvoir restaurer votre instance Nextcloud après une panne de serveur, une suppression accidentelle, une migration ou un problème de configuration. Les volumes Docker constituent, en pratique, l’endroit où est conservé l’état d’une application conteneurisée.

Dans ce tutoriel, nous allons déployer une instance Nextcloud avec Docker, puis configurer Portabase afin de sauvegarder et de restaurer ses volumes Docker.

À la fin de ce tutoriel, l’architecture comprendra :

un déploiement Nextcloud ;
un serveur Portabase fournissant l’interface web et la gestion des sauvegardes ;
un agent Portabase connecté à l’hôte Docker exécutant Nextcloud ;
une destination de stockage pour les sauvegardes ;
des sauvegardes planifiées des volumes Docker de Nextcloud.

Qu’est-ce que Nextcloud ?

Nextcloud est une plateforme collaborative open source et auto-hébergée, conçue comme une alternative aux services cloud propriétaires.

À l’origine, Nextcloud fournit des fonctionnalités de stockage et de synchronisation de fichiers, mais son écosystème va bien au-delà du simple hébergement de fichiers. Selon les applications installées, une instance Nextcloud peut également proposer des calendriers, des contacts, de l’édition collaborative de documents, des outils de communication, de la gestion de tâches et de nombreux autres services.

L’un des principaux avantages de Nextcloud est qu’il permet aux organisations et aux particuliers de conserver le contrôle sur l’emplacement de leurs données et sur la manière dont leur infrastructure est exploitée.

Bien que Docker facilite le déploiement et la maintenance de l’application, les conteneurs eux-mêmes ne doivent pas être considérés comme des sauvegardes. L’état persistant du déploiement Nextcloud est stocké dans les volumes Docker. La protection de ces volumes constitue donc un élément essentiel de toute stratégie de sauvegarde.

Qu’est-ce que Portabase ?

Portabase est une plateforme open source et auto-hébergée de sauvegarde et de restauration, conçue pour gérer de manière centralisée les sauvegardes de plusieurs serveurs.

Elle prend en charge neuf technologies de bases de données :

PostgreSQL
MySQL
MariaDB
Microsoft SQL Server
Firebird SQL
SQLite
MongoDB
Redis
Valkey

Portabase prend également en charge la sauvegarde et la restauration des volumes Docker, ce qui lui permet de protéger les données persistantes utilisées par les applications conteneurisées.

Son architecture repose sur deux composants principaux :

Le serveur Portabase fournit l’interface web permettant de configurer les projets, les destinations de stockage, les planifications de sauvegarde, les politiques de rétention et les opérations de restauration.

Les agents Portabase sont installés sur l’infrastructure où se trouvent les bases de données ou les volumes Docker. Ils exécutent les opérations de sauvegarde et de restauration et communiquent avec le serveur Portabase central.

Cette architecture permet de gérer les sauvegardes de plusieurs hôtes Docker depuis une interface unique.

Dans le cadre de notre déploiement Nextcloud, l’agent Portabase s’exécutera sur l’hôte Docker sur lequel Nextcloud est installé. Il aura accès aux volumes Docker de Nextcloud et sera chargé de les sauvegarder vers la destination de stockage configurée dans Portabase.

Architecture du tutoriel

L’environnement utilisé dans ce tutoriel se compose de deux éléments principaux :

Nextcloud, déployé avec Docker et utilisant des volumes Docker persistants ;
Portabase, composé du tableau de bord central et d’un agent connecté à l’hôte Docker.

Le flux de sauvegarde sera le suivant :

Nextcloud Docker volumes → Portabase Agent → Backup Storage

Le tableau de bord Portabase sera utilisé pour configurer et superviser le processus de sauvegarde, tandis que l’agent exécutera directement les opérations sur l’hôte Docker.

Dans les sections suivantes, nous allons d’abord déployer Nextcloud, puis installer Portabase, connecter l’agent à l’hôte Docker et enfin configurer notre première opération de sauvegarde et de restauration.

Installation de Nextcloud

Créez un répertoire dédié :

$ mkdir nextcloud

Accédez à ce répertoire :

$ cd nextcloud

Créez un fichier docker-compose.yml et collez-y le code suivant :

$ touch docker-compose.yml

services:

  postgres:
    container_name: nextcloud-db
    image: ${NEXTCLOUD_POSTGRES_IMAGE_TAG}
    volumes:
      - nextcloud-postgres:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: ${NEXTCLOUD_DB_NAME}
      POSTGRES_USER: ${NEXTCLOUD_DB_USER}
      POSTGRES_PASSWORD: ${NEXTCLOUD_DB_PASSWORD}
    networks:
      - default
    healthcheck:
      test: ["CMD", "pg_isready", "-q", "-d", "${NEXTCLOUD_DB_NAME}", "-U", "${NEXTCLOUD_DB_USER}"]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 60s
    restart: unless-stopped

  redis:
    container_name: nextcloud-redis
    image: ${NEXTCLOUD_REDIS_IMAGE_TAG}
    command: ["redis-server", "--requirepass", "$NEXTCLOUD_REDIS_PASSWORD"]
    volumes:
      - redis-data:/data
    networks:
      - default
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 60s
    restart: unless-stopped

  nextcloud:
    container_name: nextcloud-app
    image: ${NEXTCLOUD_IMAGE_TAG}
    volumes:
      - nextcloud-data:${DATA_PATH}
    ports:
      - "7689:80"
    environment:
      TZ: ${NEXTCLOUD_TIMEZONE}
      POSTGRES_HOST: nextcloud-db
      DB_PORT: 5432
      POSTGRES_DB: ${NEXTCLOUD_DB_NAME}
      POSTGRES_USER: ${NEXTCLOUD_DB_USER}
      POSTGRES_PASSWORD: ${NEXTCLOUD_DB_PASSWORD}
      REDIS_HOST: nextcloud-redis
      REDIS_HOST_PORT: 6379
      REDIS_HOST_PASSWORD: ${NEXTCLOUD_REDIS_PASSWORD}
      NEXTCLOUD_ADMIN_USER: ${NEXTCLOUD_ADMIN_USERNAME}
      NEXTCLOUD_ADMIN_PASSWORD: ${NEXTCLOUD_ADMIN_PASSWORD}
      NEXTCLOUD_TRUSTED_DOMAINS: ${NEXTCLOUD_HOSTNAME}
      OVERWRITECLIURL: ${NEXTCLOUD_URL}
      OVERWRITEHOST: ${NEXTCLOUD_HOSTNAME}
      TRUSTED_PROXIES: 172.16.0.0/12 192.168.0.0/16 10.0.0.0/8 fc00::/7 fe80::/10 2001:db8::/32
      PHP_UPLOAD_LIMIT: 8G
      PHP_MEMORY_LIMIT: 8G
    networks:
      - default
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:80/"]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 90s
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy

  nextcloud-cron:
    container_name: nextcloud-cron
    image: ${NEXTCLOUD_IMAGE_TAG}
    entrypoint: /cron.sh
    volumes:
      - nextcloud-data:${DATA_PATH}
    networks:
      - default
    restart: unless-stopped

volumes:
  nextcloud-data:
  redis-data:
  nextcloud-postgres:

Créez le fichier .env :

$ touch .env

Ajoutez ensuite les variables suivantes dans ce fichier :

NEXTCLOUD_POSTGRES_IMAGE_TAG=postgres:16
NEXTCLOUD_REDIS_IMAGE_TAG=redis:7.2
NEXTCLOUD_IMAGE_TAG=nextcloud:34

NEXTCLOUD_REDIS_PASSWORD=<your-redis-password>

NEXTCLOUD_DB_NAME=nextclouddb
NEXTCLOUD_DB_USER=nextclouddbuser
NEXTCLOUD_DB_PASSWORD=<your-database-password>

NEXTCLOUD_ADMIN_USERNAME=admin
NEXTCLOUD_ADMIN_PASSWORD=<your-admin-password>

NEXTCLOUD_URL=http://localhost:7689
NEXTCLOUD_HOSTNAME=localhost:7689
NEXTCLOUD_TIMEZONE=Europe/Paris

DATA_PATH=/var/www/html

Une fois cette étape terminée, vous pouvez démarrer votre instance en exécutant la commande suivante :

docker compose up -d

Rendez-vous ensuite à l’adresse http://localhost:7689

Vous devriez alors voir :

Connectez-vous à l’aide du nom d’utilisateur et du mot de passe Nextcloud renseignés dans le fichier .env .

Tout est désormais opérationnel : votre instance Nextcloud est prête à être utilisée.

Vous pouvez passer à la section suivante.

Installation de Portabase

Tableau de bord Portabase

Créez un répertoire :

$ mkdir portabase

Accédez à ce répertoire :

$ cd portabase

Créez un fichier docker-compose.yml et collez-y le code suivant :

$ touch docker-compose.yml

name: portabase

services:

  portabase:
    container_name: portabase-app
    image: portabase/portabase:latest
    restart: unless-stopped
    env_file:
      - .env
    ports:
      - "${HOST_PORT}:80"
    environment:
      - TZ=${TZ}
      - LOG_LEVEL=${LOG_LEVEL}
      - PROJECT_SECRET=${PROJECT_SECRET}
      - PROJECT_URL=${PROJECT_URL}
    volumes:
      - portabase-data:/data
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost/api/health"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 60s
      
volumes:
  portabase-data:

Si vous souhaitez utiliser une base de données PostgreSQL externe pour stocker les métadonnées internes de Portabase, vous pouvez consulter la documentation suivante : https://portabase.io/docs/dashboard/installation/environment

Créez le fichier .env :

$ touch .env

Ajoutez ensuite les variables suivantes dans ce fichier :

HOST_PORT="8887"
PROJECT_SECRET="<your-secret>" # openssl rand -hex 32
PROJECT_URL="http://localhost:8887"
TZ="Europe/Paris"
LOG_LEVEL="info"

Une fois cette étape terminée, vous pouvez démarrer votre instance en exécutant la commande suivante :

docker compose up -d

Rendez-vous ensuite à l’adresse http://localhost:8887

Début de l’assistant de configuration de Portabase pour installer et personnaliser la solution.

Finalisation de l’assistant de configuration de Portabase lors de l’installation.

Ajout d’« agents » à Portabase

Les « agents » correspondent essentiellement au composant installé sur l’hôte Docker. Ils exécutent les opérations principales liées à la sauvegarde de vos volumes Docker.

La configuration nécessite quelques étapes des deux côtés : sur votre serveur Portabase et sur l’hôte Docker dont vous souhaitez sauvegarder les volumes.

Côté serveur Portabase, accédez au menu Agents, puis cliquez sur Ajouter un agent.

Cela ouvrira la boîte de dialogue Créer un nouvel agent.

Donnez un nom à l’agent. Vous pouvez également ajouter une description.

Nommez l’agent et ajoutez éventuellement une description.

L’agent est maintenant ajouté côté Portabase.

Configuration de la CLI Portabase

Maintenant que l’agent est configuré côté Portabase, nous devons configurer la partie « client », c’est-à-dire l’hôte Docker.

Pour cela, nous allons installer la CLI Portabase. Son installation est simple à l’aide de la commande ci-dessous, conformément à la documentation Portabase :

curl -sL https://portabase.io/install | bash

L’écran de l’agent affiche les sections Registration et Setup, dans lesquelles vous pouvez copier la commande CLI contenant le jeton d’authentification permettant à l’agent distant de se connecter à Portabase.

Avant de poursuivre, vérifiez les volumes Nextcloud ainsi que les noms des conteneurs :

Retournez ensuite sur le tableau de bord Portabase.

Comme vous pouvez le voir ci-dessous, l’agent est désormais connecté et la section Managed Databases affiche le volume Docker que nous avons configuré pour être protégé.

Agent ajouté à Portabase et communiquant correctement avec le volume Docker enregistré.

Lier l’agent à une organisation

Créer un nouveau projet et sélectionner le volume Docker à protéger

Ci-dessous, je crée un nouveau projet. La création d’un projet est nécessaire, car c’est à ce niveau que les opérations de sauvegarde peuvent être configurées et exécutées.

Ici, je donne un nom au projet et je sélectionne le volume Docker à protéger.

Exécuter une sauvegarde avec Portabase

Ouvrez le projet Nextcloud dans Portabase.

Vous devriez maintenant voir les volumes Docker qui ont été ajoutés au projet.

Vos volumes Docker Nextcloud sont désormais protégés avec Portabase.

Aller plus loin

Une sauvegarde manuelle constitue une première étape, mais une véritable stratégie de sauvegarde doit être automatisée.

Depuis le tableau de bord Portabase, vous pouvez configurer :

des politiques de sauvegarde planifiée pour exécuter automatiquement les sauvegardes ;
des politiques de rétention pour définir la durée de conservation des sauvegardes ;
des fournisseurs de stockage pour conserver les sauvegardes en dehors de l’hôte Docker ;
des opérations de restauration pour récupérer un volume en cas de besoin.

Pour les environnements de production, il est fortement recommandé de stocker vos sauvegardes sur une infrastructure distincte du serveur Nextcloud. Ainsi, une défaillance affectant l’hôte d’origine ne pourra pas également détruire vos sauvegardes.

Une stratégie de sauvegarde fiable doit également inclure des tests réguliers de restauration. Une sauvegarde n’est réellement utile que si elle peut être restaurée lorsqu’un incident survient.

Grâce à Portabase, qui centralise le processus de sauvegarde, et à un agent exécuté directement sur l’hôte Docker, vous pouvez gérer et superviser depuis une interface unique la protection de votre déploiement Nextcloud.