Langage de politique d'acheminement pour les équilibreurs de charge

La correspondance de chaînes utilise par défaut des comparaisons sensibles à la casse.

Par exemple, si le chemin de l'URL d'une demande HTTP est /foo, le prédicat suivant ne correspond pas pour cette demande, car une comparaison de chaîne sensible à la casse est utilisée :

http.request.url.path eq '/FOO'

Une mise en correspondance non sensible à la case est effectuée si au moins une des valeurs comparées est une chaîne non sensible à la case. La syntaxe d'une chaîne non sensible à la casse est la suivante :

(i '<string content>')

Par exemple, ces chaînes sont toutes non sensibles à la casse et sont donc les mêmes, lorsqu'elles sont utilisées dans des prédicats :

(i 'foo')
(i 'Foo')
(i 'FOO')

Par rapport à l'exemple initial, ce prédicat correspond, car il utilise une comparaison sans distinction majuscules/minuscules :

http.request.url.path eq (i '/FOO')

Certaines variables contiennent des mappages clé-valeur arbitraires des données de la demande, par exemple des en-têtes ou des témoins de demande. Pour chaque clé, il peut y avoir une ou plusieurs valeurs. Par exemple, plusieurs en-têtes de demande peuvent porter le même nom.

En général, les variables de mappage peuvent être utilisées dans les règles comme suit :

• Pour vérifier si un mappage contient une clé spécifique.
• Pour vérifier si un mappage contient une clé spécifique avec une valeur spécifique.

Vérification de la présence d'une clé spécifique dans un mappage :

Pour vérifier si une variable de mappage contient une clé spécifique, le sélecteur in est utilisé. Pour plus de détails, voir Langage de politique d'acheminement pour les équilibreurs de charge.

Par exemple :

'Foo' in (http.request.cookies)

Cette condition est correspondante si la demande HTTP contient un témoin nommé Foo.

Vérification de la présence d'une clé spécifique avec une valeur spécifique dans un mappage :

Pour vérifier si un mappage contient une clé spécifique avec une valeur spécifique, des crochets [] sont utilisés pour obtenir les valeurs d'une clé spécifique. La syntaxe de la notation à crochets est la suivante :

<variable>[<key>]

La valeur <key> doit être spécifiée en tant que chaîne sensible à la casse ou non.

La recherche réelle d'une valeur spécifique est effectuée à l'aide du coupleur eq pour vérifier si any des valeurs de cette clé sont égales à cette valeur spécifique. Le prédicat correspond si au moins une des valeurs de la clé correspond à cette valeur.

Exemples :

• Pour établir une correspondance si une valeur de l'en-tête header-name est égale à header-value :

  http.request.headers[(i 'header-name')] eq 'header-value'

  La comparaison de l'en-tête name n'est pas sensible à la casse, mais celle de l'en-tête value est sensible à la casse.

• Pour établir une correspondance si une valeur du témoin "cookie-name" est égale à cookie-value :

  http.request.cookies['cookie-name'] eq 'cookie-value'

Le coupleur not eq peut être utilisé pour vérifier que none des valeurs de cette clé sont égales à une valeur spécifique.

Exemples :

• Pour établir une correspondance si aucune valeur de l'en-tête header-name n'est égale à header-value :

  http.request.headers[(i 'header-name')] not eq 'header-value'

  La comparaison du nom de l'en-tête n'est pas sensible à la casse. La comparaison de la valeur de l'en-tête est sensible à la casse.

• Pour établir une correspondance si aucune valeur du témoin "cookie-name" ne correspond à cookie-value :

  http.request.cookies['cookie-name'] not eq 'cookie-value'

Les variables disponibles pour être utilisées dans les conditions sont les suivantes :

{
  "key": [
    "value",
    "a"
  ],
  "another key": [
    "another value"
  ],
}

Une demande HTTP/1.1 entrante se présente comme suit (ligne et en-têtes de la demande) :

GET /category/some_category?action=search&query=search+terms&filters[]=5&features[]=12 HTTP/1.1
Accept-Encoding: gzip, deflate, br
Cookie: cookie_a=1; cookie_b=foo
Host: www.domain.com
User-Agent: Browser Foo/1.0
X-Forwarded-For: 1.2.3.4, 5.6.7.8
X-Forwarded-For: 9.10.11.12

Ensuite, les variables disponibles pour les règles sont alimentées avec les données de cette demande comme suit (les données des variables structurées sont affichées au format JSON) :

http.request.url.path: "/category/some_category"
 
http.request.url.query: {
  "action": ["search"],
  "query": ["search terms"],
  "filters[]": ["5", "12"]
}
 
http.request.headers: {
  "Accept-Encoding": ["gzip, deflate, br"],
  "Cookie": ["some_cookie=1; another_cookie=foo"],
  "Host": ["www.domain.com"],
  "User-Agent": ["Browser Foo/1.0"],
  "X-Forwarded-For": ["1.2.3.4, 5.6.7.8", "9.10.11.12"]
}
 
http.request.cookies: {
  "cookie_a": ["1"],
  "cookie_b": ["foo"]
}

Voici quelques exemples de mise en correspondance de cette demande :

• Pour mettre en correspondance les demandes avec le domaine www.domain.com et les chemins d'URL commençant par /category/, une condition semblable à la suivante est utilisée :

  all(http.request.headers[(i 'Host')] eq 'www.domain.com', http.request.url.path sw '/category')

• Pour mettre en correspondance les demandes où le chemin d'URL est exactement /category/some_category ou l'élément d'interrogation de demande action=search :

  any(http.request.url.path eq '/category/some_category', http.request.url.query['action'] eq 'search')

• Pour mettre en correspondance les demandes comportant un élément de chaîne d'interrogation nommé query avec la valeur search terms (sans caractères d'échappement dans l'URL) :

  http.request.url.query['query'] eq 'search terms'

• Pour mettre en correspondance les demandes comportant le témoin cookie_a, mais pas le témoin cookie_c :

  all('cookie_a' in (http.request.cookies), 'cookie_c' not in (http.request.cookies))