Aller au contenu

Mise en cache

Blockstudio inclut des caches persistants basés sur des fichiers. Ils sont activés par défaut via le réglage cache.enabled et sont écrits dans :

Code
wp-content/blockstudio/cache/

Cette racine configurée unique contient les données utiles de build du runtime, les données précompilées d’enregistrement des blocs, les ressources de l’éditeur, Tailwind CSS, les documents rendus, les fragments d’îlots, les fichiers statiques HTML, les index de graphe, les files d’attente de préchauffage et les diagnostics du cache. Cela évite de répéter les opérations de découverte, d’analyse, de compilation et de rendu, tout en gardant l’état généré du runtime dans une seule limite gérable par l’hôte.

La valeur par défaut se trouve délibérément en dehors de uploads, où les hôtes renforcés peuvent bloquer les données utiles du cache PHP. Modifiez l’emplacement avec cache.path ; les chemins relatifs sont résolus à partir de WP_CONTENT_DIR, tandis que les chemins absolus permettent d’utiliser des volumes de cache dédiés accessibles en écriture :

JSON
{
  "cache": {
    "enabled": true,
    "path": "cache/blockstudio"
  }
}

Pour une configuration propre à l’environnement, utilisez le filtre de réglage ou celui du répertoire résolu :

PHP
add_filter('blockstudio/settings/cache/path', function () {
    return '/srv/wordpress-cache/blockstudio';
});

add_filter('blockstudio/cache/dir', function (string $directory): string {
    return WP_CONTENT_DIR . '/cache/blockstudio';
});

La modification du chemin entraîne un cache froid. Les anciens fichiers de wp-content/uploads/blockstudio/cache ne sont plus lus et peuvent être supprimés.

Identité et invalidation

Chaque portée est imbriquée sous une identité réseau/blog et une identité de runtime complète. Les entrées du cache changent lorsque leurs données d’entrée changent, notamment les fichiers de blocs surveillés, les fichiers de champs, les dépendances des ressources, les réglages, le thème actif, les extensions actives, les inventaires logiques de découverte, WordPress, PHP et les versions Blockstudio. Les empreintes des dépendances propres à chaque élément isolent les compilations limitées aux éléments modifiés des objets sans rapport.

Les sources de découverte logique apportent aussi leur identifiant source, leur empreinte de contenu et leurs entrées surveillées. D’autres sélections de runtime peuvent ajouter une valeur blockstudio/cache/context pour isoler toutes les portées du cache. Les hôtes dont la limite de locataire diffère des identifiants réseau/blog WordPress peuvent filtrer blockstudio/cache/site_key ; le résultat est assaini avant de devenir un segment de chemin.

Lors d’une requête frontend avec cache préchauffé, Blockstudio hydrate le registre du runtime avant de construire les sources de découverte. Un résultat valide du cache évite donc la découverte récursive des sources, la construction des blocs, l’analyse des champs et les parcours répétés de l’arborescence des clés de cache.

La charge utile d’exécution stocke également les chemins résolus des ressources de blocs, leurs tailles, leurs horodatages et les listes de feuilles de style des modules. Les requêtes à chaud réutilisent ces métadonnées au lieu de répéter les recherches de sortie des ressources et les analyses de répertoires de modules pour chaque bloc rendu. Les filtres URL des ressources et de désactivation s’exécutent toujours pour la requête en cours, et assets.inlineLimit conserve son budget à l’échelle de la page et l’ordre de cascade. Aucune métadonnée de sortie de ressource n’est collectée lorsque assets.enqueue ou la mise en cache persistante est désactivé. Une dernière compilation valide devenue obsolète entraîne la résolution des ressources depuis le disque.

Les paramètres résolus qui n’ont pas changé réutilisent également leur empreinte dans la requête. Le rechargement ou la modification des paramètres l’invalide ; les valeurs d’objet ou de référence mutables sont recalculées au lieu de réutiliser une empreinte potentiellement obsolète.

Dans production et staging, un instantané de surveillance validé est considéré comme fiable pendant 20 secondes avant que Blockstudio ne vérifie à nouveau les statistiques de ses fichiers et répertoires. Les environnements local et development utilisent zéro par défaut afin que les modifications des sources soient visibles immédiatement. Modifiez cet intervalle avec :

PHP
add_filter('blockstudio/cache/watch_debounce', function () {
    return 30;
});

L’anti-rebond peut retarder la détection automatique des changements de source d’au plus le nombre de secondes configuré. Les ressources compilées requises, les ressources brutes non vides mises en cache et les feuilles de style des modules sont toujours vérifiées à chaque accès au cache. La suppression de l’une d’elles invalide immédiatement la charge utile d’exécution, au lieu de servir des métadonnées de ressources obsolètes jusqu’à l’expiration du délai. Réglez l’anti-rebond sur 0 lorsque vous utilisez également un environnement proche de la production pour modifier activement des fichiers.

Les charges utiles du cache sont protégées par des fichiers PHP. Les petites charges utiles utilisent des tableaux simples lorsque le processus d’écriture dispose d’une mémoire partagée OPcache active et que la destination n’est pas exclue. OPcache peut alors réutiliser le tableau compilé lors des inclusions ultérieures ; la modification des données renvoyées suit toujours le comportement normal de copie sur écriture de PHP.

Sans OPcache à mémoire partagée, les charges utiles restent des données sérialisées compressées. Cela s’applique également lorsque OPcache est plein, que son API est indisponible ou restreint, ou que sa liste noire ou opcache.max_file_size exclut le fichier. OPcache en mode cache de fichiers uniquement ne sélectionne pas le format de tableau simple. Consultez la PHP configuration d’OPcache pour connaître ces paramètres au niveau de l’hôte.

Le format par défaut en tableau simple est limité à 1 MiB, en tenant compte à la fois des données sérialisées et du code source PHP généré. Les charges utiles plus volumineuses restent compressées afin d’éviter les coûts de compilation de grands tableaux lorsqu’un processus CLI sans OPcache lit un cache préchauffé par des processus web. Les petits fichiers simples doivent tout de même être analysés par ce type de lecteur, et les fichiers nouvellement écrits peuvent nécessiter une compilation pendant opcache.file_update_protection.

Le filtre blockstudio/cache/compress remplace le format par portée, par exemple lorsque WP-CLI préchauffe des fichiers de cache pour des processus web utilisant OPcache. Renvoyer false remplace également la limite de taille : faites-le uniquement si tous les lecteurs peuvent traiter le fichier PHP généré. Si zlib est indisponible, PHP simple reste la solution de repli.

Concurrence et rétention

Les clés de cache froid utilisent un verrou à exécution unique. Une requête construit les données utiles tandis que les requêtes simultanées attendent le résultat publié de façon atomique, au lieu de répéter le même travail de découverte ou de compilation. La publication atomique évite les objets incomplets. Si une actualisation échoue, un objet valide issu de la dernière exécution réussie reste disponible, l’échec est observable et la requête suivante peut rétablir le fonctionnement.

Par défaut, les portées du runtime conservent 20 données utiles publiées. Ajustez cette limite par portée lorsqu’une intégration crée intentionnellement davantage de contextes de cache :

PHP
add_filter(
    'blockstudio/cache/max_files_per_scope',
    function (int $maximum, string $scope): int {
        return 'runtime' === $scope ? 50 : $maximum;
    },
    10,
    2
);

La rétention n’évince jamais un fichier référencé par la table de diffusion anticipée installée, et le filtre blockstudio/cache/protected_paths signale les chemins supplémentaires que l’élagage doit épargner.

Les espaces de noms inutilisés sont collectés automatiquement au lieu de s’accumuler à chaque activation d’extension et à chaque mise à jour de PHP ou WordPress. Un extrait de déploiement qui parcourait l’ancien répertoire de cache Tailwind avec une recherche de fichiers doit appeler Blockstudio\Runtime_Cache::purge('tailwind') à la place.

Un espace de noms est retiré lorsque l’identité du runtime change, par exemple après une mise à jour du cœur de WordPress. Le premier balayage de nettoyage qui le détecte comme retiré y écrit un marqueur .retired, puis l’arborescence est collectée après cache.namespaceGrace secondes (un jour par défaut). Si l’arborescence est de nouveau écrite entre-temps, le délai de grâce repart de zéro. L’espace de noms actuel d’une portée n’est jamais collecté, pas plus qu’un espace de noms dont un artefact activé est encore servi par la table de diffusion anticipée ; le délai de grâce de ce dernier commence lorsque l’activation suivante déplace son entrée dans la table. Les pages mises en cache en dehors de WordPress continuent de référencer les feuilles de style dont le nom est basé sur le contenu et avec lesquelles elles ont été rendues. Un site qui sert des pages tailwind.output: "link" via CDN ou avec un long délai de mise en cache du navigateur doit donc prolonger le délai de grâce jusqu’à la durée maximale de vie d’une telle copie :

JSON
{
  "cache": {
    "namespaceGrace": 777600
  }
}

Lorsqu’une installation mise à niveau contient l’ancien répertoire plat cache/runtime antérieur à la version 7.6, Blockstudio le renomme de façon atomique pour le retirer du chemin actif. Une tâche WP-Cron supprime ensuite au plus 500 entrées du système de fichiers par passe. Cela évite que les anciennes données utiles et les arborescences .build.lock consomment de l’espace disque, sans que la requête détectant un grand répertoire ait à le supprimer récursivement. Le nettoyage ne s’exécute que lorsque cache.enabled est actif ; modifiez la taille des lots avec blockstudio/cache/legacy_cleanup_batch_size si l’hôte a besoin de passes plus petites ou plus grandes.

Désactivez les caches persistants dans blockstudio.json :

JSON
{
  "cache": {
    "enabled": false
  }
}

Ou via un filtre :

PHP
add_filter('blockstudio/settings/cache/enabled', '__return_false');

Le cache de rendu en mémoire par requête décrit sous Performance est volontairement distinct, mais ses artefacts persistants utilisent cette même limite du système de fichiers.

Vider une accumulation d’anciens verrous

Les versions antérieures à 7.6.14 laissaient un fichier .build.lock pour chaque modification de contenu, et un site très fréquenté peut en contenir des centaines de milliers. Après la mise à niveau, WP-Cron les supprime automatiquement par lots limités. Pour vider immédiatement l’accumulation et communiquer un chiffre à votre hébergeur, exécutez la commande CLI :

Shell
wp bs cache status
wp bs cache cleanup

status compte les anciens verrous restants et indique quand le prochain lot s’exécutera. cleanup exécute des lots jusqu’à ce qu’il ne reste plus rien d’inactif, puis collecte les espaces de noms de cache dont le délai de grâce a expiré. Les verrous datant de moins d’une heure ou encore détenus par une requête en cours sont conservés pour la passe suivante. Ne supprimez jamais les fichiers de verrou à la main pendant que le site traite du trafic ; un verrou détenu coordonne les requêtes simultanées afin qu’elles ne compilent pas en parallèle.

wp bs cache clear purge tout le cache du runtime pour le site actuel, ou une portée dans tous les espaces de noms avec --scope=runtime. La requête suivante effectuera une reconstruction à froid ; exécutez cette opération lorsque le trafic est faible.

Cache Tailwind

Le cache compilé CSS de Tailwind utilise la racine de runtime partagée sous son espace de noms réseau/site/runtime et la portée tailwind. Par défaut, il conserve jusqu’à 1,000 entrées pendant 30 jours, ce qui suffit pour garder les clés de niveau page d’un site entier au lieu de les évincer après un petit nombre d’itinéraires.

Tailwind réutilise aussi un compilateur préchauffé pour une même entrée CSS dans les processus de longue durée, et conserve l’état de construction du compilateur entre les processus. Les ensembles de pages candidats compilés à froid le sont toujours indépendamment, mais ils n’ont pas besoin de reconstruire l’analyseur du framework à chaque fois.

Utilisez ces filtres pour modifier la rétention :

PHP
add_filter('blockstudio/tailwind/cache_max_files', function () {
    return 1500;
});

add_filter('blockstudio/tailwind/cache_max_age', function () {
    return 14 * DAY_IN_SECONDS;
});

L’âge minimum est d’une heure.

Les fichiers du cache sont nommés d’après leur contenu, et une page en cache en référence un par URL ; l’éviction et une page stockée peuvent donc diverger quant aux fichiers encore nécessaires. Les documents prérendus sont vérifiés par rapport à leur feuille de style liée avant d’être servis ; un fichier évincé entraîne donc un nouveau rendu plutôt qu’une page sans style. Augmentez cache_max_files au-delà du nombre de clés distinctes de niveau page pour éviter complètement ce nouveau rendu.

Prérendu statique

Le cache HTML anonyme situé sous la même racine.