• LINUX > nginx (serveur web) sous Ubuntu

      INSTALLATION NGINX

      sudo apt-get update
sudo apt-get install nginx

       

      NGINX se lance généralement directement à la suite de cette actualisation.

       

      Taper http://127.0.0.1 ou http://localhost ou http://ip_du_serveur

      Si l’installation est réussie, on obtient le message suivant :

       

      Welcome to nginx !

      CONFIGURATION NGINX

      Dans /etc/nginx, on trouve entre autres :

       

      nginx.conf le fichier de configuration central

      conf.d/ répertoire contenant des fichiers de configuration additionnels

      sites-available/ fichiers de configuration des sites disponibles

      sites-enabled/ fichiers de configuration des sites actifs (liens symboliques vers le répertoire site-availables)

       

      A chaque modification des fichiers, il faut redémarrer le serveur :

       

      sudo service nginx reload

      Tester la Configuration

      sudo service nginx configtest

      Syntaxe du fichier de Configuration

      Tous les réglages commencent par le nom variable respectif.

      Un espace vide délimite deux arguments.

      La ligne se termine toujours par un point-virgule.

       

      worker_connections 768;

       

      Les events-variable comportent des arguments qui leurs sont propres et sont entourées par des accolades {}.

       

      events {
   worker_connections 768;
   multi_accept on;
}

       

      Pour désactiver une variable : signe dièse #.

       

      # multi_accept on;

      SITE PAR DÉFAUT

      Configuration du site par Défaut

      Fichier du site par défaut /etc/nginx/sites-available/default :

       

      server {
   listen 80;
   root /chemin/vers/fichiers/du/site;
   index index.html index.htm;
   server_name localhost;
   location / {
      try_files $uri $uri/ /index.html;
   }
   location /doc {
      root /usr/share;
      autoindex on;
      allow 127.0.0.1;
      deny all;
   }
   location /images {
      root /usr/share;
      autoindex off;
   }
}

       

      EXPLICATIONS

       

      listen 80 port d’écoute : TCP/80

       

      root répertoire où se trouve la racine du site : /chemin/vers/fichiers/du/site

       

      server_name localhost à partir de l’URL http://localhost/

       

      1 - Créer le répertoire qui va héberger le site :

       

      mkdir /chemin/vers/fichiers/du/site

       

      2 - Éditer la page d’accueil : /chemin/vers/fichiers/du/site/index.html

       

      <html><body>Coucou!</body></html>

       

      3 - Fichier de configuration du site.

       

      sudo vi /etc/nginx/sites-available/monsite

       

      Avec le contenu suivant (par exemple) :

       

      server {
   listen 80;
   root /chemin/vers/fichiers/du/site;
   index index.html index.htm;
   server_name localhost;
   location / {
      # First attempt to serve request as file, then
      # as directory, then fall back to index.html
      try_files $uri $uri/ /index.html;
   }
}

       

      On supprime le site par defaut et on active le notre:

       

      cd /etc/nginx/sites-enabled
sudo rm default
sudo ln -s ../sites-available/monsite

       

      On redémarre le serveur Nginx:

       

      sudo service nginx restart

       

      Puis on teste la page: http://localhost/

       

      Pour rendre le site "visible depuis l’extérieur", il faut changer la ligne:

       

      server_name localhost;

       

      par:

       

      server_name www.monsite.com;

       

      Il faut bien sur que le nom www.monsite.com pointe sur l’adresse IP du serveur Nginx…

      choisir les répertoires locaux pour des types de contenus différents.

      Exemple : un dossier /chemin/vers/images comprenant des images.

       

      Entrer le répertoire dans le fichier de configuration, en conservant la directive du bloc serveur, qui est une sous-directive de la directive http bloc.

       

      http {
   server {
   }
}

       

      Dans ce bloc de serveur, les deux répertoires contenant les images et documents HTML doivent être indiqués. Cela donne le résultat suivant :

       

      server {
   location / {
      root /chemin/par/defaut;
   }
   location /mesimages {
      root /chemin/vers/images;
   }
}

       

      Toutes les URL avec /mesimages/ pointeront désormais vers le répertoire /chemin/vers/images.

      Sinon, le répertoire par défaut sera /chemin/par/défaut.

       

      On redémarre le service :

       

      sudo service nginx restart

       

      Mise en place d’un serveur proxy NGINX

      Exemple : Afficher les images demandées et transmettre toutes les autres demandes au serveur Web.

       

      La première étape consiste à définir le serveur principal dans nginx.conf :

       

      server {
   listen 8080;
   root /data/up1;
   location / {
   }
}

       

      On utilise ici le port 8080 pour les requêtes entrantes. Placez par ailleurs le répertoire /data/up1 et retirez la page index.html de cet endroit.

       

      Le serveur proxy et ses fonctions sont définis pour livrer des contenus d‘images, impliquant l’utilisation d’indications sur le serveur principal : le protocole (http), le nom (localhost), et le port (80800).

       

      server {
   location / {
      proxy_pass http://localhost:8080;
   }
   location ~ \.(gif|jpg|png) $ {
      root /data/images;
   }
}

       

      Le second location renvoie au serveur proxy toutes les demandes dont les URIs se terminent par .gif, .jpg et .png, en chargeant les contenus correspondants depuis le répertoire local /data/images.

      Toutes les autres requêtes sont transmises au serveur principal. Comme avec les réglages précédents, vous enregistrez votre proxy images par reload-signal sur le processus principal avec le redémarrage de NGINX. D’autres directives possibles pour des paramétrages complexes de proxy se trouvent sur le manuel en ligne NGINX.

      Optimisation !

      Ne pas loguer les message 404 sur le fichier favicon.ico (pour ne pas surcharger ses logs) :

       

      location = /favicon.ico {
         access_log off;
         return 204;
      }

       

      Durée d’expiration des en-tête des fichiers statiques (pour les caches):

       

      location ~* ^.+\.(jpg|jpeg|gif|css|png|js|xml)$ {
   # access_log off;
   expires 30d;
}

       

      Ne pas oublier de faire :

      chown -R www-data:www-data /var/www
chmod -R 775 /var/www

      drop.conf

      pour ne pas logger des informations non indispensable et empêcher de donner accès à des fichiers pouvant être sensible :

       

      /etc/nginx/drop.conf :

       

      # Do not log robots.txt if not found
location = /robots.txt  { access_log off; log_not_found off; }
# Do not log favicon.ico if not found
location = /favicon.ico { access_log off; log_not_found off; }
# Do not give access to hidden files
location ~ /\. { access_log off; log_not_found off; deny all; }
# Do not give access to vim backuped files
location ~ ~$ { access_log off; log_not_found off; deny all; }

       

      Ensuite dans les fichiers de configuration, il suffira de rajouter ces 2 lignes :

       

      /etc/nginx/sites-enabled/*

       

      server {
   # Drop config
   include drop.conf;
}

      VirtualHosts

      On va créer par exemple le blog deimos.fr : /etc/nginx/site-available/blog

       

      server {
   listen 80;
   server_name blog.deimos.fr;
   access_log /var/log/nginx/localhost.access.log;
   location / {
      root /var/www/nginx-default/blog;
      index index.html index.htm index.php;
   }
   location /doc {
      root /usr/share;
      autoindex on;
      allow 127.0.0.1;
      deny all;
   }
   location /images {
      root /usr/share;
      autoindex on;
   }
}

       

      On va activer cette conf :

       

      ln -s /etc/nginx/sites-available/blog /etc/nginx/sites-enabled/blog

      Port par défaut

      Pour stipuler le port par défaut, vous pouvez utiliser un include dans vos fichiers de configuration qui feront appel à un fichier comprenant le port. De la sorte il sera très facile de modifier d’un coup le port par défaut : /etc/nginx/listen_port.conf

       

      listen 80;

       

      Et donc dans les fichiers de configuration : /etc/nginx/sites-available/*.conf

       

      server {
    include listen_port.conf;

      Page de maintenance

      Voici une manière élégante de créer une page de maintenance : /etc/nginx/sites-enabled/www.deimos.fr

       

      server {
   location / {
      try_files /maintenance.html $uri $uri/ @maintenance;
   }
   location @maintenance {
      return 503;
   }
}

       

      Il ne vous reste plus qu’à insérer une page maintenance.html à la racine de votre site et cette page s’affichera le temps que vous fassiez vos modifications. Sinon vous pouvez toujours utiliser cette méthode : /etc/nginx/sites-enabled/www.deimos.fr

       

      server {
   location / {
      if (-f $document_root/maintenance.html) {
         return 503;
      }
   }
   error_page 503 @maintenance;
   location @maintenance {
      rewrite ^(.*)$ /maintenance.html break;
   }
}

      Limiter le flood et les sniffers

      Limiter le nombre de requêtes par IP en utilisant le module limit_req.

      Pour activer ce module, insérez cette ligne dans votre configuration core (globale) d’Nginx: /etc/nginx/nginx.conf

       

      http {
    # Flood/DoS protection
    limit_req_zone $binary_remote_addr zone=limit:10m rate=5r/s;
    limit_req_log_level notice;
}

       

      Voici les options utilisées ici:

       

      zone=limit: les IP seront stockées dans une zone appelée limit de 10M. Prévoyez assez d’espace sur cette zone pour éviter des erreurs 503 s’il n’y a plus d’espace. Une zone d’1M peut contenir 16 000 entrées de type binary_remote_addr.

      rate: on autorise 5 requêtes par secondes.

      log_level: vous pouvez supprimer cette ligne si vous ne souhaitez pas savoir dans les logs si les limites sont atteintes. Ici je souhaites tracer ce genre d’événements.

       

      Puis, informer sur quel vhost appliquer cette mesure de sécurité : /etc/nginx/sites-enabled/

       

      location ~ \.php$ {
   limit_req zone=limit burst=5 nodelay;
   include fastcgi_params;
   fastcgi_pass unix:/var/run/php5-fpm.sock;
   fastcgi_intercept_errors on;
}

       

      Là encore on retrouve des options:

       

      zone: j’utilise la zone limit précédemment déclarée dans la configuration http (core)

      burst: j’autorise le burst à 5 connexions maximum

      nodelay: si vous souhaitez que les requêtes soient tout de même servies mêmes si elles sont ralenties, utilisez le paramètre nodelay.

       

      Il ne reste plus qu’à redémarrer nginx.

      Configuration d’applications

      Server status

      Il est possible d’avoir des informations sur l’état du serveur, de ce type : /etc/nginx/sites-available/www.deimos.fr

       

      server {
   # Nginx status
   location /server-status {
      # Turn on nginx stats
      stub_status on;
      # I do not need logs for stats
      access_log off;
      # Allow from localhost
      allow 127.0.0.1;
      # Deny others
      deny all;
   }
   # PHP-FPM status
   location /php-fpm_status {
      include fastcgi_params;
      fastcgi_pass unix:/var/run/php5-fpm.sock;
      # I do not need logs for stats
      access_log off;
      # Allow from localhost
      allow 127.0.0.1;
      # Deny others
      deny all;
   }
   location ~ \.php$ {
      include fastcgi_params;
      fastcgi_pass unix:/var/run/php5-fpm.sock;
      fastcgi_intercept_errors on;
      # I do not need logs for stats
      access_log off;
      # Allow from localhost
      allow 127.0.0.1;
      # Deny others
      deny all;
   }
}

       

      Configurez convenablement les adresses autorisées ou bien placez une authentification classique via htpasswd.

       

      Voici le résultat donné lorsqu’on accède à la page (http://www.deimos.fr/server-status) :

       

      Active connections: 11
server accepts handled requests
 8109 8109 58657
Reading: 0 Writing: 1 Waiting: 10

      WordPress

      Pour la configuration de WordPress sous Nginx, voici un exemple : /etc/nginx/sites-available/blog.deimos.fr

       

      server {
    include listen_port.conf;
    listen 443 ssl;
    ssl_certificate /etc/nginx/ssl/deimos.fr/server-unified.crt;
    ssl_certificate_key /etc/nginx/ssl/deimos.fr/server.key;
    ssl_session_timeout 5m;
    server_name blog.deimos.fr;
    root /usr/share/nginx/www/deimos.fr/blog;
    index index.php;
    access_log /var/log/nginx/blog.deimos.fr_access.log;
    error_log /var/log/nginx/blog.deimos.fr_error.log;
    location / {
        try_files $uri $uri/ /index.php?$args;
    }
    location ~ \.php$ {
        fastcgi_cache mycache;
        fastcgi_cache_key $request_method$host$request_uri;
        fastcgi_cache_valid any 1h;
        include fastcgi_params;
        fastcgi_pass unix:/var/run/php5-fpm.sock;
        fastcgi_intercept_errors on;
    }

    # Drop config
    include drop.conf;

    # BEGIN W3TC Browser Cache
    gzip on;
    gzip_types text/css application/x-javascript text/x-component text/richtext image/svg+xml text/plain text/xsd text/xsl text/xml image/x-icon;
    location ~ \.(css|js|htc)$ {
        expires 31536000s;
        add_header Pragma "public";
        add_header Cache-Control "public, must-revalidate, proxy-revalidate";
        add_header X-Powered-By "W3 Total Cache/0.9.2.4";
    }
    location ~ \.(html|htm|rtf|rtx|svg|svgz|txt|xsd|xsl|xml)$ {
        expires 3600s;
        add_header Pragma "public";
        add_header Cache-Control "public, must-revalidate, proxy-revalidate";
        add_header X-Powered-By "W3 Total Cache/0.9.2.4";
    }
    location ~ \.(asf|asx|wax|wmv|wmx|avi|bmp|class|divx|doc|docx|eot|exe|gif|gz|gzip|ico|jpg|jpeg|jpe|mdb|mid|midi|mov|qt|mp3|m4a|mp4|m4v|mpeg|mpg|mpe|mpp|otf|odb|odc|odf|odg|odp|ods|odt|ogg|pdf|png|pot|pps|ppt|pptx|ra|ram|svg|svgz|swf|tar|tif|tiff|ttf|ttc|wav|wma|wri|xla|xls|xlsx|xlt|xlw|zip)$ {
        expires 31536000s;
        add_header Pragma "public";
        add_header Cache-Control "public, must-revalidate, proxy-revalidate";
        add_header X-Powered-By "W3 Total Cache/0.9.2.4";
    }
    # END W3TC Browser Cache

    # BEGIN W3TC Minify core
    rewrite ^/wp-content/w3tc/min/w3tc_rewrite_test$ /wp-content/w3tc/min/index.php?w3tc_rewrite_test=1 last;
    rewrite ^/wp-content/w3tc/min/(.+\.(css|js))$ /wp-content/w3tc/min/index.php?file=$1 last;
    # END W3TC Minify core
}
}

      FAQ

      Analyser les règles qui passent

      Vous pouvez voir le comportement de vos règles (redirect 301 par exemple) en utilisant curl :

       

      > curl -I "http://wiki.deimos.fr"

HTTP/1.1 301 Moved Permanently
Server: nginx
Content-Type: text/html
Location: http://wiki.deimos.fr/index.php
Content-Length: 178
Accept-Ranges: bytes
Date: Wed, 16 Jan 2013 22:17:05 GMT
X-Varnish: 2038764987
Age: 0
Via: 1.1 varnish
Connection: keep-alive

       

      Cela vous permet d’analyser comment fonctionne celui ci et détecter d’éventuels problèmes.

      client intended to send too large body

      Si vous avez ce genre de messages dans vos logs :

       

      nginx client intended to send too large body

       

      nginx n’autorise pas à envoyer des fichiers d’une taille aussi grande. Il faut utiliser cette variable dans la partie ‘server’ :

       

      client_max_body_size 10M;

       

      Remplacez 10M par la valeur maximale souhaitée.

      Access denied.

      C’est PHP-FPM qui rencontre des problèmes sur la gestion des extensions. Vous avez le choix de rajouter l’extension en question : /etc/php5/fpm/pool.d/www.conf

       

      security.limit_extensions = .php .php3 .php4 .php5 .cgi

       

      ou bien de désactiver cette sécurité (non recommandé) : /etc/php5/fpm/pool.d/www.conf

       

      security.limit_extensions = false

      Configuration basique de Nginx

      Fichier de configuration

      Le fichier de configuration se trouve à /usr/local/nginx/conf/nginx.conf

       

      #user  nobody;
worker_processes  1;
#error_log logs/error.log;
#error_log logs/error.log  notice;
#error_log logs/error.log  info;
#pid logs/nginx.pid;

events {
   worker_connections  1024;
}

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

   #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  logs/access.log  main;

   sendfile on;
   #tcp_nopush on;

   #keepalive_timeout 0;
   keepalive_timeout 65;

      #gzip  on;

      server {
         listen       80;
         server_name  localhost;

         #charset koi8-r;

         #access_log  logs/host.access.log  main;

         location / {
            root   html;
            index  index.html index.htm;
         }

         #error_page
         404 /404.html;

         # redirect server error pages to the static page /50x.html
         error_page 500 502 503 504 /50x.html;
         location = /50x.html {
            root   html;
         }

         # proxy the PHP scripts to Apache listening on 127.0.0.1:80
         #
         #location ~ \.php$ {
         #    proxy_pass   http://127.0.0.1;
         #}
     }

     # another virtual host using mix of IP-, name-, and port-based configuration
        #
        #server {
        #    listen 8000;
        #    listen somename:8080;
        #    server_name somename alias another.alias;

        #    location / {
        #        root   html;
        #        index  index.html index.htm;
        #    }
        #}

        # HTTPS server
        #
        #server {
        #    listen 443 ssl;
        #    server_name localhost;

        #    ssl_certificate cert.pem;
        #    ssl_certificate_key cert.key;

        #    ssl_session_cache shared:SSL:1m;
        #    ssl_session_timeout 5m;

        #    ssl_ciphers  HIGH:!aNULL:!MD5;
        #    ssl_prefer_server_ciphers  on;

        #    location / {
        #        root   html;
        #        index  index.html index.htm;
        #    }
        #}
}

       

      La seconde ligne worker_processes est un directive, la valeur 1 indique que Nginx travail un seul worker processus

      Organisation et inclusion.

      Ligne 16, on peut voir la directive include.

       

      include mime.types;

       

      Cette directive permet d’inclure un fichier spécifique. Voici un petit exemple pour comprendre:

       

      nginx.conf:
   user nginx nginx;
   worker_processes 4;
   include other_settings.conf;

other_settings.conf:
   error_log logs/error.log;
   pid logs/nginx.pid;

       

      Ce que Nginx va interpréter:

       

      user nginx nginx;
worker_processes 4;
error_log logs/error.log;
pid logs/nginx.pid;

       

      Par défaut, l’insertion de sites ce fait de cette manière. On va utiliser la directive <mon_site>.conf ou:

       

      include sites/*.conf;

      Les directives en bloque

      On peut voir également dans le fichier par défaut, la directive events, celle-ci se présente en bloque:

       

      events {
   worker_connections 1024;
}

       

      Ce bloque est définie par le module events.

      La directive worker_connections peut seulement être utilisé dans le bloque events.

       

      On peut également imbriquer des bloques les uns dans les autres:

       

      http {
   server {
      listen 80;
      server_name exemple.fr;
      acces_log /var/log/nginx/exemple.fr.log;
      location ^~ /admin/ {
         index index.php;
      }
   }
}

       

      Dans le bloque http, on peut déclarer plusieurs bloque server. Ces bloques server permettent de configurer des hôtes virtuelles. Nous verrons au fur et à mesure l’utilisation des bloques.

      Les directives des modules noyau.

      Ces modules ne peuvent être utilisés qu’une seule fois, et doivent être placé dans la racine du fichier de configuration.

       

      error_log

      Contexte: main, http, server, et location

      Syntaxe: error_log /file/path level;

      Valeur par défaut: logs/error.log error.

      Où level est une des valeurs suivantes: debug, info, notice, warn, error, et crit (du plus au moins détaillé: debug fourni les messages de logs fréquents, crit seulement les messages critiques).

      Active les messages d’erreur sur plusieurs niveaux: Application, HTTP serveur, hôte virtuel, et dossier de l’hôte virtuel.

      En redirigeant la sortie des logs vers /dev/null/, on peut désactiver les logs d’erreurs. En utilisant la directive suivante depuis la racine du fichier de configuration:

      error_log /dev/null crit;

      modules d’évenements

      Toutes les directives de la liste suivante, doivent être placé dans le bloque events, qui doit être placé à la racine du fichier de configuration:

       

      user nginx nginx;
master_process on;
worker_processes 4;
events {
  worker_connections 1024;
    use epoll;
}
[...]

      modules de configuration

      Le module de configuration permet l’insertion de fichier grâce à la directive include. Cette directive peut être inséré n’importe où dans le fichier de configuration et accepte un seul paramètre - le chemin du fichier.

       

      include /file/path.conf;
include sites/*.conf;

       

      Note : Si aucun chemin absolue n’est défini,le chemin est relatif au dossier de configuration.

      Travailler sur la configuration par défaut.

      Worker_processes : Permet d’utiliser les 4 cœurs de notre machine. A adapter suivant la machine.

      worker_processes 4;

       

      Log_not_found : Permet de logger les erreurs 404.

      log_not_found on;
log_not_found off;

       

      Worker_connections

      Nombre de connections admises par le serveur (en relation avec le worker_processes, 1 worker permet 1024 connections).

      LOGS

      Les fichiers de logs : /var/log/nginx/

      Rotation des logs

      Pour éviter la saturation des disques en quelques mois , il faut une rotation journalière :

       

      Nous allons dédier cette tâche à logrotate

       

      vi /etc/logrotate.d/nginx

       

      Et voici le contenu :

       

      /var/log/nginx/*.log {
   daily
   missingok
   rotate 5
   compress
   delaycompress
   notifempty
   create 640 root adm
   sharedscripts
   postrotate
   if [ -f /var/run/nginx.pid ]; then
      /usr/local/nginx/sbin/nginx -s reload > /dev/null
   fi
   endscript
}

      Configuration principale

      Documentation est compléte ici.

      Vhosts

      Dans nginx.conf , la ligne include /etc/nginx/site-enabled/*;permet de gérer les vhosts : tous les fichiers de conf présents dans ce répertoire seront analysés par nginx à son lancement.

       

      Création d’un vhost type :

       

      vi /etc/nginx/site-available/monsite.com

       

      Et voilà le contenu type :

       

      server {
   listen 80;
   server_name monsite.com www.monsite.com;
   location / {
      root html;
      index index.html index.htm;
   }
}

       

      Activation du vhost, en créer un lien symbolique vers site-enabled :

       

      ln -s /etc/nginx/site-available/monsite.com /etc/nginx/site-enabled/

      Démarrer nginx

      Vérifier les erreurs au lancement :

       

      tail -f /var/log/nginx/error.log

      CONFIGURER UN SITE WEB

      Éditer son contenu comme suit :

       

      server {
   listen 80;
   server_name first_site.com;
   root /var/www/first_site;
   index index.html index.php;
   location / {
      try_files $uri $uri/ =404;
   }
}

       

      Explication :

       

      listen port d’écoute

      server_name nom de domaine que l’on veut filtrer

      root répertoire qui hébergera notre site web. (attention aux droits d’accès)

      index spécifie dans l’ordre les fichiers qui seront recherchés en premier comme fichier d’index par le serveur web

      location configurer des actions automatiques lorsqu’un chemin est appelé

       

      Vérifier les configurations :

       

      nginx  -t

       

      Recharger la configuration de NGINX

       

      service nginx reload

      PROXY

      Il faut créer un fichier proxy.conf dans le répertoire conf.d qui contiendra les paramètres de configuration du serveur proxy :

       

      vi /etc/nginx/conf.d/proxy.conf

       

      Entrer ensuite le contenu :

       

      proxy_redirect            off;
proxy_set_header          Host $host;
proxy_set_header          X-Forwarded-Host $host;
proxy_set_header          X-Forwarded-Server $host;
proxy_set_header          X-Forwarded-Proto $scheme;
proxy_set_header          X-Real-IP $remote_addr;
proxy_set_header          X-Forwarded-For $proxy_add_x_forwarded_for;
client_max_body_size      10m;
client_body_buffer_size   128k;
client_header_buffer_size 64k;
proxy_connect_timeout     90;
proxy_send_timeout        90;
proxy_read_timeout        90;
proxy_buffer_size         16k;
proxy_buffers             32 16k;
proxy_busy_buffers_size   64k;

       

      Vérifier les configurations de nginx : nginx -t

       

      Si tout est OK, relancez le service : service nginx reload

       

      Pour créer un site qui pointe vers un autre (fonction proxy), Il faut créer un site en respectant les mêmes spécifications que celles vues plus haut dans le chapitre Configuration d’un site web. Sauf que nous allons adapter le fichier de configuration du site avec les configurations minimales suivantes :

       

      sudo vi /etc/nginx/sites-available/first_proxy.com

       

      server {
   listen 80;
   server_name first_proxy.com;
   location / {
      proxy_pass http://localhost/;
   }
}

       

      Pensez à créer le lien symbolique pour votre site si cela n’avait pas déjà été fait.

       

      NB : aucun root car les requêtes seront redirigées vers le site pour lequel nous jouerons le rôle de serveur proxy.

      Proxy_pass : permets de spécifier l’adresse du serveur proxy. http://localhost/. Si le site est accessible via un port autre que le port 80 vous devez spécifier l’adresse du site suivie du port Ex : http://localhost:8080.

      AUTHENTIFICATION

      Pour demander à l’utilisateur d’entre un login et un mot de passe pour avoir accès à une ressource (avant tout chargement du code dans le répertoire).

       

      Pour cela, choisir un chemin qui sera protégé par notre code. (ex: /admin ou /wp-admin comme sur WordPress).

       

      Pour commencer, nous allons installer l’outil apache2-utils qui va nous permettre de créer le fichier de configuration pour l’authentification. Pour créer un fichier caché (.htpasswd) dans le répertoire /data/wordpress/, avec un utilisateur appelez Joel (possibilité d’avoir plusieurs utilisateurs différents dans le même fichier) utiliser la commande :

       

      sudo htpasswd -c /data/wordpress/.htpasswd joel

       

      Pour ajouter des utilisateurs à un fichier existant, utilisez la commande :

       

      sudo htpasswd /data/wordpress/.htpasswd joel

       

      Si vous passez en paramètre le nom d’un utilisateur qui existe déjà, le mot de passe de ce dernier sera mis à jour.

      Maintenant, ajouter les lignes suivantes dans le virtual host (dans le fichier de configuration de votre site web). Ajoutez les dans les balises location de votre choix afin de protéger un chemin en particulier (se chemin peut être le /). Dans mon cas je l’ajoute sur le chemin /admin

       

      location /admin/ {
   root /var/www/mywebsite.com/admin;
   index index.html index.htm;
   auth_basic "Restricted"; #For Basic Auth
   auth_basic_user_file /data/wordpress/.htpasswd; #For Basic Auth
}

       

      Cette configuration est à adapter à votre configuration réelle.

       

      Ensuite, vérifier les configurations de nginx :

       

      nginx -t

       

      rechargé ensuite les configurations si tout est correct :

       

      Service nginx reload

       

      Quand vous essayez d’accéder à l’adresse qui a été spécifiée, vous aurez cette page d’authentification. La forme de la page d’authentification dépend bien sûr de votre navigateur :

      vhosts

      Les hôtes virtuels permettent à Nginx de gérer plusieurs arborescences Web en simultanées. Si vous regardez dans le dossier conf.d vous remarquerez que vous n’avez pour le moment qu’une configuration qui est la configuration par défaut.

       

      server {
    listen 80;
    server_name localhost;
    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
    }
    error_page 500 502 503 504  /50x.html;
    location = /50x.html {
        root /usr/share/nginx/html;
    }
}

       

      Dans notre cas nous souhaitons faire pointer monsupersite.fr vers notre serveur, nous allons devoir créer un nouveau virtual host :

       

      server {
    listen 80;
    server_name monsupersite.fr;
    # Les urls commençant par / (toutes les urls)
    location / {
        root /home/dev/www;
        index index.html index.htm;
        try_files $uri $uri/ $uri.html =404;
    }
    # Les urls contennant /. (dotfiles)
    location ~ /\. {
        deny all;
        access_log off;
        log_not_found off;
    }
    # On va placer les logs dans un dossier accessible
    error_log /home/dev/logs/error.log;
    access_log /home/dev/logs/acess.log;
    # Les pages d'erreurs
    error_page 404 500 501 /error.html;
}
server {
    # On redirige les www. vers la version sans www
    listen 80;
    server_name www.monsupersite.fr;
    return 301 http://monsupersite.fr$request_uri;
}

       

      Une fois ces modifications effectuées il ne faut pas oublier de recharger la configuration en redémarrant nginx.

       

      # Pour tester la configuration

      sudo nginx -t

      # Pour recharger la configuration

      sudo service nginx restart

      Permissions des dossiers

      Create a new user other than root, and add it to the www-data group.
      Set the ownership of /var/www to the www-data user and www-data group.
      Directories 775
      Files 664

      This means that:

       

      The user owner of the directory (www-data) can read, write and execute.

       

      The assigned group (www-data, where my user is) can read and execute, but not write.

       

      Everyone else can read and execute, but not write.

      To edit files from FTP require allowing the group to write adjusting the permissions like this:

      CONFIGURATION

      LOCATION

      location [mode] match {
   ...
}

       

      match permet de dire que le schéma rencontré dans l’URL permet d’activer la location.

      Si mode est du style ~ ou ~*, alors ce sera une regex (* pour insensible à la casse).

      Si mode est du style =, alors ce sera la valeur exacte.

       

      exemple:

       

      server {
   listen 80;
   server_name toto
   location / {
      root /var/www/html;
      index index.html index.htm;
   }
}

      Pour toutes pages du genre 505 504 503 etc :

       

      error_page 500 502 503 504 /50x.html;
location = /50x.html {

       

      Toutes les images :

      location ~ .(png|gif|ico|jpg|jpeg)$ {
   ...
}

      ERREURS

      si 502 Bad Gateway

      il faut bien commenter la ligne

       

      #fastcgi_pass 127.0.0.1:9000;

       

      et dé-commenter la ligne :

       

      fastcgi_pass unix:/var/run/php5-fpm.sock;

       

 

Aucun commentaire

 

Laissez un commentaire