Einrichten eines NFS-Servers, der eine Netzwerkfreigabe zwischenspeichert

Benutzerdaten werden in zwei relativ großen OpenStack Swift-Speicherclustern (> 1 PB) gespeichert. Lassen Sie sie Cluster A und Cluster B sein .

Darüber hinaus gibt es mehrere PoPs , die mit diesen Daten interagieren müssen. Server in diesen PoPs sind praktisch plattenlos, dh, keine Benutzerdaten werden auf ihnen gespeichert oder jemals auf sie heruntergeladen. PoPs können in allgemeine Weltregionen eingeteilt werden (z. B. Nordamerika , Südafrika , Mitteleuropa et al.).

Einige PoPs sind ziemlich weit von Swift-Endpunkten eines der Cluster entfernt, was zu einer unerwünschten Latenz führt. Um dies etwas abzumildern, möchte ich in jeder der Regionen einen Caching-Gateway-Server einrichten, der Schreib- / Leseanforderungen an den nächsten Cluster zwischenspeichert.

Derzeit greifen Clients in einem der PoPs über ein permanent eingehängtes virtuelles Swift-Dateisystem auf Benutzerdaten zu. Hierbei handelt es sich um ein FUSE-Modul, das den Swift-Objektspeicher (mehr oder weniger) als Blockgerät einhängt. Svfs ist jedoch in erster Linie nicht so stabil, und in Zukunft sollten Clients über NFS auf die Cache-Server zugreifen.

Dies ist ein Diagramm eines Zweigs der gewünschten Architektur:

+------------------+                +------------------+    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|
                                    +------------------+          +------------------+

Ich bin mit den Grundlagen der Einrichtung von NFS und SVFS vertraut.

Die Frage ist : Wie kann ich den Cache-Server so einrichten, dass alle verfügbaren Ressourcen (eine bestimmte Cache-Partition, RAM) verwendet werden, um so aggressiv und so viele Daten wie möglich zu cachen, bevor auf den SVFS-Mount-Punkt geschrieben wird? Grundsätzlich gilt: Wie kann ich ein Verzeichnis unter Linux zwischenspeichern?

Wenn möglich, sollten Lese- und Schreibvorgänge konsolidiert werden und die Blockgrößen in FUSE-Anforderungen sollten mindestens 128 KB betragen, um den Durchsatz zu maximieren und die Latenz zu minimieren, wenn der Cache in den Cluster schreiben muss.

Anhang 1 : Auf einigen Servern habe ich das Cluster-Mount-Modul von svfs auf S3QL umgestellt. Das Caching von S3QL hat die Leistung etwas verbessert. Ich werde versuchen, einige Leistungsdaten der Vollständigkeit halber zu erhalten.

Wenn die inhärenten Linux-Mechanismen (wie cachefsaka cachefilesd) nicht funktionieren UND Sie über ein Budget verfügen, sollten Sie sich mit WAFS (Wide Area File Services) befassen . Hierbei handelt es sich um Geräte, die für das aggressive Caching von NFS (und CIFS) entwickelt wurden, um die Latenzen auszublenden, die normalerweise bei WAN-Verbindungen auftreten.

Ich bin wirklich kein Experte auf diesem Gebiet (aber es ist sicher interessant!).

Was ich in letzter Zeit gesucht habe, ist hauptsächlich dm-cache für LVM, mit SSDs für den Caching-Teil. Hier ist ein Beispieltext von readhat, der einen guten Überblick bietet, aber nicht an RH gebunden ist: https://www.redhat.com/de/blog/improving-read-performance-dm-cache