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.
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.
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.
PHP Tools
Rasmus pubblica i suoi strumenti. L'idea che conta: il codice sta dentro la pagina HTML, tra <?php e ?>.
PHP 3
Andi Gutmans e Zeev Suraski riscrivono il motore. Il nome diventa l'acronimo ricorsivo PHP: Hypertext Preprocessor. Diventa un linguaggio vero.
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.
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.
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).
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.
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.
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.
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.
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
| Voce | PHP | Python | Node.js | Go |
|---|---|---|---|---|
| Modello | Ogni richiesta parte da zero | Processo che resta acceso | Processo acceso, un solo thread | Un binario, acceso |
| Deploy | Copi i file | virtualenv + servizio | node_modules + servizio | Un file |
| Hosting economico | Ovunque | Raro | Raro | Raro |
| Se va in crash | Muore una richiesta | Muore il processo | Muore il processo | Muore il processo |
| Punto debole | Niente stato tra richieste | Velocità | Codice asincrono ovunque | Più codice da scrivere |
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.
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.
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).
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).
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.
Installazione e versioni
Prendi quella della distribuzione, a meno che l'applicazione ne chieda un'altra.
| Distribuzione | PHP incluso |
|---|---|
| Debian 12 (bookworm) | 8.2 |
| Debian 13 (trixie) | 8.4 |
| Ubuntu 24.04 LTS | 8.3 |
| Versioni diverse da queste | Repository di Ondřej Surý (packages.sury.org per Debian, PPA ondrej/php per 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
/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.
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é.
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
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
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
$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']}'");
php -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.
Composer: i pacchetti, finalmente
Prima del 2012 le librerie si copiavano a mano in una cartella "lib". Composer ha cambiato tutto.
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
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();
composer.lock va su git
È la fotografia delle versioni che funzionano. In produzione si fa install, mai update.
vendor/ no
Si rigenera con composer install. Va nel .gitignore e fuori dalla radice pubblica del sito.
Mai Composer come root
Gli script dei pacchetti girerebbero come root. Usa l'utente del sito (sudo -u sito composer install).
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 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 funziona | Oggi |
|---|---|---|
| CGI | Il web server avvia un processo PHP nuovo per ogni richiesta, poi lo chiude | Lentissimo, solo storia |
| mod_php | PHP è caricato dentro ogni processo di Apache | Ancora diffuso, sconsigliato per i server nuovi |
| PHP-FPM | Un servizio a parte con un gruppo (pool) di processi PHP sempre pronti; il web server gli passa le richieste via FastCGI | Lo standard: nginx, Apache, Caddy |
| Worker mode (FrankenPHP, RoadRunner, Swoole) | L'applicazione resta caricata in memoria tra una richiesta e l'altra | Velocissimo, ma rompe la regola 1 della sezione 4: il codice deve essere pensato per questo |
| CLI | php script.php da terminale, cron e timer | Per script, code di lavoro, artisan, wp-cli, drush |
mod_php contro PHP-FPM
Risposta breve: PHP-FPM. Risposta lunga: qui sotto, perché ogni tanto mod_php ha ancora senso.
| Voce | mod_php | PHP-FPM |
|---|---|---|
| Web server | Solo Apache | nginx, Apache, Caddy, chiunque parli FastCGI |
| Apache MPM | prefork (un processo per connessione): PHP normalmente non è thread-safe | event (thread, gestisce migliaia di connessioni con poca RAM) |
| RAM | Ogni processo Apache porta PHP con sé, anche per servire una favicon | Apache o nginx leggeri; la RAM di PHP solo per le richieste PHP |
| Utente | Tutti i siti girano come www-data | Un pool per sito, ognuno con il suo utente |
| Se un sito viene bucato | Può leggere e scrivere i file di tutti gli altri siti | Resta chiuso nei file del suo utente |
| Versioni di PHP | Una sola per tutto il server | 8.2 per il gestionale vecchio, 8.4 per il sito nuovo, sullo stesso server |
| Limiti | Uguali per tutti | Processi, memoria e timeout diversi per pool |
| Riavviare PHP | Riavvii Apache, e con lui tutto | systemctl reload php8.4-fpm, il web server non se ne accorge |
| Diagnosi | Poca | Pagina di stato, slowlog con lo stack delle richieste lente |
| Configurazione per sito | php_value in .htaccess | Nel pool (php_admin_value) o in .user.ini |
| Latenza | Nessun passaggio intermedio | Un 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.
Configurare PHP-FPM
Un pool per sito: un file, un utente, un socket. Poi un numero da calcolare con attenzione.
[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 comporta | Quando |
|---|---|---|
dynamic | Tiene alcuni processi pronti e ne avvia altri sotto carico | Il default, va bene quasi sempre |
ondemand | Zero processi a riposo, li avvia quando arriva una richiesta | Tanti siti poco visitati sullo stesso server: risparmi RAM |
static | Sempre max_children processi accesi | Server 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.
# 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}'
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;
}
}
<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
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
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.
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"
- 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.ininella cartella del sito. - I valori di php.ini: FPM legge
/etc/php/8.4/fpm/php.ini, non quello di Apache. Riportamemory_limit,upload_max_filesizee simili. - I permessi: se passi a un utente per sito, i file su cui l'applicazione scrive (upload, cache) devono appartenere a quell'utente.
- La prova: una pagina con
<?php echo php_sapi_name();deve risponderefpm-fcgi, nonapache2handler. Poi cancellala.
# 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
Prestazioni: OPcache prima di tutto
Prima di comprare un server più grosso, controlla queste quattro cose. Di solito basta.
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
| Cosa | Effetto | Nota |
|---|---|---|
| OPcache | Il guadagno più grande: niente ricompilazione a ogni richiesta | Accesa di default su Debian, ma con valori piccoli |
| Versione di PHP | Ogni versione 8.x è un po' più veloce della precedente | Passare da 7.4 a 8.x si sente |
| Cache oggetti (Redis, APCu) | Meno query ripetute al database | WordPress e Drupal hanno i plugin apposta |
| pm.max_children giusto | Niente code e niente swap | Sezione 10 |
| JIT | Grande sul calcolo puro, piccolo su un sito web classico | Il collo di bottiglia di solito è il database, non PHP |
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.
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 evendor/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.phplasciato in giro "per vedere una cosa"chmod -R 777per far funzionare gli upload- Passare a FPM file
.phpche non esistono (vedi sotto) - Contare su
open_basedirodisable_functionscome difesa: si aggirano. Ci vuole un utente separato eval(),unserialize()su dati dell'utente- Pagina di stato FPM aperta a tutti
# prima del blocco location ~ \.php$
location ~* ^/(uploads|wp-content/uploads)/.*\.php$ {
deny all;
}
/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".
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 vedi | Cosa vuol dire | Cosa fare |
|---|---|---|
| 502 Bad Gateway | Il web server non riesce a parlare con FPM | FPM è 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 socket | listen.owner/listen.group = l'utente del web server |
| 504 Gateway Timeout | PHP ci mette troppo | Guarda 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 chiede | root sbagliata, o SCRIPT_FILENAME non impostato: usa lo snippet della distribuzione |
server reached pm.max_children setting | Tutti i processi sono occupati, le richieste fanno la coda | Ricalcola max_children (sezione 10), e cerca nello slowlog chi tiene occupati i processi |
| Pagina bianca, o 500 senza spiegazione | Errore fatale con display_errors = Off | È nel log del pool (error_log) o in journalctl -u php8.4-fpm |
Allowed memory size of ... bytes exhausted | Lo script ha superato memory_limit | Alza il limite nel pool, ma prima chiediti perché una pagina vuole 512 MB |
| Il browser scarica il file .php o mostra il codice | Il web server non passa i .php a PHP | Manca il blocco location ~ \.php$ o il SetHandler. Controlla subito che nel codice esposto non ci fossero password |
Invalid command 'php_value' → 500 | Un .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 threadsafe | mod_php con l'MPM event o worker | Passa a FPM, oppure torna a prefork (sconsigliato) |
| Upload grande: 413 da nginx | Il limite è di nginx, non di PHP | client_max_body_size nel server di nginx |
| Upload grande: il form arriva vuoto, nessun errore | Superato post_max_size: PHP butta via tutto in silenzio | Alza post_max_size e upload_max_filesize insieme |
| Hai cambiato php.ini ma non cambia niente | File sbagliato (cli invece di fpm) o FPM non ricaricato | php-fpm8.4 -i | grep "Loaded Configuration", poi systemctl reload php8.4-fpm |
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
- Oggi: su ogni server con PHP,
php -veapache2ctl -M | grep php. Scopri che versione hai, se è ancora supportata e se c'è mod_php. - Questa settimana: misura la RAM dei processi FPM e imposta
pm.max_childrencon il calcolo della sezione 10. Accendi lo slowlog. - Poi: un pool e un utente per ogni sito, OPcache sistemata,
display_errorsspento e niente PHP negli upload. - Dopo: se scrivi codice, PHP 8 con
strict_types, Composer e un framework (Laravel o Symfony) invece di reinventare tutto.
| Risorsa | Cos'è |
|---|---|
| php.net/manual | Il 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.watch | Le novità di ogni versione spiegate con esempi |
| getcomposer.org e packagist.org | Composer e il catalogo dei pacchetti |
man php-fpm8.4 e i commenti in pool.d/www.conf | Ogni opzione del pool è spiegata nel file di esempio |
| WordPress per Svogliati · Drupal per Svogliati | I due CMS PHP più usati, dalla parte di chi li gestisce |