# Tutorial su Redis: introduzione alla tecnologia dei database

Il sistema di database [Redis](https://www.ionos.it/digitalguide/hosting/tecniche-hosting/che-cose-redis/ "Che cos’è Redis?") è diventato sempre più popolare negli ultimi anni. I principali vantaggi sono la velocità e la struttura semplice dei database. I dati vengono scritti direttamente sulla memoria RAM del server e possono essere richiamati molto più velocemente rispetto ad altri database. Ecco perché Redis è spesso utilizzato come cache sul web. Ma anche i servizi di messaggistica utilizzano questo database per consentire una comunicazione rapida. Vi spieghiamo come installare il database Redis.

## Passaggio 1: installare Redis

Redis è open source e può quindi essere scaricato, utilizzato e modificato liberamente da tutti.

N.B. Di seguito descriviamo come installare e configurare Redis su Ubuntu. Tuttavia, è anche possibile lavorare con Mac o Windows. Se si desidera semplicemente provare Redis, senza installare il sistema, si consiglia l’ambiente di test online [Try Redis](http://try.redis.io/ "Try Redis sul sito web ufficiale di Redis").

Il primo passo **è scaricare Redis**. A tale scopo usiamo il gestore di pacchetti di Ubuntu, che prima di tutto deve essere aggiornato.

```none
sudo apt-get update
sudo apt-get install redis-server
```

In alternativa i file possono essere scaricati dal sito web ufficiale di Redis. Si deve quindi scompattare il pacchetto manualmente e infine installarlo. Dopodiché è possibile avviare Redis con un semplice comando.

```none
redis-server
```

Per verificare se Redis funziona correttamente, è necessario avviare per prima l’**interfaccia** che consente la comunicazione con Redis.

```none
redis-cli
```

Ora l’interfaccia mostra l’**indirizzo IP e la porta**, su cui è eseguito Redis. Si può pertanto effettuare il ping.

```none
127.0.0.1:6397> ping
PONG
```

Redis risponde, dimostrando così che il **sistema di database** è stato **installato con successo**. Si può inoltre verificare se è possibile introdurre contenuti.

```none
127.0.0.1:6397> set test "OK!"
127.0.0.1:6397> get test
"OK!"
```

N.B. Desiderate installare Redis sul vostro server? È possibile ridimensionare i [server cloud di IONOS](https://www.ionos.it/server/server-online "Cloud-Server mieten") anche per piccoli progetti.

## Passaggio 2: configurare Redis

Redis è stato installato innanzitutto con la **configurazione standard**, visualizzabile tramite un comando.

```none
127.0.0.1:6397> config get *
```

[![Immagine: Estratto del file di configurazione di Redis](https://www.ionos.it/digitalguide/fileadmin/_processed_/5/4/csm_redis-konfigurationsdatei_74a168f586.webp "Estratto del file di configurazione di Redis")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/redis-konfigurationsdatei.png) Estratto del file di configurazione di Redis Nell’elenco di tutti gli elementi di configurazione **le coppie sono sempre una sotto l’altra**. Il punto “dbfilename“ include quindi il valore “dump.rdb“. L’asterisco utilizzato per richiamare l’elenco è solo un segnaposto per un elemento particolare della configurazione. Per esaminare ciò in modo specifico è possibile inserire il nome della voce al posto dell’asterisco. Si cerca sempre la parte superiore della coppia di configurazione, la chiave del valore associato.

```none
127.0.0.1:6397> config get dbfilename
1) "dbfilename"
2) "dump.rdb"
```

Per modificare una voce nel file di configurazione si utilizza il **comando *set***, che può essere usato, ad esempio, per impostare una password.

```none
127.0.0.1:6397> config set requirepass "password"
OK
```

Se vogliamo richiedere la password con ***get***, ci viene chiesto prima di inserirla, dopotutto abbiamo appena eseguito il backup di Redis. A tal fine utilizziamo il comando ***auth***, quindi possiamo eseguire una query sulla voce di configurazione come descritto.

```none
127.0.0.1:6397> auth "password"
127.0.0.1:6397> config get requirepass
1) "requirepass"
2) "password"
```

N.B. Esistono altri modi per proteggere il database. Gli sviluppatori hanno [stilato una sintesi dei vari punti](https://redis.io/topics/security "Redis Security") sul sito ufficiale.

Redis in realtà mantiene tutti i record in memoria. Tuttavia, per ottenere la persistenza è possibile **creare uno snapshot del database sul disco fisso**, memorizzato nel file *dump.rdb*.

```none
127.0.0.1:6397> save
```

Abbiamo creato manualmente uno snapshot utilizzando il **comando *save***. I backup possono anche essere automatizzati.

```none
127.0.0.1:6397> save 60 10
```

In questo esempio abbiamo dato al comando due parametri: ora il salvataggio avviene ogni 60 secondi, se durante questo periodo ci sono già state 10 modifiche.

Tuttavia, il comando *save* non è così utile nella modalità attiva perché impedisce ai client di accedere al database. ***Bgsave*** è più adatto perché questo processo è eseguito in background.

Oltre alla versione dello snapshot esiste anche il **file append-only**. In questa modalità Redis salva ogni operazione eseguita in un file. Se il server Redis si arresta in modo imprevisto, è possibile vedere ciò che è stato fatto per ultimo. Per attivare la modalità AOF è necessario apportare una modifica al file di configurazione.

```none
127.0.0.1:6397> config set appendonly yes
```

Consiglio Se avete bisogno della massima sicurezza dei dati dovreste creare sistematicamente degli snapshot e attivare la modalità AOF. In questo modo praticamente nessun dato può andare perso. Tuttavia le operazioni rendono certamente il database un po’ più lento.

## Passaggio 3: creare voci

Dopo aver configurato Redis è possibile lavorare con il database. A tale scopo si utilizzano diversi tipi di dati e comandi.

### Stringhe

Le stringhe possono essere impostate più facilmente utilizzando il **comando *set***.

N.B. Non importa se si utilizzano o meno le virgolette quando si immettono valori. Per una migliore lettura del codice è possibile inserire il testo tra virgolette e specificare valori numerici senza tag.

```none
127.0.0.1:6397> set foo "bar"
127.0.0.1:6397> set value 1
```

Se ora richiamate le voci *foo* e *value* con ***get*** saranno visualizzati i valori corrispondenti.

```none
127.0.0.1:6397> get foo
"bar"
127.0.0.1:6397> get value
"1"
```

Per eliminare una voce si usa il **comando *del***.

```none
127.0.0.1:6397> del foo
(integer) 1
127.0.0.1:6397> get foo
(nil)
```

Per evitare di creare molte voci con una riga di codice aggiuntiva, potete utilizzare la funzione estesa ***mset***. Per richiamare i valori di più voci contemporaneamente, esiste in parallelo ***mget***.

```none
127.0.0.1:6397> mset foo1 "bar1" foo2 "bar2" foo3 "bar3"
OK
127.0.0.1:6397> mget foo1 foo2 foo3
1) "bar1"
2) "bar2"
3) "bar3"
```

### Elenchi

Con Redis è possibile utilizzare anche altri tipi di dati. Ad esempio, **elenchi e set** sono popolari quando si lavora con il database. Entrambi sono raccolte di valori. Tuttavia, mentre i set non sono ordinati, i valori negli elenchi sono numerati. È possibile aggiungere, interrogare ed eliminare voci negli elenchi.

```none
127.0.0.1:6397> lpush mylist foo
(integer) 1
127.0.0.1:6397> lpush mylist bar
(integer) 2
127.0.0.1:6397> lrange mylist 0 10
1) "foo"
2) "bar"
127.0.0.1:6397> linsert mylist before "bar" "test"
(integer) 3
127.0.0.1:6397> lrange mylist 0 10
1) "foo"
2) "test"
3) "bar"
127.0.0.1:6397> lrem mylist 0 foo
(integer) 1
127.0.0.1:6397> lrange mylist 0 10
1) "test"
2) "bar"
```

In questo esempio abbiamo prima inserito due elementi in un elenco (***lpush***) e li abbiamo visualizzati. Il comando ***lrange*** specifica quale intervallo (qui da 0 a 10) deve essere riprodotto, in tal caso è possibile utilizzare anche numeri negativi. Quindi abbiamo inserito un altro valore davanti ad uno esistente con ***linsert*** (è possibile anche con *after*) e modificato così la numerazione. Il comando ***lrem*** consente di eliminare dall’elenco le voci con un valore specifico.

### Set

Redis prevede altri comandi per i set che danno risultati simili:

```none
127.0.0.1:6397> sadd myset "foo"
(integer) 1
127.0.0.1:6397> sadd myset "bar"
(integer) 1 
127.0.0.1:6397> smembers myset 
1) "bar"
2) "foo"
127.0.0.1:6397> sismember myset "bar"
(integer) 1
127.0.0.1:6397> srem myset "bar"
(integer) 1
127.0.0.1:6397> smembers myset
1) "foo"
```

Con ***sadd*** è possibile includere contemporaneamente più elementi nel set, se sono inseriti uno dopo l’altro nel comando. Per visualizzare il set è sufficiente il comando ***smembers*** e il nome del set desiderato. Usando il comando ***sismember*** si può anche cercare una voce specifica. Analogamente all’elenco, con ***srem*** è possibile eliminare singole voci.

Redis offre inoltre agli utenti la possibilità di utilizzare i **set in un formato ordinato**.

```none
127.0.0.1:6397> zadd mysortedset 1 "foo"
(integer) 1
127.0.0.1:6397> zadd mysortedset 2 "bar"
(integer) 1
127.0.0.1:6397> zadd mysortedset 2 "foobar"
(integer) 1
127.0.0.1:6397> zrange mysortedset 0 10
1) "foo"
2) "bar"
3) "foobar"
```

In questa variante, il comando ***zadd*** e un punteggio si utilizzano per aggiungere elementi. Mentre i valori stessi non possono apparire più volte, lo stesso numero può essere assegnato diverse volte nel punteggio. Il punteggio non è quindi una numerazione diretta all’interno del set ma una ponderazione. Tutte le voci con un punteggio di 2 seguono gli elementi con un punteggio di 1. Con ***zrange*** è possibile visualizzare tutte o solo le voci selezionate.

### Hash

Il tipo di dati hash presenta una peculiarità. Come per i set e gli elenchi, si tratta di singole voci che possono contenere più valori. Tuttavia, conformemente alle **coppie chiave-valore**, esiste anche una chiave per ciascun valore.

```none
127.0.0.1:6397> hset user1 name "bob" email "bob@example.com" password "rK87_x"
OK
127.0.0.1:6397> hget user1 name
1) "bob"
127.0.0.1:6397> hgetall user1
1) "name"
2) "bob"
3) "email"
4) "bob@example.com"
5) "password"
6) "rK87_x"
127.0.0.1:6397> hvals user1
1) "bob"
2) "bob@example.com"
3) "rK87_x"
127.0.0.1:6397> hkeys user1
1) "name"
2) "email"
3) "password"
> hdel user1 password
(integer) 1
127.0.0.1:6397> hgetall user1
1) "name"
2) "bob"
3) "email"
4) "bob@example.com"
127.0.0.1:6397> del user1
(integer) 1
127.0.0.1:6397> hgetall user1
(empty list or set)
```

In questo esempio con ***hset*** abbiamo creato un hash denominato *user1*. L’hash ha tre campi. Usando il comando ***hget*** si può ottenere il valore di ogni campo separatamente. Per visualizzarli tutti è possibile utilizzare ***hgetall***. Ulteriori opzioni di query sono disponibili tramite ***hvals*** (mostra tutti i valori memorizzati nell‘hash) e ***hkeys*** (mostra tutte le chiavi memorizzate nell’hash). I singoli campi possono essere eliminati con ***hdel***, l’hash completo come al solito con ***del***.

N.B. Il comando ***flushall*** consente di eliminare tutte le voci del database.

## Passaggio 4: ulteriori opzioni

Con Redis non solo è possibile inserire voci in un database, ma anche assegnare ai dati determinate proprietà. Ad esempio, **l’ingrandimento o la riduzione incrementale** può essere molto utile.

```none
127.0.0.1:6397> set foo 1
OK
127.0.0.1:6397> get foo
"1"
127.0.0.1:6397> incr foo
(integer) 2
127.0.0.1:6397> incr foo
(integer) 3
127.0.0.1:6397> get foo
"3"
127.0.0.1:6397> decr foo
(integer) 2
127.0.0.1:6397> get foo
"2"
```

Con queste funzioni è quindi possibile aumentare o diminuire i valori di uno. A volte, tuttavia, si desidera impostare valori che sono disponibili nel database solo per un determinato periodo di tempo. In questo caso si usa la funzione ***expire***.

```none
127.0.0.1:6397> set foo "bar"
OK
127.0.0.1:6397> expire foo 100
(integer) 1
127.0.0.1:6397> ttl foo
(integer) 50
127.0.0.1:6397> ttl foo
(integer) -50
127.0.0.1:6397> get foo
(nil)
```

Il comando *expire* richiede un periodo di tempo in secondi. In questo esempio abbiamo impostato la durata della voce su 100 secondi. Dopo metà del tempo, con il comando ***ttl*** abbiamo chiesto il time to live, ovvero il tempo rimanente. Se si aspetta ancora di più, l’intervallo del TTL assume valore negativo. A questo punto la voce non esiste più.

Con il comando ***setex***, una voce nel database può essere collegata a un TTL non appena creata.

```none
127.0.0.1:6397> setex foo 100 "bar"
OK
```

La voce creata può anche essere espansa. Il comando ***append*** aggiunge un altro valore a quello memorizzato.

```none
127.0.0.1:6397> set foo "Hello"
OK
127.0.0.1:6397> append foo " World"
(integer) 11
127.0.0.1:6397> get foo
"Hello World"
127.0.0.1:6397> set bar 5
OK
127.0.0.1:6397> append bar 10
(integer) 3
127.0.0.1:6397> get bar
"510"
```

Come si può vedere, quando si richiamano nuovamente i valori corrispondenti, i nuovi componenti sono **semplicemente aggiunti al valore esistente**. Se la voce non esiste ancora, *append* funziona esattamente come *set*.

Inoltre è possibile anche rinominare le voci usando il comando ***rename***.

```none
127.0.0.1:6397> set foo 100
OK
127.0.0.1:6397> rename foo bar
OK
127.0.0.1:6397> get foo
(nil)
127.0.0.1:6397> get bar
"100"
```

Consiglio Esistono molti altri comandi per operare correttamente con Redis. Nella documentazione ufficiale è possibile trovare [tutti i comandi disponibili](https://redis.io/commands "Descrizione di tutti i comandi di Redis") con una descrizione.


This is a markdown version of: [https://www.ionos.it/digitalguide/hosting/tecniche-hosting/tutorial-su-redis/](https://www.ionos.it/digitalguide/hosting/tecniche-hosting/tutorial-su-redis/) for AI/LLM consumption.