Padroneggiare la Configurazione di Nginx: Direttive Essenziali Spiegate

La configurazione di Nginx diventa molto più semplice una volta che capisci dove ogni direttiva può essere posizionata. Se la tua regola proxy_pass, root o try_files si trova nel contesto sbagliato, Nginx potrebbe rifiutare la configurazione o gestire le richieste in modo inaspettato.

Questa guida illustra le direttive essenziali che utilizzerai quando servi file statici, fai da proxy inverso per un'app, abiliti la compressione e ricarichi le modifiche in modo sicuro.

La Struttura della Configurazione di Nginx

I file di configurazione di Nginx di solito si trovano in /etc/nginx/ sui pacchetti Linux. Il file principale è comunemente /etc/nginx/nginx.conf, e spesso include file da /etc/nginx/conf.d/. I pacchetti Debian e Ubuntu usano comunemente sites-available/ e sites-enabled/; molte altre distribuzioni no.

La configurazione è gerarchica, organizzata in blocchi o direttive. I blocchi chiave includono:

events: Configura la gestione delle connessioni.
http: Contiene le impostazioni HTTP globali e i server virtuali.
server: Definisce un server virtuale per una porta e un nome host.
location: Sceglie come gestire gli URI delle richieste corrispondenti.

Le direttive sono coppie chiave-valore che controllano il comportamento di Nginx. Possono essere globali o annidate all'interno di blocchi.

Direttive Essenziali Spiegate

Il Blocco `http`

Il blocco http racchiude le configurazioni che si applicano globalmente al traffico HTTP. Qui definirai le impostazioni comuni per il tuo server web.

include: Questa direttiva ti permette di includere altri file di configurazione, aiutando a modularizzare la tua configurazione. È comunemente usata per separare le configurazioni per diversi siti web o applicazioni.
```
http {
    include       mime.types;
    default_type  application/octet-stream;

    # Include le configurazioni del server dalla directory conf.d
    include /etc/nginx/conf.d/*.conf;
}
```

log_format: Definisce formati di log personalizzati per i log di accesso ed errore di Nginx. Questo è essenziale per una registrazione e un'analisi dettagliate.

http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                        '$status $body_bytes_sent "$http_referer" '
                        '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;
    error_log   /var/log/nginx/error.log;
    # ... altre direttive http
}

sendfile: Ottimizza i trasferimenti di file permettendo al kernel di inviare i file direttamente dal disco al client, bypassando lo spazio utente. Imposta su on per le prestazioni.
```
http {
    sendfile        on;
    # ...
}
```
tcp_nopush e tcp_nodelay: Ottimizzano il comportamento TCP per le risposte HTTP. tcp_nopush è comunemente usato con sendfile per ottimizzare l'invio dei pacchetti, mentre tcp_nodelay aiuta a evitare ritardi sulle connessioni keepalive.
```
http {
    tcp_nopush     on;
    tcp_nodelay    on;
    # ...
}
```

Il Blocco `server`

Ogni blocco server definisce un server virtuale, permettendo a Nginx di gestire richieste per diversi nomi di dominio o indirizzi IP sullo stesso server.

listen: Specifica l'indirizzo IP e/o la porta su cui il server ascolterà le connessioni in arrivo.

server {
    listen 80;
    listen [::]:80;
    server_name example.com www.example.com;
    # ...
}

server_name: Definisce i nomi del server. Nginx usa questo per abbinare l'intestazione Host della richiesta in arrivo.
```
server {
    listen 80;
    server_name mydomain.org *.mydomain.org;
    # ...
}
```
root: Imposta la radice del documento. Nginx costruisce il percorso del file aggiungendo l'URI della richiesta a questa directory.
```
server {
    listen 80;
    server_name localhost;
    root /var/www/html;
    index index.html index.htm;
    # ...
}
```
index: Specifica il file predefinito da servire quando viene richiesta una directory.
```
server {
    # ...
    index index.html index.htm default.html;
    # ...
}
```

error_page: Definisce pagine di errore personalizzate per specifici codici di stato HTTP.

server {
    # ...
    error_page 404 /404.html;
    location = /404.html {
        root /usr/share/nginx/html;
        internal;
    }
    # ...
}

Il Blocco `location`

Il blocco location viene utilizzato per abbinare gli URI delle richieste e determinare come Nginx deve elaborarli. Qui configuri il routing per diverse parti della tua applicazione.

Corrispondenza URI: Le location possono corrispondere a stringhe esatte, prefissi o espressioni regolari. Le corrispondenze esatte usano =, le espressioni regolari usano ~ o ~*, e i prefissi semplici corrispondono per prefisso URI.

location /images/ {
    # Direttive per richieste che iniziano con /images/
}

location = /favicon.ico {
    # Corrispondenza esatta per /favicon.ico
}

location ~ \.php$ {
    # Corrispondenza regex per file che terminano con .php
}

proxy_pass: Inoltra le richieste a un server upstream. Fai attenzione alla barra finale perché cambia il modo in cui Nginx riscrive il prefisso corrispondente.

location /api/ {
    proxy_pass http://backend-service:8080/;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

alias: Mappa una location a un percorso del filesystem senza aggiungere l'URI originale completo. Viene spesso utilizzato per asset statici memorizzati al di fuori della radice del documento principale.
```
location /static/ {
    alias /var/www/app/assets/;
}
```
Con alias, includi la barra finale sia sulla location che sul percorso per i mapping delle directory. alias sostituisce il prefisso della location corrispondente con il percorso alias, mentre root aggiunge l'URI al percorso radice.
try_files: Verifica l'esistenza di file in un ordine specificato e serve il primo trovato, oppure restituisce un codice/URI specificato.
```
location / {
    try_files $uri $uri/ /index.html;
}
```
Questo è comune per le applicazioni a pagina singola. Se un file o una directory richiesti non esistono, Nginx serve index.html in modo che il router lato client possa gestire il percorso.

Direttive di Sicurezza e Prestazioni

ssl_certificate e ssl_certificate_key: Essenziali per configurare HTTPS. Queste direttive puntano ai file del certificato SSL e della chiave privata.

server {
    listen 443 ssl;
    server_name secure.example.com;

    ssl_certificate /etc/letsencrypt/live/secure.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/secure.example.com/privkey.pem;

    # ... altre impostazioni SSL
}

gzip: Abilita o disabilita la compressione gzip per tipi di risposta selezionati. Spesso riduce la dimensione del trasferimento per gli asset di testo, ma evita di comprimere file già compressi come la maggior parte delle immagini.

http {
    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
    # ...
}

expires: Controlla le intestazioni di caching per gli asset statici. Usa durate di cache lunghe per file con impronta digitale e durate più brevi per file che mantengono lo stesso URL tra le distribuzioni.
```
location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
    expires 30d;
    add_header Cache-Control "public";
}
```

Comandi Comuni di Nginx

Per gestire Nginx e applicare le modifiche alla configurazione, utilizzerai frequentemente questi comandi:

Test della configurazione: Verifica la presenza di errori di sintassi nei file di configurazione di Nginx.
```
sudo nginx -t
```
Ricarica della configurazione: Ricarica la configurazione di Nginx senza interrompere le connessioni attive.
```
sudo systemctl reload nginx
# oppure
sudo service nginx reload
```

Riavvio di Nginx: Arresta e quindi avvia il servizio Nginx.

sudo systemctl restart nginx
# oppure
sudo service nginx restart

Controllo dello stato: Mostra lo stato corrente del servizio Nginx.
```
sudo systemctl status nginx
# oppure
sudo service nginx status
```

Un Esempio Funzionante Minimo

Questo esempio serve un'app a pagina singola dal disco e fa da proxy per le richieste API a un server applicativo:

server {
    listen 80;
    server_name example.com;

    root /var/www/example.com;
    index index.html;

    location /api/ {
        proxy_pass http://127.0.0.1:3000/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location / {
        try_files $uri $uri/ /index.html;
    }
}

Esegui sudo nginx -t prima di ogni ricarica. Questa abitudine coglie gli errori di sintassi prima che diventino tempi di inattività.

Conclusione

La maggior parte degli errori di Nginx deriva dalla gestione del contesto e del percorso. Metti le impostazioni HTTP globali in http, le regole specifiche dell'host in server, il routing degli URI in location, e testa ogni modifica con nginx -t prima di ricaricare.