Introdução ao Redis

Redis (Remote Dictionary Server) é um armazenamento de estrutura de dados em memória de código aberto, frequentemente utilizado como um banco de dados, cache e intermediário de mensagens. Ele oferece alta performance e versatilidade, sendo uma escolha popular para aplicações modernas.

1. Instalação do Redis

Para iniciar com o Redis, o primeiro passo é baixá-lo do site oficial (redis.io) e seguir as instruções de instalação para o seu sistema operacional. As distribuições Linux geralmente oferecem pacotes Redis em seus repositórios.

2. Redis vs. MySQL

Redis e MySQL servem a propósitos distintos no ecossistema de dados. O Redis é um banco de dados em memória, otimizado para velocidade em operações de leitura e escrita, ideal para dados temporários, cache, filas de trabalho ou contadores de alta frequência, e é não-relacional. Por outro lado, o MySQL é um banco de dados relacional baseado em disco, projetado para durabilidade, integridade de dados e consultas complexas envolvendo relações entre tabelas. A escolha entre eles depende da natureza e do volume dos dados, bem como dos requisitos de performance e persistência de sua aplicação.

3. Redis vs. Memcached

Ambos Redis e Memcached são sistemas de cache em memória de alta performance. No entanto, o Redis se destaca por oferecer uma gama mais ampla de estruturas de dados (como strings, hashes, listas, conjuntos e conjuntos ordenados), enquanto o Memcached se limita principalmente a strings. Além disso, o Redis suporta persistência de dados (RDB e AOF), o que significa que os dados podem ser recuperados após uma reinicialização do servidor, característica ausente no Memcached. O Redis também oferece recursos mais avançados, como replicação e transações.

Operações Fundamentais do Redis

1. Iniciando o Serviço Redis

Para iniciar o servidor Redis, você pode usar os seguintes comandos no terminal:

# Início em primeiro plano (o terminal fica bloqueado)
redis-server

# Início em segundo plano (Linux/macOS)
# É comum configurar o Redis para rodar como um serviço ou usar o parâmetro 'daemonize yes' no arquivo de configuração.
# Exemplo simples para rodar em segundo plano no Linux:
redis-server &

# Início com um arquivo de configuração específico
redis-server /caminho/para/seu/redis.conf

Em sistemas Windows, você pode iniciar o serviço Redis se ele foi instalado como tal, ou usar redis-server.exe diretamente.

2. Gerenciamento de Senhas

A segurança do Redis é crucial. A forma recomendada de configurar uma senha é através do arquivo de configuração redis.conf:

# Adicione ou descomente esta linha no seu redis.conf
requirepass sua_senha_secreta

Após iniciar o servidor com o arquivo de configuração atualizado, você precisará autenticar-se ao conectar. Se precisar alterar a senha em um servidor Redis em execução (essa alteração não será persistente após uma reinicialização a menos que seja salva no redis.conf), pode usar:

config set requirepass nova_senha

Para autenticar-se em uma sessão redis-cli:

auth sua_senha_secreta

3. Conectando ao Banco de Dados

Para interagir com o servidor Redis, utilize o cliente de linha de comando redis-cli:

# Conexão padrão (localhost:6379, DB 0, sem senha)
redis-cli

# Conexão com host e porta específicos
redis-cli -h 192.168.1.100 -p 6380

# Conexão com banco de dados específico e senha
redis-cli -h localhost -p 6379 -n 1 -a sua_senha_secreta

4. Alternando entre Bancos de Dados

O Redis suporta múltiplos bancos de dados lógicos, numerados de 0 a 15 por padrão. Para alternar entre eles em uma sessão redis-cli:

select 3

Este comando muda para o banco de dados de índice 3.

5. Desligando o Serviço

Para encerrar o servidor Redis de forma segura, garantindo que os dados sejam persistidos (se configurado):

redis-cli shutdown

Ou, se já estiver conectado ao cliente redis-cli:

shutdown

6. Limpando Bancos de Dados Redis

Para remover todos os dados de todos os bancos de dados Redis:

flushall

Para remover todos os dados apenas do banco de dados atualmente selecionado:

flushdb

7. Persistência de Dados

O Redis oferece mecanismos de persistência para garantir que os dados não sejam perdidos em caso de reinicialização. Os principais são RDB (Redis Database), que cria snapshots pontuais dos dados, e AOF (Append Only File), que registra todas as operações de escrita. A configuração padrão para RDB no redis.conf inclui:

save 900 1    # Salva o dump se 1 chave for modificada em 900 segundos (15 min)
save 300 10   # Salva o dump se 10 chaves forem modificadas em 300 segundos (5 min)
save 60 10000 # Salva o dump se 10000 chaves forem modificadas em 60 segundos (1 min)

Você também pode forçar um salvamento manual a qualquer momento:

save

O arquivo de persistência RDB é geralmente nomeado dump.rdb e seu local pode ser configurado no redis.conf através da diretiva dir.

8. Configurações Relevantes do Redis

O arquivo redis.conf é o coração da configuração do Redis. Algumas diretivas importantes incluem:

• bind 127.0.0.1: Define quais interfaces de rede o Redis deve escutar. Para acessibilidade externa, pode-se usar 0.0.0.0 (com cautela!) ou IPs específicos.
• port 6379: A porta TCP onde o Redis escutará as conexões.
• daemonize no: Se definido como yes, o Redis rodará em segundo plano (como um daemon).
• loglevel notice: Nível de detalhe dos logs (debug, verbose, notice, warning).
• logfile "": Caminho para o arquivo de log. Se vazio, os logs são enviados para a saída padrão.
• databases 16: Número de bancos de dados disponíveis.
• dbfilename dump.rdb: Nome do arquivo RDB para persistência.
• dir ./: Diretório de trabalho para arquivos de persistência e logs.
• requirepass sua_senha_secreta: Configura uma senha para autenticação.
• stop-writes-on-bgsave-error yes: Se um salvamento em segundo plano falhar, o Redis para de aceitar escritas para alertar sobre a perda potencial de dados.
• rdbcompression yes: Compacta os arquivos RDB, reduzindo o tamanho em disco às custas de um pouco de CPU.
• rdbchecksum yes: Adiciona um checksum ao final do arquivo RDB para verificação de integridade.

Tipos de Dados do Redis

O Redis não é apenas um cacche de chave-valor simples; ele oferece diversas estruturas de dados avançadas, o que o torna incrivelmente versátil.

Strings

São a estrutura de dados mais básica, capazes de armazenar qualquer tipo de dado binário (texto, JPEG, etc.), até 512MB.

SET nomeUsuario "Alice"
GET nomeUsuario
SETEX chaveTemporaria 60 "valorComValidade" # Define com expiração em 60 segundos
MSET usuario:1:nome "Bob" usuario:1:email "bob@exemplo.com"
MGET usuario:1:nome usuario:1:email
INCRBY contadorAcessos 1

Listas (Lists)

Coleções ordenadas de strings. Podem ser usadas como filas ou pilhas, permitindo adicionar elementos no início ou no final.

RPUSH tarefas "Comprar pão" "Pagar contas" # Adiciona no final
LPUSH tarefas "Verificar email"          # Adiciona no início
LRANGE tarefas 0 -1                      # Obtém todos os itens da lista
LINDEX tarefas 1                         # Obtém o item no índice 1
LPOP tarefas                             # Remove e retorna o primeiro item
RPOP tarefas                             # Remove e retorna o último item
LINSERT tarefas BEFORE "Pagar contas" "Lavar carro" # Insere "Lavar carro" antes de "Pagar contas"

Hashes

Mapas de campos para valores. Ideais para armazenar objetos ou registros, onde cada chave Redis representa um objeto e os campos internos representam suas propriedades.

HSET usuario:2 nome "Carlos" email "carlos@exemplo.com"
HGET usuario:2 nome
HMSET produto:1 id 123 nome "Teclado Mecânico" preco 150.00
HMGET produto:1 nome preco
HKEYS produto:1                              # Obtém todos os campos
HVALS produto:1                              # Obtém todos os valores
HDEL produto:1 preco                         # Remove o campo 'preco'

Conjuntos (Sets)

Coleções não ordenadas de strings únicas. Úteis para verificar a existência de membros, armazenar tags ou realizar operações de conjunto como união, interseção e diferença.

SADD usuariosAtivos "Ana" "Bruno" "Carlos"
SADD usuariosOnline "Carlos" "Diana"
SMEMBERS usuariosAtivos                     # Lista todos os membros
SISMEMBER usuariosAtivos "Ana"              # Verifica se "Ana" é membro
SINTER usuariosAtivos usuariosOnline        # Interseção
SUNION usuariosAtivos usuariosOnline        # União
SDIFF usuariosAtivos usuariosOnline         # Diferença
SREM usuariosAtivos "Bruno"                 # Remove um membro
SPOP usuariosAtivos                         # Remove e retorna um membro aleatório

Conjuntos Ordenados (Sorted Sets)

Semelhantes aos Sets, mas cada membro é associado a uma pontuação (score), o que permite a ordenação. Perfeitos para rankings e placares de jogos.

ZADD placarJogo 100 "JogadorA" 250 "JogadorB" 150 "JogadorC"
ZINCRBY placarJogo 50 "JogadorA"           # Incrementa a pontuação de JogadorA em 50
ZRANGE placarJogo 0 -1 WITHSCORES          # Lista do menor para o maior score
ZREVRANGE placarJogo 0 1 WITHSCORES        # Lista os 2 melhores scores (do maior para o menor)

Integração do Redis com Python

Para interagir com o Redis a partir de aplicações Python, a biblioteca redis-py é a escolha padrão.

1. Instalação da Dependência

pip install redis

2. Uso Direto

A maneira mais simples de conectar e usar o Redis. O parâmetro decode_responses=True garante que as respostas do Redis sejam automaticamente decodificadas em strings, em vez de bytes.

import redis

# Conecta ao Redis no localhost, porta 6379, DB 0, sem senha.
# decode_responses=True garante que as respostas sejam strings, não bytes.
cliente_redis_simples = redis.Redis(host='127.0.0.1', port=6379, db=0, password=None, decode_responses=True)

# Exemplo de operações
cliente_redis_simples.set('minha_chave_string', 'valor_de_exemplo')
print(f"Valor recuperado: {cliente_redis_simples.get('minha_chave_string')}")

cliente_redis_simples.hset('dados_usuario_exemplo', mapping={'id': '101', 'nome': 'Fernanda'})
print(f"Hash de usuário: {cliente_redis_simples.hgetall('dados_usuario_exemplo')}")

Nota: Evite nomear seu arquivo Python como redis.py para não conflitar com o módulo instalado.

3. Utilização de Pool de Conexões

Para aplicações com alta demanda, usar um pool de conexões é crucial para gerenciar eficientemente as conexões e evitar sobrecarga de criação/fechamento. Isso melhora a performance e a escalabilidade, pois as conexões são reutilizadas.

import redis

# Configura um pool de conexões com um limite máximo.
# Ajuste 'password' se seu servidor Redis exigir autenticação.
pool_conexao = redis.ConnectionPool(
    host='127.0.0.1',
    port=6379,
    db=1,
    password='sua_senha_do_redis' if 'sua_senha_do_redis' else None, # Substitua pela sua senha
    max_connections=50, # Número máximo de conexões no pool
    decode_responses=True
)

# Cria uma instância do cliente Redis usando o pool
cliente_pool = redis.Redis(connection_pool=pool_conexao)

# Exemplo de operações com o cliente do pool
cliente_pool.set('codigo_produto', 'XYZ-456')
print(f"Código do produto: {cliente_pool.get('codigo_produto')}")

cliente_pool.lpush('historico_acessos', 'Pagina_A', 'Pagina_B', 'Pagina_C')
print(f"Histórico de acessos: {cliente_pool.lrange('historico_acessos', 0, -1)}")

4. Redis como Backend de Cache no Django

Para usar o Redis como backend de cache no framework web Django, você precisará da biblioteca django-redis.

pip install django-redis

a. Configuração no settings.py

Adicione a seguinte configuração ao seu arquivo settings.py do Django para definir o Redis como o backend de cache padrão:

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/0", # Formato: redis://[:senha@]host:porta/db_numero
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 150}, # Configurações do pool de conexões
            "DECODE_RESPONSES": True,
            "PASSWORD": "sua_senha_do_redis", # Preencha se seu Redis tiver senha
        },
        "KEY_PREFIX": "app_cache:" # Prefixo opcional para evitar colisões de chaves
    }
}

b. Utilização no Código (ex: views.py)

Após configurar o django-redis, você pode usar a API de cache do Django para interagir com o Redis. O módulo django.core.cache atua como uma interface unificada, permitindo que você troque o backend de cache (para Redis, Memcached, etc.) apenas alterando a configuração no settings.py.

from django.core.cache import cache
from django.http import HttpResponse

def exibir_produto_detalhado(request, produto_id):
    chave_cache = f'produto_detalhe:{produto_id}'
    
    # Tenta obter dados do cache
    dados_do_produto = cache.get(chave_cache)

    if dados_do_produto is None:
        # Se não estiver no cache, simula o carregamento dos dados (ex: do banco de dados)
        # ... Lógica para obter dados do DB ...
        dados_do_produto = {
            'id': produto_id, 
            'nome': f'Item {produto_id}', 
            'preco': 99.99,
            'descricao': 'Um item de exemplo com descrição detalhada.'
        }
        
        # Armazena os dados no cache por 600 segundos (10 minutos)
        cache.set(chave_cache, dados_do_produto, 600)
        mensagem = "Dados carregados do DB e armazenados no cache."
    else:
        mensagem = "Dados obtidos do cache."

    return HttpResponse(f"<h1>Detalhes do Produto {dados_do_produto['nome']}</h1><p>{dados_do_produto['descricao']}</p><p>Preço: R${dados_do_produto['preco']}</p><p><em>{mensagem}</em></p>")