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

# Aggiornare a una nuova release

> Porta un Notifuse self-hosted a una nuova release con Docker Compose, verifica il risultato e, se serve, torna indietro.

Un aggiornamento sostituisce l'immagine di Notifuse e la riavvia. Notifuse aggiorna da solo i suoi database quando si avvia sulla nuova release.

## Leggi prima il changelog

Apri il [changelog](https://www.notifuse.com/it/docs/changelog.md) e leggi ogni release tra la tua versione e quella nuova. Alcune release hanno una nota **Prima di aggiornare** con una modifica da fare insieme all'aggiornamento, come un nuovo valore di `SECRET_KEY` per la 42.0 o `WEBHOOK_DELIVERY_ALLOW_PRIVATE_HOSTS` per i webhook sulla tua rete.

Quando **Verifica aggiornamenti** è attivo, l'utente root e i proprietari dei workspace vedono una scheda nell'elenco dei workspace quando esce una nuova release. Il suo pulsante **Scopri le novità** apre tutte le release successive alla tua, ognuna con le sue note **Prima di aggiornare:** e un link **Changelog completo**.

## Fai un backup

Fai il backup di ogni database e conserva `SECRET_KEY` insieme ai dump, come spiega [Backup](https://www.notifuse.com/it/docs/self-hosting/backups.md). Per tornare a una versione major precedente ti serve questo backup (vedi [Tornare indietro](#rolling-back)).

Imposta `DB_EXPECT_EXISTING=true` in `.env` se non c'è già. Se un aggiornamento lasciasse Notifuse davanti a un database vuoto, si fermerebbe invece di avviare una nuova installazione.

## Aggiornare con Docker Compose

`compose.yaml` prende la release da `NOTIFUSE_VERSION`:

```yaml compose.yaml
image: notifuse/notifuse:${NOTIFUSE_VERSION:-v44.0}
```

Il valore predefinito dopo `:-` è la release con cui il file è stato pubblicato. Per cambiarla, scegli uno dei due modi seguenti, dalla directory che contiene `compose.yaml`.

**Fissa la versione in .env**

Imposta la nuova release in `.env`, poi scarica l'immagine e riavvia:

```bash
# In .env: NOTIFUSE_VERSION=v44.0
docker compose pull
docker compose up -d
```

**Scarica il nuovo compose.yaml**

Sostituisci il tuo `compose.yaml` con l'ultimo, poi scarica l'immagine e riavvia. Il tuo `.env` resta com'è. Riporta nel nuovo file le modifiche che avevi fatto a `compose.yaml`.

```bash
curl -fsSL https://raw.githubusercontent.com/Notifuse/notifuse/main/compose.yaml -o compose.yaml
docker compose pull
docker compose up -d
```

Se `.env` imposta `NOTIFUSE_VERSION`, quel valore prevale sul valore predefinito del file: aggiornalo anche lì.

`docker compose pull` scarica la nuova immagine mentre quella vecchia continua a girare. `docker compose up -d` poi sostituisce il container. Notifuse ha fino a 70 secondi per fermarsi: prima terminano il passaggio di automazione in corso e le email in fase di invio.

Per controllare quale release eseguirà Compose prima di riavviare, guarda l'immagine risolta:

```bash
docker compose config | grep 'image: notifuse'
```

> [!NOTE]
>
> Fino alla 43.0, `compose.yaml` compila Notifuse dal clone del repository in cui si trova. In un clone di questo tipo, passa alla nuova release (`git fetch --tags && git checkout v44.0`), poi esegui `docker compose up -d`. Dalla 44.0, il file esegue l'immagine pubblicata, a meno che tu non passi `--build`.

## Cosa succede all'avvio

Quando la nuova release si avvia, Notifuse esegue le migrazioni del database prima di servire qualsiasi richiesta:

1. Controlla la versione di PostgreSQL. Dalla 44.0 si rifiuta di avviarsi su PostgreSQL precedente alla 17 e indica quale versione ha trovato.
2. Confronta la versione major registrata nel database di sistema (`43` per la 43.0) con la propria.
3. Applica ogni migrazione intermedia al database di sistema, poi a ogni database di workspace.
4. Registra la nuova versione. Alcune migrazioni fanno poi uscire Notifuse una volta, e Docker lo riavvia (`restart: unless-stopped`).

Con più istanze sullo stesso database, una applica le migrazioni e le altre la aspettano (dalla 42.2). Segui l'avanzamento nel log:

```bash
docker compose logs -f api
```

Il log chiude questa fase con `Migration process completed successfully`, oppure `Database is up to date, no migrations needed` quando la versione major non è cambiata. Se una migrazione fallisce, Notifuse non si avvia e il log la indica: `migration failed for version …`.

## Verifica la versione

Accedi e apri l'elenco dei workspace. Il suo piè di pagina mostra la versione in esecuzione, per esempio **Notifuse v44.0**. La mostra anche il menu dell'account.

Da riga di comando, la versione si trova nel file di configurazione della console:

```bash
curl -s https://emails.yourcompany.com/config.js | grep VERSION
```

Poi controlla che `https://emails.yourcompany.com/healthz` risponda `{"status":"ok"}`, e apri un workspace per verificare i tuoi dati.

## Tornare indietro

Notifuse registra nel database solo la versione major, e non ha migrazioni all'indietro.

All'interno della stessa versione major (per esempio dalla 44.1 alla 44.0), imposta la release precedente in `NOTIFUSE_VERSION` ed esegui `docker compose up -d`. Notifuse si avvia sullo stesso database.

Tra versioni major diverse, la release più vecchia si rifiuta di avviarsi su un database migrato da quella più nuova. Il log dice `database is at version 44, this build is version 43 - refusing to start`. Per tornare indietro:

1. Ferma lo stack con `docker compose down`.
2. Imposta la release precedente in `NOTIFUSE_VERSION`, oppure rimetti il suo `compose.yaml`.
3. Ripristina in un database vuoto il backup fatto prima dell'aggiornamento, come spiega [Ripristino](https://www.notifuse.com/it/docs/self-hosting/backups.md#restoring), con la `SECRET_KEY` in uso quando è stato fatto il backup.

Tutto ciò che è stato scritto dopo il backup va perso.

Se l'aggiornamento era quello alla 44.0, che porta anche PostgreSQL alla 18, usa invece la copia che `compose.yaml` conserva: [Tornare indietro](https://www.notifuse.com/it/docs/self-hosting/upgrading-postgresql.md#rolling-back) rimette i dati di PostgreSQL 17 com'erano prima dell'aggiornamento, con il `compose.yaml` della release precedente.

## Aggiornare PostgreSQL

La versione 44.0 porta `compose.yaml` da PostgreSQL 17 a 18, e il primo `docker compose up -d` su di essa aggiorna anche il database. [Aggiornare PostgreSQL](https://www.notifuse.com/it/docs/self-hosting/upgrading-postgresql.md) spiega cosa succede, quanto spazio su disco serve, come verificarlo e come tornare indietro.
