Skip to content
2023 API Summit Hackathon: Experiment with AI for APIs (August 28 - September 27) Learn More →
Kong Logo | Kong Docs Logo
search
  • We're Hiring!
  • Docs
    • Kong Gateway
      Lightweight, fast, and flexible cloud-native API gateway
      Kong Konnect
      Single platform for SaaS end-to-end connectivity
      Kong Mesh
      Enterprise service mesh based on Kuma and Envoy
      decK
      Helps manage Kong’s configuration in a declarative fashion
      Kong Ingress Controller
      Works inside a Kubernetes cluster and configures Kong to proxy traffic
      Kong Gateway Operator
      Manage your Kong deployments on Kubernetes using YAML Manifests
      Insomnia
      Collaborative API development platform
      Kuma
      Open-source distributed control plane with a bundled Envoy Proxy integration
  • API Specs
  • Plugin Hub
    • Explore the Plugin Hub
      View all plugins View all plugins View all plugins arrow image
    • Functionality View all View all arrow image
      View all plugins
      Authentication's icon
      Authentication
      Protect your services with an authentication layer
      Security's icon
      Security
      Protect your services with additional security layer
      Traffic Control's icon
      Traffic Control
      Manage, throttle and restrict inbound and outbound API traffic
      Serverless's icon
      Serverless
      Invoke serverless functions in combination with other plugins
      Analytics & Monitoring's icon
      Analytics & Monitoring
      Visualize, inspect and monitor APIs and microservices traffic
      Transformations's icon
      Transformations
      Transform request and responses on the fly on Kong
      Logging's icon
      Logging
      Log request and response data using the best transport for your infrastructure
  • Support
  • Community
  • Kong Academy
Get a Demo Start Free Trial
Kong Gateway
3.4.x (latest)
  • Home icon
  • Kong Gateway
  • Key Concepts
  • Routes
  • How to Configure Routes using Expressions
github-edit-pageEdit this page
report-issueReport an issue
  • Kong Gateway
  • Kong Konnect
  • Kong Mesh
  • Plugin Hub
  • decK
  • Kong Ingress Controller
  • Kong Gateway Operator
  • Insomnia
  • Kuma

  • Docs contribution guidelines
  • 3.4.x (latest)
  • 3.3.x
  • 3.2.x
  • 3.1.x
  • 3.0.x
  • 2.8.x
  • 2.7.x
  • 2.6.x
  • Archive (pre-2.6)
enterprise-switcher-icon Switch to OSS
On this pageOn this page
  • Prerequisite
  • Create routes with Expressions
    • Create complex routes with Expressions
    • Matching priority
  • Performance considerations when using Expressions
    • Examples
  • More information

How to Configure Routes using Expressions

Expressions can describe routes or paths as patterns using logical expressions. This how-to guide will walk through switching to the new router, and configuring routes with the new expressive domain specific language. For a list of all available operators and configurable fields please review the reference documentation.

Prerequisite

Edit kong.conf to contain the line router_flavor = expressions and restart Kong Gateway. Note: once you enable expressions, the match fields that traditionally exist on the Route object (such as paths, methods) will no longer be configurable and you must specify Expressions in the expression field.

Create routes with Expressions

To create a new router object using expressions, send a POST request to the services endpoint like this:

curl --request POST \
  --url http://localhost:8001/services/example-service/routes \
  --form-string expression='http.path == "/mock"'

In this example, you associated a new route object with the path /mock to the existing service example-service. The Expressions DSL also allows you to create complex router match conditions.

curl --request POST \
  --url http://localhost:8001/services/example-service/routes \
  --header 'Content-Type: multipart/form-data' \
  --form-string 'expression=(http.path == "/mock" || net.protocol == "https")'

In this example the || operator created an expression that set variables for the following fields:

curl --request POST \
  --url http://localhost:8001/services/example-service/routes \
  --header 'Content-Type: multipart/form-data' \
  --form-string 'expression=http.path == "/mock" && (net.protocol == "http" || net.protocol == "https")'

Create complex routes with Expressions

You can describe complex route objects using operators within a POST request.


curl --request POST \
  --url http://localhost:8001/services/example-service/routes \
  --header 'Content-Type: multipart/form-data' \
  --form-string name=complex_object \
  --form-string 'expression=(net.protocol == "http" || net.protocol == "https") &&
                (http.method == "GET" || http.method == "POST") &&
                (http.host == "example.com" || http.host == "example.test") &&
                (http.path ^= "/mock" || http.path ^= "/mocking") &&
                http.headers.x_another_header == "example_header" && (http.headers.x_my_header == "example" || http.headers.x_my_header == "example2")'

For a list of all available operators, see the reference documentation.

Matching priority

When the Expressions router is used, available expressions are evaluated using the priority field of the corresponding Route object where the expression is configured. Routes are evaluated in order of priority, where the highest priority integer is evaluated first. If two routes have the same priority, then the route with the higher id (UUID) will be evaluated first as a tie-breaker.

The Expressions router stops evaluating the remaining rules as soon as the first match is found.

For example, given the following config:

Route 1 =>
id: 82c8e89f-ddff-42f0-a1b8-4d1120547624
priority: 100,
expression: ...

Route 2 =>
id: 72c8e89f-ddff-42f0-a1b8-4d1120547624
priority: 100,
expression: ...

Route 3 =>
id: 92c8e89f-ddff-42f0-a1b8-4d1120547624
priority: 99,
expression: ...

The evaluation order will be: Route 1 then Route 2 and finally Route 3.

Performance considerations when using Expressions

Generally, Expressions are evaluated sequentially until a match could be found. This means with large number of Routes, the worst case match time will tends to scale linearly as the number of routes increase. Therefore it is desirable to reduce the number of unique routes by leveraging the combination capability of the language.

Keep regex usages to a minimum. Regular expressions are much more expensive to build and execute, and can not be optimized easily. Leveraging the powerful operators provided by the language instead.

Examples

Exact matches

When performing exact (not prefix) matches on paths, traditionally regex has to be used in the following form:

paths: ["~/foo/bar$"]

Routers with large amount of regexes are expensive to build and execute. With Expressions, avoid using regex by write the following:

http.path == "/foo/bar"

Optional slash at the end

Sometimes it is desirable to match both /foo and /foo/ in the same route. Traditionally, this has been done using the following regex:

paths: ["~/foo/?$"]

With Expressions, avoid using regex by write the following:

http.path == "/foo/bar" || http.path == "/foo/bar/"

Multiple routes with same Service and Plugin config

If multiple routes results in the same Service and Plugin config being used, they should be combined into a single Expression Route with logical or operator ||.

Example:

Route 1:

service: example-service
expression: http.path == "/hello"

Route 2:

service: example-service
expression: http.path == "/world"

Should be combined as:

service: example-service
expression: http.path == "/hello" || http.path == "/world"

This reduces the number of routes the Expressions engine has to consider, which helps with the matching performance at runtime

More information

  • Expressions repository
  • Expressions Language Reference
Thank you for your feedback.
Was this page useful?
Too much on your plate? close cta icon
More features, less infrastructure with Kong Konnect. 1M requests per month for free.
Try it for Free
  • Kong
    THE CLOUD CONNECTIVITY COMPANY

    Kong powers reliable digital connections across APIs, hybrid and multi-cloud environments.

    • Company
    • Customers
    • Events
    • Investors
    • Careers Hiring!
    • Partners
    • Press
    • Contact
  • Products
    • Kong Konnect
    • Kong Gateway
    • Kong Mesh
    • Get Started
    • Pricing
  • Resources
    • eBooks
    • Webinars
    • Briefs
    • Blog
    • API Gateway
    • Microservices
  • Open Source
    • Install Kong Gateway
    • Kong Community
    • Kubernetes Ingress
    • Kuma
    • Insomnia
  • Solutions
    • Decentralize
    • Secure & Govern
    • Create a Dev Platform
    • API Gateway
    • Kubernetes
    • Service Mesh
Star
  • Terms•Privacy
© Kong Inc. 2023