You are browsing documentation for an outdated version. See the latest documentation here.

Kong Gateway Performance Testing

The Kong Gateway codebase includes a performance testing framework. It allows Kong developers and users to evaluate the performance of Kong itself as well as bundled or custom plugins, and plot frame graphs to debug performance bottlenecks. The framework collects RPS (request per second) and latencies of Kong processing the request to represent performance metrics under different workloads.

The framework is implemented as an extension to Kong’s integration test suite.

Installation

The framework uses busted and some Lua development dependencies of Kong. To set up the environment, run make dev on your Kong repository to install all Lua dependencies.

Usage

Basic usage

Install Lua development dependencies of Kong being installed and invoke each test file with busted. The following runs the RPS and latency test using the docker driver.

  1. PERF_TEST_USE_DAILY_IMAGE=true PERF_TEST_VERSIONS=git:master,git:perf/your-other-branch bin/busted -o gtest spec/04-perf/01-rps/01-simple_spec.lua

Terraform managed instances

By default, Terraform doesn’t teardown instances after each test in lazy_teardown, allowing users to run multiple tests consecutively without rebuilding the infrastructure each time.

This behavior can be changed by setting the PERF_TEST_TEARDOWN_ALL environment variable to true. Users can also manually teardown the infrastructure by running:

  1. PERF_TEST_TEARDOWN_ALL=1 PERF_TEST_DRIVER=terraform PERF_TEST_TERRAFORM_PROVIDER=your-provider bin/busted -o gtest -t single spec/04-perf/99-teardown/

AWS

When using the terraform driver and aws-ec2 as the provider, AWS credentials can be provided using environment variables. It’s common to pass the AWS_PROFILE variable to point to a stored AWS credentials profile, or AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY to use credentials directly. See the Terraform AWS provider document for further information.

Charts

Charts are not rendered by default. There’s a reference implementation to draw graphs on all JSON data stored in the output directory. Use the following commands to draw graphs:

  1. cwd=$(pwd)
  2. cd spec/helpers/perf/charts/
  3. pip install -r requirements.txt
  4. for i in $(ls ${cwd}/output/*.data.json); do
  5.   python ./charts.py $i -o "${cwd}/output/"
  6. done

Drivers

Three “drivers” are implemented depending on different environments, accuracy requirements, and setup complexity.

DriverTest between git commitsTest between binary releasesFlame GraphTest unreleased version
Dockeryesyes yes (use_daily_image = true)
Terraformyesyesyesyes (use_daily_image = true)

You must install the following Lua development dependencies to use either of the drivers:

  • Docker Driver is based on Docker images. It requires fewer dependencies. And it doesn’t support FlameGraph generation.

  • terraform Driver runs in a remote VM or on a bare metal machine. It’s most accurate, but it requires Terraform knowledge to operate and setup.

    • Requires the Terraform binary be installed.
    • Requires git binary if testing between git commits. When testing between git commits, the framework assumes the current directory is Kong’s repo. It will stash your working directory and remove the stash after the test is finished. When using the Docker or Terraform driver, the framework derives the base version of each commit and uses the matching Docker image or Kong binary package and puts the local source code inside.

Workflow

Multiple test cases can share the same Lua file.

The following code snippet demonstrates a basic workflow for defining a workload and load testing Kong.

  1. local perf = require("spec.helpers.perf")
  3. perf.use_defaults()
  5. local versions = { "git:master", "3.0.0" }
  7. for _, version in ipairs(versions) do
  8.   describe("perf test for Kong " .. version .. " #simple #no_plugins", function()
  9.     local bp
  10.     lazy_setup(function()
  11.       local helpers = perf.setup_kong(version)
  13.       bp = helpers.get_db_utils("postgres", {
  14.         "routes",
  15.         "services",
  16.       })
  18.       local upstream_uri = perf.start_worker([[
  19.       location = /test {
  20.         return 200;
  21.       }
  22.       ]])
  24.       local service = bp.services:insert {
  25.         url = upstream_uri .. "/test",
  26.       }
  28.       bp.routes:insert {
  29.         paths = { "/s1-r1" },
  30.         service = service,
  31.         strip_path = true,
  32.       }
  33.     end)
  35.     before_each(function()
  36.       perf.start_kong({
  37.         --kong configs
  38.       })
  39.     end)
  41.     after_each(function()
  42.       perf.stop_kong()
  43.     end)
  45.     lazy_teardown(function()
  46.       perf.teardown()
  47.     end)
  49.     it("#single_route", function()
  50.       local results = {}
  51.       for i=1,3 do
  52.         perf.start_load({
  53.           path = "/s1-r1",
  54.           connections = 1000,
  55.           threads = 5,
  56.           duration = 10,
  57.         })
  59.         ngx.sleep(10)
  61.         local result = assert(perf.wait_result())
  63.         print(("### Result for Kong %s (run %d):\n%s"):format(version, i, result))
  64.         results[i] = result
  65.       end
  67.       print(("### Combined result for Kong %s:\n%s"):format(version, assert(perf.combine_results(results))))
  69.       perf.save_error_log("output/" .. version:gsub("[:/]", "#") .. "-single_route.log")
  70.     end)
  71.   end)
  72. end

The test can be run as a normal Busted test, using bin/busted path/to/this_file_spec.lua.

More examples can be found in the spec/04-perf folder in the Kong repository.

Sample Output

  1. ### Test Suite: git:origin/master~10 #simple #hybrid #no_plugins #single_route
  2. ### Result for Kong git:origin/master~10 (run 1):
  3. Running 30s test @ http://172.17.0.50:8000/s1-r1
  4.   5 threads and 100 connections
  5.   Thread Stats   Avg      Stdev     Max   +/- Stdev
  6.     Latency     3.53ms    3.35ms  87.02ms   89.65%
  7.     Req/Sec     6.42k     1.33k   10.53k    67.29%
  8.   Latency Distribution
  9.      50%    2.65ms
  10.      75%    4.35ms
  11.      90%    6.99ms
  12.      99%   16.86ms
  13.   960330 requests in 30.10s, 228.96MB read
  14. Requests/sec:  31904.97
  15. Transfer/sec:      7.61MB
  16. ### Result for Kong git:origin/master~10 (run 2):
  17. Running 30s test @ http://172.17.0.50:8000/s1-r1
  18.   5 threads and 100 connections
  19.   Thread Stats   Avg      Stdev     Max   +/- Stdev
  20.     Latency     4.56ms    6.55ms 236.87ms   91.95%
  21.     Req/Sec     5.79k     1.54k   10.50k    66.18%
  22.   Latency Distribution
  23.      50%    2.82ms
  24.      75%    5.31ms
  25.      90%    9.72ms
  26.      99%   26.33ms
  27.   863963 requests in 30.07s, 206.00MB read
  28. Requests/sec:  28730.72
  29. Transfer/sec:      6.85MB
  30. ### Result for Kong git:origin/master~10 (run 3):
  31. Running 30s test @ http://172.17.0.50:8000/s1-r1
  32.   5 threads and 100 connections
  33.   Thread Stats   Avg      Stdev     Max   +/- Stdev
  34.     Latency     3.79ms    3.81ms  82.25ms   89.60%
  35.     Req/Sec     6.14k     1.43k   12.59k    66.49%
  36.   Latency Distribution
  37.      50%    2.77ms
  38.      75%    4.69ms
  39.      90%    7.71ms
  40.      99%   18.88ms
  41.   917366 requests in 30.08s, 218.72MB read
  42. Requests/sec:  30499.09
  43. Transfer/sec:      7.27MB
  44. ### Combined result for Kong git:origin/master~10:
  45. RPS     Avg: 30378.26
  46. Latency Avg: 3.94ms    Max: 236.87ms
  47.    P90 (ms): 6.99, 9.72, 7.71
  48.    P99 (ms): 16.86, 26.33, 18.88

With samples in spec/04-perf, the RPS and latency results, Kong error logs, charts and Flame Graph files are saved to the output directory in the current directory.