> ## Documentation Index
> Fetch the complete documentation index at: https://docs.squarecloud.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Redis su Square Cloud: connessione, memoria e persistenza

> Redis gestito su Square Cloud: connessione TLS con rediss://, timeout di inattività, comandi bloccati, moduli integrati (Search, JSON, TimeSeries), policy di memoria noeviction, persistenza ed errori comuni.

Un server Redis gestito raggiungibile tramite TLS, con i moduli Search, JSON, TimeSeries, probabilistici e vector set integrati. Le informazioni comuni a tutti i motori (limiti, snapshot, Insights) si trovano nella [panoramica dei database](https://docs.squarecloud.app/it/services/databases.md).

## Connettersi

Copia l'URL di connessione dalla pagina del database nella dashboard:

```
rediss://default:PASSWORD@HOST:PORT
```

Lo schema è **`rediss://`** (con due s): il server accetta solo TLS e non esiste una porta in chiaro. Il certificato client non serve; per verificare il server, usa il `.pem` di **Connessione** → **Certificato SSL/TLS** come CA. Un URL salvato da un database creato prima del 29 settembre 2026 potrebbe ancora indicare `redis://`: cambialo in `rediss://`.

> [tab] node-redis
>
> ```javascript theme={"system"}
> import fs from "node:fs";
> import { createClient } from "redis";
>
> // One client for the whole process, created once and reused.
> export const redis = createClient({
>   url: process.env.REDIS_URL,
>   socket: { tls: true, ca: fs.readFileSync("certificate.pem", "utf8") },
>   pingInterval: 60_000, // keeps the connection from being closed as idle
> });
>
> redis.on("error", (err) => console.error("Redis error", err));
> await redis.connect();
> ```

> [tab] ioredis
>
> ```javascript theme={"system"}
> import fs from "node:fs";
> import Redis from "ioredis";
>
> export const redis = new Redis(process.env.REDIS_URL, {
>   tls: { ca: fs.readFileSync("certificate.pem", "utf8") },
> });
> ```

> [tab] Python
>
> ```python theme={"system"}
> import os
> import redis
>
> r = redis.from_url(
>     os.environ["REDIS_URL"],
>     ssl_ca_certs="certificate.pem",
>     health_check_interval=60,
> )
> ```

> [tab] redis-cli
>
> ```bash theme={"system"}
> redis-cli -u "rediss://default:PASSWORD@HOST:PORT" --tls --cacert certificate.pem
> ```

## Comportamento della connessione

* **I client inattivi vengono disconnessi dopo 300 secondi.** Usa un client che si riconnette automaticamente (node-redis, ioredis e redis-py lo fanno) oppure invia un `PING` periodico, come negli esempi sopra.
* **Un solo database logico (0).** `SELECT 1` o superiore risponde `ERR DB index is out of range`: separa invece i dati con prefissi di chiave (`cache:`, `session:`).
* Fino a 256 client simultanei; oltre questo limite, i nuovi ricevono `max number of clients reached`. Crea un solo client per processo e riutilizzalo.
* L'autenticazione è la password dell'utente `default`. Non è possibile creare utenti ACL aggiuntivi.

## Comandi

Tutti i comandi sui dati funzionano, così come gli script Lua e le Functions, pub/sub, `MULTI`/`EXEC`, `SCAN` e `SLOWLOG`. Questi sono bloccati e rispondono `NOPERM`: `FLUSHALL`, `FLUSHDB`, `SHUTDOWN`, `CONFIG`, `DEBUG`, `ACL`, `REPLICAOF`/`SLAVEOF` e `FAILOVER`.

Senza `CONFIG`, la policy di eviction e le notifiche del keyspace non possono essere modificate. Per svuotare il database, elimina le chiavi a blocchi con `SCAN` e `UNLINK`:

```bash theme={"system"}
URL="rediss://default:PASSWORD@HOST:PORT"
redis-cli -u "$URL" --tls --cacert certificate.pem --scan --pattern 'cache:*' \
  | xargs -n 100 redis-cli -u "$URL" --tls --cacert certificate.pem UNLINK
```

## Moduli integrati

| Modulo | Comandi |
| :- | :- |
| Search and Query | `FT.*` (full-text, indici secondari, ricerca vettoriale) |
| JSON | `JSON.*` |
| TimeSeries | `TS.*` |
| Probabilistici | `BF.*`, `CF.*`, `CMS.*`, `TOPK.*`, `TDIGEST.*` |
| Vector set | `VADD`, `VSIM` e gli altri comandi `V*` |

Le query di Search vengono eseguite su tanti thread quante sono le vCPU del database.

## Memoria

* Redis può contenere dati fino al **90% della RAM del database**. Il restante 10% copre il suo overhead, i buffer dei client e lo spazio necessario per un salvataggio.
* La policy è **`noeviction`**: quando la memoria è piena, non viene espulso nulla. Le scritture falliscono con `OOM command not allowed when used memory > 'maxmemory'`, mentre le letture continuano a funzionare e il server resta attivo.
* Quindi **imposta una scadenza sulle chiavi di cache** (`SET key value EX 3600`, `EXPIRE`), e dimensiona la RAM per i dati senza scadenza.
* Cambiare la RAM del database lo riavvia.

## Risposte grandi

Un client le cui risposte non lette superano i 32 MB (o restano sopra i 16 MB per 60 secondi) viene disconnesso; per i subscriber pub/sub i limiti sono 32 MB e 8 MB per 60 secondi. I comandi che restituiscono risposte enormi, come `KEYS *` o `HGETALL`/`SMEMBERS` su chiavi giganti, e i subscriber che leggono troppo lentamente, vengono interrotti. Itera invece con `SCAN`, `HSCAN` e `SSCAN`.

## Persistenza

* Redis salva i suoi dati su disco **ogni 60 secondi quando c'è stata almeno una scrittura**. Non esiste un file append-only, quindi un crash o un arresto per memoria esaurita perde fino agli ultimi \~60 secondi di scritture. Conserva anche in un database principale i dati che non puoi perdere.
* Se un salvataggio fallisce (storage pieno, o memoria insufficiente per salvare), le scritture rispondono `MISCONF` finché un salvataggio non riesce, e nel frattempo gli snapshot falliscono. Un salvataggio richiede storage libero accanto al file di dati attuale, pari circa alla dimensione dei dati.

## Reimpostazione della password

Reimpostare la password riavvia Redis, che legge la password solo all'avvio: resta offline per qualche secondo e tutte le connessioni si chiudono. Aggiorna l'URL nelle tue app e lascia che si riconnettano.

## Snapshot

Uno snapshot di Redis è il suo file di dati salvato. Ripristinarne uno riporta i dati e mantiene la password attuale del database. Vedi [snapshot e ripristino](https://docs.squarecloud.app/it/services/databases.md#snapshot-e-ripristino).

## Errori comuni

| Messaggio | Cosa significa | Cosa fare |
| :- | :- | :- |
| La connessione si chiude subito, `ECONNRESET` o un timeout | L'URL usa `redis://`, senza TLS. | Usa `rediss://`. |
| `OOM command not allowed when used memory > 'maxmemory'` | La memoria è piena e non viene espulso nulla. | Aggiungi scadenze alle chiavi di cache, elimina dati o aggiungi RAM. |
| `MISCONF Redis is configured to save RDB snapshots, but it's currently unable to persist to disk` | L'ultimo salvataggio è fallito. | Libera storage e memoria; le scritture riprendono dopo un salvataggio riuscito. |
| `ERR DB index is out of range` | Esiste solo il database 0. | Usa prefissi di chiave invece di `SELECT`. |
| `NOPERM ... has no permissions to run the '...' command` | Il comando è bloccato. | Usa `SCAN` + `UNLINK` invece di `FLUSHALL`/`FLUSHDB`. |
| `max number of clients reached` | Tutte le 256 connessioni sono in uso. | Riutilizza un solo client per processo. |

## Contattaci

Se continui a riscontrare **difficoltà tecniche**, il nostro **team di supporto specializzato** è disponibile ad assisterti. [**Contattaci**](https://squarecloud.app/it/support) e saremo felici di aiutarti a risolvere qualsiasi problema: la qualità del supporto è una parte importante del motivo per cui gli sviluppatori valutano Square Cloud [**4,9/5 su 402 recensioni**](https://www.trustpilot.com/review/squarecloud.app) su Google e Trustpilot.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.