Téléchargement valkey - Téléchargement du code source valkey

valkey

Autre code source

8.0.1

Télécharger

Ce projet a été dérivé du projet open source Redis juste avant la transition vers leurs nouvelles licences sources disponibles.

Ce README n'est qu'un document de démarrage rapide. Plus de détails peuvent être trouvés sous valkey.io

Qu’est-ce que Valkey ?

Valkey est un serveur de structure de données hautes performances qui sert principalement les charges de travail clé/valeur. Il prend en charge un large éventail de structures natives et un système de plugins extensible pour ajouter de nouvelles structures de données et modèles d'accès.

Construire Valkey à l'aide `Makefile`

Valkey peut être compilé et utilisé sur Linux, OSX, OpenBSD, NetBSD, FreeBSD. Nous prenons en charge les architectures big endian et little endian, ainsi que les systèmes 32 bits et 64 bits.

Il peut être compilé sur des systèmes dérivés de Solaris (par exemple SmartOS), mais notre support pour cette plate-forme est le meilleur effort et Valkey n'est pas garanti de fonctionner aussi bien que sous Linux, OSX et *BSD.

C'est aussi simple que :

 % make

Pour construire avec le support TLS, vous aurez besoin des bibliothèques de développement OpenSSL (par exemple libssl-dev sur Debian/Ubuntu).

Pour créer la prise en charge de TLS en tant que Valkey intégré :

 % make BUILD_TLS=yes

Pour construire TLS en tant que module Valkey :

 % make BUILD_TLS=module

Notez que le mode sentinelle ne prend pas en charge le module TLS.

Pour construire avec le support expérimental de RDMA, vous aurez besoin de bibliothèques de développement RDMA (par exemple librdmacm-dev et libibverbs-dev sur Debian/Ubuntu). Pour l'instant, Valkey ne prend en charge que le RDMA comme mode module de connexion. Courir:

 % make BUILD_RDMA=module

Pour construire avec le support systemd, vous aurez besoin de bibliothèques de développement systemd (telles que libsystemd-dev sur Debian/Ubuntu ou systemd-devel sur CentOS) et exécutez :

 % make USE_SYSTEMD=yes

Pour ajouter un suffixe aux noms de programmes Valkey, utilisez :

 % make PROG_SUFFIX="-alt"

Vous pouvez créer un binaire Valkey 32 bits en utilisant :

 % make 32bit

Après avoir construit Valkey, c'est une bonne idée de le tester en utilisant :

 % make test

Ce qui précède exécute les principaux tests d'intégration. Des tests supplémentaires sont lancés en utilisant :

 % 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

Pour en savoir plus sur l'exécution des tests d'intégration, consultez tests/README.md et pour les tests unitaires, voir src/unit/README.md.

Résolution des problèmes de build avec les dépendances ou les options de build mises en cache

Valkey a quelques dépendances qui sont incluses dans le répertoire deps . make ne reconstruit pas automatiquement les dépendances même si quelque chose dans le code source des dépendances change.

Lorsque vous mettez à jour le code source avec git pull ou lorsque le code dans l'arborescence des dépendances est modifié de toute autre manière, assurez-vous d'utiliser la commande suivante afin de vraiment tout nettoyer et reconstruire à partir de zéro :

 % make distclean

Cela nettoiera : jemalloc, lua, Hiredis, Linenoise et autres dépendances.

De plus, si vous forcez certaines options de construction telles que la cible 32 bits, aucune optimisation du compilateur C (à des fins de débogage) et d'autres options de construction similaires, ces options sont mises en cache indéfiniment jusqu'à ce que vous émettez une commande make distclean .

Résolution des problèmes de création de binaires 32 bits

Si après avoir construit Valkey avec une cible 32 bits vous devez le reconstruire avec une cible 64 bits, ou inversement, vous devez effectuer un make distclean dans le répertoire racine de la distribution Valkey.

En cas d'erreurs de construction lorsque vous essayez de créer un binaire 32 bits de Valkey, essayez les étapes suivantes :

Installez le package libc6-dev-i386 (essayez également g++-multilib).
Essayez d'utiliser la ligne de commande suivante au lieu de make 32bit : make CFLAGS="-m32 -march=native" LDFLAGS="-m32"

Allocateur

La sélection d'un allocateur de mémoire autre que celui par défaut lors de la construction de Valkey se fait en définissant la variable d'environnement MALLOC . Valkey est compilé et lié par défaut à libc malloc, à l'exception de jemalloc qui est la valeur par défaut sur les systèmes Linux. Cette valeur par défaut a été choisie car jemalloc s'est avéré avoir moins de problèmes de fragmentation que libc malloc.

Pour forcer la compilation avec libc malloc, utilisez :

 % make MALLOC=libc

Pour compiler avec jemalloc sur les systèmes Mac OS X, utilisez :

 % make MALLOC=jemalloc

Horloge monotone

Par défaut, Valkey construira en utilisant la fonction POSIX clock_gettime comme source d'horloge monotone. Sur la plupart des systèmes modernes, l'horloge interne du processeur peut être utilisée pour améliorer les performances. Les mises en garde peuvent être trouvées ici : http://oliveryang.net/2015/09/pitfalls-of-TSC-usage/

Pour construire avec la prise en charge de l'horloge d'instruction interne du processeur, utilisez :

 % make CFLAGS="-DUSE_PROCESSOR_CLOCK"

Construction verbeuse

Valkey construira par défaut avec une sortie colorisée conviviale. Si vous souhaitez voir une sortie plus détaillée, utilisez ce qui suit :

 % make V=1

Exécuter Valkey

Pour exécuter Valkey avec la configuration par défaut, tapez simplement :

 % cd src
% ./valkey-server

Si vous souhaitez fournir votre valkey.conf, vous devez l'exécuter en utilisant un paramètre supplémentaire (le chemin du fichier de configuration) :

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

Il est possible de modifier la configuration de Valkey en passant des paramètres directement en options à l'aide de la ligne de commande. Exemples :

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

Toutes les options de valkey.conf sont également prises en charge en tant qu'options utilisant la ligne de commande, avec exactement le même nom.

Exécuter Valkey avec TLS :

Exécution manuelle

Pour exécuter manuellement un serveur Valkey avec le mode TLS (en supposant que ./gen-test-certs.sh ait été invoqué pour que des exemples de certificats/clés soient disponibles) :

Mode intégré 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

Mode module 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

Notez que vous pouvez désactiver TCP en spécifiant explicitement --port 0 . Il est également possible d'avoir à la fois TCP et TLS disponibles en même temps, mais vous devrez attribuer des ports différents.

Utilisez valkey-cli pour vous connecter au serveur Valkey :

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

La spécification --tls-replication yes permet à une réplique de se connecter au principal.

L'utilisation de --tls-cluster yes oblige Valkey Cluster à utiliser TLS sur tous les nœuds.

Exécuter Valkey avec RDMA :

Notez que Valkey Over RDMA est une fonctionnalité expérimentale. Il peut être modifié ou supprimé dans toute version mineure ou majeure. Actuellement, il n'est pris en charge que sous Linux.

Pour exécuter manuellement un serveur Valkey avec le mode RDMA :

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

Il est possible de modifier l'adresse/le port de liaison du RDMA par la commande d'exécution :

 192.168.122.100:6379> CONFIG SET rdma.port 6380

Il est également possible d'avoir à la fois RDMA et TCP disponibles, et il n'y a pas de conflit entre TCP(6379) et RDMA(6379), Ex :

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

Notez que la carte réseau (192.168.122.100 de cet exemple) doit prendre en charge RDMA. Pour tester un serveur supportant ou non RDMA :

 % rdma res show (a new version iproute2 package)

Ou:

 % ibv_devices

Jouer avec Valkey

Vous pouvez utiliser valkey-cli pour jouer avec Valkey. Démarrez une instance de valkey-server, puis dans un autre terminal, essayez ce qui suit :

 % 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>

Installation de Valkey

Pour installer les binaires Valkey dans /usr/local/bin, utilisez simplement :

 % make install

Vous pouvez utiliser make PREFIX=/some/other/directory install si vous souhaitez utiliser une destination différente.

Remarque : Pour des raisons de compatibilité avec Redis, nous créons des liens symboliques à partir des noms Redis ( redis-server , redis-cli , etc.) vers les binaires Valkey installés par make install . Les liens symboliques sont créés dans le même répertoire que les binaires Valkey. Les liens symboliques sont supprimés lors de l'utilisation make uninstall . La création des liens symboliques peut être ignorée en définissant la variable makefile USE_REDIS_SYMLINKS=no .

make install installera simplement les binaires sur votre système, mais ne configurera pas les scripts d'initialisation et les fichiers de configuration à l'endroit approprié. Ce n'est pas nécessaire si vous voulez juste jouer un peu avec Valkey, mais si vous l'installez correctement pour un système de production, nous avons un script qui fait cela pour les systèmes Ubuntu et Debian :

 % cd utils
% ./install_server.sh

Remarque : install_server.sh ne fonctionnera pas sur Mac OSX ; il est construit uniquement pour Linux.

Le script vous posera quelques questions et configurera tout ce dont vous avez besoin pour exécuter correctement Valkey en tant que démon en arrière-plan qui redémarrera au redémarrage du système.

Vous pourrez arrêter et démarrer Valkey en utilisant le script nommé /etc/init.d/valkey_<portnumber> , par exemple /etc/init.d/valkey_6379 .

Construire avec `CMake`

En plus de la construction Makefile traditionnelle, Valkey prend en charge un système de construction alternatif et expérimental utilisant CMake .

Pour construire et installer Valkey , en mode Release (une build optimisée), tapez ceci dans votre 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

Autres options prises en charge par le système de build CMake de Valkey :

Drapeaux de construction spéciale

-DBUILD_TLS=<on|off|module> activer la construction TLS pour Valkey
-DBUILD_RDMA=<off|module> activer la construction du module RDMA (uniquement le mode module pris en charge)
-DBUILD_MALLOC=<libc|jemalloc|tcmalloc|tcmalloc_minimal> choisit l'allocateur à utiliser. Par défaut sous Linux : jemalloc , pour les autres OS : libc
-DBUILD_SANITIZER=<address|thread|undefined> build avec le désinfectant d'adresse activé
-DBUILD_UNIT_TESTS=[1|0] lorsqu'il est défini, la construction produira les valkey-unit-tests exécutables
-DBUILD_TEST_MODULES=[1|0] une fois défini, la construction inclura les modules situés dans le dossier tests/modules
-DBUILD_EXAMPLE_MODULES=[1|0] lorsqu'il est défini, la construction inclura les exemples de modules situés dans le dossier src/modules

Drapeaux communs

-DCMAKE_BUILD_TYPE=<Debug|Release...> définir le type de build, voir le manuel CMake pour plus de détails
-DCMAKE_INSTALL_PREFIX=/installation/path remplace cette valeur pour définir un préfixe d'installation personnalisé. Par défaut : /usr/local
-G<Generator Name> génère des fichiers de build pour "Generator Name". Par défaut, CMake générera Makefile s.

Construction verbeuse

CMake génère par défaut une sortie colorisée conviviale. Si vous souhaitez voir une sortie plus détaillée, utilisez ce qui suit :

make VERBOSE=1

Dépannage

Pendant l'étape CMake , CMake met en cache les variables dans un fichier local nommé CMakeCache.txt . Toutes les variables générées par Valkey sont supprimées du cache une fois consommées (cela se fait en appelant à unset(VAR-NAME CACHE) ). Cependant, certaines variables, comme le chemin du compilateur, sont conservées en cache. Pour démarrer une nouvelle build, supprimez le fichier cache CMakeCache.txt du dossier de build ou supprimez complètement le dossier de build.

Il est important de réexécuter CMake lors de l'ajout de nouveaux fichiers source.

Intégration avec l'EDI

Au cours de l'étape CMake de la construction, CMake génère un fichier JSON nommé compile_commands.json et le place sous le dossier de construction. Ce fichier est utilisé par de nombreux IDE et éditeurs de texte pour fournir la complétion du code (via clangd ).

Une petite mise en garde est que ces outils rechercheront compile_commands.json dans le dossier supérieur de Valkey. Une solution courante consiste à créer un lien symbolique vers celui-ci :

 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

Redémarrez votre IDE et voilà