Redis estruturas de dados avançadas: Hashes, Sorted Sets e HyperLogLog

Configurando a base inicial do curso - Apresentação

Introdução ao Curso

Olá! Meu nome é Vitorino Vila e é uma grande alegria ter você aqui para mais uma etapa da nossa jornada. Este é o terceiro curso da formação RedsDB e estamos muito felizes em seguir juntos nesta evolução.

Objetivos do Curso

Neste curso, vamos continuar desenvolvendo nosso sistema de gerenciamento de tarefas, que trabalha com dois modelos: tarefas agendadas com hora marcada e tarefas relacionadas ao desenvolvimento de um projeto de software.

Revisão e Novas Estruturas de Dados

Vamos começar o curso com uma revisão rápida dos principais conceitos que vimos até agora na formação, especialmente sobre o uso de listas e conjuntos dentro do Reds. Em seguida, vamos introduzir novas estruturas de dados poderosas.

Introdução aos Hashes e Sorted Sets

Primeiro, conheceremos os hashes (conjuntos de dados), que nos permitirão armazenar os detalhes de cada tarefa de forma estruturada, substituindo os blocos de textos em JSON. Depois, veremos os conjuntos ordenados, os famosos Sorted Sets (conjuntos ordenados), que serão fundamentais para organizarmos tarefas de forma automática, por horário ou, por exemplo, por prioridade.

Apresentação do HyperLogLog

Olá! Vamos apresentar o HyperLogLog, uma estrutura extremamente leve para a contagem estimada de elementos únicos dentro do Redis. Essa estrutura é ideal para criarmos métricas e monitoramento sem consumir muita memória. Vamos entender como essas estruturas, quando usadas em conjunto, podem agregar valor real aos nossos modelos de gerenciamento de tarefas.

Exemplos Práticos e Importância do Redis

Além disso, ao final do curso, exploraremos exemplos práticos de relatórios automatizados, combinando comandos do Redis com recursos do Linux, para extrairmos valores valiosos diretamente do nosso terminal. É importante destacar que o Redis vem sendo cada vez mais utilizado por empresas como um banco complementar a sistemas transacionais e, às vezes, a sistemas gerenciais. Isso ocorre porque o Redis é extremamente rápido e foi criado com um propósito muito claro: adicionar performance e inteligência a sistemas já existentes.

Conclusão e Motivação

Por isso, dominar o Redis é uma habilidade poderosa no mercado de trabalho atual. O profissional que aprende a combinar o Redis com outros bancos e sistemas estará preparado para aproveitar diversas oportunidades profissionais. Estamos muito felizes por estar aqui com vocês. Vamos começar mais essa etapa no nosso curso? Muito obrigado, vamos em frente e até o próximo vídeo.

Observação sobre o Conteúdo do Vídeo

Neste segmento do vídeo, o instrutor discute o conteúdo do curso, incluindo as estruturas de dados que serão abordadas (Hashes, Sorted Sets, HyperLogLog), mas não apresenta ou escreve exemplos de código. Portanto, não há snippets de código para extrair deste segmento específico do vídeo.

Configurando a base inicial do curso - Recuperando os dados do curso anterior

Introdução ao Curso e Revisão do Sistema de Gerenciamento de Tarefas

Olá! Vamos iniciar mais um curso na Formação Redis TB. No curso anterior, observamos que nosso sistema de gerenciamento de tarefas se tornou mais complexo. Criamos dois sistemas distintos: um utilizando listas para controlar tarefas agendadas, com data e hora para execução, e outro utilizando conjuntos, onde as tarefas são realizadas por uma equipe de desenvolvimento de software que está trabalhando em um projeto de criação de um aplicativo.

As tarefas estão associadas a conjuntos que determinam o status e a prioridade. Em relação ao status, criamos três conjuntos específicos para armazenar o código e o identificador das tarefas: pendentes, em execução e concluídas. Quanto à prioridade, as tarefas são armazenadas em conjuntos de baixa, média e alta prioridade.

Nesse modelo, detalhamos as tarefas em uma chave-valor simples do tipo string, onde armazenamos o JSON com o detalhamento da tarefa. Assim como no curso anterior, vamos apagar todas as chaves de valor e criar novas, para que todos os modelos sejam iguais.

Preparação do Ambiente e Execução do Script

Para isso, é necessário baixar o script no link associado à atividade deste vídeo e copiá-lo para o diretório SR, dentro de Redis SCR, no Linux. Este diretório foi criado no curso anterior. Utilizando o explorador do Windows, acessaremos esse diretório no Linux, copiaremos o script e, em seguida, apagaremos todas as chaves de valor do banco e executaremos o script.

Vamos realizar todos esses passos agora. No meu computador, baixamos para um diretório local o script comandos iniciais 4444, que foi obtido a partir do link disponível nas atividades. Em seguida, abrimos o Linux e apagamos todas as chaves de valor armazenadas no Redis atualmente. Para isso, utilizamos o comando:

redis-cli --raw FLUSHDB

Esse comando limpa o banco de dados Redis, removendo todas as chaves existentes. Agora, o Redis está vazio.

Navegação e Verificação do Script no Diretório

Abrimos uma nova janela do explorador de arquivos do sistema operacional e digitamos \\wsl$. Navegamos pelos diretórios do Linux, acessando o diretório principal, o raiz, depois o home, o nosso usuário e, por fim, o redis-scr. Para navegar até o diretório correto, utilizamos o comando:

cd /home/victor/redisscr

Buscamos o script que acabamos de baixar e copiamos para dentro desse diretório. Para confirmar que o script foi copiado, basta executar o comando:

ls -l

Esse comando lista os arquivos no diretório atual, permitindo verificar que o script está lá.

Execução do Script no Redis

Agora, vamos rodar o comando cat, direcionando-o para o script no caminho completo, seguido de | redis-cli, para executar o script no Redis:

cat /home/victor/redisscr/Comandos_iniciais_4444.txt | redis-cli

Ao fazer isso, várias chaves são criadas dentro do banco. Podemos verificar as chaves criadas utilizando o comando:

redis-cli --raw KEYS '*'

Com todas as chaves criadas, podemos começar o nosso curso. Vamos encerrar o vídeo por aqui e, no próximo, relembrar o que aprendemos no curso anterior.

Configurando a base inicial do curso - Revisão do gerenciamento de tarefas com listas e conjuntos

Introdução às Estruturas Avançadas do Redis

Antes de explorarmos as estruturas avançadas do Redis, como Hashes, Sorted Sets e Hyperlog Log, que são temas deste curso, é fundamental revisarmos o que já foi implementado no nosso sistema de gerenciamento de tarefas. Até agora, utilizamos listas e conjuntos: listas para organizar tarefas agendadas e conjuntos para gerenciar tarefas de execução de um projeto. Essa abordagem permitiu estruturar melhor os dados dentro do Redis.

Revisão do Curso Anterior

É muito importante lembrar do que foi mostrado no curso anterior, pois os conceitos vistos lá serão essenciais para darmos continuidade ao aprendizado. Vamos relembrar: começamos pelo modelo de tarefas agendadas, que utilizava listas. Cada chave representa uma lista onde estão todas as tarefas que serão executadas em uma determinada data. Por isso, o formato do nome da chave era tarefa:ano:mês:dia.

tarefa:YYYY-MM-DD.

Cada elemento da lista é uma tarefa agendada, contendo detalhamento como hora, descrição, responsável, prioridade e observações.

-hora
-descrição
-responsável
-prioridade
-observações

Comandos para Gerenciamento de Tarefas

Por exemplo, vamos observar as tarefas agendadas para o dia 21 de março de 2025. Para isso, usamos o comando LRange. Lembrando que, ao utilizar LRange, é necessário especificar a parte da lista que se deseja ver. Quando utilizamos 0 -1, estamos visualizando todos os elementos da lista.

redis-cli --raw LRANGE tarefa:2025-03-21 0 -1

Vamos copiar esse comando, executá-lo no Redis, no prompt do Linux, e visualizar todas as tarefas agendadas para o dia 21 de março de 2025. Cada elemento da lista é um JSON que contém detalhes como hora, descrição, responsável, prioridade e observações. Essas tarefas foram inseridas previamente no script do vídeo anterior, usando o comando rpush. Ao usar rpush, basta declarar os comandos na ordem desejada para garantir que serão gravadas na ordem que representa a hora em que a tarefa será executada.

Desafios do Modelo Atual

O ponto fraco desse modelo é que precisamos ter cuidado ao incluir uma nova tarefa associada a um dia específico. Dependendo da hora de execução da tarefa, é necessário determinar, no momento da inserção, em que ponto da lista ela será colocada. Podemos usar lpush para inserir no início da lista, rpush para incluir no final, ou linsert com a cláusula before ou after, dependendo de quem queremos usar como referência.

Outro comando importante visto no curso anterior, relacionado a listas, foi o lrem, utilizado para remover tarefas já realizadas.

Uso de Conjuntos para Gerenciamento de Status e Prioridade

No outro modelo, utilizamos conjuntos e criamos dois grupos de conjuntos: um para expressar o status de execução e outro para o nível de prioridade. Armazenamos dentro dos conjuntos apenas o número da tarefa. Por exemplo, para listar as tarefas pendentes, nossa chave tinha o formato tarefas:dev:software:pendentes.

tarefa:DevSoftware:Pendentes

Ao executar o comando smembers, podemos visualizar todos os elementos existentes em um conjunto.

redis-cli --raw SMEMBERS tarefa:DevSoftware:Pendentes

Ao rodar o comando, observamos que as tarefas 4 e 5 estão pendentes. Para ver as tarefas que estão sendo executadas, substituímos o comando por executando.

redis-cli --raw SMEMBERS tarefa:DevSoftware:Executando

Assim, apenas a tarefa 3 está em execução no momento. Para visualizar as tarefas concluídas, utilizamos o comando concluídas.

redis-cli --raw SMEMBERS tarefa:DevSoftware:Concluidas

E constatamos que as tarefas 1 e 2 foram finalizadas.

Classificação por Prioridade

Além disso, é possível classificar as tarefas por prioridade, o que facilita a visualização do que é mais urgente. Vamos listar agora as tarefas de alta prioridade. O conjunto era tarefa dev software, e ao utilizar altas, identificamos que as tarefas 3 e 1 são de alta prioridade.

redis-cli --raw SMEMBERS tarefa:DevSoftware:Altas

Para visualizar as de média prioridade, utilizamos médias.

redis-cli --raw SMEMBERS tarefa:DevSoftware:Medias

E vemos que a tarefa 5 possui média prioridade. Ao utilizar baixas, constatamos que as tarefas 2 e 4 têm baixa prioridade.

redis-cli --raw SMEMBERS tarefa:DevSoftware:Baixas

Detalhamento das Tarefas

No modelo utilizado, dentro dos conjuntos, armazenamos apenas o número da tarefa. O detalhamento, ou seja, a informação complementar de cada tarefa, está salvo separadamente em uma chave-valor do tipo string. O formato dessa chave-valor é tarefa dev software seguido pelo ID da tarefa.

tarefa:DevSoftware:<ID>

Por exemplo, para ver o detalhamento da tarefa 003, utilizamos o comando get para buscar a string e visualizar o detalhamento da tarefa 003.

redis-cli --raw GET tarefa:DevSoftware:00003

Ao executar o comando, vemos que o detalhamento da tarefa, no nosso sistema de projetos, contém apenas descrição e responsável.

{"descricao": "Correção de bugs na tela de login", "responsavel": "Guilherme Augusto"}

Limitações do Modelo Atual e Próximos Passos

Esse modelo nos permite ter uma visão geral da tarefa e consultar seu conteúdo completo de forma separada. No entanto, como veremos nas próximas aulas, esse modelo apresenta algumas limitações, especialmente ao atualizar determinados campos. Por exemplo, para mudar a prioridade de uma tarefa, é necessário realizar um trabalho duplo: primeiro, transferir a tarefa do conjunto e, em seguida, alterar o valor na chave específica. Como o conteúdo é um JSON no formato string, é preciso reescrever a string completa, alterando apenas a propriedade desejada. Não é possível, com os comandos do Redis, atualizar uma propriedade específica.

No curso anterior, vimos que é possível, através de uma biblioteca de manipulação de JSONs e anexando funcionalidades do sistema operacional Linux aos comandos Redis, alterar somente uma propriedade. No entanto, isso exige um avanço além do que o Redis oferece. Para resolver essas questões, vamos evoluir nosso sistema e explorar novas estruturas que podem preencher essas lacunas.

Encerramento e Próximos Temas

Encerramos o vídeo por aqui. No próximo vídeo, começaremos a falar sobre hashes, uma estrutura que permite manipular dados de tarefas de forma muito mais flexível. Muito obrigado e até o próximo vídeo.

Sobre o curso Redis estruturas de dados avançadas: Hashes, Sorted Sets e HyperLogLog

O curso Redis estruturas de dados avançadas: Hashes, Sorted Sets e HyperLogLog possui 139 minutos de vídeos, em um total de 52 atividades. Gostou? Conheça nossos outros cursos de NoSQL em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Configurando a base inicial do curso
• Hashes
• Sorted Sets
• HyperLogLog
• Unindo uso das estruturas e expiração de tarefas