Como implemento as notificações de keyspace do Redis no ElastiCache?

Breve descrição

As notificações de keyspace do Redis permitem que você se inscreva nos canais do PubSub. Por meio desses canais, os eventos publicados são recebidos quando ocorre um comando do Redis ou uma alteração de dados. Essas notificações são úteis quando uma aplicação precisa responder às alterações que ocorrem no valor armazenado em chaves específicas. Além disso, é possível usar as notificações de keyspace do Redis para acompanhar as alterações no conjunto de dados. O atributo de notificações de keyspace está disponível nas versões 2.8.6 e posteriores. Quando uma notificação de keyspace do Redis é invocada, ocorre uma notificação de keyspace e uma notificação de evento-chave. O canal keyspace recebe o nome do evento e o canal do evento-chave recebe o nome da chave como uma mensagem.

Resolução

Observação: A resolução a seguir se aplica aos clusters do ElastiCache com o modo de cluster desativado. Para mais informações, consulte Notificações de keyspace do Redis no site do Redis.

Para implementar as notificações de keyspace do Redis no ElastiCache, conclua as seguintes etapas:

Ativar notificações de keyspace do Redis

Observação: Por padrão, o ElastiCache desativa as notificações de keyspace do Redis. Para ativar as notificações de keyspace em um grupo de parâmetros de cache personalizado, use o parâmetro notify-keyspace-events. Esse valor de parâmetro usa vários parâmetros para determinar qual canal (keyspace ou key-event) é usado e as informações a serem publicadas no canal. Para mais informações, consulte os parâmetros adicionados do Redis 2.8.6.

1. Abra o console do ElastiCache.
2. Para ver uma lista dos grupos de parâmetros disponíveis, selecione Grupos de parâmetros no painel de navegação.
3. Selecione o grupo de parâmetros que você deseja modificar.
   Observação: Não é possível modificar um grupo de parâmetros padrão. Se todos os grupos de parâmetros listados forem padrão, crie um novo grupo de parâmetros.
4. (Opcional) Para criar um novo grupo de parâmetros, escolha Criar grupo de parâmetros:
   No campo Nome, insira um nome exclusivo.
   Insira uma descrição no campo Descrição.
   Selecione uma Família.
   Selecione Criar.
5. Escolha Editar valores de parâmetros.
6. Navegue até notify-keyspace-events e, em seguida, insira AKE no campo Valor. Para mais informações sobre os valores permitidos, consulte os parâmetros adicionados do Redis 2.8.6.
7. Escolha Salvar alterações. As alterações entram em vigor imediatamente e o cluster não precisa ser reiniciado.
   Observação: Certifique-se de atribuir o novo grupo de parâmetros modificado ao seu cluster do Redis.

Gerar eventos

Para gerar eventos, use a interface de linha de comandos (CLI) do Redis ou o cliente Redis Python:

Usar a CLI do Redis (redis-cli)

1. Para assinar notificações, use redis-cli para executar o seguinte comando:

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

2. Para criar eventos de keyspace, execute qualquer conjunto de comandos. Os comandos de exemplo a seguir definem o valor e o tempo de expiração em 3 segundos para a chave do Redis e o assinante para eventos expirados.

   #./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. Confirme se os eventos são gerados. Veja a seguir um exemplo de saída dos eventos gerados:

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

   Para a saída do exemplo anterior, o primeiro evento indica que você se inscreveu com sucesso em 1 canal. O segundo evento é uma notificação de keyspace que indica o nome do evento definido como a mensagem. O terceiro evento é uma notificação de evento-chave que indica o nome da chave key1 como mensagem. Após o terceiro evento, é possível ver as mensagens de expiração das notificações de keyspace e de evento-chave.

Usar o cliente Redis Python (redis-py)

1. Para assinar notificações, use um script Python 2 ou Python 3.
   Observação: Os scripts a seguir assinam todas as notificações de keyspace e imprimem os eventos recebidos.
   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)

   Observação: Pode haver sobrecarga do servidor quando valores mais baixos ou a ausência de hibernação fazem com que o cliente pesquise constantemente o canal. Valores mais altos causam maior uso de memória no servidor. Os scripts anteriores definiram o time.sleep como 0,01.

2. Em uma sessão separada, conecte-se ao cluster e execute o script createkey.py para definir ou expirar as chaves:
   Observação: Certifique-se de definir a example-key como chave e o example-value como valor. Além disso, use um valor de 3 segundos como tempo de expiração.

   # 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. Em uma sessão separada, execute o script subscribe.py.
   Exemplo de saída:

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

   Observação: Depois de concluir o comando anterior, seu receptor de chaves do Redis estará pronto.