Serveur HTTP Apache Version 2.4

Apache > Serveur HTTP > Documentation > Version 2.4 > Rewrite

# Redirection et remise en correspondance avec mod_rewrite

Langues Disponibles: en | fr

Ce document est un complément à la Documentation de référence de `mod_rewrite`. Il montre comment utiliser `mod_rewrite` pour rediriger et remettre en correspondance une requête. Il contient de nombreux exemples d'utilisation courante de mod_rewrite avec une description détaillée de leur fonctionnement.

Vous devez vous attacher à comprendre le fonctionnement des exemples, car la plupart d'entre eux ne fonctionneront pas sur votre système si vous vous contentez de les copier/coller dans vos fichiers de configuration.

### Voir aussi

- Documentation du module mod_rewrite
- Introduction à mod_rewrite
- Contrôler l'accès
- Serveurs virtuels
- Serveurs mandataires
- Utilisation de RewriteMap
- Techniques avancées
- Quand ne pas utiliser mod_rewrite
- Commentaires

## De l'ancienne à la nouvelle URL (en interne)

Description :

  Supposons que nous ayons récemment renommé la page `foo.html` en `bar.html`, et voulions maintenant que l'ancienne URL soit toujours valide à des fins de compatibilité ascendante. En fait, on voudrait que le changement de nom soit transparent aux utilisateurs de l'ancienne URL.

Solution :

  On réécrit l'ancienne URL en interne vers la nouvelle via la règle suivante :

      RewriteEngine  on
      RewriteRule    "^/foo\.html$" "/bar.html" [PT]

## De l'ancien au nouveau (en externe)

Description :

  Supposons toujours que nous ayons récemment renommé la page `foo.html` en `bar.html`, et voulions maintenant que l'ancienne URL soit toujours valide à des fins de compatibilité ascendante. En revanche, nous voulons cette fois que la nouvelle URL soit suggérée aux utilisateurs de l'ancienne URL, c'est à dire que l'adresse vue depuis leur navigateur doit également être modifiée.

Solution :

  On force une redirection HTTP vers la nouvelle URL, ce qui entraîne une modification de celle du navigateur et aussi de ce que voit l'utilisateur :

      RewriteEngine  on
      RewriteRule    "^foo\.html$"  "bar.html"  [R]

Discussion

  Dans l'exemple interne, on a utilisé mod_rewrite afin de dissimuler la redirection au client. Dans cet exemple, en revanche, on aurait pu se contenter d'une directive Redirect :

      Redirect "/foo.html" "/bar.html"

## Ressource déplacée vers un autre serveur

Description :

  Si une ressource a été déplacée vers un autre serveur, vous pouvez faire en sorte que les URLs de l'ancien serveur continuent de fonctionner pendant un certain temps, afin de laisser au utilisateurs le temps de modifier leurs favoris.

Solution :

  Vous pouvez utiliser `mod_rewrite` pour rediriger ces URLs vers le nouveau serveur, mais vous pouvez aussi utiliser les directives Redirect ou RedirectMatch.

      #Avec mod_rewrite
      RewriteEngine on
      RewriteRule   "^/docs/(.+)"  "http://nouveau.example.com/docs/$1"  [R,L]

      #Avec RedirectMatch
      RedirectMatch "^/docs/(.*)" "http://nouveau.example.com/docs/$1"

      #Avec Redirect
      Redirect "/docs/" "http://nouveau.example.com/docs/"

## De statique à dynamique

Description :

  Comment transformer une page statique `foo.html` en sa variante dynamique `foo.cgi` de manière transparente, c'est à dire sans en avertir le navigateur/utilisateur.

Solution :

  On réécrit simplement l'URL en script CGI et force le gestionnaire de contenu à cgi-script de façon à ce que le script s'exécute en tant que programme CGI. Ainsi, une requête vers `/~quux/foo.html` conduit en interne à l'invocation de `/~quux/foo.cgi`.

      RewriteEngine  on
      RewriteBase    "/~quux/"
      RewriteRule    "^foo\.html$"  "foo.cgi"  [H=cgi-script]

## Compatibilité ascendante dans le cadre d'une modification d'extension de nom de fichier

Description :

  Comment conférer une compatibilité ascendante aux URLs (existant encore virtuellement) après avoir migré `document.YYYY` vers `document.XXXX`, c'est à dire après avoir par exemple traduit un lot de fichiers `.html` en fichiers `.php` ?

Solution :

  On réécrit simplement le nom du fichier en son nom de base et vérifie s'il existe aussi avec la nouvelle extension. Si c'est le cas, on utilise ce nom, sinon on réécrit l'URL sous sa forme originale.

      #   jeu de règles assurant une compatibilité ascendante en réécrivant

      #   document.html en document.php si et seulement si document.php

      #   existe
      <Directory "/var/www/htdocs">
          RewriteEngine on
          RewriteBase "/var/www/htdocs"

          RewriteCond "$1.php" -f
          RewriteCond "$1.html" !-f
          RewriteRule "^(.*).html$" "$1.php"
      </Directory>

Discussion

  Cet exemple utilise une fonctionnalité souvent méconnue de mod_rewrite, en tirant avantage de l'ordre d'exécution du jeu de règles. En particulier, mod_rewrite évalue la partie gauche des règles de réécriture avant d'évaluer les directives RewriteCond. En conséquence, $1 est déjà défini au moment où les directives RewriteCond sont évaluées. Ceci nous permet de tester l'existence du fichier original (`document.html`) et du fichier cible (`document.php`) en utilisant le même nom de base.

  Ce jeu de règles est conçu pour une utilisation dans un contexte de répertoire (au sein d'une section <Directory> ou d'un fichier .htaccess), de façon à ce que les vérifications `-f` effectuent leurs recherches dans le bon répertoire. Vous serez peut-être amené à définir une directive `RewriteBase` pour spécifier le répertoire de base à partir duquel vous travaillez.

## Noms d'hôtes canoniques

Description :
  Le but de cette règle est de préférer l'utilisation d'un nom d'hôte particulier à d'autres noms d'hôte utilisables pour atteindre le même site. Par exemple, si vous voulez utiliser www.example.com à la place de example.com, vous pouvez utiliser une solution du style :
Solution :

  Pour y parvenir, il vaut mieux se passer de mod_rewrite, et utiliser plutôt la directive `Redirect` dans une section de serveur virtuel pour le/les noms d'hôte non canoniques.

      <VirtualHost *:80>
        ServerName undesired.example.com
        ServerAlias example.com notthis.example.com

        Redirect "/" "http://www.example.com/"
      </VirtualHost>

      <VirtualHost *:80>
        ServerName www.example.com
      </VirtualHost>

  Vous pouvez aussi utiliser la directive `<If>` :

      <If "%{HTTP_HOST} != 'www.example.com'">
      	Redirect "/" "http://www.example.com/"
      </If>

  Ou, par exemple, pour rediriger une portion de votre site vers HTTPS :

      <If "%{SERVER_PROTOCOL} != 'HTTPS'">
      	Redirect "/admin/" "https://www.example.com/admin/"
      </If>

  Si, pour une raison particulière, vous voulez tout de même utiliser `mod_rewrite` - dans le cas, par exemple, où vous avez besoin d'un jeu plus important de règles de réécritures - vous pouvez utiliser la recette suivante :

  Pour les sites écoutant sur un port autre que 80:

      RewriteCond "%{HTTP_HOST}"   "!^www\.example\.com" [NC]
      RewriteCond "%{HTTP_HOST}"   "!^$"
      RewriteCond "%{SERVER_PORT}" "!^80$"
      RewriteRule "^/?(.*)"         "http://www.example.com:%{SERVER_PORT}/$1" [L,R,NE]

  Et pour un site écoutant sur le port 80

      RewriteCond "%{HTTP_HOST}"   "!^www\.example\.com" [NC]
      RewriteCond "%{HTTP_HOST}"   "!^$"
      RewriteRule "^/?(.*)"         "http://www.example.com/$1" [L,R,NE]

  Si vous souhaitez que cette règle s'applique à tous les noms de domaine - en d'autres termes, si vous voulez rediriger example.com vers www.example.com pour toutes les valeurs possibles de example.com, vous pouvez utiliser le jeu de règles suivants :

      RewriteCond "%{HTTP_HOST}" "!^www\." [NC]
      RewriteCond "%{HTTP_HOST}" "!^$"
      RewriteRule "^/?(.*)" "http://www.%{HTTP_HOST}/$1" [L,R,NE]

  Vous pouvez utiliser ce jeu de règles aussi bien dans le fichier de configuration de votre serveur principal que dans un fichier `.htaccess` placé dans le répertoire défini par la directive `DocumentRoot` du serveur.

## Recherche de pages dans plus d'un répertoire

Description:

  Une ressource peut exister dans plusieurs répertoires, et nous voulons rechercher cette ressource dans ces répertoires lorsqu'elle fait l'objet d'une requête. Il est possible que nous ayons récemment réorganisé la structure de notre site en répartissant son contenu dans plusieurs répertoires.

Solution :

  Le jeu de règles suivant recherche la ressource dans deux répertoires, et s'il ne la trouve dans aucun des deux, il tentera simplement de la servir à partir de l'adresse fournie dans la requête.

      RewriteEngine on

      #   on cherche tout d'abord dans dir1/...
      #   ... et si on trouve, on est content et on arrête :
      RewriteCond         "%{DOCUMENT_ROOT}/dir1/%{REQUEST_URI}"  -f
      RewriteRule  "^(.+)"  "%{DOCUMENT_ROOT}/dir1/$1"  [L]

      #   on cherche ensuite dans dir2/...
      #   ... et si on trouve, on est content et on arrête :
      RewriteCond         "%{DOCUMENT_ROOT}/dir2/%{REQUEST_URI}"  -f
      RewriteRule  "^(.+)"  "%{DOCUMENT_ROOT}/dir2/$1"  [L]

      #   sinon, on continue la recherche avec d'autres directives Alias
      #   ou ScriptAlias, etc...
      RewriteRule   "^"  "-"  [PT]

## Redirection vers des serveurs géographiquement distribués

Description :

  Notre site web possède de nombreux miroirs, et nous voulons rediriger les utilisateurs vers celui qui se situe dans le pays où ils se trouvent.

Solution :

  En consultant le nom d'hôte du client demandeur, on détermine le pays dans lequel il se trouve. S'il est impossible d'effectuer une recherche sur leur adresse IP, on se rabat sur un serveur par défaut.

  Nous allons utiliser une directive `RewriteMap` afin de construire une liste des serveurs que nous voulons utiliser.

      HostnameLookups on
      RewriteEngine on
      RewriteMap    multiplex         "txt:/path/to/map.mirrors"
      RewriteCond  "%{REMOTE_HOST}"     "([a-z]+)$ [NC]"
      RewriteRule   "^/(.*)$"  "${multiplex:%1|http://www.example.com/}$1"  [R,L]

  `## liste_miroirs -- Table de correspondance pays - serveurs
  de http://www.exemple.de/
  uk http://www.exemple.uk/
  com http://www.example.com/
  ##EOF##`

Discussion
  Ce jeu de règles nécessite la définition à `on` de la directive `HostNameLookups`, ce qui peut induire une baisse de performance significative.

  La directive `RewriteCond` extrait la dernière partie du nom d'hôte du client demandeur - le code du pays - et la règle de réécriture qui suit utilise cette valeur pour rechercher le serveur miroir approprié dans le fichier de correspondances.

## Contenu dépendant du navigateur

Description :

  Nous voulons fournir des contenus différents en fonction du navigateur (user-agent) qui effectue la requête.

Solution :

  Nous devons déterminer quel contenu servir, en nous basant sur l'en-tête HTTP "User-Agent". La configuration suivante effectue ceci : si l'en-tête HTTP "User-Agent" commence par "Mozilla/3", le nom de la page `foo.html` est réécrit en `foo.NS.html` et la réécriture s'arrête. Si le navigateur est "Lynx" ou "Mozilla" version 1 ou 2, l'URL devient `foo.20.html`. Tous les autres navigateurs reçoivent la page `foo.32.html`. Tout ceci est effectué par le jeu de règles suivant :

      RewriteCond "%{HTTP_USER_AGENT}"  "^Mozilla/3.*"
      RewriteRule "^foo\.html$"         "foo.NS.html"          [L]

      RewriteCond "%{HTTP_USER_AGENT}"  "^Lynx/" [OR]
      RewriteCond "%{HTTP_USER_AGENT}"  "^Mozilla/[12]"
      RewriteRule "^foo\.html$"         "foo.20.html"          [L]

      RewriteRule "^foo\.html$"         "foo.32.html"          [L]

## URLs canoniques

Description :

  Sur certains serveurs, une ressource peut posséder plusieurs URLs. Il y a en général les URLs canoniques (celles qui sont réellement distribuées et utilisées), et celles qui correspondent à des raccourcis, les URLs internes, etc... Quelle que soit l'adresse que l'utilisateur fournit dans la requête, il devrait finalement voir l'URL canonique dans la barre d'adresse de son navigateur.

Solution :

  Nous effectuons une redirection HTTP externe pour toutes les URLs non canoniques afin de les corriger dans la barre d'adresse du navigateur, et ceci pour toutes les requêtes futures. Dans le jeu de règles suivant, nous remplaçons `/matous` et `/minettes` par le canonique `/chats`.

      RewriteRule   "^/(matous|minettes)/(.*)"    "/chats/$2"  [R]

Discussion :
  On serait mieux inspiré d'utiliser ici les directives Redirect ou RedirectMatch :

      RedirectMatch "^/(matous|minettes)/(.*)" "/chats/$2"

## Déplacement du répertoire `DocumentRoot`

Description :

  En général, le répertoire `DocumentRoot` du serveur web correspond à l'URL "`/`". Ce répertoire ne contient cependant pas forcément des ressources de première importance pour l'utilisateur. Par exemple, vous préférerez peut-être que le répertoire d'accueil d'un visiteur accédant pour la première fois à votre site soit un répertoire particulier `/a-propos-de/`. Pour y parvenir, utilisez le jeu de règles suivant :

Solution :

  On redirige l'URL `/` vers `/a-propos-de/` :

      RewriteEngine on
      RewriteRule   "^/$"  "/a-propos-de/"  [R]

  Notez que l'on peut aussi y parvenir en utilisant la directive `RedirectMatch` :

      RedirectMatch "^/$" "http://example.com/a-propos-de/"

  Notez aussi que cet exemple ne réécrit que l'URL racine. En d'autres termes, il réécrit une requête pour `http://example.com/`, mais pas pour une requête `http://example.com/page.html`. Si vous avez effectivement modifié la racine de vos documents - c'est à dire si tous vos contenus se trouvent dans un sous-répertoire, il est largement préférable de modifier simplement votre directive `DocumentRoot`, ou de déplacer l'ensemble du contenu vers le répertoire supérieur, plutôt que de réécrire les URLs.

## Ressource par défaut

Description :
  Vous voulez qu'une seule ressource (disons un certain fichier tel que index.php) soit servie pour toutes les requêtes à destination d'un certain répertoire, sauf pour celles qui concernent une ressource existant effectivement comme une image, ou un fichier css.
Solution :

  Depuis la version 2.2.16, vous pouvez y parvenir via la directive `FallbackResource` :

      <Directory "/var/www/my_blog">
        FallbackResource "index.php"
      </Directory>

  Cependant, si vos besoins étaient plus complexes, vous pouviez, dans les versions plus anciennes d'Apache, utiliser un jeu de règles du style :

      <Directory "/var/www/my_blog">
        RewriteBase "/my_blog"

        RewriteCond "/var/www/my_blog/%{REQUEST_FILENAME}" !-f
        RewriteCond "/var/www/my_blog/%{REQUEST_FILENAME}" !-d
        RewriteRule "^" "index.php" [PT]
      </Directory>

  D'autre part, si vous voulez transmettre l'URI de la requête en tant que chaîne de paramètres à index.php, vous pouvez remplacer cette règle de réécriture par :

      RewriteRule "(.*)" "index.php?$1" [PT,QSA]

  Notez que l'on peut utiliser ces jeux de règles aussi bien dans un fichier `.htaccess` que dans une section <Directory>.

## Rewrite query string

Description :
  Vous voulez extraire une valeur particulière d'une chaîne de paramètres d'une URL, et soit la remplacer, soit l'incorporer dans un autre composant de l'URL.
Solutions :

  Dans la plupart des solutions de cette section, on utilise la même condition qui stocke la valeur recherchée dans la référence arrière %2. %1 est le début de la requête, et %3 ce qui reste. Cette condition est un peu complexe car elle introduit de la flexibilité et évite les doubles perluettes '&&' dans les substitutions.

  - Cette solution supprime le couple clé/valeur recherché :

        # Remove mykey=???
        RewriteCond "%{QUERY_STRING}" "(.*(?:^|&))mykey=([^&]*)&?(.*)&?$"
        RewriteRule "(.*)" "$1?%1%3"

  - Cette solution remplace la partie de l'URL qui suit la valeur recherchée par un '?' :

        # Copy from query string to PATH_INFO
        RewriteCond "%{QUERY_STRING}" "(.*(?:^|&))mykey=([^&]*)&?(.*)&?$"
        RewriteRule "(.*)" "$1/products/%2/?" [PT]

  - Cette solution utilise la valeur recherchée dans une deuxième condition ::

        # Capture the value of mykey in the query string
        RewriteCond "%{QUERY_STRING}" "(.*(?:^|&))mykey=([^&]*)&?(.*)&?$""
        RewriteCond "%2" !=not-so-secret-value
        RewriteRule "(.*)" - [F]

  - Cette solution produit l'effet inverse des précédentes ; elle copie des composantes du chemin (peut-être PATH_INFO) depuis l'URL vers sa chaîne de paramètres :

        # The desired URL might be /products/kitchen-sink, and the script expects
        # /path?products=kitchen-sink.
        RewriteRule "^/?path/([^/]+)/([^/]+)" "/path?$1=$2" [PT]

Langues Disponibles: en | fr

## Commentaires

Notice:
This is not a Q&A section. Comments placed here should be pointed towards suggestions on improving the documentation or server, and may be removed by our moderators if they are either implemented or considered invalid/off-topic. Questions on how to manage the Apache HTTP Server should be directed at either our IRC channel, #httpd, on Freenode, or sent to our mailing lists.