Comment configurer un serveur NFS qui met en cache un partage réseau?

Les données utilisateur sont stockées sur deux clusters de stockage OpenStack Swift assez grands (> 1 PB). Qu'ils soient du groupe A et le groupe B .

En outre, plusieurs PoP doivent interagir avec ces données. Les serveurs de ces PoP sont effectivement sans disque, ce qui signifie qu'aucune donnée utilisateur n'est stockée sur eux ou jamais téléchargée sur eux. Les PoP peuvent être regroupés en régions mondiales générales (par exemple , Amérique du Nord , Afrique du Sud , Europe centrale et al.).

Certains PoP sont assez éloignés des points d'extrémité Swift de l'un des clusters, ce qui introduit une latence indésirable. Afin d'atténuer quelque peu cela, je veux configurer un serveur de passerelle de mise en cache dans chacune des régions, qui mettra en cache les demandes r / w vers le cluster le plus proche.

Actuellement, les clients de l'un des PoP accèdent aux données utilisateur par un système de fichiers virtuel swift monté en permanence , qui est un module FUSE qui monte Swift Object Storage en tant que périphérique de bloc (plus ou moins). Cependant, svfs n'est pas du tout stable au départ et à l'avenir, les clients devraient accéder aux serveurs de cache via NFS.

Il s'agit d'un schéma d'une branche de l'architecture souhaitée:

+------------------+                +------------------+    NFS   +------------------+
|    Cluster A     |     SVFS       |  Region 1 Cache  +---------->  R1 PoP a Client |
|                  +---------------->                  |          |                  |
|Persistent Storage|                |Ephemeral  Storage+----+     |Generates R/W Load|
+-----------------++                +------------------+    |     +------------------+
                  |                                         |
                  |                 +------------------+    | NFS +------------------+
                  |      SVFS       |  Region 2 Cache  |    +----->  R1 PoP b Client |
                  +----------------->                  |          |                  |
                                    |Ephemeral  Storage|          |Generates R/W Load|
                                    +------------------+          +------------------+

Je connais les bases de la configuration de NFS et svfs.

La question est : comment puis-je configurer le serveur de mise en cache pour utiliser toutes les ressources disponibles (une partition de cache désignée, RAM) pour mettre en cache de manière aussi agressive et autant de données que possible avant d'écrire sur le point de montage svfs? Fondamentalement, cela se résume à: Comment puis-je mettre en cache un répertoire sous Linux?

Si possible, les lectures et les écritures doivent être consolidées et la taille des blocs dans les demandes FUSE doit être d'au moins 128 Ko si possible pour maximiser le débit et minimiser la latence si le cache doit écrire dans le cluster.

Addendum 1 : J'ai changé le module de montage de cluster de svfs en S3QL sur quelques serveurs. La mise en cache de S3QL a un peu amélioré les performances. Je vais essayer d'obtenir des données de performance pour être complet.

Si les mécanismes linux inhérents (comme cachefsaka cachefilesd) ne fonctionnent pas ET que vous avez un budget, vous pouvez regarder dans WAFS (services de fichiers étendus). Ce sont des appareils conçus pour la mise en cache agressive de NFS (et CIFS), pour essayer de cacher les latences généralement impliquées dans les liaisons WAN.

Je ne suis vraiment pas un expert dans ce domaine (mais c'est sûr que c'est intéressant!).

Ce que j'ai cherché récemment, c'est principalement dm-cache pour LVM, avec des SSD pour la partie mise en cache. Voici un exemple de texte de readhat qui a une bonne vue d'ensemble, mais qui n'est pas lié à RH: https://www.redhat.com/en/blog/improving-read-performance-dm-cache