Cloud & IT Cert Prep · Aula

Armazenamento de sessões e padrões de classificação

Use o ElastiCache para retirar o estado das sessões HTTP dos servidores da sua aplicação e implemente classificações em tempo real com conjuntos ordenados do Redis.

Aula 4 de 413 etapas

Armazenamento de sessões e padrões de classificação é uma aula grátis de Cloud & IT Cert Prep no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Cloud & IT Cert Prep, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Cloud & IT Cert Prep inclui 4 aulas no total.

O Problema com Sessões no Servidor

As aplicações web tradicionais armazenam os dados da sessão na memória do servidor. Isso funciona com um único servidor, mas falha quando você faz o dimensionamento horizontal — se a solicitação seguinte de um usuário for direcionada para uma instância EC2 diferente, essa instância não terá conhecimento da sessão do usuário, que será desconectado. Sessões fixas (afinidade de sessão no balanceador de carga) resolvem parcialmente o problema, mas reduzem a eficácia do balanceamento de carga. A solução escalável é mover o estado da sessão para um armazenamento compartilhado e de baixa latência, acessível por todas as instâncias — exatamente o que o ElastiCache Redis oferece.

Redis para Armazenamento de Sessões

Armazenar sessões no Redis oferece: leituras de sessão em menos de um milissegundo em todos os servidores da aplicação, TTL integrado para expiração automática de sessões, atualizações atômicas de sessões para evitar condições de corrida e a possibilidade de invalidar imediatamente uma sessão excluindo a chave. A aplicação armazena o ID da sessão em um cookie; a cada solicitação, ela procura esse ID de sessão no Redis para recuperar os dados da sessão. Todos os servidores da aplicação compartilham o mesmo Redis, portanto qualquer servidor pode processar a solicitação de qualquer usuário.

# Session storage with Redis (Python Flask example)
import redis, json, uuid
from datetime import timedelta

redis_client = redis.Redis(host='prod-redis-primary', port=6379)
SESSION_TTL = int(timedelta(hours=8).total_seconds())

def create_session(user_id):
    session_id = str(uuid.uuid4())
    session_data = {'user_id': user_id, 'logged_in': True}
    redis_client.setex(f'session:{session_id}', SESSION_TTL, json.dumps(session_data))
    return session_id

def get_session(session_id):
    data = redis_client.get(f'session:{session_id}')
    return json.loads(data) if data else None

TTL de Sessão e Expiração Deslizante

Um TTL fixo significa que a sessão expira N segundos após a criação, independentemente da atividade. Um TTL deslizante (que estende a expiração a cada acesso) é mais conveniente para o usuário — a sessão expira N segundos após o último acesso. No Redis, implemente um TTL deslizante chamando EXPIRE (ou EXPIREAT) na chave da sessão a cada leitura bem-sucedida da sessão, para redefinir a contagem regressiva da expiração. Isso garante que usuários ativos nunca sejam desconectados inesperadamente, enquanto sessões inativas expiram automaticamente, liberando memória.

# Sliding TTL session implementation
def get_session_with_sliding_ttl(session_id, redis_client, ttl_seconds=1800):
    session_key = f'session:{session_id}'

    # Pipeline: GET + EXPIRE in one round trip
    pipe = redis_client.pipeline()
    pipe.get(session_key)
    pipe.expire(session_key, ttl_seconds)  # Reset TTL on access
    results = pipe.execute()

    data = results[0]
    if data:
        return json.loads(data)
    return None   # Session expired or not found

Carrinho de Compras no Redis

Um carrinho de compras de comércio eletrônico é naturalmente adequado ao Redis. Cada carrinho é armazenado como um Hash do Redis, no qual o campo é o SKU do produto e o valor é a quantidade. Operações de hash como HINCRBY e HDEL permitem atualizações atômicas sem recuperar e regravar o carrinho inteiro. Combinado com um TTL (para expirar carrinhos abandonados após 24 horas), o Redis fornece um armazenamento de carrinhos rápido e persistente, sem a sobrecarga de usar um banco de dados relacional para cada evento de adição ao carrinho.

# Shopping cart operations using Redis Hash
cart_key = f'cart:{user_id}'

# Add item (or increase quantity)
# HINCRBY cart:user42 SKU-001 2
redis_client.hincrby(cart_key, 'SKU-001', 2)

# Remove item
# HDEL cart:user42 SKU-001
redis_client.hdel(cart_key, 'SKU-001')

# Get all items in cart
# HGETALL cart:user42
cart = redis_client.hgetall(cart_key)  # {b'SKU-001': b'2', b'SKU-002': b'1'}

# Set TTL for cart abandonment (24 hours)
redis_client.expire(cart_key, 86400)

Arquitetura de classificações

Uma classificação em tempo real é um caso de uso clássico do Redis, possibilitado pelos conjuntos ordenados (ZSETs). Cada entrada de jogador tem uma pontuação; o conjunto ordenado mantém os membros sempre em ordem crescente de pontuação. As consultas da classificação (os N melhores jogadores, a posição de um jogador e os jogadores em um intervalo de pontuação) têm complexidade O(log n) ou O(log n + m) — são extremamente rápidas mesmo com milhões de jogadores. Os conjuntos ordenados do Redis são a base de muitos recursos de classificação em jogos, aplicativos de condicionamento físico e redes sociais, sem a necessidade de uma consulta complexa ao banco de dados ou de recalcular a posição a cada carregamento de página.

# Real-time leaderboard with Redis Sorted Set

# Add or update a player's score
# ZADD game:weekly:leaderboard 15750 'player:alice'
redis_client.zadd('game:weekly:leaderboard', {'player:alice': 15750})

# Increment score (atomic)
# ZINCRBY game:weekly:leaderboard 500 'player:alice'
redis_client.zincrby('game:weekly:leaderboard', 500, 'player:alice')

# Get top 10 players (highest scores first)
# ZREVRANGE game:weekly:leaderboard 0 9 WITHSCORES
top_10 = redis_client.zrevrange('game:weekly:leaderboard', 0, 9, withscores=True)

Posição do jogador e jogadores próximos

Dois recursos comuns de classificações, além de “mostrar os 10 melhores”, são mostrar a posição de um jogador e mostrar os jogadores próximos de um determinado jogador. Ambos são triviais com conjuntos ordenados do Redis. ZREVRANK retorna a posição, indexada a partir de 0, de um jogador na ordem decrescente de pontuação. Para mostrar 5 jogadores acima e abaixo de um jogador, obtenha a posição dele e use ZREVRANGE do intervalo rank-5 a rank+5. Isso fornece uma visualização personalizada da classificação usando dois comandos do Redis — sem a necessidade de funções complexas de janela do SQL.

# Get Alice's rank (0-indexed, so add 1 for display)
# ZREVRANK game:weekly:leaderboard 'player:alice'
rank = redis_client.zrevrank('game:weekly:leaderboard', 'player:alice')
print(f'Alice is rank #{rank + 1}')

# Get 5 players above and below Alice
start = max(0, rank - 5)
end = rank + 5
nearby = redis_client.zrevrange(
    'game:weekly:leaderboard', start, end, withscores=True
)
print('Players near Alice:', nearby)

Limitação de taxa com Redis

A limitação de taxa (restringir quantas solicitações um cliente pode fazer em uma janela de tempo) é outro caso de uso de alto valor do Redis. O algoritmo de janela deslizante usa um conjunto ordenado no qual cada membro é o registro de data e hora de uma solicitação. A cada solicitação: remova os membros mais antigos que a janela, conte os membros restantes, rejeite a solicitação se a contagem exceder o limite e adicione o novo registro de data e hora. Isso implementa uma limitação de taxa precisa por janela deslizante, com resolução de milissegundos — muito mais precisa que os contadores de janela fixa e sem a sobrecarga de um banco de dados.

# Sliding window rate limiter (100 requests per 60 seconds)
import time

def is_rate_limited(user_id, redis_client, limit=100, window_seconds=60):
    key = f'ratelimit:{user_id}'
    now = time.time()
    window_start = now - window_seconds

    pipe = redis_client.pipeline()
    pipe.zremrangebyscore(key, '-inf', window_start)  # Remove old
    pipe.zcard(key)                                    # Count current
    pipe.zadd(key, {str(now): now})                   # Add this request
    pipe.expire(key, window_seconds)
    results = pipe.execute()

    request_count = results[1]
    return request_count >= limit  # True = rate limited

Bloqueios distribuídos com Redis

Os bloqueios distribuídos coordenam o acesso exclusivo a um recurso compartilhado entre vários servidores de aplicativos. O comando SET key value NX EX ttl do Redis fornece aquisição atômica do bloqueio: ele define a chave somente se ela não existir (NX = Not eXists) e define um TTL para evitar bloqueios permanentes caso o detentor falhe. Quando a operação é concluída, o detentor exclui a chave. O algoritmo Redlock (que usa vários nós do Redis para formar um quórum) fornece um bloqueio distribuído mais robusto, embora acrescente complexidade. Para a maioria dos casos de uso, um bloqueio em um único nó do Redis é suficiente.

# Distributed lock with Redis SET NX EX
import uuid

def acquire_lock(redis_client, resource, ttl_seconds=30):
    lock_id = str(uuid.uuid4())  # Unique ID to identify this lock holder
    key = f'lock:{resource}'
    acquired = redis_client.set(key, lock_id, nx=True, ex=ttl_seconds)
    return lock_id if acquired else None

def release_lock(redis_client, resource, lock_id):
    key = f'lock:{resource}'
    # Only delete if we still own the lock (Lua script for atomicity)
    lua = 'if redis.call("get",KEYS[1])==ARGV[1] then return redis.call("del",KEYS[1]) else return 0 end'
    redis_client.eval(lua, 1, key, lock_id)

Armazenamento de sessões: ElastiCache vs DynamoDB

Tanto o ElastiCache Redis quanto o DynamoDB podem armazenar dados de sessão, mas apresentam diferentes compromissos. ElastiCache Redis: latência de microssegundos, armazenamento em memória (volátil, a menos que a persistência esteja habilitada), modelo de dados mais simples e exige uma VPC. DynamoDB: latência de milissegundos de um único dígito (DAX pode igualar o Redis), totalmente gerenciado, sem cluster para manter, durável por padrão, acessível globalmente com Global Tables e sem servidor, com capacidade sob demanda. Para a prova SAA-C03: se a questão enfatizar latência de microssegundos ou operações complexas em memória, escolha o Redis. Se enfatizar durabilidade, sem servidor ou escala global, considere o DynamoDB.

Indexação geoespacial com Redis

O Redis tem um tipo de dados geoespaciais integrado (comandos GEO) que armazena coordenadas de latitude e longitude e permite consultas de proximidade. Com GEOADD, GEODIST e GEORADIUS (agora GEOSEARCH no Redis 6.2), você pode encontrar todos os locais dentro de um determinado raio de um ponto em O(n + log n). Casos de uso: encontrar motoristas próximos (transporte por aplicativo), encontrar restaurantes em um raio de 5 km e ordenar resultados de pesquisa por distância. Isso elimina a necessidade de um banco de dados geoespacial separado e mantém as consultas de localização em velocidades de memória.

# Store driver locations
# GEOADD drivers 13.361389 38.115556 'driver:001'
# GEOADD drivers 15.087269 37.502669 'driver:002'

# Find all drivers within 10 km of a point
# GEOSEARCH drivers FROMLONLAT 13.5 38.1 BYRADIUS 10 km ASC COUNT 5 WITHCOORD

# Result: sorted list of driver IDs within 10 km with coordinates

HyperLogLog para contagem de visitantes únicos

Um HyperLogLog é uma estrutura de dados probabilística que estima a contagem de elementos únicos em um conjunto usando uma quantidade fixa de memória (12 KB no Redis), independentemente de quantos itens únicos sejam adicionados. Ele oferece um erro padrão aproximado de 0,81%. Use PFADD para adicionar elementos e PFCOUNT para obter a estimativa. Isso é perfeito para contar usuários ativos únicos por dia, visualizações únicas de páginas ou endereços IP únicos quando não são necessárias contagens exatas e a eficiência de memória é importante. Armazenar milhões de IDs de usuários únicos como um Set do Redis consumiria GBs; o HyperLogLog usa 12 KB.

# Count unique daily visitors using HyperLogLog
date = '2024-01-15'
hll_key = f'unique_visitors:{date}'

# Track a visitor (PFADD is idempotent for the same user)
# PFADD unique_visitors:2024-01-15 'user:12345'
redis_client.pfadd(hll_key, 'user:12345')
redis_client.pfadd(hll_key, 'user:67890')
redis_client.pfadd(hll_key, 'user:12345')  # Duplicate — not counted again

# Get estimated unique visitor count
# PFCOUNT unique_visitors:2024-01-15
count = redis_client.pfcount(hll_key)
print(f'Unique visitors today (estimate): {count}')

Verificação rápida

Teste sua compreensão dos conceitos do AWS Solutions Architect (SAA-C03) abordados nesta lição.

Recapitulação da lição

Nesta lição, você aprendeu que: o armazenamento de sessões no Redis permite a escalabilidade horizontal sem estado, dando a todas as instâncias acesso ao estado compartilhado da sessão com latência inferior a um milissegundo; os conjuntos ordenados do Redis viabilizam classificações em tempo real com consultas de posição O(log n); e os tipos de dados especializados do Redis (HyperLogLog para contagens únicas, GEO para proximidade e bloqueios distribuídos) resolvem problemas comuns de arquitetura com eficiência. Com isso, concluímos o curso de Caching com ElastiCache — a seguir, exploraremos Alta Disponibilidade e Arquiteturas Tolerantes a Falhas.

Grátis para começar

Aprenda Cloud & IT Cert Prep com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
150
Aulas
600

Perguntas Frequentes

A aula “Armazenamento de sessões e padrões de classificação” é grátis?

Sim — o texto completo de “Armazenamento de sessões e padrões de classificação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Cloud & IT Cert Prep, atualize para CoddyKit PRO. O curso de Cloud & IT Cert Prep inclui 4 aulas no total.

O que vou aprender em “Armazenamento de sessões e padrões de classificação”?

Use o ElastiCache para retirar o estado das sessões HTTP dos servidores da sua aplicação e implemente classificações em tempo real com conjuntos ordenados do Redis. Você pratica Cloud & IT Cert Prep com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Cloud & IT Cert Prep?

Nenhuma experiência prévia é necessária. Cloud & IT Cert Prep no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Armazenamento de sessões e padrões de classificação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Cloud & IT Cert Prep?

Sim. Cada aula de Cloud & IT Cert Prep inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Redis versus Memcached: Escolha do mecanismo adequado
  2. Grupos de replicação e modo de cluster do ElastiCache Redis
  3. Estratégias de cache: carregamento sob demanda e gravação simultânea
  4. Armazenamento de sessões e padrões de classificação
← Voltar para Cloud & IT Cert Prep