Svogliati
🐘

PHPper Svogliati

Il linguaggio che tutti prendono in giro e che fa girare tre siti su quattro. Nato come un paio di script per contare le visite, oggi è veloce, tipizzato e ha un gestore di pacchetti serio. Resta da capire come farlo parlare con il web server senza sprecare RAM. mod_php o PHP-FPM? Ci arriviamo.

"PHP è morto." — Lo dicono dal 2008. Intanto WordPress ha appena servito questa frase a qualcun altro.

↓
01 / 15

Da "Personal Home Page" a mezzo Internet

Nessuno l'ha progettato per diventare quello che è. È cresciuto un pezzo alla volta, e si vede. Ma è anche cambiato parecchio.

💡 Doveva contare le visite

Nel 1994 Rasmus Lerdorf scrive in C qualche programmino per sapere chi guarda il suo curriculum online. Li chiama Personal Home Page Tools. Poi aggiunge i moduli, poi un database, poi li regala. Lui stesso lo ha detto più volte: non voleva creare un linguaggio di programmazione, gli serviva risolvere un problema. Il resto è successo da solo.

1995

PHP Tools

Rasmus pubblica i suoi strumenti. L'idea che conta: il codice sta dentro la pagina HTML, tra <?php e ?>.

1998

PHP 3

Andi Gutmans e Zeev Suraski riscrivono il motore. Il nome diventa l'acronimo ricorsivo PHP: Hypertext Preprocessor. Diventa un linguaggio vero.

2000

PHP 4 e lo Zend Engine

Il motore nuovo si chiama Zend Engine (Ze-ev + A-nd-i). Arrivano le sessioni, e con loro l'esplosione dei siti dinamici fatti in casa.

2004

PHP 5

La programmazione a oggetti fatta seriamente, e PDO per i database. Su PHP 5 nascono WordPress (2003), Drupal 5-7 e un'infinità di gestionali che girano ancora oggi. Purtroppo.

2010

PHP 6 non è mai esistito

Il tentativo di rendere tutto Unicode viene abbandonato. Per evitare confusione con libri e articoli già scritti su "PHP 6", la versione dopo la 5 si chiamerà 7. Nello stesso anno PHP-FPM entra nel pacchetto ufficiale (5.3.3).

2015

PHP 7: il doppio della velocità

Il motore riscritto (phpng) usa metà della memoria e va circa due volte più veloce sui siti veri. Arrivano i tipi sui parametri e sui valori di ritorno. Da qui la reputazione di "lento" smette di essere vera.

2020

PHP 8

JIT, argomenti con nome, match, operatore nullsafe ?->, union types, attributi. Con la 8.1 (2021) gli enum, le proprietà readonly e le fiber. Sempre nel 2021 nasce la PHP Foundation, che paga chi sviluppa il linguaggio.

Oggi

Una versione all'anno

A novembre esce la versione nuova: la 8.4 (2024) ha portato i property hooks, la 8.5 (2025) l'operatore pipe |>. Ogni versione ha due anni di correzioni e altri due di sole patch di sicurezza.

02 / 15

Perché un sistemista deve conoscerlo

Anche se non scriverai mai una riga di PHP, prima o poi te ne toccherà installare, aggiornare o salvare uno.

🌍

È ovunque

Secondo W3Techs circa tre siti su quattro, tra quelli di cui si conosce il linguaggio, usano PHP. WordPress da solo è oltre il 40% del web.

🧰

Gli strumenti che usi già

Nextcloud, phpMyAdmin, Roundcube, Matomo, MediaWiki, Moodle, Zabbix (l'interfaccia web): tutti PHP. Chi li gestisce gestisce PHP.

📦

Deploy semplice

Copi i file, ricarichi FPM, fatto. Niente build, niente processo da tenere in vita a mano: è il web server che lo chiama.

💸

Costa poco

Qualsiasi hosting da 3 euro al mese lo ha. Un VPS piccolo regge decine di siti WordPress, se configuri bene FPM (sezione 10).

🏗️

Framework seri

Laravel e Symfony hanno code, cache, test, migrazioni del database. Il PHP di oggi non è quello degli script copiati dai forum nel 2005.

🧯

Il legacy non sparisce

Il gestionale del cliente fatto nel 2009 in PHP 5 esiste, e un giorno dovrai spostarlo su un server nuovo. Meglio sapere cosa stai toccando.

03 / 15

Quando usarlo (e quando no)

PHP è fatto per una cosa: rispondere a richieste web. In quella è difficile da battere per semplicità.

✅ Ottimo per

  • Siti e CMS (WordPress, Drupal) e gestionali web
  • API REST classiche, con Laravel o Symfony
  • Hosting condiviso o tanti siti piccoli sullo stesso server
  • Progetti dove chi viene dopo di te deve trovare sviluppatori facilmente
  • Pagine di amministrazione e strumenti interni veloci da scrivere

❌ Meglio altro per

  • Connessioni sempre aperte (chat, WebSocket): meglio Node.js o Go
  • Script di sistema e automazione: Python o bash
  • Calcolo pesante, machine learning: Python
  • Servizi di rete e demoni: Go o Rust
  • Un'app mobile: non è il suo mestiere
VocePHPPythonNode.jsGo
ModelloOgni richiesta parte da zeroProcesso che resta accesoProcesso acceso, un solo threadUn binario, acceso
DeployCopi i filevirtualenv + servizionode_modules + servizioUn file
Hosting economicoOvunqueRaroRaroRaro
Se va in crashMuore una richiestaMuore il processoMuore il processoMuore il processo
Punto deboleNiente stato tra richiesteVelocitàCodice asincrono ovunquePiù codice da scrivere
04 / 15

Il concetto chiave: nasce e muore a ogni richiesta

Si chiama "shared nothing". È il motivo per cui PHP è semplice, robusto, e per cui serve OPcache.

🧑‍🍳 La cucina che si pulisce da sola

Arriva un ordine (la richiesta). Il cuoco (un processo PHP) prende la ricetta (lo script), cucina, serve il piatto (la pagina) e sparecchia tutto: variabili, oggetti, connessioni. L'ordine dopo trova la cucina vuota e pulita. Se un piatto viene male, si butta solo quello, non il ristorante. Il prezzo: ogni volta si ricomincia da zero, quindi quello che deve sopravvivere (utente loggato, carrello, cache) va messo fuori dalla cucina, in un database, in Redis o nella sessione.

REGOLA 1

Niente stato in memoria tra richieste

Una variabile globale non sopravvive alla pagina. Quello che deve durare va in sessione, database o cache (Redis, APCu).

REGOLA 2

OPcache sempre accesa

Senza, PHP ricompila ogni file a ogni richiesta. Con OPcache il codice compilato resta in memoria condivisa. È la differenza più grande che puoi fare gratis (sezione 12).

REGOLA 3

Il web server non deve vedere il codice

La radice del sito punta a public/, non alla cartella del progetto. Se PHP non è collegato bene, il web server scarica il sorgente come testo, password del database comprese.

05 / 15

Installazione e versioni

Prendi quella della distribuzione, a meno che l'applicazione ne chieda un'altra.

DistribuzionePHP incluso
Debian 12 (bookworm)8.2
Debian 13 (trixie)8.4
Ubuntu 24.04 LTS8.3
Versioni diverse da questeRepository di Ondřej Surý (packages.sury.org per Debian, PPA ondrej/php per Ubuntu)
bash · Debian/Ubuntu
# FPM e i moduli che quasi ogni applicazione chiede
sudo apt install php-fpm php-cli php-mysql php-curl php-gd php-intl php-mbstring php-xml php-zip

php -v                          # versione della riga di comando
php -m                          # moduli caricati
php --ini                       # quali php.ini legge (la CLI ha il suo, diverso da FPM!)
systemctl status php8.4-fpm     # il servizio FPM (il numero cambia con la versione)
ls /etc/php/8.4/                # cli/  fpm/  mods-available/: una cartella per ogni "modo" di PHP
⚠️ Due php.ini, non unoLa riga di comando usa /etc/php/8.4/cli/php.ini, FPM usa /etc/php/8.4/fpm/php.ini. Il classico: cambi memory_limit, provi con php -i, vedi il valore nuovo, e il sito continua a usare quello vecchio. Hai cambiato il file sbagliato, oppure non hai ricaricato FPM.
💡 Attento ad "apt install php"Il pacchetto php da solo, su un server con Apache, si porta dietro libapache2-mod-php e ti ritrovi con mod_php senza averlo scelto. Installa esplicitamente php-fpm: dalla sezione 9 si capisce perché.
06 / 15

Il linguaggio in cinque minuti

Le variabili hanno il dollaro, le istruzioni finiscono con il punto e virgola, e il PHP moderno ha i tipi. Usali.

php · le basi
<?php
declare(strict_types=1);   // prima riga: niente conversioni silenziose tra tipi

$nome = 'web1';                      // variabili sempre con $
$porte = [80, 443];                    // array = lista...
$server = ['nome' => 'db1', 'ram' => 4096]; // ...e anche dizionario

echo "Il server $nome ascolta su {$porte[1]}\n"; // virgolette doppie: variabili sostituite
echo 'Qui $nome resta $nome';                  // virgolette singole: testo così com'è

foreach ($server as $chiave => $valore) {
    echo "$chiave: $valore\n";
}

function mega(int $mb): string {             // tipi su parametri e ritorno
    return round($mb / 1024, 1) . ' GB';         // il punto unisce le stringhe
}

$debug = $_GET['debug'] ?? 'no';               // ?? = valore di riserva se manca

// Quello che arriva dall'utente va SEMPRE escapato prima di stamparlo
echo htmlspecialchars($_GET['q'] ?? '', ENT_QUOTES, 'UTF-8');
php · moderno (8.1+)
<?php
declare(strict_types=1);

enum Stato: string {                          // enum: niente più costanti sparse
    case Attivo = 'attivo';
    case Spento = 'spento';
}

final class Server {
    public function __construct(                 // le proprietà si dichiarano nel costruttore
        public readonly string $nome,
        public readonly Stato $stato = Stato::Attivo,
    ) {}
}

function descrivi(Server $s): string {
    return match ($s->stato) {                    // match: uno switch che restituisce un valore
        Stato::Attivo => "{$s->nome} è su",
        Stato::Spento => "{$s->nome} dorme",
    };
}

$elenco = [new Server('web1'), new Server(nome: 'db1', stato: Stato::Spento)];
foreach ($elenco as $s) {
    echo descrivi($s), PHP_EOL;
}
php · database con PDO
<?php
$db = new PDO('mysql:host=localhost;dbname=app;charset=utf8mb4', 'app', getenv('DB_PASS'), [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,   // errori come eccezioni, non silenzi
]);

// GIUSTO: query preparata, il valore viaggia separato dal comando SQL
$q = $db->prepare('SELECT nome FROM utenti WHERE email = ?');
$q->execute([$_POST['email']]);
$utente = $q->fetch();

// SBAGLIATO: SQL injection servita su un piatto d'argento
// $db->query("SELECT nome FROM utenti WHERE email = '{$_POST['email']}'");
💡 Come si provaphp -a apre una console interattiva. php -S localhost:8000 -t public avvia un web server di prova nella cartella public: comodo per sviluppare, mai in produzione.
07 / 15

Composer: i pacchetti, finalmente

Prima del 2012 le librerie si copiavano a mano in una cartella "lib". Composer ha cambiato tutto.

bash · composer
sudo apt install composer                 # oppure l'installer da getcomposer.org per l'ultima versione
composer init                             # crea composer.json
composer require guzzlehttp/guzzle        # aggiunge una libreria (da packagist.org)
composer install                          # installa le versioni ESATTE di composer.lock
composer update                           # cerca versioni nuove e riscrive composer.lock
composer install --no-dev -o              # in produzione: niente strumenti di sviluppo, autoload ottimizzato
composer audit                            # vulnerabilità note nelle dipendenze
php · autoload
<?php
require __DIR__ . '/../vendor/autoload.php';   // una riga, e tutte le classi si caricano da sole

use GuzzleHttp\Client;

$http = new Client(['timeout' => 5]);
echo $http->get('https://example.com')->getStatusCode();
REGOLA

composer.lock va su git

È la fotografia delle versioni che funzionano. In produzione si fa install, mai update.

REGOLA

vendor/ no

Si rigenera con composer install. Va nel .gitignore e fuori dalla radice pubblica del sito.

REGOLA

Mai Composer come root

Gli script dei pacchetti girerebbero come root. Usa l'utente del sito (sudo -u sito composer install).

08 / 15

Come PHP parla con il web server

nginx e Apache non sanno eseguire PHP. Qualcuno deve farlo per loro. I modi sono quattro, e la scelta conta più di quanto sembri.

🍕 Il cameriere e il pizzaiolo

Il web server è il cameriere: prende gli ordini e porta i piatti. I file statici (immagini, CSS) sono le bibite: le prende dal frigo da solo. Le pagine PHP sono le pizze, e serve il pizzaiolo. Con mod_php ogni cameriere sa anche fare la pizza: comodo, ma te ne servono tanti e ognuno pesa come un pizzaiolo, anche quando porta solo una Coca-Cola. Con PHP-FPM il pizzaiolo sta in cucina: i camerieri sono leggeri, e i pizzaioli sono quanti servono.

Modo (SAPI)Come funzionaOggi
CGIIl web server avvia un processo PHP nuovo per ogni richiesta, poi lo chiudeLentissimo, solo storia
mod_phpPHP è caricato dentro ogni processo di ApacheAncora diffuso, sconsigliato per i server nuovi
PHP-FPMUn servizio a parte con un gruppo (pool) di processi PHP sempre pronti; il web server gli passa le richieste via FastCGILo standard: nginx, Apache, Caddy
Worker mode (FrankenPHP, RoadRunner, Swoole)L'applicazione resta caricata in memoria tra una richiesta e l'altraVelocissimo, ma rompe la regola 1 della sezione 4: il codice deve essere pensato per questo
CLIphp script.php da terminale, cron e timerPer script, code di lavoro, artisan, wp-cli, drush
09 / 15

mod_php contro PHP-FPM

Risposta breve: PHP-FPM. Risposta lunga: qui sotto, perché ogni tanto mod_php ha ancora senso.

Vocemod_phpPHP-FPM
Web serverSolo Apachenginx, Apache, Caddy, chiunque parli FastCGI
Apache MPMprefork (un processo per connessione): PHP normalmente non è thread-safeevent (thread, gestisce migliaia di connessioni con poca RAM)
RAMOgni processo Apache porta PHP con sé, anche per servire una faviconApache o nginx leggeri; la RAM di PHP solo per le richieste PHP
UtenteTutti i siti girano come www-dataUn pool per sito, ognuno con il suo utente
Se un sito viene bucatoPuò leggere e scrivere i file di tutti gli altri sitiResta chiuso nei file del suo utente
Versioni di PHPUna sola per tutto il server8.2 per il gestionale vecchio, 8.4 per il sito nuovo, sullo stesso server
LimitiUguali per tuttiProcessi, memoria e timeout diversi per pool
Riavviare PHPRiavvii Apache, e con lui tuttosystemctl reload php8.4-fpm, il web server non se ne accorge
DiagnosiPocaPagina di stato, slowlog con lo stack delle richieste lente
Configurazione per sitophp_value in .htaccessNel pool (php_admin_value) o in .user.ini
LatenzaNessun passaggio intermedioUn socket in più: differenza trascurabile

🏚️ Quando mod_php va ancora bene

Un solo sito, una macchina piccola, Apache già configurato così e un'applicazione vecchia che usa php_value in decine di .htaccess. Se funziona e non c'è niente da migrare, non è un'emergenza. Su un server nuovo però non c'è un buon motivo per sceglierlo.

🏢 Quando FPM è obbligatorio

Con nginx (non esiste un mod_php per nginx). Con più siti o più clienti sullo stesso server. Quando ti servono due versioni di PHP. Quando la RAM è poca e il traffico tanto. Cioè: quasi sempre.

🎯 La regola da svogliatoServer nuovo: nginx (o Apache con MPM event) + PHP-FPM, un pool per sito, un utente per sito. Server vecchio con mod_php che funziona: lascialo stare finché non devi toccarlo, poi migra (sezione 11).
10 / 15

Configurare PHP-FPM

Un pool per sito: un file, un utente, un socket. Poi un numero da calcolare con attenzione.

ini · /etc/php/8.4/fpm/pool.d/blog.conf
[blog]
user = blog                                   ; utente del sito: niente www-data per tutti
group = blog
listen = /run/php/php8.4-fpm-blog.sock
listen.owner = www-data                       ; chi può parlare col socket: il web server
listen.group = www-data
listen.mode = 0660

pm = dynamic                                  ; processi tra min e max secondo il carico
pm.max_children = 12                          ; IL numero importante: vedi sotto
pm.start_servers = 3
pm.min_spare_servers = 2
pm.max_spare_servers = 4
pm.max_requests = 500                         ; ricicla i processi: argine alle perdite di memoria

pm.status_path = /fpm-status                  ; pagina di stato (da proteggere!)
slowlog = /var/log/php-fpm/blog-slow.log
request_slowlog_timeout = 5s                  ; registra lo stack delle richieste lente
request_terminate_timeout = 60s

php_admin_value[memory_limit] = 256M          ; admin = il codice del sito non può cambiarlo
php_admin_value[upload_max_filesize] = 32M
php_admin_value[post_max_size] = 32M
php_admin_value[error_log] = /var/log/php-fpm/blog-error.log
pm =Come si comportaQuando
dynamicTiene alcuni processi pronti e ne avvia altri sotto caricoIl default, va bene quasi sempre
ondemandZero processi a riposo, li avvia quando arriva una richiestaTanti siti poco visitati sullo stesso server: risparmi RAM
staticSempre max_children processi accesiServer dedicato a un sito con traffico alto e costante

🧮 Calcolare pm.max_children

Troppo basso: le richieste fanno la coda e nel log trovi "server reached pm.max_children". Troppo alto: sotto carico finisci la RAM e il kernel inizia a uccidere processi (database compreso). Si calcola così:

max_children = RAM che puoi dare a PHP ÷ RAM media di un processo PHP

Esempio: server da 4 GB, togli 1 GB per sistema e database, restano 3 GB; un processo WordPress pesa circa 80 MB → 3000 ÷ 80 ≈ 37. Arrotonda per difetto, e se hai più pool dividi la RAM tra loro. Il default di Debian è 5: va bene per provare, non per un sito vero.

bash · quanto pesa un processo
# RAM media dei processi FPM, in MB (misurala dopo un po' di traffico vero)
ps -C php-fpm8.4 -o rss= | awk '{s+=$1; n++} END {printf "%d processi, media %.0f MB\n", n, s/n/1024}'
nginx
server {
    server_name blog.example.com;
    root /srv/blog/public;
    index index.php;

    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    location ~ \.php$ {
        # Debian: c'è già il try_files che
        # rifiuta i file .php inesistenti
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php8.4-fpm-blog.sock;
    }
}
apache · nel VirtualHost
<VirtualHost *:443>
    ServerName blog.example.com
    DocumentRoot /srv/blog/public

    <FilesMatch "\.php$">
        SetHandler "proxy:unix:/run/php/php8.4-fpm-blog.sock|fcgi://localhost"
    </FilesMatch>
</VirtualHost>

# una volta sola:
# a2enmod proxy_fcgi setenvif
bash · dopo ogni modifica
sudo useradd --system --home /srv/blog --shell /usr/sbin/nologin blog   # l'utente del pool, una volta
sudo php-fpm8.4 -t                     # controlla la configurazione prima di applicarla
sudo systemctl reload php8.4-fpm       # reload: le richieste in corso finiscono, niente errori
11 / 15

Da mod_php a FPM, e più versioni insieme

Su Debian e Ubuntu sono sei comandi. Fallo in un momento tranquillo e tieni aperta una seconda sessione SSH.

bash · Apache, da mod_php a FPM
sudo apt install php8.4-fpm
sudo a2enmod proxy_fcgi setenvif
sudo a2enconf php8.4-fpm               # manda i .php al pool predefinito (www)
sudo a2dismod php8.4 mpm_prefork       # via mod_php e il vecchio MPM
sudo a2enmod mpm_event
sudo apachectl configtest && sudo systemctl restart apache2

✅ Prima di dire "fatto"

  1. Gli .htaccess: cerca grep -rn "php_value\|php_flag" /var/www. Con FPM quelle righe danno errore 500: spostale nel pool (php_admin_value) o in un file .user.ini nella cartella del sito.
  2. I valori di php.ini: FPM legge /etc/php/8.4/fpm/php.ini, non quello di Apache. Riporta memory_limit, upload_max_filesize e simili.
  3. I permessi: se passi a un utente per sito, i file su cui l'applicazione scrive (upload, cache) devono appartenere a quell'utente.
  4. La prova: una pagina con <?php echo php_sapi_name(); deve rispondere fpm-fcgi, non apache2handler. Poi cancellala.
bash · due versioni sullo stesso server
# dopo aver aggiunto il repository di Ondřej Surý
sudo apt install php8.2-fpm php8.4-fpm
# due servizi separati, due socket separati:
#   /run/php/php8.2-fpm.sock  → gestionale vecchio
#   /run/php/php8.4-fpm.sock  → sito nuovo
# ogni vhost punta al suo socket in fastcgi_pass / SetHandler

sudo update-alternatives --config php   # sceglie quale versione risponde a "php" in terminale
php8.2 artisan migrate                 # o chiami direttamente la versione che serve
🧪 Vederlo dal vivoNel lab di NetForge lo stesso server risponde con tre versioni di PHP diverse (8.3, 8.4 e 8.5), una per nome di dominio: tre pool FPM e un web server davanti.
12 / 15

Prestazioni: OPcache prima di tutto

Prima di comprare un server più grosso, controlla queste quattro cose. Di solito basta.

ini · /etc/php/8.4/fpm/conf.d/99-produzione.ini
opcache.enable = 1
opcache.memory_consumption = 256          ; MB per il codice compilato
opcache.interned_strings_buffer = 16
opcache.max_accelerated_files = 20000     ; più dei file .php del sito (Composer ne porta tanti)
opcache.validate_timestamps = 0           ; non controllare se i file cambiano...
                                          ; ...quindi dopo ogni deploy: systemctl reload php8.4-fpm
realpath_cache_size = 4096K
CosaEffettoNota
OPcacheIl guadagno più grande: niente ricompilazione a ogni richiestaAccesa di default su Debian, ma con valori piccoli
Versione di PHPOgni versione 8.x è un po' più veloce della precedentePassare da 7.4 a 8.x si sente
Cache oggetti (Redis, APCu)Meno query ripetute al databaseWordPress e Drupal hanno i plugin apposta
pm.max_children giustoNiente code e niente swapSezione 10
JITGrande sul calcolo puro, piccolo su un sito web classicoIl collo di bottiglia di solito è il database, non PHP
⚠️ validate_timestamps = 0 e il "non vedo le modifiche"Con questa opzione PHP non si accorge dei file cambiati: carichi la versione nuova e il sito mostra la vecchia. Non è un bug, è il motivo per cui va veloce. Metti il reload di FPM nello script di deploy, e su un server dove modifichi a mano lasciala a 1.
13 / 15

Sicurezza: le cose che contano davvero

La maggior parte dei siti PHP bucati non lo è per colpa di PHP, ma di un plugin vecchio o di una cartella di upload che esegue codice.

ini · php.ini di produzione (fpm)
expose_php = Off                ; non annunciare la versione negli header
display_errors = Off            ; gli errori nel log, non in faccia al visitatore
log_errors = On
allow_url_include = Off         ; mai include di codice da URL (è già Off di default)
session.cookie_httponly = 1
session.cookie_secure = 1       ; solo se il sito è tutto in HTTPS (dovrebbe)
session.cookie_samesite = Lax
session.use_strict_mode = 1

✅ Fai

  • Un utente e un pool per sito
  • Radice del sito su public/, config e vendor/ fuori
  • Niente esecuzione di PHP nella cartella degli upload
  • Query preparate (PDO) e htmlspecialchars() su ogni output
  • Versione di PHP ancora supportata, e composer audit
  • File di codice di proprietà di root, scrivibili dal sito solo dove serve

❌ Non fare

  • phpinfo.php lasciato in giro "per vedere una cosa"
  • chmod -R 777 per far funzionare gli upload
  • Passare a FPM file .php che non esistono (vedi sotto)
  • Contare su open_basedir o disable_functions come difesa: si aggirano. Ci vuole un utente separato
  • eval(), unserialize() su dati dell'utente
  • Pagina di stato FPM aperta a tutti
nginx · niente PHP negli upload
# prima del blocco location ~ \.php$
location ~* ^/(uploads|wp-content/uploads)/.*\.php$ {
    deny all;
}
🕳️ Il vecchio buco di cgi.fix_pathinfoCon una configurazione nginx ingenua, una richiesta a /uploads/foto.jpg/x.php faceva eseguire a PHP il file foto.jpg, che poteva contenere codice caricato da un attaccante. Le difese sono già nei default moderni: il try_files nello snippet di Debian rifiuta i file che non esistono, e FPM esegue solo le estensioni di security.limit_extensions (di default .php). Non toglierle "perché così funziona".
14 / 15

Errori tipici, tradotti

Il log di nginx o Apache dice cosa è successo tra il web server e PHP. Il log del pool dice cosa è successo dentro PHP. Guardali tutti e due.

Cosa vediCosa vuol direCosa fare
502 Bad GatewayIl web server non riesce a parlare con FPMFPM è spento, o il socket in fastcgi_pass ha un nome diverso da listen del pool
connect() to unix:/run/php/... failed (13: Permission denied)Il web server non ha il permesso sul socketlisten.owner/listen.group = l'utente del web server
504 Gateway TimeoutPHP ci mette troppoGuarda lo slowlog. Alza fastcgi_read_timeout solo se la lentezza è voluta
Primary script unknown / "File not found."FPM non trova il file che il web server gli chiederoot sbagliata, o SCRIPT_FILENAME non impostato: usa lo snippet della distribuzione
server reached pm.max_children settingTutti i processi sono occupati, le richieste fanno la codaRicalcola max_children (sezione 10), e cerca nello slowlog chi tiene occupati i processi
Pagina bianca, o 500 senza spiegazioneErrore fatale con display_errors = OffÈ nel log del pool (error_log) o in journalctl -u php8.4-fpm
Allowed memory size of ... bytes exhaustedLo script ha superato memory_limitAlza il limite nel pool, ma prima chiediti perché una pagina vuole 512 MB
Il browser scarica il file .php o mostra il codiceIl web server non passa i .php a PHPManca il blocco location ~ \.php$ o il SetHandler. Controlla subito che nel codice esposto non ci fossero password
Invalid command 'php_value' → 500Un .htaccess con impostazioni di mod_php, ma mod_php non c'è piùSposta i valori nel pool o in .user.ini (sezione 11)
Apache is running a threaded MPM, but your PHP Module is not compiled to be threadsafemod_php con l'MPM event o workerPassa a FPM, oppure torna a prefork (sconsigliato)
Upload grande: 413 da nginxIl limite è di nginx, non di PHPclient_max_body_size nel server di nginx
Upload grande: il form arriva vuoto, nessun erroreSuperato post_max_size: PHP butta via tutto in silenzioAlza post_max_size e upload_max_filesize insieme
Hai cambiato php.ini ma non cambia nienteFile sbagliato (cli invece di fpm) o FPM non ricaricatophp-fpm8.4 -i | grep "Loaded Configuration", poi systemctl reload php8.4-fpm
15 / 15

Da dove continuare

Il manuale ufficiale di PHP è uno dei migliori in circolazione. Sotto ogni pagina ci sono anche commenti di vent'anni fa: leggili con prudenza.

🗺️ Un percorso in quattro tappe

  1. Oggi: su ogni server con PHP, php -v e apache2ctl -M | grep php. Scopri che versione hai, se è ancora supportata e se c'è mod_php.
  2. Questa settimana: misura la RAM dei processi FPM e imposta pm.max_children con il calcolo della sezione 10. Accendi lo slowlog.
  3. Poi: un pool e un utente per ogni sito, OPcache sistemata, display_errors spento e niente PHP negli upload.
  4. Dopo: se scrivi codice, PHP 8 con strict_types, Composer e un framework (Laravel o Symfony) invece di reinventare tutto.
RisorsaCos'è
php.net/manualIl manuale ufficiale, anche in italiano. La pagina Supported Versions dice fino a quando è supportata la tua versione
PHP: The Right Way (phptherightway.com)Le buone pratiche del PHP moderno in una pagina sola
php.watchLe novità di ogni versione spiegate con esempi
getcomposer.org e packagist.orgComposer e il catalogo dei pacchetti
man php-fpm8.4 e i commenti in pool.d/www.confOgni opzione del pool è spiegata nel file di esempio
WordPress per Svogliati · Drupal per SvogliatiI due CMS PHP più usati, dalla parte di chi li gestisce
🐘 L'ultimo consiglio da svogliatoQuando un sito PHP è lento, nove volte su dieci non è PHP: è una query senza indice o una chiamata a un servizio esterno. Lo slowlog di FPM ti dice quale funzione stava aspettando. Guardalo prima di aggiungere RAM.