Utilisation des cartes de réécriture dans le module de réécriture d’URL

Article
03/21/2024

Cette procédure pas à pas vous présente le concept de réécriture des cartes dans le module de réécriture d’URL et vous guidera sur la création de règles de réécriture qui utilisent des cartes de réécriture. Dans cette procédure pas à pas, vous allez créer deux cartes de réécriture : une carte de réécriture sera utilisée par une règle qui effectue la réécriture d’URL, et une autre carte de réécriture sera utilisée par une règle qui effectue des redirections vers un autre domaine.

Background

Une carte de réécriture est une collection arbitraire de paires nom-valeur qui peuvent être utilisées dans les règles de réécriture pour générer l’URL de substitution pendant la réécriture. Les cartes de réécriture sont particulièrement utiles lorsque vous disposez d’un grand ensemble de règles de réécriture, qui utilisent toutes des chaînes statiques (c’est-à-dire qu’il n’existe aucuns critères spéciaux utilisés). Dans ce cas, plutôt que de définir un grand nombre de règles de réécriture simples, vous pouvez placer tous les mappages entre eux dans la carte de réécriture en utilisant l’URL d’entrée comme clé et l’URL de substitution comme valeur. Ensuite, pour rechercher l’URL de substitution en fonction de l’URL d’entrée, vous aurez une règle de réécriture qui référence cette carte de réécriture.

Prérequis

Cette procédure pas à pas nécessite les prérequis suivants :

IIS 7.0 ou version ultérieure avec le service de rôle ASP.NET activé
Réécriture de l’URL version Go Live installée

Configuration d’une page internet de test

Pour illustrer la fonctionnalité de réécriture de la carte, nous allons utiliser une simple page de test asp.net. Cette page lit les variables du serveur internet et affiche leurs valeurs dans le navigateur.

Copiez le code ASP.NET suivant et placez-le dans le dossier %SystemDrive%\inetpub\wwwroot\ dans un fichier appelé article.aspx :

<%@ Page Language="C#" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>URL Rewrite Module Test</title>
</head>
<body>
      <h1>URL Rewrite Module Test Page</h1>
      <table>
            <tr>
                  <th>Server Variable</th>
                  <th>Value</th>
            </tr>
            <tr>
                  <td>Original URL: </td>
                  <td><%= Request.ServerVariables["HTTP_X_ORIGINAL_URL"] %></td>
            </tr>
            <tr>
                  <td>Final URL: </td>
                  <td><%= Request.ServerVariables["SCRIPT_NAME"] + "?" + Request.ServerVariables["QUERY_STRING"] %></td>
            </tr>
      </table>
</body>
</html>

Après avoir copié ce fichier, accédez à http://localhost/article.aspx et vérifiez que la page s’affiche correctement dans un navigateur.

Créer une carte pour la réécriture

Tout d’abord, nous allons créer une carte de réécriture et une règle de réécriture qui seront utilisées pour effectuer la réécriture d’URL en fonction d’un ensemble de mappages statiques entre les URL d’origine et les URL réécrites. Pour créer une carte de réécriture, procédez comme suit :

Accéder au Gestionnaire des services internet (IIS)
Sélectionnez « Site internet par défaut »
Dans la vue des fonctionnalités, cliquez sur « Réécriture d’URL »
Dans le volet « Actions » à droite, cliquez sur « Afficher les cartes réécritures... » :
Dans le volet « Actions » sur le site de droite, cliquez sur « Ajouter une carte de réécriture... » puis entrez le nom de la carte de réécriture en tant que « StaticRewrites » :
Dans la page pour la nouvelle carte de réécriture, dans le volet « Actions » à droite, cliquez sur « Ajouter une entrée de mappage... » puis entrez « /article » et « /article.aspx?id=1&title=some-title » dans « Valeur d’origine : » et « Nouvelle valeur : » respectivement. La valeur d’origine spécifie le chemin d’accès URL à partir duquel nous voulons réécrire ; la nouvelle valeur spécifie le chemin d’accès URL dans lequel nous voulons réécrire.
Répétez l’étape 6 pour ajouter les mappages suivants à la carte de réécriture :

Valeur d’origine : Nouvelle valeur :

/some-title /article.aspx?id=1&title=some-title

/post/some-title.html /article.aspx?id=1&title=some-title

Valeur d’origine :	Nouvelle valeur :
/some-title	/article.aspx?id=1&title=some-title
/post/some-title.html	/article.aspx?id=1&title=some-title

Ouvrez maintenant le fichier web.config pour votre site internet (si vous utilisez le site internet par défaut, le fichier web.config est disponible à l’emplacement %SystemDrive%\inetpub\wwwroot). Vous devez voir la section suivante :

<rewrite>
    <rewriteMaps>
        <rewriteMap name="StaticRewrites" defaultValue="">
            <add key="/article1" value="/article.aspx?id=1&amp;title=some-title" />
            <add key="/some-title" value="/article.aspx?id=1&amp;title=some-title" />
            <add key="/post/some-title.html" value="/article.aspx?id=1&amp;title=some-title" />
        </rewriteMap>
    </rewriteMaps>
</rewrite>

Cette carte de réécriture, appelée « StaticRewrites », sera utilisé pour réécrire les URL entrantes (définies en tant que clés dans la carte de réécriture) à leurs représentations internes (définies en tant que valeurs). L’attribut defaultValue définit la valeur à utiliser si une URL entrante n’est pas définie dans la carte. Dans ce cas, une chaîne vide est retournée.

Notez qu’il n’existe aucun modèle courant évident dans les clés et leur relation avec les valeurs. Cela signifie qu’il n’est pas possible d’utiliser des expressions régulières ou des caractères génériques pour définir la logique de transformation d’URL. En outre, cela signifie que si nous n’avions pas utilisé de cartes de réécriture, nous aurions dû créer trois règles de réécriture. Avec les cartes de réécriture, nous ne pouvons créer qu’une seule règle de réécriture. La section suivante explique comment créer une règle de réécriture qui utilise cette carte de réécriture.

Référencement d’une carte de réécriture à partir d’une règle de réécriture

Pour créer une règle de réécriture qui utilise les cartes de réécriture, copiez et collez le code XML suivant dans la section <rewrite> du fichier web.config pour votre site internet :

<rules>
    <rule name="Rewrite Rule">
        <match url=".*" />
        <conditions>
            <add input="{StaticRewrites:{REQUEST_URI}}" pattern="(.+)" />
        </conditions>
        <action type="Rewrite" url="{C:1}" />
    </rule>
</rules>

Passons en revue chaque élément de règle pour comprendre ce qu’il fait :
<match url=".*" /> – cet élément indique au module de réécriture d’URL de correspondre à n’importe quelle URL entrante (à l’aide d’un caractère spécial d’expression régulière « . »)

<add input="{StaticRewrites:{REQUEST\_URI}}" pattern="(.+)"> – cette condition vérifie que la valeur retournée par la réécriture de la carte StaticRewrites n’est pas une chaîne vide. Pour effectuer cette vérification, la valeur de la variable serveur REQUEST_URI est passée en tant que paramètre à la carte de réécriture. Si la carte de réécriture contient une entrée avec une clé, c’est-à-dire identique à REQUEST_URI, la valeur correspondant à cette clé est retournée. Le modèle d’expression régulière correspond uniquement aux chaînes non vides. Par conséquent, si une chaîne vide a été retournée à partir de la carte, la condition prend la valeur false, et aucune réécriture n’est donc effectuée. Si une chaîne non vide a été retournée, cette chaîne sera capturée dans une référence arrière, en raison de la parenthèse utilisée dans le modèle.

<action type="Rewrite" url="{C:1}" /> – cet élément spécifie que le module de réécriture d’URL doit réécrire la chaîne d’URL actuelle avec le nouveau extrait de la carte de réécriture. Notez que l’attribut d’URL fait référence à la condition {C:1}, qui a été définie lorsque le modèle dans la condition a été mis en correspondance.

Tester la règle pour la réécriture

Pour tester la règle de réécriture qui utilise la carte « StaticRewrites », ouvrez le navigateur internet et demandez l’une des URL suivantes :

http://localhost/article1
http://localhost/some-title
http://localhost/post/some-title.html

L’une des URL ci-dessus doit entraîner la réécriture de l’URL conformément aux mappages définis dans la carte de réécriture. Les résultats doivent ressembler à la page suivante :

Utilisation de cartes de réécriture pour la redirection

Nous allons maintenant créer un autre carte de réécriture qui sera utilisé pour définir des mappages statiques entre les URL sources et les URL de redirection. Pour créer une carte de réécriture, suivez les mêmes étapes que celles décrites dans la section « Création d’une carte pour la réécriture », mais nommez la carte de réécriture en tant que « StaticRedirects » et utilisez les valeurs suivantes pour les entrées de mappage :

Valeur d’origine :	Nouvelle valeur :
/old-article.aspx?id=1	/article.aspx?id=1
/posts/default.aspx?id=1	/article.aspx?id=1
/old-title.html	/article.aspx?id=1

Le fichier web.config de votre site internet doit maintenant contenir ces deux cartes de réécriture :

<rewriteMaps>
    <rewriteMap name="StaticRewrites">
        <add key="/article1" value="/article.aspx?id=1&amp;title=some-title" />
        <add key="/some-title" value="/article.aspx?id=1&amp;title=some-title" />
        <add key="/post/some-title.html" value="/article.aspx?id=1&amp;title=some-title" />
    </rewriteMap>
    <rewriteMap name="StaticRedirects">
        <add key="/old-article.aspx?id=1" value="/article.aspx?id=1" />
        <add key="/posts/default.aspx?id=1" value="/article.aspx?id=1" />
        <add key="/old-title.html" value="/article.aspx?id=1" />
    </rewriteMap>
</rewriteMaps>

Pour créer une règle qui utilise la carte de réécriture StaticRedirects, copiez et collez la définition de règle suivante dans le fichier web.config de votre site internet :

<rules>
    <rule name="Redirect Rule" stopProcessing="true">
        <match url=".*" />
        <conditions>
            <add input="{StaticRedirects:{REQUEST_URI}}" pattern="(.+)" />
        </conditions>
        <action type="Redirect" url="http://localhost{C:1}" appendQueryString="False" redirectType="Permanent" />
    </rule>
</rules>

Là encore, passons en revue chaque élément de règle pour comprendre ce qu’il fait :
<match url=".*" /> – cet élément indique au module de réécriture d’URL de correspondre à n’importe quelle URL entrante (à l’aide d’un caractère spécial d’expression régulière « . »)

<add input="{StaticRedirects:{REQUEST\_URI}}" pattern="(.+)"> – cette condition vérifie que la valeur retournée par la réécriture de la carte StaticRedirects n’est pas une chaîne vide. Pour effectuer cette vérification, la valeur de la variable serveur REQUEST_URI est passée en tant que paramètre à la carte de réécriture. Si la carte de réécriture contient une entrée avec une clé, c’est-à-dire identique à REQUEST_URI, la valeur correspondant à cette clé est retournée. Le modèle d’expression régulière correspond uniquement aux chaînes non vides. Par conséquent, si une chaîne vide a été retournée à partir de la carte, la condition prend la valeur false, et aucune réécriture n’est donc effectuée. Si une chaîne non vide a été retournée, cette chaîne sera capturée dans une référence arrière, en raison de la parenthèse utilisée dans le modèle.

<action type="Redirect" url="http://localhost{C:1}" appendQueryString="False" redirectType="Permanent" /> – cet élément spécifie que le module de réécriture d’URL doit rediriger le client internet vers une nouvelle URL construite en concaténant le nouveau nom de domaine (dans ce cas, il s’agit du même domaine à des fins de simplicité) et le chemin d’URL de redirection retourné par la carte StaticRedirects.

Tester la règle de redirection

Pour tester la règle de réécriture qui utilise la carte « StaticRedirects », ouvrez le navigateur internet et demandez l’une des URL suivantes :

http://localhost/old-article
http://localhost/posts/default.aspx?id=1
http://localhost/old-title.html

L’une des URL ci-dessus doit rediriger le navigateur vers http://localhost/article.aspx?id=1.

Utiliser des cartes de réécriture pour les paramètres de chaîne de requête

L’utilisation de cartes de réécriture n’est pas limitée aux exemples mentionnés ci-dessus. La carte de réécriture est une collection générique de paires clé-valeur qui peuvent être utilisées n’importe où dans la règle de réécriture. Pour illustrer cela, nous allons créer une carte de réécriture qui peut être utilisé pour la manipulation des paramètres de chaîne de requête.

Créez un troisième mappage de réécriture en suivant les mêmes étapes que celles décrites dans la section « Création d’une carte pour la réécriture ». Nommez la carte de réécriture « IDtoTitleMap » et utilisez les valeurs suivantes pour les entrées de mappage :

Valeur d’origine :	Nouvelle valeur :
1	some-title-1
2	some-title-2
3	some-title-3

Le fichier web.config de votre site internet doit maintenant contenir ces deux cartes de réécriture :

<rewriteMaps>
    <rewriteMap name="StaticRewrites">
        <add key="/article1" value="/article.aspx?id=1&amp;title=some-title" />
        <add key="/some-title" value="/article.aspx?id=1&amp;title=some-title" />
        <add key="/post/some-title.html" value="/article.aspx?id=1&amp;title=some-title" />
    </rewriteMap>
    <rewriteMap name="StaticRedirects">
        <add key="/old-article.aspx?id=1" value="/article.aspx?id=1" />
        <add key="/posts/default.aspx?id=1" value="/article.aspx?id=1" />
        <add key="/old-title.html" value="/article.aspx?id=1" />
    </rewriteMap>
    <rewriteMap name="IDtoTitleMap">
        <add key="1" value="some-title-1" />
        <add key="2" value="some-title-2" />
        <add key="3" value="some-title-3" />
    </rewriteMap>
</rewriteMaps>

Pour créer une règle qui utilise la carte de réécriture IDtoTitleMap, copiez et collez la définition de règle suivante dans le fichier web.config de votre site internet :

<rules>
    <rule name="Query String Rule" stopProcessing="true">
        <match url="^article\.aspx$" />
        <conditions>
            <add input="{QUERY_STRING}" pattern="(?:^|&)id=([0-9]+)(?:&|$)" />
            <add input="{IDtoTitleMap:{C:1}}" pattern="(.+)" />
        </conditions>
        <action type="Redirect" url="article.aspx?title={C:1}" appendQueryString="False" 
                                                            redirectType="Permanent" />
    </rule>
</rules>

Passons en revue chaque élément de règle pour comprendre ce qu’il fait :
<match url="^article\.aspx$" /> – cet élément indique au module de réécriture d’URL d’exécuter la règle lorsque le fichier article.aspx est demandé.

<add input="{QUERY\_STRING}" pattern="(?:^|&)id=([0-9]+)(?:&|$)" /> – cette condition vérifie si la chaîne de requête contient un paramètre id qui a une valeur numérique. La valeur réelle est capturée dans une condition de référence arrière. Notez que ce modèle fonctionne même s’il existe d’autres paramètres sur la chaîne de requête.

<add input="{IDtoTitleMap:{C:1}}" pattern="(.+)" /> – cette condition vérifie si la valeur retournée à partir de la carte de réécriture IDtoTitleMap n’est pas une chaîne vide. La condition utilise la référence arrière du modèle de condition précédent comme entrée de la carte de réécriture.

<action type="Redirect" url="article.aspx?title={C:1}" appendQueryString="False" redirectType="Permanent" /> – cet élément spécifie que le module de réécriture d’URL doit rediriger le client internet vers le fichier article.aspx, mais avec un paramètre de chaîne de requête title différent, qui a une valeur qui a été recherchée dans la carte de réécriture.

Tester la règle pour la chaîne de requête

Pour tester la règle de réécriture qui utilise la carte « IDtoTitleMap », ouvrez le navigateur internet et demandez l’une des URL suivantes :

http://localhost/article.aspx?id=1. Vous serez redirigé vers http://localhost/article.aspx?title=some-title-1. http://localhost/article.aspx?someparam=somevalue&id=2. Vous serez redirigé vers http://localhost/article.aspx?title=some-title-2

Résumé

Dans cette procédure pas à pas, vous avez appris à utiliser des cartes de réécriture pour définir des mappages d’URL pour réécrire et rediriger des règles. Vous avez également appris à utiliser des cartes de réécriture pour manipuler les paramètres de chaîne de requête.

Les cartes de réécriture vous permettent de réduire le nombre de règles de réécriture lorsque les URL de réécriture et de redirection sont statiques et que la logique de réécriture ne peut pas être exprimée à l’aide de techniques de correspondance de modèle.