Déployer Dolibarr : cache Framework en 2026

Déployer Dolibarr : exploiter le cache Framework en 2026
Par [Nom du rédacteur] – 2 novembre 2025

1. Introduction – Pourquoi parler de cache en 2026 ?

Dolibarr, solution ERP/CRM open‑source écrite en PHP, fête déjà plus d’une décennie d’existence. En 2026, la version Dolibarr 19 (ou supérieure) sera la référence officielle, avec un moteur de plugins plus modulable, un API REST + GraphQL et une compatibilité native avec les principaux frameworks PHP (Symfony 7, Laravel 12 et Symfony Micro).

Le cache devient alors un levier stratégique :

Besoin Impact
Chargement des listes de contacts, devis, factures (souvent très volumineux) Réduction du temps de réponse de 30 % à 70 %
Génération de rapports PDF et d’exports CSV Diminution de la charge serveur de 40 %
Consultation simultanée d’utilisateurs multi‑site Meilleure scalabilité horizontale

Le Framework Cache (ou Cache Framework) – notion qui regroupe les mécanismes de mise en cache dérivés des composants de Symfony, Laravel et du modèle d’Cache‑PSR‑16 – sera le point d’ancrage pour rendre Dolibarr à la fois plus rapide et plus prévisible dans un environnement micro‑services en 2026.

2. Panorama du cache « Framework » en 2026

Technologie Version prévue 2026 Particularités pour Dolibarr
Symfony Cache (PSR‑16) 7.2 Intégration via le Cache Component ; support natif du tagging et du invalidation par événements Dolibarr.
Laravel Filesystem / Cache 12.x Utilisable via le Service Provider dédié à Dolibarr, idéal pour les farms d’applications Docker/K8s.
Doctrine Cache 3.0 Principe de query‑cache appliqué aux SELECT lourds des modules “CRM”.
Cache‑PSR‑16 + TTL-aware adapters 1.3 Cache “TTL‑aware” qui évite les rafraissements simultanés (stampede) – utile pour les listes de tarifs actualisées en temps réel.
CDN + Edge‑Cache CDN‑2026 Distribution des artefacts statiques (PDF, images de contrats) via un CDN global, améliorant la latence pour les filiales étrangères.

Note : Le Framework‑Cache de 2026 n’est pas une seule librairie, mais un ensemble d’interfaces (PSR‑16, PSR‑17, PSR‑85) que les fournisseurs (Symfony, Laravel, Doctrine) implémentent de façon interopérable. Cela simplifie l’écriture d’un Cache‑Adapter qui peut basculer d’un backend à l’autre en fonction du context (Docker, VM, serveur dédié).

3. Architecture proposée : Cache des données transactionnelles et des vues

3.1. Diagramme simplifié

+----------------------------+      +----------------------------+

|  Front‑end SPA / Web UI      | ---> |  API REST + GraphQL (v2)   |

+----------------------------+      +----------------------------+

                                   |

                                   v

+----------------------------+      +----------------------------+

|  Dolibarr Core (PHP 8.3)   | <--> |  Cache Adapter (PSR‑16)    |

+----------------------------+      +----------------------------+

                                   |                     |

                 -----------------------------------------------------------

                 |                     |                     |

               Symfony               Doctrine               Laravel

                 Cache               Cache                 Cache

  • Front‑end (Vue 3 + Vite) consomme les endpoints REST/GraphQL exposés par Dolibarr.

  • API expose des Cache‑Headers (Cache-Control, ETag) générés par le Cache Adapter interne.

  • Cache Adapter orchestre les appels aux back‑ends de cache (Redis, Memcached, SQLite‑Cache).

3.2. Stratégie de mise en cache par type d’entité

Entité Niveau de cache Exemple de TTL Invalidations
Customer / Supplier Shared (Redis) 5 min (TTL) userUpdated, addressChanged → purge des tags customers:*
Invoice / Quote Object (Doctrine query cache) 2 min invoiceGenerated → invalidateByKey('invoice:#id')
Report PDF External (CDN + ETag) « Cache‑Until‑Change » reportRegenerated → mise à jour de l’ETag
Multi‑company settings Distributed (SQLite + Cache‑Tag) 30 s companySettingsChanged → clearTags('settings:*')

4. Implémentation concrète (code réel)

Contexte : Vous avez un module « Supplier » qui charge la liste des partenaires dans l’interface d’achat. Le nombre de lignes peut atteindre 10 000. Nous allons mettre en place un cache PSR‑16 partagé avec Symfony Cache Component.

4.1. Installation des dépendances

composer require symfony/cache:^7.2

composer require symfony/cache-tauri:^7.2   # pour les adapters (redis, apc, etc.)

composer require psr/cache ^3.0

4.2. Configuration du service (dans src/Dolibarr/Extension/Cache/Extension.php)

<?php

declare(strict_types=1);
namespace Dolibarr\Extension\Cache;
use Symfony\Component\Cache\CacheInterface;

use Symfony\Component\Cache\Adapter\RedisAdapter;

use Symfony\Component\Cache\Adapter\ArrayAdapter;

use Psr\Cache\CacheInterface as PsrCacheInterface;
/**

 * Factory de cache adaptée aux besoins de Dolibarr.

 *

 * @return CacheInterface

 */

function getCache(): CacheInterface

{

    // Choix du backend selon la variable d'environnement

    $backend = getenv('DOLIBARR_CACHE_BACKEND') ?: 'array';
switch ($backend) {

        case 'redis':

            $redis = new RedisAdapter('tcp://127.0.0.1:6379', 'cache', 300);

            return $redis;                       // implémente CacheInterface + PsrCacheInterface

        case 'memcached':

            // Méthode similaire en passant un MemcachedAdapter

            // ...

        default:

        case 'array':

            // Simple in‑memory array adapter – utilisable en dev ou micro‑services limités.

            return new ArrayAdapter();

    }

}
/**

 * Exemple d’utilisation dans le service SupplierRepository.

 */

class SupplierRepository extends AbstractRepository

{

    private \Symfony\Component\Cache\CacheInterface $cache;
public function __construct()

    {

        $this->cache = getCache();

    }
/**

     * Retourne la liste des fournisseurs avec cache TTL de 300 s.

     *

     * @return array

     */

    public function findAllWithCache(): array

    {

        $key = 'suppliers:all';

        $ttl = 300; // secondes
// 1️⃣ On tente de récupérer le cache

        $data = $this->cache->get($key, function () {

            // 2️⃣ Si le cache est manquant, on charge la DB

            return $this->loadSuppliersFromDb();

        });
// 3️⃣ Retourner les données (cache rafraîchi automatiquement si expired)

        return $data;

    }
private function loadSuppliersFromDb(): array

    {

        // … code SQL via PDO …

        return $rows; // tableau de fournisseurs

    }

}

Points clés

  • L’interface CacheInterface de Symfony garantit le PSR‑16 : get($key, callable $default) permet d’exécuter la closure uniquement en cas de cache miss.

  • Les tags sont ajoutés via tag($tag), et l’invalidation se fait avec $this->cache->invalidate([$tag]).

  • Le choix du backend (Redis, SQLite, APCu…) se fait par variable d’environnement – crucial lors du déploiement en K8s où chaque pod possède son propre ConfigMap.

4.3. Invalidation au moment d’un changement

public function updateSupplier(int $id, array $data): bool

{

    // 1️⃣ Persiste les changements en base

    $this->pdo->prepare(

        "UPDATE llx_supplier SET libelle = :lib, factura = :fact WHERE rowid = :id"

    )->execute([

        ':lib'  => $data['name'],

        ':fact' => $data['invoice'],

        ':id'   => $id,

    ]);
// 2️⃣ Invalide le cache lié aux fournisseurs

    $this->cache->invalidate(['supplier_list']); // tag utilisé lors du get()

    return true;

}

Tagging : L’appel tag('supplier_list') lors du premier fetch crée un identifiant de groupe. Lors de la mise à jour, on n’a besoin qu’à invalider ce tag, ce qui libère automatiquement toutes les clés associées, sans devoir parcourir chaque clé.

5. Gestion du cache dans un environnement micro‑services (2026)

En 2026, la plupart des déploiements Dolibarr sont containerisés via Docker‑Compose ou Kubernetes. Voici comment le cache s’intègre :

Élément Rôle
Redis Cluster (ou Upstash) Backend de cache partagé entre tous les pods (TTL configurable via ConfigMap).
Edge‑Cache CDN (Cloudflare Workers) Cache HTTP de toutes les réponses GET /api/v2/ avec Cache-Control: public, max-age=86400.
Side‑Car “Cache‑Proxy” (Envoy) Intercepte les requêtes internes (ex : GET /suppliers) et ajoute les en‑têtes de validation (ETag, Last‑Modified).
Prometheus + Grafana Métriques : cache_hits_total, cache_misses_total, latency_cache – pour ajuster les TTL.

5.1. Exemple de configuration Kubernetes (YAML)

apiVersion: v1

kind: ConfigMap

metadata:

  name: dolibarr-cache-config

data:

  APP_CACHE_BACKEND: "redis"

  REDIS_URL: "redis://redis:6379/0?timeout=2.5"

---

apiVersion: apps/v1

kind: Deployment

metadata:

  name: dolibarr-web

spec:

  replicas: 3

  selector:

    matchLabels:

      app: dolibarr

  template:

    metadata:

      labels:

        app: dolibarr

    spec:

      containers:

      - name: php-fpm

        image: myrepo/dolibarr:19

        envFrom:

        - configMapRef:

            name: dolibarr-cache-config

        env:

        - name: REDIS_URL

          valueFrom:

            configMapKeyRef:

              name: dolibarr-cache-config

              key: REDIS_URL

        ports:

        - containerPort: 8080

      - name: redis

        image: redis:7

        ports:

        - containerPort: 6379

        resources:

          limits:

            memory: "256Mi"

          requests:

            memory: "128Mi"

Tip 2026 : Le “cache‑aware autoscaling” de Kubernetes (via le HorizontalPodAutoscaler basé sur les métriques redis_commands_processed_total et cache_hit_ratio) permet de lancer automatiquement plus de pods lorsqu’un cache miss rate dépasse 20 % pendant plus de 5 minutes.

6. Bonnes pratiques à retenir pour 2026

# Pratique Pourquoi
1️⃣ Utiliser les Tags PSR‑16 Permet d’invalider des groupes de clés sans connaître chaque clé.
2️⃣ Ne jamais mettre en cache les données d’authentification Sécurité – les tokens JWT sont toujours « no‑cache ».
3️⃣ Mettre en cache les réponses GraphQL via le Cache‑Control généré par le resolver.
4️⃣ Limiter le TTL aux besoins métier (≥ 30 s pour les listes, ≤ 5 s pour les stats temps réel). Évite les stale reads qui sautent des changements critiques (prix, stocks).
5️⃣ Activer le suivi des erreurs (Cache‑Miss, Cache‑Stampede) avec des alertes Prometheus. Déclenche une récupération automatique (circuit‑breaker).
6️⃣ Versionner le schéma de cache (cache_version dans la base) afin d’appliquer des migrations (ex : passage de ArrayAdapter à RedisAdapter).
7️⃣ Audit de sécurité – s’assurer que les clés de cache ne fuient pas d’informations sensibles (ex : numéros de compte bancaire).

7. Perspectives d’évolution au-delà de 2026

2027‑2028 Innovation Impact sur Dolibarr
Cache Invalidation Based on Domain Events (Kafka Streams) Propagation d’évènements « ProductUpdated » à tous les pods Cache toujours à jour dans un architecture event‑driven.
AI‑assisted Cache TTL Optimisation Algorithmes qui ajustent dynamiquement le TTL selon le taux de rafraîchissement historique. Réduction supplémentaire des latences de 10‑15 %.
Serverless Edge‑Cache (e.g., Cloudflare Workers KV) Décalage du cache vers la périphérie, éliminant la latence réseau interne. Possibilité de servir 99 % des requêtes depuis le CDN uniquement.
Cache‑Direct sur MySQL 9.0 JSON‑Indexes Cache natif des requêtes JSON via Cache plugin intégré. Moins de dépendance aux solutions externes, mais nécessite MySQL 9+.

8. Conclusion

En 2026, le cacheFramework n’est plus un agrégat de solutions disparates mais un éco‑système cohérent autour du standard PSR‑16, qui peut être orchestré par n’importe quel moteur PHP moderne – Symfony, Laravel ou même le noyau de Dolibarr lui‑même.

Pour exploiter pleinement ce potentiel :

  1. Intégrez un Cache Adapter (Redis/Array) via Symfony Cache Component.

  2. Utilisez le tagging pour grouper les clés (ex : supplier_list, invoice_#id).

  3. Déployez un backend partagé (Redis Cluster ou Upstash) et captez les métriques de performance.

  4. Adoptez les patterns de micro‑services (Envoy, side‑car) pour ajouter les en‑têtes de validation et les stratégies de scalabilité.

En suivant ces étapes, votre instance Dolibarr passera d’une application monolithique à une architecture distribuée à hautes performances, capable de gérer des flux de transactions massifs tout en conservant la simplicité d’utilisation qui a fait sa renommée.

À retenir : En 2026, le cache n’est plus un « plus‑mauvais », mais le cœur de la scalabilité de Dolibarr. Maîtrisez-le, et vous aurez une plateforme prête pour les exigences de l’industrie 5.0.

Sources :

  • Symfony Cache Component 7.2 – Documentation officielle (2025)

  • Laravel Cache 12.x – Release Notes (novembre 2025)

  • “Designing Distributed Cache Architectures for ERP Systems”, IEEE 2024

  • Dolibarr Roadmap 2025‑2027 (dolibarr.org)

Auteur : Jonathan Lambert, Consultant ERP & Open‑Source, spécialisé dans les architectures PHP‑based.

Bon déploiement ! 🚀

Publications similaires