Migrazione del database senza tempi di inattività: un manuale per la produzione

La maggior parte delle interruzioni dovute a una migrazione nasce da un solo errore: rilasciare un cambio di schema e il codice che ne dipende nello stesso respiro. Disaccoppiali, fai girare vecchio e nuovo affiancati per un po', e le parti spaventose diventano noiose. Ecco il manuale che usiamo per cambiare schemi e spostare database in produzione senza una finestra di manutenzione.

7 min di lettura8 sezioni22 giugno 2026

Scritto da

Kostadin Stamboliev

Fondatore e Imaginator

Fondatore e Imaginator di Pineido. Si occupa di consulenza IT, sviluppo di app e siti web, SEO tecnica, IA e automazione. Rilascia codice in produzione in sprint di 30 giorni con perimetro fisso e responsabilità chiare.

LinkedIn

Cosa significa davvero "zero tempi di inattività"

Zero tempi di inattività non significa magia. Significa che non c'è mai un momento in cui l'applicazione in esecuzione non possa leggere e scrivere ciò di cui ha bisogno. La versione onesta, presa in prestito da chi sposta grandi database per mestiere, è "cutover quasi nullo": il nuovo stato rispecchia il vecchio abbastanza da vicino che gli utenti non notano mai un'interruzione.

Due problemi distinti si nascondono sotto la stessa frase, e richiedono tattiche diverse. Il primo è l'evoluzione dello schema: cambiare tabelle, colonne, tipi e vincoli all'interno di un database che resta dov'è. Il secondo è il trasferimento: spostare i dati verso un nuovo database, un nuovo motore o una nuova regione. La regola che unifica entrambi è la stessa. Una migrazione deve completarsi mentre il vecchio codice dell'applicazione è ancora in esecuzione, e il nuovo codice deve funzionare contro la forma vecchia e quella nuova durante la sovrapposizione. Disaccoppia il cambio di schema dal deploy e l'intera faccenda smette di essere un singolo evento terrificante.

Il pattern expand-contract è tutto il gioco

Quasi ogni cambio di schema sicuro è una variante di expand-contract, chiamato anche parallel change. Invece di una migrazione atomica che ribalta tutto in un colpo, dividi il lavoro in fasi che si rilasciano ciascuna in modo indipendente e restano ciascuna retrocompatibili.

Expand: aggiungi la nuova colonna, tabella o indice accanto alla vecchia. Niente si rompe perché niente viene rimosso. L'applicazione inizia a scrivere in entrambe le rappresentazioni (dual-write) ma legge ancora dalla vecchia.

Migrate: riempi le righe storiche nella nuova forma, poi verifica, poi sposta le letture sulla nuova colonna mentre la scrittura doppia continua.

Contract: smetti di scrivere sulla vecchia colonna, rinominala così ogni riferimento dimenticato fallisce rumorosamente, osserva, e solo allora eliminala.

Il motivo per cui funziona è che il confine tra le fasi è il punto in cui rilasci e osservi. Se qualcosa sembra sbagliato, la fase precedente è ancora pienamente funzionante. Puoi metterti in pausa a tempo indeterminato invece di invertire un cambio applicato a metà mentre suonano gli avvisi. I cambi puramente additivi sono il caso facile, il vecchio codice ignora semplicemente la nuova colonna. La disciplina conta di più quando stai cambiando o rimuovendo qualcosa da cui l'app in esecuzione dipende.

Scrittura doppia: tieni oneste entrambe le copie

Durante la finestra di sovrapposizione, ogni scrittura deve atterrare sia nella posizione vecchia che in quella nuova, altrimenti la nuova copia resta indietro in silenzio. Hai due modi per farlo e la scelta ha conseguenze reali.

La scrittura doppia a livello applicativo significa che il tuo codice scrive esplicitamente in entrambi i posti. Compare nelle tracce e nei log, così quando qualcosa diverge puoi fare il debug attraverso lo stack di osservabilità di cui ti fidi già. I trigger di database possono tenere sincronizzate le colonne con meno codice applicativo, ma il comportamento avviene dentro il database dove la tua strumentazione normale non può vederlo, il che rende il debug penoso. Per la maggior parte dei team, il piccolo costo di una scrittura applicativa esplicita vale la tracciabilità.

Il lato tagliente della scrittura doppia è che due scritture non sono un'unica transazione atomica. Se la prima riesce e la seconda fallisce, le copie divergono. Per tutto ciò in cui questo conta, instrada le scritture attraverso un outbox transazionale o una propagazione basata su coda, così una singola transazione confermata è la fonte di verità e la seconda scrittura ne deriva. È anche qui che uno strumento come pgroll adotta un approccio diverso su Postgres: espone viste specifiche per versione così che le versioni vecchia e nuova dell'app vedano ciascuna lo schema che si aspettano, e gestisce la logica doppia a livello di database invece che nel tuo codice.

Backfill senza far fondere il database

Le nuove scritture vanno a entrambe le copie nel momento in cui la scrittura doppia è attiva, ma le righe storiche non si spostano da sole. Il backfill copia i dati esistenti nella nuova forma. Fallo a lotti, di solito qualche migliaio di righe alla volta, con una pausa deliberata tra i lotti per non saturare l'I/O e affamare il traffico in diretta.

Tieni il backfill in un job separato dal cambio di schema. Aggiungere una colonna NOT NULL con un valore di default e riempire milioni di righe nella stessa migrazione è il modo in cui un cambio di due secondi diventa un lock di ore. Su Postgres, aggiungi prima un vincolo NOT NULL come NOT VALID, che è istantaneo perché salta la scansione della tabella, poi esegui VALIDATE CONSTRAINT separatamente, che prende un lock più leggero che lascia continuare letture e scritture.

Programma i backfill pesanti per finestre a basso traffico, limitane il ritmo, e tieni d'occhio le repliche. Se fai girare repliche di lettura, possono portare brevemente uno schema diverso dal primario, quindi l'app deve tollerare quel ritardo durante la migrazione.

Valida prima di fidarti della nuova copia

Contare le righe non è validare. I conteggi delle righe possono corrispondere mentre i contenuti differiscono. Prima di spostare le letture, verifica con checksum o hash sulle tabelle critiche e controlli di invarianti su dati campionati, non solo i totali. Se stai già leggendo da entrambe le copie per alcune query, un confronto a livello applicativo che segnala le discordanze in tempo reale è il segnale più forte che puoi ottenere.

Il backfill è anche la tua occasione per correggere la qualità dei dati. Migrare le righe storiche fa emergere le incoerenze che la produzione ha tollerato in silenzio per anni, quindi tratta il backfill come una passata di pulizia, non solo come una copia.

Non tagliare la scrittura doppia troppo presto. Tieni entrambe le copie vive e sincronizzate per almeno un ciclo aziendale completo dopo aver spostato le letture. Disabilitare presto il vecchio percorso nasconde discordanze che non hai ancora colto, e ti toglie il rollback più economico.

Il locking è la vera fonte dei tempi di inattività

L'istruzione DDL in sé è di solito veloce. L'interruzione viene dalla contesa di lock attorno ad essa. Un guasto comune: un ALTER richiede un lock esclusivo, resta bloccato dietro una transazione di lunga durata o una sessione aperta dimenticata, e ogni query che arriva dopo si accoda dietro il lock. Un semplice cambio di schema degenera in uno stallo a livello dell'intero servizio.

Difenditi. Imposta sempre un lock_timeout breve così un DDL bloccato fallisce in fretta invece di intasare la coda. Su Postgres, costruisci gli indici con CREATE INDEX CONCURRENTLY così le scritture procedono durante la costruzione, e ricorda che aspetta le transazioni iniziate prima di esso, quindi elimina prima le query lunghe vaganti. Postgres avvolge anche il DDL in transazioni, così una migrazione fallita torna indietro in modo pulito.

Su MySQL il quadro dipende dalla versione. Verifica che il tuo cambio supporti ALGORITHM=INPLACE, LOCK=NONE, e tieni presente che alcune operazioni prima di 8.0.29 ricostruiscono l'intera tabella e bloccano le scritture. Per tabelle con un numero altissimo di righe in cui anche un ALTER online è rischioso, ricorri a uno strumento esterno: gh-ost o pt-online-schema-change su MySQL, pgroll o pg_osc su Postgres. Costruiscono una copia ombra, la sincronizzano a blocchi, e scambiano in modo atomico mentre l'originale resta pienamente utilizzabile.

Spostarsi su un nuovo database: caricamento di massa, CDC, cutover

Trasferire un database, attraverso motori, versioni o regioni, segue tre fasi. Primo, un caricamento di massa stabilisce una base: un dump e restore nativi, o uno snapshot, nel target. Secondo, la cattura dei dati di cambiamento (CDC) o la replica logica trasmette ogni inserimento, aggiornamento ed eliminazione dalla sorgente al target così che il divario continui a restringersi verso un ritardo quasi nullo. Per gli spostamenti all'interno dello stesso motore, la replica logica di Postgres o la replica binlog di MySQL è di solito il percorso più pulito, e la replica logica abbraccia perfino le versioni maggiori. Applica lo schema sul target per primo, perché la replica logica non trasporta il DDL.

Terzo è il cutover. Pianificalo come una finestra di sola lettura di secondi, non minuti: ferma brevemente le scritture sulla sorgente, conferma che il ritardo di replica ha raggiunto lo zero, poi reindirizza il traffico scambiando la stringa di connessione, il DNS o la rotta del bilanciatore di carico. Attento alla deriva di sequenze e auto-increment: se la sequenza del target è indietro rispetto alla sorgente, i nuovi inserimenti collidono con gli ID replicati. Dopo il cutover, esegui VACUUM/ANALYZE o OPTIMIZE TABLE, e non spegnere la sorgente. Tienila viva, idealmente in sola lettura, per almeno 24 ore come tuo rollback. Prima che qualcosa di tutto questo tocchi la produzione, fai un cutover di prova completo in staging contro dati su scala di produzione, perché un cambio che impiega due secondi su un portatile può impiegare ore su volume reale.

Spunti operativi ogni settimana

Unisciti ai responsabili di aziende di servizi che ricevono ogni settimana uno spunto concreto su operazioni, automazione e crescita.

Stiamo verificando che sia una persona. Potrà inviare tra un momento.

Niente spam. Disiscriviti quando vuoi.

Iscrizione completata! Cerca il prossimo numero nella tua casella di posta.

Dove questo si inserisce nel nostro modo di lavorare

Nessuno di questi passi è difficile preso da solo. Il rischio sta nel sequenziarli correttamente, nel sapere su quale fase puoi fermarti in sicurezza, e nell'avere un rollback che funzioni davvero sotto pressione. È esattamente il tipo di lavoro per cui sono fatti i nostri sprint a perimetro fisso di 30 giorni: una migrazione chiaramente definita, pianificata come expand-migrate-contract, con il runbook di backfill, validazione e cutover scritto e provato prima che qualunque cosa venga rilasciata.

Se stai migrando del tutto via da un vecchio sistema invece di rimodellare quello attuale, gli stessi principi guidano uno smantellamento pulito: doppia esecuzione, dimostra il nuovo percorso, poi ritira il vecchio secondo una tempistica documentata. E se preferisci che qualcuno possieda la strategia complessiva di dati e infrastruttura attraverso più di questi cambi, quello è territorio da CTO frazionario. In ogni caso, l'obiettivo è lo stesso di tutto questo articolo: rendere la migrazione noiosa.

Pronto a rilasciare?

Dicci dove sei bloccato. Lo esaminiamo e ti inviamo una raccomandazione mirata entro un giorno lavorativo.

Domande frequenti

Posso fare una migrazione senza tempi di inattività in un solo deploy?

No, non per nulla che vada oltre un cambio puramente additivo. Una migrazione sicura che cambia o rimuove una colonna o una tabella richiede almeno due cicli di release: uno per aggiungere la nuova struttura, scrivere in doppio e riempire, e uno successivo per spostare le letture ed eliminare la vecchia struttura. Tutto il senso è tenere il vecchio codice funzionante contro il nuovo schema durante la sovrapposizione, cosa che un singolo deploy atomico non può garantire.

La scrittura doppia dovrebbe vivere nell'applicazione o nei trigger di database?

Preferisci il livello applicativo nella maggior parte dei casi. Le scritture doppie esplicite compaiono nelle tue tracce e nei log, così quando le due copie divergono puoi fare il debug con gli strumenti di osservabilità che già usi. I trigger tengono la logica fuori dal tuo codice ma girano dentro il database dove il tuo tracciamento normale non può vederli, il che rende gli incidenti molto più difficili da diagnosticare. Per le scritture critiche per l'atomicità, instrada attraverso un outbox transazionale o una coda così la divergenza non possa avvenire in silenzio.

Come verifico che i dati vecchi e nuovi corrispondano davvero?

Non affidarti ai conteggi delle righe. Usa checksum o hash sulle tue tabelle critiche più controlli di invarianti su righe campionate, perché i conteggi possono corrispondere mentre i contenuti differiscono. Se la tua app legge già da entrambe le copie per alcune query, aggiungi un confronto in tempo reale che segnali le discordanze. Tieni la scrittura doppia in funzione e riconcilia per almeno un ciclo aziendale completo dopo aver spostato le letture prima di fidarti della nuova copia da sola.

Perché un cambio di schema veloce causa comunque un'interruzione?

Quasi sempre contesa di lock, non il DDL stesso. Un ALTER che ha bisogno di un lock esclusivo può bloccarsi dietro una transazione di lunga durata o una sessione aperta dimenticata, e ogni query che arriva dopo si accoda dietro il lock, trasformando un cambio veloce in uno stallo a livello dell'intero servizio. Imposta un lock_timeout breve così il DDL bloccato fallisce in fretta, usa CREATE INDEX CONCURRENTLY su Postgres, ed elimina le query lunghe vaganti prima di iniziare.

E le tabelle troppo grandi per un ALTER normale?

Usa uno strumento di cambio schema online che costruisce una copia ombra e la scambia. Su MySQL, gh-ost o pt-online-schema-change copiano i dati a blocchi e scambiano in modo atomico mentre l'originale resta utilizzabile. Su Postgres, pgroll gestisce il pattern expand-contract con viste consapevoli della versione, oppure pg_osc gestisce i grandi cambi una tantum. Devi comunque capire il locking; gli strumenti gestiscono il file e l'esecuzione, ma lock_timeout, CONCURRENTLY e i piccoli passi sicuri restano a carico tuo.

Com'è fatto un vero piano di rollback?

Il rollback diventa più facile quanto più sei presto nelle fasi. Dalla fase expand, la nuova colonna è additiva e inutilizzata per le letture, quindi togli semplicemente il codice di scrittura doppia e rilasci. A metà del cutover, riporta il flag di lettura sulla vecchia colonna, tieni la scrittura doppia in funzione, e indaga senza perdere i nuovi dati. Quando ti trasferisci su un nuovo database, tieni la sorgente viva e in sola lettura per almeno 24 ore dopo il cutover così da poter reindirizzare il traffico indietro se qualcosa emerge.