Maîtrise de la configuration Nginx : directives essentielles expliquées

La configuration de Nginx devient beaucoup plus facile une fois que vous comprenez où chaque directive peut être placée. Si votre règle proxy_pass, root ou try_files se trouve dans le mauvais contexte, Nginx peut rejeter la configuration ou traiter les requêtes d'une manière que vous n'aviez pas prévue.

Ce guide vous présente les directives essentielles que vous utiliserez lors du service de fichiers statiques, du proxy inverse d'une application, de l'activation de la compression et du rechargement sécurisé des modifications.

La structure de configuration de Nginx

Les fichiers de configuration de Nginx se trouvent généralement dans /etc/nginx/ sur les paquets Linux. Le fichier principal est généralement /etc/nginx/nginx.conf, et il inclut souvent des fichiers provenant de /etc/nginx/conf.d/. Les paquets Debian et Ubuntu utilisent couramment sites-available/ et sites-enabled/ ; de nombreuses autres distributions ne le font pas.

La configuration est hiérarchique, organisée en blocs ou directives. Les blocs clés incluent :

events : Configure le traitement des connexions.
http : Contient les paramètres généraux HTTP et les serveurs virtuels.
server : Définit un serveur virtuel pour un port et un nom d'hôte.
location : Choisit comment traiter les URI de requêtes correspondantes.

Les directives sont des paires clé-valeur qui contrôlent le comportement de Nginx. Elles peuvent être globales ou imbriquées dans des blocs.

Directives essentielles expliquées

Le bloc `http`

Le bloc http englobe les configurations qui s'appliquent globalement au trafic HTTP. C'est là que vous définirez les paramètres communs de votre serveur web.

include : Cette directive vous permet d'inclure d'autres fichiers de configuration, ce qui facilite la modularisation de votre configuration. Elle est couramment utilisée pour séparer les configurations de différents sites web ou applications.
```
http {
    include       mime.types;
    default_type  application/octet-stream;

    # Inclure les configurations du serveur depuis le répertoire conf.d
    include /etc/nginx/conf.d/*.conf;
}
```

log_format : Définit des formats de journal personnalisés pour les journaux d'accès et d'erreur de Nginx. Ceci est essentiel pour une journalisation et une analyse détaillées.

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;
    # ... autres directives http
}

sendfile : Optimise les transferts de fichiers en permettant au noyau d'envoyer les fichiers directement du disque au client, en contournant l'espace utilisateur. Définissez sur on pour les performances.
```
http {
    sendfile        on;
    # ...
}
```
tcp_nopush et tcp_nodelay : Ces directives ajustent le comportement TCP pour les réponses HTTP. tcp_nopush est couramment utilisé avec sendfile pour optimiser l'envoi de paquets, tandis que tcp_nodelay aide à éviter les délais sur les connexions persistantes.
```
http {
    tcp_nopush     on;
    tcp_nodelay    on;
    # ...
}
```

Le bloc `server`

Chaque bloc server définit un serveur virtuel, permettant à Nginx de gérer les requêtes pour différents noms de domaine ou adresses IP sur le même serveur.

listen : Spécifie l'adresse IP et/ou le port sur lequel le serveur écoutera les connexions entrantes.

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

server_name : Définit les noms du serveur. Nginx l'utilise pour faire correspondre l'en-tête Host de la requête entrante.
```
server {
    listen 80;
    server_name mydomain.org *.mydomain.org;
    # ...
}
```
root : Définit la racine du document. Nginx construit le chemin du fichier en ajoutant l'URI de la requête à ce répertoire.
```
server {
    listen 80;
    server_name localhost;
    root /var/www/html;
    index index.html index.htm;
    # ...
}
```
index : Spécifie le fichier par défaut à servir lorsqu'un répertoire est demandé.
```
server {
    # ...
    index index.html index.htm default.html;
    # ...
}
```

error_page : Définit des pages d'erreur personnalisées pour des codes d'état HTTP spécifiques.

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

Le bloc `location`

Le bloc location est utilisé pour faire correspondre les URI de requête et déterminer comment Nginx doit les traiter. C'est là que vous configurez le routage pour différentes parties de votre application.

Correspondance des URI : Les emplacements peuvent correspondre à des chaînes exactes, des préfixes ou des expressions régulières. Les correspondances exactes utilisent =, les expressions régulières utilisent ~ ou ~*, et les préfixes simples correspondent par préfixe d'URI.
```
location /images/ {
    # Directives pour les requêtes commençant par /images/
}

location = /favicon.ico {
    # Correspondance exacte pour /favicon.ico
}

location ~ \.php$ {
    # Correspondance regex pour les fichiers se terminant par .php
}
```

proxy_pass : Transfère les requêtes vers un serveur en amont. Faites attention à la barre oblique finale car elle modifie la façon dont Nginx réécrit le préfixe correspondant.

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 : Mappe un emplacement vers un chemin du système de fichiers sans ajouter l'URI d'origine complète. Il est souvent utilisé pour les actifs statiques stockés en dehors de la racine du document principal.
```
location /static/ {
    alias /var/www/app/assets/;
}
```
Avec alias, incluez la barre oblique finale à la fois sur l'emplacement et le chemin pour les mappages de répertoires. alias remplace le préfixe d'emplacement correspondant par le chemin d'alias, tandis que root ajoute l'URI au chemin racine.
try_files : Vérifie l'existence de fichiers dans un ordre spécifié et sert le premier trouvé, ou renvoie un code/URI spécifié.
```
location / {
    try_files $uri $uri/ /index.html;
}
```
Ceci est courant pour les applications à page unique. Si un fichier ou un répertoire demandé n'existe pas, Nginx sert index.html afin que le routeur côté client puisse gérer le chemin.

Directives de sécurité et de performance

ssl_certificate et ssl_certificate_key : Essentielles pour configurer HTTPS. Ces directives pointent vers vos fichiers de certificat SSL et de clé privée.

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;

    # ... autres paramètres SSL
}

gzip : Active ou désactive la compression gzip pour certains types de réponses. Cela réduit souvent la taille de transfert pour les actifs textuels, mais évitez de compresser les fichiers déjà compressés comme la plupart des images.
```
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 : Contrôle les en-têtes de mise en cache pour les actifs statiques. Utilisez des durées de vie de cache longues pour les fichiers avec empreinte, et des durées plus courtes pour les fichiers qui conservent la même URL entre les déploiements.
```
location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
    expires 30d;
    add_header Cache-Control "public";
}
```

Commandes Nginx courantes

Pour gérer Nginx et appliquer les modifications de configuration, vous utiliserez fréquemment ces commandes :

Tester la configuration : Vérifie les erreurs de syntaxe dans vos fichiers de configuration Nginx.
```
sudo nginx -t
```
Recharger la configuration : Recharge élégamment la configuration Nginx sans interrompre les connexions actives.
```
sudo systemctl reload nginx
# ou
sudo service nginx reload
```

Redémarrer Nginx : Arrête puis démarre le service Nginx.

sudo systemctl restart nginx
# ou
sudo service nginx restart

Vérifier l'état : Affiche l'état actuel du service Nginx.

sudo systemctl status nginx
# ou
sudo service nginx status

Un exemple fonctionnel minimal

Cet exemple sert une application à page unique depuis le disque et transmet les requêtes API à un serveur d'application :

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;
    }
}

Exécutez sudo nginx -t avant chaque rechargement. Cette habitude permet de détecter les erreurs de syntaxe avant qu'elles ne deviennent des temps d'arrêt.

À retenir

La plupart des erreurs Nginx proviennent du contexte et de la gestion des chemins. Placez les paramètres généraux HTTP dans http, les règles spécifiques à l'hôte dans server, le routage des URI dans location, et testez chaque modification avec nginx -t avant de recharger.