Anleitungen im Zusammenhang mit Beach

Wie man Redis zum Caching für Neos und Flow verwendet

Die Verwendung von Redis in Beach Projekten ist einfach und wird die Ladezeiten beschleunigen und die Nutzererfahrung deiner Neos Nutzer verbessern.

Übersicht

Dieser Leitfaden führt dich durch die Schritte, mit denen du deine Neos Website oder Flow-Anwendung so konfigurierst, dass sie Redis als Cache-Backend nutzen kann.

Du brauchst einen Projektplan, der Redis unterstützt. Wenn du dir nicht sicher bist, kannst du dich über SSH in eine der Instanzen deines Projekts einloggen und die Redis-Verbindungsinformationen wie folgt anzeigen

env | grep REDIS

Wenn Redis verfügbar ist, sollte die Ausgabe etwa so aussehen:

BEACH_REDIS_PASSWORD=... sehr langes Passwort ...BEACH_REDIS_HOST=redis-123abc45-6789-1234-abcd-22913d67eef0

Hinter den Kulissen

Flow Framework - und damit natürlich auch Neos - bietet ein Caching-Framework, das es ermöglicht, verschiedene Cache-Backends zum Speichern von Daten einzubinden. Standardmäßig werden dateisystembasierte Cache-Backends verwendet, was Flow und Neos mit praktisch jeder Hosting-Umgebung kompatibel macht.

Es gibt jedoch eine Reihe von Gründen, die für ein Redis-Backend sprechen:

Redis speichert Daten im Speicher und kann daher noch schneller Ergebnisse liefern
sobald du deine Anwendung skalierst, werden mehrere Instanzen auf einen gemeinsamen Cache-Speicher zugreifen wollen
Redis speichert seine Daten unabhängig vom ephemeren Speicher deiner Instanz. Benutzersitzungen und andere sitzungsbasierte Daten würden nach jedem Einsatz verloren gehen, wenn sie im Dateisystem des Containers gespeichert werden. Durch den Einsatz von Redis können die Benutzersitzungen den Einsatz "überleben" und die Redakteure von Neos können weiterarbeiten

Neos und Flow verwenden verschiedene Caches für unterschiedliche Zwecke, z. B. zum Speichern von Sitzungen, kompiliertem Code und anderen temporären Daten. Nicht alle Caches sind sinnvoll oder können in Redis gespeichert werden.

Aktivieren von Redis für Neos

Die Konfiguration von Neos für die Nutzung von Redis ist sehr einfach: Du musst nur die notwendigen Informationen in einer Datei namens Caches.yaml bereitstellen und sie als Teil deiner Neos Distribution verteilen. Anstatt den Hostnamen und das Passwort fest zu kodieren, solltest du die Umgebungsvariablen verwenden, die von Beach bereitgestellt werden.

Erstelle in deinem Neos Projekt eine neue Datei Caches.yaml im globalen Konfigurationsverzeichnis deines Projekts. Wir empfehlen, die Konfiguration in Configuration/Production/Caches.yaml abzulegen.

Kopiere dann die folgende YAML-Konfiguration und füge sie in deine neue Datei ein:

Flow_Mvc_Routing_Route:
  backend: 'Neos\Cache\Backend\RedisBackend'
  backendOptions:
    hostname: '%env:BEACH_REDIS_HOST%'
    password: '%env:BEACH_REDIS_PASSWORD%'
    port: 6379
    # starting with database 2 here, since 0 and 1 are used and flushed by
    # the core unit tests and should not be used if possible.
    database: 2
    defaultLifetime: 0

Flow_Mvc_Routing_Resolve:
  backend: 'Neos\Cache\Backend\RedisBackend'
  backendOptions:
    hostname: '%env:BEACH_REDIS_HOST%'
    password: '%env:BEACH_REDIS_PASSWORD%'
    port: 6379
    database: 3
    defaultLifetime: 0

Neos_Fusion_Content:
  backend: 'Neos\Cache\Backend\RedisBackend'
  backendOptions:
    hostname: '%env:BEACH_REDIS_HOST%'
    password: '%env:BEACH_REDIS_PASSWORD%'
    port: 6379
    database: 4
    defaultLifetime: 0

Flow_Session_MetaData:
  backend: 'Neos\Cache\Backend\RedisBackend'
  backendOptions:
    hostname: '%env:BEACH_REDIS_HOST%'
    password: '%env:BEACH_REDIS_PASSWORD%'
    port: 6379
    database: 5
    defaultLifetime: 0

Flow_Session_Storage:
  backend: 'Neos\Cache\Backend\RedisBackend'
  backendOptions:
    hostname: '%env:BEACH_REDIS_HOST%'
    password: '%env:BEACH_REDIS_PASSWORD%'
    port: 6379
    database: 6
    defaultLifetime: 0

Neos_Neos_LoginTokenCache:
  backend: 'Neos\Cache\Backend\RedisBackend'
  backendOptions:
    hostname: '%env:BEACH_REDIS_HOST%'
    password: '%env:BEACH_REDIS_PASSWORD%'
    port: 6379
    database: 7

Neos_Media_ImageSize:
  backend: 'Neos\Cache\Backend\RedisBackend'
  backendOptions:
    hostname: '%env:BEACH_REDIS_HOST%'
    password: '%env:BEACH_REDIS_PASSWORD%'
    port: 6379
    database: 8
    defaultLifetime: 0

Übertrage die Änderungen in dein Git-Repository und stelle die Änderungen auf deiner Beach Instanz bereit. Wenn die Instanz bereitgestellt wurde, kannst du überprüfen, ob die Cache-Konfiguration wirklich aktiv ist, indem du dich über SSH bei deiner Instanz anmeldest und die Flow-Konfiguration anzeigst:

./flow configuration:show --type Caches | grep -A 5 Flow_Mvc_Routing Flow_Mvc_Routing_Route: backend: Neos\Cache\Backend\RedisBackend backendOptions: hostname: redis-123abc45-6789-1234-abcd-22913d67eef0 password: ... very long password ... port: 6379 -- Flow_Mvc_Routing_Resolve: frontend: Neos\Cache\Frontend\StringFrontend Backend: Neos\Cache\Backend\RedisBackend backendOptions: hostname: redis-123abc45-6789-1234-abcd-22913d67eef0 password: ... very long password ..

Herzlichen Glückwunsch! Du verwendest jetzt Redis für die wichtigsten Neos Caches.

Aktivieren von Redis für Flow-Anwendungen und Neos Plugins

Je nachdem, welche Pakete und Caches deine Flow-Anwendung oder die Neos Plugins verwenden, möchtest du vielleicht weitere Caches so konfigurieren, dass sie Redis als Backend nutzen. Du kannst diese einfach zu deiner Caches.yaml hinzufügen - achte aber darauf, dass du einen "Datenbank"-Wert verwendest, der von keinem anderen Cache in deiner Instanz genutzt wird.

Caveats

Es gibt einige Dinge, die du beachten musst, wenn du Redis als Cache-Backend für Neos und Flow verwendest:

Caches müssen von Flow geleert werden

Wenn du alle Caches leeren möchtest, solltest du nicht in die Falle tappen und einfach alle Dateien in Data/Tempory löschen. Verwende stattdessen den Flow-Befehl, der nicht nur Dateien löscht, sondern auch die Cache-Einträge aller anderen Cache-Backends leert:

./flow flow:cache:flush

Beachte, dass durch das Flushen der Caches der Redis-Cache nicht geleert wird, denn Flow löscht im Grunde nur das Verzeichnis Date/Temporary/*:

# So wird der Redis-Cache nicht geleert: ./flow flow:cache:flush --force

Übrigens, hast du stattdessen das hier versucht?

./flow sys 64738

Redis ist nur mittel-persistent

Auch wenn deine Redis-Cache-Einträge länger leben als die Dateien in deinen Containern, werden sie nicht ewig leben. Wenn wir zum Beispiel ein Cluster-Upgrade durchführen oder Cluster-Knoten auf neuere Maschinen verschieben, muss der Cluster-Scheduler die Container neu starten, auch deinen Redis-Server. Alle Cache-Einträge sind nach einem Neustart weg, aber wenn du ihn wirklich als Cache und nicht als dauerhaften Speicher verwendest, wird deine Anwendung alle benötigten Cache-Einträge problemlos neu erstellen.

Redis-Inhalt und -Status debuggen

Es ist ziemlich einfach, den Redis-Server selbst zu untersuchen. Es gibt zwei Möglichkeiten: eine einfache und eine erweiterte.

Die einfache Methode verwendet netcat, nachdem du dich per SSH bei deiner Instanz angemeldet hast.

$ ssh -J beach@ssh.flownative.cloud beach@instance-….beach

beach@instance-…-qg7jb:/application$ echo $BEACH_REDIS_PASSWORD
oArc…long…password…7Hc7

beach@instance-…-qg7jb:/application$ nc $BEACH_REDIS_HOST 6379
AUTH oArc…long…password…7Hc7
+OK
INFO
$3728
# Server
redis_version:6.0.16
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:6d95e1af3a2c082a
redis_mode:standalone

…

# Keyspace
db0:keys=1828,expires=0,avg_ttl=0

QUIT
+OK
^C
beach@instance-…-qg7jb:/application$

Zuerst meldest du dich bei deiner Instanz an (Zeile 1)
Dann holst du dir das Passwort für dein Redis und kopierst es (Zeile 3)
Jetzt verwendest du nc, um dich mit Redis zu verbinden (Zeile 6) - du wirst keine Ausgabe erhalten, gib einfach deine Befehle ein...
Der nächste Schritt ist die Authentifizierung mit AUTH und dem kopierten Passwort (Zeile 7)
Von nun an kannst du alle Redis-Befehle verwenden, z.B. INFO (Zeile 9)
Wenn du fertig bist, beende QUIT und dann nc mit Ctrl-C (Zeile 23)

Der fortgeschrittenere Weg ist, einen SSH-Tunnel zu deinem Redis über deine Beach Instanz zu erstellen. Dann kannst du jeden Redis-Client verwenden, indem du dich mit deinem lokalen Tunnelendpunkt verbindest. Das ist ähnlich wie der Zugriff auf eine Beach Instanzdatenbank:

$ ssh -nNT -L 6379:redis-da125679-1234-4cdb-8800-a335023289b5:3306 beach@instance-…

Um die benötigten Daten zu erhalten, kopierst du den Redis-Hostnamen von deiner Instanz-Detailseite und holst dir das Passwort wie oben beschrieben. Dann kannst du auf deinem Rechner wie folgt auf Redis zugreifen, nachdem du den Tunnel eingerichtet hast:

$ redis-cli
127.0.0.1:6379>

Der nächste Schritt ist die Authentifizierung mit AUTH und dem kopierten Passwort. Von nun an kannst du jeden Redis-Befehl verwenden. Du kannst natürlich auch jeden anderen Client verwenden.