Wie implementiere ich Redis-Keyspace-Benachrichtigungen in ElastiCache?

Kurzbeschreibung

Redis-Keyspace-Benachrichtigungen ermöglichen es dir, PubSub-Kanäle zu abonnieren. Über diese Kanäle werden veröffentlichte Ereignisse empfangen, wenn ein Redis-Befehl oder eine Datenänderung erfolgt. Diese Benachrichtigungen sind nützlich, wenn eine Anwendung auf Änderungen der in bestimmten Schlüsseln gespeicherten Werte reagieren muss. Du kannst außerdem Redis-Keyspace-Benachrichtigungen verwenden, um Änderungen an den Datensätzen zu verfolgen. Das Feature für Keyspace-Benachrichtigungen ist in den Versionen 2.8.6 und höher verfügbar. Wenn eine Redis-Keyspace-Benachrichtigung aufgerufen wird, erfolgt eine Keyspace-Benachrichtigung und eine Key-Space-Benachrichtigung. Der Keyspace-Kanal empfängt den Namen des Ereignisses, und der Key-Event-Kanal empfängt den Namen des Schlüssels als Nachricht.

Lösung

Hinweis: Die folgende Lösung gilt für ElastiCache-Cluster mit ausgeschaltetem Clustermodus. Weitere Informationen findest du unter Redis-Keyspace-Benachrichtigungen auf der Redis-Website.

Um Redis-Keyspace-Benachrichtigungen in ElastiCache zu implementieren, führe die folgenden Schritte aus:

Redis-Keyspace-Benachrichtigungen aktivieren

Hinweis: Standardmäßig deaktiviert ElastiCache Redis-Keyspace-Benachrichtigungen. Um Keyspace-Benachrichtigungen in einer benutzerdefinierten Cache-Parametergruppe zu aktivieren, verwende den Parameter notify-keyspace-events. Dieser Parameterwert verwendet mehrere Parameter, um zu bestimmen, welcher Kanal (Keyspace oder Key-Event) verwendet wird und welche Informationen an den Kanal gesendet werden sollen. Weitere Informationen findest du unter Redis 2.8.6 hinzugefügte Parameter.

1. Öffne die ElastiCache-Konsole.
2. Um eine Liste der verfügbaren Parametergruppen anzuzeigen, wähle im Navigationsbereich Parametergruppen aus.
3. Wähle die Parametergruppe aus, die du zurücksetzen möchtest.
   Hinweis: Du kannst eine Standard-Parametergruppe nicht ändern. Sind sämtliche aufgeführten Parametergruppen voreingestellt, erstelle eine neue Parametergruppe.
4. (Optional) Um eine neue Parametergruppe zu erstellen, wähle Parametergruppe erstellen aus:
   Gib in das Feld Name einen eindeutigen Namen ein.
   Gib in das Feld Beschreibung eine Beschreibung ein.
   Wähle eine Familie aus.
   Wähle Erstellen aus.
5. Wähle Parameterwerte bearbeiten aus.
6. Navigiere zu notify-keyspace-events und gib dann AKE in das Feld Wert ein. Weitere Informationen über zulässige Werte findest du unter Redis 2.8.6 hinzugefügte Parameter.
7. Wähle Änderungen speichern aus. Die Änderungen werden sofort wirksam und der Cluster muss nicht neu gestartet werden.
   Hinweis: Vergewissere dich, dass du deinem Redis-Cluster die neue geänderte Parametergruppe zuweist.

Ereignisse generieren

Um Ereignisse zu erzeugen, verwende entweder die Redis-Befehlszeilenschnittstelle (Command Line Interface, CLI) oder den Redis-Python-Client:

Die Redis-CLI (redis-cli) verwenden

1. Um Benachrichtigungen zu abonnieren, verwende redis-cli, um den folgenden Befehl auszuführen:

   #./redis-cli -h testdisabled.xxxxx.ng.0001.use1.cache.amazonaws.com -p 6379 --csv psubscribe '__key*__:*'

2. Um Keyspace-Ereignisse zu erstellen, führe einen beliebigen Befehlssatz aus. Die folgenden Beispielbefehle setzen den Wert und die Ablaufzeit auf 3 Sekunden für den Key-Redis und den Subscriber für abgelaufene Ereignisse.

   #./redis-cli -h testdisabled.xxxxx.ng.0001.use1.cache.amazonaws.com -p 6379
   testdisabled.xm4oz6.ng.0001.use1.cache.amazonaws.com:6379>
   testdisabled.xm4oz6.ng.0001.use1.cache.amazonaws.com:6379> SET key1 value1 ex 5
   testdisabled.xm4oz6.ng.0001.use1.cache.amazonaws.com:6379>

3. Bestätige, dass die Ereignisse generiert werden. Im Folgenden findest du ein Beispiel für die Ausgabe der generierten Ereignisse:

   #./redis-cli -h testdisabled.xxxxx.ng.0001.use1.cache.amazonaws.com -p 6379 --csv psubscribe '__key*__:*'
   Reading messages... (press Ctrl-C to quit)
   "psubscribe","__key*__:*",1
   "pmessage","__key*__:*","__keyspace@0__:key1","set"
   "pmessage","__key*__:*","__keyevent@0__:set","key1"
   "pmessage","__key*__:*","__keyspace@0__:key1","expire"
   "pmessage","__key*__:*","__keyevent@0__:expire","key1"
   "pmessage","__key*__:*","__keyspace@0__:key1","expired"
   "pmessage","__key*__:*","__keyevent@0__:expired","key1"

   In der vorangehenden Beispielausgabe zeigt das erste Ereignis an, dass du Kanal 1 erfolgreich abonniert hast. Das zweite Ereignis ist eine Keyspace-Benachrichtigung, die den als Nachricht festgelegten Ereignisnamen angibt. Das dritte Ereignis ist eine Key-Event-Benachrichtigung, die den Schlüsselnamen key1 als Nachricht angibt. Nach dem dritten Ereignis kannst du die Ablaufmeldungen für den Keyspace und die Key-Event-Benachrichtigungen sehen.

Verwende den Redis-Python-Client (redis-py)

1. Verwende zum Abonnieren von Benachrichtigungen ein Python 2- oder Python 3-Skript.
   Hinweis: Die folgenden Skripte abonnieren alle Keyspace-Benachrichtigungen und drucken empfangene Ereignisse.
   Python 2:

   # cat subscribe.py
   import redis
   import datetime
   import time
   r = redis.Redis(host='testdisabled.xxxxx.ng.0001.use1.cache.amazonaws.com', port=6379, db=0)
   #Subscribing for events matching pattern "__key*__:*"
   p = r.pubsub()
   p.psubscribe('__key*__:*')
   print('Starting message loop')
   while True:
       message = p.get_message()
       if message:
           print datetime.datetime.now(), message
       else:
           time.sleep(0.01)

   Python 3:

   import redis
   from datetime import datetime
   import time
   r = redis.Redis(host = 'testdisabled.xxxxx.ng.0001.use1.cache.amazonaws.com', port = 6379, db = 0)
   #Subscribing for events matching pattern "__key*__:*
   p = r.pubsub()
   p.psubscribe('__key*__:*')
   print('Starting message loop')
   while True:
       message = p.get_message()
       if message:
           print (datetime.now(), message)
       else:
           time.sleep(0.01)

   Hinweis: Zu einer Überlastung des Servers kann es kommen, wenn niedrige Werte oder das Fehlen eines Ruhezustands den Client dazu veranlassen, den Kanal ständig abzufragen. Höhere Werte führen zu einem erhöhten Speicherbedarf auf dem Server. Die vorangegangenen Skripte setzen die time.sleep auf 0,01.

2. Verbinde dich in einer separaten Sitzung mit dem Cluster und führe dann das Skript createkey.py aus, um Schlüssel zu setzen oder ablaufen zu lassen:
   Hinweis: Vergewissere dich, dass du example-key als Schlüssel und example-value als Wert einstellst. Verwende außerdem einen Wert von 3 Sekunden für die Ablaufzeit.

   # cat createkey.py
   import redis
   r = redis.Redis(host='testdisabled.xxxxx.ng.0001.use1.cache.amazonaws.com', port=6379, db=0)
   r.set('example-key','example-value')
   r.expire('example-key',3)

3. Führe das Skript subscribe.py in einer separaten Sitzung aus.
   Beispielausgabe:

   # python2 subscribe.py
   Starting message loop
   2024-04-29 23:40:56.356659 {u'pattern': None, u'type': 'psubscribe', u'channel': '__key*__:*', u'data': 1L}
   2024-04-29 23:40:56.356659 {u'pattern': None, u'type': 'psubscribe', u'channel': '__key*__:*', u'data': 1L}
   2024-04-29 23:41:00.016410 {u'pattern': '__key*__:*', u'type': 'pmessage', u'channel': '__keyspace@0__:example-key', u'data': 'set'}
   2024-04-29 23:41:00.016512 {u'pattern': '__key*__:*', u'type': 'pmessage', u'channel': '__keyevent@0__:set', u'data': 'example-key'}
   2024-04-29 23:41:00.016582 {u'pattern': '__key*__:*', u'type': 'pmessage', u'channel': '__keyspace@0__:example-key', u'data': 'expire'}
   2024-04-29 23:41:00.016650 {u'pattern': '__key*__:*', u'type': 'pmessage', u'channel': '__keyevent@0__:expire', u'data': 'example-key'}
   2024-04-29 23:41:03.111509 {u'pattern': '__key*__:*', u'type': 'pmessage', u'channel': '__keyspace@0__:example-key', u'data': 'expired'}
   2024-04-29 23:41:03.111601 {u'pattern': '__key*__:*', u'type': 'pmessage', u'channel': '__keyevent@0__:expired', u'data': 'example-key'}

   Hinweis: Nachdem du den vorangegangenen Befehl ausgeführt hast, ist dein Redis-Key-Listener fertig.