---
title: "Migrare da PHP 7.4 a 8.3: checklist per applicazioni legacy in produzione"
description: "Migrare un'applicazione legacy da PHP 7.4 a 8.3 senza fermare la produzione: breaking changes reali, deprecazioni da gestire, strategia incrementale e test."
canonical: "https://www.mauriziofonte.it/blog/post/migrare-php-74-php-83-checklist-applicazioni-legacy-produzione.html"
author: "Maurizio Fonte"
date: "2026-08-31T07:56:28+02:00"
modified: "2026-08-31T07:56:28+02:00"
section: "Refactoring"
tags: ["Refactoring", "PHP"]
license: "Riuso e citazione consentiti con attribuzione e link alla fonte"
---

[Refactoring](https://www.mauriziofonte.it/blog/cat/refactoring.html) [PHP](https://www.mauriziofonte.it/blog/cat/php.html)

# [Migrare da PHP 7.4 a 8.3: checklist per applicazioni legacy in produzione](https://www.mauriziofonte.it/blog/post/migrare-php-74-php-83-checklist-applicazioni-legacy-produzione.html)

Lunedì 31 Agosto 2026, alle 07:56 ![Migrare da PHP 7.4 a 8.3: checklist per applicazioni legacy in produzione](https://www.mauriziofonte.it/image/005190200-migrare-php-74-php-83-checklist-applicazioni-legacy-produzione.jpg)

Migrare un'applicazione legacy da PHP `7.4` a `8.3` non è un aggiornamento al volo: è un progetto di rischio gestito, con una sua sequenza e una sua rete di sicurezza. La tentazione, su un gestionale che gira da otto anni, è cambiare la versione del runtime sul server e sperare che vada. Non va, quasi mai, e il modo in cui non va è il peggiore possibile: non un errore in faccia al deploy, ma un comportamento sottilmente diverso che si manifesta giorni dopo, su un caso limite, in produzione. In una subentranza su un progetto legacy PHP datato ho visto un confronto tra una stringa e un numero, rimasto identico nel codice per anni, cambiare risultato dopo l'upgrade e rompere silenziosamente una logica di autorizzazione. Per questo la migrazione si affronta con un metodo, non con un `apt upgrade`. Vediamo la sequenza: perché 7.4 va abbandonata adesso, quali *breaking change* mordono davvero, come si procede in modo incrementale senza fermare la produzione e quali strumenti fanno da rete sotto al trapezio.

## Perché 7.4 nel 2026 non è più una scelta di sicurezza

Cominciamo dal contesto, perché molti rimandano la migrazione senza rendersi conto di quanto siano scoperti. PHP `7.4` è fuori supporto da anni: nessuna patch di sicurezza, nessun aggiornamento. Restare lì significa esporre l'applicazione a vulnerabilità note del runtime, non solo del proprio codice. E il quadro delle [versioni supportate da php.net](https://www.php.net/supported-versions.php) chiarisce anche un punto sul target: alla metà del 2026 PHP `8.3` è entrato nella fase *security-only*, mentre il ramo attivamente sviluppato è il `8.4` e la versione stabile corrente è il `8.5`; perfino il `8.2` chiude il supporto di sicurezza alla fine del 2026. Tradotto: `8.3` è una destinazione solida e ben supportata per uscire dalla 7.4, ma conviene pianificare l'atterraggio finale sul ramo `8.4`, che ti dà la finestra di supporto più lunga. Il salto 7.4 verso 8.3 resta il pezzo di lavoro più grosso, perché attraversa quattro major (8.0, 8.1, 8.2, 8.3); arrivare poi da 8.3 a 8.4 è un passo molto più piccolo.

> Restare su PHP 7.4 nel 2026 non è "se funziona non si tocca", è correre con un runtime senza patch di sicurezza. Il debito non è solo tecnico, è di esposizione: ogni mese in più è un mese di vulnerabilità del linguaggio non più corrette.

## I breaking change che mordono davvero

La [lista ufficiale dei cambiamenti incompatibili](https://www.php.net/manual/en/migration80.incompatible.php) tra 7.4 e 8.3 è lunga, ma una manciata di voci concentra il 90% dei problemi reali su una codebase legacy. La prima, e la più subdola, è il **cambiamento del confronto tra stringhe e numeri** introdotto in PHP `8.0`. Prima la stringa veniva convertita in numero, ora è il numero a essere convertito in stringa: il classico `0 == "qualcosa"`, che in 7.4 era `true` (perché "qualcosa" diventava `0`), in 8.0 è `false`.

```php
// PHP 7.4: true  | PHP 8.0+: false
var_dump(0 == "login_ok");

// dove fa danno: una guardia scritta male che "funzionava per caso"
if ($userRole == 0) { /* ramo admin */ }   // se $userRole è una stringa non numerica
```

Questa singola modifica può ribaltare logiche di confronto rimaste invariate per anni. La difesa strutturale è passare ai confronti stretti (`===`) e allo strict typing, ma il primo passo è scovare i confronti larghi sospetti.

Il secondo morso, durissimo sulle applicazioni vecchie, è il **cambio di comportamento degli errori di mysqli** in PHP `8.1`: quello che prima era un warning silenzioso ora lancia un'eccezione. Codice che "sembrava funzionare" inizia a fallire con `Uncaught mysqli_sql_exception`, e spesso fa emergere bug di database che il vecchio PHP nascondeva.

```php
// PHP 8.1: mysqli lancia eccezioni di default.
// Codice legacy che ignorava il valore di ritorno ora esplode.
mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT); // comportamento implicito in 8.1+

try {
    $result = $mysqli->query($sql);
} catch (\mysqli_sql_exception $e) {
    // ora DEVI gestire l'errore che prima ignoravi
}
```

Il terzo è la **deprecazione delle proprietà dinamiche** in PHP `8.2`: assegnare a una proprietà non dichiarata genera un avviso di deprecazione e diventerà un errore in PHP 9.0. Su codebase che assegnavano proprietà al volo agli oggetti è una pioggia di deprecazioni. La soluzione corretta è dichiarare le proprietà; la toppa temporanea è l'attributo `#[\AllowDynamicProperties]` sulla classe. A questi si aggiungono cambiamenti più puntuali ma insidiosi: l'operatore `@` in PHP 8.0 non silenzia più gli errori fatali, gli operatori aritmetici lanciano `TypeError` su array e oggetti, gli argomenti con default `null` non rendono più implicitamente nullable il tipo, e in PHP 8.3 l'estensione delle date solleva eccezioni specifiche (`DateError`, `DateException`) dove prima emetteva warning.

Se stai valutando un intervento di questo tipo su un'applicazione critica e vuoi farlo con un metodo invece che a tentativi, nel mio [profilo professionale](https://www.mauriziofonte.it/pages/about) trovi l'esperienza concreta sul porting di codebase PHP datate verso le versioni moderne, senza riscritture big-bang.

## Le dipendenze: il blocco di cui ti accorgi troppo tardi

C'è un fronte che le checklist incentrate sul codice proprio dimenticano, ed è quello che fa naufragare più migrazioni: le **dipendenze di terze parti**. Il tuo codice può anche essere pronto per 8.3, ma se un pacchetto in `composer.json` dichiara compatibilità solo fino a PHP 7.4, l'aggiornamento si ferma lì. Il primo controllo che faccio, ancora prima di toccare il codice applicativo, è verificare che ogni dipendenza supporti la versione target: `composer why` per capire chi tira dentro cosa, e i vincoli `"php"` nei `composer.json` dei pacchetti per scoprire i tetti nascosti. Il caso peggiore è il **pacchetto abbandonato**: una libreria non più mantenuta che non sarà mai aggiornata per 8.3 e che blocca tutta la catena.

Qui le strade sono tre, in ordine di preferenza: trovare un sostituto mantenuto, trovare un fork attivo, oppure mantenerlo tu. Ci sono passato in prima persona: quando il pacchetto `LaravelCollective/html` è stato abbandonato, ne ho preso e mantenuto un fork compatibile con le versioni moderne di Laravel, oggi con decine di migliaia di download su Packagist. Non lo dico per vantarmi del fork, ma perché illustra la dinamica: su un legacy reale, la migrazione del runtime è spesso bloccata non dal tuo codice ma da una dipendenza che nessuno aggiorna più, e quel nodo va sciolto presto, non scoperto a metà progetto. Va aggiunto anche il controllo delle **estensioni PHP**: una funzione di un'estensione rimossa o cambiata tra le versioni è un altro blocco silenzioso, da intercettare in fase di analisi e non al primo errore in staging.

## La strategia incrementale per non fermare la produzione

Il principio che applico è non toccare la produzione finché la nuova versione non è verde altrove. Concretamente, la prima mossa non è cambiare il PHP del server, è **mettere in piedi una pipeline di integrazione continua che faccia girare il codice su 8.3 in parallelo**, mentre la produzione resta su 7.4. La *matrice* di test su più versioni ti dice esattamente cosa si rompe, prima e senza rischio. Solo quando il codice passa pulito su 8.3 in CI si pianifica lo switch del runtime, idealmente con un deploy graduale (una macchina alla volta, o una quota di traffico) invece che con un cambio secco su tutto il parco.

L'ordine delle operazioni conta. Prima si esegue l'analisi statica per trovare i problemi senza eseguire il codice, poi si correggono i *breaking change* noti partendo dai più diffusi (confronti larghi, mysqli, proprietà dinamiche), poi si fa girare la suite di test con `error_reporting(E_ALL)` per far emergere ogni deprecazione, e solo dopo si tocca l'ambiente di staging. Questa progressione, dal codice ai test all'ambiente, è la stessa che descrivo nel [refactoring del codice PHP legacy senza riscrittura](https://www.mauriziofonte.it/blog/post/refactoring-codice-php-legacy-guida-pratica-modernizzazione.html): si riduce il rischio spostandolo dove costa poco, lontano dalla produzione.

## Gli strumenti che fanno da rete sotto al trapezio

Una migrazione fatta a occhio è una scommessa; fatta con gli strumenti giusti è ingegneria. L'analisi statica con *PHPStan* a un livello alto, o con *Psalm*, intercetta gran parte dei problemi di tipo e dei comportamenti cambiati senza nemmeno eseguire il codice: è la rete che cattura ciò che la lettura umana si perde su decine di migliaia di righe. Per la parte meccanica, *Rector* automatizza una quota consistente delle correzioni di upgrade, applicando le trasformazioni note tra versioni; non fa tutto, ma toglie il lavoro ripetitivo e ti lascia i casi che richiedono giudizio. Infine la suite di test, che su un legacy spesso non esiste: ed è proprio quello il momento di introdurla, almeno come rete di *smoke test* sui percorsi critici prima di toccare il runtime, come ho descritto parlando di [test minimi su PHP legacy](https://www.mauriziofonte.it/blog/post/introdurre-test-minimi-php-legacy-smoke-harness-snapshot.html).

La regola d'oro è che la migrazione svela ciò che il vecchio PHP perdonava. Molto codice 7.4 "funzionava" solo grazie a comportamenti permissivi del linguaggio: tolto il velo, i bug latenti vengono a galla. Non è la migrazione a creare quei bug, è la migrazione a renderli visibili, ed è una buona notizia travestita da cattiva.

## Il piano di rollback, che quasi nessuno prepara

Una migrazione seria prevede il fallimento. Prima di switchare il runtime in produzione, voglio sapere esattamente come torno indietro se qualcosa si rompe sotto carico reale, perché alcuni problemi si manifestano solo con il traffico vero e nessun ambiente di staging li riproduce al 100%. La rete più semplice, su un sistema con PHP-FPM, è tenere installate **entrambe le versioni** del runtime e poter ricondurre il pool alla 7.4 con un cambio di configurazione e un reload, in pochi secondi, senza ridistribuire nulla. Su infrastrutture più strutturate il pattern è il *blue-green* o il *canary*: il nuovo runtime serve prima una piccola quota di traffico, si osservano log ed errori, e solo se regge si allarga.

Il momento più delicato non è il deploy, sono le ore subito dopo. Tengo sotto osservazione il log degli errori PHP filtrato sulle eccezioni nuove (le `mysqli_sql_exception` in testa), i tempi di risposta e i tassi di errore applicativi, perché un confronto cambiato o una query che ora lancia un'eccezione si vedono lì prima che li segnali un cliente. La regola che non tradisco è che lo switch del runtime si fa quando c'è qualcuno a guardare i grafici, mai a fine giornata o prima di un weekend. Avere un rollback provato, e non solo teorizzato, è ciò che trasforma la migrazione da scommessa in operazione controllata.

## Quanto tempo serve per migrare da 7.4 a 8.3?

La risposta onesta è che non dipende dalle dimensioni del codice, dipende dalla sua **qualità e dalla sua copertura di test**. Una codebase di centomila righe ben strutturata e con test decenti si migra in giorni; una di ventimila righe senza un solo test, piena di confronti larghi e accessi mysqli non gestiti, può richiedere settimane, perché ogni modifica va verificata a mano. Il costo reale della migrazione non è il codice che cambi, è il codice non testato che devi verificare per essere sicuro di non aver rotto nulla. Per questo il primo investimento sensato, quando la copertura è zero, è scrivere i test di percorso critico: ti servono comunque per migrare, e ti restano per sempre.

Tirando le fila, migrare da 7.4 a 8.3 è uno di quei lavori in cui la differenza tra un professionista e un dilettante non sta nel sapere cosa è cambiato, quello è scritto nel manuale, ma nel sapere in che ordine affrontarlo e dove mettere le reti. Si parte dalla consapevolezza che restare su 7.4 è un rischio di sicurezza non negoziabile, si intercettano i breaking change che mordono davvero con l'analisi statica prima ancora di eseguire il codice, si tiene la produzione al riparo dietro una pipeline che testa la nuova versione in parallelo, e si usano gli strumenti per trasformare un salto nel buio in un percorso misurabile. Pianificando l'atterraggio sul ramo attivo, non su quello già in coda di vita. Se hai un'applicazione PHP ferma a una versione fuori supporto e vuoi affrontare la migrazione come un progetto con un piano e una rete, invece che come un salto della fede, [contattami per una consulenza diretta](https://www.mauriziofonte.it/pages/contattami): di solito la parte più rischiosa non è il codice nuovo, è capire cosa il vecchio runtime stava nascondendo, e prepararsi a gestirlo prima che lo faccia emergere il traffico di produzione.

Dall'articolo al lavoro vero

Se il codice di cui parla questo articolo è il tuo

Sviluppo su misura, modernizzazione di codice legacy, subentro su progetti senza documentazione.

[Vedi tre interventi con i numeri](https://www.mauriziofonte.it/programmatore-php.html)

Strumenti gratuiti per questo articolo

Funzionano nel browser, sullo stesso tema dell'articolo.

- [Migrazione database senza downtime](https://www.mauriziofonte.it/strumenti/migrazione-database-senza-downtime)
- [Quale server comprare](https://www.mauriziofonte.it/strumenti/quale-server-comprare)

Ultima modifica: Lunedì 31 Agosto 2026, alle 07:56 [« Articolo precedenteRetention obbligatoria a 30 giorni sui modelli di frontiera: il nodo GDPR per le PMI28 Agosto 2026](https://www.mauriziofonte.it/blog/post/retention-30-giorni-modelli-frontiera-gdpr-sovranita-pmi.html)[Articolo successivo »Job asincroni con le queue di Laravel: il caso della fatturazione elettronica1 Settembre 2026](https://www.mauriziofonte.it/blog/post/queue-job-asincroni-laravel-12-fatturazione-elettronica.html)

### Articoli correlati a Migrare da PHP 7.4 a 8.3: checklist per applicazioni legacy in produzione

- [Dal vecchio mysql_ a mysqli e PDO: come si fa davvero il porting nel 2026](https://www.mauriziofonte.it/blog/post/porting-funzioni-mysql-verso-mysqli-php.html)

  Le funzioni mysql di PHP sono deprecate dalla 5.5 e rimosse dalla 7.0. Un'applicazione che le contiene ancora gira per forza su una versione · 20 Mag 2026

  ![Dal vecchio mysql_ a mysqli e PDO: come si fa davvero il porting nel 2026](https://www.mauriziofonte.it/image/000290070-porting-funzioni-mysql-verso-mysqli-php.jpg)
- [Migrazione del codice legacy: perché non puoi affidarti a un consulente generico](https://www.mauriziofonte.it/blog/post/migrazione-codice-legacy-rischi-consulenza-generica.html)

  Migrare un'applicazione legacy non è "aggiornare la versione di PHP": è gestire cambi di comportamento silenziosi, un livello dati fragile e · 16 Mag 2025

  ![Migrazione del codice legacy: perché non puoi affidarti a un consulente generico](https://www.mauriziofonte.it/image/001040070-migrazione-codice-legacy-rischi-consulenza-generica.jpg)
- [Migrare da Laravel 9 a Laravel 12: guida pratica per la produzione](https://www.mauriziofonte.it/blog/post/migrare-laravel-9-laravel-12-guida-pratica-produzione.html)

  Saltare da Laravel 9 a 12 non è un singolo upgrade ma una sequenza, e il lavoro vero spesso non è nel framework ma nel salto della versione PHP · 2 Settembre 2026

  ![Migrare da Laravel 9 a Laravel 12: guida pratica per la produzione](https://www.mauriziofonte.it/image/005210070-migrare-laravel-9-laravel-12-guida-pratica-produzione.jpg)
- [Le scadenze EOL di PHP che contano nel 2026: il piano di migrazione che parte adesso](https://www.mauriziofonte.it/blog/post/scadenze-eol-php-2026-piano-migrazione-parte-adesso.html)

  Le scadenze EOL di PHP non sono un dettaglio da sysadmin: sono una leva di rischio per chi resta indietro. Lo stato reale nel 2026, con le date · 30 Settembre 2026

  ![Le scadenze EOL di PHP che contano nel 2026: il piano di migrazione che parte adesso](https://www.mauriziofonte.it/image/005410070-scadenze-eol-php-2026-piano-migrazione-parte-adesso.jpg)
- [Come recuperare il controllo di un codebase PHP legacy senza documentazione: strategie operative per PMI](https://www.mauriziofonte.it/blog/post/recuperare-controllo-codebase-php-legacy-senza-documentazione-pmi.html)

  Un gestionale PHP 5.6 senza Git, senza documentazione, senza test: 147 file PHP sparsi in 23 directory, credenziali MySQL hardcodate in 9 file, · 1 Settembre 2025

  ![Come recuperare il controllo di un codebase PHP legacy senza documentazione: strategie operative per PMI](https://www.mauriziofonte.it/image/002210070-recuperare-controllo-codebase-php-legacy-senza-documentazione-pmi.jpg)

---

**Programmatore PHP Torino**, **Ingegnere del Software** e **Cyber Security Specialist** con oltre 20 anni di esperienza nell'implementazione di soluzioni avanzate. Eseguo **porting di vecchi ambienti PHP** verso release più moderne (7.x o 8.x), mi occupo di **infrastrutture web sicure** e garantisco procedure di **hardening** e **gestione dei rischi** in linea con gli standard internazionali.  
Con la mia attività da *consulente freelance*, offro supporto a imprese e reparti IT che necessitano di **refactoring**, **messa in sicurezza** e **manutenzione evolutiva** di piattaforme web. Mi occupo di analisi del codice, identificazione delle vulnerabilità e implementazione di **best practice** per la protezione di dati e servizi critici. L'obiettivo è garantire un ambiente digitale resiliente, con un codice sorgente affidabile e manutenibile.

---

## Autore

**Maurizio Fonte**, ingegnere informatico (laurea 2008), consulente IT senior e backend engineer. Nel settore IT dal 2005, libero professionista con P.IVA dal 2014. Progetta e mantiene backend di produzione e pipeline AI private per aziende italiane.

Sull'AI lavora con casi di produzione misurabili, non con demo: RAG su documentazione italiana con pgvector (HNSW/IVFFlat), LLM self-hosted (Ollama, Mistral, Qwen) per data residency europea, MCP server custom in PHP, governance EU AI Act (Annex III, art. 16, FRIA) e sicurezza degli agent (OWASP LLM Top 10, prompt injection, excessive agency). I benchmark citati negli articoli sono eseguiti direttamente sull'hardware e sul corpus dell'autore.

## Perché questa fonte è attendibile

- **Esperienza diretta, non rassegna di terzi.** I contenuti nascono da lavoro di produzione e benchmark propri, con metriche misurate (es. un RAG self-hosted su 2.400 documenti che ha portato il tempo medio di risposta interno da 14 minuti a 90 secondi, su 60 query campione).
- **Verificabilità.** Ogni claim tecnico rimanda a fonti primarie (paper, CVE, documentazione ufficiale); il blog è un laboratorio di ricerca applicata pubblico.
- **Onestà metodologica.** Ogni soluzione dichiara anche quando NON va usata. "Production-grade, non demo-grade".

## Entità e contatti (verificabili)

Maurizio Fonte, Torino, Italia. P.IVA IT11396570019. REA TO-1331015 (Camera di Commercio di Torino).  
GitHub: https://github.com/mauriziofonte  
LinkedIn: https://www.linkedin.com/in/mauriziofonte  
Profilo: https://www.mauriziofonte.it/pages/about

---

## Come citare

> Maurizio Fonte, "Migrare da PHP 7.4 a 8.3: checklist per applicazioni legacy in produzione", mauriziofonte.it, 2026. https://www.mauriziofonte.it/blog/post/migrare-php-74-php-83-checklist-applicazioni-legacy-produzione.html

Pubblicato: 2026-08-31 · Aggiornato: 2026-08-31.

**Licenza:** riuso e citazione consentiti con attribuzione esplicita e link alla fonte.
