[BD] História 4: Lory e o Uso de Cache com Go

O Desafio da Performance no E-commerce
Lory, uma programadora dedicada, teve mais uma ideia para melhorar a performance do ecommerce, fazer o uso de cache. Tabelas como Order, Customer, Invoice e Product acumularam milhões de registros, e as consultas começaram a sofrer com lentidão. Lory sabia que precisava agir para otimizar o desempenho e garantir uma experiência fluida para os usuários.

A Solução com Cache
Lory decidiu implementar um sistema de cache usando Redis, uma ferramenta popular que armazena dados em memória para respostas rápidas. Em vez de consultar o banco de dados diretamente, os resultados frequentemente acessados seriam armazenados em cache.

Implementação em Go

Lory usou a biblioteca go-redis para interagir com o Redis.
Configuração do Redis: Primeiro, ela configurou o cliente Redis.

import (
    "context"
    "github.com/redis/go-redis/v9"
)
var ctx = context.Background()
func newRedisClient() *redis.Client {
    return redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
}

Consulta com Cache: Depois, ela implementou uma função para buscar pedidos de um cliente. Se os dados estivessem em cache, eram retornados rapidamente. Caso contrário, a consulta seria feita no banco, e os dados armazenados em cache.

type Order struct {
    OrderID    int
    CustomerID int
    OrderDate  string
    Amount     float64
}
func getOrdersByCustomer(redisClient *redis.Client, customerId int) ([]Order, error) {
    cacheKey := fmt.Sprintf("orders:%d", customerId)

    // Tenta buscar no cache
    cachedOrders, err := redisClient.Get(ctx, cacheKey).Result()
    if err == nil {
        // Deserializa os pedidos do cache
        var orders []Order
        json.Unmarshal([]byte(cachedOrders), &orders)
        return orders, nil
    }

    // Se não estiver no cache, consulta no banco de dados (simulação)
    orders := []Order{
        {OrderID: 1, CustomerID: customerId, OrderDate: "2024-11-01", Amount: 150.00},
    }

    // Salva os resultados no cache
    data, _ := json.Marshal(orders)
    redisClient.Set(ctx, cacheKey, data, 3600*time.Second)
    return orders, nil
}

Benefícios e Limitações do Cache
Benefícios:

• Resposta Rápida: Dados em cache são retornados em milissegundos.
• Redução de Carga no Banco: Menos consultas diretas ao banco liberam recursos para outras operações.
• Escalabilidade: Suporta mais usuários simultaneamente.

Limitações:

• Dados Desatualizados: Alterações no banco podem não ser refletidas imediatamente no cache.
• Consumo de Memória: Armazenar grandes volumes de dados no Redis pode sobrecarregar os recursos.
• Complexidade de Implementação: Exige planejamento para garantir que o cache seja sincronizado corretamente.

Lições Aprendidas

• Cache Não É a Solução Definitiva: Deve complementar, não substituir, otimizações no banco.
• Garantir dados atualizados: Criar estratégias para garantir que os dados no cache estejam sempre atualizados conforme as regras de negócio.
• Monitoramento Contínuo: Ferramentas como Prometheus ajudaram Lory a identificar gargalos.

Conclusão
A jornada de Lory mostra que melhorar a performance no banco de dados é um processo contínuo. Com cache, views, particionamento e processamento assíncrono, ela transformou o sistema em uma plataforma escalável e eficiente, pronta para crescer junto com o negócio.