**Cette page a été importée automatiquement de notre ancien wiki mais n'a pas encore été révisée.**

# Howto Redis

Redis est un serveur noSQL clé-valeur. Une valeur peut être une chaîne de caractères, un tableau, une liste, etc.
Redis tourne en mémoire, et sauvegarde de temps en temps ses données sur le disque.

<http://redis.io/documentation>

## Installation

*Sous Debian Squeeze*, la version de Redis est 1.2.6 :

~~~
# aptitude install redis-server
~~~

Si l'on a besoin d'une version 2 de Redis, il faut
utiliser les backports Squeeze. Voici un pinning pour cela :

~~~
Package: redis-server
Pin: release a=squeeze-backports
Pin-Priority: 999
~~~

*Sous Debian Jessie*, on installe Redis de la même manière (version 2.8.1). Si on utilise systemd, on surcharge l'unit redis.service en spécifiant le RuntimeDirectory (voir la note
[wiki:HowtoDebian/MigrationWheezyJessie#Redis ici]).

## Configuration

La configuration principale se fait dans _/etc/redis/redis.conf_ dont voici
quelques options :

~~~
daemonize yes
pidfile /var/run/redis.pid
port 6379
unixsocket /var/run/redis/redis.sock
bind 127.0.0.1
timeout 300
loglevel notice
logfile /var/log/redis/redis-server.log
databases 16
save 900 1
save 300 10
save 60 10000
dbfilename dump.rdb
dir /var/lib/redis
#requirepass <password>
maxclients 128
maxmemory 104857600
~~~

La plupart des options sont reconfigurables en mode CLI via la commande _CONFIG SET_.
La liste des arguments peut être listée :

~~~
redis> CONFIG get *
 1) "dir"
 2) "/var/lib/redis"
 3) "dbfilename"
 4) "dump.rdb"
 5) "requirepass"
 6) (nil)
 7) "masterauth"
 8) (nil)
 9) "maxmemory"
10) "0"
~~~

## Utilisation

En mode CLI :

~~~
$ redis-cli -s /var/run/redis/redis.sock
$ redis-cli
redis 127.0.0.1:6379>
redis> set foo 3
OK
redis> get blabla
(nil)
redis> get foo
3
redis> keys *
1) "foo"
redis> mset un 1 deux 2 trois 3 quatre 4
OK
redis> keys *
1) "un"
2) "foo"
3) "deux"
4) "trois"
5) "quatre"
redis> *keys *r*
1) "four"
2) "three"
redis> get four
"4"
redis> del "trois" "quatre"
(integer) 2
~~~

Mais aussi en réseau (sans authentification, attention) :

~~~
$ telnet 127.0.0.1 6379
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
get foo
$1
3
quit
Connection closed by foreign host.
~~~

En PHP, il existe différentes bibliothèques. Nous utilisons principalement <http://github.com/nicolasff/phpredis>
et nous utilisons un fork pour avoir un packaging Debian propre :

~~~
$ git clone <https://github.com/gcolpart/phpredis>
$ cd phpredis
$ tar --exclude debian --exclude .git -cvzf ../php5-redis_0.1~git20120519.orig.tar.gz .
$ git-buildpackage -us -uc
~~~

## Sessions PHP avec Redis

Redis peut notamment être utilisé pour stocker les sessions PHP. Par exemple :

~~~
session.save_handler = redis
session.save_path = "tcp://127.0.0.1:6379?auth=<password>"
~~~

## Instances Redis

Il peut être pratique de lancer plusieurs instances Redis sur un même serveur.

Pour cela on copiera le fichier _redis.conf_ en ajustant les directives _pidfile_, _port_, _unixsocket_, _logfile_ et _dbfilename_.
Il faudrait ensuite copier le script d'init.d en ajustant les variables RUNDIR, PIDFILE, DAEMON_ARGS et DESC

## Sauvegardes

<http://redis.io/topics/persistence>

Par défaut, Redis sauvegarde de temps en temps ses données sur le disque (mode RDB persistence).
Il suffit donc de copier ce fichier pour sauvegarder une base Redis à chaud !

Pour restaurer les données, il suffira d'éteindre Redis, remettre en place le fichier RDB, et relancer Redis.

## Réplication

<http://redis.io/topics/replication>

Côté "slave" il suffit de mettre en place la configuration :

~~~
slaveof 192.0.43.10 6379
#masterauth <password>
~~~

Une fois le démon relancé on peut vérifier l'état de la réplication de la façon suivante :

~~~
#redis-cli -h X.X.X.X -p 6379 info replication
~~~

On peut arrêter la réplication et passer un slave en master

~~~
#redis-cli -h X.X.X.X -p 6379 slaveof no one
~~~

~~~
#redis-cli -h X.X.X.X -p 6379 info replication
# Replication
role:master
connected_slaves:1
master_repl_offset:631177410
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:630128835
repl_backlog_histlen:1048576
~~~

### Tests

On test une écriture sur le master, est-ce répliqué sur le slave ?


~~~
redis [master] 127.0.0.1:6379> set key value
redis [slave] 127.0.0.1:6379> get key
~~~

On devrait avoir « value ». Par ailleurs on pourra lire dans les logs du slave (/var/log/redis/redis-server.log) :

~~~
[26287] 06 Sep 15:04:04 * MASTER <-> SLAVE sync: receiving 34 bytes from master
~~~

Depuis redis 2.6 (2.4 en Wheezy), par défaut, le slave est en read-only, on peut le passer en read & write, en mettant ceci dans la configuration du slave :

~~~
slave-read-only off
~~~

### Sentinel

Sentinel permet de faire du failover avec des slaves Redis.
Attention, il est encore en développement. Il est donc dans la branche instable du dépôt de redis.
Par ememple, une instance master redis1 et un slave redis2. En cas de panne les rôles s'échangent, redis2 devient master et redis1 devient le slave.

## Benchmarks

<http://redis.io/topics/benchmarks>

~~~
redis-benchmark -n 100000
=##### PING (inline)=
  100000 requests completed in 1.88 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

97.82% <= 1 milliseconds
99.80% <= 2 milliseconds
99.89% <= 3 milliseconds
99.93% <= 4 milliseconds
99.93% <= 5 milliseconds
100.00% <= 6 milliseconds
100.00% <= 6 milliseconds
53276.50 requests per second

=##### PING=
  100000 requests completed in 1.97 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

93.58% <= 1 milliseconds
99.36% <= 2 milliseconds
99.61% <= 3 milliseconds
99.71% <= 4 milliseconds
99.81% <= 5 milliseconds
99.87% <= 6 milliseconds
99.88% <= 7 milliseconds
99.88% <= 8 milliseconds
99.92% <= 10 milliseconds
99.93% <= 11 milliseconds
99.93% <= 12 milliseconds
99.95% <= 13 milliseconds
100.00% <= 13 milliseconds
50761.42 requests per second

=##### MSET (10 keys)=
  100000 requests completed in 3.12 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

19.71% <= 1 milliseconds
91.36% <= 2 milliseconds
98.93% <= 3 milliseconds
99.66% <= 4 milliseconds
99.75% <= 5 milliseconds
99.76% <= 8 milliseconds
99.77% <= 9 milliseconds
99.77% <= 10 milliseconds
99.80% <= 11 milliseconds
99.80% <= 14 milliseconds
99.85% <= 15 milliseconds
99.89% <= 22 milliseconds
99.89% <= 23 milliseconds
99.94% <= 24 milliseconds
99.95% <= 160 milliseconds
99.95% <= 208 milliseconds
99.95% <= 245 milliseconds
99.95% <= 246 milliseconds
100.00% <= 246 milliseconds
32020.49 requests per second

=##### SET=
  100000 requests completed in 1.86 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

97.80% <= 1 milliseconds
99.78% <= 2 milliseconds
99.84% <= 3 milliseconds
99.87% <= 4 milliseconds
99.93% <= 5 milliseconds
99.95% <= 10 milliseconds
99.96% <= 11 milliseconds
100.00% <= 12 milliseconds
100.00% <= 12 milliseconds
53850.30 requests per second

=##### GET=
  100000 requests completed in 2.02 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

91.26% <= 1 milliseconds
99.65% <= 2 milliseconds
99.86% <= 3 milliseconds
99.89% <= 4 milliseconds
99.92% <= 5 milliseconds
99.97% <= 7 milliseconds
100.00% <= 7 milliseconds
49407.12 requests per second

[etc.]
~~~

## Monitoring

### Nagios

Un check Nagios « basique » consiste à initier une connexion TCP sur le socket unix du serveur Redis, et s'assurer qu'il répond bien :

~~~
$ /usr/lib/nagios/plugins/check_tcp -H /var/run/redis.pid
~~~

Des checks Nagios avancés existent également, notamment pour surveiller la réplication ou pour retourner diverses info sur le status du serveur :

* <http://exchange.nagios.org/directory/Plugins/Others/check_redis/details>
* <https://github.com/shift/nagios-check-redis/>

Ces 2 plugins nécessitent de se connecter via un socket réseau au serveur, mais une [version antérieure](https://github.com/shift/nagios-check-redis/commit/16ee166aecd7b617c21dc8138a61829f506dc34c) de _nagios-check-redis_ supporte les sockets unix.

### Munin

* Un plugin Munin existe pour grapher divers paramètres comme la mémoire utilisée par Redis, le nombre de clés utiliséees, le nombre de requêtes par seconde, et le nombre de clients connectés.

~~~
# mkdir -p /usr/local/share/munin/plugins/
# cd /usr/local/share/munin/plugins/
# wget "https://raw.githubusercontent.com/munin-monitoring/contrib/master/plugins/redis/redis_"
# chmod -R 755 /usr/local/share/munin
# cd /etc/munin/plugins/
# for module in connected_clients key_ratio keys_per_sec per_sec used_keys used_memory; do ln -s /usr/local/share/munin/plugins/redis_ redis_${module}; done
~~~

Si vous avez un mot de passe à votre redis :

~~~
# cat /etc/munin/plugin-conf.d/munin-node 
[redis_*]
env.password PASSWORD
~~~