Redis: installazione e configurazione in Linux Centos 8, l'interfaccia da riga di comando e la configurazione del firewall.

di Giulio di Bari :: 25 settembre 2020

Redis è un database di tipo NoSQL, che salva i dati nella RAM anzichè su disco, come un insieme di coppie chiave-valore.

I database NoSQL si dividono in quattro differenti tipologie: chiave-valore, orientato ai documenti, a grafo, orientati alle colonne: Redis utilizza la tipologia "chiave-valore" in cui ogni singolo elemento viene salvato con una chiave assieme al suo valore.

Redis consente di salvare una vasta gamma di tipologie di dati tra sui: stringhe, liste, insiemi, insiemi ordinati, hash.

Questo rappresenta il primo di una serie di articoli dedicati a Redis. In questo articolo vediamo come installarlo in una distribuzione Centos8.

Installazione di Redis

Utilizziamo yum, o dnf, per installare Redis

# yum install redis

Ultimata l'installazione, per esser certi della sua installazione, e per conoscere la versione installata, digitiamo

# rpm -q redis

Otteniamo come risposta la versione installata

redis-5.0.3-2.module_el8.2.0+318+3d7e67ea.x86_64

Per avere informazioni aggiuntive sull'installazione effettuata aggiungiamo l'attributo "i"

# rpm -qi redis

Ecco il risultato

Name        : redis
Version     : 5.0.3
Release     : 2.module_el8.2.0+318+3d7e67ea
Architecture: x86_64
Install Date: Thu 24 Sep 2020 11:45:55 AM CEST
Group       : Unspecified
Size        : 3371025
License     : BSD and MIT
Signature   : RSA/SHA256, Tue 12 May 2020 04:51:49 PM CEST, Key ID 05b555b38483c65d
Source RPM  : redis-5.0.3-2.module_el8.2.0+318+3d7e67ea.src.rpm
Build Date  : Thu 07 May 2020 04:22:29 AM CEST
Build Host  : x86-01.mbox.centos.org
Relocations : (not relocatable)
Packager    : CentOS Buildsys <bugs@centos.org>
Vendor      : CentOS
URL         : http://redis.io
Summary     : A persistent key-value database
Description :
Redis is an advanced key-value store. It is often referred to as a data
structure server since keys can contain strings, hashes, lists, sets and
sorted sets.

You can run atomic operations on these types, like appending to a string;
incrementing the value in a hash; pushing to a list; computing set
intersection, union and difference; or getting the member with highest
ranking in a sorted set.

In order to achieve its outstanding performance, Redis works with an
in-memory dataset. Depending on your use case, you can persist it either
by dumping the dataset to disk every once in a while, or by appending
each command to a log.

Redis also supports trivial-to-setup master-slave replication, with very
fast non-blocking first synchronization, auto-reconnection on net split
and so forth.

Other features include Transactions, Pub/Sub, Lua scripting, Keys with a
limited time-to-live, and configuration settings to make Redis behave like
a cache.

You can use Redis from most programming languages also.

Avvio di Redis

Abbiamo ultimato l'installazione. Procediamo con l'avvio del servizio

# systemctl start redis

Per abilitare il servizio all'avvio automatico al riavvio del server

# systemctl enable redis

Per verificare lo stato del servizio

# systemctl status redis

Come possiamo vedere, redis è attivo

Di default, Redis utilizza la porta 6379 ed accetta connessioni solo dal server locale (127.0.0.1). Possiamo verificarlo con netstat.

# netstat -plunt
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.1:6379          0.0.0.0:*               LISTEN      31534/redis-server
tcp        0      0 0.0.0.0:5355            0.0.0.0:*               LISTEN      8730/systemd-resolv
............................................

Possiamo anche usare il comando "ss" per verificare che Redis è in ascolto sulla porta 6379

# ss -an | grep 6379
tcp  LISTEN   0   128    127.0.0.1:6379     0.0.0.0:*

Configurare Redis per connessioni remote

Come detto, di default Redis non consente connessioni remote ma solo da localhost. Possiamo cambiare questa impostazione modificando il file di configurazione di redis "redis.conf"

Utilizziamo ad esempi "vi" come editor

# vi /etc/redis.conf

Individuiamo la riga che inizia con "bind 127.0.0.1" e aggiungiamo a questo l'indirizzo IP del tuo server che dovrà connettersi, ad esempio 192.168.100.30

bind 127.0.0.1 192.168.100.30

Se invece vogliamo aprire Redis a tutte le connessioni remote indichiamo 0.0.0.0

bind 0.0.0.0

In alternativa basta commentare la riga.

Effettuata la modifica, riavviamo Redis

systemctl restart redis

Configurazione del firewall

Se abbiamo aperto Redis alle connessioni remote dobbiamo configurare il firewall per consentirne l'accesso.

Ipotizziamo di volere consentire l'accesso al server con IP 192.168.100.30

Se utilizziamo IPtables, aggiungiamo questa regola

# iptables -A INPUT -p tcp -s 192.168.100.30/32 --dport 6379 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT

Se invece utilizziamo Firewalld, aggiungiamo una nuova zona chiamata "redis", specifichiamo la porta tpc 6379 da aprire, e infine abilitiamo l'ip che può accedere.

# firewall-cmd --new-zone=redis --permanent

# firewall-cmd --zone=redis --add-port=6379/tcp --permanent

# firewall-cmd --zone=redis --add-source=192.168.100.30/32 --permanent

Ricorda di riavviare il firewall!

Redis Cli: interfaccia da riga di comando

Per verificare che tutto sia impostato correttamente, utilizzando l'interfaccia della riga di comando redis-cli, puoi provare a eseguire il ping del server Redis dal tuo computer (locale o remoto)

Se ci stiamo connettendo da locale

# redis-cli
127.0.0.1:6379> ping
PONG

Se tutto è ok, dovrebbe rispondere PONG !

Se invece ci stiamo connettendo da un server remoto dobbiamo indicare l'ip della macchina redis

# redis-cli -h IP-SERVER-REDIS

Redis Cli: accesso con password. Il comando AUTH

Questa interfaccia consente di accedere al database, e chiunque può accervi.

Per aumentare la sicurezza possiamo importare una password i, e per farlo modifichiamo il file di configurazione redis.conf, già visto in precedenza.

Cerchiamo l'istruzione commentata "requirepass"

# Warning: since Redis is pretty fast an outside user can try up to
# 150k passwords per second against a good box. This means that you should
# use a very strong password otherwise it will be very easy to break.
#
# requirepass foobared

# Command renaming.
#
# It is possible to change the name of dangerous commands in a shared
# environment. For instance the CONFIG command may be renamed into something
# hard to guess so that it will still be available for internal-use tools
# but not available for general clients.

Decommentiamola ed indichiamo una password, ad esempio "pipp@1234p!uto"

# Warning: since Redis is pretty fast an outside user can try up to
# 150k passwords per second against a good box. This means that you should
# use a very strong password otherwise it will be very easy to break.
#

requirepass pipp@1234p!uto

# Command renaming.
#
# It is possible to change the name of dangerous commands in a shared
# environment. For instance the CONFIG command may be renamed into something
# hard to guess so that it will still be available for internal-use tools
# but not available for general clients.

Adesso riavviamo Redis

# systemctl restart redis

Adesso, prova a fare il PING dall'interfaccia cli... e vedrai l'errore "NOAUTH Authentication required"

# redis-cli
127.0.0.1:6379> ping
(error) NOAUTH Authentication required.

Questo significa che prima di inserire qualunque comando, devi prima autenticarti con il comando "auth" seguito dalla password scelta. Inserita la password possiamo procedere con il ping.

# redis-cli
127.0.0.1:6379> auth pipp@1234p!uto
OK
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> exit

Per uscire dall'interfaccia cli, utilizziamo il comando exit.

Il comando INFO

Proseguiamo con l'utilizzo dell'interfaccia da linea di comando

Il comando "INFO" fornisce informazioni relative al sistema redise, suddivise per "sezioni"

# redis-cli
127.0.0.1:6379> INFO
NOAUTH Authentication required.
127.0.0.1:6379> auth pipp@1234p!uto
OK
127.0.0.1:6379> info
# Server
redis_version:5.0.3
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:28849dbea6f07cc8
redis_mode:standalone
os:Linux 4.18.0-147.3.1.el8_1.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll
atomicvar_api:atomic-builtin
gcc_version:8.3.1
process_id:31987
run_id:02a48761dd3b43eeffc3da363fee482fb40383a5
tcp_port:6379
uptime_in_seconds:14323
uptime_in_days:0
hz:10
configured_hz:10
lru_clock:7123111
executable:/usr/bin/redis-server
config_file:/etc/redis.conf

# Clients
connected_clients:1
client_recent_max_input_buffer:2
client_recent_max_output_buffer:0
blocked_clients:0

# Memory
used_memory:853976
used_memory_human:833.96K
used_memory_rss:9695232
used_memory_rss_human:9.25M
used_memory_peak:62669576
used_memory_peak_human:59.77M
used_memory_peak_perc:1.36%
used_memory_overhead:840782
used_memory_startup:791016
used_memory_dataset:13194
used_memory_dataset_perc:20.96%
allocator_allocated:844936
allocator_active:1056768
allocator_resident:4788224
total_system_memory:134646034432
total_system_memory_human:125.40G
used_memory_lua:37888
used_memory_lua_human:37.00K
used_memory_scripts:0
used_memory_scripts_human:0B
number_of_cached_scripts:0
maxmemory:0
maxmemory_human:0B
maxmemory_policy:noeviction
allocator_frag_ratio:1.25
allocator_frag_bytes:211832
allocator_rss_ratio:4.53
allocator_rss_bytes:3731456
rss_overhead_ratio:2.02
rss_overhead_bytes:4907008
mem_fragmentation_ratio:11.94
mem_fragmentation_bytes:8883248
mem_not_counted_for_evict:0
mem_replication_backlog:0
mem_clients_slaves:0
mem_clients_normal:49694
mem_aof_buffer:0
mem_allocator:jemalloc-5.1.0
active_defrag_running:0
lazyfree_pending_objects:0

# Persistence
loading:0
rdb_changes_since_last_save:0
rdb_bgsave_in_progress:0
rdb_last_save_time:1600953259
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:0
rdb_current_bgsave_time_sec:-1
rdb_last_cow_size:2220032
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
aof_last_cow_size:0

# Stats
total_connections_received:15175
total_commands_processed:12
instantaneous_ops_per_sec:0
total_net_input_bytes:465741562
total_net_output_bytes:378957284
instantaneous_input_kbps:0.02
instantaneous_output_kbps:0.00
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:0
expired_stale_perc:0.00
expired_time_cap_reached_count:0
evicted_keys:0
keyspace_hits:1
keyspace_misses:0
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:468
migrate_cached_sockets:0
slave_expires_tracked_keys:0
active_defrag_hits:0
active_defrag_misses:0
active_defrag_key_hits:0
active_defrag_key_misses:0

# Replication
role:master
connected_slaves:0
master_replid:950ac79844aa9f2da9e73649224c46733e045098
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

# CPU
used_cpu_sys:51.042462
used_cpu_user:16.254754
used_cpu_sys_children:0.000940
used_cpu_user_children:0.000000

# Cluster
cluster_enabled:0

# Keyspace
db0:keys=1,expires=0,avg_ttl=0

Per estrarre, ad esempio, solo le informazioni relativi alla sezione "server" utilizziamo il comando INFO: server

# redis-cli
127.0.0.1:6379> INFO: server

Il comando CLIENT LIST

Per conoscere il numero di client connessi a Redis utilizziamo il comando "client list": in questo momento siamo connessi solamente noi..

# redis-cli
127.0.0.1:6379> auth pipp@1234p!uto
OK
127.0.0.1:6379> client list
id=15178 addr=127.0.0.1:46782 fd=7 name= age=25 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 obl=0 oll=0 omem=0 events=r cmd=client

Il comando MONITOR

Possiamo monitorare Redis in tempo reale, e capire cosa sta succedendo al database, utilizzando il comando "monitor"

# redis-cli
127.0.0.1:6379> auth pipp@1234p!uto
OK
127.0.0.1:6379> monitor
OK

Ci occuperemo di Redis cli nei prossimo articoli in cui vedremo esempi di utilizzo di Redis.

Se volete testare online Redis Cli accedi a questo sito.

Limiti all'utilizzo della RAM

Nel file di configurazione "redis.conf" è possibile definire la quantità di memoria massima da utilizzare.

Individuiamo l'istruzione "maxmemory": di default è commentata, questo significa che non vengono impostati limiti di memoria.

Se ad esempio vogliamo impostare un limite a 8gb di ram, decommentiamo l'istruzione "maxmemory", e indichiamo quanto segue

maxmemory 8gb

Quando viene raggiunta la quantità di memoria specificata, è possibile specificare il comportamento che Redis dovrà avere: può restituire un errore oppure può eliminare alcuni vecchi dati (chiavi) il modo tale da rientrare nel mimite di ram impostata. Se optiamo per questa seconda possibilità occorre definire una "policy" cioè un comportamento tra quelli disponibili, utilizzando l'istruzione "maxmemory-policy".

Individuiamo questa istruzione del file di configurazione. Un esempio di policy è questa

maxmemory-policy allkeys-lru

Stiamo dicendo a Redis di cancellare tutte le chiavi salvate, quando viene raggiunta la memoria massima di 8GB, utilizzando l'algoritmo LRU. In merito all'algoritmo LRU (e l'algoritmo LFU) e alle policy si rimanda alla documentazione ufficiale nel link riportato a fondo articolo.

Nei prossimi articoli vedremo alcuni strumenti di benchmark per misurare le performance di Redis, l'utilizzo effettivo di Redis per gestire un database con alcuni esempi, e l'utilizzo in PHP.

Stay tuned!