Routing Policy Language for Load Balancers

String case-sensitivity

String matching uses case-sensitive comparisons by default.

For example, if the HTTP request URL path for some request is /foo then the following predicate would not match for that request, because case-sensitive string comparison is used:

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

Case-insensitive matching is done if at least one of the compared values is a case-insensitive string. The syntax for a case insensitive string is:

(i '<string content>')

For example, these strings are all case-insensitive and are therefore equivalent, when used in predicates:

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

In comparison to the original example - this predicate does match, because it uses case-insensitive comparison:

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

Map Type Variables

Some of the variables contain arbitrary key-value maps of request data, for example request headers or cookies. For each key, there can be one or more values. For example, there can be multiple request headers with the same name.

Generally map variables can be used in rules these ways:

• To check if a map has a specific key.

• To check if a map has a specific key with a specific value.

Checking if a map has a specific key:

Checking if a map variable has a specific key is done with the in matcher. For more details, refer to Routing Policy Language for Load Balancers.

For example:

'Foo' in (http.request.cookies)

This condition matches if the HTTP request has a cookie with the name 'Foo.'

Checking if a map has a specific key with a specific value:

Checking if a map has a specific key with a specific value is done using bracket [] notation to get the values at a specific key. The syntax for using bracket notation is:

<variable>[<key>]

The <key> must be specified as a case-sensitive or case-insensitive string.

The actual check for a specific value is done using the eq matcher to check if any of the values at that key are equal to that specific value. The predicate matches if at least one of the values at that key match that specific value.

Examples:

• To match if any value of the header "header-name" equals "header-value":

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

  Header name is compared case-insensitively, but header value is compared case-sensitively.

• To match if any value of the cookie "cookie-name" equals 'cookie-value':

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

The not eq matcher can be used to check that none of the values at that key are equal to a specific value.

Examples:

• To match if no value of the header "header-name" equals "header-value":

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

  Header name is compared case-insensitively. Header value is compared case-sensitively.

• To match if no value of the cookie "cookie-name" equals 'cookie-value':

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

All Available Variables

The variables available to be used in the conditions are:

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

Examples

An incoming HTTP/1.1 request looks like this (request line and headers):

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

Then the variables available for rules would be populated with data from this request as follows:(the data for structured variables is shown in JSON format)

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"]
}

Here are some examples how we could match this request:

• If we wanted to match requests to domain "www.domain.com" and URL paths that start with "/category/," we would use a condition like this:

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

• To match requests where the URL path is exactly "/category/some_category" or request query element "action=search"

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

• To match requests that have a query string element named "query" with value "search terms" (after URL unescaping)

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

• To match requests that have cookie "cookie_a" but don't have cookie "cookie_c":

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