IT

Applicazioni

Installare Nginx e PHP-FPM

Installa Nginx e PHP-FPM su Debian o Ubuntu: repository aggiornati, virtual host, pool dedicato, test PHP, impostazioni essenziali, HTTPS, aggiornamenti e risoluzione dei problemi.

7 min di lettura, aggiornato il 18 novembre 2026

In questa pagina

I tuoi valori

Inseriscili una volta: i comandi della guida si aggiornano.

Questa guida ti spiega come installare Nginx dal repository ufficiale di nginx.org e PHP-FPM in una versione recente, poi come pubblicare un sito con il proprio virtual host e il proprio pool PHP.

Ordina un server

Per ospitare i tuoi siti, HostMyServers offre diverse soluzioni:

Prerequisiti

  • Un server con Debian 12/13 o Ubuntu 22.04/24.04
  • Un accesso SSH con root o con un utente sudo
  • Un nome di dominio i cui record puntano al server (vedi creare un record A)
  • Le porte 80 e 443 aperte in TCP

PHP-FPM comunica con Nginx tramite un socket locale: non ha bisogno di alcuna porta aperta. Se usi UFW (vedi Configurare UFW):

Terminale
sudo ufw allow 80,443/tcp comment 'Web'

Passo 1: installare Nginx

Se Nginx è già installato dai pacchetti della tua distribuzione, fai il backup di /etc/nginx, poi rimuovilo con sudo apt remove nginx nginx-common.

Installa gli strumenti necessari. Su Debian:

Terminale
sudo apt update
sudo apt install curl gnupg2 ca-certificates lsb-release debian-archive-keyring

Su Ubuntu:

Terminale
sudo apt update
sudo apt install curl gnupg2 ca-certificates lsb-release ubuntu-keyring

Importa la chiave di firma e mostra le sue impronte:

Terminale
curl -fsSL https://nginx.org/keys/nginx_signing.key | gpg --dearmor | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg > /dev/null
gpg --show-keys /usr/share/keyrings/nginx-archive-keyring.gpg

L'elenco deve contenere l'impronta 573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62. In caso contrario, elimina il file e fermati qui.

Aggiungi il repository del ramo stabile, dagli la priorità, poi installa Nginx:

Terminale
. /etc/os-release
echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] https://nginx.org/packages/$ID $(lsb_release -cs) nginx" | sudo tee /etc/apt/sources.list.d/nginx.list
printf 'Package: *\nPin: origin nginx.org\nPin: release o=nginx\nPin-Priority: 900\n' | sudo tee /etc/apt/preferences.d/99nginx
sudo apt update
sudo apt install nginx
sudo systemctl enable --now nginx
nginx -v

Passo 2: installare PHP-FPM

Il progetto PHP non pubblica un repository APT. Per ottenere una versione recente su tutti questi sistemi, questa guida usa il repository packages.sury.org, gestito da Ondřej Surý, anche manutentore dei pacchetti PHP di Debian. È un repository di terze parti: aggiungilo solo se ti fidi.

Terminale
sudo apt install lsb-release ca-certificates curl
curl -fsSLo /tmp/debsuryorg-archive-keyring.deb https://packages.sury.org/debsuryorg-archive-keyring.deb
sudo dpkg -i /tmp/debsuryorg-archive-keyring.deb
echo "deb [signed-by=/usr/share/keyrings/debsuryorg-archive-keyring.gpg] https://packages.sury.org/php/ $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/php.list
sudo apt update

Installa PHP 8.5 con le estensioni più comuni:

Terminale
sudo apt install php8.5-fpm php8.5-cli php8.5-curl php8.5-mbstring php8.5-xml php8.5-zip php8.5-intl php8.5-gd php8.5-mysql
php -v
sudo systemctl status php8.5-fpm

Installa proprio php8.5-fpm e non il pacchetto generico php, che può aggiungere Apache.

Passo 3: creare il sito

Qui ogni sito dispone di un utente di sistema. PHP può leggere il codice, ma può scrivere solo in uploads:

Terminale
sudo useradd --system --user-group --home-dir /var/www/tuo-dominio.com --shell /usr/sbin/nologin webapp
sudo mkdir -p /var/www/tuo-dominio.com/public/uploads
sudo chown -R "$USER":webapp /var/www/tuo-dominio.com
sudo find /var/www/tuo-dominio.com -type d -exec chmod 755 {} +
sudo chown webapp:webapp /var/www/tuo-dominio.com/public/uploads

Crea una pagina di test:

Terminale
nano /var/www/tuo-dominio.com/public/index.php
PHP
<?php
header('Content-Type: text/plain; charset=utf-8');
echo 'PHP ', PHP_VERSION, ' (', PHP_SAPI, ')', PHP_EOL;
echo 'User: ', posix_getpwuid(posix_geteuid())['name'], PHP_EOL;
echo 'OPcache: ', (function_exists('opcache_get_status') && opcache_get_status(false)) ? 'on' : 'off', PHP_EOL;

Passo 4: creare il pool PHP-FPM

Terminale
sudo nano /etc/php/8.5/fpm/pool.d/tuo-dominio.com.conf
Configurazione
[tuo-dominio.com]
user = webapp
group = webapp

listen = /run/php/tuo-dominio.com.sock
listen.owner = nginx
listen.group = nginx
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 = 120s
catch_workers_output = yes
php_admin_flag[log_errors] = on

Disattiva il pool predefinito, che non serve più:

Terminale
sudo mv /etc/php/8.5/fpm/pool.d/www.conf /etc/php/8.5/fpm/pool.d/www.conf.disabled

Passo 5: configurare PHP

Metti le tue impostazioni in un file separato, che non verrà toccato dagli aggiornamenti:

Terminale
sudo nano /etc/php/8.5/fpm/conf.d/90-custom.ini
Configurazione
memory_limit = 256M
upload_max_filesize = 32M
post_max_size = 32M
max_execution_time = 60
date.timezone = Europe/Paris

expose_php = Off
display_errors = Off
log_errors = On

session.use_strict_mode = 1
session.cookie_httponly = 1

opcache.enable = 1
opcache.memory_consumption = 128
opcache.max_accelerated_files = 10000
opcache.validate_timestamps = 1
opcache.revalidate_freq = 2

Testa e poi riavvia PHP-FPM:

Terminale
sudo php-fpm8.5 -t
sudo systemctl restart php8.5-fpm
ls -l /run/php/

Il socket tuo-dominio.com.sock deve appartenere a nginx:nginx.

Passo 6: configurare Nginx

Disattiva la configurazione di esempio, poi crea le impostazioni generali:

Terminale
sudo mv /etc/nginx/conf.d/default.conf /etc/nginx/conf.d/default.conf.disabled
sudo nano /etc/nginx/conf.d/00-defaults.conf
Nginx
server_tokens off;

gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_types text/plain text/css application/javascript application/json application/xml image/svg+xml;

server {
    listen 80 default_server;
    listen [::]:80 default_server;
    server_name _;
    return 444;
}

server {
    listen 443 ssl default_server;
    listen [::]:443 ssl default_server;
    server_name _;
    ssl_reject_handshake on;
}

Questi due blocchi chiudono la connessione quando una richiesta non corrisponde a nessuno dei tuoi domini. Crea poi il virtual host:

Terminale
sudo nano /etc/nginx/conf.d/tuo-dominio.com.conf
Nginx
server {
    listen 80;
    listen [::]:80;
    server_name tuo-dominio.com www.tuo-dominio.com;

    root /var/www/tuo-dominio.com/public;
    index index.php index.html;

    access_log /var/log/nginx/tuo-dominio.com.access.log;
    error_log /var/log/nginx/tuo-dominio.com.error.log;

    client_max_body_size 32m;

    location ~ /\.(?!well-known) {
        deny all;
    }

    location ^~ /uploads/ {
        location ~ \.php$ {
            deny all;
        }
    }

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

    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_pass unix:/run/php/tuo-dominio.com.sock;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        fastcgi_param DOCUMENT_ROOT $realpath_root;
    }
}

Questa configurazione nega l'accesso ai file nascosti come .env e l'esecuzione di PHP in uploads. Testa e ricarica:

Terminale
sudo nginx -t
sudo systemctl reload nginx

Passo 7: verificare il sito

Dal server:

Terminale
curl -i -H 'Host: tuo-dominio.com' http://127.0.0.1/

La risposta deve essere 200 OK, con la versione di PHP, l'utente webapp e OPcache: on. Verifica anche le protezioni:

Terminale
echo 'test' > /var/www/tuo-dominio.com/public/.test
curl -s -o /dev/null -w '%{http_code}\n' -H 'Host: tuo-dominio.com' http://127.0.0.1/.test
rm /var/www/tuo-dominio.com/public/.test

Il codice atteso è 403. Apri poi http://tuo-dominio.com nel tuo browser. Una richiesta diretta all'indirizzo IP non ottiene risposta: è l'effetto voluto del blocco predefinito.

Passo 8: attivare HTTPS

Segui la guida Installare un certificato SSL con Let's Encrypt, sezione Nginx. Ignora la parte su sites-available: il tuo file è /etc/nginx/conf.d/tuo-dominio.com.conf. Il comando principale è:

Terminale
sudo certbot --nginx -d tuo-dominio.com -d www.tuo-dominio.com

Una volta installato il certificato, attiva HTTP/2 aggiungendo questa riga nel blocco server che contiene listen 443 ssl:

Nginx
http2 on;

Aggiungi anche questa riga a /etc/php/8.5/fpm/conf.d/90-custom.ini per riservare i cookie di sessione a HTTPS:

Configurazione
session.cookie_secure = 1

Applica e poi controlla:

Terminale
sudo nginx -t
sudo systemctl reload nginx
sudo systemctl restart php8.5-fpm
curl -I https://tuo-dominio.com
sudo certbot renew --dry-run

Terminati i tuoi test, sostituisci la pagina di test con la tua applicazione.

Dimensionare PHP-FPM

pm.max_children limita il numero di richieste PHP elaborate contemporaneamente. Un valore troppo alto può esaurire la memoria. Misura il consumo medio, preferibilmente sotto carico reale:

Terminale
ps --no-headers -o rss -C php-fpm8.5 | awk '{s+=$1; n++} END {printf "%.0f Mo\n", s/n/1024}'
free -m

Calcola poi: memoria disponibile per PHP ÷ consumo medio di un processo. Per esempio, 1 024 MB ÷ 60 MB danno circa 17 processi. Lascia un margine per il sistema e per il database, poi ricarica con sudo systemctl reload php8.5-fpm.

Aggiornamenti

Terminale
sudo apt update
sudo apt upgrade
sudo nginx -t
sudo systemctl status nginx php8.5-fpm

Per passare a un nuovo ramo di PHP, installa i suoi pacchetti, copia il tuo pool e 90-custom.ini nella cartella della nuova versione, ferma il vecchio servizio, poi avvia quello nuovo. Poiché il socket mantiene lo stesso nome, il virtual host non cambia. Testa prima la tua applicazione.

Backup

Fai il backup del sito e della sua configurazione, poi copia l'archivio fuori dal server:

Terminale
sudo tar czf site-backup.tar.gz /var/www/tuo-dominio.com /etc/nginx /etc/php/8.5/fpm /etc/letsencrypt
sudo chmod 600 site-backup.tar.gz

L'archivio contiene le chiavi private dei tuoi certificati. Se il sito usa un database, fanne il backup separatamente, per esempio con mariadb-dump (vedi Installare e proteggere MariaDB).

In caso di problemi

I log utili sono /var/log/nginx/tuo-dominio.com.error.log e /var/log/php8.5-fpm.log.

502 Bad Gateway con connect() ... failed (13: Permission denied)

Nginx non ha accesso al socket. Verifica listen.owner e listen.group nel pool, poi riavvia PHP-FPM.

502 Bad Gateway con connect() ... failed (2: No such file or directory)

PHP-FPM è fermo, oppure il percorso del socket differisce tra il pool e fastcgi_pass. Consulta sudo systemctl status php8.5-fpm e sudo php-fpm8.5 -t.

File not found. o Primary script unknown

Il file non esiste nel percorso indicato da root, oppure l'utente webapp non può leggerlo. Verifica il percorso e i permessi con namei -l /var/www/tuo-dominio.com/public/index.php.

Il browser scarica il file PHP

Il blocco location ~ \.php$ non viene preso in considerazione. Verifica che il dominio corrisponda a server_name, poi ricarica Nginx.

413 Request Entity Too Large

Aumenta client_max_body_size in Nginx, oltre a upload_max_filesize e post_max_size in PHP, con valori coerenti.

504 Gateway Timeout

Lo script supera il timeout di Nginx. Ottimizzalo se possibile, oppure regola insieme fastcgi_read_timeout, max_execution_time e request_terminate_timeout.

server reached pm.max_children setting

Tutti i posti del pool sono occupati. Cerca prima le richieste lente, poi aumenta pm.max_children se la memoria lo consente.

bind() to 0.0.0.0:80 failed (98: Address already in use)

Un altro servizio, spesso Apache, occupa la porta. Individualo con sudo ss -ltnp | grep ':80 '.

curl: (52) Empty reply from server

La richiesta non corrisponde a nessun server_name e il blocco predefinito ha chiuso la connessione. Verifica l'intestazione Host e il dominio configurato.

Riferimenti