DevOps Dolibarr : export Méthode avec des exemples concrets

Pourquoi automatiser les exports ? Comment les intégrer dans un pipeline CI/CD ? Quel format choisir ? Des scripts, des API, du Docker…

1️⃣ Introduction

Dolibarr est un ERP/CRM open‑source très apprécié des PME pour sa simplicité d’utilisation et son architecture modulaire.
Dans un contexte DevOps, le problème le plus récurrent est la reproductibilité : comment extraire régulièrement les données métier (produits, clients, factures…) et les rendre disponibles pour :

  • des sauvegardes automatisées,

  • des traitements de Business Intelligence,

  • des migrations vers un autre système,

  • des tests d’intégration continus.

Cet article passe en revue les différentes méthodes d’export que Dolibarr propose (ou que l’on peut implémenter) et montre comment les encadrer dans un workflow DevOps grâce à des outils modernes (API REST, scripts Python, conteneurs Docker, pipelines CI/CD).

2️⃣ Pourquoi l’Export fait‑il partie du processus DevOps

Enjeu DevOps Impact d’un export bien défini
Traçabilité Historique des jeux de données (ex. : versions de catalogue produit).
Reproductibilité Un même jeu de données peut être reconstruit à chaque run du pipeline.
Sécurité Export dans un format contrôlé (CSV, JSON) qui peut être chiffré ou signé.
Scalabilité Des exports automatisés évitent les goulots d’étranglement lors de migrations.
Collaboration Les équipes QA, BI ou les intégrateurs consomment les mêmes artifacts.

En résumé : lorsqu’on peut export‑er les données de manière fiable, on rend le système plus résilient.

3️⃣ Les différentes méthodes d’export dans Dolibarr

Méthode Quand l’utiliser Points forts Limites
Export natif via l’interface Besoin ponctuel, petite quantité de données. Aucun code requis, UI familière. Pas automatisable facilement, aucun contrôle de format.
Export CSV via module “Export” Export de listes (articles, clients, factures). Simple,可选 champs, téléchargement direct. Pas de logique personnalisée, dépend de la version de Dolibarr.
Export via API REST Scénarios CI/CD, transformations JSON, scripts automatisés. Contrôle total du payload, authentification token, réutilisable. Nécessite d’activer le module REST (GET / POST).
Export via scripts PHP/CLI Besoin de traitement lourd (filtrage, agrégations). Flexibilité totale, possibilité d’utiliser les classes internes. Installation de scripts sur le serveur, maintenance du code.
Backup de la base de données (mysqldump, pg_dump) Sauvegarde complète ou point‑in‑time. Sauvegarde fidèle du schéma + données. Pas un export métier « dé‑couplé », nécessite l’accès DB.
Conteneurisation (Docker) Déploiement reproducible, CI/CD, environnements isolés. Touts les artefacts (code, dépendances) sont versionnés. Nécessite un Dockerfile et un registre d’images.

Le bon compromis pour la plupart des équipes DevOps : API REST + Docker + pipeline CI/CD.
Nous détaillerons ces trois leviers avec des exemples concrets.

4️⃣ Exemple 1 – Export CSV via l’interface (cas basique)

  1. Connexion à l’interface Web de Dolibarr.

  2. Aller dans “Products → Listes” → cliquer sur l’icône 📄 Export.

  3. Choisir le format CSV et sélectionner les colonnes à exporter.

  4. Sauvegarder le fichier sur le serveur.

Automatisation possible : on peut simuler le clic via un script curl qui reproduit les paramètres POST envoyés par le formulaire.
Cependant, pour des besoins DevOps plus robustes, on privilégiera l’API (voir §5).

5️⃣ Exemple 2 – Export JSON via l’API REST de Dolibarr

5.1 Activer le module REST

  • Dans l’administration → Paramètres → API REST → activer « Oui ».

  • Créer un Token d’API (ou utiliser les credentials “Admin”).

  • Le token est une chaîne du type token=abcd1234efgh5678.

5.2 URL d’accès

GET /dolibarr/api/v1/articles

Retourne le JSON contenant la liste des articles (produits) avec leurs attributs (label,_price, type, …).

5.3 Script Python d’export (exécuté dans le pipeline)

# file: export_articles.py

import requests

import csv

import os

import sys

import json
API_ROOT = os.getenv('DOLIBARR_URL', 'https://dolibarr.example.com')

TOKEN    = os.getenv('DOLIBARR_TOKEN')          # <-- à injecter depuis le CI

HEADERS  = {'Authorization': f'Token {TOKEN}'}
def fetch_articles():

    url = f'{API_ROOT}/api/v1/articles'

    resp = requests.get(url, headers=HEADERS, timeout=30)

    resp.raise_for_status()

    return resp.json()       # listes d'objets article
def write_csv(data, path='articles.csv'):

    with open(path, 'w', newline='', encoding='utf-8') as f:

        writer = csv.DictWriter(

            f,

            fieldnames=['id','ref','label','price','type','description']

        )

        writer.writeheader()

        for a in data:

            writer.writerow({

                'id': a['id'],

                'ref': a['ref'],

                'label': a['label'],

                'price': a['price'],

                'type': a['type'],

                'description': a.get('description', '')

            })

    print(f'✅  CSV exporté vers {path}')
if __name__ == '__main__':

    articles = fetch_articles()

    write_csv(articles)

5.4 Intégration dans un fichier GitLab CI (.gitlab-ci.yml)

stages:

  - export

  - test
export_articles:

  stage: export

  image: python:3.11-slim

  script:

    - pip install --quiet requests

    - export DOLIBARR_URL=https://dolibarr.monrepo.local

    - export DOLIBARR_TOKEN=$CI_JOB_TOKEN   # token généré par GitLab

    - python export_articles.py

  artifacts:

    paths:

      - articles.csv

    expire_in: 1 week

  only:

    - main

Ce qui est automatisé : le pipeline télécharge le token CI, interroge l’API, écrit un CSV et le conserve en tant qu’artifact pour les étapes suivantes (tests d’intégrité, uploads S3, etc.).

6️⃣ Exemple 3 – Export de la base de données via Docker & Script Bash

Dans un environnement DevOps, on préfère souvent dé‑coupler le code applicatif de la persistance.
Voici comment exporter tout le Schéma + les données de Dolibarr en utilisant :

  • Un conteneur PostgreSQL contenant l’instance Dolibarr.

  • Un script pg_dump lancé depuis un conteneur alpine dans le pipeline.

6.1 Docker‑Compose (extrait)

version: "3.8"

services:

  db:

    image: postgres:15-alpine

    environment:

      POSTGRES_DB: dolibarr

      POSTGRES_USER: dolibarr

      POSTGRES_PASSWORD: secret

    volumes:

      - pgdata:/var/lib/postgresql/data
dolibarr:

    image: dolibarr/dolibarr:latest

    depends_on: [db]

    environment:

      - MYSQL_HOST=db

      - DB_USER=dolibarr

      - DB_PASSWORD=secret

      - DB_NAME=dolibarr

    ports:

      - "8080:80"
backup:

    image: alpine:latest

    depends_on: [dolibarr]

    entrypoint: ["/bin/sh","-c"]

    command: |

      apk add --no-cache postgresql-client &&

      pg_dump -h db -U dolibarr -Fc dolibarr > backup.dump &&

      echo "dump créé : $(ls -lh backup.dump)"

    volumes:

      - backup-data:/backup

    restart: "no"
volumes:

  pgdata:

  backup-data:

6.2 Étapes de backup dans le pipeline

backup_db:

  image: docker:latest

  services:

    - docker:dind

  script:

    - docker-compose up -d dolibarr db backup

    # Attestation : le conteneur backup crée backup.dump dans /backup

    - docker cp $(docker-compose ps -q backup):/backup/backup.dump ./backup.dump

    - ls -lh backup.dump

  artifacts:

    paths:

      - backup.dump

    expire_in: 2 weeks

Le résultat : le fichier backup.dump (format custom de PostgreSQL) est versionné comme artefact CI.
Il pourra être restauré dans un environnement de staging avec pg_restore -d dolibarr backup.dump.

7️⃣ Exemple 4 – Export automatisé de CVs (contacts) vers Amazon S3

Supposons que l’on doive migrer les fichiers de contacts (clients, fournisseurs) vers un bucket S3 afin d’alimenter un pipeline de data‑lake.

7.1 Script PowerShell (ou Bash)

# export_contacts.ps1

$ApiUrl = "https://dolibarr.monrepo.local/apirest.php/c/apicontents"

$Token  = "$env:DOLIBARR_TOKEN"

$Headers = @{ Authorization = "Token $Token" }
$Response = Invoke-RestMethod -Uri "$ApiUrl/contacts" -Headers $Headers -Method Get

$Response | ConvertTo-Json -Depth 5 | Out-File -Encoding utf8 contacts.json
# Upload vers S3 (awscli installé dans l’image)

aws s3 cp contacts.json s3://my-company-data-lake/dolibarr/contacts/

Write-Host "✅  Contacts exportés et poussés vers S3"

7.2 Pipeline GitHub Actions

name: Export Contacts → S3

on:

  schedule:

    - cron: '0 2 * * *'   # tous les jours à 02 h

  workflow_dispatch:

jobs:

  export:

    runs-on: ubuntu-latest

    steps:

      - uses: actions/checkout@v4

      - name: Setup Python

        uses: actions/setup-python@v5

        with:

          python-version: '3.11'

      - name: Install dependencies

        run: pip install --quiet requests boto3

      - name: Export contacts

        env:

          DOLIBARR_URL: ${{ secrets.DOLIBARR_URL }}

          DOLIBARR_TOKEN: ${{ secrets.DOLIBARR_TOKEN }}

        run: python export_contacts.py

      - name: Upload to S3

        env:

          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}

          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

          AWS_DEFAULT_REGION: eu-west-1

        run: aws s3 cp contacts.json s3://my-company-data-lake/dolibarr/contacts/

Avantages DevOps : exécution planifiée, logs centralisés, secrets gérés par GitHub Secrets, auditabilité complète.

8️⃣ Bonnes pratiques pour des exports fiables

❗️ Aspect ✅ Recommandation
Idempotence L’export doit toujours produire le même artefact lorsqu’il est relancé (pas de données “éphémères”).
Versionnage Nommez les fichiers avec YYYYMMDD-HHMM ou avec le SHA du commit CI (export-${GIT_SHA}.csv).
Sécurité Utilisez un token à durée limitée ; ne conservez jamais le mot de passe en clair dans les scripts.
Encodage Privilégiez UTF‑8 (ex. CSV/JSON).
Chunking Si la volumétrie est importante, exportez en plusieurs petits fichiers ou compressez (gzip).
Tests de validation Ajoutez une étape validation (schema JSON, checksum MD5) avant de publier les artefacts.
Déploiement Conservez les artefacts dans un dépôt d’objets (S3, OSS, Azure Blob) qui a une politique de rétention claire.
Rollback Gardez un prev version du dernier export pour permettre une restauration rapide.

9️⃣ Checklist DevOps pour un Export Dolibarr

✅ Étape ✅ Comment le mettre en place
1️⃣ Activer l’API REST /dolibarr/api/v1/authorize → créez un token d’API.
2️⃣ Définir le périmètre /api/v1/articles, /api/v1/customers, /api/v1/invoices.
3️⃣ Choisir le format JSON (facile à transformer), CSV (BI), Dump DB (backup).
4️⃣ Script d’extraction Python/Node avec gestion des erreurs, pagination (page, range).
5️⃣ Persistance gitlab-ci job artifacts / GitHub Actions upload-artifact / S3.
6️⃣ Validation jq -c '.. | objects | select(.price == null)' ou jsonschema.
7️⃣ Publication aws s3 cp …, docker push myrepo/export:tag, publish npm package.
8️⃣ Monitoring Logs ELK → alertes sur erreurs > 5 min, métriques de taille.
9️⃣ Nettoyage Retention des artefacts (ex. 30 jours), purge des anciens tokens.

🔚 Conclusion

L’export de données depuis Dolibarr n’est pas une fonctionnalité « nice‑to‑have » ; c’est un pivot DevOps qui assure :

  • La traçabilité des changements métier,

  • La reproducibilité des environnements de test et de déploiement,

  • Et la déclinaison vers d’autres outils (BI, data‑lake, migration).

En combinant :

  • L’API REST (source structurée, controllable),

  • Des conteneurs Docker (mise en place reproducible, scaling),

  • Des pipelines CI/CD (GitLab, GitHub, Azure DevOps),

on obtient un workflow d’export automatisé, sécurisé et observable.

Le véritable défi réside maintenant dans la mise en œuvre : choisissez la méthode qui correspond le mieux à vos besoins de volume, de fréquence et de format, puis commercialisez‑la comme un standard d’export au sein de votre organisation.

« Exportation automatisée = plus de confiance »,
et dans un monde où le code évolue chaque jour, la confiance se construit avec des artefacts fiables et versionnés.

À vous de jouer !
Intégrez l’un des exemples ci‑dessus dans votre chaîne CI/CD, testez avec un petit jeu de données, puis étendez progressivement jusqu’à couvrir tous les objets métier de Dolibarr. Bon DevOps ! 🚀

Publications similaires