Project: Kong (Orchestration & Management / API Gateway)
File: CHANGELOG-OLD.md

Looking for recent releases? Please see instead. Bumped lua-resty-healthcheck from 1.5.0 to 1.5.1 Bumped `OpenSSL` from 1.1.1l to 1.1.1n Only reschedule router and plugin iterator timers after finishing previous execution, avoiding unnecessary concurrent executions. Implements conditional rebuilding of router, plugins iterator and balancer on data planes. This means that DPs will not rebuild router if there were no changes in routes or services. Similarly, the plugins iterator will not be rebuilt if there were no changes to plugins, and, finally, the balancer will not be reinitialized if there are no changes to upstreams or targets. The external project is considered deprecated in favor of the embedded server approach described in the . OpenSSL bumped to 1.1.1m Bumped resty.session from 3.8 to 3.10 Bumped lua-resty-openssl to 0.8.5 Customizable transparent dynamic TLS SNI name. Thanks, ! Routes now support matching headers with regular expressions Thanks, ! Secrets Management and Vault support as been introduced as a Beta feature. This means it is intended for testing in staging environments. It not intended for use in Production environments. You can read more about Secrets Management in . Improved the calculation of declarative configuration hash for big configurations The new method is faster and uses less memory Multiple improvements in the Router. Amongst others: The router builds twice as fast compared to prior Kong versions Failures are cached and discarded faster (negative caching) Routes with header matching are cached These changes should be particularly noticeable when rebuilding on db-less environments Prometheus plugin export performance is improved, it now has less impact to proxy side traffic when being scrapped. Response-ratelimiting: Redis ACL support, and genenarized Redis connection support for usernames. Thanks, for the original contribution! ACME: Add rsakeysize config option Thanks, ! Prometheus: Added gauges to track `ngx.timer.running_count()` and `ngx.timer.pending_count()` `CLUSTERINGMAXPAYLOAD` is now configurable in kong.conf Thanks, ! The current declarative configuration hash is now returned by the `status` endpoint when Kong node is running in dbless or data-plane mode. When the Router encounters an SNI FQDN with a trailing dot (`.`), the dot will be ignored, since according to said dot is not part of the hostname. Fixed a bug in the Router that would not prioritize the routes with both a wildcard and a port (`route.:80`) over wildcard-only routes (`route.`), which have less specificity The internal DNS client isn't confused by the single-dot (`.`) domain which can appear in `/etc/resolv.conf` in special cases like `search .` Cassandra connector now records migration consistency level. Thanks, ! Targets keep their health status when upstreams are updated. One debug message which was erroneously using the `error` log level has been downgraded to the appropiate `debug` log level. Replaced cryptic error message with more useful one when there is a failure on SSL when connecting with CP: Fix incorrect `next` field in when paginating Upstreams Phase names are correctly selected when performing phase checks Fixed a bug in the go-PDK where if `kong.request.getrawbody` was big enough to be buffered into a temporary file, it would return an an empty string. External Plugins: Fixed incorrect handling of the Headers Protobuf Structure and representation of null values, which provoked an error on init with the go-pdk. External Plugins: Unwrap `ConsumerSpec` and `AuthenticateArgs`. Thanks, ! External Plugins: Fixed a problem in the stream subsystem would attempt to load HTTP headers. CORS: The CORS plugin does not send the `Vary: Origin` header any more when the header `Access-Control-Allow-Origin` is set to `*`. Thanks, ! AWS-Lambda: Fixed incorrect behavior when configured to use an http proxy and deprecated the `proxy_scheme` config attribute for removal in

oauth2: The plugin clears the `X-Authenticated-UserId` and `X-Authenticated-Scope` headers when it configured in logical OR and is used in conjunction with another authentication plugin. Datadog: The plugin schema now lists the default values for configuration options in a single place instead of in two separate places. Reschedule resolve timer only when the previous one has finished. Plugins, and any entities implemented with subchemas, now can use the `transformations` and `shorthand_fields` properties, which were previously only available for non-subschema entities. Bumped `kong-plugin-session` from 0.7.1 to 0.7.2 Bumped `resty.openssl` from 0.7.4 to 0.7.5 Bumped `go-pdk` used in tests from v0.6.0 to v0.7.1 Cassandra support is deprecated with 2.7 and will be fully removed with 4.0. Deprecated the `worker_consistency` directive, and changed its default to `eventual`. Future versions of Kong will remove the option and act with `eventual` consistency only. In this release we continued our work on better performance: Improved the plugin iterator performance and JITability Simplified the Kong core context read and writes for better performance Reduced proxy long tail latency while reloading DB-less config DAOs in plugins must be listed in an array, so that their loading order is explicit. Loading them in a hash-like table is now deprecated. Postgres credentials `pguser` and `pgpassword`, and `pgrouser` and `pgropassword` now support automatic secret rotation when used together with vault references. New functions: `kong.response.getrawbody` and `kong.response.setrawbody` IP-Restriction: response status and message can now be customized through configurations `status` and `message`. Thanks for the patch! Datadog: add support for the `distribution` metric type. Thanks for the patch! Datadog: allow service, consumer, and status tags to be customized through plugin configurations `servicetag`, `consumertag`, and `status_tag`. Thanks for the patch! gRPC Gateway and gRPC Web: Now share most of the ProtoBuf definitions. Both plugins now share the Timestamp transcoding and included `.proto` files features. gRPC Gateway: processes services and methods defined in imported `.proto` files. Rate-Limiting: add support for Redis SSL, through configuration properties `redisssl` (can be set to `true` or `false`), `sslverify`, and `sslservername`. Thanks for the patch! LDAP: basic authentication header was not parsed correctly when the password contained colon (`:`). Thanks for reporting the issue! Old `BasePlugin` is deprecated and will be removed in a future version of Kong. Porting tips in the The deprecated BasePlugin has been removed. Removed the following config options, which had been deprecated in previous versions, in favor of other config names. If you have any of these options in your config you will have to rename them: (removed option -> current option). upstreamkeepalive -> nginxupstreamkeepalive + nginxhttpupstreamkeepalive nginxhttpupstreamkeepalive -> nginxupstream_keepalive nginxhttpupstreamkeepaliverequests -> nginxupstreamkeepalive_requests nginxhttpupstreamkeepalivetimeout -> nginxupstreamkeepalive_timeout nginxhttpupstreamdirectives -> nginxupstream_directives nginxhttpstatusdirectives -> nginxstatus_directives nginxupstreamkeepalive -> upstreamkeepalivepool_size nginxupstreamkeepaliverequests -> upstreamkeepalivemaxrequests nginxupstreamkeepalivetimeout -> upstreamkeepaliveidletimeout clientmaxbodysize -> nginxhttpclientmaxbodysize clientbodybuffersize -> nginxhttpclientmaxbuffersize cassandraconsistency -> cassandrawriteconsistency / cassandraread_consistency routerupdatefrequency -> workerstateupdate_frequency Removed the nginx_optimizations config option. If you have it in your configuration, please remove it before updating to 3.0. Balancer caches are now reset on configuration reload. Configuration reload no longer causes a new DNS-resolving timer to be started. Fixed problem when bootstrapping multi-node Cassandra clusters, where migrations could attempt insertions before schema agreement occurred. Fixed intermittent botting error which happened when a custom plugin had inter-dependent entity schemas on its custom DAO and they were loaded in an incorrect order Fixed problem when the consistent hash header is not found, the balancer tries to hash a nil value. Fixed DNS client fails to resolve unexpectedly in `sslcert` and `sslsession_fetch` phases. `kong.log.inspect` log level is now debug instead of

It also renders text boxes more cleanly now Prometheus: Control Plane does not show Upstream Target health metrics Bumped `lua-pack` from 1.0.5 to 2.0.0 Release date: 2021/10/04 Bumped `openresty` from 1.19.3.2 to Bumped `openssl` from `1.1.1k` to `1.1.1l` Bumped `lua-resty-http` from 0.15 to 0.16.1 Bumped `Penlight` to 1.11.0 Bumped `lua-resty-http` from 0.15 to 0.16.1 Bumped `lua-protobuf` from 0.3.2 to 0.3.3 Bumped `lua-resty-openssl` from 0.7.3 to 0.7.4 Bumped `lua-resty-acme` from 0.6 to 0.7.1 Bumped `grpcurl` from 1.8.1 to 1.8.2 Bumped `luasec` from 1.0.1 to 1.0.2 Bumped `lua-resty-ipmatcher` to 0.6.1 Thanks for the patch! All Kong Gateway OSS plugins will be moved from individual repositories and centralized into the main Kong Gateway (OSS) repository. We are making a gradual transition. On this release: Moved AWS-Lambda inside the Kong repo . Moved ACME inside the Kong repo . Moved Prometheus inside the Kong repo . Moved Session inside the Kong repo . Moved GRPC-web inside the Kong repo . Moved Serverless functions inside the Kong repo . New schema entity validator: `mutually_exclusive`. It accepts a list of fields. If more than 1 of those fields is set simultaneously, the entity is considered invalid. On this release we've done some special efforts with regards to performance. There's a new performance workflow which periodically checks new code additions against some typical scenarios In addition to that, the following changes were specifically included to improve performance: Reduced unnecessary reads of `ngx.var` Loaded more indexed variables Optimized table creation in Balancer Reduce calls to `ngx.update_time` Use read-only replica for PostgreSQL meta-schema reading URL escaping detects cases when it's not needed and early-exits Accelerated variable loading via indexes Removed unnecessary call to `get_phase` in balancer Enable IPV6 on `dns_order` as unsupported experimental feature. Please give it a try and report back any issues . The template renderer can now use `os.getenv` . Data plane is able to eliminate some unknown fields when Control Plane is using a more modern version . Added support for the HTTP HEAD method for all Admin API endpoints Added better support for OPTIONS requests. Previously, the Admin API replied the same on all OPTIONS requests, where as now OPTIONS request will only reply to routes that our Admin API has. Non-existing routes will have a 404 returned. It also adds Allow header to responses, both Allow and Access-Control-Allow-Methods now contain only the methods that the specific API supports. AWS-Lambda: The plugin will now try to detect the AWS region by using `AWS_REGION` and `AWSDEFAULTREGION` environment variables (when not specified with the plugin configuration). This allows to specify a 'region' on a per Kong node basis, hence adding the ability to invoke the Lamda in the same region where Kong is located. Datadog: `host` and `port` config options can be configured from environment variables `KONGDATADOGAGENTHOST` and `KONGDATADOGAGENTPORT`. This allows to set different destinations on a per Kong node basis, which makes multi-DC setups easier and in Kubernetes allows to run the datadog agents as a daemon-set. Thanks for the patch! Prometheus: A new metric`dataplaneclustercertexpirytimestamp`is added to expose the Data Plane'sclustercertexpiry timestamp for improved monitoring in Hybrid Mode.. Request Termination: New `trigger` config option, which makes the plugin only activate for any requests with a header or query parameter named like the trigger. This can be a great debugging aid, without impacting actual traffic being processed. . The `request-echo` config option was added. If set, the plugin responds with a copy of the incoming request. This eases troubleshooting when Kong is behind one or more other proxies or LB's, especially when combined with the new 'trigger' option. . GRPC-Gateway: Fields of type

on the gRPC side are now transcoded to and from ISO8601 strings in the REST side. URI arguments like `..?foo.bar=x&foo.baz=y` are interpreted as structured fields, equivalent to `{"foo": {"bar": "x", "baz": "y"}}` Thanks for the patch! Balancer retries now correctly set the `:authority` pseudo-header on balancer retries . Healthchecks are now stopped while the Balancer is being recreated . Fixed an issue in which a malformed `Accept` header could cause unexpected HTTP 500 . Kong no longer removes `Proxy-Authentication` request header and `Proxy-Authenticate` response header . Fixed an issue where Kong would not sort correctly Routes with both regex and prefix paths Thanks for the patch! Ensure data plane config thread is terminated gracefully, preventing a semi-deadlocked state Thanks for the patch! Older data planes using `aws-lambda`, `grpc-web` or `request-termination` plugins can now talk with newer control planes by ignoring new plugin fields. `kong config parse` no longer crashes when there's a Go plugin server enabled . Declarative Configuration parser now prints more correct errors when pointing unknown foreign references . YAML anchors in Declarative Configuration are properly processed . `GET /upstreams/:upstreams/targets/:target` no longer returns 404 when target weight is 0 . `kong.response.exit` now uses customized "Content-Length" header when found . ACME: Dots in wildcard domains are escaped . Prometheus: Upstream's health info now includes previously missing `subsystem` field . Proxy-Cache: Fixed an issue where the plugin would sometimes fetch data from the cache but not return it Thanks for the patch! Release date: 2021/09/07 This is the first patch release in the 2.5 series. Being a patch release, it strictly contains bugfixes. There are no new features or breaking changes. Bumped `grpcurl` from 1.8.1 to 1.8.2 Bumped `lua-resty-openssl` from 0.7.3 to 0.7.4 Bumped `penlight` from 1.10.0 to 1.11.0 Bumped `luasec` from 1.0.1 to 1.0.2 Bumped `OpenSSL` from 1.1.1k to 1.1.1l You can now successfully delete workspaces after deleting all entities associated with that workspace. Previously, Kong Gateway was not correctly cleaning up parent-child relationships. For example, creating an Admin also creates a Consumer and RBAC user. When deleting the Admin, the Consumer and RBAC user are also deleted, but accessing the `/workspaces/workspace_name/meta` endpoint would show counts for Consumers and RBAC users, which prevented the workspace from being deleted. Now deleting entities correctly updates the counts, allowing an empty workspace to be deleted. When an upstream event is received from the DAO, `handler.lua` now gets the workspace ID from the request and adds it to the upstream entity that will be used in the worker and cluster events. Before this change, when posting balancer CRUD events, the workspace ID was lost and the balancer used the default workspace ID as a fallback. Fixes regression that included an issue where Go plugins prevented CLI commands like `kong config parse` or `kong config db_import` from working as expected. Improves tests reliability. ( ) Adds Github Issues template forms. Moves "Feature Request" link from Github Issues to Discussions. Kong Gateway now validates workspace names, preventing the use of reserved names on workspaces. Release date: 2021-07-13 This is the final release of Kong 2.5.0, with no breaking changes with respect to the 2.x series. This release includes Control Plane resiliency to database outages and the new `declarativeconfigstring` config option, among other features and fixes. :warning: Since 2.4.1, Kong packages are no longer distributed through Bintray. Please visit for more details. Bumped `openresty` from 1.19.3.1 to 1.19.3.2 Bumped `luasec` from 1.0 to 1.0.1 Bumped `luarocks` from 3.5.0 to 3.7.0 Bumped `grpcurl` from 1.8.0 to 1.8.1 Bumped `penlight` from 1.9.2 to 1.10.0 Bumped `lua-resty-dns-client` from 6.0.0 to 6.0.2 Bumped `kong-plugin-prometheus` from 1.2 to

Bumped `kong-plugin-zipkin` from 1.3 to 1.4 Bumped `lua-resty-openssl` from 0.7.2 to 0.7.3 Bumped `lua-resty-healthcheck` from 1.4.1 to 1.4.2 Bumped `hmac-auth` from 2.3.0 to 2.4.0 Pinned `lua-protobuf` to 0.3.2 (previously unpinned) All Kong Gateway OSS plugins will be moved from individual repositories and centralized into the main Kong Gateway (OSS) repository. We are making a gradual transition, starting with the grpc-gateway plugin first: Moved grpc-gateway inside the Kong repo. Control Planes can now send updates to new data planes even if the control planes lose connection to the database. Kong now automatically adds `clustercert`(`clustermtls=shared`) or `clustercacert`(`cluster_mtls=pki`) into `luassltrusted_certificate` when operating in Hybrid mode. Before, Hybrid mode users needed to configure `luassltrusted_certificate` manually as a requirement for Lua to verify the Control Planes certificate. See in the Hybrid Mode guide for more information. New `declarativeconfigstring` option allows loading a declarative config directly from a string. See the section of the DB-less and Declarative Configuration guide for more information. The Kong PDK now accepts tables in the response body for Stream subsystems, just as it does for the HTTP subsystem. Before developers had to check the subsystem if they wrote code that used the `exit()` function before calling it, because passing the wrong argument type would break the request response. hmac-auth: The HMAC Authentication plugin now includes support for the `@request-target` field in the signature string. Before, the plugin used the `request-line` parameter, which contains the HTTP request method, request URI, and the HTTP version number. The inclusion of the HTTP version number in the signature caused requests to the same target but using different request methods(such as HTTP/2) to have different signatures. The newly added request-target field only includes the lowercase request method and request URI when calculating the hash, avoiding those issues. See the documentation for more information. syslog: The Syslog plugin now includes facility configuration options, which are a way for the plugin to group error messages from different sources. See the description for the facility parameter in the section of the Syslog documentation for more information. . Thanks, ! Prometheus: The Prometheus plugin now exposes connected data planes' status on the control plane. New metrics include the following: `dataplanelastseen`, `dataplaneconfighash` and `dataplaneversion_compatible`. These metrics can be useful for troubleshooting when data planes have inconsistent configurations across the cluster. See the section of the Prometheus plugin documentation for more information. Zipkin: The Zipkin plugin now includes the following tags: `kong.route`,`kong.servicename` and `kong.routename`. See the section of the Zipkin plugin documentation for more information. Kong now exposes an upstream health checks endpoint (using the status API) on the data plane for better observability. Control Planes are now more lenient when checking Data Planes' compatibility in Hybrid mode. See the section of the Hybrid Mode guide for more information. This release starts the groundwork for Hybrid Mode 2.0 Protocol. This code isn't active by default in Kong 2.5, but it allows future development. When using DB-less mode, `selectbycache_key` now finds entities by using the provided `field` directly in ` selectbykey` and does not complete unnecessary cache reads. Kong can now finish initialization even if a plugins `init_worker` handler fails, improving stability. TLS keepalive requests no longer share their context. Before when two calls were made to the same "server+hostname" but different routes and using a keepalive connection, plugins that were active in the first call were also sometimes (incorrectly) active in the second

The wrong plugin was active because Kong was passing context in the SSL phase to the plugin iterator, creating connection-wide structures in that context, which was then shared between different keepalive requests. With this fix, Kong does not pass context to plugin iterators with the `certificate` phase, avoiding plugin mixups. The HTTP status 405 is now handled by Kong's error handler. Before accessing Kong using the TRACE method returned a standard NGINX error page because the 405 wasnt included in the error page settings of the NGINX configuration. . Thanks, ! Custom `ngx.sleep` implementation in `initworker` phase now invokes `updatetime` in order to prevent time-based deadlocks `Proxy-Authorization` header is removed when it is part of the original request or when a plugin sets it to the same value as the original request `HEAD` requests don't provoke an error when a Plugin implements the `response` phase Control planes no longer perform health checks on CRUD upstreams and targets events. To prevent unnecessary cache flips on data planes, Kong now checks `dao:crud` events more strictly and has a new cluster event, `clustering:push_config` for configuration pushes. These updates allow Kong to filter invalidation events that do not actually require a database change. Furthermore, the clustering module does not subscribe to the generic `invalidations` event, which has a more broad scope than database entity invalidations. Data Planes ignore null fields coming from Control Planes when doing schema validation. Kong now includes the source in error logs produced by Control Planes. Data Plane config hash calculation and checking is more consistent now: it is impervious to changes in table iterations, hashes are calculated in both CP and DP, and DPs send pings more immediately and with the new hash now All targets are returned by the Admin API now, including targets with a `weight=0`, or disabled targets. Before disabled targets were not included in the output when users attempted to list all targets. Then when users attempted to add the targets again, they received an error message telling them the targets already existed. Upserting existing targets no longer fails. Before, because of updates made to target configurations since Kong v2.2.0, upserting older configurations would fail. This fix allows older configurations to be imported. The last balancer attempt is now correctly logged. Before balancer tries were saved when retrying, which meant the last retry state was not saved since there were no more retries. This update saves the failure state so it can be correctly logged. Kong now ensures that the correct upstream event is removed from the queue when updating the balancer state. The `prefix` argument in the `kong stop` command now takes precedence over environment variables, as it does in the `kong start` command. Declarative configurations now correctly parse custom plugin entities schemas with attributes called "plugins". Before when using declarative configurations, users with custom plugins that included a "plugins" field would encounter startup exceptions. With this fix, the declarative configuration can now distinguish between plugins schema and custom plugins fields. The stream access log configuration options are now properly separated from the HTTP access log. Before when users used Kong with TCP, they couldnt use a custom log format. With this fix, `proxystreamaccesslog` and `proxystreamerrorlog` have been added to differentiate stream access log from the HTTP subsystem. See and in the Configuration Property Reference for more information. Kong no longer assumes that `/?/init.lua` is in the Lua path when doing migrations. Before, when users created a custom plugin in a non-standard location and set `luapackagepath = /usr/local/custom/?.lua`, migrations failed. Migrations failed because the Kong core file is `init.lua` and it is required as part of `kong.plugins.<name>.migrations`. With this fix, migrations no longer expect `init.lua` to be a part of the

Kong no longer emits errors when doing `ALTER COLUMN` operations in Apache Cassandra 4.0. With this update, `kong.response.get_XXX()` functions now work in the log phase on external plugins. Before `kong.response.get_XXX()` functions required data from the response object, which was not accessible in the post-log timer used to call log handlers in external plugins. Now these functions work by accessing the required data from the set saved at the start of the log phase. See in the Plugin Development Kit for more information. External plugins handle certain error conditions better while the Kong balancer is being refreshed. Before when an `instance_id` of an external plugin changed, and the plugin instance attempted to reset and retry, it was failing because of a typo in the comparison. . Thanks, ! With this release, `kong.log`'s phase checker now accounts for the existence of the new `response` pseudo-phase. Before users may have erroneously received a safe runtime error for using a function out-of-place in the PDK. Kong no longer sandboxes the `string.rep` function. Before `string.rep` was sandboxed to disallow a single operation from allocating too much memory. However, a single operation allocating too much memory is no longer an issue because in LuaJIT there are no debug hooks and it is trivial to implement a loop to allocate memory on every single iteration. Additionally, since the `string` table is global and obtainable by any sandboxed string, its sandboxing provoked issues on global state. The `kong.pdk.node` function can now correctly iterates over all the shared dict metrics. Before this fix, users using the `kong.pdk.node` function could not see all shared dict metrics under the Stream subsystem. All custom plugins that are using the deprecated `BasePlugin` class have to remove this inheritance. LDAP-auth: The LDAP Authentication schema now includes a default value for the `config.ldap_port` parameter that matches the documentation. Before the plugin documentation section included a reference to a default value for the LDAP port; however, the default value was not included in the plugin schema. Prometheus: The Prometheus plugin exporter now attaches subsystem labels to memory stats. Before, the HTTP and Stream subsystems were not distinguished, so their metrics were interpreted as duplicate entries by Prometheus. https://github.com/Kong/kong-plugin-prometheus/pull/118 External Plugins: the return code 127 (command not found) is detected and appropriate error is returned Released 2021/05/11 This is a patch release in the 2.4 series. Being a patch release, it strictly contains bugfixes. There are no new features or breaking changes. :warning: Starting with this release, Kong packages are no longer distributed through Bintray. Please download from . Bump `luasec` from 1.0.0 to 1.0.1 Bump `prometheus` plugin from 1.2.0 to 1.2.1 Ensure healthchecks and balancers are not created on control plane nodes. Optimize URL normalization code. Fix issue where control plane nodes would needlessly invalidate and send new configuration to data plane nodes. Ensure HTTP code `405` is handled by Kong's error page. Ensure errors in plugins `init_worker` do not break Kong's worker initialization. Fix issue where two subsequent TLS keepalive requests would lead to incorrect plugin execution. Ensure Targets upsert operation behaves similarly to other entities' upsert method. Ensure failed balancer retry is saved and accounted for in log data. Ensure `kong start` and `kong stop` prioritize CLI flag `--prefix` over environment variable `KONG_PREFIX`. Ensure Stream subsystem allows for configuration of access logs format. Ensure targets with weight 0 are displayed in the Admin API. Ensure new `response` phase is accounted for in phase checkers. Ensure plugins written in languages other than Lua can use `kong.response.get_*` methods - e.g., `kong.response.get_status`. `hmac-auth`: enable JIT compilation of authorization header

Released 2021/04/06 This is the final release of Kong 2.4.0, with no breaking changes with respect to the 2.x series. This release includes JavaScript PDK, improved CP/DP updates and UTF-8 Tags, amongst other improvements and fixes. :warning: For Kong 2.4, the required OpenResty version has been bumped to , and the set of patches included has changed, including the latest release of . If you are installing Kong from one of our distribution packages, you are not affected by this change. Note: if you are not using one of our distribution packages and compiling OpenResty from source, you must still apply Kong's [OpenResty patches](https://github.com/Kong/kong-build-tools/tree/master/openresty-build-tools/patches) (and, as highlighted above, compile OpenResty with the new lua-kong-nginx-module). Our repository will allow you to do both easily. Bump luarocks from 3.4.0 to 3.5.0. Bump luasec from 0.9 to 1.0. Bump lua-resty-dns-client from 5.2.1 to 6.0.0. Bump kong-lapis from 1.8.1.2 to 1.8.3.1. Bump pgmoon from 1.11.0 to 1.12.0. Bump lua-resty-openssl from 0.6.9 to 0.7.2. Bump kong-plugin-zipkin from 1.2 to 1.3. Bump kong-prometheus-plugin from 1.0 to 1.2. Bump lua-cassandra from 1.5.0 to 1.5.1 Bump luasyslog from 1.0.0 to 2.0.1 Relaxed version check between Control Planes and Data Planes, allowing Data Planes that are missing minor updates to still connect to the Control Plane. Also, now Data Plane is allowed to have a superset of Control Plane plugins. Allowed UTF-8 in Tags Added support for Online Certificate Status Protocol responder found in cluster. is released alongside with Kong 2.4. It allows users to write Kong plugins in JavaScript and TypeScript. Beta release of Protobuf plugin communication protocol, which can be used in place of MessagePack to communicate with non-Lua plugins. Enabled `ssl_certificate` phase on plugins with stream module. Zipkin: support for Jaeger style uber-trace-id headers. Thanks for the patch! Zipkin: support for OT headers. Thanks for the patch! Zipkin: allow insertion of custom tags on the Zipkin request trace. Zipkin: creation of baggage items on child spans is now possible. Thanks for the patch! JWT: Add ES384 support Thanks for the patch! Several plugins: capability to set new log fields, or unset existing fields, by executing custom Lua code in the Log phase. Changed default values and validation rules for plugins that were not well-adjusted for dbless or hybrid modes. Kong 2.4 ensures that all the Core entities are loaded before loading any plugins. This fixes an error in which Plugins to could not link to or modify Core entities because they would not be loaded yet If needed, `Host` header is now updated between balancer retries, using the value configured in the correct upstream entity. Schema validations now log more descriptive error messages when types are invalid. Thanks for the patch! Kong now ignores tags in Cassandra when filtering by multiple entities, which is the expected behavior and the one already existent when using Postgres databases. `Upgrade` header is not cleared anymore when response `Connection` header contains `Upgrade`. Accept fully-qualified domain names ending in dots. Kong does not try to warmup upstream names when warming up DNS entries. Migrations order is now guaranteed to be always the same. Buffered responses are disabled on connection upgrades. Make entity relationship traverse-order-independent. The host header is updated between balancer retries. The router prioritizes the route with most matching headers when matching headers. Fixed an edge case on multipart/form-data boundary check. Paths are now properly normalized inside Route objects. Do not cache empty upstream name dictionary. Do not assume upstreams do not exist after init phase. Do not overwrite configuration files when running

Now Kong does not leave plugin servers alive after exiting and does not try to start them in the unsupported stream subsystem. Go does not cache `kong.log` methods The `response` phase is included on the list of public phases Config file style and options case are now consistent all around. Added right protobuf MacOS path to enable external plugins in Homebrew installations. Auto-escape upstream path to avoid proxying errors. Ports are now declared as `Int`. oauth2: better handling more cases of client invalid token generation. Thanks for the patch! Zipkin: the w3c parsing function was returning a non-used extra value, and it now early-exits. Thanks for the patch! Zipkin: fixed a bug in which span timestamping could sometimes raise an error. Thanks for the patch! Released 2021/03/05 This is a patch release in the 2.3 series. Being a patch release, it strictly contains bugfixes. The are no new features or breaking changes. Bump OpenSSL from `1.1.1i` to `1.1.1j`. Ensure control plane nodes do not execute healthchecks. Ensure only one worker executes active healthchecks. Declarative config can be now loaded as an inline yaml file by `kong config` (previously it was possible only as a yaml string inside json). JSON declarative config is now parsed with the `cjson` library, instead of with `libyaml`. When using eventual worker consistency now every Nginx worker deals with its upstreams changes, avoiding unnecessary synchronization among workers. Remove `prng_seed` from the Admin API and add PIDs instead. Ensure `kong.log.serialize` properly calculates reported latencies. HMAC-Auth: fix issue where the plugin would check if both a username and signature were specified, rather than either. Released 2021/02/09 This is a patch release in the 2.3 series. Being a patch release, it strictly contains bugfixes. The are no new features or breaking changes. Fix an issue where certain incoming URI may make it possible to bypass security rules applied on Route objects. This fix make such attacks more difficult by always normalizing the incoming request's URI before matching against the Router. Properly validate Lua input in sandbox module. Mark boolean fields with default values as required. `kong migrations` now accepts a `-p`/`--prefix` flag. JWT: disallow plugin on consumers. rate-limiting: improve counters accuracy. Released 2021/01/26 This is a patch release in the 2.3 series. Being a patch release, it strictly contains bugfixes. The are no new features or breaking changes. lua-resty-dns-client was bumped to 5.2.1, which fixes an issue that could lead to a busy loop when renewing addresses. Fixed an issue that made Kong return HTTP 500 Internal Server Error instead of HTTP 502 Bad Gateway on upstream connection errors when using buffered proxying. Released 2021/01/08 This is a new release of Kong, with no breaking changes with respect to the 2.x series, with Control Plane/Data Plane version checks, UTF-8 names for Routes and Services, and a Plugin Servers. :warning: Support for Centos 6 has been removed, as said distro entered EOL on Nov 30. Bump kong-plugin-serverless-functions from 1.0 to 2.1. Bump lua-resty-dns-client from 5.1.0 to 5.2.0. Bump lua-resty-healthcheck from 1.3.0 to 1.4.0. Bump OpenSSL from 1.1.1h to 1.1.1i. Bump `kong-plugin-zipkin` from 1.1 to 1.2. Bump `kong-plugin-request-transformer` from 1.2 to 1.3. Introduce version checks between Control Plane and Data Plane nodes in Hybrid Mode. Sync will be stopped if the major/minor version differ or if installed plugin versions differ between Control Plane and Data Plane nodes. Kong entities with a `name` field now support utf-8 characters. The certificates entity now has `certalt` and `keyalt` fields, used to specify an alternative certificate and key pair. The go-pluginserver `stderr` and `stdout` are now written into Kong's logs. Introduce support for multiple

This feature is backwards-compatible with the existing single Go pluginserver. Introduce a `kong.node.get_hostname` method that returns current's node host name. Introduce a `kong.cluster.get_id` method that returns a unique ID for the current Kong cluster. If Kong is running in DB-less mode without a cluster ID explicitly defined, then this method returns nil. For Hybrid mode, all Control Planes and Data Planes belonging to the same cluster returns the same cluster ID. For traditional database based deployments, all Kong nodes pointing to the same database will also return the same cluster ID. Introduce a `kong.log.setserializevalue`, which allows for customizing the output of `kong.log.serialize`. `http-log`: the plugin now has a `headers` configuration, so that custom headers can be specified for the log request. `key-auth`: the plugin now has two additional boolean configurations: `keyinheader`: if `false`, the plugin will ignore keys passed as headers. `keyinquery`: if `false`, the plugin will ignore keys passed as query arguments. Both default to `true`. `request-size-limiting`: add new configuration `requirecontentlength`, which causes the plugin to ensure a valid `Content-Length` header exists before reading the request body. `serverless-functions`: introduce a sandboxing capability, and it has been enabled by default, where only Kong PDK, OpenResty `ngx` APIs, and Lua standard libraries are allowed. `clientmaxbodysize` and `clientbodybuffersize`, that previously hardcoded to 10m, are now configurable through `nginxadminclientmaxbodysize` and `nginxadminclientbodybuffersize`. Kong-generated SSL privates keys now have `600` file system permission. Properties `sslcert`, `sslcertkey`, `adminssl_cert`, `adminsslcertkey`, `statussslcert`, and `statussslcertkey` is now an array: previously, only an RSA certificate was generated by default; with this change, an ECDSA is also generated. On intermediate and modern cipher suites, the ECDSA certificate is set as the default fallback certificate; on old cipher suite, the RSA certificate remains as the default. On custom certificates, the first certificate specified in the array is used. Kong now runs as a `kong` user if it exists; it said user does not exist in the system, the `nobody` user is used, as before. Fix issue where a Go plugin would fail to read kong.ctx.shared values set by Lua plugins. Properly trigger `dao:delete_by:post` hook. Fix issue where a route that supports both http and https (and has a hosts and snis match criteria) would fail to proxy http requests, as it does not contain an SNI. Fix issue where a `nil` request context would lead to errors `attempt to index local 'ctx'` being shown in the logs Reduced the number of needed timers to active health check upstreams and to resolve hosts. Schemas for full-schema validations are correctly cached now, avoiding memory leaks when reloading declarative configurations. The schema for the upstream entities now limits the highest configurable number of successes and failures to 255, respecting the limits imposed by lua-resty-healthcheck. Certificates for database connections now are loaded in the right order avoiding failures to connect to Postgres databases. Fix issue where `kong reload -c <config>` would fail. Fix issue where the Kong configuration cache would get corrupted. Ensure the log serializer encodes the `tries` field as an array when empty, rather than an object. request-transformer plugin does not allow `null` in config anymore as they can lead to runtime errors. Released 2021/03/01 This is a patch release in the 2.2 series. Being a patch release, it strictly contains bugfixes. The are no new features or breaking changes. `serverless-functions`: introduce a sandboxing capability, enabled by default, where only Kong PDK, OpenResty `ngx` APIs, and some Lua standard libraries are allowed. Read the documentation . Released 2020/12/01 This is a patch release in the 2.2 series. Being a patch release, it strictly contains

The are no new features or breaking changes. Fix issue where Kong would fail to start a Go plugin instance with a `starting instance: nil` error. Fix issue where a route that supports both `http` and `https` (and has a `hosts` and `snis` match criteria) would fail to proxy `http` requests, as it does not contain an SNI. Fix issue where a Go plugin would fail to read `kong.ctx.shared` values set by Lua plugins. Fix issue where gRPC requests would fail to set the `:authority` pseudo-header in upstream requests. Fix issue where `kong config dbimport` and `kong config dbexport` commands would fail if Go plugins were enabled. Thanks for the patch! Released 2020/10/23 This is a new major release of Kong, including new features such as UDP support, Configurable Request and Response Buffering, Dynamically Loading of OS Certificates, and much more. Added support for running Kong as the non-root user kong on distributed systems. :warning: For Kong 2.2, the required OpenResty version has been bumped to , and the the set of patches included has changed, including the latest release of . If you are installing Kong from one of our distribution packages, you are not affected by this change. Bump OpenSSL version from `1.1.1g` to `1.1.1h`. Note: if you are not using one of our distribution packages and compiling OpenResty from source, you must still apply Kong's [OpenResty patches](https://github.com/Kong/kong-build-tools/tree/master/openresty-build-tools/openresty-patches) (and, as highlighted above, compile OpenResty with the new lua-kong-nginx-module). Our repository will allow you to do both easily. :warning: Cassandra 2.x support is now deprecated. If you are still using Cassandra 2.x with Kong, we recommend you to upgrade, since this series of Cassandra is about to be EOL with the upcoming release of Cassandra 4.0. :fireworks: UDP support: Kong now features support for UDP proxying in its stream subsystem. The `"udp"` protocol is now accepted in the `protocols` attribute of Routes and the `protocol` attribute of Services. Load balancing and logging plugins support UDP as well. Configurable Request and Response Buffering: The buffering of requests or responses can now be enabled or disabled on a per-route basis, through setting attributes `Route.requestbuffering` or `Route.responsebuffering` to `true` or `false`. Default behavior remains the same: buffering is enabled by default for requests and responses. Option to Automatically Load OS Certificates: The configuration attribute `luassltrusted_certificate` was extended to accept a comma-separated list of certificate paths, as well as a special `system` value, which expands to the "system default" certificates file installed by the operating system. This follows a very simple heuristic to try to use the most common certificate file in most popular distros. Consistent-Hashing load balancing algorithm does not require to use the entire target history to build the same proxying destinations table on all Kong nodes anymore. Now deleted targets are actually removed from the database and the targets entities can be manipulated by the Admin API as any other entity. Add `X-Forwarded-Path` header: if a trusted source provides a `X-Forwarded-Path` header, it is proxied as-is. Otherwise, Kong will set the content of said header to the request's path. Hybrid mode synchronization performance improvements: Kong now uses a new internal synchronization method to push changes from the Control Plane to the Data Plane, drastically reducing the amount of communication between nodes during bulk updates. The `Upstream.client_certificate` attribute can now be used from proxying: This allows `client_certificate` setting used for mTLS handshaking with the `Upstream` server to be shared easily among different Services. However, `Service.client_certificate` will take precedence over `Upstream.client_certificate` if both are set simultaneously. In previous releases, `Upstream.client_certificate` was only used for mTLS in active health

New `shorthand_fields` top-level attribute in schema definitions, which deprecates `shorthands` and includes type definitions in addition to the shorthand callback. Hybrid Mode: the table of Data Plane nodes at the Control Plane is now cleaned up automatically, according to a delay value configurable via the `clusterdataplanepurgedelay` attribute, set to 14 days by default. Hybrid Mode: Data Plane nodes now apply only the last config when receiving several updates in sequence, improving the performance when large configs are in use. Hybrid Mode: new endpoint `/clustering/data-planes` which returns complete information about all Data Plane nodes that are connected to the Control Plane cluster, regardless of the Control Plane node to which they connected. :warning: The `/clustering/status` endpoint is now deprecated, since it returns only information about Data Plane nodes directly connected to the Control Plane node to which the Admin API request was made, and is superseded by `/clustering/data-planes`. Admin API responses now honor the `headers` configuration setting for including or removing the `Server` header. New function `kong.request.getforwardedprefix`: returns the prefix path component of the request's URL that Kong stripped before proxying to upstream, respecting the value of `X-Forwarded-Prefix` when it comes from a trusted source. `kong.response.exit` now honors the `headers` configuration setting for including or removing the `Server` header. `kong.log.serialize` function now can be called using the stream subsystem, allowing various logging plugins to work under TCP and TLS proxy modes. Requests with `multipart/form-data` MIME type now can use the same part name multiple times. New Response Phase: both Go and Lua pluggins now support a new plugin phase called `response` in Lua plugins and `Response` in Go. Using it automatically enables response buffering, which allows you to manipulate both the response headers and the response body in the same phase. This enables support for response handling in Go, where header and body filter phases are not available, allowing you to use PDK functions such as `kong.Response.GetBody()`, and provides an equivalent simplified feature for handling buffered responses from Lua plugins as well. aws-lambda: bump to version 3.5.0: support for 'isBase64Encoded' flag in Lambda function responses grpc-web: introduce configuration passstrippedpath, which, if set to true, causes the plugin to pass the stripped request path (see the `strip_path` Route attribute) to the upstream gRPC service. rate-limiting: Support for rate limiting by path, by setting the `limit_by = "path"` configuration attribute. Thanks for the patch! correlation-id: the plugin now generates a correlation-id value by default if the correlation id header arrives but is empty. Released 2020/09/18 This is a patch release in the 2.0 series. Being a patch release, it strictly contains bugfixes. The are no new features or breaking changes. Improve graceful exit of Control Plane and Data Plane nodes in Hybrid Mode. datadog, loggly, statsd: fixes for supporting logging TCP/UDP services. Logging plugins: request and response sizes are now reported by the log serializer as number attributes instead of string. prometheus: Remove unnecessary `WARN` log that was seen in the Kong 2.1 series. key-auth: no longer trigger HTTP 400 error when the body cannot be decoded. aws-lambda: respect `skiplargebodies` config setting even when not using AWS API Gateway compatibility. Fix issue where `kong reload` would occasionally leave stale workers locked at 100% CPU. Hybrid Mode: more informative error message when the Control Plane cannot be reached. `kong hybrid gen_cert` now reports "permission denied" errors correctly when it fails to write the certificate files. acl: bumped to

Fix regression in a scenario where an ACL plugin with a `deny` clause was configured for a group that does not exist would cause a HTTP 401 when an authenticated plugin would match the anonymous consumer. The behavior is now restored to that seen in Kong 1.x and 2.0. request-transformer: bumped to 1.2.7 Fix the construction of the error message when a template throws a Lua error. Released 2020/08/19 This is a patch release in the 2.0 series. Being a patch release, it strictly contains bugfixes. The are no new features or breaking changes. Fix behavior of `X-Forwarded-Prefix` header with stripped path prefixes: the stripped portion of path is now added in `X-Forwarded-Prefix`, except if it is `/` or if it is received from a trusted client. Avoid creating unnecessary an index for Postgres. DB-less: fix concurrency issues with `/config` endpoint. It now waits for the configuration to update across workers before returning, and returns HTTP 429 on attempts to perform concurrent updates and HTTP 504 in case of update timeouts. request-transformer: bump from v1.2.5 to v1.2.6 Fix an issue where query parameters would get incorrectly URL-encoded. acl: Fix migration of ACLs table for the Kong 2.1 series. Released 2020/08/13 :whitecheckmark: Update (2020/08/13): This release fixed a balancer bug that may cause incorrect request payloads to be sent to unrelated upstreams during balancer retries, potentially causing responses for other requests to be returned. Therefore it is highly recommended that Kong users running versions `2.1.0` and `2.1.1` to upgrade to this version as soon as possible, or apply mitigation from the section below. Fix a bug that balancer retries causes incorrect requests to be sent to subsequent upstream connections of unrelated requests. Fix an issue where plugins iterator was being built before setting the default workspace id, therefore indexing the plugins under the wrong workspace. Improve reentrancy of Cassandra migrations. Make sure the `kong.response.error` PDK function respects gRPC related content types. Released 2020/08/05 :red_circle: Post-release note (as of 2020/08/13): A faulty behavior has been observed with this change. When Kong proxies using the balancer and a request to one of the upstream `Target` fails, Kong might send the same request to another healthy `Target` in a different request later, causing response for the failed request to be returned. This bug could be mitigated temporarily by disabling upstream keepalive pools. It can be achieved by either: In `kong.conf`, set `upstreamkeepalivepool_size=0`, or Setting the environment `KONGUPSTREAMKEEPALIVEPOOLSIZE=0` when starting Kong with the CLI. Then restart/reload the Kong instance. Thanks Nham Le (@nhamlh) for reporting it in . :whitecheckmark: Update (2020/08/13): A fix to this regression has been released as part of . See the section of the Changelog related to this release for more details. Bump to `0.5.9`. No longer reject valid characters (as specified in the RFC 3986) in the `path` attribute of the Service entity. Fix issue in Cassandra migrations where empty values in some entities would be incorrectly migrated. Fix issue where consumed worker memory as reported by the `kong.node.getmemorystats()` PDK method would be incorrectly reported in kilobytes, rather than bytes, leading to inaccurate values in the `/status` Admin API endpoint (and other users of said PDK method). rate-limiting: fix issue where rate-limiting by Service would result in a global limit, rather than per Service. rate-limiting: fix issue where a TTL would not be set to some Redis keys. Released 2020/07/16 :red_circle: Post-release note (as of 2020/08/13): A faulty behavior has been observed with this change. When Kong proxies using the balancer and a request to one of the upstream `Target` fails, Kong might send the same request to another healthy `Target` in a different request later, causing response for the failed request to be

This bug could be mitigated temporarily by disabling upstream keepalive pools. It can be achieved by either: In `kong.conf`, set `upstreamkeepalivepool_size=0`, or Setting the environment `KONGUPSTREAMKEEPALIVEPOOLSIZE=0` when starting Kong with the CLI. Then restart/reload the Kong instance. Thanks Nham Le (@nhamlh) for reporting it in . :whitecheckmark: Update (2020/08/13): A fix to this regression has been released as part of . See the section of the Changelog related to this release for more details. :gift: Introduce package for Ubuntu 20.04. Add `ca-certificates` to the Alpine Docker image. :warning: The no longer ships with Kong packages; users are encouraged to build it along with their Go plugins. For more info, check out the . :warning: In order to use all Kong features, including the new dynamic upstream keepalive behavior, the required OpenResty version is . If you are installing Kong from one of our distribution packages, this version and all required patches and modules are included. If you are building from source, you must apply Kong's as well as include . Our repository allows you to do both easily. Bump OpenSSL version from `1.1.1f` to `1.1.1g`. Bump from `4.1.3` to `5.0.1`. Bump from `0.2.4` to `0.2.5`. Bump from `0.6.0` to `0.6.2`. Increase maximum allowed payload size in hybrid mode. Targets now support a weight range of 0-65535. :warning: The configuration properties `router_consistency` and `routerupdatefrequency` have been renamed to `worker_consistency` and `workerstateupdate_frequency`, respectively. The new properties allow for configuring the consistency settings of additional internal structures, see below for details. :warning: The `nginxupstreamkeepalive_*` configuration properties have been renamed to `upstreamkeepalive*`. This is due to the introduction of dynamic upstream keepalive pools, see below for details. :warning: The default value of `workerstateupdate_frequency` (previously `routerupdatefrequency`) was changed from `1` to `5`. :warning: Change authentication plugins to standardize on `allow` and `deny` as terms for access control. Previous nomenclature is deprecated and support will be removed in Kong 3.0. ACL: use `allow` and `deny` instead of `whitelist` and `blacklist` bot-detection: use `allow` and `deny` instead of `whitelist` and `blacklist` ip-restriction: use `allow` and `deny` instead of `whitelist` and `blacklist` :fireworks: Asynchronous upstream updates: Kong's load balancer is now able to update its internal structures asynchronously instead of onto the request/stream path. This change required the introduction of new configuration properties and the deprecation of older ones: New properties: `worker_consistency` `workerstateupdate_frequency` Deprecated properties: `router_consistency` `routerupdatefrequency` The new `workerconsistency` property is similar to `routerconsistency` and accepts either of `strict` (default, synchronous) or `eventual` (asynchronous). Unlike its deprecated counterpart, this new property aims at configuring the consistency of all internal structures of Kong, and not only the router. :fireworks: Read-Only Postgres: Kong users are now able to configure a read-only Postgres replica. When configured, Kong will attempt to fulfill read operations through the read-only replica instead of the main Postgres connection. Introducing dynamic upstream keepalive pools. This change prevents virtual host confusion when Kong proxies traffic to virtual services (hosted on the same IP/port) over TLS. Keepalive pools are now created by the `upstream IP/upstream port/SNI/client certificate` tuple instead of `IP/port` only. Users running Kong in front of virtual services should consider adjusting their keepalive settings appropriately. This change required the introduction of new configuration properties and the deprecation of older ones: New properties: `upstreamkeepalivepool_size` `upstreamkeepalivemax_requests` `upstreamkeepaliveidle_timeout` Deprecated properties: `nginxupstreamkeepalive` `nginxupstreamkeepalive_requests` `nginxupstreamkeepalive_timeout` Additionally, this change allows for specifying an indefinite amount of max requests and idle timeout threshold for upstream keepalive connections, a capability that was previously removed by Nginx 1.15.3. The default certificate for the proxy can now be configured via Admin API using the `/certificates`

A special `*` SNI has been introduced which stands for the default certificate. Add support for PKI in Hybrid Mode mTLS. Add `X-Forwarded-Prefix` to set of headers forwarded to upstream requests. Introduce a `_transform` option to declarative configuration, which allows importing basicauth credentials with and without hashed passwords. This change is only supported in declarative configuration format version `2.1`. Add capability to define different consistency levels for read and write operations in Cassandra. New configuration properties `cassandrawriteconsistency` and `cassandrareadconsistency` were introduced and the existing `cassandra_consistency` property was deprecated. Thanks for the patch! Introduce certificate expiry and CA constraint checks to Hybrid Mode certificates (`clustercert` and `clusterca_cert`). Introduce new attributes to the Services entity, allowing for customizations in TLS verification parameters: `tls_verify`: whether TLS verification is enabled while handshaking with the upstream Service `tlsverifydepth`: the maximum depth of verification when validating upstream Service's TLS certificate `ca_certificates`: the CA trust store to use when validating upstream Service's TLS certificate Introduce new attribute `client_certificate` in Upstreams entry, used for supporting mTLS in active health checks. Migrations: add a new `--force` flag to `kong migrations bootstrap`. Introduce configuration property `dbcacheneg_ttl`, allowing the configuration of negative TTL for DB entities. Thanks for the patch! Support `kong.response.exit` in Stream (L4) proxy mode. Introduce `kong.request.getforwardedpath` method, which returns the path component of the request's URL, but also considers `X-Forwarded-Prefix` if it comes from a trusted source. Introduce `kong.response.error` method, that allows PDK users to exit with an error while honoring the Accept header or manually forcing a content-type. Introduce `kong.client.tls` module, which provides the following methods for interacting with downstream mTLS: `kong.client.tls.requestclientcertificate()`: request client to present its client-side certificate to initiate mutual TLS authentication between server and client. `kong.client.tls.disablesessionreuse()`: prevent the TLS session for the current connection from being reused by disabling session ticket and session ID for the current TLS connection. `kong.client.tls.getfullclientcertificatechain()`: return the PEM encoded downstream client certificate chain with the client certificate at the top and intermediate certificates (if any) at the bottom. Introduce `kong.log.serialize` method. Introduce new methods to the `kong.service` PDK module: `kong.service.settlsverify()`: set whether TLS verification is enabled while handshaking with the upstream Service `kong.service.settlsverify_depth()`: set the maximum depth of verification when validating upstream Service's TLS certificate `kong.service.settlsverify_store()`: set the CA trust store to use when validating upstream Service's TLS certificate :fireworks: New Plugin: introduce the , allowing clients to consume gRPC services via the gRPC-Web protocol. :fireworks: New Plugin: introduce the , allowing access to upstream gRPC services through a plain HTTP request. Go: add getter and setter methods for `kong.ctx.shared`. Add `X-Credential-Identifier` header to the following authentication plugins: basic-auth key-auth ldap-auth oauth2 Rate-Limiting: auto-cleanup expired rate-limiting metrics in Postgres. OAuth2: add ability to persist refresh tokens throughout their life cycle. Thanks for the patch! IP-Restriction: add support for IPv6. OAuth2: add support for PKCE. Thanks for the patch! OAuth2: allow optional hashing of client secrets. aws-lambda: bump from v3.1.0 to v3.4.0 Add `host` configuration to allow for custom Lambda endpoints. zipkin: bump from 0.2 to 1.1.0 Add support for B3 single header Add `traceidbytecount` config option Add support for W3C header Add new option `header_type` serverless-functions: bump from 0.3.1 to 1.0.0 Add ability to run functions in each request processing phase. prometheus: bump from 0.7.1 to 0.9.0 Performance: significant improvements in throughput and CPU usage. Expose healthiness of upstreams targets. Thanks for the patch! rate-limiting: allow rate-limiting by custom header. Thanks for the patch! session: bumped from 2.3.0 to 2.4.0. Fix memory leak when loading a declarative configuration that fails schema validation. Fix migration issue where the index for the `ca_certificates` table would fail to be

Fix issue where DNS resolution would fail in DB-less mode. Disallow `PATCH` on `/upstreams/:upstreams/targets/:targets` Go: fix issue where instances of the same Go plugin applied to different Routes would get mixed up. Strip `Authorization` value from logged headers. Values are now shown as `REDACTED`. . ACL: respond with HTTP 401 rather than 403 if credentials are not provided. ldap-auth: set credential ID upon authentication, allowing subsequent plugins (e.g., rate-limiting) to act on said value. ldap-auth: hash the cache key generated by the plugin. zipkin: bump from 0.2 to 1.1.0 Stopped tagging non-erroneous spans with `error=false`. Changed the structure of `localEndpoint` and `remoteEndpoint`. Store annotation times in microseconds. Prevent an error triggered when timing-related kong variables were not present. aws-lambda: AWS regions are no longer validated against a hardcoded list; if an invalid region name is provided, a proxy Internal Server Error is raised, and a DNS resolution error message is logged. Released 2020/06/30 Bump OpenSSL version from `1.1.1f` to `1.1.1g`. Bump from version from `0.2.0` to `0.3.2`, leveraging `0.3.1`. See the . Fix a race condition leading to random config fetching failure in DB-less mode. Fix issue where a respawned worker would not use the existing configuration in DB-less mode. Fix issue where declarative configuration would fail with the error: `Cannot serialise table: excessively sparse array`. Targets now support a weight range of 0-65535. Make kong.ctx.plugin light-thread safe Thanks for the assistance! Go: fix issue with Go plugins where the plugin instance would be intermittently killed. Thanks for the patch! Auto-convert `config.anonymous` from empty string to the `ngx.null` value. Fix issue where DB-less wouldn't correctly validate input with missing IDs, names, or cache key. Fix issue where a request to the upstream health endpoint would fail with HTTP 500 Internal Server Error. Fix issue where providing a declarative configuration file containing fields with explicit null values would result in an error. Fix issue where the balancer wouldn't be built for all workers. Fix issue where a declarative configuration file with primary keys specified as numbers would result in an error. Fix issue where the Postgres password from the Kong configuration file would be truncated if it contained a `#` character. Fix issue where a `PUT` request on `/upstreams/:upstreams/targets/:targets` would result in HTTP 500 Internal Server Error. Stop request processing flow if body encoding fails. Ensure `kong.service.set_target()` includes the port number if a non-default port is used. Go: fix issue where the go-pluginserver would not reload Go plugins' configurations. Thanks for the patch! basic-auth: avoid fetching credentials when password is not given. Thanks for the patch! cors: avoid overwriting upstream response `Vary` header; new values are now added as additional `Vary` headers. Thanks for the patch! Released 2020/04/22 Disable JIT mlcache:get_bulk() on ARM64 Don't incrementing log counters on unexpected errors Invalidate target history at cleanup so balancers stay synced Set a log prefix with the upstream name Fix memory leaks when loading a declarative config that fails schema validation Fix some balancer and cluster_events issues Send declarative config updates to stream subsystem via Unix domain Now when using declarative configurations the cache is purged on reload, cleaning any references to removed entries Released 2020/04/06 This is a patch release in the 2.0 series. Being a patch release, it strictly contains performance improvements and bugfixes. The are no new features or breaking changes. Setting the target weight to 0 does not automatically remove the upstream. . The plugins iterator is now always fully built, even if the initialization of any of them fails. . Fixed the load of `dnsnotfoundttl` and `dnserror_ttl` configuration options.

Consumers and tags are properly warmed-up from the plugins' perspective, i.e. they are loaded to the cache space that plugins access. . Customized error messages don't affect subsequent default error responses now. . Fixed the `luapackagepath` option precedence over `LUA_PATH` environment variable. . Support to Nginx binary upgrade by correctly handling the `USR2` signal. . Fixed the logrotate configuration file with the right line terminators. . Thanks, Fixed the `sni is duplicated` error when sending multiple `SNIs` as body arguments and an `SNI` on URL that matched one from the body. . Released 2020/02/27 This is a patch release in the 2.0 series. Being a patch release, it strictly contains performance improvements and bugfixes. The are no new features or breaking changes. Fix issue related to race condition in Cassandra select each method . Thanks, ! Fix issue related to running control plane under multiple Nginx workers . Don't change route paths when marshaling . Fix propagation of posted health across workers . Use proper units for timeouts with cassandra . Fix broken SNI based routing in L4 proxy mode . Enable the ACME plugin by default . Accept consumer username in anonymous field . Released 2020/02/04 This is a patch release in the 2.0 series. Being a patch release, it strictly contains performance improvements and bugfixes. The are no new features or breaking changes. Migrations include the configured Lua path now . Hop-by-hop headers to not clear upgrade header on upgrade . Balancers now properly check if a response is produced by an upstream . Thanks, ! Kong correctly logs an error message when the Lua VM cannot allocate memory Thanks, ! Schema validations work again in DB-less mode . oauth2: handle `Authorization` headers with missing `access_token` correctly. . Thanks, ! oauth2: hash oauth2_tokens cache key via the DAO Released 2020/01/20 This is a new major release of Kong, including new features such as Hybrid mode, Go language support for plugins and buffered proxying, and much more. Kong 2.0.0 removes the deprecated service mesh functionality, which was been retired in favor of , as Kong continues to focus on its core gateway capabilities. Please note that Kong 2.0.0 also removes support for migrating from versions below 1.0.0. If you are running Kong 0.x versions below 0.14.1, you need to migrate to 0.14.1 first, and once you are running 0.14.1, you can migrate to Kong 1.5.0, which includes special provisions for migrating from Kong 0.x, such as the `kong migrations migrate-apis` command, and then finally to Kong 2.0.0. :warning: The required OpenResty version is , and the the set of patches included has changed, including the latest release of . If you are installing Kong from one of our distribution packages, you are not affected by this change. Note: if you are not using one of our distribution packages and compiling OpenResty from source, you must still apply Kong's [OpenResty patches](https://github.com/Kong/kong-build-tools/tree/master/openresty-build-tools/openresty-patches) (and, as highlighted above, compile OpenResty with the new lua-kong-nginx-module). Our repository will allow you to do both easily. RPM packages are now signed with our own GPG keys. You can download our public key at https://bintray.com/user/downloadSubjectPublicKey?username=kong Kong now ships with a systemd unit file :fireworks: Hybrid mode for management of control-plane and data-plane nodes. This allows running control-plane nodes using a database and have them deliver configuration updates to DB-less data-plane

:fireworks: Buffered proxying - plugins can now request buffered reading of the service response (as opposed to the streaming default), allowing them to modify headers based on the contents of the body The `transformations` in DAO schemas now also support `on_read`, allowing for two-way (read/write) data transformations between Admin API input/output and database storage. Added `threshold` attribute for health checks Caches for core entities and plugin-controlled entities (such as credentials, etc.) are now separated, protecting the core entities from cache eviction caused by plugin behavior. Cipher suite was updated to the Mozilla v5 release. Better support for using already existing Cassandra keyspaces when migrating Better log messages when plugin modules fail to load `stream_listen` now supports the `backlog` option. The internal cache was split into two independent segments, `kong.corecache` and `kong.cache`. The `corecache` region is used by the Kong core to store configuration data that doesn't change often. The other region is used to store plugin runtime data that is dependent on traffic pattern and user behavior. This change should decrease the cache contention between Kong core and plugins and result in better performance overall. :warning: Note that both structures rely on the already existent `memcachesize` configuration option to set their size, so when upgrading from a previous Kong version, the cache memory consumption might double if this value is not adjusted `kong config init` now accepts a filename argument :fireworks: Extended support for Nginx directive injections via Kong configurations, reducing the needs for custom Nginx templates. New injection contexts were added: `nginxmain`, `nginxevents` and `nginxsupstream_` (`upstream` in `stream` mode). Enable `reuseport` option in the listen directive by default and allow specifying both `reuseport` and `backlog=N` in the listener flags. Check existence of `luassltrusted_certificate` at startup Added `/upstreams/<id>/health?balancer_health=1` attribute for detailed information about balancer health based on health threshold configuration New functions `kong.service.request.enable_buffering`, `kong.service.response.getrawbody` and `kong.service.response.get_body` for use with buffered proxying :fireworks: Go plugin support - plugins can now be written in Go as well as Lua, through the use of an out-of-process Go plugin server. The lifecycle of the Plugin Server daemon for Go language support is managed by Kong itself. :fireworks: New plugin: ACME - Let's Encrypt and ACMEv2 integration with Kong :fireworks: aws-lambda: bumped version to 3.0.1, with a number of new features! :fireworks: prometheus: bumped to version 0.7.0 including major performance improvements zipkin: bumped to version 0.2.1 session: bumped to version 2.2.0, adding `authenticated_groups` support rate-limiting: added experimental support for standardized headers based on the ongoing rate-limiting: added Retry-After header on HTTP 429 responses datadog: report metrics with tags -- Thanks for the patch! request-size-limiting: added `size_unit` configuration option. request-termination: add extra check for `conf.message` before sending response back with body object included. jwt: add `X-Credential-Identifier` header in response -- Thanks for the patch! Correct detection of update upon deleting Targets -- Thanks for the patch! Fix declarative config loading of entities with abstract records Fix sort priority when matching routes by longest prefix Detect changes in Routes that happen halfway through a router update Corrected the behavior when overwriting a Service configuration using the `url` shorthand :warning: Removed Service Mesh support - That has been deprecated in Kong 1.4 and made off-by-default already, and the code is now gone in 2.0. For Service Mesh, we now have , which is something designed for Mesh patterns from day one, so we feel at peace with removing Kong's native Service Mesh functionality and focus on its core capabilities as a gateway. Routes using `tls` are now supported in stream mode by adding an entry in `stream_listen` with the `ssl` keyword enabled. As part of service mesh removal, serviceless proxying was removed. You can still set `service = null` when creating a route for use with serverless plugins such as `aws-lambda`, or

Removed the `origins` property which was used for service mesh. Removed the `transparent` property which was used for service mesh. Removed the `nginx_optimizations` property; the equivalent settings can be performed via Nginx directive injections. The Nginx directive injection prefixes `nginxhttpupstream_` and `nginxhttpstatus` were renamed to `nginxupstream_` and `nginxstatus` respectively. Removed the Sidecar Injector plugin which was used for service mesh. Released 2020/02/19 This is a patch release over 1.5.0, fixing a minor issue in the `kong migrations migrate-apis` command, which assumed execution in a certain order in the migration process. This now allows the command to be executed prior to running the migrations from 0.x to 1.5.1. Do not assume new fields are already available when running `kong migrations migrate-apis` Released 2020/01/20 Kong 1.5.0 is the last release in the Kong 1.x series, and it was designed to help Kong 0.x users upgrade out of that series and into more current releases. Kong 1.5.0 includes two features designed to ease the transition process: the new `kong migrations migrate-apis` commands, to help users migrate away from old `apis` entities which were deprecated in Kong 0.13.0 and removed in Kong 1.0.0, and a compatibility flag to provide better router compatibility across Kong versions. New `path_handling` attribute in Routes entities, which selects the behavior the router will have when combining the Service Path, the Route Path, and the Request path into a single path sent to the upstream. This attribute accepts two values, `v0` or `v1`, making the router behave as in Kong 0.x or Kong 1.x, respectively. New command `kong migrations migrate-apis`, which converts any existing `apis` from an old Kong 0.x installation and generates Route, Service and Plugin entities with equivalent configurations. The converted routes are set to use `path_handling = v0`, to ensure compatibility. Fixed the routing prioritization that could lead to a match in a lower priority path. Changes in router or plugins entities while the rebuild is in progress now are treated in the next rebuild, avoiding to build invalid iterators. Fixed invalid incorrect calculation of certificate validity period. -- Thanks for the patch! Released 2020/01/09 :warning: This release includes a security fix to address potentially sensitive information being written to the error log file. This affects certain uses of the Admin API for DB-less mode, described below. This is a patch release in the 1.4 series, and as such, strictly contains bugfixes. There are no new features nor breaking changes. Fix the detection of the need for balancer updates when deleting targets -- Thanks for the patch! Fix behavior of longest-path criteria when matching routes Fix incorrect use of cache when using header-based routing -- Thanks for the patch! Do not make a debugging dump of the declarative config input into `error.log` when posting it with `/config` and using `formatversion` as a top-level parameter (instead of embedded in the `config` parameter). Fix incorrect behavior of PUT for /certificates acl: fixed an issue where getting ACLs by group failed when multiple consumers share the same group Released 2019/12/10 This is another patch release in the 1.4 series, and as such, strictly contains bugfixes. There are no new features nor breaking changes. Fixes some corner cases in the balancer behavior http-log: disable queueing when using the default settings, to avoid memory consumption issues prometheus: restore compatibility with version 0.6.0 Released 2019/12/03 This is a patch release in the 1.4 series, and as such, strictly contains bugfixes. There are no new features nor breaking changes. Fixed a memory leak in the balancer -- Thanks for the patch! Removed arbitrary limit on worker

Fixed `preserve_host` behavior for gRPC routes Fix migrations for ttl for OAuth2 tokens Improve handling of errors when creating balancers Fixed an issue with `kong config db_export` when reading entities that are ttl-enabled and whose ttl value is `null`. Various fixes for Admin API behavior , , , http-log: do not impose a retry delay on successful sends Released on 2019/10/22 :warning: All Bintray assets have been renamed from `.all.` / `.noarch.` to be architecture specific namely `.arm64.` and `.amd64.` :fireworks: New configuration option `cassandrarefreshfrequency` to set the frequency that Kong will check for Cassandra cluster topology changes, avoiding restarts when Cassandra nodes are added or removed. New `transformations` property in DAO schemas, which allows adding functions that run when database rows are inserted or updated. The new attribute `hostname` has been added to `upstreams` entities. This attribute is used as the `Host` header when proxying requests through Kong to servers that are listening on server names that are different from the names to which they resolve. New status interface has been introduced. It exposes insensitive health, metrics and error read-only information from Kong, which can be consumed by other services in the infrastructure to monitor Kong's health. This removes the requirement of the long-used workaround to monitor Kong's health by injecting a custom server block. New Admin API response header `X-Kong-Admin-Latency`, reporting the time taken by Kong to process an Admin API request. :warning: New configuration option `service_mesh` which enables or disables the Service Mesh functionality. The Service Mesh is being deprecated and will not be available in the next releases of Kong. New configuration option `routerupdatefrequency` that allows setting the frequency that router and plugins will be checked for changes. This new option avoids performance degradation when Kong routes or plugins are frequently changed. rate-limiting: in addition to consumer, credential, and IP levels, now rate-limiting plugin has service-level support. Thanks for the patch! Now rate-limiting `local` policy counters expire using the shared dictionary's TTL, avoiding to keep unnecessary counters in memory. Thanks for the patch! Authentication plugins have support for tags now. response-transformer plugin now supports renaming response headers. Thanks for the patch! :warning: Service Mesh is known to cause HTTPS requests to upstream to ignore `proxy_ssl*` directives, so it is being discontinued in the next major release of Kong. In this release it is disabled by default, avoiding this issue, and it can be enabled as aforementioned in the configuration section. Fixed an issue on reporting the proper request method and URL arguments on NGINX-produced errors in logging plugins. Fixed an issue where targets were not properly updated in all Kong workers when they were removed. Deadlocks cases in database access functions when using Postgres and cleaning up `cluster_events` in high-changing scenarios were fixed. Fixed issues with tag-filtered GETs on Cassandra-backed nodes. Fixed Lua parsing and error handling in declarative configurations. Automatically escape any unescaped `#` characters in parsed `KONG_*` environment variables. file-log: creates log file with proper permissions when Kong uses declarative config. basic-auth: fixed credentials parsing when using DB-less configurations. jwt: plugin handles empty claims and return the correct error message. Thanks to for the patch! serverless-functions: Lua code in declarative configurations is validated and loaded correctly. request-transformer: fixed bug on removing and then adding request headers with the same name. Released on 2019/08/21 Kong 1.3 is the first version to officially support gRPC proxying! Following our vision for Kong to proxy modern Web services protocols, we are excited for this newest addition to the family of protocols already supported by Kong (HTTP(s), WebSockets, and

As we have recently stated in our latest , more protocols are to be expected in the future. Additionally, this release includes several highly-requested features such as support for upstream mutual TLS, header-based routing (not only `Host`), database export, and configurable upstream keepalive timeouts. :warning: The required OpenResty version has been bumped to . If you are installing Kong from one of our distribution packages, you are not affected by this change. See . With this new version comes a number of improvements: The new . Configurable of upstream keepalive connections by timeout or number of requests. Support for ARM64 architectures. LuaJIT GC64 mode for x86_64 architectures, raising the LuaJIT GC-managed memory limit from 2GB to 128TB and producing more predictable GC performance. :warning: From this version on, the new Nginx module is required to be built into OpenResty for Kong to function properly. This new module allows Kong to support new features such as mutual TLS authentication. If you are installing Kong from one of our distribution packages, you are not affected by this change. Note: if you are not using one of our distribution packages and compiling OpenResty from source, you must still apply Kong's [OpenResty patches](https://github.com/kong/openresty-patches) (and, as highlighted above, compile OpenResty with the new lua-kong-nginx-module). Our new repository will allow you to do both easily. :warning: Bugfixes in the router may, in some edge-cases, result in different Routes being matched. It was reported to us that the router behaved incorrectly in some cases when configuring wildcard Hosts and regex paths (e.g. ). It may be so that you are subject to these bugs without realizing it. Please ensure that wildcard Hosts and regex paths Routes you have configured are matching as expected before upgrading. See , , and for details. Upstream connections are now only kept-alive for 100 requests or 60 seconds (idle) by default. Previously, upstream connections were not actively closed by Kong. This is a (non-breaking) change in behavior, inherited from Nginx 1.15, and configurable via new configuration properties (see below). :warning: The `upstream_keepalive` configuration property is deprecated, and replaced by the new `nginxhttpupstream_keepalive` property. Its behavior is almost identical, but the notable difference is that the latter leverages the [injected Nginx directives](https://konghq.com/blog/kong-ce-nginx-injected-directives/) feature added in Kong 0.14.0. In future releases, we will gradually increase support for injected Nginx directives. We have high hopes that this will remove the occasional need for custom Nginx configuration templates. :fireworks: Native gRPC proxying. Two new protocol types; `grpc` and `grpcs` correspond to gRPC over h2c and gRPC over h2. They can be specified on a Route or a Service's `protocol` attribute (e.g. `protocol = grpcs`). When an incoming HTTP/2 request matches a Route with a `grpc(s)` protocol, the request will be handled by the , and proxied to the upstream Service according to the gRPC protocol specifications. :warning: Note that not all Kong plugins are compatible with gRPC requests yet. :fireworks: Mutual TLS handshake with upstream services. The Service entity now has a new `client_certificate` attribute, which is a foreign key to a Certificate entity. If specified, Kong will use the Certificate as a client TLS cert during the upstream TLS handshake. :fireworks: Route by any request header. The router now has the ability to match Routes by any request header (not only `Host`). The Route entity now has a new `headers` attribute, which is a map of headers names and values. E.g. `{ "X-Forwarded-Host": ["example.org"], "Version": ["2", "3"] }`. :fireworks: Least-connection load-balancing. A new `algorithm` attribute has been added to the Upstream entity. It can be set to `"round-robin"` (default), `"consistent-hashing"`, or

A new core entity, "CA Certificates" has been introduced and can be accessed via the new `/ca_certificates` Admin API endpoint. CA Certificates entities will be used as CA trust store by Kong. Certificates stored by this entity need not include their private key. Healthchecks now use the combination of IP + Port + Hostname when storing upstream health information. Previously, only IP + Port were used. This means that different virtual hosts served behind the same IP/port will be treated differently with regards to their health status. New endpoints were added to the Admin API to manually set a Target's health status. :fireworks: A new section in the `kong.conf` file describes [injected Nginx directives](https://konghq.com/blog/kong-ce-nginx-injected-directives/) (added to Kong 0.14.0) and specifies a few default ones. In future releases, we will gradually increase support for injected Nginx directives. We have high hopes that this will remove the occasional need for custom Nginx configuration templates. :fireworks: New configuration properties allow for controlling the behavior of upstream keepalive connections. `nginxhttpupstreamkeepaliverequests` and `nginxhttpupstreamkeepalivetimeout` respectively control the maximum number of proxied requests and idle timeout of an upstream connection. New flags have been added to the `*_listen` properties: `deferred`, `bind`, and `reuseport`. :fireworks: Database export via the new `kong config db_export` CLI command. This command will export the configuration present in the database Kong is connected to (Postgres or Cassandra) as a YAML file following Kong's declarative configuration syntax. This file can thus be imported later on in a DB-less Kong node or in another database via `kong config db_import`. Many endpoints now support more levels of nesting for ease of access. For example: `/services/:services/routes/:routes` is now a valid API endpoint. The API now accepts `form-urlencoded` payloads with deeply nested data structures. Previously, it was only possible to send such data structures via JSON payloads. :fireworks: New bundled plugin: the [session plugin](https://github.com/Kong/kong-plugin-session) is now bundled in Kong. It can be used to manage browser sessions for APIs proxied and authenticated by Kong. ldap-auth: A new `config.ldaps` property allows configuring the plugin to connect to the LDAP server via TLS. It provides LDAPS support instead of only relying on STARTTLS. jwt-auth: The new `header_names` property accepts an array of header names the JWT plugin should inspect when authenticating a request. It defaults to `["Authorization"]`. : Bumped to 0.4 for minor fixes and performance improvements. : The plugin is now more resilient to Kubernetes schema changes. : Bumped to 0.3 for minor performance improvements. Functions can now have upvalues. : Bumped to 0.4.1 for minor performance improvements. cors: add OPTIONS, TRACE and CONNECT to default allowed methods Thanks to for the patch! New function `kong.service.settlscert_key()`. This functions sets the client TLS certificate used while handshaking with the upstream service. Fix WebSocket protocol upgrades in some cases due to case-sensitive comparisons of the `Upgrade` header. Router: Fixed a bug causing invalid matches when configuring two or more Routes with a plain `hosts` attribute shadowing another Route's wildcard `hosts` attribute. Details of the issue can be seen in . Router: Ensure regex paths always have priority over plain paths. Details of the issue can be seen in . Cleanup of expired rows in PostgreSQL is now much more efficient thanks to a new query plan. Improved various query plans against Cassandra instances by increasing the default page size. cors: ensure non-preflight OPTIONS requests can be proxied. Thanks to for the patch! Consumer references in various plugin entities are now properly marked as required, avoiding credentials that map to no Consumer. hmac-auth: Correct the encoding of HTTP/1.0

oauth2: empty client_id wasn't checked, causing a server error. response-transformer: preserve empty arrays correctly. Fixed an issue when running `kong restart` and Kong was not running, causing stdout/stderr logging to turn off. Ensure PUT works correctly when applied to plugin configurations. Prevent PDK calls from failing in custom content blocks. This fixes a misbehavior affecting the Prometheus plugin. Ensure `kong.response.add_header` works in the `rewrite` phase. Released on 2019/08/14 :warning: This release includes patches to the NGINX core (1.13.6) fixing vulnerabilities in the HTTP/2 module (CVE-2019-9511 CVE-2019-9513 CVE-2019-9516). This is a patch release in the 1.2 series, and as such, strictly contains bugfixes. There are no new features nor breaking changes. Case sensitivity fix when clearing the Upgrade header. Speed up cascade deletes in Cassandra. Released on 2019/06/26 This is a patch release in the 1.2 series, and as such, strictly contains bugfixes. There are no new features nor breaking changes. Fix an issue preventing WebSocket connections from being established by clients. This issue was introduced in Kong 1.1.2, and would incorrectly clear the `Upgrade` response header. Fix a memory usage growth issue in the `/config` endpoint when configuring Upstream entities. This issue was mostly observed by users of the [Kong Ingress Controller](https://github.com/Kong/kubernetes-ingress-controller). Cassandra: ensure serial consistency is `LOCAL_SERIAL` when a datacenter-aware load balancing policy is in use. This fixes unavailability exceptions sometimes experienced when connecting to a multi-datacenter cluster with cross-datacenter connectivity issues. Schemas: fix an issue in the schema validator that would not allow specifying `false` in some schema rules, such a `{ type = "boolean", eq = false }`. Fix an underlying issue with regards to database entities cache keys generation. Ensure the `cassandralocaldatacenter` configuration property is specified when a datacenter-aware Cassandra load balancing policy is in use. request-transformer: fix an issue that would prevent adding a body to requests without one. kubernetes-sidecar-injector: fix an issue causing mutating webhook calls to fail. Released on: 2019/06/07 This release brings improvements to reduce long latency tails, consolidates declarative configuration support, and comes with newly open sourced plugins previously only available to Enterprise customers. It also ships with new features improving observability and usability. This release includes database migrations. Please take a few minutes to read the for more details regarding changes and migrations before planning to upgrade your Kong cluster. :warning: All Bintray repositories have been renamed from `kong-community-edition-` to `kong-`. :warning: All Kong packages have been renamed from `kong-community-edition` to `kong`. For more details about the updated installation, please visit the official docs: . :fireworks: Support for wildcard SNI matching: the `sslcertificateby_lua` phase and the stream `preread` phase) is now able to match a client hello SNI against any registered wildcard SNI. This is particularly helpful for deployments serving a certificate for multiple subdomains. :fireworks: HTTPS Routes can now be matched by SNI: the `snis` Route attribute (previously only available for `tls` Routes) can now be set for `https` Routes and is evaluated by the HTTP router. :fireworks: Native support for HTTPS redirects: Routes have a new `httpsredirectstatus_code` attribute specifying the status code to send back to the client if a plain text request was sent to an `https` Route. The loading of declarative configuration is now done atomically, and with a safety check to verify that the new configuration fits in memory. Schema fields can now be marked as immutable. Support for loading custom DAO strategies from plugins. Support for IPv6 to `tcp` and `tls` Routes. :fireworks: Asynchronous router updates: a new configuration property `router_consistency` accepts two possible values: `strict` and

The former is the default setting and makes router rebuilds highly consistent between Nginx workers. It can result in long tail latency if frequent Routes and Services updates are expected. The latter helps preventing long tail latency issues by instructing Kong to rebuild the router asynchronously (with eventual consistency between Nginx workers). :fireworks: Database cache warmup: Kong can now preload entities during its initialization. A new configuration property (`dbcachewarmup_entities`) was introduced, allowing users to specify which entities should be preloaded. DB cache warmup allows for ahead-of-time DNS resolution for Services with a hostname. This feature reduces first requests latency, improving the overall P99 latency tail. Improved PostgreSQL connection management: two new configuration properties have been added: `pgmaxconcurrent_queries` sets the maximum number of concurrent queries to the database, and `pgsemaphoretimeout` allows for tuning the timeout when acquiring access to a database connection. The default behavior remains the same, with no concurrency limitation. :fireworks: Add declarative configuration hash checking avoiding reloading if the configuration has not changed. The `/config` endpoint now accepts a `check_hash` query argument. Hash checking only happens if this argument's value is set to `1`. :fireworks: Add a schema validation endpoint for entities: a new endpoint `/schemas/:entity_name/validate` can be used to validate an instance of any entity type in Kong without creating the entity itself. :fireworks: Add memory statistics to the `/status` endpoint. The response now includes a `memory` field, which contains the `luashareddicts` and `workersluavms` fields with statistics on shared dictionaries and workers Lua VM memory usage. New function `kong.node.getmemorystats()`. This function returns statistics on shared dictionaries and workers Lua VM memory usage, and powers the memory statistics newly exposed by the `/status` endpoint. :fireworks: Newly open-sourced plugin: the HTTP [proxy-cache plugin](https://github.com/kong/kong-plugin-proxy-cache) (previously only available in Enterprise) is now bundled in Kong. :fireworks: Newly open-sourced plugin capabilities: The [request-transformer plugin](https://github.com/Kong/kong-plugin-request-transformer) now includes capabilities previously only available in Enterprise, among which templating and variables interpolation. Logging plugins: log request TLS version, cipher, and verification status. Plugin development: inheriting from `BasePlugin` is now optional. Avoiding the inheritance paradigm improves plugins' performance. Active healthchecks: `http` checks are not performed for `tcp` and `tls` Services anymore; only `tcp` healthchecks are performed against such Services. Fix an issue where updates in migrations would not correctly populate default values. Improvements in the reentrancy of Cassandra migrations. Fix an issue causing the PostgreSQL strategy to not bootstrap the schema when using a PostgreSQL account with limited permissions. Fix `kong db_import` to support inserting entities without specifying a UUID for their primary key. Entities with a unique identifier (e.g. `name` for Services) can have their primary key omitted. The `kong migrations [up|finish] -f` commands does not run anymore if there are no previously executed migrations. ldap-auth: ensure TLS connections are reused. oauth2: ensured access tokens preserve their `token_expiration` value when migrating from previous Kong versions. Released on: 2019/04/24 This is a patch release in the 1.0 series. Being a patch release, it strictly contains bugfixes. The are no new features or breaking changes. core: address issue where field type "record" nested values reset on update core: correctly manage primary keys of type "foreign" core: declarative config is not parsed on db-mode anymore db-less: Fixed a problem in Kong balancer timing out. db-less: Accept declarative config directly in JSON requests. db-less: do not mis-detect mesh mode db-less: fix crash when field has same name as entity basic-auth: ignore password if nil on basic auth credential patch http-log: Simplify queueing mechanism. Fixed a bug where traces were lost in some cases. request-transformer: validate header values in plugin configuration. Thanks, ! . rate-limiting: added index on rate-limiting

Thanks, ! Released on: 2019/03/28 This release contains a fix for 0.14 Kong clusters using Cassandra to safely migrate to Kong 1.1. Ensure the 0.14 -> 1.1 migration path for Cassandra does not corrupt the database schema. Allow the `kong config init` command to run without a pointing to a prefix directory. Released on: 2019/03/27 This release introduces new features such as Declarative Configuration, DB-less Mode, Bulk Database Import, Tags, as well as Transparent Proxying. It contains a large number of other features and fixes, listed below. Also, the Plugin Development kit also saw a minor updated, bumped to version 1.1. This release includes database migrations. Please take a few minutes to read the for more details regarding changes and migrations before planning to upgrade your Kong cluster. :largeorangediamond: Post-release note (as of 2019/03/28): an issue has been found when migrating from a 0.14 Kong cluster to 1.1.0 when running on top of Cassandra. Kong 1.1.1 has been released to address this issue. Kong clusters running on top of PostgreSQL are not affected by this issue, and can migrate to 1.1.0 or 1.1.1 safely. :fireworks: Kong can now run without a database, using in-memory storage only. When running Kong in DB-less mode, entities are loaded via a declarative configuration file, specified either through Kong's configuration file, or uploaded via the Admin API. :fireworks: Transparent proxying - the `service` attribute on Routes is now optional; a Route without an assigned Service will proxy transparently Support for tags in entities Every core entity now adds a `tags` field New `protocols` field in the Plugin entity, allowing plugin instances to be set for specific protocols only (`http`, `https`, `tcp` or `tls`). It filters out plugins during execution according to their `protocols` field It throws an error when trying to associate a Plugin to a Route which is not compatible, protocols-wise, or to a Service with no compatible routes. New option in `kong.conf`: `database=off` to start Kong without a database New option in `kong.conf`: `declarative_config=kong.yml` to load a YAML file using Kong's new [declarative config format](https://discuss.konghq.com/t/rfc-kong-native-declarative-config-format/2719) New option in `kong.conf`: `pg_schema` to specify Postgres schema to be used The Stream subsystem now supports Nginx directive injections `nginxstream` (or `KONG_NGINX_STREAM_` environment variables) for injecting entries to the `stream` block `nginxsproxy` (or `KONG_NGINX_SPROXY_` environment variables) for injecting entries to the `server` block inside `stream` :fireworks: Bulk database import using the same declarative configuration format as the in-memory mode, using the new command: `kong config db_import kong.yml`. This command upserts all entities specified in the given `kong.yml` file in bulk New command: `kong config init` to generate a template `kong.yml` file to get you started New command: `kong config parse kong.yml` to verify the syntax of the `kong.yml` file before using it New option `--wait` in `kong quit` to ease graceful termination when using orchestration tools New Admin API endpoint: `/config` to replace the configuration of Kong entities entirely, replacing it with the contents of a new declarative config file When using the new `database=off` configuration option, the Admin API endpoints for entities (such as `/routes` and `/services`) are read-only, since the configuration can only be updated via `/config` Admin API endpoints now support searching by tag (for example, `/consumers?tags=example_tag`) You can search by multiple tags: `/services?tags=serv1,mobile` to search for services matching tags `serv1` and `mobile` `/services?tags=serv1/serv2` to search for services matching tags `serv1` or `serv2` New Admin API endpoint `/tags/` for listing entities by tag: `/tags/example_tag` New PDK function: `kong.client.get_protocol` for obtaining the protocol in use during the current request New PDK function:

so plugins can detect whether they are running on the HTTP or Stream subsystem :fireworks: Support for ACL authenticated groups, so that authentication plugins that use a 3rd party (other than Kong) to store credentials can benefit from using a central ACL plugin to do authorization for them The Kubernetes Sidecar Injection plugin is now bundled into Kong for a smoother K8s experience aws-lambda: includes AWS China region. Thanks for the patch! The required OpenResty version is still 1.13.6.2, but for a full feature set including stream routing and Service Mesh abilities with mutual TLS, Kong's must be applied (those patches are already bundled with our official distribution packages). The openresty-patches bundle was updated in Kong 1.1.0 to include the `streamrealipmodule` as well. Kong in HTTP(S) Gateway scenarios does not require these patches. Service Mesh abilities require at least OpenSSL version 1.1.1. In our official distribution packages, OpenSSL has been bumped to 1.1.1b. , Resolve hostnames properly during initialization of Cassandra contact points , Fix health checks for Targets that need two-level DNS resolution (e.g. SRV A IP) Fix serialization of map types in the Cassandra backend Fix target cleanup and cascade-delete for Targets Avoid crash when failing to obtain list of Upstreams Disallow invalid timeout value of 0ms for attributes in Services DAO fix for foreign fields used as primary keys Proper support for `PUT /{entities}/{entity}/plugins/{plugin}` Fix Admin API inferencing of map types using form-encoded Accept UUID-like values in `/consumers?custom_id=` basic-auth, ldap-auth, key-auth, jwt, hmac-auth: fixed status code for unauthorized requests: they now return HTTP 401 instead of 403 tcp-log: remove spurious trailing carriage return Thanks for the patch! jwt: fix `typ` handling for supporting JOSE (JSON Object Signature and Validation) Thanks for the patch! Fixes to the best-effort auto-converter for legacy plugin schemas Released on: 2019/01/31 This is a patch release addressing several regressions introduced some plugins, and improving the robustness of our migrations and core components. Improve Cassandra schema consensus logic when running migrations. Ensure Routes that don't have a `regex_priority` (e.g. if it was removed as part of a `PATCH`) don't prevent the router from being built. Reduce rebuild time of the load balancer by retrieving larger sized pages of Target entities. Ensure schema definitions of Arrays and Sets with `default = {}` are JSON-encoded as `[]`. request-transformer: fix a regression causing the upstream Host header to be unconditionally set to that of the client request (effectively, as if the Route had `preserve_host` enabled). cors: fix a regression that prevented regex origins from being matched. Regexes such as `(.*[.])?example\.org` can now be used to match all sub-domains, while regexes containing `:` will be evaluated against the scheme and port of an origin (i.e. `^https?://(.*[.])?example\.org(:8000)?$`). oauth2: fix a runtime error when using a global token against a plugin not configured as global (i.e. with `global_credentials = false`). Improve performance of the `PUT` method in auth plugins endpoints (e.g. `/consumers/:consumers/basic-auth/:basicauth_credentials`) by preventing a unnecessary read-before-write. Released on: 2019/01/18 This is a hotfix release mainly addressing an issue when connecting to the datastore over TLS (Cassandra and PostgreSQL). Fix an issue that would prevent Kong from starting when connecting to its datastore over TLS. Ensure plugins added via `PUT` get enabled without requiring a restart. zipkin Fix a logging failure when DNS is not resolved. Avoid sending redundant tags. Move `run_on` field to top level plugin schema instead of its config. Released on: 2019/01/16 This is a patch release in the 1.0 series. Being a patch release, it strictly contains performance improvements and bugfixes. The are no new features or breaking

:red_circle: Post-release note (as of 2019/01/17): A regression has been observed with this version, preventing Kong from starting when connecting to its datastore over TLS. Installing this version is discouraged; consider upgrading to . :rocket: Assorted changes for warmup time improvements over Kong 1.0.0 , , , , Ensure `luasslverifydepth` works even when `luassltrustedcertificate` is not set . Thanks for the patch. Ensure Kong starts when only a `stream` listener is enabled Ensure Postgres works with non-`public` schemas Fix an artifact in upstream migrations where `created_at` timestamps would occasionally display fractional values , Fixed issue with HTTP/2 support advertisement Fixed handling of invalid targets in `/upstreams` endpoints for health checks , Fixed the `/plugins/schema/:name` endpoint, as it was failing in some cases (e.g. the `datadog` plugin) and producing incorrect results in others (e.g. `request-transformer`). , , Fix PDK memory leaks in `kong.service.response` and `kong.ctx` , Released on: 2018/12/18 This is a major release, introducing new features such as Service Mesh and Stream Routing support, as well as a New Migrations framework. It also includes version 1.0.0 of the Plugin Development Kit. It contains a large number of other features and fixes, listed below. Also, all plugins included with Kong 1.0 are updated to use version 1.0 of the PDK. As usual, major version upgrades require database migrations and changes to the Nginx configuration file (if you customized the default template). Please take a few minutes to read the [1.0 Upgrade Path](https://github.com/Kong/kong/blob/master/UPGRADE.md) for more details regarding breaking changes and migrations before planning to upgrade your Kong cluster. Being a major version, all entities and concepts that were marked as deprecated in Kong 0.x are now removed in Kong 1.0. The deprecated features are retained in , the final entry in the Kong 0.x series, which is being released simultaneously to Kong 1.0. Kong 1.0 includes all breaking changes from 0.15, as well as the removal of deprecated concepts. The required OpenResty version is still 1.13.6.2, but for a full feature set including stream routing and Service Mesh abilities with mutual TLS, Kong's must be applied (those patches are already bundled with our official distribution packages). Kong in HTTP(S) Gateway scenarios does not require these patches. Service Mesh abilities require at least OpenSSL version 1.1.1. In our official distribution packages, OpenSSL has been bumped to 1.1.1. :warning: The `custom_plugins` directive is removed (deprecated since 0.14.0, July 2018). Use `plugins` instead. Modifications must be applied to the Nginx configuration. You are not affected by this change if you do not use a custom Nginx template. See the for a diff of changes to apply. The default value for `cassandralbpolicy` changed from `RoundRobin` to `RequestRoundRobin`. This helps reducing the amount of new connections being opened during a request when using the Cassandra strategy. :warning: The API entity and related concepts such as the `/apis` endpoint, are removed (deprecated since 0.13.0, March 2018). Use Routes and Services instead. :warning: The old DAO implementation is removed, along with the old schema validation library (`apis` was the last entity using it). Use the new schema format instead in custom plugins. To ease the transition of plugins, the plugin loader in 1.0 includes a best-effort schema auto-translator, which should be sufficient for many plugins. Timestamps now bear millisecond precision in their decimal part. The PDK function `kong.request.get_body` will now return `nil, err, mime` when the body is valid JSON but neither an object nor an array. :warning: The new migrations framework (detailed below) has a different usage (and subcommands) compared to its predecessor. :warning: In the

release, Upstreams, Targets, and Plugins were still implemented using the old DAO and Admin API. In 0.15.0 and 1.0.0, all core entities use the new `kong.db` DAO, and their endpoints have been upgraded to the new Admin API (see below for details). A summary of the changes introduced in the new Admin API: Pagination has been included in all "multi-record" endpoints, and pagination control fields are different than in 0.14.x. Filtering now happens via URL path changes (`/consumers/x/plugins`) instead of querystring fields (`/plugins?consumer_id=x`). Array values can't be coerced from comma-separated strings anymore. They must now be "proper" JSON values on JSON requests, or use a new syntax on form-url-encoded or multipart requests. Error messages have been been reworked from the ground up to be more consistent, precise and informative. The `PUT` method has been reimplemented with idempotent behavior and has been added to some entities that didn't have it. For more details about the new Admin API, please visit the official docs: https://docs.konghq.com/ :warning: The `galileo` plugin has been removed (deprecated since 0.13.0). :warning: Some internal modules that were occasionally used by plugin authors before the introduction of the Plugin Development Kit (PDK) in 0.14.0 are now removed: The `kong.tools.ip` module was removed. Use `kong.ip` from the PDK instead. The `kong.tools.public` module was removed. Use the various equivalent features from the PDK instead. The `kong.tools.responses` module was removed. Please use `kong.response.exit` from the PDK instead. You might want to use `kong.log.err` to log internal server errors as well. The `kong.api.crud_helpers` module was removed (deprecated since the introduction of the new DAO in 0.13.0). Use `kong.api.endpoints` instead if you need to customize the auto-generated endpoints. All bundled plugins' schemas and custom entities have been updated to the new `kong.db` module, and their APIs have been updated to the new Admin API, which is described in the above section. :warning: All plugins migrations have been converted to the new migration framework. Custom plugins must use the new migration framework from 0.15 onwards. Kong's Service Mesh support resulted in a number of additions to Kong's configuration, Admin API, and plugins that deserve their own section in this changelog. Support for TCP & TLS Stream Routes via the new `stream_listen` config option. A new `origins` config property allows overriding hosts from Kong. A `transparent` suffix added to stream listeners allows for setting up a dynamic Service Mesh with `iptables`. Kong instances can now create a shared internal Certificate Authority, which is used for Service Mesh TLS traffic. Plugins get a new `run_on` field to control how they behave in a Service Mesh environment. There is a new phase called `preread`. This is where stream traffic routing is done. A new `dnsvalidttl` property can be set to forcefully override the TTL value of all resolved DNS records. A new `pg_timeout` property can be set to configure the timeout of PostgreSQL connections. `upstream_keepalive` can now be disabled when set to 0. Thanks for the patch. The new `transparent` suffix also applies to the `proxy_listen` directive. :fireworks: New migrations framework. This new implementation supports no-downtime, Blue/Green migrations paths that will help sustain Kong 1.0's stability. It brings a considerable number of other improvements, such as new commands, better support for automation, improved CLI logging, and many more. Additionally, this new framework alleviates the old limitation around multiple nodes running concurrent migrations. See the related PR for a complete list of improvements. :fireworks: Support for TLS 1.3. The support for OpenSSL 1.1.1 (bumped in our official distribution packages) not only enabled Service Mesh features, but also unlocks support for the latest version of the TLS

:fireworks: Support for HTTPS in active healthchecks. :fireworks: Improved router rebuilds resiliency by reducing database accesses in high concurrency scenarios. :fireworks: Significant performance improvements in the core's plugins runloop. PDK improvements: New `kong.node` module. New functions `kong.response.getpathwith_query()` and `kong.request.getstarttime()`. Getters and setters for Service, Route, Consumer, and Credential. `kong.response.get_source()` returns `error` on nginx-produced errors. `kong.response.exit()` can be used in the `header_filter` phase, but only without a body. Schema improvements: New field validators: `distinct`, `ne`, `is_regex`, `contains`, `gt`. Adding a new field which has a default value to a schema no longer requires a migration. :fireworks: Routes now have a `name` field (like Services). Multipart parsing support. Admin API errors expose the name of the current strategy. :fireworks: aws-lambda: Support for Lambda Proxy Integration with the new `isproxyintegration` property. Thanks for the patch! . http-log: Support for buffering logging messages in a configurable logging queue. Most plugins' logic has been rewritten with the PDK instead of using internal Kong functions or ngx_lua APIs. Fix an issue which would insert an extra `/` in the upstream URL when the request path was longer than the configured Route's `path` attribute. Ensure better backwards-compatibility between the new DAO and existing core runloop code regarding null values. Ensure support for Datastax Enterprise 6.x. Thanks for the patch! Various issues with the PostgreSQL DAO strategy were addressed. Various issues related to the new schema library bundled with the new DAO were addressed. PDK improvements: `kong.request.get_path()` and other functions now properly handle cases when `$request_uri` is nil. Ensure the `/certificates` endpoints properly returns all SNIs configured on a given certificate. Ensure the `upstreams/:upstream/targets/...` endpoints returns an empty JSON array (`[]`) instead of an empty object (`{}`) when no targets exist. Improved inferring of arguments with `application/x-www-form-urlencoded`. Fix the handling of defaults values in some cases when using `PATCH`. cors: Ensure `Vary: Origin` is set when `config.credentials` is enabled. Thanks for the patch! Return HTTP 200 instead of 204 for preflight requests. Thanks for the patch! Ensure request origins specified as flat strings are safely validated. acl: Minor performance improvements by ensuring proper caching of computed values. correlation-id: Prevent an error to be thrown when the access phase was skipped, such as on nginx-produced errors. aws-lambda: When the client uses HTTP/2, strip response headers that are disallowed by the protocols. rate-limiting & response-ratelimiting: Improve efficiency by avoiding unnecessary Redis `SELECT` operations. Released on: 2018/12/18 This is the last release in the 0.x series, giving users one last chance to upgrade while still using some of the options and concepts that were marked as deprecated in Kong 0.x and were removed in Kong 1.0. For a list of additions and fixes in Kong 0.15, see the changelog. This release includes all new features included in 1.0 (Service Mesh, Stream Routes and New Migrations), but unlike Kong 1.0, it retains a lot of the deprecated functionality, like the API entity, around. Still, Kong 0.15 does have a number of breaking changes related to functionality that has changed since version 0.14 (see below). If you are starting with Kong, we recommend you to use 1.0.0 instead of this release. If you are already using Kong 0.14, our recommendation is to plan to move to 1.0 -- see the [1.0 Upgrade Path](https://github.com/kong/kong/blob/master/UPGRADE.md) document for details. Upgrading to 0.15.0 is only recommended if you can't do away with the deprecated features but you need some fixes or new features right now. The required OpenResty version is still

but for a full feature set including stream routing and Service Mesh abilities with mutual TLS, Kong's must be applied (those patches are already bundled with our official distribution packages). Kong in HTTP(S) Gateway scenarios does not require these patches. Service Mesh abilities require at least OpenSSL version 1.1.1. In our official distribution packages, OpenSSL has been bumped to 1.1.1. The default value for `cassandralbpolicy` changed from `RoundRobin` to `RequestRoundRobin`. This helps reducing the amount of new connections being opened during a request when using the Cassandra strategy. Timestamps now bear millisecond precision in their decimal part. The PDK function `kong.request.get_body` will now return `nil, err, mime` when the body is valid JSON but neither an object nor an array. :warning: The new migrations framework (detailed in the [1.0.0 changelog](#100)) has a different usage (and subcommands) compared to its predecessor. :warning: In the 0.14.x release, Upstreams, Targets, and Plugins were still implemented using the old DAO and Admin API. In 0.15.0 and 1.0.0, all core entities use the new `kong.db` DAO, and their endpoints have been upgraded to the new Admin API (see below for details). A summary of the changes introduced in the new Admin API: Pagination has been included in all "multi-record" endpoints, and pagination control fields are different than in 0.14.x. Filtering now happens via URL path changes (`/consumers/x/plugins`) instead of querystring fields (`/plugins?consumer_id=x`). Array values can't be coherced from comma-separated strings. They must be "proper" JSON values on JSON requests, or use a new syntax on form-url-encoded or multipart requests. Error messages have been been reworked from the ground up to be more consistent, precise and informative. The `PUT` method has been reimplemented with idempotent behavior and has been added to some entities that didn't have it. For more details about the new Admin API, please visit the official docs: https://docs.konghq.com/ All bundled plugins' schemas and custom entities have been updated to the new `kong.db` module, and their APIs have been updated to the new Admin API, which is described in the above section. :warning: All plugins migrations have been converted to the new migration framework. Custom plugins must use the new migration framework from 0.15 onwards. Kong 0.15.0 contains the same additions as 1.0.0. See the [1.0.0 changelog](#100) for a complete list. Kong 0.15.0 contains the same fixes as 1.0.0. See the for a complete list. Released on: 2018/08/21 jwt: Support for tokens signed with HS384 and HS512. Thanks for the patch. acl: Add a new `hidegroupsheader` configuration option. If enabled, this option prevents the plugin from injecting the `X-Consumer-Groups` header into the upstream request. Thanks for the patch! Prevent some plugins from breaking in subtle ways when manipulating some entities and their attributes. An example of such breaking behavior could be observed when Kong was wrongly injecting `X-Consumer-Username: userdata: NULL` in upstream requests headers, instead of not injecting this header at all. Fix an issue which, in some cases, prevented the use of Kong with Cassandra in environments where DNS load-balancing is in effect for contact points provided as hostnames (e.g. Kubernetes with `cassandracontactpoints = cassandra`). Fix an issue which prevented the use of UNIX domain sockets in some logging plugins, and custom plugins making use of such sockets. Thanks for the patch. Avoid logging false-negative error messages related to worker events. Database connectivity errors are properly prefixed with the database name again (e.g. `[postgres]`). zipkin Allow usage of the plugin with the deprecated "API" entity, and introduce a new `kong.api` tag. Properly report the `kong.credential` tag. Ensure the plugin does not throw errors when no Route was matched. basic-auth: Passwords with whitespaces are not trimmed anymore. Thanks for the

hmac-auth: Ensure backward compatibility for clients generating signatures without the request's querystring, as is the case for Kong versions prior to 0.14.0, which broke this behavior. Users of this plugin on previous versions of Kong can now safely upgrade to the 0.14 family. Thanks for the patch! ldap-auth Set the WWW-Authenticate header authentication scheme accordingly with the `conf.header_type` property, which allows browsers to show the authentication popup automatically. Thanks for the patch. Invalid authentication attempts do not block subsequent valid attempts anymore. This release introduces the first version of the Plugin Development Kit: a Lua SDK, comprised of a set of functions to ease the development of custom plugins. Additionally, it contains several major improvements consolidating Kong's feature set and flexibility, such as the support for `PUT` endpoints on the Admin API for idempotent workflows, the execution of plugins during Nginx-produced errors, and the injection of Nginx directives without having to rely on the custom Nginx configuration pattern! Finally, new bundled plugins allow Kong to better integrate with Cloud Native environments, such as Zipkin and Prometheus. As usual, major version upgrades require database migrations and changes to the Nginx configuration file (if you customized the default template). Please take a few minutes to read the [0.14 Upgrade Path](https://github.com/Kong/kong/blob/master/UPGRADE.md#upgrade-to-014x) for more details regarding breaking changes and migrations before planning to upgrade your Kong cluster. :warning: The required OpenResty version has been bumped to 1.13.6.2. If you are installing Kong from one of our distribution packages, you are not affected by this change. :warning: Support for PostgreSQL 9.4 (deprecated in 0.12.0) is now dropped. :warning: Support for Cassandra 2.1 (deprecated in 0.12.0) is now dropped. :warning: The `servertokens` and `latencytokens` configuration properties have been removed. Instead, a new `headers` configuration properties replaces them and allows for more granular settings of injected headers (e.g. `Server`, `Via`, `X-Kong-*-Latency`, etc...). :warning: New required `luashareddict` entries must be added to the Nginx configuration. You are not affected by this change if you do not use a custom Nginx template. :warning: Other important modifications must be applied to the Nginx configuration. You are not affected by this change if you do not use a custom Nginx template. :warning: The Runscope plugin has been dropped, based on the EoL announcement made by Runscope about their Traffic Inspector product. :warning: The SSL Certificates and SNI entities have moved to the new DAO implementation. As such, the `/certificates` and `/snis` endpoints have received notable usability improvements, but suffer from a few breaking changes. :warning: The Consumers entity has moved to the new DAO implementation. As such, the `/consumers` endpoint has received notable usability improvements, but suffers from a few breaking changes. The default value of `dbcachettl` is now `0` (disabled). Now that our level of confidence around the new caching mechanism introduced in 0.11.0 is high enough, we consider `0` (no TTL) to be an appropriate default for production environments, as it offers a smoother cache consumption behavior and reduces database pressure. :fireworks: Serve stale data from the database cache when the datastore cannot be reached. Such stale items are "resurrected" for `dbresurrectttl` seconds (see configuration section). Reduce LRU churning in the database cache against some workloads. :fireworks: Support for injecting Nginx directives via configuration properties (in the `kong.conf` file or via environment variables)! This new way of customizing the Nginx configuration should render obsolete the old way of maintaining a custom Nginx template in most cases! :fireworks: Support for selectively disabling bundled plugins. A new `plugins` configuration property is introduced, and is used to specify which plugins should be loaded by the

Custom plugins should now be specified in this new property, and the `custom_plugins` property is deprecated. If desired, Kong administrators can specify a minimal set of plugins to load (instead of the default, bundled plugins), and improve P99 latency thanks to the resulting decrease in database traffic. The new `headers` configuration property allows for specifying the injection of a new header: `X-Kong-Upstream-Status`. When enabled, Kong will inject this header containing the HTTP status code of the upstream response in the client response. This is particularly useful for clients to distinguish upstream statuses upon rewriting of the response by Kong. A new `dbresurrectttl` configuration property can be set to customize the amount of time stale data can be resurrected for when it cannot be refreshed. Defaults to 30 seconds. Two new Cassandra load balancing policies are available: `RequestRoundRobin` and `RequestDCAwareRoundRobin`. Both policies guarantee that the same peer will be reused across several queries during the lifetime of a request, thus guaranteeing no new connection will be opened against a peer during this request. :fireworks: Execute plugins on Nginx-produced errors. Now, when Nginx produces a 4xx error (upon invalid requests) or 5xx (upon failure from the load balancer to connect to a Service), Kong will execute the response phases of its plugins (`headerfilter`, `bodyfilter`, `log`). As such, Kong logging plugins are not blind to such Nginx-produced errors anymore, and will start properly reporting them. Plugins should be built defensively against cases where their `rewrite` or `access` phases were not executed. :fireworks: Support for cookie-based load balancing! :fireworks: Introduction of the Plugin Development Kit! A set of Lua functions and variables that will greatly ease and speed up the task of developing custom plugins. The Plugin Development Kit (PDK) allows the retrieval and manipulation of the request and response objects, as well as interacting with various core components (e.g. logging, load balancing, DAO, etc...) without having to rely on OpenResty functions, and with the guarantee of their forward-compatibility with future versions of Kong. :fireworks: New bundled plugin: Zipkin! This plugin allows Kong to sample traces and report them to a running Zipkin instance. (See: https://github.com/Kong/kong-plugin-zipkin) :fireworks: New bundled plugin: Prometheus! This plugin allows Kong to expose metrics in the Prometheus Exposition format. Available metrics include HTTP status codes, latencies histogram, bandwidth, and more... (See: https://github.com/Kong/kong-plugin-prometheus) :fireworks: New bundled plugin: Azure Functions! This plugin can be used to invoke [Microsoft Azure Functions](https://azure.microsoft.com/en-us/services/functions/), similarly to the already existing AWS Lambda and OpenWhisk plugins. (See: https://github.com/Kong/kong-plugin-azure-functions) :fireworks: New bundled plugin: Serverless Functions! Dynamically run Lua without having to write a full-fledged plugin. Lua code snippets can be uploaded via the Admin API and be executed during Kong's `access` phase. (See: https://github.com/Kong/kong-plugin-serverless-functions) jwt: Support for limiting the allowed expiration period of JWT tokens. A new `config.maximum_expiration` property can be set to indicate the maximum number of seconds the `exp` claim may be ahead in the future. Thanks for the patch! aws-lambda: Add `us-gov-west-1` to the list of allowed regions. :fireworks: Support for `PUT` in new endpoints (e.g. `/services/{id or name}`, `/routes/{id}`, `/consumers/{id or username}`), allowing the development of idempotent configuration workflows when scripting the Admin API. Support for `PATCH` and `DELETE` on the `/services/{name}`, `/consumers/{username}`, and `/snis/{name}` endpoints. Properly support IPv6 addresses in `proxylisten` and `adminlisten` configuration properties. IPv6 nameservers with a scope are now ignored by the DNS resolver. SRV records without a port number now returns the default port instead of `0`. Ensure DNS-based round robin load balancing starts at a randomized position to prevent all Nginx workers from starting with the same peer. Properly report timeouts in passive health

Previously, connection timeouts were counted as `tcp_failures`, and upstream timeouts were ignored. Health check users should ensure that their `timeout` settings reflect their intended behavior. Ensure active health check probe requests send the `Host` header. Overall, more reliable health checks healthiness counters behavior. Do not set `Content-Type` headers on HTTP 204 No Content responses. Ensure the PostgreSQL connector of the new DAO (used by Services, Routes, Consumers, and SSL certs/SNIs) is now fully re-entrant and properly behaves in busy workloads (e.g. scripting requests to the Admin API). Properly route HTTP/1.0 requests without a Host header when using the old deprecated "API" entity. Ensure that all Kong-produced errors respect the `headers` configuration setting (previously `server_tokens`) and do not include the `Server` header if not configured. Harden an existing Cassandra migration. Prevent the load balancer from needlessly rebuilding its state when creating Targets. Prevent some harmless error logs to be printed during startup when initialization takes more than a few seconds. hmac: Ensure that empty request bodies do not pass validation if there is no digest header. Thanks for the patch! response-transformer: Prevent the plugin from throwing an error when its `access` handler did not get a chance to run (e.g. on short-circuited, unauthorized requests). aws-lambda: Ensure logging plugins subsequently run when this plugin terminates. request-termination: Ensure logging plugins subsequently run when this plugin terminates. Requests to `/healthy` and `/unhealthy` endpoints for upstream health checks now properly propagate the new state to other nodes of a Kong cluster. Do not produce an HTTP 500 error when POST-ing to `/services` with an empty `url` argument. Ensure foreign keys are required when creating child entities (e.g. `service.id` when creating a Route). Previously some rows could have an empty `service_id` field. Better type inference in new endpoints (e.g. `/services`, `/routes`, `/consumers`) when using `application/x-www-form-urlencoded` MIME type. This release contains numerous bug fixes and a few convenience features. Notably, a best-effort/backwards-compatible approach is followed to resolve `no memory` errors caused by the fragmentation of shared memory between the core and plugins. Cache misses are now stored in a separate shared memory zone from hits if such a zone is defined. This reduces cache turnover and can increase the cache hit ratio quite considerably. Users with a custom Nginx template are advised to define such a zone to benefit from this behavior: `luashareddict kongdbcache_miss 12m;`. We now ensure that the Cassandra or PostgreSQL instance Kong is connecting to falls within the supported version range. Deprecated versions result in warning logs. As a reminder, Kong 0.13.x supports Cassandra 2.2+, and PostgreSQL 9.5+. Cassandra 2.1 and PostgreSQL 9.4 are supported, but deprecated. HTTP 494 errors thrown by Nginx are now caught by Kong and produce a native, Kong-friendly response. Thanks for the contribution! Report errors when compiling custom Nginx templates. Friendlier behavior of Routes schema validation: PATCH requests can be made without specifying all three of `methods`, `hosts`, or `paths` if at least one of the three is specified in the body. jwt: Support for identity providers using JWKS by ensuring the `config.keyclaimname` values is looked for in the token header. Thanks for the contribution! basic-auth: Allow specifying empty passwords. Thanks and for the contributions! Numerous users have reported `no memory` errors which were caused by circumstantial memory fragmentation. Such errors, while still possible if plugin authors are not careful, should now mostly be

If you are using a custom Nginx template, be sure to define the following shared memory zones to benefit from these fixes: ``` luashareddict kongdbcache_miss 12m; luashareddict kongratelimiting_counters 12m; ``` Redirect Nginx's stdout and stderr output to `kong start` when `nginx_daemon` is enabled (such as when using the Kong Docker image). This also prevents growing log files when Nginx redirects logs to `/dev/stdout` and `/dev/stderr` but `nginx_daemon` is disabled. Set a Service's `port` to `443` when the `url` convenience parameter uses the `https://` scheme. Ensure PATCH requests do not return an error when un-setting foreign key fields with JSON `null`. Ensure the `/plugin/schema/:name` endpoint does not corrupt plugins' schemas. Properly URL-decode path segments of plugins endpoints accepting spaces (e.g. `/consumers/<consumer>/basic-auth/John%20Doe/`). Properly serialize boolean filtering values when using Cassandra. rate-limiting/response-rate-limiting: If defined in the Nginx configuration, will use a dedicated `luashareddict` instead of using the `kong_cache` shared memory zone. This prevents memory fragmentation issues resulting in `no memory` errors observed by numerous users. Users with a custom Nginx template are advised to define such a zone to benefit from this fix: `luashareddict kongratelimiting_counters 12m;`. When using the Redis strategy, ensure the correct Redis database is selected. This issue could occur when several request and response rate-limiting were configured using different Redis databases. Thanks for the patch! key-auth: Respect request MIME type when re-encoding the request body if both `config.keyinbody` and `config.hide_credentials` are enabled. Thanks for the patch! oauth2: Return HTTP 400 on invalid `scope` type. Thanks for the patch! ldap-auth: Ensure the plugin does not throw errors when configured as a global plugin. hmac-auth: Verify signature against non-normalized (`$request_uri`) request line (instead of `$uri`). aws-lambda: Fix a typo in upstream headers sent to the function. We now properly send the `X-Amz-Log-Type` header. This release introduces two new core entities that will improve the way you configure Kong: Routes & Services. Those entities replace the "API" entity and simplify the setup of non-naive use-cases by providing better separation of concerns and allowing for plugins to be applied to specific endpoints. As usual, major version upgrades require database migrations and changes to the Nginx configuration file (if you customized the default template). Please take a few minutes to read the [0.13 Upgrade Path](https://github.com/Kong/kong/blob/master/UPGRADE.md#upgrade-to-013x) for more details regarding breaking changes and migrations before planning to upgrade your Kong cluster. :warning: The `proxylisten` and `adminlisten` configuration values have a new syntax. This syntax is more aligned with that of NGINX and is more powerful while also simpler. As a result, the following configuration values have been removed because superfluous: `ssl`, `admin_ssl`, `http2`, `adminhttp2`, `proxylistenssl`, and `adminlisten_ssl`. :warning: galileo: As part of the Galileo deprecation path, the galileo plugin is not enabled by default anymore, although still bundled with 0.13. Users are advised to stop using the plugin, but for the time being can keep enabling it by adding it to the `custom_plugin` configuration value. :warning: rate-limiting (Cassandra): The default migration for including Routes and Services in plugins will remove and re-create the Cassandra rate-limiting counters table. This means that users that were rate-limited because of excessive API consumption will be able to consume the API until they reach their limit again. There is no such data deletion in PostgreSQL. Note to Docker users: The `latest` tag on Docker Hub now points to the alpine image instead of CentOS. This also applies to the `0.13.0` tag. The OpenResty version shipped with our default packages has been bumped to `1.13.6.1`. The 0.13.0 release should still be compatible with the OpenResty `1.11.2.x` series for the time being. Bumped to `2.0.0`. Bumped to `0.12`. Bumped to `0.5.5`. Bumped to `0.4.0`. :fireworks: Support for control-plane and data-plane modes. The new syntax of `proxylisten` and `adminlisten` supports `off`, which disables either one of those

It is now simpler than ever to make a Kong node "Proxy only" (data-plane) or "Admin only" (control-plane). :fireworks: This release introduces two new entities: Routes and Services. Those entities will provide a better separation of concerns than the "API" entity offers. Routes will define rules for matching a client's request (e.g., method, host, path...), and Services will represent upstream services (or backends) that Kong should proxy those requests to. Plugins can also be added to both Routes and Services, enabling use-cases to apply plugins more granularly (e.g., per endpoint). Following this addition, the API entity and related Admin API endpoints are now deprecated. This release is backwards-compatible with the previous model and all of your currently defined APIs and matching rules are still supported, although we advise users to migrate to Routes and Services as soon as possible. :fireworks: New endpoints: `/routes` and `/services` to interact with the new core entities. More specific endpoints are also available such as `/services/{service id or name}/routes`, `/services/{service id or name}/plugins`, and `/routes/{route id}/plugins`. :fireworks: Our new endpoints (listed above) provide much better responses with regards to producing responses for incomplete entities, errors, etc... In the future, existing endpoints will gradually be moved to using this new Admin API content producer. :fireworks: Improved argument parsing in form-urlencoded requests to the new endpoints as well. Kong now expects the following syntaxes for representing arrays: `hosts[]=a.com&hosts[]=b.com`, `hosts[1]=a.com&hosts[2]=b.com`, which avoid comma-separated arrays and related issues that can arise. In the future, existing endpoints will gradually be moved to using this new Admin API content parser. jwt: `ngx.ctx.authenticatedjwttoken` is available for other plugins to use. statsd: The fields `host`, `port` and `metrics` are no longer marked as "required", since they have a default value. Fix an issue causing nodes in a cluster to use the default health checks configuration when the user configured them from another node (event propagated via the cluster). Increase the default load balancer wheel size from 100 to 10.000. This allows for a better distribution of the load between Targets in general. Fix several issues with application/multipart MIME type parsing of payloads. Fix several issues with the parsing of health checks configuration values. Suppress a memory leak in the core introduced in 0.12.2. Thanks for the report. Load balancers now log DNS errors to facilitate debugging. Reports now can include custom immutable values. The `kong migrations reset` command has a new `--yes` flag. This flag makes the command run non-interactively, and ensures no confirmation prompt will occur. A new endpoint `/upstreams/:upstream_id/health` will return the health of the specified upstream. The `/` endpoint in the Admin API now exposes the `node_id` field. HTTP/1.0 requests without a Host header are routed instead of being rejected. HTTP/1.1 requests without a Host are considered invalid and will still be rejected. Thanks to for the patch! Fix the load balancer initialization when some Targets would contain hostnames. Fix incomplete handling of errors when initializing DAO objects. Remove bogus errors in the logs provoked by healthcheckers between the time they are unregistered and the time they are garbage-collected () and when receiving an HTTP status not tracked by healthy or unhealthy lists (). Fix soft errors not being handled correctly inside the Kong cache. Better handling of already existing Cassandra keyspaces in migrations. . Thanks to for the patch! Ensure `GET /certificates/{uuid}` does not return HTTP 500 when the given identifier does not exist. Thanks to for the patch! This release addresses a few issues encountered with 0.12.0, including one which would prevent upgrading from a previous version. The [0.12 Upgrade

is still relevant for upgrading existing clusters to 0.12.1. Fix a migration between previous Kong versions and 0.12.0. Ensure Lua errors are propagated when thrown in the `access` handler by plugins. This major release focuses on two new features we are very excited about: health checks and hash based load balancing! We also took this as an opportunity to fix a few prominent issues, sometimes at the expense of breaking changes but overall improving the flexibility and usability of Kong! Do keep in mind that this is a major release, and as such, that we require of you to run the migrations step, via the `kong migrations up` command. Please take a few minutes to thoroughly read the [0.12 Upgrade Path](https://github.com/Kong/kong/blob/master/UPGRADE.md#upgrade-to-012x) for more details regarding breaking changes and migrations before planning to upgrade your Kong cluster. Starting with 0.12.0, we are announcing the deprecation of older versions of our supported databases: Support for PostgreSQL 9.4 is deprecated. Users are advised to upgrade to 9.5+ Support for Cassandra 2.1 and below is deprecated. Users are advised to upgrade to 2.2+ Note that the above deprecated versions are still supported in this release, but will be dropped in subsequent ones. :warning: The required OpenResty version has been bumped to 1.11.2.5. If you are installing Kong from one of our distribution packages, you are not affected by this change. :warning: As Kong now executes subsequent plugins when a request is being short-circuited (e.g. HTTP 401 responses from auth plugins), plugins that run in the header or body filter phases will be run upon such responses from the access phase. We consider this change a big improvement in the Kong run-loop as it allows for more flexibility for plugins. However, it is unlikely, but possible that some of these plugins (e.g. your custom plugins) now run in scenarios where they were not previously expected to run. :warning: By default, the Admin API now only listens on the local interface. We consider this change to be an improvement in the default security policy of Kong. If you are already using Kong, and your Admin API still binds to all interfaces, consider updating it as well. You can do so by updating the `adminlisten` configuration value, like so: `adminlisten = 127.0.0.1:8001`. Thanks for the suggestion and the patch. :red_circle: Note to Docker users: Beware of this change as you may have to ensure that your Admin API is reachable via the host's interface. You can use the `-e KONGADMINLISTEN` argument when provisioning your container(s) to update this value; for example, `-e KONGADMINLISTEN=0.0.0.0:8001`. :warning: To reduce confusion, the `/upstreams/:upstreamnameor_id/targets/` has been updated to not show the full list of Targets anymore, but only the ones that are currently active in the load balancer. To retrieve the full history of Targets, you can now query `/upstreams/:upstreamnameor_id/targets/all`. The `/upstreams/:upstreamnameor_id/targets/active` endpoint has been removed. Thanks for tackling this backlog item! :warning: The `orderlist` property of Upstreams has been removed, along with any confusion it may have brought. The balancer is now able to fully function without it, yet with the same level of entropy in its load distribution. :warning: The `$ kong compile` command which was deprecated in 0.11.0 has been removed. :warning: In logging plugins, the `request.request_uri` field has been renamed to `request.url`. :fireworks: Support for health checks! Kong can now short-circuit some of your upstream Targets (replicas) from its load balancer when it encounters too many TCP or HTTP

You can configure the number of failures, or the HTTP status codes that should be considered invalid, and Kong will monitor the failures and successes of proxied requests to each upstream Target. We call this feature passive health checks. Additionally, you can configure active health checks, which will make Kong perform periodic HTTP test requests to actively monitor the health of your upstream services, and pre-emptively short-circuit them. Upstream Targets can be manually taken up or down via two new Admin API endpoints: `/healthy` and `/unhealthy`. :fireworks: Support for hash based load balancing! Kong now offers consistent hashing/sticky sessions load balancing capabilities via the new `hash_*` attributes of the Upstream entity. Hashes can be based off client IPs, request headers, or Consumers! :fireworks: Logging plugins now log requests that were short-circuited by Kong! (e.g. HTTP 401 responses from auth plugins or HTTP 429 responses from rate limiting plugins, etc.) Kong now executes any subsequent plugins once a request has been short-circuited. Your plugin must be using the `kong.tools.responses` module for this behavior to be respected. Kong is now compatible with OpenResty up to version 1.13.6.1. Be aware that the recommended (and default) version shipped with this release is still 1.11.2.5. `$ kong start` now considers the commonly used `/opt/openresty` prefix when searching for the `nginx` executable. Two new endpoints, `/healthy` and `/unhealthy` can be used to manually bring upstream Targets up or down, as part of the new health checks feature of the load balancer. logging plugins: A new field `upstream_uri` now logs the value of the upstream request's path. This is useful to help debugging plugins or setups that aim at rewriting a request's URL during proxying. Thanks for the patch! tcp-log: Support for TLS handshake with the logs recipients for secure transmissions of logging data. jwt: Support for JWTs passed in cookies. Use the new `config.cookie_names` property to configure the behavior to your liking. Thanks for the patch! oauth2 New `config.authheadername` property to customize the authorization header's name. Thanks New `config.refresh_ttl` property to customize the TTL of refresh tokens, previously hard-coded to 14 days. Thanks for the patch! Avoid an error in the logs when trying to retrieve an access token from a request without a body. Thanks for the patch. ldap: New `config.header_type` property to customize the authorization method in the `Authorization` header. Thanks for the patch! Fix a potential vulnerability in which an attacker could read the Kong configuration file with insufficient permissions for a short window of time while Kong is being started. Proper log message upon timeout in `$ kong quit`. The `/certificates` endpoint now properly supports the `snis` parameter in PUT and PATCH requests. Thanks for the contribution! Avoid sending the `HTTP/1.1 415 Unsupported Content Type` response when receiving a request with a valid `Content-Type`, but with an empty payload. basic-auth: Accept passwords containing `:`. Thanks for the patch! Performance improvements, courtesy of key-auth: New endpoints to manipulate API keys. Thanks for the contribution. `/key-auths/` to paginate through all keys. `/key-auths/:credentialkeyor_id/consumer` to retrieve the Consumer associated with a key. basic-auth: New endpoints to manipulate basic-auth credentials. Thanks for the contribution. `/basic-auths/` to paginate through all basic-auth credentials. `/basic-auths/:credentialusernameor_id/consumer` to retrieve the Consumer associated with a credential. jwt: New endpoints to manipulate JWTs. Thanks for the contribution. `/jwts/` to paginate through all JWTs. `/jwts/:jwtkeyor_id/consumer` to retrieve the Consumer associated with a JWT. hmac-auth: New endpoints to manipulate hmac-auth credentials. Thanks for the contribution. `/hmac-auths/` to paginate through all hmac-auth credentials. `/hmac-auths/:hmacusernameor_id/consumer` to retrieve the Consumer associated with a credential. acl: New endpoints to manipulate ACLs. Thanks for the contribution. `/acls/` to paginate through all ACLs. `/acls/:acl_id/consumer` to retrieve the Consumer associated with an

Avoid logging some unharmful error messages related to clustering. Improve performance and memory footprint when parsing multipart request bodies. Add a format check for the `adminlistenssl` property, ensuring it contains a valid port. PUT requests with payloads containing non-existing primary keys for entities now return HTTP 404 Not Found, instead of HTTP 200 OK without a response body. On the `/` endpoint, ensure `enabledincluster` shows up as an empty JSON Array (`[]`), instead of an empty JSON Object (`{}`). Thanks for the patch! hmac-auth: Better parsing of the `Authorization` header to avoid internal errors resulting in HTTP 500. Thanks for the patch! Improve the performance of the rate-limiting and response-rate-limiting plugins when using the Redis policy. Improve the performance of the response-transformer plugin. Drop the `luacodecache` configuration property. This setting has been considered harmful since 0.11.0 as it interferes with Kong's internals. DNS: SRV records pointing to an A record are now properly handled by the load balancer when `preserve_host` is disabled. Such records used to throw Lua errors on the proxy code path. Fixed an edge-case where `preserve_host` would sometimes craft an upstream request with a Host header from a previous client request instead of the current one. Ensure APIs with regex URIs are evaluated in the order that they are created. Fixed a typo that caused the load balancing components to ignore the Upstream slots property. Fixed the verification of self-signed SSL certificates for PostgreSQL and Cassandra in the `kong migrations` command. Self-signed SSL certificates are now properly verified during migrations according to the `luassltrusted_certificate` configuration property. The `/upstream/{upstream}/targets/active` endpoint used to return HTTP `405 Method Not Allowed` when called with a trailing slash. Both notations (with and without the trailing slash) are now supported. bot-detection: Fixed an issue which would prevent the plugin from running and result in an HTTP `500` error if configured globally. ip-restriction: Fixed support for the `0.0.0.0/0` CIDR block. This block is now supported and won't trigger an error when used in this plugin's properties. aws-lambda: Added support to forward the client request's HTTP method, headers, URI, and body to the Lambda function. key-auth: New `runonpreflight` configuration option to control authentication on preflight requests. jwt: New `runonpreflight` configuration option to control authentication on preflight requests. Ensure migrations have valid, unique names to avoid conflicts between custom plugins. Thanks for the patch! Improve migrations reliability for future major releases. Improve the performance of the acl and oauth2 plugins. DNS: SRV records pointing to an A record are now properly handled by the load balancer when `preserve_host` is disabled. Such records used to throw Lua errors on the proxy code path. HTTP `400` errors thrown by Nginx are now correctly caught by Kong and return a native, Kong-friendly response. Fix an edge-case where an API with multiple `uris` and `strip_uri = true` would not always strip the client URI. Fix an issue where Kong would match an API with a shorter URI (from its `uris` value) as a prefix instead of a longer, matching prefix from another API. Fixed a typo that caused the load balancing components to ignore the Upstream `slots` property. Octothorpes (`#`) can now be escaped (`\#`) and included in the Kong configuration values such as your datastore passwords or usernames. The `data` response field of the `/upstreams/{upstream}/targets/active` Admin API endpoint now returns a list (`[]`) instead of an object (`{}`) when no active targets are present. datadog: Avoid a runtime error if the plugin is configured as a global plugin but the downstream request did not match any configured API. Thanks for the fix! ip-restriction: Fixed support for the

CIDR block. This block is now supported and won't trigger an error when used in this plugin's properties. The latest and greatest version of Kong features improvements all over the board for a better and easier integration with your infrastructure! The highlights of this release are: Support for regex URIs in routing, one of the oldest requested features from the community. Support for HTTP/2 traffic from your clients. Kong does not depend on Serf anymore, which makes deployment and networking requirements considerably simpler. A better integration with orchestration tools thanks to the support for non FQDNs in Kong's DNS resolver. As per usual, our major releases include datastore migrations which are considered breaking changes. Additionally, this release contains numerous breaking changes to the deployment process and proxying behavior that you should be familiar with. We strongly advise that you read this changeset thoroughly, as well as the if you are planning to upgrade a Kong cluster. :warning: Numerous updates were made to the Nginx configuration template. If you are using a custom template, you must apply those modifications. See the [0.11 Upgrade Path](https://github.com/Kong/kong/blob/master/UPGRADE.md#upgrade-to-011x) for a complete list of changes to apply. :warning: Migrations are not executed automatically by `kong start` anymore. Migrations are now a manual process, which must be executed via the `kong migrations` command. In practice, this means that you have to run `kong migrations up [-c kong.conf]` in one of your nodes before starting your Kong nodes. This command should be run from a single node/container to avoid several nodes running migrations concurrently and potentially corrupting your database. Once the migrations are up-to-date, it is considered safe to start multiple Kong nodes concurrently. :warning: :fireworks: Serf is not a dependency anymore. Kong nodes now handle cache invalidation events via a built-in database polling mechanism. See the new "Datastore Cache" section of the configuration file which contains 3 new documented properties: `dbupdatefrequency`, `dbupdatepropagation`, and `dbcachettl`. If you are using Cassandra, you should pay a particular attention to the `dbupdatepropagation` setting, as you should not use the default value of `0`. :warning: Kong now requires OpenResty `1.11.2.4`. OpenResty's LuaJIT can now be built with Lua 5.2 compatibility. :warning: Previously, the `X-Forwarded-*` and `X-Real-IP` headers were trusted from any client by default, and forwarded upstream. With the introduction of the new `trusted_ips` property (see the below "Added" section) and to enforce best security practices, Kong does not trust any client IP address by default anymore. This will make Kong not forward incoming `X-Forwarded-*` headers if not coming from configured, trusted IP addresses blocks. This setting also affects the API `check_https` field, which itself relies on trusted `X-Forwarded-Proto` headers only. :warning: The API Object property `httpifterminated` is now set to `false` by default. For Kong to evaluate the client `X-Forwarded-Proto` header, you must now configure Kong to trust the client IP (see above change), and you must explicitly set this value to `true`. This affects you if you are doing SSL termination somewhere before your requests hit Kong, and if you have configured `https_only` on the API, or if you use a plugin that requires HTTPS traffic (e.g. OAuth2). :warning: The internal DNS resolver now honours the `search` and `ndots` configuration options of your `resolv.conf` file. Make sure that DNS resolution is still consistent in your environment, and consider eventually not using FQDNs anymore. :warning: As a result of the Serf removal, Kong is now entirely stateless, and as such, the `/cluster` endpoint has disappeared. :warning: The Admin API `/status` endpoint does not return a count of the database entities

Instead, it now returns a `database.reachable` boolean value, which reflects the state of the connection between Kong and the underlying database. Please note that this flag does not reflect the health of the database itself. :warning: The upstream URI is now determined via the Nginx `$upstreamuri` variable. Custom plugins using the `ngx.req.seturi()` API will not be taken into consideration anymore. One must now set the `ngx.var.upstream_uri` variable from the Lua land. :warning: The `hooks.lua` module for custom plugins is dropped, along with the `database_cache.lua` module. Database entities caching and eviction has been greatly improved to simplify and automate most caching use-cases. See the [Plugins Development Guide](https://getkong.org/docs/0.11.x/plugin-development/entities-cache/) and the [0.11 Upgrade Path](https://github.com/Kong/kong/blob/master/UPGRADE.md#upgrade-to-011x) for more details. :warning: To ensure that the order of execution of plugins is still the same for vanilla Kong installations, we had to update the `PRIORITY` field of some of our bundled plugins. If your custom plugin must run after or before a specific bundled plugin, you might have to update your plugin's `PRIORITY` field as well. The complete list of plugins and their priorities is available on the [Plugins Development Guide](https://getkong.org/docs/0.11.x/plugin-development/custom-logic/). The `kong compile` command has been deprecated. Instead, prefer using the new `kong prepare` command. Performance around DNS resolution has been greatly improved in some cases. Secret values are now generated with a kernel-level, Cryptographically Secure PRNG. The `.kong_env` file created by Kong in its running prefix is now written without world-read permissions. The `marshall_event` function on schemas is now ignored by Kong, and can be safely removed as the new cache invalidation mechanism natively handles safer events broadcasting. :fireworks: Support for regex URIs! You can now define regexes in your APIs `uris` property. Those regexes can have capturing groups which can be extracted by Kong during a request, and accessed later in the plugins (useful for URI rewriting). See the [Proxy Guide](https://getkong.org/docs/0.11.x/proxy/#using-regexes-in-uris) for documentation on how to use regex URIs. :fireworks: Support for HTTP/2. A new `http2` directive now enables HTTP/2 traffic on the `proxylistenssl` address. :fireworks: Support for the `search` and `ndots` configuration options of your `resolv.conf` file. Kong now forwards new headers to your upstream services: `X-Forwarded-Host`, `X-Forwarded-Port`, and `X-Forwarded-Proto`. Support for the PROXY protocol. If the new `realipheader` configuration property is set to `realipheader = proxy_protocol`, then Kong will append the `proxy_protocol` parameter to the Nginx `listen` directive of the Kong proxy port. Support for BDR compatibility in the PostgreSQL migrations. Thanks for the patch! Support for DNS nameservers specified in IPv6 format. A few new DNS configuration properties allow you to tweak the Kong DNS resolver, and in particular, how it handles the resolution of different record types or the eviction of stale records. A new `trusted_ips` configuration property allows you to define a list of trusted IP address blocks that are known to send trusted `X-Forwarded-*` headers. Requests from trusted IPs will make Kong forward those headers upstream. Requests from non-trusted IP addresses will make Kong override the `X-Forwarded-*` headers with its own values. In addition, this property also sets the ngxhttprealipmodule `setrealipfrom` directive(s), which makes Kong trust the incoming `X-Real-IP` header as well, which is used for operations such as rate-limiting by IP address, and that Kong forwards upstream as well. You can now configure the ngxhttprealip_module from the Kong configuration. In addition to `trusted_ips` which sets the `setrealipfrom` directives(s), two new properties, `realip_header` and `realiprecursive` allow you to configure the ngxhttprealip_module directives bearing the same name. Ability to hide Kong-specific response

Two new configuration fields: `servertokens` and `latencytokens` will respectively toggle whether the `Server` and `X-Kong-*-Latency` headers should be sent to downstream clients. New configuration property to tune handling request body data via the `clientmaxbodysize` and `clientbodybuffersize` directives (mirroring their Nginx counterparts). Note these settings are only defined for proxy requests; request body handling in the Admin API remains unchanged. New `errordefaulttype` configuration property. This setting is to specify a MIME type that will be used as the error response body format when Nginx encounters an error, but no `Accept` header was present in the request. The default value is `text/plain` for backwards compatibility. Thanks for the contribution! New `nginx_user` configuration property, which interfaces with the Nginx `user` directive. Thanks for the contribution! New `kong prepare` command to prepare the Kong running prefix (creating log files, SSL certificates, etc...) and allow for Kong to be started via the `nginx` binary. This is useful for environments like containers, where the foreground process should be the Nginx master process. The `kong compile` command has been deprecated as a result of this addition. Ability to retrieve plugins added to a Consumer via two new endpoints: `/consumers/:usernameorid/plugins/` and `/consumers/:usernameorid/plugins/:plugin_id`. Support for JSON `null` in `PATCH` requests to unset a value on any entity. jwt: Support for RS512 signed tokens. Thanks for the patch! rate-limiting/response-ratelimiting: Optionally hide informative response headers. aws-lambda: Define a custom response status when the upstream `X-Amz-Function-Error` header is "Unhandled". Thanks for the contribution! aws-lambda: Add new AWS regions that were previously unsupported. hmac: New option to validate the client-provided SHA-256 of the request body. Thanks for the contribution! hmac: Added support for `enforce_headers` option and added HMAC-SHA256, HMAC-SHA384, and HMAC-SHA512 support. statsd: New metrics and more flexible configuration. Support for prefixes, configurable stat type, and added metrics. datadog: New metrics and more flexible configuration. Support for prefixes, configurable stat type, and added metrics. Kong now ensures that your clients URIs are transparently proxied upstream. No percent-encoding/decoding or querystring stripping will occur anymore. Fix an issue where Kong would match an API with a shorter URI (from its `uris` value) as a prefix instead of a longer, matching prefix from another API. Fix an edge-case where an API with multiple `uris` and `strip_uri = true` would not always strip the client URI. HTTP `400` errors thrown by Nginx are now correctly caught by Kong and return a native, Kong-friendly response. Octothorpes (`#`) can now be escaped (`\#`) and included in the Kong configuration values such as your datastore passwords or usernames. The `data` response field of the `/upstreams/{upstream}/targets/active` Admin API endpoint now returns a list (`[]`) instead of an object (`{}`) when no active targets are present. The `unique` constraint on OAuth2 `client_secrets` has been removed. The `unique` constraint on JWT Credentials `secrets` has been removed. oauth2: When requesting a token from `/oauth2/token`, one can now pass the `clientid` as a request body parameter, while `clientid:client_secret` is passed via the Authorization header. This allows for better integration with some OAuth2 flows proposed out there, such as from Cloudflare Apps. Thanks for the patch! datadog: Avoid a runtime error if the plugin is configured as a global plugin but the downstream request did not match any configured API. Thanks for the fix! Logging plugins: the produced logs `latencies.kong` field used to omit the time Kong spent in its Load Balancing logic, which includes DNS resolution time. This latency is now included in `latencies.kong`. We noticed that some distribution packages were not building OpenResty against a JITable PCRE library. This happened on Ubuntu and RHEL environments where OpenResty was built against the system's PCRE

We now compile OpenResty against a JITable PCRE source for those platforms, which should result in significant performance improvements in regex matching. TLS connections are now handled with a modern list of accepted ciphers, as per the Mozilla recommended TLS ciphers list. See https://wiki.mozilla.org/Security/ServerSideTLS. This behavior is configurable via the newly introduced configuration properties described in the below "Added" section. Plugins: rate-limiting: Performance improvements when using the `cluster` policy. The number of round trips to the database has been limited to the number of configured limits. New `sslciphersuite` and `ssl_ciphers` configuration properties to configure the desired set of accepted ciphers, based on the Mozilla recommended TLS ciphers list. New `proxysslcertificate` and `proxysslcertificate_key` configuration properties. These properties configure the Nginx directives bearing the same name, to set client certificates to Kong when connecting to your upstream services. Proxy and Admin API access and error log paths are now configurable. Access logs can be entirely disabled if desired. Plugins: Logging plugins: The produced logs include a new `tries` field which contains, which includes the upstream connection successes and failures of the load-balancer. key-auth: Credentials can now be sent in the request body. cors: Origins can now be defined as regular expressions. APIs matching: prioritize APIs with longer `uris` when said APIs also define `hosts` and/or `methods` as well. Thanks for the patch. SSL connections to Cassandra can now properly verify the certificate in use (when `cassandrasslverify` is enabled). The DNS resolver no longer sends a A or AAAA DNS queries for SRV records. This should improve performance by avoiding unnecessary lookups. & Plugins All authentication plugins don't throw an error anymore when invalid credentials are given and the `anonymous` user isn't configured. rate-limiting: Effectively use the desired Redis database when the `redis` policy is in use and the `config.redis_database` property is set. cors: The regression introduced in 0.10.1 regarding not sending the `*` wildcard when `conf.origin` was not specified has been fixed. oauth2: properly check the client application ownership of a token before refreshing it. The Kong DNS resolver now honors the `MAXNS` setting (3) when parsing the nameservers specified in `resolv.conf`. Kong now matches incoming requests via the `$request_uri` property, instead of `$uri`, in order to better handle percent-encoded URIS. A more detailed explanation will be included in the below "Fixed" section. Upstream calls do not unconditionally include a trailing `/` anymore. See the below "Added" section for more details. Admin API: The "active targets" endpoint now only return the most recent nonzero weight Targets, instead of all nonzero weight targets. This is to provide a better picture of the Targets currently in use by the Kong load balancer. :fireworks: Plugins can implement a new `rewrite` handler to execute code in the Nginx rewrite phase. This phase is executed prior to matching a registered Kong API, and prior to any authentication plugin. As such, only global plugins (neither tied to an API or Consumer) will execute this phase. Ability for the client to chose whether the upstream request (Kong <-> upstream) should contain a trailing slash in its URI. Prior to this change, Kong 0.10 would unconditionally append a trailing slash to all upstream requests. The added functionality is described in , and was implemented in . Ability to hide Kong-specific response headers. Two new configuration fields: `servertokens` and `latencytokens` will respectively toggle whether the `Server` and `X-Kong-*-Latency` headers should be sent to downstream clients. New `cassandraschemaconsensus_timeout` configuration property, to allow for Kong to wait for the schema consensus of your Cassandra cluster during migrations. Serf commands executed by a running Kong node are now logged in the Nginx error logs with a `DEBUG`

Ensure the required shared dictionaries are defined in the Nginx configuration. This will prevent custom Nginx templates from potentially resulting in a breaking upgrade for users. Admin API: Target Objects can now be deleted with their ID as well as their name. The endpoint becomes: `/upstreams/:nameorid/targets/:targetorid`. Plugins: :fireworks: New Request termination plugin. This plugin allows to temporarily disable an API and return a pre-configured response status and body to your client. Useful for use-cases such as maintenance mode for your upstream services. Thanks to for the contribution. Logging plugins: The produced logs include two new fields: a `consumer` field, which contains the properties of the authenticated Consumer (`id`, `custom_id`, and `username`), if any, and a `tries` field, which includes the upstream connection successes and failures of the load- balancer. http-log: Now set an upstream HTTP basic access authentication header if the configured `conf.http_endpoint` parameter includes an authentication section. Thanks for the contribution. file-log: New `config.reopen` property to close and reopen the log file on every request, in order to effectively rotate the logs. jwt: Returns `401 Unauthorized` on invalid claims instead of the previous `403 Forbidden` status. key-auth: Allow setting API key header names with an underscore. cors: When `config.credentials = true`, we do not send an ACAO header with value `*`. The ACAO header value will be that of the request's `Origin: ` header. Upstream connections over TLS now set their Client Hello SNI field. The SNI value is taken from the upstream `Host` header value, and thus also depends on the `preserve_host` setting of your API. Thanks for the original patch. Correctly match APIs with percent-encoded URIs in their `uris` property. Generally, this change also avoids normalizing (and thus, potentially altering) the request URI when trying to match an API's `uris` value. Instead of relying on the Nginx `$uri` variable, we now use `$request_uri`. Handle a routing edge-case under some conditions with the `uris` matching rule of APIs that would falsely lead Kong into believing no API was matched for what would actually be a valid request. If no API was configured with a `hosts` matching rule, then the `preserve_host` flag would never be honored. The `X-Forwarded-For` header sent to your upstream services by Kong is not set from the Nginx `$proxyaddxforwardedfor` variable anymore. Instead, Kong uses the `$realipremoteaddr` variable to append the real IP address of a client, instead of `$remote_addr`, which can come from a previous proxy hop. CNAME records are now properly being cached by the DNS resolver. This results in a performance improvement over previous 0.10 versions. When using Cassandra, some migrations would not be performed on the same coordinator as the one originally chosen. The same migrations would also require a response from other replicas in a cluster, but were not waiting for a schema consensus beforehand, causing indeterministic failures in the migrations, especially if the cluster's inter-nodes communication is slow. The `cassandra_timeout` configuration property is now correctly taken into consideration by Kong. Correctly trigger plugins configured on the anonymous Consumer for anonymous requests (from auth plugins with the new `config.anonymous` parameter). When multiple auth plugins were configured with the recent `config.anonymous` parameter for "OR" authentication, such plugins would override each other's results and response headers, causing false negatives. Ensure the `cassandracontactpoints` property does not contain any port information. Those should be specified in `cassandra_port`. Thanks for the contribution. Prevent an upstream or legitimate internal error in the load balancing code from throwing a Lua-land error as well. Allow backwards compatibility with custom Nginx configurations that still define the `resolver ${{DNS_RESOLVER}}`

Vales from the Kong `dns_resolver` property will be flattened to a string and appended to the directive. Plugins: hmac: Better handling of invalid base64-encoded signatures. Previously Kong would return an HTTP 500 error. We now properly return HTTP 403 Forbidden. Admin API: Detect conflicts between SNI Objects in the `/snis` and `/certificates` endpoint. The `/certificates` route used to not return the `total` and `data` JSON fields. We now send those fields back instead of a root list of certificate objects. Endpoints with path parameters like `/xxxorid` will now also yield the proper result if the `xxx` field is formatted as a UUID. Most notably, this fixes a problem for Consumers whose `username` is a UUID, that could not be found when requesting `/consumers/{usernameasuuid}`. The "active targets" endpoint does not require a trailing slash anymore. Upstream Objects can now be deleted properly when using Cassandra. :warning: Serf has been downgraded to version 0.7 in our distributions, although versions up to 0.8.1 are still supported. This fixes a problem when automatically detecting the first non-loopback private IP address, which was defaulted to `127.0.0.1` in Kong 0.10.0. Greater versions of Serf can still be used, but the IP address needs to be manually specified in the `cluster_advertise` configuration property. :warning: The parameter `config.origin` is now `config.origins`. :red_circle: Post-release note (as of 2017/05/12): A faulty behavior has been observed with this change. Previously, the plugin would send the `*` wildcard when `config.origin` was not specified. With this change, the plugin does not send the `*` wildcard by default anymore. You will need to specify it manually when configuring the plugin, with `config.origins=*`. This behavior is to be fixed in a future release. :whitecheckmark: Update (2017/05/24): A fix to this regression has been released as part of 0.10.3. See the section of the Changelog related to this release for more details. Admin API: Disable support for TLS/1.0. Admin API: Active targets can be pulled with `GET /upstreams/{name}/targets/active`. Provide a convenience endpoint to disable targets at: `DELETE /upstreams/{name}/targets/{target}`. Under the hood, this creates a new target with `weight = 0` (the correct way of disabling targets, which used to cause confusion). Plugins: cors: Support for configuring multiple Origin domains. Use an LRU cache for Lua-land entities caching to avoid exhausting the Lua VM memory in long-running instances. Avoid potential deadlocks upon callback errors in the caching module for database entities. Relax multipart MIME type parsing. A space is allowed in between values of the Content-Type header. Admin API: Better handling of non-supported HTTP methods on endpoints of the Admin API. In some cases this used to throw an internal error. Calling any endpoint with a non-supported HTTP method now always returns `405 Method Not Allowed` as expected. CLI: Better error handling when missing Serf executable. Fix a bug in the `kong migrations` command that would prevent it to run correctly. Trim list values specified in the configuration file. Align the default configuration file's values to the actual, hard-coded default values to avoid confusion. Plugins: hmac: Generate an HMAC secret value if none is provided. oauth2: Don't try to remove credential values from request bodies if the MIME type is multipart, since such attempts would result in an error. ldap: This plugin should not be applied to a single Consumer, however, this was not properly enforced. It is now impossible to apply this plugin to a single Consumer (as per all authentication plugin). aws-lambda: Support for `us-west-2` region in schema. Kong 0.10 is one of most significant releases to this

It ships with exciting new features that have been heavily requested for the last few months, such as load balancing, Cassandra 3.0 compatibility, Websockets support, internal DNS resolution (A and SRV records without Dnsmasq), and more flexible matching capabilities for APIs routing. On top of those new features, this release received a particular attention to performance, and brings many improvements and refactors that should make it perform significantly better than any previous version. :warning: API Objects (as configured via the Admin API) do not support the `requesthost` and `requesturi` fields anymore. The 0.10 migrations should upgrade your current API Objects, but make sure to read the new [0.10 Proxy Guide](https://getkong.org/docs/0.10.x/proxy) to learn the new routing capabilities of Kong. On the good side, this means that Kong can now route incoming requests according to a combination of Host headers, URIs, and HTTP methods. :warning: Final slashes in `upstream_url` are no longer allowed. :warning: The SSL plugin has been removed and dynamic SSL capabilities have been added to Kong core, and are configurable via new properties on the API entity. See the related PR for a detailed explanation of this change. :warning: Drop the Dnsmasq dependency. We now internally resolve both A and SRV DNS records. :warning: Dropping support for insecure `TLS/1.0` and defaulting `Upgrade` responses to `TLS/1.2`. Bump the compatible OpenResty version to `1.11.2.1` and `1.11.2.2`. Support for OpenResty `1.11.2.2` requires the `--without-luajit-lua52` compilation flag. Separate Admin API and Proxy error logs. Admin API logs are now written to `logs/admin_access.log`. Auto-generates stronger SHA-256 with RSA encryption SSL certificates. :fireworks: Support for Cassandra 3.x. :fireworks: SRV records resolution. :fireworks: Load balancing. When an A or SRV record resolves to multiple entries, Kong now rotates those upstream targets with a Round-Robin algorithm. This is a first step towards implementing more load balancing algorithms. Another way to specify multiple upstream targets is to use the newly introduced `/upstreams` and `/targets` entities of the Admin API. :fireworks: Multiple hosts and paths per API. Kong can now route incoming requests to your services based on a combination of Host headers, URIs and HTTP methods. See the related PR for a detailed explanation of the new properties and capabilities of the new router. :fireworks: Maintain upstream connection pools which should greatly improve performance, especially for HTTPS upstream connections. We now use HTTP/1.1 for upstream connections as well as an nginx `upstream` block with a configurable`keepalive` directive, thanks to the new `nginx_keepalive` configuration property. :fireworks: Websockets support. Kong can now upgrade client connections to use the `ws` protocol when `Upgrade: websocket` is present. Use an in-memory caching strategy for database entities in order to reduce CPU load during requests proxying. Provide negative-caching for missed database entities. This should improve performance in some cases. Support for serving the Admin API over SSL. This introduces new properties in the configuration file: `adminlistenssl`, `adminssl`, `adminssl_cert` and `adminsslcert_key`. Support for upstream connection timeouts. APIs now have 3 new fields: `upstreamconnecttimeout`, `upstreamsendtimeout`, `upstreamreadtimeout` to specify, in milliseconds, a timeout value for requests between Kong and your APIs. Support for clustering key rotation in the underlying Serf process: new `clusterkeyringfile` property in the configuration file. new `kong cluster keys ..` CLI commands that expose the underlying `serf keys ..` commands. Support for `luasocketpool_size` property in configuration file. Plugins: :fireworks: New AWS Lambda plugin. Thanks Tim Erickson for his collaboration on this new addition. Anonymous authentication for auth plugins. When such plugins receive the `config.anonymous=<consumer_id>` property, even non-authenticated requests will be proxied by Kong, with the traditional Consumer headers set to the designated anonymous consumer, but also with a `X-Anonymous-Consumer`

Multiple auth plugins will work in a logical `OR` fashion. and request-transformer: Ability to change the HTTP method of the upstream request. jwt: Support for ES256 signatures. rate-limiting: Ability to select the Redis database to use via the new `config.redis_database` plugin property. Looking for Serf in known installation paths. Including port in upstream `Host` header. Clarify the purpose of the `clusterlistenrpc` property in the configuration file. Thanks Jeremy Monin for the patch. Admin API: Properly Return JSON responses (instead of HTML) on HTTP 409 Conflict when adding Plugins. CLI: Avoid double-prefixing migration error messages with the database name (PostgreSQL/Cassandra). Plugins: Fix fault tolerance logic and error reporting in rate-limiting plugins. CORS: Properly return `Access-Control-Allow-Credentials: false` if `Access-Control-Allow-Origin: *`. key-auth: enforce `key_names` to be proper header names according to Nginx. Correctly put Cassandra sockets into the Nginx connection pool for later reuse. This greatly improves the performance for rate-limiting and response-ratelimiting plugins. Correct length of a year in seconds for rate-limiting and response-ratelimiting plugins. A year was wrongly assumed to only be 360 days long. Prevent misinterpretation of the `%` character in proxied URLs encoding. Thanks Thomas Jouannic for the patch. Properly set the admin IP in the Serf script. Provide negative-caching for missed database entities. This should improve performance in some cases. Plugins: Fix fault tolerance logic and error reporting in rate-limiting plugins. Fixed a performance issue in Cassandra by removing an old workaround that was forcing Cassandra to use LuaSocket instead of cosockets. Fixed an issue that was causing a recursive attempt to stop Kong's services when an error was occurring. Custom plugins are now properly loaded again. Plugins: Galileo: properly encode empty arrays. OAuth 2: implements a missing Postgres migration for `redirect_uri` in every OAuth 2 credential. OAuth 2: safely parse the request body even when no data has been sent. Resolve support for PostgreSQL SSL connections. Ensure `kong start` honors the `--conf` flag is a config file already exists at one of the default locations (`/etc/kong.conf`, `/etc/kong/kong.conf`). Obfuscate sensitive properties from the `/` Admin API route which returns the current node's configuration. Dropping support for OpenResty 1.9.15.1 in favor of 1.11.2.1 Fixed an error (introduced in 0.9.4) in the auto-clustering event Fixed the random string generator that was causing some problems, especially in Serf for clustering. Seed random number generator in CLI. Reducing log noise in the Admin API. Fixed the reports lock implementation that was generating a periodic error message. Added support for Serf 0.8. Properly invalidate global plugins. Correctly report migrations errors. This was caused by an error being thrown from the error handler, and superseding the actual error. [#1605] (https://github.com/Kong/kong/pull/1605) Prevent Kong from silently failing to start. This would be caused by an erroneous error handler. [28f5d10] (https://github.com/Kong/kong/commit/28f5d10) Only report a random number generator seeding error when it is not already seeded. Reduce intra-cluster noise by not propagating keepalive requests events. Admin API: Obfuscates sensitive configuration settings from the `/` route. CLI: Prevent a failed `kong start` to stop an already running Kong node. Remove unset configuration placeholders from the nginx configuration template. This would occur when no Internet connection would be available and would cause Kong to compile an erroneous nginx config. Properly count the number of executed migrations. Plugins: OAuth2: remove the "Kong" mentions in missing `provision_key` error messages. OAuth2: allow to correctly delete applications when using Cassandra. galileo: provide a default `bodySize` value when `log_bodies=true` but the current request/response has no body. Plugins: ACL: allow to retrieve/update/delete an ACL by group name. Basic Authentication: allow to retrieve/update/delete a credential by `username`. HMAC Authentication: allow to retrieve/update/delete a credential by

JWT Authentication: allow to retrieve/update/delete a credential by `key`. Key Authentication: allow to retrieve/update/delete a credential by `key`. OAuth2 Authentication: allow to retrieve/update/delete a credential by `clientid` and tokens by `accesstoken`. Correctly parse configuration file settings containing comments. Prevent third-party Lua modules (and plugins) to override the seed for random number generation. This prevents the creation of conflicting UUIDs. Use `2.0.0` which properly namespaces our fork, avoiding conflicts with other versions of pgmoon, such as the one installed by Lapis. Avoid exposing OpenResty's information on HTTP `4xx` errors. ulimit with `unlimited` value is now properly handled. CLI: Stop third-party services (Dnsmasq/Serf) when Kong could not start. Prefix database migration errors (such as Postgres' `connection refused`) with the database name (`postgres`/`cassandra`) to avoid confusions. Plugins: galileo: Use `Content-Length` header to get request/response body size when `log_bodies` is disabled. Admin API: Revert the `/plugins/enabled` endpoint's response to be a JSON array, and not an Object. The main focus of this release is Kong's new CLI. With a simpler configuration file, new settings, environment variables support, new commands as well as a new interpreter, the new CLI gives more power and flexibility to Kong users and allow for an easier integration in your deployment workflow, as well as better testing for developers and plugins authors. Additionally, some new plugins and performance improvements are included as well as the regular bug fixes. :warning: PostgreSQL is the new default datastore for Kong. If you were using Cassandra and you are upgrading, you need to explicitly set `cassandra` as your `database`. :warning: New CLI, with new commands and refined arguments. This new CLI uses the `resty-cli` interpreter (see ) instead of LuaJIT. As a result, the `resty` executable must be available in your `$PATH` (resty-cli is shipped in the OpenResty bundle) as well as the `bin/kong` executable. Kong does not rely on Luarocks installing the `bin/kong` executable anymore. This change of behavior is taken care of if you are using one of the official Kong packages. :warning: Kong uses a new configuration file, with an easier syntax than the previous YAML file. New arguments for the CLI, such as verbose, debug and tracing flags. We also avoid requiring the configuration file as an argument to each command as per the previous CLI. Customization of the Nginx configuration can now be taken care of using two different approaches: with a custom Nginx configuration template and using `kong start --template <file>`, or by using `kong compile` to generate the Kong Nginx sub-configuration, and `include` it in a custom Nginx instance. Plugins: Rate Limiting: the `continueonerror` property is now called `fault_tolerant`. Response Rate Limiting: the `continueonerror` property is now called `fault_tolerant`. :fireworks: Support for overriding configuration settings with environment variables. :fireworks: Support for SSL connections between Kong and PostgreSQL. :fireworks: Ability to apply plugins with more granularity: per-consumer, and global plugins are now possible. New `kong check` command: validates a Kong configuration file. Better version check for third-party dependencies (OpenResty, Serf, Dnsmasq). Ability to configure the validation depth of database SSL certificates from the configuration file. `request_host`: internationalized url support; utf-8 domain names through punycode support and paths through %-encoding. Implements caching locks when fetching database configuration (APIs, Plugins...) to avoid dog pile effect on cold nodes. Plugins: :fireworks: New bot-detection plugin: protect your APIs by detecting and rejecting common bots and crawlers. correlation-id: new "tracker" generator, identifying requests per worker and connection. request/response-transformer: ability to add strings including colon

rate-limiting: support for new rate-limiting policies (`cluster`, `local` and `redis`), and for a new `limit_by` property to force rate-limiting by `consumer`, `credential` or `ip`. response-rate-limiting: support for new rate-limiting policies (`cluster`, `local` and `redis`), and for a new `limit_by` property to force rate-limiting by `consumer`, `credential` or `ip`. galileo: performance improvements of ALF serialization. ALFs are not discarded when exceeding 20MBs anymore. statsd: new `upstream_stream` latency metric. datadog: new `upstream_stream` latency metric and tagging support for each metric. We now use for UUID generation, which is a pure Lua implementation of . As a result, libuuid is not a dependency of Kong anymore. Sensitive configuration settings are not printed to stdout anymore. Fixed bug that caused nodes to remove themselves from the database when they attempted to join the cluster. Plugins: request-size-limiting: use proper constant for MB units while setting the size limit. OAuth2: security and config validation fixes. request/response-transformer: better validation of fields provided without a value. JWT: handle some edge-cases that could result in HTTP 500 errors. internal new test suite using resty-cli and removing the need to monkey-patch the `ngx` global. custom assertions and new helper methods (`wait_until()`) to gracefully fail in case of timeout. increase atomicity of the testing environment. lighter testing instance, only running 1 worker and not using Dnsmasq by default. This release includes some bugfixes: Switched the log level of the "No nodes found in cluster" warning to `INFO`, that was printed when starting up the first Kong node in a new cluster. Kong now requires OpenResty `1.9.7.5`. New nodes are now properly registered into the `nodes` table when running on the same machine. Fixed a failed error parsing on Postgres. Plugins: Response Transformer: Slashes are now encoded properly, and fixed a bug that hang the execution of the plugin. and JWT: If a value for `algorithm` is missing, it's now `HS256` by default. This problem occurred when migrating from older versions of Kong. OAuth 2.0: Fixed a Postgres problem that was preventing an application from being created, and fixed a check on the `redirect_uri` field. and This release includes bugfixes and minor updates: Support for a simple slash in `request_path`. Plugins: Response Rate Limiting: it now appends usage headers to the upstream requests in the form of `X-Ratelimit-Remaining-{limitname}` and introduces a new `config.blockonfirstviolation` property. Plugins: Mashape Analytics: The plugin is now called "Galileo", and added support for Galileo v3. Postgres now relies on the `search_path` configured on the database and its default value `$user, public`. Kong now properly encodes an empty querystring parameter like `?param=` when proxying the request. The configuration now checks that `cluster.ttlonfailure` is at least 60 seconds. Plugins: Loggly: Fixed an issue that was triggering 400 and 500 errors. JWT: The `TYP` value in the header is not optional and case-insensitive. Request Transformer: Fixed a bug when transforming request headers. OAuth 2.0: Multiple redirect URIs are now supported. IP Restriction: Fixed that prevented the plugin for working properly when added on an API. CORS: Fixed an issue when `config.preflight_continue` was enabled. This release includes some fixes and minor updates: Adds `X-Forwarded-Host` and `X-Forwarded-Prefix` to the upstream request headers. Plugins: Datadog: Added two new metrics, `uniqueusers` and `requestper_user`, that log the consumer information. Fixed a DAO bug that affected full entity updates. Fixed a bug when setting the authentication provider in Cassandra. Updated the Cassandra driver to v0.5.2. Properly enforcing required fields in PUT requests. Fixed a bug that prevented to retrieve the hostname of the local machine on certain systems. This release includes support for PostgreSQL as Kong's primary datastore! Remove support for the long deprecated `/consumers/:consumer/keyauth/` and `/consumers/:consumer/basicauth/` routes (deprecated in `0.5.0`). The new routes (available since

too) use the real name of the plugin: `/consumers/:consumer/key-auth` and `/consumers/:consumer/basic-auth`. Support for PostgreSQL 9.4+ as Kong's primary datastore. Configurable Cassandra reading/writing consistency. Admin API: including pending and running timers count in the response to `/`. Plugins New correlation-id plugin: assign unique identifiers to the requests processed by Kong. Courtesy of . LDAP: add support for LDAP authentication. StatsD: add support for StatsD logging. JWT: add support for RS256 signed tokens thanks to ! ACL: appends `X-Consumer-Groups` to the request, so the upstream service can check what groups the consumer belongs to. Galileo (mashape-analytics): increase batch sending timeout to 30s. Added `ttlonfailure` option in the cluster configuration, to configure the TTL of failed nodes. Introduce a new `port` option when connecting to your Cassandra cluster instead of using the CQL default (9042). Plugins Request/Response Transformer: add missing migrations for upgrades from ` <= 0.5.x`. OAuth2 Error responses comply to RFC 6749. Handle multipart requests. Make access_tokens correctly expire. internal replace globals with singleton pattern thanks to . fixed resolution mismatches when using deep paths in the path resolver. Due to the NGINX security fixes (CVE-2016-0742, CVE-2016-0746, CVE-2016-0747), OpenResty was bumped to `1.9.7.3` which is not backwards compatible, and thus requires changes to be made to the `nginx` property of Kong's configuration file. See the for instructions. However by upgrading the underlying OpenResty version, source installations do not have to patch the NGINX core and use the old `ssl-cert-by-lua` branch of ngx_lua anymore. This will make source installations much easier. Support for OpenResty `1.9.7.*`. This includes NGINX security fixes (CVE-2016-0742, CVE-2016-0746, CVE-2016-0747). Plugins New Runscope plugin: Monitor your APIs from Kong with Runscope. Courtesy of . Datadog: New `response.size` metric. Rate-Limiting and Response Rate-Limiting New `config.async` option to asynchronously increment counters to reduce latency at the cost of slightly reducing the accuracy. New `config.continueonerror` option to keep proxying requests in case the datastore is unreachable. rate-limiting operations will be disabled until the datastore is responsive again. CLI Perform a simple permission check on the NGINX working directory when starting, to prevent errors during execution. Send 50x errors with the appropriate format. Plugins OAuth2 Better handling of `redirect_uri` (prevent the use of fragments and correctly handle querystrings). Courtesy of . Add `PUT` support to the `/auth2_tokens` route. Better error message when the `access_token` is missing. IP restriction: Fix an issue that could arise when restarting Kong. Now Kong does not need to be restarted for the ip-restriction configuration to take effect. ACL: Properly invalidating entities when assigning a new ACL group. SSL: Replace shelled out openssl calls with native `ngx.ssl` conversion utilities, which preserve the certificate chain. Avoid user warning on start when the user is not root. Store Serf logs in NGINX working directory to prevent eventual permission issues. Allow plugins configured on a Consumer without being configured on an API to run. Fixed an edge-case where Kong nodes would not be registered in the `nodes` table. This release contains tiny bug fixes that were especially annoying for complex Cassandra setups and power users of the Admin API! A `timeout` property for the Cassandra configuration. In ms, this timeout is effective as a connection and a reading timeout. Correctly set the Cassandra SSL certificate in the Nginx configuration while starting Kong. Rename the `user` Cassandra property to `username` (Kong looks for `username`, hence `user` would fail). Allow Cassandra authentication with arbitrary plain text auth providers (such as Instaclustr uses), fixing authentication with them. Admin API Fix the `/plugins/:id` route for `PATCH`

Plugins HTTP logging: remove the additional `\r\n` at the end of the logging request body. Galileo: catch occasional internal errors happening when a request was cancelled by the client and fix missing shm for the retry policy. We would recommended to consult the suggested for this release. is now a Kong dependency. It allows Kong nodes to communicate between each other opening the way to many features and improvements. The configuration file changed. Some properties were renamed, others were moved, and some are new. We would recommend checking out the new default configuration file. Drop the Lua 5.1 dependency which was only used by the CLI. The CLI now runs with LuaJIT, which is consistent with other Kong components (Luarocks and OpenResty) already relying on LuaJIT. Make sure the LuaJIT interpreter is included in your `$PATH`. One of the biggest new features of this release is the cluster-awareness added to Kong in , which deserves its own section: Each Kong node is now aware of belonging to a cluster through Serf. Nodes automatically join the specified cluster according to the configuration file's settings. The datastore cache is not invalidated by expiration time anymore, but following an invalidation strategy between the nodes of a same cluster, leading to improved performance. Admin API Expose a `/cache` endpoint for retrieving elements stored in the in-memory cache of a node. Expose a `/cluster` endpoint used to add/remove/list members of the cluster, and also used internally for data propagation. CLI New `kong cluster` command for cluster management. New `kong status` command for cluster healthcheck. Other additions include: New Cassandra driver which makes Kong aware of the Cassandra cluster. Kong is now unaffected if one of your Cassandra nodes goes down as long as a replica is available on another node. Load balancing policies also improve the performance along with many other smaller improvements. Admin API A new `total` field in API responses, that counts the total number of entities in the datastore. Configuration Possibility to configure the keyspace replication strategy for Cassandra. It will be taken into account by the migrations when the configured keyspace does not already exist. Dnsmasq is now optional. You can specify a custom DNS resolver address that Kong will use when resolving hostnames. This can be configured in `kong.yml`. Plugins New "syslog" plugin: send logs to local system log. New "loggly" plugin: send logs to Loggly over UDP. New "datadog" plugin: send logs to Datadog server. OAuth2 Add support for `X-Forwarded-Proto` header. Expose a new `/oauth2_tokens` endpoint with the possibility to retrieve, update or delete OAuth 2.0 access tokens. JWT Support for base64 encoded secrets. Support to configure the claim in which the key is given into the token (not `iss` only anymore). Request transformer Support for more transformation options: `remove`, `replace`, `add`, `append` motivated by . See Support JSON body transformation. Response transformer Support for more transformation options: `remove`, `replace`, `add`, `append` motivated by . See As mentioned in the breaking changes section, a new configuration file format and validation. All properties are now documented and commented out with their default values. This allows for a lighter configuration file and more clarity as to what properties relate to. It also catches configuration mistakes. Replace the UUID generator library with a new implementation wrapping lib-uuid, fixing eventual conflicts happening in cases such as described in . See Admin API Increase the maximum body size to 10MB in order to handle configuration requests with heavy payloads. Disable access logs for the `/status` endpoint. The `/status` endpoint now includes `database` statistics, while the previous stats have been moved to a `server` response

Behaviors described in related to the failure of Cassandra nodes thanks to the new driver. Latency headers are now properly included in responses sent to the client. `striprequestpath` does not add a trailing slash to the API's `upstream_url` anymore before proxying. Do not URL decode querystring before proxying the request to the upstream service. Handle cases when the request would be terminated prior to the Kong execution (that is, before ngxlua reaches the `accessby_lua` context) in cases such as the use of a custom nginx module. Admin API The PUT method now correctly updates boolean fields (such as `striprequestpath`). The PUT method now correctly resets a plugin configuration. PATCH correctly set previously unset fields. In the responses, the `next` link is not being displayed anymore if there are no more entities to be returned. Prevent the update of `created_at` fields. Better `request_path` validation for APIs. "/" is not considered a valid path anymore. Plugins Galileo: ensure the `mimeType` value is always a string in ALFs. JWT: allow to update JWT credentials using the PATCH method. It previously used to reply with `405 Method not allowed` because the PATCH method was not implemented. Rate limiting: fix a warning when many periods are configured. Basic Authentication: do not re-hash the password field when updating a credential. File log: better permissions for on file creation for file-log plugin. OAuth2 Implement correct responses when the OAuth2 challenges are refused. Handle querystring on `/authorize` and `/token` URLs. Handle punctuation in scopes on `/authorize` and `/token` endpoints. *internal* Event bus for local and cluster-wide events propagation. Plans for this event bus is to be widely used among Kong in the future. The Kong Public Lua API (Lua helpers integrated in Kong such as DAO and Admin API helpers) is now documented with . Work has been done to restore the reliability of the CI platforms. Migrations can now execute DML queries (instead of DDL queries only). Handy for migrations implying plugin configuration changes, plugins renamings etc... Mashape Analytics plugin (renamed Galileo): Improve stability under heavy load. base64 encode ALF request/response bodies, enabling proper support for Galileo bodies inspection capabilities. Do not include JSON bodies in ALF `postData.params` field. Avoids additional URL encoding when proxying to an upstream service. Potential timing comparison bug in HMAC plugin. The Galileo plugin now supports arbitrary host, port and path values. A few fixes requested by the community! Kong properly search the `nginx` in your $PATH variable. Plugins: OAuth2: can detect that the originating protocol for a request was HTTPS through the `X-Forwarded-Proto` header and work behind another reverse proxy (load balancer). HMAC signature: support for `X-Date` header to sign the request for usage in browsers (since the `Date` header is protected). Fixing a few glitches we let out with 0.5.0! Basic Authentication and HMAC Authentication plugins now also send the `X-Credential-Username` to the upstream server. Admin API now accept JSON when receiving a CORS request. Add a `WWW-Authenticate` header for HTTP 401 responses for basic-auth and key-auth. Protect Kong from POODLE SSL attacks by omitting SSLv3 (CVE-2014-3566). Remove support for key-auth key in body. Plugins HMAC The migration for this plugin is now correctly being run. Wrong username doesn't return HTTP 500 anymore, but 403. JWT: `iss` not being found doesn't return HTTP 500 anymore, but 403. OAuth2: client credentials flow does not include a refresh token anymore. Fix an occasional error when updating a plugin without a config. With new plugins, many improvements and bug fixes, this release comes with breaking changes that will require your attention. Several breaking changes are

You will have to slightly change your configuration file and a migration script will take care of updating your database cluster. Please follow the instructions in for an update without downtime. Many plugins were renamed due to new naming conventions for consistency. In the configuration file, the Cassandra `hosts` property was renamed to `contact_points`. Properties belonging to APIs entities have been renamed for clarity. `publicdns` -> `requesthost` `path` -> `request_path` `strippath` -> `striprequest_path` `targeturl` -> `upstreamurl` `plugins_configurations` have been renamed to `plugins`, and their `value` property has been renamed to `config` to avoid confusions. The database schema has been updated to handle the separation of plugins outside of the core repository. The Key authentication and Basic authentication plugins routes have changed: ``` Old route New route /consumers/:consumer/keyauth -> /consumers/:consumer/key-auth /consumers/:consumer/keyauth/:id -> /consumers/:consumer/key-auth/:id /consumers/:consumer/basicauth -> /consumers/:consumer/basic-auth /consumers/:consumer/basicauth/:id -> /consumers/:consumer/basic-auth/:id ``` The old routes are still maintained but will be removed in upcoming versions. Consider them deprecated. Admin API The route to retrieve enabled plugins is now under `/plugins/enabled`. The route to retrieve a plugin's configuration schema is now under `/plugins/schema/{plugin name}`. Plugins New Response Rate Limiting plugin: Give a usage quota to your users based on a parameter in your response. New ACL (Access Control) plugin: Configure authorizations for your Consumers. New JWT (JSON Web Token) plugin: Verify and authenticate JWTs. New HMAC signature plugin: Verify and authenticate HMAC signed HTTP requests. Plugins migrations. Each plugin can now have its own migration scripts if it needs to store data in your cluster. This is a step forward to improve Kong's pluggable architecture. Basic Authentication: the password field is now sha1 encrypted. Basic Authentication: now supports credentials in the `Proxy-Authorization` header. Basic Authentication and Key Authentication now require authentication parameters even when the `Expect: 100-continue` header is being sent. Key Auth plugin does not support passing the key in the request payload anymore. APIs' names cannot contain characters from the RFC 3986 reserved list. Resolver Making a request with a querystring will now correctly match an API's path. Admin API Data associated to a given API/Consumer will correctly be deleted if related Consumer/API is deleted. The `/api/{apinameorid}/plugins/{pluginnameorid}` changed to `/api/{apinameorid}/plugins/{pluginid}` to avoid requesting the wrong plugin if two are configured for one API. APIs created without a `name` but with a `requestpath` will now have a name which defaults to the set `requestpath`. Plugins Mashape Analytics: More robust buffer and better error logging. Mashape Analytics: Several ALF (API Log Format) serialization fixes. Oauth2: A response is now returned on `http://kong:8001/consumers/{consumer}/oauth2/{oauth2_id}`. Oauth2: Saving `authenticated_userid` on Password Grant. Oauth2: Proper handling of the `/oauth2/authorize` and `/oauth2/token` endpoints in the OAuth 2.0 Plugin when an API with a `path` is being consumed using the `public_dns` instead. OAuth2: Properly returning `X-Authenticated-UserId` in the `client_credentials` and `password` flows. Response-Transformer: Properly handling JSON responses that have a charset specified in their `Content-Type` header. Cassandra authentication and SSL encryption. `preserve_host` flag on APIs to preserve the Host header when a request is proxied. Added the Resource Owner Password Credentials Grant to the OAuth 2.0 Plugin. Auto-generation of default SSL certificate. Remove `cassandra.port` property in configuration. Ports are specified by having `cassandra.hosts` addresses using the `host:port` notation (RFC 3986). Default SSL certificate is now auto-generated and stored in the `nginxworkingdir`. OAuth 2.0 plugin now properly forces HTTPS. Better handling of multi-nodes Cassandra clusters. mashape-analytics plugin: handling of numerical values in querystrings. Path resolver `strip_path` option wrongfully matching the `path` property multiple times in the request URI. File Log Plugin bug that prevented the file creation in some environments. Clean output of the Kong

Issues with the Mashape Analytics plugin. Handle hyphens when executing path routing with `strip_path` option enabled. Adding the Client Credentials OAuth 2.0 flow. A bug that prevented "dnsmasq" from being started on some systems, including Debian. File Log plugin: optimizations by avoiding the buffered I/O layer. Implement wildcard subdomains for APIs' `public_dns`. Plugins New OAuth 2.0 plugin. New Mashape Analytics plugin. New IP restriction plugin. Ratelimiting: support for multiple limits. HTTP logging: support for HTTPS endpoint. Logging plugins: new properties for logs timing. Key authentication: now auto-generates a key if none is specified. Resolver `path` property now accepts arbitrary depth. Admin API Enable CORS by default. Expose a new endpoint to get a plugin configuration's schema. Expose a new endpoint to retrieve a node's status. CLI `$ kong migrations reset` now asks for confirmation. Plugins Basic authentication not being executed if added to an API with default configuration. SSL plugin configuration parsing. SSL plugin doesn't accept a `consumer_id` anymore, as this wouldn't make sense. Authentication plugins now return `401` when missing credentials. Admin API Non supported HTTP methods now return `405` instead of `500`. Prevent PATCH requests from overriding a plugin's configuration if partially updated. Handle occasionally missing `schema_migrations` table. internal DAO: Complete refactor. No more need for hard-coded queries. Schemas: New `self_check` test for schema definitions. Uppercase Cassandra keyspace bug that prevented Kong to work with Multipart requests not properly parsed in the admin API. Schema migrations are now automatic, which was missing from previous releases. Support for SSL. Plugins New HTTP logging plugin. New SSL plugin. New request size limiting plugin. Default logging format improvements. File logging now logs to a custom file. Keyauth plugin now defaults `key_names` to "apikey". Admin API RESTful routing. Much nicer Admin API routing. Ex: `/apis/{nameorid}/plugins`. Support `PUT` method for endpoints such as `/apis/`, `/apis/plugins/`, `/consumers/` Support for `application/json` and `x-www-form-urlencoded` Content Types for all `PUT`, `POST` and `PATCH` endpoints by passing a `Content-Type` header. Resolver Support resolving APIs by Path as well as by Header. Support for `X-Host-Override` as an alternative to `Host` for browsers. Auth plugins now send user informations to your upstream services. Invalid `target_url` value are now being caught when creating an API. Uppercase Cassandra keyspace causing migration failure. Guarantee that ratelimiting won't allow requests in case the atomicity of the counter update is not guaranteed. internal Schemas: New property type: `array`. Entities schemas now live in their own files and are starting to be unit tested. Subfields are handled better: (notify required subfields and auto-vivify is subfield has default values). Way faster unit tests. Not resetting the DB anymore between tests. Improved coverage computation (exclude `vendor/`). Travis now lints `kong/`. Way faster Travis setup. Added a new HTTP client for in-nginx usage, using the cosocket API. Various refactorings. Fix . Disabled ipv6 in resolver. This is a maintenance release including several bug fixes and usability improvements. Support for local DNS resolution. Support for Debian 8 and Ubuntu 15.04. DAO Cassandra version bumped to 2.1.5 Support for Cassandra downtime. If Cassandra goes down and is brought back up, Kong will not need to restart anymore, statements will be re-prepared on-the-fly. This is part of an ongoing effort from , and . Queries effectuated during the downtime will still be lost. Leverage reused sockets. If the DAO reuses a socket, it will not re-set their keyspace. This should give a small but appreciable performance improvement. Cascade delete plugins configurations when deleting a Consumer or an API associated with it. Allow Cassandra hosts listening on different ports than the

CLI Added a notice log when Kong tries to connect to Cassandra to avoid user confusion. The CLI now tests if the ports are already being used before starting and warns. Admin API `name` is now an optional property for APIs. If none is being specified, the name will be the API `public_dns`. Configuration The memory cache size is now configurable. Resolver More explicit "API not found" message from the resolver if the Host was not found in the system. "API not found with Host: %s". If multiple hosts headers are being sent, Kong will test them all to see if one of the API is in the system. Admin API: responses now have a new line after the body. DAO: keepalive property is now properly passed when Kong calls `set_keepalive` on Cassandra sockets. Multipart dependency throwing error at startup. internal Separate Migrations from the DAO factory. Update dev config + Makefile rules (`run` becomes `start`). Introducing an `ngx` stub for unit tests and CLI. Switch many PCRE regexes to using patterns. First public release of Kong. This version brings a lot of internal improvements as well as more usability and a few additional plugins. Plugins CORS plugin. Request transformation plugin. NGINX plus monitoring plugin. Configuration New properties: `proxyport` and `apiadmin_port`. CLI Better info, help and error messages. New commands: `kong reload`, `kong quit`. Alias of `version`: `kong --version` `kong restart` simply starts Kong if not previously running + better pid file handling. Package distributions: .rpm, .deb and .pkg for easy installs on most common platforms. Admin API: trailing slash is not necessary anymore for core resources such as `/apis` or `/consumers`. Leaner default configuration. internal All scripts moved to the CLI as "hidden" commands (`kong db`, `kong config`). More tests as always, and they are structured better. The coverage went down mainly because of plugins which will later move to their own repos. We are all eagerly waiting for that! `src/` was renamed to `kong/` for ease of development All system dependencies versions for package building and travis-ci are now listed in `versions.sh` DAO doesn't need to `:prepare()` prior to run queries. Queries can be prepared at runtime. Wrong behavior of auto-migration in `kong start`. First public beta. Includes caching and better usability. Required Openresty is now `1.7.10.1`. Freshly built CLI, rewritten in Lua `kong start` using a new DB keyspace will automatically migrate the schema. Anonymous error reporting on Proxy and API. Configuration Simplified configuration file (unified in `kong.yml`). In configuration, `pluginsinstalled` was renamed to `pluginsavailable`. Order of `plugins_available` doesn't matter anymore. Better handling of plugins: Kong now detects which plugins are configured and if they are installed on the current machine. `bin/kong` now defaults on `/etc/kong.yml` for config and `/var/logs/kong` for output. Proxy: APIs/Consumers caching with expiration for faster authentication. Admin API: Plugins now use plain form parameters for configuration. Keep track of already executed migrations. `rollback` now behaves as expected. `Server` header now sends Kong. migrations not being executed in order on Linux. This issue wasn't noticed until unit testing the migrations because for now we only have 1 migration file. Admin API: Errors responses are now sent as JSON. internal We now have code linting and coverage. Faker and Migrations instances don't live in the DAO Factory anymore, they are only used in scripts and tests. `scripts/config.lua` allows environment based configurations. `make dev` generates a `kong.DEVELOPMENT.yml` and `kong_TEST.yml`. Different keyspaces and ports. `spec_helpers.lua` allows tests to not rely on the `Makefile` anymore. Integration tests can run 100% from `busted`. Switch integration testing from [httpbin.org] to [mockbin.com]. `core` plugin was renamed to `resolver`. First version running