Redis - Guide rapide

Redis est un magasin de valeurs-clés avancé et open source et une solution appropriée pour créer des applications Web évolutives et performantes.

Redis a trois particularités principales qui le distinguent.

• Redis conserve sa base de données entièrement dans la mémoire, en utilisant le disque uniquement pour la persistance.

• Redis dispose d'un ensemble relativement riche de types de données par rapport à de nombreux magasins de données clé-valeur.

• Redis peut répliquer des données sur n'importe quel nombre d'esclaves.

Avantages Redis

Voici certains avantages de Redis.

• Exceptionally fast - Redis est très rapide et peut effectuer environ 110000 SET par seconde, environ 81000 GET par seconde.

• Supports rich data types- Redis prend en charge nativement la plupart des types de données que les développeurs connaissent déjà, tels que la liste, l'ensemble, l'ensemble trié et les hachages. Cela facilite la résolution de divers problèmes car nous savons quel problème peut être mieux géré par quel type de données.

• Operations are atomic - Toutes les opérations Redis sont atomiques, ce qui garantit que si deux clients accèdent simultanément, le serveur Redis recevra la valeur mise à jour.

• Multi-utility tool - Redis est un outil multi-utilitaire et peut être utilisé dans un certain nombre de cas d'utilisation tels que la mise en cache, les files d'attente de messagerie (Redis prend en charge nativement Publish / Subscribe), toutes les données de courte durée de votre application, telles que les sessions d'application Web, Web nombre de consultations de page, etc.

Redis par rapport aux autres magasins à valeur clé

• Redis est un chemin d'évolution différent dans les bases de données clé-valeur, où les valeurs peuvent contenir des types de données plus complexes, avec des opérations atomiques définies sur ces types de données.

• Redis est une base de données en mémoire mais persistante sur la base de données de disque, par conséquent, il représente un compromis différent où une vitesse d'écriture et de lecture très élevée est obtenue avec la limitation des ensembles de données qui ne peuvent pas être plus grands que la mémoire.

• Un autre avantage des bases de données en mémoire est que la représentation en mémoire de structures de données complexes est beaucoup plus simple à manipuler que la même structure de données sur le disque. Ainsi, Redis peut faire beaucoup avec peu de complexité interne.

Dans ce chapitre, vous découvrirez la configuration environnementale de Redis.

Installez Redis sur Ubuntu

Pour installer Redis sur Ubuntu, accédez au terminal et tapez les commandes suivantes -

$sudo apt-get update $sudo apt-get install redis-server

Cela installera Redis sur votre machine.

Démarrez Redis

$redis-server

Vérifiez si Redis fonctionne

$redis-cli

Cela ouvrira une invite de redis.

redis 127.0.0.1:6379>

Dans l'invite ci-dessus, 127.0.0.1 est l'adresse IP de votre appareil et 6379est le port sur lequel le serveur Redis s'exécute. Tapez maintenant ce qui suitPING commander.

redis 127.0.0.1:6379> ping 
PONG

Cela montre que Redis est correctement installé sur votre ordinateur.

Installez Redis Desktop Manager sur Ubuntu

Pour installer le gestionnaire de bureau Redis sur Ubuntu, téléchargez simplement le package à partir de https://redisdesktop.com/download

Ouvrez le package téléchargé et installez-le.

Le gestionnaire de bureau Redis vous donnera une interface utilisateur pour gérer vos clés et vos données Redis.

Dans Redis, un fichier de configuration (redis.conf) est disponible dans le répertoire racine de Redis. Bien que vous puissiez obtenir et définir toutes les configurations Redis par RedisCONFIG commander.

Syntaxe

Voici la syntaxe de base de Redis CONFIG commander.

redis 127.0.0.1:6379> CONFIG GET CONFIG_SETTING_NAME

Exemple

redis 127.0.0.1:6379> CONFIG GET loglevel  
1) "loglevel" 
2) "notice"

Pour obtenir tous les paramètres de configuration, utilisez * à la place de CONFIG_SETTING_NAME

Exemple

redis 127.0.0.1:6379> CONFIG GET *  
  1) "dbfilename" 
  2) "dump.rdb" 
  3) "requirepass" 
  4) "" 
  5) "masterauth" 
  6) "" 
  7) "unixsocket" 
  8) "" 
  9) "logfile" 
 10) "" 
 11) "pidfile" 
 12) "/var/run/redis.pid" 
 13) "maxmemory" 
 14) "0"
 15) "maxmemory-samples" 
 16) "3" 
 17) "timeout" 
 18) "0" 
 19) "tcp-keepalive" 
 20) "0" 
 21) "auto-aof-rewrite-percentage" 
 22) "100" 
 23) "auto-aof-rewrite-min-size" 
 24) "67108864" 
 25) "hash-max-ziplist-entries" 
 26) "512" 
 27) "hash-max-ziplist-value" 
 28) "64" 
 29) "list-max-ziplist-entries" 
 30) "512" 
 31) "list-max-ziplist-value" 
 32) "64" 
 33) "set-max-intset-entries" 
 34) "512" 
 35) "zset-max-ziplist-entries" 
 36) "128" 
 37) "zset-max-ziplist-value" 
 38) "64" 
 39) "hll-sparse-max-bytes" 
 40) "3000" 
 41) "lua-time-limit" 
 42) "5000" 
 43) "slowlog-log-slower-than" 
 44) "10000" 
 45) "latency-monitor-threshold" 
 46) "0" 
 47) "slowlog-max-len" 
 48) "128" 
 49) "port" 
 50) "6379" 
 51) "tcp-backlog" 
 52) "511" 
 53) "databases" 
 54) "16" 
 55) "repl-ping-slave-period" 
 56) "10" 
 57) "repl-timeout" 
 58) "60" 
 59) "repl-backlog-size" 
 60) "1048576" 
 61) "repl-backlog-ttl" 
 62) "3600" 
 63) "maxclients" 
 64) "4064" 
 65) "watchdog-period" 
 66) "0" 
 67) "slave-priority" 
 68) "100" 
 69) "min-slaves-to-write" 
 70) "0" 
 71) "min-slaves-max-lag" 
 72) "10" 
 73) "hz" 
 74) "10" 
 75) "no-appendfsync-on-rewrite" 
 76) "no" 
 77) "slave-serve-stale-data" 
 78) "yes" 
 79) "slave-read-only" 
 80) "yes" 
 81) "stop-writes-on-bgsave-error" 
 82) "yes" 
 83) "daemonize" 
 84) "no" 
 85) "rdbcompression" 
 86) "yes"
 87) "rdbchecksum" 
 88) "yes" 
 89) "activerehashing" 
 90) "yes" 
 91) "repl-disable-tcp-nodelay" 
 92) "no" 
 93) "aof-rewrite-incremental-fsync" 
 94) "yes" 
 95) "appendonly" 
 96) "no" 
 97) "dir" 
 98) "/home/deepak/Downloads/redis-2.8.13/src" 
 99) "maxmemory-policy" 
100) "volatile-lru" 
101) "appendfsync" 
102) "everysec" 
103) "save" 
104) "3600 1 300 100 60 10000" 
105) "loglevel" 
106) "notice" 
107) "client-output-buffer-limit" 
108) "normal 0 0 0 slave 268435456 67108864 60 pubsub 33554432 8388608 60" 
109) "unixsocketperm" 
110) "0" 
111) "slaveof" 
112) "" 
113) "notify-keyspace-events" 
114) "" 
115) "bind" 
116) ""

Modifier la configuration

Pour mettre à jour la configuration, vous pouvez modifier redis.conf fichier directement ou vous pouvez mettre à jour les configurations via CONFIG set commander.

Syntaxe

Voici la syntaxe de base de CONFIG SET commander.

redis 127.0.0.1:6379> CONFIG SET CONFIG_SETTING_NAME NEW_CONFIG_VALUE

Exemple

redis 127.0.0.1:6379> CONFIG SET loglevel "notice" 
OK 
redis 127.0.0.1:6379> CONFIG GET loglevel  
1) "loglevel" 
2) "notice"

Redis prend en charge 5 types de types de données.

Cordes

La chaîne Redis est une séquence d'octets. Les chaînes dans Redis sont binaires sûres, ce qui signifie qu'elles ont une longueur connue non déterminée par des caractères de fin spéciaux. Ainsi, vous pouvez stocker jusqu'à 512 mégaoctets dans une chaîne.

Exemple

redis 127.0.0.1:6379> SET name "tutorialspoint" 
OK 
redis 127.0.0.1:6379> GET name 
"tutorialspoint"

Dans l'exemple ci-dessus, SET et GET sont des commandes Redis, name est la clé utilisée dans Redis et tutorialspoint est la valeur de chaîne stockée dans Redis.

Note - Une valeur de chaîne peut avoir une longueur maximale de 512 mégaoctets.

Hashs

Un hachage Redis est une collection de paires valeur / clé. Les hachages Redis sont des mappages entre les champs de chaîne et les valeurs de chaîne. Par conséquent, ils sont utilisés pour représenter des objets.

Exemple

redis 127.0.0.1:6379> HMSET user:1 username tutorialspoint password 
tutorialspoint points 200 
OK 
redis 127.0.0.1:6379> HGETALL user:1  
1) "username" 
2) "tutorialspoint" 
3) "password" 
4) "tutorialspoint" 
5) "points" 
6) "200"

Dans l'exemple ci-dessus, le type de données de hachage est utilisé pour stocker l'objet de l'utilisateur qui contient des informations de base sur l'utilisateur. IciHMSET, HGETALL sont des commandes pour Redis, tandis que user − 1 C'est la clé.

Chaque hachage peut stocker jusqu'à 2 ³² - 1 paires de valeurs de champ (plus de 4 milliards).

Listes

Les listes Redis sont simplement des listes de chaînes, triées par ordre d'insertion. Vous pouvez ajouter des éléments à une liste Redis sur la tête ou sur la queue.

Exemple

redis 127.0.0.1:6379> lpush tutoriallist redis 
(integer) 1 
redis 127.0.0.1:6379> lpush tutoriallist mongodb 
(integer) 2 
redis 127.0.0.1:6379> lpush tutoriallist rabitmq 
(integer) 3 
redis 127.0.0.1:6379> lrange tutoriallist 0 10  

1) "rabitmq" 
2) "mongodb" 
3) "redis"

La longueur maximale d'une liste est de 2 ³² - 1 éléments (4294967295, plus de 4 milliards d'éléments par liste).

Ensembles

Les ensembles Redis sont une collection non ordonnée de chaînes. Dans Redis, vous pouvez ajouter, supprimer et tester l'existence de membres en complexité temporelle O (1).

Exemple

redis 127.0.0.1:6379> sadd tutoriallist redis 
(integer) 1 
redis 127.0.0.1:6379> sadd tutoriallist mongodb 
(integer) 1 
redis 127.0.0.1:6379> sadd tutoriallist rabitmq 
(integer) 1 
redis 127.0.0.1:6379> sadd tutoriallist rabitmq 
(integer) 0 
redis 127.0.0.1:6379> smembers tutoriallist  

1) "rabitmq" 
2) "mongodb" 
3) "redis"

Note - Dans l'exemple ci-dessus, rabitmq est ajouté deux fois, mais en raison de la propriété unique de l'ensemble, il n'est ajouté qu'une seule fois.

Le nombre maximum de membres dans un ensemble est de 2 ³² - 1 (4294967295, plus de 4 milliards de membres par ensemble).

Ensembles triés

Les ensembles triés Redis sont similaires aux ensembles Redis, des collections non répétitives de chaînes. La différence est que chaque membre d'un ensemble trié est associé à un score, qui est utilisé pour prendre l'ensemble trié ordonné, du plus petit au plus grand score. Bien que les membres soient uniques, les scores peuvent être répétés.

Exemple

redis 127.0.0.1:6379> zadd tutoriallist 0 redis 
(integer) 1 
redis 127.0.0.1:6379> zadd tutoriallist 0 mongodb 
(integer) 1 
redis 127.0.0.1:6379> zadd tutoriallist 0 rabitmq 
(integer) 1 
redis 127.0.0.1:6379> zadd tutoriallist 0 rabitmq 
(integer) 0 
redis 127.0.0.1:6379> ZRANGEBYSCORE tutoriallist 0 1000  

1) "redis" 
2) "mongodb" 
3) "rabitmq"

Les commandes Redis sont utilisées pour effectuer certaines opérations sur le serveur Redis.

Pour exécuter des commandes sur le serveur Redis, vous avez besoin d'un client Redis. Le client Redis est disponible dans le package Redis, que nous avons installé précédemment.

Syntaxe

Voici la syntaxe de base du client Redis.

$redis-cli

Exemple

L'exemple suivant explique comment démarrer le client Redis.

Pour démarrer le client Redis, ouvrez le terminal et tapez la commande redis-cli. Cela se connectera à votre serveur local et vous pouvez maintenant exécuter n'importe quelle commande.

$redis-cli 
redis 127.0.0.1:6379> 
redis 127.0.0.1:6379> PING  
PONG

Dans l'exemple ci-dessus, nous nous connectons au serveur Redis s'exécutant sur la machine locale et exécutons une commande PING, qui vérifie si le serveur fonctionne ou non.

Exécuter les commandes sur le serveur distant

Pour exécuter des commandes sur le serveur distant Redis, vous devez vous connecter au serveur par le même client redis-cli

Syntaxe

$ redis-cli -h host -p port -a password

Exemple

L'exemple suivant montre comment se connecter au serveur distant Redis, s'exécutant sur l'hôte 127.0.0.1, port 6379 et possède un mot de passe mypass.

$redis-cli -h 127.0.0.1 -p 6379 -a "mypass" 
redis 127.0.0.1:6379> 
redis 127.0.0.1:6379> PING  
PONG

Les commandes de touches Redis sont utilisées pour gérer les clés dans Redis. Voici la syntaxe d'utilisation des commandes de touches redis.

Syntaxe

redis 127.0.0.1:6379> COMMAND KEY_NAME

Exemple

redis 127.0.0.1:6379> SET tutorialspoint redis 
OK 
redis 127.0.0.1:6379> DEL tutorialspoint 
(integer) 1

Dans l'exemple ci-dessus, DEL est la commande, tandis que tutorialspointC'est la clé. Si la clé est supprimée, alors la sortie de la commande sera (entier) 1, sinon ce sera (entier) 0.

Commandes des touches Redis

Le tableau suivant répertorie certaines commandes de base liées aux touches.

Sr.Non	Commande et description
1	Touche DEL Cette commande supprime la clé, si elle existe.
2	Clé DUMP Cette commande renvoie une version sérialisée de la valeur stockée à la clé spécifiée.
3	Touche EXISTS Cette commande vérifie si la clé existe ou non.
4	EXPIRE les secondes de la touche Définit l'expiration de la clé après l'heure spécifiée.
5	Horodatage de la clé EXPIREAT Définit l'expiration de la clé après l'heure spécifiée. Ici, l'heure est au format d'horodatage Unix.
6	Touche PEXPIRE millisecondes Définit l'expiration de la clé en millisecondes.
sept	Horodatage en millisecondes de la clé PEXPIREAT Définit l'expiration de la clé dans l'horodatage Unix spécifié en millisecondes.
8	Modèle KEYS Recherche toutes les clés correspondant au modèle spécifié.
9	Touche MOVE db Déplace une clé vers une autre base de données.
dix	Touche PERSIST Supprime l'expiration de la clé.
11	Touche PTTL Obtient le temps restant d'expiration des clés en millisecondes.
12	Clé TTL Obtient le temps restant à l'expiration des clés.
13	RANDOMKEY Renvoie une clé aléatoire de Redis.
14	RENAME key newkey Modifie le nom de la clé.
15	Touche RENAMENX newkey Renomme la clé, si une nouvelle clé n'existe pas.
16	Touche TYPE Renvoie le type de données de la valeur stockée dans la clé.

Les commandes de chaînes Redis sont utilisées pour gérer les valeurs de chaîne dans Redis. Voici la syntaxe d'utilisation des commandes de chaîne Redis.

Syntaxe

redis 127.0.0.1:6379> COMMAND KEY_NAME

Exemple

redis 127.0.0.1:6379> SET tutorialspoint redis 
OK 
redis 127.0.0.1:6379> GET tutorialspoint 
"redis"

Dans l'exemple ci-dessus, SET et GET sont les commandes, tandis que tutorialspoint C'est la clé.

Commandes de chaînes Redis

Le tableau suivant répertorie quelques commandes de base pour gérer les chaînes dans Redis.

Sr.Non	Commande et description
1	SET valeur clé Cette commande définit la valeur de la clé spécifiée.
2	Obtenir la clé Obtient la valeur d'une clé.
3	GETRANGE touche début fin Obtient une sous-chaîne de la chaîne stockée dans une clé.
4	Valeur clé GETSET Définit la valeur de chaîne d'une clé et renvoie son ancienne valeur.
5	Décalage de la touche GETBIT Renvoie la valeur de bit au décalage dans la valeur de chaîne stockée sur la clé.
6	MGET clé1 [clé2 ..] Obtient les valeurs de toutes les clés données
sept	Valeur de décalage de clé SETBIT Définit ou efface le bit au décalage dans la valeur de chaîne stockée sur la clé
8	Valeur des secondes de touche SETEX Définit la valeur avec l'expiration d'une clé
9	Valeur de clé SETNX Définit la valeur d'une clé, uniquement si la clé n'existe pas
dix	Valeur de décalage de clé SETRANGE Remplace la partie d'une chaîne à la clé en commençant au décalage spécifié
11	Touche STRLEN Obtient la longueur de la valeur stockée dans une clé
12	Valeur de clé MSET [valeur de clé ...] Définit plusieurs clés sur plusieurs valeurs
13	Valeur de clé MSETNX [valeur de clé ...] Définit plusieurs clés sur plusieurs valeurs, uniquement si aucune des clés n'existe
14	Valeur en millisecondes de la clé PSETEX Définit la valeur et l'expiration en millisecondes d'une clé
15	Touche INCR Incrémente la valeur entière d'une clé de un
16	Incrément de clé INCRBY Incrémente la valeur entière d'une clé du montant donné
17	Incrément de clé INCRBYFLOAT Incrémente la valeur flottante d'une clé du montant donné
18	Touche DECR Décrémente la valeur entière d'une clé de un
19	Décrémenter la touche DECRBY Décrémente la valeur entière d'une clé du nombre donné
20	APPEND valeur clé Ajoute une valeur à une clé

Les hachages Redis sont des mappages entre les champs de chaîne et les valeurs de chaîne. Par conséquent, ils constituent le type de données parfait pour représenter des objets.

Dans Redis, chaque hachage peut stocker jusqu'à plus de 4 milliards de paires champ-valeur.

Exemple

redis 127.0.0.1:6379> HMSET tutorialspoint name "redis tutorial" 
description "redis basic commands for caching" likes 20 visitors 23000 
OK 
redis 127.0.0.1:6379> HGETALL tutorialspoint  
1) "name" 
2) "redis tutorial" 
3) "description" 
4) "redis basic commands for caching" 
5) "likes" 
6) "20" 
7) "visitors" 
8) "23000"

Dans l'exemple ci-dessus, nous avons défini le détail des tutoriels Redis (nom, description, likes, visiteurs) dans le hachage nommé 'tutorialspoint'.

Commandes de hachage Redis

Le tableau suivant répertorie quelques commandes de base liées au hachage.

Sr.Non	Commande et description
1	Champ clé HDEL2 [champ2] Supprime un ou plusieurs champs de hachage.
2	Champ clé HEXISTES Détermine si un champ de hachage existe ou non.
3	Champ clé HGET Obtient la valeur d'un champ de hachage stocké à la clé spécifiée.
4	Touche HGETALL Obtient tous les champs et valeurs stockés dans un hachage à la clé spécifiée
5	Incrément de champ clé HINCRBY Incrémente la valeur entière d'un champ de hachage du nombre donné
6	Incrément du champ clé HINCRBYFLOAT Incrémente la valeur flottante d'un champ de hachage du montant donné
sept	Clé HKEYS Obtient tous les champs dans un hachage
8	Touche HLEN Obtient le nombre de champs dans un hachage
9	HMGET clé champ1 [champ2] Obtient les valeurs de tous les champs de hachage donnés
dix	HMSET clé champ1 valeur1 [champ2 valeur2] Définit plusieurs champs de hachage sur plusieurs valeurs
11	Valeur du champ clé HSET Définit la valeur de chaîne d'un champ de hachage
12	Valeur du champ clé HSETNX Définit la valeur d'un champ de hachage, uniquement si le champ n'existe pas
13	Touche HVALS Obtient toutes les valeurs d'un hachage
14	Curseur de la touche HSCAN [Modèle MATCH] [COUNT count] Répète incrémentalement les champs de hachage et les valeurs associées

Les listes Redis sont simplement des listes de chaînes, triées par ordre d'insertion. Vous pouvez ajouter des éléments dans les listes Redis dans la tête ou la queue de la liste.

La longueur maximale d'une liste est de 2 ³² - 1 éléments (4294967295, plus de 4 milliards d'éléments par liste).

Exemple

redis 127.0.0.1:6379> LPUSH tutorials redis 
(integer) 1 
redis 127.0.0.1:6379> LPUSH tutorials mongodb 
(integer) 2 
redis 127.0.0.1:6379> LPUSH tutorials mysql 
(integer) 3 
redis 127.0.0.1:6379> LRANGE tutorials 0 10  
1) "mysql" 
2) "mongodb" 
3) "redis"

Dans l'exemple ci-dessus, trois valeurs sont insérées dans la liste Redis nommée `` tutoriels '' par la commande LPUSH.

Commandes des listes Redis

Le tableau suivant répertorie certaines commandes de base liées aux listes.

Sr.Non	Commande et description
1	Délai BLPOP key1 [key2] Supprime et récupère le premier élément d'une liste, ou bloque jusqu'à ce qu'il en soit un disponible
2	Délai d'expiration BRPOP key1 [key2] Supprime et récupère le dernier élément d'une liste, ou bloque jusqu'à ce qu'il en soit un disponible
3	Délai d'expiration de la destination source BRPOPLPUSH Saute une valeur dans une liste, la pousse dans une autre liste et la renvoie; ou bloque jusqu'à ce qu'il y en ait un disponible
4	Index de clé LINDEX Obtient un élément d'une liste par son index
5	Touche LINSERT BEFORE | AFTER valeur pivot Insère un élément avant ou après un autre élément dans une liste
6	Touche LLEN Obtient la longueur d'une liste
sept	Clé LPOP Supprime et récupère le premier élément d'une liste
8	Clé LPUSH valeur1 [valeur2] Ajoute une ou plusieurs valeurs à une liste
9	Valeur de clé LPUSHX Ajoute une valeur à une liste, uniquement si la liste existe
dix	Touche LRANGE start stop Obtient une plage d'éléments d'une liste
11	Valeur du nombre de clés LREM Supprime des éléments d'une liste
12	Valeur d'index de clé LSET Définit la valeur d'un élément dans une liste par son index
13	Touche LTRIM start stop Ajuste une liste à la plage spécifiée
14	Clé RPOP Supprime et récupère le dernier élément d'une liste
15	Destination source RPOPLPUSH Supprime le dernier élément d'une liste, l'ajoute à une autre liste et le renvoie
16	RPUSH clé valeur1 [valeur2] Ajoute une ou plusieurs valeurs à une liste
17	Valeur de clé RPUSHX Ajoute une valeur à une liste, uniquement si la liste existe

Les ensembles Redis sont une collection non ordonnée de chaînes uniques. Les ensembles de moyens uniques ne permettent pas la répétition des données dans une clé.

Dans l'ensemble Redis, ajoutez, supprimez et testez l'existence de membres dans O (1) (temps constant quel que soit le nombre d'éléments contenus dans l'ensemble). La longueur maximale d'une liste est de 2 ³² - 1 éléments (4294967295, plus de 4 milliards d'éléments par ensemble).

Exemple

redis 127.0.0.1:6379> SADD tutorials redis 
(integer) 1 
redis 127.0.0.1:6379> SADD tutorials mongodb 
(integer) 1 
redis 127.0.0.1:6379> SADD tutorials mysql 
(integer) 1 
redis 127.0.0.1:6379> SADD tutorials mysql 
(integer) 0 
redis 127.0.0.1:6379> SMEMBERS tutorials  
1) "mysql" 
2) "mongodb" 
3) "redis"

Dans l'exemple ci-dessus, trois valeurs sont insérées dans l'ensemble Redis nommé 'tutorials' par la commande SADD.

Commandes des ensembles Redis

Le tableau suivant répertorie certaines commandes de base liées aux ensembles.

Sr.Non	Commande et description
1	Clé SADD membre1 [membre2] Ajoute un ou plusieurs membres à un ensemble
2	Touche SCARD Obtient le nombre de membres dans un ensemble
3	SDIFF clé1 [clé2] Soustrait plusieurs ensembles
4	SDIFFSTORE destination key1 [key2] Soustrait plusieurs ensembles et stocke l'ensemble résultant dans une clé
5	SINTER key1 [key2] Intersecte plusieurs ensembles
6	SINTERSTORE destination key1 [key2] Intersecte plusieurs ensembles et stocke l'ensemble résultant dans une clé
sept	Membre clé du SISMEMBER Détermine si une valeur donnée est membre d'un ensemble
8	Touche SMEMBERS Obtient tous les membres d'un ensemble
9	Membre de destination source SMOVE Déplace un membre d'un ensemble à un autre
dix	Touche SPOP Supprime et renvoie un membre aléatoire d'un ensemble
11	Clé SRANDMEMBER [count] Obtient un ou plusieurs membres aléatoires d'un ensemble
12	Clé SREM membre1 [membre2] Supprime un ou plusieurs membres d'un ensemble
13	SUNION clé1 [clé2] Ajoute plusieurs ensembles
14	SUNIONSTORE destination key1 [key2] Ajoute plusieurs ensembles et stocke l'ensemble résultant dans une clé
15	Curseur de la touche SSCAN [Modèle MATCH] [COUNT count] Itère incrémentalement les éléments de l'ensemble

Les ensembles triés Redis sont similaires aux ensembles Redis avec la caractéristique unique de valeurs stockées dans un ensemble. La différence est que chaque membre d'un ensemble trié est associé à un score, qui est utilisé pour prendre l'ensemble trié ordonné, du plus petit au plus grand score.

Dans l'ensemble trié Redis, ajoutez, supprimez et testez l'existence de membres dans O (1) (temps constant quel que soit le nombre d'éléments contenus dans l'ensemble). La longueur maximale d'une liste est de 2 ³² - 1 éléments (4294967295, plus de 4 milliards d'éléments par ensemble).

Exemple

redis 127.0.0.1:6379> ZADD tutorials 1 redis 
(integer) 1 
redis 127.0.0.1:6379> ZADD tutorials 2 mongodb 
(integer) 1 
redis 127.0.0.1:6379> ZADD tutorials 3 mysql 
(integer) 1 
redis 127.0.0.1:6379> ZADD tutorials 3 mysql 
(integer) 0 
redis 127.0.0.1:6379> ZADD tutorials 4 mysql 
(integer) 0 
redis 127.0.0.1:6379> ZRANGE tutorials 0 10 WITHSCORES  
1) "redis" 
2) "1" 
3) "mongodb" 
4) "2" 
5) "mysql" 
6) "4"

Dans l'exemple ci-dessus, trois valeurs sont insérées avec son score dans l'ensemble trié Redis nommé `` tutoriels '' par la commande ZADD.

Commandes d'ensembles triés Redis

Le tableau suivant répertorie certaines commandes de base liées aux ensembles triés.

Sr.Non	Commande et description
1	Clé ZADD score1 membre1 [score2 membre2] Ajoute un ou plusieurs membres à un ensemble trié, ou met à jour son score, s'il existe déjà
2	Touche ZCARD Obtient le nombre de membres dans un ensemble trié
3	Touche ZCOUNT min max Compte les membres dans un ensemble trié avec des scores dans les valeurs données
4	Membre d'incrémentation de clé ZINCRBY Incrémente le score d'un membre dans un ensemble trié
5	Touche numérique de destination ZINTERSTORE [touche ...] Intersecte plusieurs ensembles triés et stocke l'ensemble trié résultant dans une nouvelle clé
6	Touche ZLEXCOUNT min max Compte le nombre de membres dans un ensemble trié entre une plage lexicographique donnée
sept	Touche ZRANGE start stop [WITHSCORES] Renvoie une plage de membres dans un ensemble trié, par index
8	Touche ZRANGEBYLEX min max [LIMIT offset count] Renvoie une plage de membres dans un ensemble trié, par plage lexicographique
9	ZRANGEBYSCORE clé min max [WITHSCORES] [LIMIT] Renvoie une plage de membres dans un ensemble trié, par score
dix	Membre clé de ZRANK Détermine l'index d'un membre dans un ensemble trié
11	Membre clé de ZREM [membre ...] Supprime un ou plusieurs membres d'un ensemble trié
12	Touche ZREMRANGEBYLEX min max Supprime tous les membres d'un ensemble trié entre la plage lexicographique donnée
13	Touche ZREMRANGEBYRANK start stop Supprime tous les membres d'un ensemble trié dans les index donnés
14	Touche ZREMRANGEBYSCORE min max Supprime tous les membres d'un ensemble trié dans les scores donnés
15	Touche ZREVRANGE start stop [WITHSCORES] Renvoie une plage de membres dans un ensemble trié, par index, avec des scores classés de haut en bas
16	Touche ZREVRANGEBYSCORE min. Max. [WITHSCORES] Renvoie une plage de membres dans un ensemble trié, par score, avec des scores classés de haut en bas
17	Membre clé de ZREVRANK Détermine l'index d'un membre dans un ensemble trié, avec des scores classés de haut en bas
18	Membre clé de ZSCORE Obtient le score associé au membre donné dans un ensemble trié
19	ZUNIONSTORE destination numkeys touche [touche ...] Ajoute plusieurs ensembles triés et stocke l'ensemble trié résultant dans une nouvelle clé
20	Curseur de la touche ZSCAN [Modèle MATCH] [COUNT count] Itère incrémentalement les éléments des ensembles triés et les scores associés

Redis HyperLogLog est un algorithme qui utilise la randomisation afin de fournir une approximation du nombre d'éléments uniques dans un ensemble en utilisant juste une constante et une petite quantité de mémoire.

HyperLogLog fournit une très bonne approximation de la cardinalité d'un ensemble même en utilisant une très petite quantité de mémoire autour de 12 ko par clé avec une erreur standard de 0,81%. Il n'y a pas de limite au nombre d'éléments que vous pouvez compter, sauf si vous approchez 2 ⁶⁴ éléments.

Exemple

L'exemple suivant explique le fonctionnement de Redis HyperLogLog.

redis 127.0.0.1:6379> PFADD tutorials "redis"  
1) (integer) 1  
redis 127.0.0.1:6379> PFADD tutorials "mongodb"  
1) (integer) 1  
redis 127.0.0.1:6379> PFADD tutorials "mysql"  
1) (integer) 1  
redis 127.0.0.1:6379> PFCOUNT tutorials  
(integer) 3

Commandes Redis HyperLogLog

Le tableau suivant répertorie certaines commandes de base liées à Redis HyperLogLog.

Sr.Non	Commande et description
1	Élément clé PFADD [élément ...] Ajoute les éléments spécifiés au HyperLogLog spécifié.
2	Touche PFCOUNT [clé ...] Renvoie la cardinalité approximative du ou des ensembles observés par HyperLogLog au (x) clé (s).
3	PFMERGE destkey sourcekey [sourcekey ...] Fusionne N HyperLogLogs différents en un seul.

Redis Pub / Sub implémente le système de messagerie où les expéditeurs (dans la terminologie redis appelés éditeurs) envoient les messages tandis que les destinataires (abonnés) les reçoivent. Le lien par lequel les messages sont transférés est appeléchannel.

Dans Redis, un client peut s'abonner à n'importe quel nombre de canaux.

Exemple

L'exemple suivant explique comment fonctionne le concept d'abonné de publication. Dans l'exemple suivant, un client s'abonne à un canal nommé «redisChat».

redis 127.0.0.1:6379> SUBSCRIBE redisChat  
Reading messages... (press Ctrl-C to quit) 
1) "subscribe" 
2) "redisChat" 
3) (integer) 1

Maintenant, deux clients publient les messages sur le même canal nommé «redisChat» et le client abonné ci-dessus reçoit des messages.

redis 127.0.0.1:6379> PUBLISH redisChat "Redis is a great caching technique"  
(integer) 1  
redis 127.0.0.1:6379> PUBLISH redisChat "Learn redis by tutorials point"  
(integer) 1   
1) "message" 
2) "redisChat" 
3) "Redis is a great caching technique" 
1) "message" 
2) "redisChat" 
3) "Learn redis by tutorials point"

Commandes Redis PubSub

Le tableau suivant répertorie certaines commandes de base liées à Redis Pub / Sub.

Sr.Non	Commande et description
1	Motif PSUBSCRIBE [motif ...] S'abonne aux chaînes correspondant aux modèles donnés.
2	Sous-commande PUBSUB [argument [argument ...]] Indique l'état du système Pub / Sub. Par exemple, quels clients sont actifs sur le serveur.
3	PUBLIER le message de la chaîne Publie un message sur une chaîne.
4	PUNSUBSCRIBE [modèle [modèle ...]] Arrête d'écouter les messages publiés sur les canaux correspondant aux modèles donnés.
5	SUBSCRIBE channel [canal ...] Écoute les messages publiés sur les canaux donnés.
6	UNSUBSCRIBE [canal [canal ...]] Stops listening for messages posted to the given channels.

Redis transactions allow the execution of a group of commands in a single step. Following are the two properties of Transactions.

• All commands in a transaction are sequentially executed as a single isolated operation. It is not possible that a request issued by another client is served in the middle of the execution of a Redis transaction.

• Redis transaction is also atomic. Atomic means either all of the commands or none are processed.

Sample

Redis transaction is initiated by command MULTI and then you need to pass a list of commands that should be executed in the transaction, after which the entire transaction is executed by EXEC command.

redis 127.0.0.1:6379> MULTI 
OK 
List of commands here 
redis 127.0.0.1:6379> EXEC

Example

Following example explains how Redis transaction can be initiated and executed.

redis 127.0.0.1:6379> MULTI 
OK 
redis 127.0.0.1:6379> SET tutorial redis 
QUEUED 
redis 127.0.0.1:6379> GET tutorial 
QUEUED 
redis 127.0.0.1:6379> INCR visitors 
QUEUED 
redis 127.0.0.1:6379> EXEC  
1) OK 
2) "redis" 
3) (integer) 1

Redis Transaction Commands

Following table shows some basic commands related to Redis transactions.

Sr.No	Command & Description
1	DISCARD Discards all commands issued after MULTI
2	EXEC Executes all commands issued after MULTI
3	MULTI Marks the start of a transaction block
4	UNWATCH Forgets about all watched keys
5	WATCH key [key ...] Watches the given keys to determine the execution of the MULTI/EXEC block

Redis scripting is used to evaluate scripts using the Lua interpreter. It is built into Redis starting from version 2.6.0. The command used for scripting is EVAL command.

Syntax

Following is the basic syntax of EVAL command.

redis 127.0.0.1:6379> EVAL script numkeys key [key ...] arg [arg ...]

Example

Following example explains how Redis scripting works.

redis 127.0.0.1:6379> EVAL "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 
key2 first second  
1) "key1" 
2) "key2" 
3) "first" 
4) "second"

Redis Scripting Commands

Following table lists some basic commands related to Redis Scripting.

Sr.No	Command & Description
1	EVAL script numkeys key [key ...] arg [arg ...] Executes a Lua script.
2	EVALSHA sha1 numkeys key [key ...] arg [arg ...] Executes a Lua script.
3	SCRIPT EXISTS script [script ...] Checks the existence of scripts in the script cache.
4	SCRIPT FLUSH Removes all the scripts from the script cache.
5	SCRIPT KILL Kills the script currently in execution.
6	SCRIPT LOAD script Loads the specified Lua script into the script cache.

Redis connection commands are basically used to manage client connections with Redis server.

Example

Following example explains how a client authenticates itself to Redis server and checks whether the server is running or not.

redis 127.0.0.1:6379> AUTH "password" 
OK 
redis 127.0.0.1:6379> PING 
PONG

Redis Connection Commands

Following table lists some basic commands related to Redis connections.

Sr.No	Command & Description
1	AUTH password Authenticates to the server with the given password
2	ECHO message Prints the given string
3	PING Checks whether the server is running or not
4	QUIT Closes the current connection
5	SELECT index Changes the selected database for the current connection

Redis server commands are basically used to manage Redis server.

Example

Following example explains how we can get all statistics and information about the server.

redis 127.0.0.1:6379> INFO  

# Server 
redis_version:2.8.13 
redis_git_sha1:00000000 
redis_git_dirty:0 
redis_build_id:c2238b38b1edb0e2 
redis_mode:standalone 
os:Linux 3.5.0-48-generic x86_64 
arch_bits:64 
multiplexing_api:epoll 
gcc_version:4.7.2 
process_id:3856 
run_id:0e61abd297771de3fe812a3c21027732ac9f41fe 
tcp_port:6379 
uptime_in_seconds:11554 
uptime_in_days:0 hz:10 
lru_clock:16651447 
config_file:  

# Clients 
connected_clients:1
client_longest_output_list:0 
client_biggest_input_buf:0 
blocked_clients:0  

# Memory 
used_memory:589016 
used_memory_human:575.21K 
used_memory_rss:2461696 
used_memory_peak:667312 
used_memory_peak_human:651.67K 
used_memory_lua:33792 
mem_fragmentation_ratio:4.18 
mem_allocator:jemalloc-3.6.0  

# Persistence 
loading:0 
rdb_changes_since_last_save:3 
rdb_bgsave_in_progress:0 
rdb_last_save_time:1409158561 
rdb_last_bgsave_status:ok 
rdb_last_bgsave_time_sec:0 
rdb_current_bgsave_time_sec:-1 
aof_enabled:0 
aof_rewrite_in_progress:0 
aof_rewrite_scheduled:0 
aof_last_rewrite_time_sec:-1 
aof_current_rewrite_time_sec:-1 
aof_last_bgrewrite_status:ok 
aof_last_write_status:ok  

# Stats 
total_connections_received:24 
total_commands_processed:294 
instantaneous_ops_per_sec:0 
rejected_connections:0 
sync_full:0 
sync_partial_ok:0 
sync_partial_err:0 
expired_keys:0 
evicted_keys:0 
keyspace_hits:41
keyspace_misses:82 
pubsub_channels:0 
pubsub_patterns:0 
latest_fork_usec:264  

# Replication 
role:master 
connected_slaves:0 
master_repl_offset:0 
repl_backlog_active:0 
repl_backlog_size:1048576 
repl_backlog_first_byte_offset:0 
repl_backlog_histlen:0  

# CPU 
used_cpu_sys:10.49 
used_cpu_user:4.96 
used_cpu_sys_children:0.00 
used_cpu_user_children:0.01  

# Keyspace 
db0:keys = 94,expires = 1,avg_ttl = 41638810 
db1:keys = 1,expires = 0,avg_ttl = 0 
db3:keys = 1,expires = 0,avg_ttl = 0

Redis Server Commands

Following table lists some basic commands related to Redis server.

Sr.No	Command & Description
1	BGREWRITEAOF Asynchronously rewrites the append-only file
2	BGSAVE Asynchronously saves the dataset to the disk
3	CLIENT KILL [ip:port] [ID client-id] Kills the connection of a client
4	CLIENT LIST Gets the list of client connections to the server
5	CLIENT GETNAME Gets the name of the current connection
6	CLIENT PAUSE timeout Stops processing commands from the clients for a specified time
7	CLIENT SETNAME connection-name Sets the current connection name
8	CLUSTER SLOTS Gets an array of Cluster slot to node mappings
9	COMMAND Gets an array of Redis command details
10	COMMAND COUNT Gets total number of Redis commands
11	COMMAND GETKEYS Extracts the keys given a full Redis command
12	BGSAVE Asynchronously saves the dataset to the disk
13	COMMAND INFO command-name [command-name ...] Gets an array of specific Redis command details
14	CONFIG GET parameter Gets the value of a configuration parameter
15	CONFIG REWRITE Rewrites the configuration file with the in-memory configuration
16	CONFIG SET parameter value Sets a configuration parameter to the given value
17	CONFIG RESETSTAT Resets the stats returned by INFO
18	DBSIZE Returns the number of keys in the selected database
19	DEBUG OBJECT key Gets debugging information about a key
20	DEBUG SEGFAULT Makes the server crash
21	FLUSHALL Removes all the keys from all databases
22	FLUSHDB Removes all the keys from the current database
23	INFO [section] Gets information and statistics about the server
24	LASTSAVE Gets the UNIX time stamp of the last successful save to the disk
25	MONITOR Listens for all the requests received by the server in real time
26	ROLE Returns the role of the instance in the context of replication
27	SAVE Synchronously saves the dataset to the disk
28	SHUTDOWN [NOSAVE] [SAVE] Synchronously saves the dataset to the disk and then shuts down the server
29	SLAVEOF host port Makes the server a slave of another instance, or promotes it as a master
30	SLOWLOG subcommand [argument] Manages the Redis slow queries log
31	SYNC Command used for replication
32	TIME Returns the current server time

Redis SAVE command is used to create a backup of the current Redis database.

Syntax

Following is the basic syntax of redis SAVE command.

127.0.0.1:6379> SAVE

Example

Following example creates a backup of the current database.

127.0.0.1:6379> SAVE  
OK

This command will create a dump.rdb file in your Redis directory.

Restore Redis Data

To restore Redis data, move Redis backup file (dump.rdb) into your Redis directory and start the server. To get your Redis directory, use CONFIG command of Redis as shown below.

127.0.0.1:6379> CONFIG get dir  
1) "dir" 
2) "/user/tutorialspoint/redis-2.8.13/src"

In the output of the above command /user/tutorialspoint/redis-2.8.13/src is the directory, where Redis server is installed.

Bgsave

To create Redis backup, an alternate command BGSAVE is also available. This command will start the backup process and run this in the background.

Example

127.0.0.1:6379> BGSAVE  
Background saving started

Redis database can be secured, such that any client making a connection needs to authenticate before executing a command. To secure Redis, you need to set the password in the config file.

Example

Following example shows the steps to secure your Redis instance.

127.0.0.1:6379> CONFIG get requirepass 
1) "requirepass" 
2) ""

By default, this property is blank, which means no password is set for this instance. You can change this property by executing the following command.

127.0.0.1:6379> CONFIG set requirepass "tutorialspoint" 
OK 
127.0.0.1:6379> CONFIG get requirepass 
1) "requirepass" 
2) "tutorialspoint"

After setting the password, if any client runs the command without authentication, then (error) NOAUTH Authentication required. error will return. Hence, the client needs to use AUTH command to authenticate himself.

Syntax

Following is the basic syntax of AUTH command.

127.0.0.1:6379> AUTH password

Example

127.0.0.1:6379> AUTH "tutorialspoint" 
OK 
127.0.0.1:6379> SET mykey "Test value" 
OK 
127.0.0.1:6379> GET mykey 
"Test value"

Redis benchmark is the utility to check the performance of Redis by running n commands simultaneously.

Syntax

Following is the basic syntax of Redis benchmark.

redis-benchmark [option] [option value]

Example

Following example checks Redis by calling 100000 commands.

redis-benchmark -n 100000  

PING_INLINE: 141043.72 requests per second 
PING_BULK: 142857.14 requests per second 
SET: 141442.72 requests per second 
GET: 145348.83 requests per second 
INCR: 137362.64 requests per second 
LPUSH: 145348.83 requests per second 
LPOP: 146198.83 requests per second 
SADD: 146198.83 requests per second 
SPOP: 149253.73 requests per second 
LPUSH (needed to benchmark LRANGE): 148588.42 requests per second 
LRANGE_100 (first 100 elements): 58411.21 requests per second 
LRANGE_300 (first 300 elements): 21195.42 requests per second 
LRANGE_500 (first 450 elements): 14539.11 requests per second 
LRANGE_600 (first 600 elements): 10504.20 requests per second 
MSET (10 keys): 93283.58 requests per second

Following is a list of available options in Redis benchmark.

Sr.No	Option	Description	Default Value
1	-h	Specifies server host name	127.0.0.1
2	-p	Specifies server port	6379
3	-s	Specifies server socket
4	-c	Specifies the number of parallel connections	50
5	-n	Specifies the total number of requests	10000
6	-d	Specifies data size of SET/GET value in bytes	2
7	-k	1=keep alive, 0=reconnect	1
8	-r	Use random keys for SET/GET/INCR, random values for SADD
9	-p	Pipeline <numreq> requests	1
10	-h	Specifies server host name
11	-q	Forces Quiet to Redis. Just shows query/sec values
12	--csv	Output in CSV format
13	-l	Generates loop, Run the tests forever
14	-t	Only runs the comma-separated list of tests
15	-I	Idle mode. Just opens N idle connections and wait

Example

Following example shows the multiple usage options in Redis benchmark utility.

redis-benchmark -h 127.0.0.1 -p 6379 -t set,lpush -n 100000 -q  

SET: 146198.83 requests per second 
LPUSH: 145560.41 requests per second

Redis accepts clients’ connections on the configured listening TCP port and on the Unix socket, if enabled. When a new client connection is accepted, the following operations are performed −

• The client socket is put in non-blocking state since Redis uses multiplexing and non-blocking I/O.

• The TCP_NODELAY option is set in order to ensure that we don't have delays in our connection.

• A readable file event is created so that Redis is able to collect the client queries as soon as new data is available to be read on the socket.

Maximum Number of Clients

In Redis config (redis.conf), there is a property called maxclients, which describes the maximum number of clients that can connect to Redis.

Following is the basic syntax of command.

config get maxclients  

1) "maxclients" 
2) "10000"

By default, this property is set to 10000 (depending upon the maximum number of file descriptors limit of OS), although you can change this property.

Example

In the following example, we have set the maximum number of clients to 100000, while starting the server.

redis-server --maxclients 100000

Client Commands

Sr.No	Command	Description
1	CLIENT LIST	Returns the list of clients connected to Redis server
2	CLIENT SETNAME	Assigns a name to the current connection
3	CLIENT GETNAME	Returns the name of the current connection as set by CLIENT SETNAME
4	CLIENT PAUSE	This is a connections control command able to suspend all the Redis clients for the specified amount of time (in milliseconds)
5	CLIENT KILL	This command closes a given client connection.

Redis is a TCP server and supports request/response protocol. In Redis, a request is accomplished with the following steps −

• The client sends a query to the server, and reads from the socket, usually in a blocking way, for the server response.

• The server processes the command and sends the response back to the client.

Meaning of Pipelining

The basic meaning of pipelining is, the client can send multiple requests to the server without waiting for the replies at all, and finally reads the replies in a single step.

Exemple

Pour vérifier le pipeline Redis, démarrez simplement l'instance Redis et tapez la commande suivante dans le terminal.

$(echo -en "PING\r\n SET tutorial redis\r\nGET tutorial\r\nINCR 
visitor\r\nINCR visitor\r\nINCR visitor\r\n"; sleep 10) | nc localhost 6379  
+PONG 
+OK 
redis 
:1 
:2 
:3

Dans l'exemple ci-dessus, nous vérifierons la connexion Redis en utilisant PINGcommander. Nous avons défini une chaîne nomméetutorial avec valeur redis. Plus tard, nous obtenons cette valeur de clé et incrémentons le nombre de visiteurs trois fois. Dans le résultat, nous pouvons voir que toutes les commandes sont soumises à Redis une fois, et Redis fournit la sortie de toutes les commandes en une seule étape.

Avantages du pipelining

L'avantage de cette technique est une performance de protocole considérablement améliorée. L'accélération obtenue par le pipelining va d'un facteur de cinq pour les connexions à l'hôte local jusqu'à un facteur d'au moins cent sur des connexions Internet plus lentes.

Le partitionnement est le processus de division de vos données en plusieurs instances Redis, de sorte que chaque instance ne contiendra qu'un sous-ensemble de vos clés.

Avantages du partitionnement

• Il permet des bases de données beaucoup plus volumineuses, en utilisant la somme de la mémoire de nombreux ordinateurs. Sans partitionnement, vous êtes limité à la quantité de mémoire qu'un seul ordinateur peut prendre en charge.

• Il permet d'étendre la puissance de calcul à plusieurs cœurs et plusieurs ordinateurs, et la bande passante réseau à plusieurs ordinateurs et adaptateurs réseau.

Inconvénients du partitionnement

• Les opérations impliquant plusieurs clés ne sont généralement pas prises en charge. Par exemple, vous ne pouvez pas effectuer l'intersection entre deux ensembles s'ils sont stockés dans les clés qui sont mappées à différentes instances Redis.

• Les transactions Redis impliquant plusieurs clés ne peuvent pas être utilisées.

• Le granuliaire de partitionnement est la clé, il n'est donc pas possible de partitionner un ensemble de données avec une seule clé énorme comme un très grand ensemble trié.

• Lorsque le partitionnement est utilisé, la gestion des données est plus complexe. Par exemple, vous devez gérer plusieurs fichiers RDB / AOF et pour obtenir une sauvegarde de vos données, vous devez agréger les fichiers de persistance de plusieurs instances et hôtes.

• L'ajout et la suppression de la capacité peuvent être complexes. Par exemple, Redis Cluster prend en charge le rééquilibrage principalement transparent des données avec la possibilité d'ajouter et de supprimer des nœuds au moment de l'exécution. Cependant, d'autres systèmes comme le partitionnement côté client et les proxys ne prennent pas en charge cette fonctionnalité. Une technique appeléePresharding aide à cet égard.

Types de partitionnement

Il existe deux types de partitionnement disponibles dans Redis. Supposons que nous ayons quatre instances Redis, R0, R1, R2, R3 et de nombreuses clés représentant des utilisateurs tels que user: 1, user: 2, ... et ainsi de suite.

Partitionnement de plage

Le partitionnement de plage est réalisé en mappant des plages d'objets dans des instances Redis spécifiques. Supposons que dans notre exemple, les utilisateurs de l'ID 0 à l'ID 10000 iront dans l'instance R0, tandis que les utilisateurs de l'ID 10001 à l'ID 20000 iront dans l'instance R1 et ainsi de suite.

Partitionnement de hachage

Dans ce type de partitionnement, une fonction de hachage (par exemple, une fonction de module) est utilisée pour convertir la clé en un nombre, puis les données sont stockées dans des instances Redis différentes.

Avant de commencer à utiliser Redis dans vos programmes Java, vous devez vous assurer que le pilote Redis Java et Java sont configurés sur la machine. Vous pouvez consulter notre tutoriel Java pour l'installation de Java sur votre machine.

Installation

Voyons maintenant comment configurer le pilote Redis Java.

• Vous devez télécharger le pot à partir du chemin Download jedis.jar. Assurez-vous de télécharger la dernière version de celui-ci.

• Vous devez inclure le jedis.jar dans votre chemin de classe.

Connectez-vous au serveur Redis

import redis.clients.jedis.Jedis; 

public class RedisJava { 
   public static void main(String[] args) { 
      //Connecting to Redis server on localhost 
      Jedis jedis = new Jedis("localhost"); 
      System.out.println("Connection to server sucessfully"); 
      //check whether server is running or not 
      System.out.println("Server is running: "+jedis.ping()); 
   } 
}

Maintenant, compilons et exécutons le programme ci-dessus pour tester la connexion au serveur Redis. Vous pouvez changer votre chemin selon vos besoins. Nous supposons que la version actuelle dejedis.jar est disponible dans le chemin actuel.

$javac RedisJava.java 
$java RedisJava 
Connection to server sucessfully 
Server is running: PONG

Exemple de chaîne Java Redis

import redis.clients.jedis.Jedis; 

public class RedisStringJava { 
   public static void main(String[] args) { 
      //Connecting to Redis server on localhost 
      Jedis jedis = new Jedis("localhost"); 
      System.out.println("Connection to server sucessfully"); 
      //set the data in redis string 
      jedis.set("tutorial-name", "Redis tutorial"); 
      // Get the stored data and print it 
      System.out.println("Stored string in redis:: "+ jedis.get("tutorialname")); 
   } 
}

Maintenant, compilons et exécutons le programme ci-dessus.

$javac RedisStringJava.java 
$java RedisStringJava 
Connection to server sucessfully 
Stored string in redis:: Redis tutorial

Exemple de liste Java Redis

import redis.clients.jedis.Jedis; 

public class RedisListJava { 
   public static void main(String[] args) { 
   
      //Connecting to Redis server on localhost 
      Jedis jedis = new Jedis("localhost"); 
      System.out.println("Connection to server sucessfully"); 
      
      //store data in redis list 
      jedis.lpush("tutorial-list", "Redis"); 
      jedis.lpush("tutorial-list", "Mongodb"); 
      jedis.lpush("tutorial-list", "Mysql"); 
      // Get the stored data and print it 
      List<String> list = jedis.lrange("tutorial-list", 0 ,5); 
      
      for(int i = 0; i<list.size(); i++) { 
         System.out.println("Stored string in redis:: "+list.get(i)); 
      } 
   } 
}

Maintenant, compilons et exécutons le programme ci-dessus.

$javac RedisListJava.java 
$java RedisListJava 
Connection to server sucessfully 
Stored string in redis:: Redis 
Stored string in redis:: Mongodb 
Stored string in redis:: Mysql

Exemple de clés Java Redis

import redis.clients.jedis.Jedis; 

public class RedisKeyJava { 
   public static void main(String[] args) { 
   
      //Connecting to Redis server on localhost 
      Jedis jedis = new Jedis("localhost"); 
      System.out.println("Connection to server sucessfully"); 
      //store data in redis list 
      // Get the stored data and print it 
      List<String> list = jedis.keys("*"); 
      
      for(int i = 0; i<list.size(); i++) { 
         System.out.println("List of stored keys:: "+list.get(i)); 
      } 
   } 
}

Maintenant, compilons et exécutons le programme ci-dessus.

$javac RedisKeyJava.java 
$java RedisKeyJava 
Connection to server sucessfully 
List of stored keys:: tutorial-name 
List of stored keys:: tutorial-list

Avant de commencer à utiliser Redis dans vos programmes PHP, vous devez vous assurer que le pilote PHP Redis et PHP sont configurés sur la machine. Vous pouvez consulter le didacticiel PHP pour l'installation de PHP sur votre machine.

Installation

Voyons maintenant comment configurer le pilote PHP Redis.

Vous devez télécharger le phpredis depuis le référentiel github https://github.com/nicolasff/phpredis. Une fois que vous l'avez téléchargé, extrayez les fichiers dans le répertoire phpredis. Sur Ubuntu, installez l'extension suivante.

cd phpredis 
sudo phpize 
sudo ./configure 
sudo make 
sudo make install

Maintenant, copiez et collez le contenu du dossier «modules» dans le répertoire de l'extension PHP et ajoutez les lignes suivantes dans php.ini.

extension = redis.so

Maintenant, votre installation Redis PHP est terminée

Connectez-vous au serveur Redis

<?php 
   //Connecting to Redis server on localhost 
   $redis = new Redis(); 
   $redis->connect('127.0.0.1', 6379); echo "Connection to server sucessfully"; //check whether server is running or not echo "Server is running: ".$redis->ping(); 
?>

Lorsque le programme est exécuté, il produira le résultat suivant.

Connection to server sucessfully 
Server is running: PONG

Exemple de chaîne PHP Redis

<?php 
   //Connecting to Redis server on localhost 
   $redis = new Redis(); $redis->connect('127.0.0.1', 6379); 
   echo "Connection to server sucessfully"; 
   //set the data in redis string 
   $redis->set("tutorial-name", "Redis tutorial"); // Get the stored data and print it echo "Stored string in redis:: " .$redis→get("tutorial-name"); 
?>

Lorsque le programme ci-dessus est exécuté, il produira le résultat suivant.

Connection to server sucessfully 
Stored string in redis:: Redis tutorial

Exemple de liste Redis php

<?php 
   //Connecting to Redis server on localhost 
   $redis = new Redis(); $redis->connect('127.0.0.1', 6379); 
   echo "Connection to server sucessfully"; 
   //store data in redis list 
   $redis->lpush("tutorial-list", "Redis"); $redis->lpush("tutorial-list", "Mongodb"); 
   $redis->lpush("tutorial-list", "Mysql"); // Get the stored data and print it $arList = $redis->lrange("tutorial-list", 0 ,5); echo "Stored string in redis:: "; print_r($arList); 
?>

Lorsque le programme ci-dessus est exécuté, il produira le résultat suivant.

Connection to server sucessfully 
Stored string in redis:: 
Redis 
Mongodb 
Mysql

Exemple de clés PHP Redis

<?php 
   //Connecting to Redis server on localhost 
   $redis = new Redis(); $redis->connect('127.0.0.1', 6379); 
   echo "Connection to server sucessfully"; 
   // Get the stored keys and print it 
   $arList = $redis->keys("*"); 
   echo "Stored keys in redis:: " 
   print_r($arList); 
?>

Lorsque le programme est exécuté, il produira le résultat suivant.

Connection to server sucessfully 
Stored string in redis:: 
tutorial-name 
tutorial-list