Come posso implementare le notifiche keyspace Redis in ElastiCache?

Breve descrizione

Le notifiche keyspace Redis ti consentono di abbonarti ai canali PubSub. Attraverso questi canali si ricevono gli eventi pubblicati in caso di modifica dei dati o di un comando Redis. Tali notifiche sono utili quando un'applicazione deve rispondere alle modifiche del valore memorizzato in chiavi specifiche. Inoltre, puoi utilizzare le notifiche keyspace Redis per seguire le modifiche apportate ai set di dati. La funzione di notifica keyspace è disponibile nelle versioni 2.8.6 e successive. Quando viene invocata una notifica keyspace Redis, si verificano una notifica keyspace e una notifica key-event. Il canale keyspace riceve il nome dell'evento e il canale key-event riceve il nome della chiave come messaggio.

Risoluzione

Nota: la seguente risoluzione si applica ai cluster ElastiCache con la modalità cluster disattivata. Per ulteriori informazioni, consulta Redis keyspace notifications (Notifiche keyspace Redis) sul sito web di Redis.

Per implementare le notifiche keyspace Redis in ElastiCache, completa i seguenti passaggi:

Attiva le notifiche keyspace Redis

Nota: per impostazione predefinita, ElastiCache disattiva le notifiche keyspace Redis. Per attivare le notifiche keyspace in un gruppo di parametri cache personalizzato, utilizza il parametro notify-keyspace-events. Questo valore parametrico utilizza più parametri per determinare quale canale (keyspace ** o ** key-event) viene utilizzato e le informazioni da pubblicare sul canale. Per ulteriori informazioni, consulta Redis 2.8.6 added parameters (Parametri aggiunti in Redis 2.8.6).

1. Apri la console ElastiCache.
2. Per visualizzare un elenco dei gruppi di parametri disponibili, scegli Gruppi di parametri nel pannello di navigazione.
3. Seleziona il gruppo di parametri che desideri modificare.
   Nota: non puoi modificare un gruppo di parametri predefinito. Se tutti i gruppi di parametri elencati sono predefiniti, crea un nuovo gruppo di parametri.
4. (Facoltativo) Per creare un nuovo gruppo di parametri, scegli Crea gruppo di parametri:
   Inserisci un nome univoco nel campo Nome.
   Inserisci una descrizione nel campo Descrizione.
   Seleziona una Famiglia.
   Scegli Crea.
5. Scegli Modifica i valori dei parametri.
6. Vai a notify-keyspace-events, quindi inserisci AKE nel campo Valore. Per ulteriori informazioni sui valori consentiti, consulta Redis 2.8.6 added parameters (Parametri aggiunti in Redis 2.8.6).
7. Scegli Salva le modifiche. Le modifiche hanno effetto immediato e non è necessario riavviare il cluster.
   Nota: assicurati di assegnare il nuovo gruppo di parametri modificato al cluster Redis.

Genera eventi

Per generare eventi, utilizza l'Interfaccia a riga di comando Redis (Redis CLI) o il client Redis Python:

Utilizza Redis CLI Redis (redis-cli)

1. Per abbonarti alle notifiche, utilizza redis-cli per eseguire il seguente comando:

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

2. Per creare eventi keyspace, esegui qualsiasi set di comandi. I seguenti esempi di comando impostano il valore e il tempo di scadenza su 3 secondi per chiave Redis e abbonato per gli eventi scaduti.

   #./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. Verifica che gli eventi vengano generati. Di seguito è riportato un esempio di output degli eventi generati:

   #./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"

   Nell'esempio di output precedente, il primo evento indica ti sei abbonato correttamente al canale 1. Il secondo evento è una notifica keyspace che indica come messaggio il nome dell'evento set. Il terzo evento è una notifica key-event che indica come messaggio il nome della chiave key1. Dopo il terzo evento sono presenti i messaggi di scadenza per le notifiche keyspace e key-event.

Utilizza il client Redis Python (redis-py)

1. Per abbonarti alle notifiche, utilizza uno script Python 2 o Python 3.
   Nota: i seguenti script abbonano a tutte le notifiche keyspace e stampano gli eventi ricevuti.
   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)

   Nota: può verificarsi un sovraccarico del server se si impostano valori inferiori o se non si prevede un tempo di sospensione poiché il client esegue costantemente il polling del canale. Valori superiori causano invece un maggiore utilizzo della memoria del server. Gli script precedenti impostano un tempo di sospensione **time.sleep ** pari a 0,01.

2. In una sessione separata, esegui la connessione al cluster, quindi esegui lo script createkey.py per impostare o far scadere le chiavi:
   Nota: assicurati di impostare come chiave example-key e come valoreexample-value. Inoltre, utilizza un valore di 3 secondi per il tempo di scadenza.

   # 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. In una sessione separata, esegui lo script subscribe.py.
   Esempio di output:

   # 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'}

   Nota: sopo aver completato il comando precedente, il key listener Redis è pronto.