No mundo das soluções de armazenamento de dados, o Redis se destaca como um poderoso armazenamento de valores-chave na memória. Com seu alto desempenho e versatilidade, tornou-se a escolha preferida de muitos desenvolvedores. Nesta postagem do blog, orientarei você no processo de construção de um clone do Redis do zero, compartilhando insights, desafios e as escolhas de design que fiz ao longo do caminho.

Visão geral do projeto

O objetivo deste projeto é replicar os recursos essenciais do Redis, criando uma versão simplificada que pode realizar operações básicas como armazenar, recuperar e excluir pares de valores-chave na memória. O projeto é implementado em Go, aproveitando os pontos fortes da linguagem em simultaneidade e desempenho.

Você pode encontrar o código-fonte do projeto no GitHub.

Por que construir um clone do Redis?

Construir um clone do Redis oferece vários benefícios educacionais:

1. Compreendendo os armazenamentos de valores-chave: Ao replicar a funcionalidade do Redis, obtive uma compreensão mais profunda de como funcionam os armazenamentos de valores-chave, incluindo estruturas de dados, gerenciamento de memória e otimização de desempenho.

2. Simultaneidade e desempenho: Redis é conhecido por sua velocidade. A implementação de um clone me ajudou a explorar a programação simultânea em Go, bem como a otimizar o desempenho para operações na memória.

3. Experiência prática: Construir um aplicativo do mundo real do zero reforça conceitos aprendidos na teoria, proporcionando experiência prática que pode ser aplicada em projetos futuros.

Projeto e Implementação

Recursos principais

Meu clone do Redis inclui os seguintes recursos principais:

• Operações Definir e Obter: Operações básicas para adicionar e recuperar valores com base em chaves.
• Operação Excluir: Remove entradas da loja.
• Expiração: suporte para definir um tempo de expiração nas chaves.
• Persistência: embora não seja uma implementação completa do Redis, adicionei um mecanismo básico de persistência baseado em arquivo para salvar dados no desligamento e restaurar na inicialização.

Estruturas de dados

Usei as estruturas de dados integradas do Go para implementar o armazenamento de valores-chave. Um mapa foi utilizado para armazenar pares de valores-chave, permitindo complexidade de tempo médio O(1) para pesquisas, inserções e exclusões. Para gerenciar a expiração, implementei uma estrutura separada para controlar os prazos de expiração.

type Store struct {
    data       map[string]string
    expiration map[string]time.Time
}

Simultaneidade

As goroutines e canais do Go são fundamentais no tratamento de solicitações simultâneas. Usei um mutex para sincronizar o acesso às estruturas de dados compartilhadas, garantindo a segurança do thread durante as operações de leitura e gravação.

var mu sync.Mutex

func (s *Store) Set(key, value string, expiration time.Duration) {
    mu.Lock()
    defer mu.Unlock()
    s.data[key] = value
    if expiration > 0 {
        s.expiration[key] = time.Now().Add(expiration)
    }
}

Persistência

Para fornecer um mecanismo básico de persistência, implementei a funcionalidade para salvar o estado atual do armazenamento em um arquivo. Na inicialização, o programa verifica a existência deste arquivo e carrega os dados, se disponíveis.

func (s *Store) Save() error {
    file, err := os.Create("data.rdb")
    if err != nil {
        return err
    }
    defer file.Close()
    encoder := json.NewEncoder(file)
    return encoder.Encode(s.data)
}

func (s *Store) Load() error {
    file, err := os.Open("data.rdb")
    if err != nil {
        return err
    }
    defer file.Close()
    decoder := json.NewDecoder(file)
    return decoder.Decode(&s.data)
}

Testando o clone

Para garantir que meu clone do Redis funcione conforme o esperado, escrevi um conjunto de testes de unidade cobrindo todas as funcionalidades. Usando a estrutura de testes do Go, validei a exatidão das operações de valor-chave e verifiquei se o recurso de expiração funciona corretamente.

func TestSetAndGet(t *testing.T) {
    store := NewStore()
    store.Set("key1", "value1", 0)
    value := store.Get("key1")
    if value != "value1" {
        t.Errorf("expected value1, got %s", value)
    }
}

Conclusão

Construir um clone do Redis foi um projeto desafiador, mas gratificante, que aprofundou minha compreensão do armazenamento de dados na memória e da programação simultânea em Go. Embora minha implementação não cubra todos os recursos avançados do Redis, ela serve como uma base sólida para entender como funciona um armazenamento de valores-chave.

Se você estiver interessado em explorar o código, sinta-se à vontade para verificar o repositório GitHub. Eu encorajo você a experimentar, adicionar novos recursos ou até mesmo construir sua própria versão inspirada neste projeto!