IT

Linux e rete

Installa e proteggi Redis

Installa Redis dal repository ufficiale su Debian o Ubuntu: utenti ACL, ascolto locale, persistenza RDB e AOF, limite di memoria, backup e ripristino.

10 min di lettura, aggiornato il 18 novembre 2026

In questa pagina

I tuoi valori

Inseriscili una volta: i comandi della guida si aggiornano.

Questa guida ti spiega come installare Redis sul tuo VPS o server dedicato dal repository ufficiale, proteggerlo con utenti ACL, scegliere la persistenza adatta, limitarne la memoria e salvare i suoi dati.

Redis è progettato per essere usato da client affidabili. Qui resta quindi accessibile solo in locale, e ogni applicazione si connette con un account dai permessi limitati.

Ordinare un server

Redis tiene i suoi dati in memoria: prevedi una RAM sufficiente per i tuoi dati e per i backup in background. HostMyServers propone diverse offerte:

Prerequisiti

  • Un server con Debian 12 o 13, oppure Ubuntu 22.04 o 24.04
  • Un accesso SSH con un utente che dispone di sudo
  • Un sistema aggiornato (sudo apt update && sudo apt upgrade)

Porte da aprire

Nessuna. Redis ascolta sulla porta 6379 di 127.0.0.1 e ::1. Per accedervi dal tuo computer, usa il tunnel SSH descritto più avanti, che passa dalla tua porta SSH già aperta.

Installare Redis dal repository ufficiale

Al momento della stesura, il repository ufficiale propone Redis 8.10 per Debian 12 e 13 e per Ubuntu 22.04 e 24.04.

Terminale
sudo apt install -y lsb-release curl gpg
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
sudo chmod 644 /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
sudo apt update
sudo apt install -y redis
sudo systemctl enable --now redis-server

Verificare l'installazione

Terminale
redis-server --version
sudo systemctl status redis-server --no-pager
redis-cli ping
sudo ss -tlnp | grep 6379

redis-cli ping deve rispondere PONG. ss deve mostrare un ascolto solo su 127.0.0.1:6379 e [::1]:6379.

Elemento Percorso
Configurazione del pacchetto /etc/redis/redis.conf
Le tue impostazioni (creato più avanti) /etc/redis/local.conf
Utenti (creato più avanti) /etc/redis/users.acl
Dati /var/lib/redis/
Log /var/log/redis/redis-server.log

Creare gli utenti ACL

Per impostazione predefinita, qualsiasi connessione locale può eseguire tutti i comandi. Disattiverai questo utente default e creerai tre account:

Utente Permessi
admin Amministrazione completa
app Lettura e scrittura sulle chiavi app:*, senza comandi pericolosi
backup Solo avvio dei backup, senza accesso alle chiavi
  1. Genera le password e il file degli utenti. Vi vengono registrate solo le loro impronte SHA-256:

    Terminale
    ADMIN_PASS="$(openssl rand -hex 32)"
    APP_PASS="$(openssl rand -hex 32)"
    BACKUP_PASS="$(openssl rand -hex 32)"
    sha() { printf '%s' "$1" | sha256sum | cut -d' ' -f1; }
    
    sudo install -o redis -g redis -m 640 /dev/null /etc/redis/users.acl
    sudo tee /etc/redis/users.acl > /dev/null <<EOF
    user default off
    user admin on #$(sha "$ADMIN_PASS") ~* &* +@all
    user app on #$(sha "$APP_PASS") ~app:* resetchannels &app:* -@all +@read +@write +@connection +@transaction -@dangerous
    user backup on #$(sha "$BACKUP_PASS") resetchannels -@all +ping +bgsave +lastsave
    EOF
  2. Conserva la password di backup per lo script, poi mostra le altre due per riporle nel tuo gestore di password:

    Terminale
    printf '%s' "$BACKUP_PASS" | sudo sh -c 'umask 077; cat > /root/.redis-backup-pass'
    printf 'admin: %s\napp: %s\n' "$ADMIN_PASS" "$APP_PASS"
    unset ADMIN_PASS APP_PASS BACKUP_PASS
  3. Crea il tuo file di impostazioni. Resta separato da redis.conf, il che semplifica gli aggiornamenti:

    Terminale
    sudo install -o redis -g redis -m 640 /dev/null /etc/redis/local.conf
    sudo nano /etc/redis/local.conf
    Configurazione
    aclfile /etc/redis/users.acl
    maxmemory 512mb
    maxmemory-policy noeviction

    Adatta maxmemory al tuo server, come spiegato nella sezione sulla memoria.

  4. Carica questo file alla fine della configurazione, poi riavvia:

    Terminale
    echo 'include /etc/redis/local.conf' | sudo tee -a /etc/redis/redis.conf
    sudo systemctl restart redis-server
  5. Verifica il risultato:

    Terminale
    redis-cli ping
    redis-cli --user admin --askpass ping
    redis-cli --user app --askpass

    Il primo comando deve rispondere NOAUTH Authentication required. e il secondo PONG dopo l'inserimento della password admin. Nella sessione aperta dal terzo, con la password app:

    Testo
    SET app:test ok
    GET app:test
    DEL app:test
    SET autre:test non
    FLUSHALL

    I primi tre comandi devono riuscire. Gli ultimi due devono essere rifiutati con un errore NOPERM.

Nella tua applicazione, indica l'utente app, la sua password, e prefissa le chiavi con app:. Se ha bisogno di altri comandi, modifica la sua riga in users.acl, poi ricarica il file da una sessione admin con ACL LOAD.

Accedere a Redis dal tuo computer

Apri un tunnel SSH e lascia attivo questo comando:

Terminale
ssh -N -L 6380:127.0.0.1:6379 TUO_USER@IP_DEL_TUO_SERVER

In un altro terminale, connettiti tramite la porta locale 6380:

Terminale
redis-cli -p 6380 --user admin --askpass

Se un'applicazione remota non può proprio passare da un tunnel o da una rete privata, configura TLS mantenendo le ACL, e limita la porta all'indirizzo di quel client nel firewall.

Scegliere la persistenza

Modalità Funzionamento Rischio di perdita Utilizzo consigliato
RDB Snapshot regolari in dump.rdb Dall'ultimo snapshot Dati che si possono in parte ricreare
AOF Log delle scritture, sincronizzato ogni secondo per impostazione predefinita Circa un secondo Dati importanti
RDB + AOF Entrambi insieme Circa un secondo La scelta migliore per dati da conservare
Nessuna Tutto viene perso al riavvio Totale Cache pura

RDB è attivo per impostazione predefinita, con le soglie 3600 1 300 100 60 10000: uno snapshot dopo 1 ora se almeno 1 chiave è cambiata, dopo 5 minuti per 100 chiavi, dopo 1 minuto per 10 000 chiavi.

Attivare AOF senza perdere dati

  1. Apri una sessione admin:

    Terminale
    redis-cli --user admin --askpass
  2. Attiva AOF e segui la sua creazione:

    Testo
    CONFIG SET appendonly yes
    INFO persistence

    Ripeti INFO persistence finché non ottieni aof_rewrite_in_progress:0, aof_rewrite_scheduled:0 e aof_last_bgrewrite_status:ok.

  3. Aggiungi la riga seguente a /etc/redis/local.conf per mantenere questa impostazione:

    Configurazione
    appendonly yes
  4. Riavvia Redis, poi verifica con DBSIZE che il numero di chiavi non sia cambiato:

    Terminale
    sudo systemctl restart redis-server

Usare Redis come cache pura

Se tutti i dati possono essere ricostruiti, aggiungi queste righe a /etc/redis/local.conf e riavvia:

Configurazione
save ""
appendonly no
maxmemory-policy allkeys-lru

Tenere sotto controllo la memoria

Redis non ha un limite di memoria predefinito su un sistema a 64 bit. Imposta sempre maxmemory, lasciando spazio al sistema, agli altri tuoi servizi e ai buffer di Redis. Durante un backup su un'istanza con molte scritture, Redis può consumare fino a il doppio della sua memoria abituale.

Policy Comportamento al limite Utilizzo
noeviction Rifiuta le nuove scritture Dati da non perdere
allkeys-lru Elimina le chiavi usate meno di recente Cache generale
allkeys-lfu Elimina le chiavi usate meno frequentemente Cache con chiavi molto richieste
volatile-lru Elimina tra le chiavi con una scadenza Cache e dati misti
volatile-ttl Elimina le chiavi la cui scadenza è più vicina Scadenze ben controllate

Attiva l'impostazione del kernel raccomandata da Redis per rendere più affidabili i backup in background:

Terminale
echo 'vm.overcommit_memory = 1' | sudo tee /etc/sysctl.d/90-redis.conf
sudo sysctl --system

Per monitorare l'utilizzo da una sessione admin:

Testo
INFO memory
INFO stats
MEMORY DOCTOR

Guarda in particolare used_memory_human, maxmemory_human, mem_fragmentation_ratio e evicted_keys.

Automatizzare i backup

Il file RDB può essere copiato mentre Redis è in funzione: viene sostituito solo quando il nuovo snapshot è completo. Lo script richiede uno snapshot recente, ne attende la fine, poi lo copia.

  1. Crea lo script:

    Terminale
    sudo nano /usr/local/sbin/redis-backup.sh
    Terminale
    #!/bin/bash
    set -euo pipefail
    umask 077
    
    DEST="/var/backups/redis"
    RETENTION_DAYS=7
    export REDISCLI_AUTH="$(cat /root/.redis-backup-pass)"
    
    cli() { redis-cli --user backup "$@"; }
    
    mkdir -p "$DEST"
    before="$(cli LASTSAVE)"
    cli BGSAVE SCHEDULE > /dev/null
    
    now="$before"
    for _ in $(seq 1 1800); do
      sleep 1
      now="$(cli LASTSAVE)"
      [ "$now" -gt "$before" ] && break
    done
    
    if [ "$now" -le "$before" ]; then
      echo "BGSAVE did not finish in time" >&2
      exit 1
    fi
    
    cp /var/lib/redis/dump.rdb "$DEST/dump-$(date +%F_%H%M%S).rdb"
    find "$DEST" -name 'dump-*.rdb' -mtime +"$RETENTION_DAYS" -delete
  2. Crea il servizio:

    Terminale
    sudo chmod 700 /usr/local/sbin/redis-backup.sh
    sudo nano /etc/systemd/system/redis-backup.service
    Configurazione
    [Unit]
    Description=Redis backup
    After=redis-server.service
    
    [Service]
    Type=oneshot
    ExecStart=/usr/local/sbin/redis-backup.sh
  3. Crea il timer:

    Terminale
    sudo nano /etc/systemd/system/redis-backup.timer
    Configurazione
    [Unit]
    Description=Daily Redis backup
    
    [Timer]
    OnCalendar=*-*-* 02:45:00
    RandomizedDelaySec=10min
    Persistent=true
    
    [Install]
    WantedBy=timers.target
  4. Attivalo e lancia un primo backup:

    Terminale
    sudo systemctl daemon-reload
    sudo systemctl enable --now redis-backup.timer
    sudo systemctl start redis-backup.service
    sudo ls -lh /var/backups/redis

Testare il ripristino

Questo test carica l'ultimo backup in un'istanza temporanea, raggiungibile solo tramite un socket locale. La tua istanza di produzione non viene modificata.

Terminale
LATEST="$(sudo sh -c 'ls -1t /var/backups/redis/dump-*.rdb | head -n 1')"
sudo install -d -o redis -g redis -m 750 /var/lib/redis-restore-test
sudo install -o redis -g redis -m 640 "$LATEST" /var/lib/redis-restore-test/dump.rdb
sudo -u redis redis-server --port 0 --unixsocket /var/lib/redis-restore-test/redis.sock --unixsocketperm 700 --dir /var/lib/redis-restore-test --dbfilename dump.rdb --appendonly no --save "" --daemonize yes --logfile /var/lib/redis-restore-test/redis.log
sleep 2
sudo -u redis redis-cli -s /var/lib/redis-restore-test/redis.sock DBSIZE

Confronta questo numero con quello dell'istanza di produzione e leggi alcune chiavi importanti con GET. Ferma poi l'istanza di test ed elimina i suoi file:

Terminale
sudo -u redis redis-cli -s /var/lib/redis-restore-test/redis.sock SHUTDOWN NOSAVE
sudo rm -rf /var/lib/redis-restore-test

Se i tuoi dati usano i moduli JSON, Search, TimeSeries o Bloom, aggiungi al comando di avvio le opzioni --loadmodule corrispondenti, con i percorsi indicati in /etc/redis/redis.conf.

Ripristinare dopo un incidente

Quando AOF è attivo, Redis carica i suoi dati da AOF e ignora dump.rdb. La procedura disattiva quindi AOF per la durata del ripristino.

  1. Ferma le applicazioni e Redis, poi metti da parte i file attuali:

    Terminale
    sudo systemctl stop redis-server
    sudo mkdir -p /var/backups/redis/before-restore
    sudo sh -c 'mv /var/lib/redis/dump.rdb /var/lib/redis/appendonlydir /var/backups/redis/before-restore/ 2>/dev/null || true'
  2. Copia il backup scelto, adattandone il nome:

    Terminale
    sudo install -o redis -g redis -m 660 /var/backups/redis/dump-2026-11-18_024500.rdb /var/lib/redis/dump.rdb
  3. Se usi AOF, sostituisci appendonly yes con appendonly no in /etc/redis/local.conf, poi avvia Redis:

    Terminale
    sudo systemctl start redis-server
  4. Verifica i tuoi dati con DBSIZE in una sessione admin. Se usi AOF, riattivalo a caldo con CONFIG SET appendonly yes, attendi la fine della sua creazione come spiegato nella sezione sulla persistenza, poi rimetti appendonly yes in local.conf.

Aggiornare Redis

Salva prima i tuoi dati, poi aggiorna il pacchetto:

Terminale
sudo systemctl start redis-backup.service
sudo apt update
sudo apt install --only-upgrade redis redis-server redis-tools
redis-server --version
sudo systemctl status redis-server --no-pager

Se apt segnala che /etc/redis/redis.conf è cambiato, confronta le versioni prima di decidere. Se adotti la nuova versione, aggiungi di nuovo la riga include /etc/redis/local.conf alla fine del file. Leggi anche le note di rilascio prima di cambiare versione maggiore.

In caso di problemi

NOAUTH Authentication required.

Il client non si è autenticato, cosa prevista dato che default è disattivato. Indica un utente con --user e --askpass, oppure configura questi valori nella tua applicazione.

WRONGPASS invalid username-password pair or user is disabled.

Il nome utente o la password sono errati. Se hai perso una password, generane una nuova, sostituisci la sua impronta in /etc/redis/users.acl, poi riavvia Redis o esegui ACL LOAD.

NOPERM

L'utente non ha accesso a quel comando o a quella chiave. Da una sessione admin, ACL LOG indica che cosa è stato rifiutato. Amplia solo ciò che è necessario.

OOM command not allowed when used memory > 'maxmemory'

Il limite di memoria è stato raggiunto con una policy che non libera chiavi. Aumenta maxmemory se il server lo permette, elimina i dati inutili, oppure scegli allkeys-lru se Redis fa da cache.

MISCONF Redis is configured to save RDB snapshots

L'ultimo snapshot è fallito, e Redis rifiuta le scritture per avvisarti. Verifica lo spazio su disco, i permessi e il log:

Terminale
df -h /var/lib/redis
sudo ls -ld /var/lib/redis
sudo tail -n 50 /var/log/redis/redis-server.log

La nostra guida Verificare lo spazio su disco può aiutarti a liberare spazio.

WARNING Memory overcommit must be enabled!

Applica l'impostazione vm.overcommit_memory = 1 descritta nella sezione sulla memoria.

Redis non si avvia più

Un errore in users.acl o in local.conf impedisce l'avvio. Consulta il log:

Terminale
sudo journalctl -u redis-server -n 50 --no-pager
sudo tail -n 50 /var/log/redis/redis-server.log

Verifica anche che users.acl esista e che l'utente redis possa leggerlo. Non definire utenti in redis.conf quando si usa aclfile: Redis rifiuta di mescolare i due metodi.

Could not connect to Redis at 127.0.0.1:6379: Connection refused

Redis è fermo o ascolta altrove. Controlla sudo systemctl status redis-server e sudo ss -tlnp | grep redis.

Riferimenti