Download valkey - download do código-fonte valkey

valkey

Outro código-fonte

8.0.1

Baixar

Este projeto foi bifurcado do projeto Redis de código aberto logo antes da transição para suas novas licenças de código-fonte disponíveis.

Este README é apenas um documento de início rápido. Mais detalhes podem ser encontrados em valkey.io

O que é Valkey?

Valkey é um servidor de estrutura de dados de alto desempenho que atende principalmente cargas de trabalho de chave/valor. Ele suporta uma ampla gama de estruturas nativas e um sistema de plugins extensível para adicionar novas estruturas de dados e padrões de acesso.

Construindo Valkey usando `Makefile`

Valkey pode ser compilado e usado em Linux, OSX, OpenBSD, NetBSD, FreeBSD. Oferecemos suporte a arquiteturas big endian e little endian e sistemas de 32 e 64 bits.

Ele pode ser compilado em sistemas derivados do Solaris (por exemplo, SmartOS), mas nosso suporte para esta plataforma é o melhor esforço e não é garantido que Valkey funcione tão bem quanto em Linux, OSX e *BSD.

É tão simples quanto:

 % make

Para construir com suporte TLS, você precisará de bibliotecas de desenvolvimento OpenSSL (por exemplo, libssl-dev no Debian/Ubuntu).

Para construir suporte TLS como Valkey integrado:

 % make BUILD_TLS=yes

Para construir TLS como módulo Valkey:

 % make BUILD_TLS=module

Observe que o modo sentinela não oferece suporte ao módulo TLS.

Para construir com suporte experimental RDMA você precisará de bibliotecas de desenvolvimento RDMA (por exemplo, librdmacm-dev e libibverbs-dev no Debian/Ubuntu). Por enquanto, Valkey suporta apenas RDMA como modo de módulo de conexão. Correr:

 % make BUILD_RDMA=module

Para construir com suporte ao systemd, você precisará de bibliotecas de desenvolvimento do systemd (como libsystemd-dev no Debian/Ubuntu ou systemd-devel no CentOS) e execute:

 % make USE_SYSTEMD=yes

Para acrescentar um sufixo aos nomes dos programas Valkey, use:

 % make PROG_SUFFIX="-alt"

Você pode construir um binário Valkey de 32 bits usando:

 % make 32bit

Depois de construir o Valkey, é uma boa ideia testá-lo usando:

 % make test

O acima executa os principais testes de integração. Testes adicionais são iniciados usando:

 % make test-unit     # Unit tests
% make test-modules  # Tests of the module API
% make test-sentinel # Valkey Sentinel integration tests
% make test-cluster  # Valkey Cluster integration tests

Mais sobre como executar os testes de integração podem ser encontrados em testes/README.md e para testes de unidade, consulte src/unit/README.md.

Corrigindo problemas de compilação com dependências ou opções de compilação em cache

Valkey possui algumas dependências que estão incluídas no diretório deps . make não reconstrói dependências automaticamente, mesmo que algo no código-fonte das dependências mude.

Ao atualizar o código-fonte com git pull ou quando o código dentro da árvore de dependências for modificado de qualquer outra forma, certifique-se de usar o seguinte comando para realmente limpar tudo e reconstruir do zero:

 % make distclean

Isto irá limpar: jemalloc, lua, Hiredis, linenoise e outras dependências.

Além disso, se você forçar certas opções de compilação, como destino de 32 bits, nenhuma otimização do compilador C (para fins de depuração) e outras opções de tempo de compilação semelhantes, essas opções serão armazenadas em cache indefinidamente até que você emita um comando make distclean .

Corrigindo problemas ao criar binários de 32 bits

Se depois de construir o Valkey com um alvo de 32 bits você precisar reconstruí-lo com um alvo de 64 bits, ou vice-versa, você precisará executar um make distclean no diretório raiz da distribuição Valkey.

Em caso de erros de construção ao tentar construir um binário de 32 bits do Valkey, tente as seguintes etapas:

Instale o pacote libc6-dev-i386 (tente também g++-multilib).
Tente usar a seguinte linha de comando em vez de make 32bit : make CFLAGS="-m32 -march=native" LDFLAGS="-m32"

Alocador

A seleção de um alocador de memória não padrão ao construir o Valkey é feita definindo a variável de ambiente MALLOC . Valkey é compilado e vinculado ao libc malloc por padrão, com exceção de jemalloc sendo o padrão em sistemas Linux. Este padrão foi escolhido porque jemalloc provou ter menos problemas de fragmentação que libc malloc.

Para forçar a compilação no libc malloc, use:

 % make MALLOC=libc

Para compilar em jemalloc em sistemas Mac OS X, use:

 % make MALLOC=jemalloc

Relógio monotônico

Por padrão, Valkey irá construir usando a função POSIX clock_gettime como fonte de relógio monotônico. Na maioria dos sistemas modernos, o clock interno do processador pode ser usado para melhorar o desempenho. Cuidados podem ser encontrados aqui: http://oliveryang.net/2015/09/pitfalls-of-TSC-usage/

Para construir com suporte ao clock de instruções interno do processador, use:

 % make CFLAGS="-DUSE_PROCESSOR_CLOCK"

Construção detalhada

Valkey será construído com uma saída colorida amigável por padrão. Se você quiser ver uma saída mais detalhada, use o seguinte:

 % make V=1

Executando Valkey

Para executar o Valkey com a configuração padrão, basta digitar:

 % cd src
% ./valkey-server

Se você deseja fornecer seu valkey.conf, você deve executá-lo usando um parâmetro adicional (o caminho do arquivo de configuração):

 % cd src
% ./valkey-server /path/to/valkey.conf

É possível alterar a configuração do Valkey passando parâmetros diretamente como opções através da linha de comando. Exemplos:

 % ./valkey-server --port 9999 --replicaof 127.0.0.1 6379
% ./valkey-server /etc/valkey/6379.conf --loglevel debug

Todas as opções em valkey.conf também são suportadas como opções usando a linha de comando, exatamente com o mesmo nome.

Executando Valkey com TLS:

Executando manualmente

Para executar manualmente um servidor Valkey com modo TLS (assumindo que ./gen-test-certs.sh foi invocado para que certificados/chaves de amostra estejam disponíveis):

Modo integrado TLS:

 ./src/valkey-server --tls-port 6379 --port 0 
    --tls-cert-file ./tests/tls/valkey.crt 
    --tls-key-file ./tests/tls/valkey.key 
    --tls-ca-cert-file ./tests/tls/ca.crt

Modo do módulo TLS:

 ./src/valkey-server --tls-port 6379 --port 0 
    --tls-cert-file ./tests/tls/valkey.crt 
    --tls-key-file ./tests/tls/valkey.key 
    --tls-ca-cert-file ./tests/tls/ca.crt 
    --loadmodule src/valkey-tls.so

Observe que você pode desabilitar o TCP especificando --port 0 explicitamente. Também é possível ter TCP e TLS disponíveis ao mesmo tempo, mas você terá que atribuir portas diferentes.

Use valkey-cli para conectar-se ao servidor Valkey:

 ./src/valkey-cli --tls 
    --cert ./tests/tls/valkey.crt 
    --key ./tests/tls/valkey.key 
    --cacert ./tests/tls/ca.crt

Especificar --tls-replication yes faz com que uma réplica se conecte ao primário.

Usar --tls-cluster yes faz com que o Valkey Cluster use TLS entre nós.

Executando Valkey com RDMA:

Observe que Valkey Over RDMA é um recurso experimental. Ele pode ser alterado ou removido em qualquer versão secundária ou principal. Atualmente, ele é compatível apenas com Linux.

Para executar manualmente um servidor Valkey com modo RDMA:

 % ./src/valkey-server --protected-mode no 
     --loadmodule src/valkey-rdma.so bind=192.168.122.100 port=6379

É possível alterar o endereço/porta de ligação do RDMA pelo comando de tempo de execução:

 192.168.122.100:6379> CONFIG SET rdma.port 6380

Também é possível ter RDMA e TCP disponíveis, e não há conflito de TCP(6379) e RDMA(6379), Ex:

 % ./src/valkey-server --protected-mode no 
     --loadmodule src/valkey-rdma.so bind=192.168.122.100 port=6379 
     --port 6379

Observe que a placa de rede (192.168.122.100 deste exemplo) deve suportar RDMA. Para testar se um servidor suporta ou não RDMA:

 % rdma res show (a new version iproute2 package)

Ou:

 % ibv_devices

Brincando com Valkey

Você pode usar valkey-cli para brincar com Valkey. Inicie uma instância do valkey-server e, em outro terminal, tente o seguinte:

 % cd src
% ./valkey-cli
valkey> ping
PONG
valkey> set foo bar
OK
valkey> get foo
"bar"
valkey> incr mycounter
(integer) 1
valkey> incr mycounter
(integer) 2
valkey>

Instalando Valkey

Para instalar os binários Valkey em /usr/local/bin, basta usar:

 % make install

Você pode usar make PREFIX=/some/other/directory install se desejar usar um destino diferente.

Nota : Para compatibilidade com Redis, criamos links simbólicos dos nomes Redis ( redis-server , redis-cli , etc.) para os binários Valkey instalados por make install . Os links simbólicos são criados no mesmo diretório dos binários Valkey. Os links simbólicos são removidos ao usar make uninstall . A criação dos links simbólicos pode ser ignorada definindo a variável makefile USE_REDIS_SYMLINKS=no .

make install instalará apenas binários em seu sistema, mas não configurará scripts de inicialização e arquivos de configuração no local apropriado. Isso não é necessário se você quiser apenas brincar um pouco com o Valkey, mas se você estiver instalando da maneira correta para um sistema de produção, temos um script que faz isso para sistemas Ubuntu e Debian:

 % cd utils
% ./install_server.sh

Nota : install_server.sh não funcionará no Mac OSX; ele foi desenvolvido apenas para Linux.

O script fará algumas perguntas e configurará tudo que você precisa para executar o Valkey corretamente como um daemon em segundo plano que será reiniciado na reinicialização do sistema.

Você poderá parar e iniciar o Valkey usando o script chamado /etc/init.d/valkey_<portnumber> , por exemplo /etc/init.d/valkey_6379 .

Construindo usando `CMake`

Além da construção tradicional Makefile , Valkey suporta um sistema de construção alternativo e experimental usando CMake .

Para compilar e instalar Valkey , no modo Release (uma compilação otimizada), digite isto em seu terminal:

mkdir build-release
cd $_
cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/opt/valkey
sudo make install
# Valkey is now installed under /opt/valkey

Outras opções suportadas pelo sistema de compilação CMake da Valkey:

Sinalizadores de construção especiais

-DBUILD_TLS=<on|off|module> habilita construção TLS para Valkey
-DBUILD_RDMA=<off|module> habilita a construção do módulo RDMA (apenas modo de módulo suportado)
-DBUILD_MALLOC=<libc|jemalloc|tcmalloc|tcmalloc_minimal> escolha o alocador a ser usado. Padrão no Linux: jemalloc , para outro sistema operacional: libc
-DBUILD_SANITIZER=<address|thread|undefined> compilação com sanitizador de endereço habilitado
-DBUILD_UNIT_TESTS=[1|0] quando definido, a compilação produzirá os valkey-unit-tests executáveis
-DBUILD_TEST_MODULES=[1|0] quando definido, a compilação incluirá os módulos localizados na pasta tests/modules
-DBUILD_EXAMPLE_MODULES=[1|0] quando definido, a compilação incluirá os módulos de exemplo localizados na pasta src/modules

Sinalizadores comuns

-DCMAKE_BUILD_TYPE=<Debug|Release...> define o tipo de compilação, consulte o manual do CMake para mais detalhes
-DCMAKE_INSTALL_PREFIX=/installation/path substitui esse valor para definir um prefixo de instalação customizado. Padrão: /usr/local
-G<Generator Name> gera arquivos de construção para "Generator Name". Por padrão, o CMake irá gerar Makefile s.

Construção detalhada

CMake gera uma saída colorida amigável por padrão. Se você quiser ver uma saída mais detalhada, use o seguinte:

make VERBOSE=1

Solução de problemas

Durante o estágio CMake , CMake armazena variáveis em cache em um arquivo local chamado CMakeCache.txt . Todas as variáveis geradas pelo Valkey são removidas do cache uma vez consumidas (isso é feito chamando unset(VAR-NAME CACHE) ). Entretanto, algumas variáveis, como o caminho do compilador, são mantidas em cache. Para iniciar uma nova compilação, remova o arquivo de cache CMakeCache.txt da pasta de compilação ou exclua a pasta de compilação completamente.

É importante executar novamente CMake ao adicionar novos arquivos de origem.

Integração com IDE

Durante o estágio CMake da construção, CMake gera um arquivo JSON chamado compile_commands.json e o coloca na pasta de construção. Este arquivo é usado por muitos IDEs e editores de texto para fornecer conclusão de código (via clangd ).

Uma pequena ressalva é que essas ferramentas procurarão compile_commands.json na pasta superior do Valkey. Uma solução alternativa comum é criar um link simbólico para ele:

 cd /path/to/valkey/
# We assume here that your build folder is `build-release`
ln -sf $( pwd ) /build-release/compile_commands.json $( pwd ) /compile_commands.json

Reinicie seu IDE e pronto