Per installare LEMP su Ubuntu 24.04 basta l’archivio standard di Ubuntu: un solo comando apt install fornisce Nginx 1.24.0, MariaDB 10.11.14 e PHP 8.3.6-FPM (versioni al 25 ottobre 2026). Il set minimo php8.3-fpm php8.3-mysql però non basta per WordPress: sul nostro banco di prova lo strumento integrato Salute del sito ha segnalato sette moduli mancanti, tra cui gd, che è obbligatorio. Qui sotto trovi comandi testati, un server block, un pool PHP-FPM con una formula per pm.max_children, un controllo di salute e una tabella degli errori con righe di log reali.
Questa guida parte da dove finisce la configurazione di base del server: utente sudo, accesso con chiave SSH, ufw, fail2ban e swap sono trattati nella nostra guida configurare un VPS Ubuntu 24.04 e qui non li ripetiamo.
Come abbiamo testato
Banco di prova RichHost: container isolato con 2 vCPU / 8 GB, Ubuntu 24.04.4 LTS, pacchetti dall’archivio Ubuntu, 25 ottobre 2026. Abbiamo eseguito le configurazioni di questo articolo su una porta separata, con un nostro master PHP-FPM e una copia di un sito WordPress 6.7.2, le abbiamo validate con nginx -t, php-fpm8.3 -t e curl, e abbiamo riprodotto gli errori rompendo apposta la configurazione. La memoria è PSS e RSS da /proc/<pid>/smaps_rollup; il carico è ApacheBench, 1000 richieste a una pagina articolo senza cache di pagina. Il container non ha systemd, quindi abbiamo avviato i servizi direttamente; su un VPS systemctl fa la stessa cosa (vedi la tabella più sotto). I numeri descrivono solo il banco di prova, non i server di produzione di RichHost; tutte le risorse di test sono state poi eliminate.
Passo 1. Installare i pacchetti con un solo comando
sudo apt update
sudo apt install -y nginx mariadb-server php8.3-fpm php8.3-mysql \
php8.3-curl php8.3-xml php8.3-mbstring php8.3-gd php8.3-zip php8.3-intl
Non installare il metapacchetto php: la sua prima dipendenza è il modulo di Apache, che a LEMP non serve. Controlla da dove arrivano i pacchetti e cosa è installato (output del banco di prova, abbreviato):
$ apt-cache policy nginx php8.3-fpm mariadb-server
nginx:
Installed: 1.24.0-2ubuntu7.18
*** 1.24.0-2ubuntu7.18 500
500 http://archive.ubuntu.com/ubuntu noble-updates/main amd64 Packages
php8.3-fpm:
Installed: 8.3.6-0ubuntu0.24.04.13
*** 8.3.6-0ubuntu0.24.04.13 500
500 http://archive.ubuntu.com/ubuntu noble-updates/universe amd64 Packages
mariadb-server:
Installed: 1:10.11.14-0ubuntu0.24.04.1
*** 1:10.11.14-0ubuntu0.24.04.1 500
500 http://archive.ubuntu.com/ubuntu noble-updates/universe amd64 Packages
$ nginx -v
nginx version: nginx/1.24.0 (Ubuntu)
$ php-fpm8.3 -v
PHP 8.3.6 (fpm-fcgi) (built: Oct 19 2026 15:16:58)
$ mariadb --version
mariadb Ver 15.1 Distrib 10.11.14-MariaDB, for debian-linux-gnu (x86_64)
Due cose saltano all’occhio. Primo, PHP 8.3.6 su Ubuntu non è “vecchio”: Canonical mantiene il numero di versione e riporta indietro le correzioni di sicurezza, quindi conta il suffisso 0ubuntu0.24.04.13. Secondo, se sono installate più versioni di PHP, php -v potrebbe non mostrare quella che serve il tuo sito. Sul nostro banco c’è anche PHP 8.4 per altri test, e php -v restituiva 8.4.21 mentre il sito gira su 8.3. Verifica con php-fpm8.3 -v oppure cambia la CLI con sudo update-alternatives --set php /usr/bin/php8.3.
Quali estensioni PHP servono a WordPress
Abbiamo eseguito il controllo dei moduli integrato in WordPress 6.7.2 (lo stesso di Strumenti > Salute del sito) dentro PHP-FPM con tre set di pacchetti:
| Installato | Moduli PHP | Esito del controllo di WordPress |
|---|---|---|
php8.3-fpm php8.3-mysql |
39 | Critico: manca gd (obbligatorio se manca Imagick); mancano curl, dom, mbstring, zip, intl, imagick |
+ php8.3-curl php8.3-xml php8.3-mbstring |
47 | Critico: manca gd; mancano zip, intl, imagick |
+ php8.3-gd php8.3-zip php8.3-intl |
50 | Solo un consiglio: imagick |
Nessuno degli otto pacchetti PHP del comando sopra è quindi facoltativo. Senza gd (e senza Imagick) WordPress non può creare le miniature delle immagini. Per curl, zip e mbstring ha delle alternative interne, ma sono più lente e meno affidabili, ed è per questo che il controllo le segnala. Imagick resta l’unico consiglio: php8.3-imagick si porta dietro 12 nuovi pacchetti di librerie ImageMagick (secondo apt-get install -s), quindi installalo solo se ti servono anteprime PDF o formati insoliti. Una trappola in cui siamo caduti: se lanci lo stesso controllo tramite WP-CLI, mbstring non risulta mancante, perché WP-CLI include un proprio sostituto di quelle funzioni. Verifica dall’interfaccia web o con php-fpm8.3 -m.
Passo 2. Database e utente MariaDB
sudo mariadb-secure-installation
sudo mariadb
mariadb-secure-installation rimuove gli utenti anonimi e il database di test e disattiva l’accesso remoto di root: rispondi Y a queste domande. Puoi saltare il passaggio a unix_socket, perché su Ubuntu root accede già così (tramite sudo mariadb, senza password). Crea un utente dedicato con permessi solo sul proprio database:
CREATE DATABASE example_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'example'@'localhost' IDENTIFIED BY 'change-me-Long-Pass-42';
GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, INDEX, DROP,
CREATE TEMPORARY TABLES, LOCK TABLES
ON example_db.* TO 'example'@'localhost';
Al posto di GRANT ALL c’è un elenco esplicito: per il lavoro quotidiano WordPress ha bisogno di SELECT, INSERT, UPDATE e DELETE, mentre CREATE, ALTER, INDEX e DROP servono per aggiornamenti e plugin. FLUSH PRIVILEGES non serve dopo CREATE USER e GRANT. Su Ubuntu MariaDB ascolta solo su 127.0.0.1, quindi la porta 3306 è chiusa dall’esterno per impostazione predefinita.
Passo 3. Un pool PHP-FPM dedicato
Invece di modificare il file predefinito www.conf, crea un pool per il sito in /etc/php/8.3/fpm/pool.d/example.conf. Se i pool di siti diversi girano con utenti diversi, un sito compromesso non può leggere i file dei vicini.
[example]
user = www-data
group = www-data
listen = /run/php/php8.3-fpm-example.sock
listen.owner = www-data
listen.group = www-data
listen.mode = 0660
pm = dynamic
pm.max_children = 10
pm.start_servers = 2
pm.min_spare_servers = 1
pm.max_spare_servers = 3
pm.max_requests = 500
request_terminate_timeout = 60s
request_slowlog_timeout = 5s
slowlog = /var/log/php8.3-fpm-example-slow.log
pm.status_path = /fpm-status
php_admin_value[upload_max_filesize] = 64M
php_admin_value[post_max_size] = 64M
php_admin_value[memory_limit] = 256M
php_admin_value[max_execution_time] = 60
sudo php-fpm8.3 -t && sudo systemctl reload php8.3-fpm
I limiti di upload stanno nel pool, quindi valgono solo per questo sito. Abbiamo verificato perché contano: con i valori predefiniti post_max_size = 8M e upload_max_filesize = 2M un file da 10 MB ha superato nginx (limite 64m), ma PHP lo ha scartato in silenzio. Il modulo è arrivato vuoto e nel log è comparsa solo questa riga:
PHP Warning: POST Content-Length of 10000212 bytes exceeds the limit of 8388608 bytes
Con le righe php_admin_value lo stesso file è stato accettato, e nginx ha rifiutato 70 MB con un 413. Approfondimenti su questi limiti in come aumentare upload_max_filesize e su memory_limit in Allowed memory size exhausted. Un’altra trappola: se request_slowlog_timeout è maggiore di request_terminate_timeout, PHP-FPM non parte affatto e ogni pagina restituisce 502:
ERROR: [pool example] 'request_slowlog_timeout' (5) can't be greater than 'request_terminate_timeout' (3)
ERROR: FPM initialization failed
Per questo php-fpm8.3 -t prima di ogni reload è obbligatorio, proprio come nginx -t.
Come calcolare pm.max_children
Il limite superiore viene da una formula: pm.max_children = (RAM − sistema e riserva − MariaDB − nginx) / RSS di un worker. Dati del banco di prova dopo 1000 richieste a una pagina WordPress: un worker PHP-FPM usava 41,7 MB di RSS (il valore mostrato da ps), ma solo 10,6 MB di PSS. Il resto è OPcache condivisa e librerie che il kernel non duplica, quindi la formula basata sull’RSS lascia un margine, ed è un bene. Nginx (master, due worker e cache manager) usava 7,9 MB di PSS. MariaDB con il valore predefinito innodb_buffer_pool_size = 128M occupava circa 100 MB subito dopo l’avvio (misurato lo stesso giorno) e 265 MB dopo qualche ora di test (il server di database non restituisce la memoria che ha preso).
$ ps --no-headers -o rss,cmd -C php-fpm8.3 | grep "pool example" | awk '{s+=$1;n++} END {printf "%.0f MB (n=%d)\n", s/n/1024, n}'
42 MB (n=9)
Esempio per un VPS da 2 GB (stima): (2048 − 400 per sistema e riserva − 300 per MariaDB − 25 per nginx) / 42 ≈ 31. È un tetto di memoria, non un valore consigliato, e dipende dal sito: plugin e WooCommerce aumentano l’RSS dei worker, quindi misura il tuo dopo una giornata di traffico reale.
Cosa danno i worker in più: una misurazione
Abbiamo inviato 1000 richieste con 50 connessioni simultanee (ab -n 1000 -c 50) con pm = static e diversi valori di pm.max_children:

| pm.max_children | RSS del pool, MB | PSS del pool, MB | Richieste/s | Risposta mediana, ms | Errori |
|---|---|---|---|---|---|
| 2 | 86 | 43 | 36,3 | 1361 | 0 |
| 5 | 211 | 67 | 34,4 | 1424 | 0 |
| 10 | 417 | 105 | 36,2 | 1356 | 0 |
| 20 | 837 | 178 | 34,3 | 1423 | 0 |
Con 2 vCPU una pagina WordPress senza cache è limitata dalla CPU: due worker tengono già occupati entrambi i core, quindi 20 worker hanno dato lo stesso throughput (circa 35 richieste al secondo) e la stessa latenza, con dieci volte la memoria. Errori nessuno: le richieste in eccesso aspettavano nella coda del socket (listen.backlog vale 511 per impostazione predefinita). Più worker aiutano quando PHP aspetta qualcosa di esterno: in un altro test sullo stesso banco, con un plugin simulato che attendeva 250 ms una API, passare da 5 a 20 worker ha portato il throughput da 14,0 a 18,8 richieste al secondo.
Regola pratica: parti da 2-4 worker per vCPU, aumenta il valore se il log di FPM mostra server reached pm.max_children setting mentre la CPU non è al massimo, e non superare mai il tetto della formula. Errori 502 sotto carico li abbiamo ottenuti riducendo la coda: con listen.backlog = 8 e due worker, 987 richieste su 1000 sono fallite con 502 e la riga connect() ... failed (11: Resource temporarily unavailable). Quella riga significa che mancano worker o spazio in coda, non che il codice del sito si è rotto.
Passo 4. Server block di Nginx
sudo mkdir -p /var/www/example.com/public
sudo chown -R $USER:www-data /var/www/example.com
Le directory hanno 755, i file 644, e www-data deve poter scrivere solo dove il sito scrive davvero (per WordPress wp-content/uploads e la cache). Cosa succede quando PHP non riesce a leggere un file lo mostra la tabella degli errori più sotto. Il file /etc/nginx/sites-available/example.com:
server {
listen 80;
listen [::]:80;
server_name example.com www.example.com;
root /var/www/example.com/public;
index index.php index.html;
access_log /var/log/nginx/example.com.access.log;
error_log /var/log/nginx/example.com.error.log;
# must match post_max_size and upload_max_filesize in the PHP pool
client_max_body_size 64m;
location / {
try_files $uri $uri/ /index.php?$args;
}
location ~ \.php$ {
include snippets/fastcgi-php.conf;
fastcgi_pass unix:/run/php/php8.3-fpm-example.sock;
fastcgi_read_timeout 60s;
}
location ~* \.(css|js|jpg|jpeg|png|gif|webp|avif|svg|ico|woff2?)$ {
expires 30d;
access_log off;
try_files $uri =404;
}
location ~ /\.(?!well-known) {
deny all;
}
location = /health.php {
allow 127.0.0.1;
deny all;
include snippets/fastcgi-php.conf;
fastcgi_pass unix:/run/php/php8.3-fpm-example.sock;
}
location = /fpm-status {
allow 127.0.0.1;
deny all;
include fastcgi.conf;
fastcgi_pass unix:/run/php/php8.3-fpm-example.sock;
}
}
sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default
sudo nginx -t && sudo systemctl reload nginx
Cosa ha mostrato curl sul banco di prova (stesso blocco su una porta di test, abbreviato):
$ nginx -t
nginx: configuration file /etc/nginx/nginx.conf test is successful
$ curl -s -o /dev/null -w "%{http_code}\n" http://127.0.0.1:8117/post-293/
200
$ curl -sI http://127.0.0.1:8117/wp-includes/css/dashicons.min.css | grep -iE "expires|cache-control"
Expires: Tue, 24 Nov 2026 13:49:46 GMT
Cache-Control: max-age=2592000
$ curl -s -o /dev/null -w "%{http_code}\n" http://127.0.0.1:8117/.git/config
403
$ curl -s -o /dev/null -w "%{http_code}\n" -F "f=@/tmp/r17_70m.bin" http://127.0.0.1:8117/r17-uploadtest.php
413
I test hanno fatto emergere tre problemi, già corretti nel blocco sopra. All’inizio la location dei file statici conteneva sia expires 30d sia add_header Cache-Control "public", e nginx inviava due header Cache-Control: expires imposta già max-age da solo, quindi la seconda riga è superflua. La pagina /fpm-status con include fastcgi_params restituiva “File not found.” perché quel file non contiene SCRIPT_FILENAME; con include fastcgi.conf funziona e mostra, tra l’altro, il contatore max children reached. Infine la riga listen [::]:80 fa fallire nginx -t quando IPv6 è disattivato: socket() [::]:80 failed (97: Address family not supported by protocol). In quel caso basta eliminarla.
Passo 5. Un controllo di salute per tutto lo stack
/var/www/example.com/public/health.php controlla la versione di PHP, i moduli necessari, OPcache e la connessione al database. Il codice di stato 200 o 500 è comodo per il monitoraggio; il server block lo consente solo da 127.0.0.1.
<?php
header('Content-Type: application/json');
$need = ['mysqli','curl','dom','mbstring','xml','zip','gd','intl','exif','fileinfo','openssl'];
$out = ['php' => PHP_VERSION, 'sapi' => PHP_SAPI,
'missing' => array_values(array_filter($need, fn($e) => !extension_loaded($e))),
'opcache' => function_exists('opcache_get_status') && (opcache_get_status(false)['opcache_enabled'] ?? false)];
try {
$db = new mysqli('localhost', 'example', 'change-me-Long-Pass-42', 'example_db');
$out['db'] = $db->query('SELECT VERSION()')->fetch_row()[0];
} catch (Throwable $e) {
$out['db'] = 'ERROR: ' . $e->getMessage();
}
$ok = !$out['missing'] && $out['opcache'] && !str_starts_with($out['db'], 'ERROR');
http_response_code($ok ? 200 : 500);
echo json_encode($out + ['ok' => $ok], JSON_UNESCAPED_SLASHES), "\n";
$ curl -s http://127.0.0.1:8117/health.php # on a VPS: curl -s -H "Host: example.com" http://127.0.0.1/health.php
{"php":"8.3.6","sapi":"fpm-fcgi","missing":[],"opcache":true,"db":"10.11.14-MariaDB-0ubuntu0.24.04.1","ok":true}
Per i controlli esterni, aggiungi l’IP del tuo servizio di monitoraggio in allow invece di aprire il file a tutti: rivela le versioni del software e contiene la password del database.
HTTPS con Let’s Encrypt
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d example.com -d www.example.com
sudo certbot renew --dry-run
Questo passo non l’abbiamo eseguito sul banco di prova: il container non ha un dominio pubblico. Certbot aggiunge al server block le direttive ssl_certificate e un redirect da HTTP, e il timer di systemd certbot.timer rinnova il certificato da 90 giorni. Approfondimenti in certificato SSL su hosting condiviso.
systemctl su un VPS e cosa abbiamo fatto noi
| Operazione | VPS con systemd | Banco di prova senza systemd |
|---|---|---|
| Verificare le configurazioni | sudo nginx -t, sudo php-fpm8.3 -t |
Uguale |
| Applicare le modifiche a nginx | sudo systemctl reload nginx |
nginx -s reload |
| Applicare le modifiche al pool | sudo systemctl reload php8.3-fpm |
Fermare il master, avviare php-fpm8.3 -D -y file |
| Stato e log | systemctl status php8.3-fpm, journalctl -u mariadb |
pgrep, file di log |
| Avvio al boot | I pacchetti abilitano i servizi; verifica con systemctl is-enabled nginx php8.3-fpm mariadb |
Non applicabile |
Errori comuni: sintomo, riga di log, soluzione
Abbiamo provocato ogni riga qui sotto sul banco di prova rompendo apposta la configurazione (abbreviato). Cercale in /var/log/nginx/example.com.error.log e /var/log/php8.3-fpm.log.
| Sintomo | Riga di log | Causa | Soluzione |
|---|---|---|---|
| 502 Bad Gateway | connect() to unix:/run/php/php8.2-fpm.sock failed (2: No such file or directory) |
Il percorso in fastcgi_pass non coincide con il listen del pool, oppure PHP-FPM è fermo |
ls /run/php/, allineare i percorsi, systemctl status php8.3-fpm |
| 502 Bad Gateway | connect() ... failed (13: Permission denied) |
Il socket appartiene a root, nginx (www-data) non riesce a connettersi | listen.owner e listen.group = www-data, listen.mode = 0660 |
| 502 sotto carico | connect() ... failed (11: Resource temporarily unavailable) |
Coda del socket piena | Non ridurre listen.backlog; aggiungere worker o cache di pagina |
| 502 su richieste lunghe | recv() failed (104: Connection reset by peer); FPM: execution timed out ... terminating |
request_terminate_timeout ha terminato lo script |
Trovare il punto lento nello slowlog, alzare il limite se serve |
| 502 dopo una modifica al pool | FPM initialization failed |
Errore di configurazione, FPM non è partito | php-fpm8.3 -t prima del reload |
| 504 Gateway Time-out | upstream timed out (110: Connection timed out) |
Lo script dura più di fastcgi_read_timeout |
Velocizzare lo script o alzare il timeout insieme a quello di FPM |
| “File not found.” (404) | FastCGI sent in stderr: "Primary script unknown" |
PHP-FPM ha ricevuto uno SCRIPT_FILENAME inesistente: root sbagliato o fastcgi_params senza SCRIPT_FILENAME |
include snippets/fastcgi-php.conf o fastcgi.conf, controllare root |
| “Access denied.” (403) | Unable to open primary script: ... (Permission denied) |
L’utente del pool non può leggere il file (ad esempio root:root 600) | chown al proprietario del sito con gruppo www-data, permessi 644 |
| 413 Request Entity Too Large | client intended to send too large body |
Superato client_max_body_size |
Aumentarlo insieme a post_max_size |
Come seguire i timeout quando il server non è tuo è spiegato in errore 504 Gateway Timeout.
Quando non ti serve un LEMP tuo
Un LEMP tuo significa che aggiornamenti di sicurezza, monitoraggio, backup e gli errori 502 notturni sono responsabilità tua. Se ti serve un sito e non un server, l’hosting condiviso di RichHost ti dà un web server pronto e gestito, PHP e database, mentre tu gestisci siti, database, posta e SSL gratuito Let’s Encrypt dal pannello di controllo proprietario con assistente IA. Dischi NVMe, siti e caselle di posta illimitati, server in Europa e negli Stati Uniti; piani da 8 $ al mese (A3), -10% con pagamento annuale. Confronta i piani di hosting condiviso oppure leggi la nostra guida all’hosting per WordPress.
Domande frequenti
Quanta RAM serve a LEMP con WordPress?
Sul nostro banco di prova, a riposo, nginx usava circa 8 MB, MariaDB da 100 a 265 MB, due worker PHP-FPM già caldi 86 MB di RSS. Un sito piccolo sta in 1 GB di RAM, mentre 2 GB lasciano spazio a 10-20 worker e alla cache del database (stima per un sito semplice senza plugin pesanti).
Imagick è obbligatorio?
No. Senza Imagick WordPress usa gd, e Salute del sito indica Imagick solo come consiglio. Installa php8.3-imagick se ti servono anteprime PDF o formati che gd non supporta.
MariaDB o MySQL?
Vanno bene entrambi per WordPress: la pagina dei requisiti di WordPress (consultata il 25 ottobre 2026) indica PHP 8.3 o superiore e MariaDB 10.11 o MySQL 8.0 o superiore. MariaDB 10.11 dall’archivio di Ubuntu 24.04 soddisfa questi requisiti senza repository di terze parti.



