Nginx


> nginx

Nginx (prononcez “Engine X”) est serveur web robuste, léger et très performant sous licence BSD … Igor Sysoev a démarré son développement en 2002, et sa version 1.0 est sorti en 2011. Il a été développé dans la perspective de pouvoir répondre à la problématique des sites web actuels : desservir 10K clients simultanément.
Sa faible empreinte mémoire et CPU en fait le parfait candidat pour de petits serveurs à faibles ressources physiques, où les sites à très fort trafic. Il s’avère 3 à 4 fois plus rapide que Apache en mode prefork + PHP embarqué dans la plupart des cas pour une bande passante moindre. D’après le wiki nginx, il est utilisé par 46% des sites russes et, d’après W3Techs, par 8% des serveurs web à travers le monde le mettant ainsi en 3ème position derrière IIS et Apache. Pour le traitement du contenu dynamique, il s’appuie sur une interface FastCGI mais aussi uWSGI. Il possède nombre de modules lui permettant de rivaliser avec les plus utilisés des serveurs HTTP et permet aussi de faire proxy pour les protocoles IMAP, POP et SMTP.

Sur ces belles paroles, faisons tourner la bête pour voir de quoi il retourne vraiment.

Installation

USE

Concernant sa variable USE voici ce que nous activerons en mettant cette ligne dans le fichier /etc/portage/package.use/nginx.use par exemple :

www-servers/nginx aio http http-cache ipv6 pcre ssl vim-syntax
  • aio : active les entrées sorties asynchrones,
  • http : active le support HTTP (c’est mieux dans la perspective de publier des pages web!)
  • http-cache : active le support du cache,
  • ipv6 : active le support IPv6,
  • pcre : active le support des expressions,
  • rtmp : active le support de serveur de streaming,
  • ssl : active le support OpenSSL,
  • syslog : active le support de syslog,
  • uwsgi : active le support du protocole uWSGI,
  • vim-syntax : active la coloration syntaxique de la configuration sous vim.

NGINX_MODULES_HTTP

Nginx possède un grand nombre de modules activables via la variable NGINX_MODULES_HTTP.

Ajoutez au fichier /etc/portage/make.conf ce qui suit :

NGINX_MODULES_HTTP="access auth_basic autoindex fastcgi browser charset gzip proxy referer rewrite spdy stub_status upstream upstream_check"
  • access : module proposant le contrôle d’accès basé sur l’hôte,
  • auth_basic : module d’authentification HTTP avec utilisateur et mot de passe,
  • autoindex : module permettant de lister les fichiers d’un repertoire,
  • fastcgi : module FastCGI pour la communication avec les langages,
  • browser : module permettant de créer des variables et données basées sur l’entête “User-agent de la requête,
  • charset : module de re-encodage des données,
  • gzip : module de compression des données,
  • proxy : module proxy,
  • referer : module permettant de créer des filtres basés sur l’entête “Referer” de la requête,
  • rewrite : module de ré-écriture des URLs
  • spdy : module implémentant le protocole SDPY (‘Speedy’) créer par Google,
  • stub_status : module permettant la visualisation en temps réel de l’état du service,
  • upstream : module permettant de créer des pools de ressources appelés dans la configuration,
  • upstream_check : module permettant de tester les pools de ressources.

Une fois que vous avez paramétré ses variables, il ne vous reste plus qu’à l’installer :

emerge -av www-servers/nginx

Configuration

Ici nous appliquerons une configuration quelque peu calquée sur Debian pour la gestion de l’activation des vhosts via des liens symboliques.

Créez les répertoires nécéssaires :

mkdir /etc/nginx/{conf.d,sites-available,sites-enabled}

Passons maintenant au coeur du sujet. Si nous autorisons 2048 connexions (worker_processes * worker_connections), nginx aura besoin de 2048 file descriptors (descripteurs de fichiers). Sachant que la limite par défaut sous Linux est de 1024 par utilisateur, il vous faudra faire certains réglages.

Créez un utilisateur :

useradd -d /dev/null -g 33 -u 33 -s /sbin/nologin

Augmentez les limites d’ouvertures de file descriptors en modifiant le fichier /etc/security/limits.conf :

www          soft    nofile           2048
www          hard    nofile           2048

Afin que cela soit appliquer lors de l’utilisation du script d’initialisation ajoutez le fichier /etc/conf.d/nginx :

rc_ulimit="-n 2048"

A noter que dans le cas d’utilisation du module proxy, chaque requête consommera 4 file descriptors, il vous faudra donc adapter ces chiffres à votre utilisation.

nginx.conf

###
user www www;
worker_processes 2;

error_log /var/log/nginx/error_log info;

events {
        worker_connections  1024;
        use epoll;
}

http {
        server_tokens off;

        server_names_hash_max_size 512;
        server_names_hash_bucket_size 128;
        server_name_in_redirect off;

        include         mime.types;
        default_type    application/octet-stream;

        client_header_timeout   10m;
        client_body_timeout     10m;
        send_timeout            10m;
        client_max_body_size    50m;

        connection_pool_size            256;
        client_header_buffer_size       64k;
        client_body_buffer_size         128k;
        large_client_header_buffers     8 16k;
        request_pool_size               4k;

        gzip              on;
        gzip_vary         on;
        gzip_proxied      any;
        gzip_http_version 1.1;
        gzip_comp_level   2;
        gzip_min_length   1100;
        gzip_buffers      16 8k;
        gzip_types        text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
        gzip_disable      "MSIE [1-6]\.(?!.*SV1)";

        output_buffers  1 32k;
        postpone_output 1460;

        sendfile        on;
        tcp_nopush      on;
        tcp_nodelay     on;

        keepalive_timeout       75 75;

        ignore_invalid_headers  on;

        index index.html;

        include conf.d/*.conf;
        include sites-enabled/*;

        access_log      /var/log/nginx/access_log;
        error_log       /var/log/nginx/error_log;

}

Vhosts

Default

Passons maintenant à la configuration des vhosts et créons celui par défaut, c’est-à-dire écoutant même sur l’adresse seule.

Fichier /etc/nginx/sites-available/default :

server {
                listen 80;
                server_name _;
                server_name_in_redirect off;
                return 444;
}

Dans ce cas, si la requête est faite sur un vhost ne stipulant pas le nom de domaine, la requête retourne un code HTTP 444 (pas de réponse).

www.gentoo-fr.org

Créez votre premier vhost; dans cet exemple l’écoute se fait uniquement le nom de domaine www.gentoo-fr.org, les fichiers commençant par .ht (htaccess, htpasswd…) sont interdits, l’accès au fichier favicon.ico ne sera pas enregistré dans les logs et son expiration est fixé à 1 jour (équivalent du mod_expire sous Apache).

Fichier /etc/nginx/sites-available/gentoo-fr.org :

server {
        listen 80;
        server_name www.gentoo-fr.org;
        root /var/www/gentoo-fr.org/www;

        location ~ /\.ht {
                deny  all;
        }

        location /favicon.ico {
                access_log  off;
                log_not_found  off;
                expires  1d;
        }
}

Faites les liens des sites que vous activez :

cd /etc/nginx/sites-enabled
ln -s ../sites-available/default 00-default
ln -s ../sites-available/gentoo-fr.org 10-gentoo-fr.org

Vérifiez la syntaxe :

nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Et démarrez le service :

rc-update add nginx default
/etc/init.t/nginx start

Cela dit, je suis d’accord avec vous, peu de sites sont statiques à notre époque, et donc la configuration d’un interpréteur s’impose.

Modules

Il existe un certain nombre de modules pour Nginx, je ne traiterai que les principaux pour un usage basique. Pour vos besoins spécifiques, je vous invite à vous reporter à la documentation en anglais.

FastCGI PHP

php-fpm

fpm pour “Fork Process Manager” est le gestionnaire de processus PHP intégré à PHP à partir de la version 5.3.

Afin d’exécuter les scripts PHP via l’interface Fastcgi, il faut vous assurer du support cgi et fpm à sa compilation.

Configurez le service php-fpm en modifiant le fichier /etc/php/fpm-php5.3/php-fpm.conf :

[global]
pid = /var/run/php-fpm.pid
error_log = /var/log/php-fpm.log

[www]
listen = /var/run/php-fpm.sock
listen.owner = www
listen.group = www
listen.mode = 0660
user = www
group = www
pm = dynamic
pm.max_children = 50
pm.start_servers = 20
pm.min_spare_servers = 5
pm.max_spare_servers = 35
pm.max_requests = 500

Démarrez :

rc-update add php-fpm default
/etc/init.d/php-fpm start

Ajoutez le fichier /etc/nginx/conf.d/00-upstream.conf :

upstream php5-backend {
        server unix:/var/run/php-fpm.sock;
}

Ajoutez le fichier _/etc/nginx/php_fatcgiparams qui contiendra les options FastCGI PHP génériques :

fastcgi_send_timeout 180;
fastcgi_read_timeout 180;
fastcgi_buffer_size 128k;
fastcgi_buffers 4 256k;
fastcgi_busy_buffers_size 256k;
fastcgi_temp_file_write_size 256k;
fastcgi_intercept_errors on;

fastcgi_param  SCRIPT_FILENAME    $request_filename;
fastcgi_param  QUERY_STRING       $query_string;
fastcgi_param  REQUEST_METHOD     $request_method;
fastcgi_param  CONTENT_TYPE       $content_type;
fastcgi_param  CONTENT_LENGTH     $content_length;

fastcgi_param  SCRIPT_NAME        $fastcgi_script_name;
fastcgi_param  REQUEST_URI        $request_uri;
fastcgi_param  DOCUMENT_URI       $document_uri;
fastcgi_param  DOCUMENT_ROOT      $document_root;
fastcgi_param  SERVER_PROTOCOL    $server_protocol;

fastcgi_param  GATEWAY_INTERFACE  CGI/1.1;
fastcgi_param  SERVER_SOFTWARE    nginx/$nginx_version;

fastcgi_param  REMOTE_ADDR        $remote_addr;
fastcgi_param  REMOTE_PORT        $remote_port;
fastcgi_param  SERVER_ADDR        $server_addr;
fastcgi_param  SERVER_PORT        $server_port;
fastcgi_param  SERVER_NAME        $server_name;

# PHP only, required if PHP was built with --enable-force-cgi-redirect
fastcgi_param  REDIRECT_STATUS    200;

Modifiez votre vhost afin qu’il transfère au service php-fpm les requêtes concernant les fichiers avec l’extension .php :

server {
        listen 80;
        server_name www.gentoo-fr.org;
        root /var/www/gentoo-fr.org/www;
        index index.html index.php;

        location ~ /\.ht {
                deny  all;
        }

        location ~ \.php$ {
                include php_fastcgi_params;
                fastcgi_pass php5-backend;
        }

        location /favicon.ico {
                access_log  off;
                log_not_found  off;
                expires  1d;
        }
}

Redémarrez le service nginx :

/etc/init.d/nginx restart

spawn-fcgi

Pour ceux qui utilisent une version inférieure à php-5.3, vous pouvez utiliser spawn-fcgi, initialement développé pour lighttpd, comme gestionnaire de processus php-cgi.

emerge -av spawn-fcgi

Modifiez le fichier /etc/conf.d/spawn-fcgi :

FCGI_SOCKET=/var/run/spawn-fcgi/php-cgi.sock
FCGI_PROGRAM=/usr/bin/php-cgi
FCGI_CHILDREN=1
FCGI_USER=www
FCGI_GROUP=www
PHP_FCGI_CHILDREN=10
PHP_FCGI_MAX_REQUESTS=500
ALLOWED_ENV="PATH PHP_FCGI_CHILDREN PHP_FCGI_MAX_REQUESTS"

Démarrez le service spawn-fcgi :

rc-update add spawn-fcgi default
/etc/init.d/spawn-fcgi start

Modifiez votre configuration nginx en conséquence en modifiant le fichier /etc/nginx/conf.d/00-upstream.conf :

upstream php5-backend {
        server unix:/var/run/spawn-fcgi/php-cgi.sock;
}

Redémarrez le service nginx.

Rails & Rack

Il y a une manière relativement simple d’utiliser le framework Rails et Rack sous nginx en utilisant Phusion Passenger aussi appelé mod_rails sous Apache, mais aussi Thin ou encore Unicorn. En paramétrant nginx en mode proxy, tout le contenu dynamique étant demandé à l’application.

Créez le fichier /etc/nginx/proxy_params qui contiendra les informations génériques pour la communication entre nginx et :

proxy_redirect             off;
proxy_set_header           Host            $http_host;
proxy_set_header           X-Real-IP       $remote_addr;
proxy_set_header           X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_connect_timeout      180;
proxy_send_timeout         180;
proxy_read_timeout         180;
proxy_buffer_size          4k;
proxy_buffers              4   32k;
proxy_busy_buffers_size    64k;
proxy_temp_file_write_size 64k;

Ensuite faites ressembler votre vhost à ce qui suit :

# Upstream Ruby process cluster for load balancing
upstream rails-gentoo-fr {
    server unix:/tmp/rails-gentoo-fr.0.sock;
    server unix:/tmp/rails-gentoo-fr.1.sock;
    server unix:/tmp/rails-gentoo-fr.2.sock;
    server unix:/tmp/rails-gentoo-fr.3.sock;
}

server {
        listen 80;
        server_name  projects.gentoo-fr.org;
        root  /var/www/gentoo-fr.org/projects/public;

        location / {
                try_files $uri/index.html $uri.html $uri @rails-gentoo-fr;
        }

        location @rails-gentoo-fr {
                include proxy_params;
                proxy_pass http://rails-gentoo-fr;
        }

        location ~ /\.ht {
                deny  all;
        }

        location /favicon.ico {
                access_log  off;
                log_not_found  off;
                expires  1d;
        }

        location ~ /(images|javascripts|stylesheets)/ {
                expires   1d;
        }
}

Redémarrez nginx et le tour est joué.

SSL

Passons à la configuration du module SSL.

Global

Pour utiliser le même certificat pour tous les vhosts, créez le fichier /etc/nginx/conf.d/10-ssl.conf :

ssl on;
ssl_certificate /etc/ssl/private/nginx.cert;
ssl_certificate_key /etc/ssl/private/nginx.key;

Ensuite modifiez vos vhosts afin qu’ils écoutent sur le port 443 au lieu de 80.

Vhost

Pour utiliser un certificat spécifique par vhost reportez les lignes ci-dessus dans sa configuration :

server {
        listen 443;
[...]
        ssl on;
        ssl_certificate /etc/ssl/private/nginx.cert;
        ssl_certificate_key /etc/ssl/private/nginx.key;
[...]
}

uWSGI

Le module uWSGI permet d’utiliser le protocole du même nom. Ajoutez l’upstream correspondant à votre fichier /etc/nginx/conf.d/00-upstream.conf :

upstream uwsgi-www-php54 {
        server unix:/run/uwsgi_www-php54/uwsgi.www-php54.sock;
}

Crééz le fichier _/etc/nginx/uwsgiparams :

uwsgi_param  QUERY_STRING       $query_string;
uwsgi_param  REQUEST_METHOD     $request_method;
uwsgi_param  CONTENT_TYPE       $content_type;
uwsgi_param  CONTENT_LENGTH     $content_length;

uwsgi_param  REQUEST_URI        $request_uri;
uwsgi_param  PATH_INFO          $document_uri;
uwsgi_param  DOCUMENT_ROOT      $document_root;
uwsgi_param  SERVER_PROTOCOL    $server_protocol;
uwsgi_param  HTTPS              $https if_not_empty;

uwsgi_param  REMOTE_ADDR        $remote_addr;
uwsgi_param  REMOTE_PORT        $remote_port;
uwsgi_param  REMOTE_USER        $remote_user;
uwsgi_param  SERVER_PORT        $server_port;
uwsgi_param  SERVER_NAME        $server_name;

En enfin le vhost :

[...]
        location ~ \.php$ {
                try_files    $uri =404;
                include uwsgi_params;
                uwsgi_modifier1 14;
                uwsgi_pass uwsgi-www-php54;
        }
[...]

Pour le paramètre uwsgi_modifier1 reportez-vous à la documention du protocole uWSGI.

Access

Le module access va vous permettre d’effectuer un filtrage par adresse IP pour l’accès à certaines ressources :

server {
[...]
        location / {
                allow 127.0.0.1;
                allow 192.168.0.0/24;
                deny all;
        }
[...]
}

Auth

Le module d’authentification vous permet quant à lui de restreindre l’accès par utilisateur :

server {
[...]
        location / {
                auth_basic  "Secure Access";
                auth_basic_user_file  /etc/nginx/.htpasswd;
        }
[...]
}

Auto Index

Ce module permet de lister les fichiers et répertoires contenus dans un emplacement :

server {
[...]
        location /download/ {
                autoindex  on;
        }
[...]
}

Proxy

server {
[...]
        location / {
                include proxy_params;
                proxy_pass http://localhost:8080;
        }
[...]
}

Rewrite

Le module rewrite permet la re-écriture des URLs, très partique afin de convertir les RewriteRules Apache.

Si le site est appelé en http://gentoo-fr.org/ , modifier l’URL en http://www.gentoo-fr.org/ de manière permanente (code HTTP 301) :

server {
        listen 80;
        server_name gentoo-fr.org;
        return 301 http://www.gentoo-fr.org$request_uri;
}

Emuler le comportement Apache pour les applications du type WordPress :

server {
[...]
        try_files $uri $uri/ /index.php?q=$uri&$args;
[...]
}

Liens


http