Dal monolite ai microservizi: una strategia di migrazione passo dopo passo

La maggior parte delle migrazioni ai microservizi fallisce per le stesse poche ragioni: confini sbagliati, una riscrittura in un colpo solo e uno strato dati che nessuno ha pianificato. Ecco un manuale sequenziato che consegna valore ogni poche settimane e ti permette di fermarti non appena i conti smettono di tornare.

4 min di lettura7 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

Prima, decidi se dovresti davvero migrare

La risposta onesta per molti team è: non ancora. Il sondaggio CNCF 2025 ha rilevato che circa il 42% delle organizzazioni che hanno adottato i microservizi stanno riportando alcuni servizi in unità più grandi perché il costo operativo ha superato il beneficio. Una soglia comune tra i professionisti: sotto i 30 sviluppatori circa o con un monolite sotto le 100.000 righe, i microservizi di solito aggiungono costo con poco ritorno. Migra quando più team sono bloccati a modificare la stessa base di codice, quando una funzionalità ha esigenze di scalabilità davvero diverse dal resto, o quando una capacità ha bisogno di un proprio team dedicato e di una propria cadenza di rilascio. Se la motivazione è solo che i monoliti sembrano superati, sistema prima la modularità all'interno del monolite (un monolite modulare) e risparmiati la tassa dei sistemi distribuiti.

Usa il pattern strangler fig, non una riscrittura in un colpo solo

Le riscritture complete sono il modo più affidabile di fallire: tempi lunghi, bollette cloud triplicate e guasti in produzione che nessuno riesce a isolare perché è cambiato tutto in una volta. Il pattern strangler fig, battezzato da Martin Fowler già nel 2004, fa crescere il nuovo sistema attorno al vecchio e ritira il monolite pezzo per pezzo. Introduci una facciata (di solito il tuo gateway API o uno strato di routing come Istio o un proxy basato su Envoy) che intercetta ogni richiesta. All'inizio instrada quasi tutto verso il monolite. Mentre estrai ogni funzionalità, sposti la sua rotta verso il nuovo servizio. Gli utenti non vedono mai un giorno di passaggio. E a ogni passo il vecchio percorso del codice è ancora lì, ed è il tuo rollback istantaneo se il nuovo servizio si comporta male.

Traccia i confini per dominio di business, non per strato tecnico

La causa numero uno delle migrazioni fallite è suddividere per strato tecnico: un servizio UI, un servizio di logica, un servizio di database. Questo produce un monolite distribuito, tutto l'overhead di rete senza nessuna delle indipendenze. Suddividi invece per capacità di business: Ordini, Inventario, Pagamenti, Notifiche. Il modo più rapido di trovare queste linee è un workshop di Event Storming (la tecnica di Alberto Brandolini): porta esperti di dominio e ingegneri in una stanza, mappa ciò che accade nel sistema come una linea temporale di eventi, poi raggruppali. I contesti delimitati emergono dove cambia il linguaggio. Il Prodotto in un contesto di catalogo (nome, immagini, SEO) è una cosa diversa dal Prodotto nell'inventario (SKU, magazzino, soglia di riordino). Dimensionali attorno al comportamento, non alle entità, oppure finisci con servizi anemici che da soli non fanno nulla.

Parti dai bordi, poi procedi verso l'interno

L'istinto è estrarre prima il nucleo facile: autenticazione, gestione utenti, il modello di dominio centrale. Resisti. Quelli sono esattamente i pezzi da cui dipende tutto il resto, quindi romperli rompe l'intero sistema. Parti dai bordi, le funzionalità foglia con poche dipendenze in entrata e confini API chiari. Un endpoint di reportistica, un worker di notifiche, un job di PDF o di esportazione, un'API pubblica in sola lettura. Questi ti danno una vera vittoria in produzione, dimostrano la pipeline (routing del gateway, deploy, osservabilità) e costruiscono il sostegno della dirigenza di cui hai bisogno per finire. Scegliere una prima fetta a basso rischio è anche ciò che impedisce a una migrazione di arenarsi in un Frankenstein permanente a metà strada, il modo più comune in cui questi progetti muoiono in silenzio.

Suddividi i dati con la CDC, non con le doppie scritture

I dati sono la parte più difficile di ogni migrazione, e le doppie scritture (far scrivere l'app sia nel vecchio sia nel nuovo database) sono una trappola: le scritture concorrenti perdono dati in silenzio e non hai alcuna garanzia transazionale tra due archivi. Usa invece la change data capture basata su log. Debezium (2.x e successivi, con connettori per PostgreSQL, MySQL, MongoDB, SQL Server e Oracle) legge il log delle transazioni del database ed emette un evento per ogni modifica confermata, così il nuovo servizio può costruire e tenere sincronizzato il proprio archivio senza toccare il percorso di scrittura del monolite. Le versioni recenti hanno aggiunto snapshot incrementali senza lock e una migliore semantica esattamente-una-volta. Per i nuovi servizi che devono pubblicare i propri eventi in modo affidabile, abbina la CDC al pattern outbox: scrivi la riga di business e la riga di evento in un'unica transazione locale, e lascia che la CDC la propaghi. E accetta il vero compromesso fin dall'inizio: le transazioni ACID tra servizi sono finite. Dove prima avvolgevi tutto in un'unica transazione, ora progetti per la consistenza eventuale con le saghe.

Passa una funzionalità alla volta e verifica in parallelo

Per ogni funzionalità, il ciclo è: estrai il servizio, indirizza una piccola fetta di traffico verso di esso attraverso il gateway, e fai girare il vecchio e il nuovo percorso fianco a fianco mentre confronti i risultati. Gli strumenti di suddivisione del traffico (Istio, Linkerd o un gateway Envoy) ti permettono di spostare l'1%, poi il 10%, poi il 100%, e di tornare indietro in pochi secondi annullando la rotta. Allestisci l'osservabilità prima dell'estrazione, non dopo il primo incidente: log strutturati, tracing distribuito (OpenTelemetry) e metriche per servizio in Prometheus o nell'APM che preferisci. Il motivo per cui i team rimpiangono i microservizi è di solito operativo: sostituire un'app con cinquanta significa circa cinquanta volte i deploy, i log e i dashboard, quindi la piattaforma deve essere pronta prima che arrivino i servizi. Una volta che una funzionalità ha girato pulita a pieno traffico, elimina il percorso di codice morto nel monolite. Solo quando l'ultima funzionalità è uscita dismetti il monolite. L'obiettivo è un finale chiaro, non due sistemi che accudisci per sempre.

Fissa tempistiche realistiche e una condizione di arresto

Analisi indipendenti delle migrazioni aziendali collocano la tempistica tipica end-to-end a circa 18-36 mesi per un sistema grande, con una manciata di fattori di rischio (confini, dati, maturità operativa) responsabili della maggior parte dei fallimenti. Metti a budget il lavoro di piattaforma, non solo i servizi: CI/CD, orchestrazione dei container, tracing e reperibilità devono maturare tutti in parallelo. Altrettanto importante, definisci una condizione di arresto in anticipo. Poiché l'approccio strangler consegna software funzionante ogni poche settimane, ti è concesso fermarti una volta che le parti dolorose sono uscite e il resto del monolite va bene dov'è. Una migrazione parziale è un esito legittimo, spesso ottimale. Il fallimento non è fermarsi presto, è arrancare su servizi che non avevano mai bisogno di spostarsi.

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.

Domande frequenti

Cos'è il pattern strangler fig in una migrazione?

È un approccio incrementale in cui fai crescere nuovi servizi attorno al monolite esistente e lo ritiri pezzo per pezzo. Uno strato di routing (di solito il tuo gateway API) si pone davanti, invia la maggior parte del traffico al monolite, e sposti la rotta di ogni funzionalità verso un nuovo servizio una volta che è pronto e verificato. Non c'è un giorno di passaggio, e il vecchio percorso del codice è il tuo rollback a ogni passo.

Quanto dura una migrazione dal monolite ai microservizi?

Per un grande sistema aziendale, analisi indipendenti collocano la tempistica tipica a circa 18-36 mesi end-to-end, incluso il lavoro di piattaforma (CI/CD, orchestrazione, osservabilità) da cui dipendono i servizi. Poiché l'approccio strangler consegna valore ogni poche settimane, ottieni benefici molto prima che la migrazione completa sia finita, e puoi fermarti una volta usciti i servizi ad alto valore.

Come si suddivide un database condiviso tra i servizi?

Evita le doppie scritture, che perdono dati in concorrenza. Usa la change data capture basata su log (per esempio Debezium che legge il log delle transazioni) così un nuovo servizio può costruire e sincronizzare il proprio archivio senza toccare le scritture del monolite. Abbinala al pattern outbox per una pubblicazione affidabile degli eventi, e progetta per la consistenza eventuale con le saghe invece che con transazioni tra servizi.

Quale servizio dovrei estrarre per primo?

Parti dai bordi, non dal nucleo. Scegli una funzionalità foglia con poche dipendenze in entrata e un confine pulito, come reportistica, notifiche o un job di esportazione. Estrarre per prima l'autenticazione o il modello di dominio centrale è rischioso perché tutto ne dipende. Una vittoria precoce e a basso rischio dimostra la pipeline e impedisce alla migrazione di arenarsi.

Dovrei davvero migrare ai microservizi?

Solo se hai un problema reale che i microservizi risolvono: più team bloccati su una base di codice, una funzionalità con esigenze di scalabilità davvero diverse, o una capacità che ha bisogno di un proprio team e di una propria cadenza. Circa il 42% degli adottanti (CNCF 2025) sta riconsolidando i servizi. Se il tuo team è piccolo o il monolite è modesto, un monolite modulare di solito consegna la maggior parte del beneficio senza nessun overhead dei sistemi distribuiti.

Perché la maggior parte delle migrazioni ai microservizi fallisce?

Tre cause ricorrenti: suddividere per strato tecnico invece che per dominio di business (creando un monolite distribuito), tentare una riscrittura in un colpo solo in cui nessun guasto può essere isolato, e sottovalutare la complessità dei dati e operativa. I confini sbagliati sono i più comuni. Usa l'Event Storming per trovare i confini di dominio, il pattern strangler per migrare in modo incrementale, e allestisci l'osservabilità prima di estrarre qualsiasi cosa.

Pronto a rilasciare?

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