spring-cloud-gateway Documentation

Technical Documentation: spring-cloud/spring-cloud-gateway

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

Antora Playbook.Yml (`docs/antora-playbook.yml`) Copy Section

antora:
extensions:
- require: '@springio/antora-extensions'
root_component_name: 'cloud-gateway'
site:
title: Spring Cloud Gateway
url: https://docs.spring.io/spring-cloud-gateway/reference/
content:
sources:
- url: ./..
branches: HEAD
start_path: docs
worktrees: true
asciidoc:
attributes:
page-stackoverflow-url: https://stackoverflow.com/tags/spring-cloud
page-pagination: ''
hide-uri-scheme: '@'
tabs-sync-option: '@'
chomp: 'all'
extensions:
- '@asciidoctor/tabs'
- '@springio/asciidoctor-extensions'
sourcemap: true
urls:
latest_version_segment: ''
runtime:
log:
failure_level: warn
format: pretty
ui:
bundle:
url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.26/ui-bundle.zip

Antora.Yml (`docs/antora.yml`) Copy Section

name: cloud-gateway
version: true
title: Spring Cloud Gateway
nav:

• modules/ROOT/nav.adoc
  ext:
  collector:
  run:
  command: ./mvnw --no-transfer-progress -B process-resources -Pdocs -pl docs -Dantora-maven-plugin.phase=none -Dgenerate-docs.phase=none -Dgenerate-readme.phase=none -Dgenerate-cloud-resources.phase=none -Dmaven-dependency-plugin-for-docs.phase=none -Dmaven-dependency-plugin-for-docs-classes.phase=none -DskipTests -DdisableConfigurationProperties
  local: true
  scan:
  dir: ./target/classes/antora-resources/

Package.Json (`docs/package.json`) Copy Section

{
"dependencies": {
"antora": "3.2.1",
"@antora/atlas-extension": "1.0.0-alpha.6",
"@antora/collector-extension": "1.0.3",
"@asciidoctor/tabs": "1.0.0-beta.6",
"@springio/antora-extensions": "1.14.13",
"@springio/asciidoctor-extensions": "1.0.0-alpha.18"
}
}

Modules ROOT Nav (`docs/modules/ROOT/nav.adoc`) Copy Section

• xref:index.adoc[Introduction]

// begin Gateway Server WebFlux

• xref:spring-cloud-gateway-server-webflux.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/starter.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/glossary.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/how-it-works.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/configuring-route-predicate-factories-and-filter-factories.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/request-predicates-factories.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/addrequestheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/addrequestheadersifnotpresent-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/addrequestparameter-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/addresponseheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/circuitbreaker-filter-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/cacherequestbody-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/deduperesponseheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/fallback-headers.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/jsontogrpc-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/local-cache-response-filter.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/maprequestheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/modifyrequestbody-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/modifyresponsebody-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/prefixpath-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/preservehostheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/redirectto-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/removejsonattributesresponsebody-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/removerequestheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/removerequestparameter-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/removeresponseheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/requestheadersize-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/requestheadertorequesturi-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/requestratelimiter-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/rewritelocationresponseheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/rewritepath-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/rewriterequestparameter-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/rewriteresponseheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/savesession-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/secureheaders-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/setpath-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/setrequestheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/setresponseheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/setstatus-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/stripprefix-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/retry-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/requestsize-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/setrequesthostheader-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/tokenrelay-factory.adoc[]
  *** xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/default-filters.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/global-filters.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/httpheadersfilters.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/tls-and-ssl.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/spring-security.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/http-client.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/configuration.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/route-metadata-configuration.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/http-timeouts-configuration.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/fluent-java-routes-api.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/the-discoveryclient-route-definition-locator.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/reactor-netty-access-logs.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/cors-configuration.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/actuator-api.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/sharing-routes.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/troubleshooting.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/developer-guide.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/aot-and-native-image-support.adoc[]
  ** xref:spring-cloud-gateway-server-webflux/configuration-properties.adoc[]

// begin Gateway Server Web MVC

• xref:spring-cloud-gateway-server-webmvc.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/starter.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/glossary.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/how-it-works.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/java-routes-api.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/gateway-request-predicates.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/gateway-handler-filter-functions.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/adaptcachedbody.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/addrequestheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/addrequestheadersifnotpresent.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/addrequestparameter.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/addresponseheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/circuitbreaker-filter.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/deduperesponseheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/fallback-headers.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/loadbalancer.adoc[]
  //*** xref:spring-cloud-gateway-server-mvc/filters/local-cache-response-filter.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/maprequestheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/modifyrequestbody.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/modifyresponsebody.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/prefixpath.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/preservehostheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/redirectto.adoc[]
  //*** xref:spring-cloud-gateway-server-mvc/filters/removejsonattributesresponsebody.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/removerequestheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/removerequestparameter.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/removeresponseheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/requestheadersize.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/ratelimiter.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/rewritelocationresponseheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/rewritepath.adoc[]
  //*** xref:spring-cloud-gateway-server-mvc/filters/rewriterequestparameter.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/rewriteresponseheader.adoc[]
  //*** xref:spring-cloud-gateway-server-mvc/filters/savesession.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/setpath.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/setrequestheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/setresponseheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/setstatus.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/stripcontextpath.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/stripprefix.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/retry.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/requestsize.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/setrequesthostheader.adoc[]
  *** xref:spring-cloud-gateway-server-webmvc/filters/tokenrelay.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/httpheadersfilters.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/writing-custom-predicates-and-filters.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/working-with-servlets-and-filters.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/tls-and-ssl.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/websockets.adoc[]
  ** xref:spring-cloud-gateway-server-webmvc/spring-security.adoc[]

// begin Gateway Proxy Exchange

• xref:spring-cloud-gateway-proxy-exchange.adoc[]
• xref:appendix.adoc[]

Modules ROOT Pages Attributes (`docs/modules/ROOT/pages/_attributes.adoc`) Copy Section

:doctype: book
:idprefix:
:idseparator: -
:tabsize: 4
:numbered:
:sectanchors:
:sectnums:
:icons: font
:hide-uri-scheme:
:docinfo: shared,private

:sc-ext: java
:project-full-name: Spring Cloud Gateway
:all: {asterisk}{asterisk}

Modules ROOT Pages Appendix (`docs/modules/ROOT/pages/appendix.adoc`) Copy Section

:numbered!:
[appendix]
[[common-application-properties]]
= Common application properties
:page-section-summary-toc: 1

Various properties can be specified inside your application.properties file, inside your application.yml file, or as command line switches.
This appendix provides a list of common Spring Cloud Gateway properties and references to the underlying classes that consume them.

NOTE: Property contributions can come from additional jar files on your classpath, so you should not consider this an exhaustive list.
Also, you can define your own properties.

include::partial$_configprops.adoc[]

[[observability]]
== Observability metadata

include::partial$_metrics.adoc[]

include::partial$_spans.adoc[]

include::partial$_conventions.adoc[]

Modules ROOT Pages Configprops (`docs/modules/ROOT/pages/configprops.adoc`) Copy Section

[[configuration-properties]]
= Configuration Properties

Below you can find a list of configuration properties.

include::partial$_configprops.adoc[]

Modules ROOT Pages Intro (`docs/modules/ROOT/pages/intro.adoc`) Copy Section

[[introduction]]
= Spring Cloud Gateway

This project provides an API Gateway built on top of the Spring Ecosystem, including: Spring Framework 7, Spring Boot 4, and Project Reactor. Spring Cloud Gateway aims to provide a simple, yet effective way to route to APIs and provide cross cutting concerns to them such as: security, monitoring/metrics, and resiliency.

There are two distinct flavors of Spring Cloud Gateway: Server and Proxy Exchange. Each flavor offers WebFlux and Web MVC compatibility.

• The Server variant is a full-featured API gateway that can be standalone or embedded in a Spring Boot application.
• The Proxy Exchange variant is exclusively for use in annotation based WebFlux or Web MVC applications and allows the use of a special ProxyExchange object as a parameter to a web handler method.

Modules ROOT Pages Spring Cloud Gateway Proxy Exchange (`docs/modules/ROOT/pages/spring-cloud-gateway-proxy-exchange.adoc`) Copy Section

[[proxy-exchange-gateway]]
= Proxy Exchange Gateway with Spring Web MVC or WebFlux

WARNING: The following describes an alternative style gateway. None of the Spring Cloud Gateway Server documentation applies to what follows.

== How to Include Spring Cloud Gateway Proxy Exchange

To include Spring Cloud Gateway Proxy Exchange in your project, use the artifact with a group ID of org.springframework.cloud and an artifact ID of spring-cloud-gateway-proxyexchange-webmvc for the MVC Proxy Exchange. For the WebFlux Proxy Exchange use artifact with a group ID of org.springframework.cloud and an artifact ID of spring-cloud-gateway-proxyexchange-webflux.

See the https://projects.spring.io/spring-cloud/[Spring Cloud Project page] for details on setting up your build system with the current Spring Cloud Release Train.

== Using Proxy Exchange

Spring Cloud Gateway provides a utility object called ProxyExchange.
You can use it inside a regular Spring web handler as a method parameter.
It supports basic downstream HTTP exchanges through methods that mirror the HTTP verbs.
With MVC, it also supports forwarding to a local handler through the forward() method.
To use the ProxyExchange, include the right module in your classpath (either spring-cloud-gateway-proxyexchange-webmvc or spring-cloud-gateway-proxyexchange-webflux).

The following MVC example proxies a request to /test downstream to a remote server:

[source,java] Copy Chapter

@RestController
@SpringBootApplication
public class GatewaySampleApplication {

@Value("${remote.home}")
private URI home;

@GetMapping("/test")
public ResponseEntity<?> proxy(ProxyExchange proxy) throws Exception {
	return proxy.uri(home.toString() + "/image/png").get();
}

} Copy Chapter

The following example does the same thing with Webflux:

[source,java] Copy Chapter

@RestController
@SpringBootApplication
public class GatewaySampleApplication {

@Value("${remote.home}")
private URI home;

@GetMapping("/test")
public Mono<ResponseEntity<?>> proxy(ProxyExchange proxy) throws Exception {
	return proxy.uri(home.toString() + "/image/png").get();
}

} Copy Chapter

Convenience methods on the ProxyExchange enable the handler method to discover and enhance the URI path of the incoming request.
For example, you might want to extract the trailing elements of a path to pass them downstream:

[source,java] Copy Chapter

@GetMapping("/proxy/path/**") public ResponseEntity proxyPath(ProxyExchange proxy) throws Exception { String path = proxy.path("/proxy/path/"); return proxy.uri(home.toString() + "/foos/" + path).get(); } Copy Chapter

All the features of Spring MVC and Webflux are available to gateway handler methods.
As a result, you can inject request headers and query parameters, for instance, and you can constrain the incoming requests with declarations in the mapping annotation.
See the documentation for @RequestMapping in Spring MVC for more details of those features.

You can add headers to the downstream response by using the header() methods on ProxyExchange.

You can also manipulate response headers (and anything else you like in the response) by adding a mapper to the get() method (and other methods).
The mapper is a Function that takes the incoming ResponseEntity and converts it to an outgoing one.

First-class support is provided for "sensitive" headers (by default, cookie and authorization) and "skipped" headers (by default, content-length and host), which are not passed downstream, and for "proxy" (x-forwarded-*) headers. The idea behind "skipped" headers is that they may result in problems when copied over to the downstream request. For example: because of the way that the ProxyExchange calls the downstream endpoint the content's length might have changed or even use a Transfer-Encoding: chunked instead of a Content-Length header.

Modules ROOT Pages Spring Cloud Gateway Server Webflux (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux.adoc`) Copy Section

[[spring-cloud-gateway-server-webflux]]
= Spring Cloud Gateway Server WebFlux
:page-section-summary-toc: 1

{spring-cloud-version}

Modules ROOT Pages Spring Cloud Gateway Server Webmvc (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc.adoc`) Copy Section

[[spring-cloud-gateway-server-webmvc]]
= Spring Cloud Gateway Server Web MVC
:page-section-summary-toc: 1

// TODO:

Modules ROOT Partials Configprops (`docs/modules/ROOT/partials/_configprops.adoc`) Copy Section

|===
|Name | Default | Description

|spring.cloud.gateway.server.webflux.default-filters | | List of filter definitions that are applied to every route.
|spring.cloud.gateway.server.webflux.discovery.locator.enabled | +++false+++ | Flag that enables DiscoveryClient gateway integration.
|spring.cloud.gateway.server.webflux.discovery.locator.filters | |
|spring.cloud.gateway.server.webflux.discovery.locator.include-expression | +++true+++ | SpEL expression that will evaluate whether to include a service in gateway integration or not, defaults to: true.
|spring.cloud.gateway.server.webflux.discovery.locator.lower-case-service-id | +++false+++ | Option to lower case serviceId in predicates and filters, defaults to false. Useful with eureka when it automatically uppercases serviceId. so "MYSERVICE", would match /myservice/**
|spring.cloud.gateway.server.webflux.discovery.locator.predicates | |
|spring.cloud.gateway.server.webflux.discovery.locator.route-id-prefix | | The prefix for the routeId, defaults to discoveryClient.getClass().getSimpleName() + "_". ServiceId will be appended to create the routeId.
|spring.cloud.gateway.server.webflux.discovery.locator.url-expression | +++'lb://'+serviceId+++ | SpEL expression that create the uri for each route, defaults to: 'lb://'+serviceId.
|spring.cloud.gateway.server.webflux.enabled | +++true+++ | Enables gateway functionality.
|spring.cloud.gateway.server.webflux.fail-on-route-definition-error | +++true+++ | Option to fail on route definition errors, defaults to true. Otherwise, a warning is logged.
|spring.cloud.gateway.server.webflux.filter.add-request-header.enabled | +++true+++ | Enables the add-request-header filter.
|spring.cloud.gateway.server.webflux.filter.add-request-parameter.enabled | +++true+++ | Enables the add-request-parameter filter.
|spring.cloud.gateway.server.webflux.filter.add-response-header.enabled | +++true+++ | Enables the add-response-header filter.
|spring.cloud.gateway.server.webflux.filter.circuit-breaker.enabled | +++true+++ | Enables the circuit-breaker filter.
|spring.cloud.gateway.server.webflux.filter.dedupe-response-header.enabled | +++true+++ | Enables the dedupe-response-header filter.
|spring.cloud.gateway.server.webflux.filter.fallback-headers.enabled | +++true+++ | Enables the fallback-headers filter.
|spring.cloud.gateway.server.webflux.filter.json-to-grpc.enabled | +++true+++ | Enables the JSON to gRPC filter.
|spring.cloud.gateway.server.webflux.filter.local-response-cache.enabled | +++false+++ | Enables the local-response-cache filter.
|spring.cloud.gateway.server.webflux.filter.local-response-cache.request.no-cache-strategy | +++skip-update-cache-entry+++ |
|spring.cloud.gateway.server.webflux.filter.local-response-cache.size | | Maximum size of the cache to evict entries for this route (in KB, MB and GB).
|spring.cloud.gateway.server.webflux.filter.local-response-cache.time-to-live | +++5m+++ | Time to expire a cache entry (expressed in s for seconds, m for minutes, and h for hours).
|spring.cloud.gateway.server.webflux.filter.map-request-header.enabled | +++true+++ | Enables the map-request-header filter.
|spring.cloud.gateway.server.webflux.filter.modify-request-body.enabled | +++true+++ | Enables the modify-request-body filter.
|spring.cloud.gateway.server.webflux.filter.modify-response-body.enabled | +++true+++ | Enables the modify-response-body filter.
|spring.cloud.gateway.server.webflux.filter.prefix-path.enabled | +++true+++ | Enables the prefix-path filter.
|spring.cloud.gateway.server.webflux.filter.preserve-host-header.enabled | +++true+++ | Enables the preserve-host-header filter.
|spring.cloud.gateway.server.webflux.filter.redirect-to.enabled | +++true+++ | Enables the redirect-to filter.
|spring.cloud.gateway.server.webflux.filter.remove-hop-by-hop.headers | |
|spring.cloud.gateway.server.webflux.filter.remove-hop-by-hop.order | |
|spring.cloud.gateway.server.webflux.filter.remove-request-header.enabled | +++true+++ | Enables the remove-request-header filter.
|spring.cloud.gateway.server.webflux.filter.remove-request-parameter.enabled | +++true+++ | Enables the remove-request-parameter filter.
|spring.cloud.gateway.server.webflux.filter.remove-response-header.enabled | +++true+++ | Enables the remove-response-header filter.
|spring.cloud.gateway.server.webflux.filter.request-header-size.enabled | +++true+++ | Enables the request-header-size filter.
|spring.cloud.gateway.server.webflux.filter.request-header-to-request-uri.enabled | +++true+++ | Enables the request-header-to-request-uri filter.
|spring.cloud.gateway.server.webflux.filter.request-rate-limiter.default-key-resolver | |
|spring.cloud.gateway.server.webflux.filter.request-rate-limiter.default-rate-limiter | |
|spring.cloud.gateway.server.webflux.filter.request-rate-limiter.enabled | +++true+++ | Enables the request-rate-limiter filter.
|spring.cloud.gateway.server.webflux.filter.request-size.enabled | +++true+++ | Enables the request-size filter.
|spring.cloud.gateway.server.webflux.filter.retry.enabled | +++true+++ | Enables the retry filter.
|spring.cloud.gateway.server.webflux.filter.rewrite-location-response-header.enabled | +++true+++ | Enables the rewrite-location-response-header filter.
|spring.cloud.gateway.server.webflux.filter.rewrite-location.enabled | +++true+++ | Enables the rewrite-location filter.
|spring.cloud.gateway.server.webflux.filter.rewrite-path.enabled | +++true+++ | Enables the rewrite-path filter.
|spring.cloud.gateway.server.webflux.filter.rewrite-request-parameter.enabled | +++true+++ | Enables the rewrite-request-parameter filter.
|spring.cloud.gateway.server.webflux.filter.rewrite-response-header.enabled | +++true+++ | Enables the rewrite-response-header filter.
|spring.cloud.gateway.server.webflux.filter.save-session.enabled | +++true+++ | Enables the save-session filter.
|spring.cloud.gateway.server.webflux.filter.secure-headers.content-security-policy | +++default-src 'self' https:; font-src 'self' https: data:; img-src 'self' https: data:; object-src 'none'; script-src https:; style-src 'self' https: 'unsafe-inline'+++ |
|spring.cloud.gateway.server.webflux.filter.secure-headers.content-type-options | +++nosniff+++ |
|spring.cloud.gateway.server.webflux.filter.secure-headers.default-headers | |
|spring.cloud.gateway.server.webflux.filter.secure-headers.disable | |
|spring.cloud.gateway.server.webflux.filter.secure-headers.disabled-headers | |
|spring.cloud.gateway.server.webflux.filter.secure-headers.download-options | +++noopen+++ |
|spring.cloud.gateway.server.webflux.filter.secure-headers.enabled | +++true+++ | Enables the secure-headers filter.
|spring.cloud.gateway.server.webflux.filter.secure-headers.enabled-headers | |
|spring.cloud.gateway.server.webflux.filter.secure-headers.frame-options | +++DENY+++ |
|spring.cloud.gateway.server.webflux.filter.secure-headers.permissions-policy | +++accelerometer=(), ambient-light-sensor=(), autoplay=(), battery=(), camera=(), cross-origin-isolated=(), display-capture=(), document-domain=(), encrypted-media=(), execution-while-not-rendered=(), execution-while-out-of-viewport=(), fullscreen=(), geolocation=(), gyroscope=(), keyboard-map=(), magnetometer=(), microphone=(), midi=(), navigation-override=(), payment=(), picture-in-picture=(), publickey-credentials-get=(), screen-wake-lock=(), sync-xhr=(), usb=(), web-share=(), xr-spatial-tracking=()+++ |
|spring.cloud.gateway.server.webflux.filter.secure-headers.permitted-cross-domain-policies | +++none+++ |
|spring.cloud.gateway.server.webflux.filter.secure-headers.referrer-policy | +++no-referrer+++ |
|spring.cloud.gateway.server.webflux.filter.secure-headers.strict-transport-security | +++max-age=631138519+++ |
|spring.cloud.gateway.server.webflux.filter.secure-headers.xss-protection-header | +++1 ; mode=block+++ |
|spring.cloud.gateway.server.webflux.filter.set-path.enabled | +++true+++ | Enables the set-path filter.
|spring.cloud.gateway.server.webflux.filter.set-request-header.enabled | +++true+++ | Enables the set-request-header filter.
|spring.cloud.gateway.server.webflux.filter.set-request-host-header.enabled | +++true+++ | Enables the set-request-host-header filter.
|spring.cloud.gateway.server.webflux.filter.set-response-header.enabled | +++true+++ | Enables the set-response-header filter.
|spring.cloud.gateway.server.webflux.filter.set-status.enabled | +++true+++ | Enables the set-status filter.
|spring.cloud.gateway.server.webflux.filter.strip-prefix.enabled | +++true+++ | Enables the strip-prefix filter.
|spring.cloud.gateway.server.webflux.forwarded.by.enabled | +++false+++ | Enables the Forwarded: by header part.
|spring.cloud.gateway.server.webflux.forwarded.enabled | +++true+++ | Enables the ForwardedHeadersFilter.
|spring.cloud.gateway.server.webflux.global-filter.adapt-cached-body.enabled | +++true+++ | Enables the adapt-cached-body global filter.
|spring.cloud.gateway.server.webflux.global-filter.forward-path.enabled | +++true+++ | Enables the forward-path global filter.
|spring.cloud.gateway.server.webflux.global-filter.forward-routing.enabled | +++true+++ | Enables the forward-routing global filter.
|spring.cloud.gateway.server.webflux.global-filter.load-balancer-client.enabled | +++true+++ | Enables the load-balancer-client global filter.
|spring.cloud.gateway.server.webflux.global-filter.local-response-cache.enabled | +++true+++ | Enables the local-response-cache filter for all routes, it allows to add a specific configuration at route level using LocalResponseCache filter.
|spring.cloud.gateway.server.webflux.global-filter.netty-routing.enabled | +++true+++ | Enables the netty-routing global filter.
|spring.cloud.gateway.server.webflux.global-filter.netty-write-response.enabled | +++true+++ | Enables the netty-write-response global filter.
|spring.cloud.gateway.server.webflux.global-filter.reactive-load-balancer-client.enabled | +++true+++ | Enables the reactive-load-balancer-client global filter.
|spring.cloud.gateway.server.webflux.global-filter.remove-cached-body.enabled | +++true+++ | Enables the remove-cached-body global filter.
|spring.cloud.gateway.server.webflux.global-filter.route-to-request-url.enabled | +++true+++ | Enables the route-to-request-url global filter.
|spring.cloud.gateway.server.webflux.global-filter.websocket-routing.enabled | +++true+++ | Enables the websocket-routing global filter.
|spring.cloud.gateway.server.webflux.globalcors.add-to-simple-url-handler-mapping | +++false+++ | If global CORS config should be added to the URL handler.
|spring.cloud.gateway.server.webflux.globalcors.cors-configurations | |
|spring.cloud.gateway.server.webflux.handler-mapping.order | +++1+++ | The order of RoutePredicateHandlerMapping.
|spring.cloud.gateway.server.webflux.httpclient.compression | +++false+++ | Enables compression for Netty HttpClient.
|spring.cloud.gateway.server.webflux.httpclient.connect-timeout | | The connect timeout in millis, the default is 30s.
|spring.cloud.gateway.server.webflux.httpclient.max-header-size | | The max response header size.
|spring.cloud.gateway.server.webflux.httpclient.max-initial-line-length | | The max initial line length.
|spring.cloud.gateway.server.webflux.httpclient.pool.acquire-timeout | | Only for type FIXED, the maximum time in millis to wait for acquiring.
|spring.cloud.gateway.server.webflux.httpclient.pool.eviction-interval | +++0+++ | Perform regular eviction checks in the background at a specified interval. Disabled by default ({@link Duration#ZERO})
|spring.cloud.gateway.server.webflux.httpclient.pool.leasing-strategy | +++fifo+++ | Configures the leasing strategy for the pool (fifo or lifo), defaults to FIFO which is Netty's default.
|spring.cloud.gateway.server.webflux.httpclient.pool.max-connections | | Only for type FIXED, the maximum number of connections before starting pending acquisition on existing ones.
|spring.cloud.gateway.server.webflux.httpclient.pool.max-idle-time | | Time in millis after which the channel will be closed. If NULL, there is no max idle time.
|spring.cloud.gateway.server.webflux.httpclient.pool.max-life-time | | Duration after which the channel will be closed. If NULL, there is no max life time.
|spring.cloud.gateway.server.webflux.httpclient.pool.metrics | +++false+++ | Enables channel pools metrics to be collected and registered in Micrometer. Disabled by default.
|spring.cloud.gateway.server.webflux.httpclient.pool.name | +++proxy+++ | The channel pool map name, defaults to proxy.
|spring.cloud.gateway.server.webflux.httpclient.pool.type | +++elastic+++ | Type of pool for HttpClient to use (elastic, fixed or disabled).
|spring.cloud.gateway.server.webflux.httpclient.proxy.host | | Hostname for proxy configuration of Netty HttpClient.
|spring.cloud.gateway.server.webflux.httpclient.proxy.non-proxy-hosts-pattern | | Regular expression (Java) for a configured list of hosts. that should be reached directly, bypassing the proxy
|spring.cloud.gateway.server.webflux.httpclient.proxy.password | | Password for proxy configuration of Netty HttpClient.
|spring.cloud.gateway.server.webflux.httpclient.proxy.port | | Port for proxy configuration of Netty HttpClient.
|spring.cloud.gateway.server.webflux.httpclient.proxy.type | +++http+++ | proxyType for proxy configuration of Netty HttpClient (http, socks4 or socks5).
|spring.cloud.gateway.server.webflux.httpclient.proxy.username | | Username for proxy configuration of Netty HttpClient.
|spring.cloud.gateway.server.webflux.httpclient.response-timeout | | The response timeout.
|spring.cloud.gateway.server.webflux.httpclient.ssl.close-notify-flush-timeout | +++3000ms+++ | SSL close_notify flush timeout. Default to 3000 ms.
|spring.cloud.gateway.server.webflux.httpclient.ssl.close-notify-read-timeout | +++0+++ | SSL close_notify read timeout. Default to 0 ms.
|spring.cloud.gateway.server.webflux.httpclient.ssl.handshake-timeout | +++10000ms+++ | SSL handshake timeout. Default to 10000 ms
|spring.cloud.gateway.server.webflux.httpclient.ssl.key-password | | Key password, default is same as keyStorePassword.
|spring.cloud.gateway.server.webflux.httpclient.ssl.key-store | | Keystore path for Netty HttpClient.
|spring.cloud.gateway.server.webflux.httpclient.ssl.key-store-password | | Keystore password.
|spring.cloud.gateway.server.webflux.httpclient.ssl.key-store-provider | | Keystore provider for Netty HttpClient, optional field.
|spring.cloud.gateway.server.webflux.httpclient.ssl.key-store-type | +++JKS+++ | Keystore type for Netty HttpClient, default is JKS.
|spring.cloud.gateway.server.webflux.httpclient.ssl.ssl-bundle | | The name of the SSL bundle to use.
|spring.cloud.gateway.server.webflux.httpclient.ssl.trusted-x509-certificates | | Trusted certificates for verifying the remote endpoint's certificate.
|spring.cloud.gateway.server.webflux.httpclient.ssl.use-insecure-trust-manager | +++false+++ | Installs the netty InsecureTrustManagerFactory. This is insecure and not suitable for production.
|spring.cloud.gateway.server.webflux.httpclient.websocket.max-frame-payload-length | | Max frame payload length.
|spring.cloud.gateway.server.webflux.httpclient.websocket.proxy-ping | +++true+++ | Proxy ping frames to downstream services, defaults to true.
|spring.cloud.gateway.server.webflux.httpclient.wiretap | +++false+++ | Enables wiretap debugging for Netty HttpClient.
|spring.cloud.gateway.server.webflux.httpserver.customizer-enabled | +++false+++ | Enables Gateway Customizer for Netty HttpServer, the default is false.
|spring.cloud.gateway.server.webflux.httpserver.wiretap | +++false+++ | Enables wiretap debugging for Netty HttpServer.
|spring.cloud.gateway.server.webflux.loadbalancer.use404 | +++false+++ |
|spring.cloud.gateway.server.webflux.metrics.enabled | +++false+++ | Enables the collection of metrics data.
|spring.cloud.gateway.server.webflux.metrics.path-tags.enabled | +++false+++ | Enables the gateway path tag provider.
|spring.cloud.gateway.server.webflux.metrics.prefix | +++spring.cloud.gateway+++ | The prefix of all metrics emitted by gateway.
|spring.cloud.gateway.server.webflux.metrics.tags | | Tags map that added to metrics.
|spring.cloud.gateway.server.webflux.metrics.tags.path.enabled | +++false+++ | Enables the gateway path tag provider.
|spring.cloud.gateway.server.webflux.observability.enabled | +++true+++ | If Micrometer Observability support should be turned on.
|spring.cloud.gateway.server.webflux.predicate.after.enabled | +++true+++ | Enables the after predicate.
|spring.cloud.gateway.server.webflux.predicate.before.enabled | +++true+++ | Enables the before predicate.
|spring.cloud.gateway.server.webflux.predicate.between.enabled | +++true+++ | Enables the between predicate.
|spring.cloud.gateway.server.webflux.predicate.cloud-foundry-route-service.enabled | +++true+++ | Enables the cloud-foundry-route-service predicate.
|spring.cloud.gateway.server.webflux.predicate.cookie.enabled | +++true+++ | Enables the cookie predicate.
|spring.cloud.gateway.server.webflux.predicate.header.enabled | +++true+++ | Enables the header predicate.
|spring.cloud.gateway.server.webflux.predicate.host.enabled | +++true+++ | Enables the host predicate.
|spring.cloud.gateway.server.webflux.predicate.host.include-port | +++true+++ | Include the port in matching the host name.
|spring.cloud.gateway.server.webflux.predicate.method.enabled | +++true+++ | Enables the method predicate.
|spring.cloud.gateway.server.webflux.predicate.path.enabled | +++true+++ | Enables the path predicate.
|spring.cloud.gateway.server.webflux.predicate.query.enabled | +++true+++ | Enables the query predicate.
|spring.cloud.gateway.server.webflux.predicate.read-body.enabled | +++true+++ | Enables the read-body predicate.
|spring.cloud.gateway.server.webflux.predicate.remote-addr.enabled | +++true+++ | Enables the remote-addr predicate.
|spring.cloud.gateway.server.webflux.predicate.weight.enabled | +++true+++ | Enables the weight predicate.
|spring.cloud.gateway.server.webflux.predicate.xforwarded-remote-addr.enabled | +++true+++ | Enables the xforwarded-remote-addr predicate.
|spring.cloud.gateway.server.webflux.redis-rate-limiter.burst-capacity-header | +++X-RateLimit-Burst-Capacity+++ | The name of the header that returns the burst capacity configuration.
|spring.cloud.gateway.server.webflux.redis-rate-limiter.config | |
|spring.cloud.gateway.server.webflux.redis-rate-limiter.include-headers | +++true+++ | Whether or not to include headers containing rate limiter information, defaults to true.
|spring.cloud.gateway.server.webflux.redis-rate-limiter.remaining-header | +++X-RateLimit-Remaining+++ | The name of the header that returns number of remaining requests during the current second.
|spring.cloud.gateway.server.webflux.redis-rate-limiter.replenish-rate-header | +++X-RateLimit-Replenish-Rate+++ | The name of the header that returns the replenish rate configuration.
|spring.cloud.gateway.server.webflux.redis-rate-limiter.requested-tokens-header | +++X-RateLimit-Requested-Tokens+++ | The name of the header that returns the requested tokens configuration.
|spring.cloud.gateway.server.webflux.redis-route-definition-repository.enabled | +++true+++ | If RedisRouteDefinitionRepository should be enabled.
|spring.cloud.gateway.server.webflux.restrictive-property-accessor.enabled | +++true+++ | Restricts method and property access in SpEL.
|spring.cloud.gateway.server.webflux.route-filter-cache-enabled | +++false+++ | Enables the route filter cache, defaults to false.
|spring.cloud.gateway.server.webflux.route-refresh-listener.enabled | +++true+++ | If RouteRefreshListener should be turned on.
|spring.cloud.gateway.server.webflux.routes | | List of Routes.
|spring.cloud.gateway.server.webflux.set-status.original-status-header-name | | The name of the header which contains http code of the proxied request.
|spring.cloud.gateway.server.webflux.streaming-media-types | |
|spring.cloud.gateway.server.webflux.trusted-proxies | | Regular expression defining proxies that are trusted when they appear in a Forwarded or X-Forwarded header.
|spring.cloud.gateway.server.webflux.version.default-version | | The defaultVersion.
|spring.cloud.gateway.server.webflux.version.detect-supported-versions | +++true+++ | Flag whether to use API versions that appear in mappings for supported version validation (true), or use only explicitly configured versions (false). Defaults to true.
|spring.cloud.gateway.server.webflux.version.header-name | | The header name used to extract the API Version.
|spring.cloud.gateway.server.webflux.version.media-type | | The media type name used to extract the API Version.
|spring.cloud.gateway.server.webflux.version.media-type-param-name | | The media type parameter name used to extract the API Version.
|spring.cloud.gateway.server.webflux.version.path-segment | | The index of a path segment used to extract the API Version.
|spring.cloud.gateway.server.webflux.version.request-param-name | | The request parameter name used to extract the API Version.
|spring.cloud.gateway.server.webflux.version.required | +++false+++ |
|spring.cloud.gateway.server.webflux.version.supported-versions | |
|spring.cloud.gateway.server.webflux.x-forwarded.enabled | +++true+++ | If the XForwardedHeadersFilter is enabled.
|spring.cloud.gateway.server.webflux.x-forwarded.for-append | +++true+++ | If appending X-Forwarded-For as a list is enabled.
|spring.cloud.gateway.server.webflux.x-forwarded.for-enabled | +++true+++ | If X-Forwarded-For is enabled.
|spring.cloud.gateway.server.webflux.x-forwarded.host-append | +++true+++ | If appending X-Forwarded-Host as a list is enabled.
|spring.cloud.gateway.server.webflux.x-forwarded.host-enabled | +++true+++ | If X-Forwarded-Host is enabled.
|spring.cloud.gateway.server.webflux.x-forwarded.order | +++0+++ | The order of the XForwardedHeadersFilter.
|spring.cloud.gateway.server.webflux.x-forwarded.port-append | +++true+++ | If appending X-Forwarded-Port as a list is enabled.
|spring.cloud.gateway.server.webflux.x-forwarded.port-enabled | +++true+++ | If X-Forwarded-Port is enabled.
|spring.cloud.gateway.server.webflux.x-forwarded.prefix-append | +++true+++ | If appending X-Forwarded-Prefix as a list is enabled.
|spring.cloud.gateway.server.webflux.x-forwarded.prefix-enabled | +++true+++ | If X-Forwarded-Prefix is enabled.
|spring.cloud.gateway.server.webflux.x-forwarded.proto-append | +++true+++ | If appending X-Forwarded-Proto as a list is enabled.
|spring.cloud.gateway.server.webflux.x-forwarded.proto-enabled | +++true+++ | If X-Forwarded-Proto is enabled.
|spring.cloud.gateway.server.webmvc.form-filter.enabled | +++true+++ | Enables the form-filter.
|spring.cloud.gateway.server.webmvc.forwarded-by-enabled | +++false+++ | Whether to add the "by" parameter to the Forwarded header.
|spring.cloud.gateway.server.webmvc.forwarded-request-headers-filter.enabled | +++true+++ | Enables the forwarded-request-headers-filter.
|spring.cloud.gateway.server.webmvc.remove-content-length-request-headers-filter.enabled | +++true+++ | Enables the remove-content-length-request-headers-filter.
|spring.cloud.gateway.server.webmvc.remove-hop-by-hop-request-headers-filter.enabled | +++true+++ | Enables the remove-hop-by-hop-request-headers-filter.
|spring.cloud.gateway.server.webmvc.remove-hop-by-hop-response-headers-filter.enabled | +++true+++ | Enables the remove-hop-by-hop-response-headers-filter.
|spring.cloud.gateway.server.webmvc.remove-http2-status-response-headers-filter.enabled | +++true+++ | Enables the remove-http2-status-response-headers-filter.
|spring.cloud.gateway.server.webmvc.routes | | List of Routes.
|spring.cloud.gateway.server.webmvc.routes-map | | Map of Routes.
|spring.cloud.gateway.server.webmvc.streaming-buffer-size | +++16384+++ | Buffer size for streaming media mime-types.
|spring.cloud.gateway.server.webmvc.streaming-media-types | | Mime-types that are streaming.
|spring.cloud.gateway.server.webmvc.transfer-encoding-normalization-request-headers-filter.enabled | +++true+++ | Enables the transfer-encoding-normalization-request-headers-filter.
|spring.cloud.gateway.server.webmvc.trusted-proxies | | Regular expression defining proxies that are trusted when they appear in a Forwarded of X-Forwarded header.
|spring.cloud.gateway.server.webmvc.use-framework-retry-filter | +++false+++ | In the case where Spring Retry is on the classpath but you still want to use Spring Framework retry as your retry filter, set this property to true.
|spring.cloud.gateway.server.webmvc.weight-calculator-filter.enabled | +++true+++ | Enables the weight-calculator-filter.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.enabled | +++true+++ | If the XForwardedHeadersFilter is enabled.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.for-append | +++true+++ | If appending X-Forwarded-For as a list is enabled.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.for-enabled | +++true+++ | If X-Forwarded-For is enabled.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.host-append | +++true+++ | If appending X-Forwarded-Host as a list is enabled.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.host-enabled | +++true+++ | If X-Forwarded-Host is enabled.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.order | +++0+++ | The order of the XForwardedHeadersFilter.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.port-append | +++true+++ | If appending X-Forwarded-Port as a list is enabled.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.port-enabled | +++true+++ | If X-Forwarded-Port is enabled.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.prefix-append | +++true+++ | If appending X-Forwarded-Prefix as a list is enabled.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.prefix-enabled | +++true+++ | If X-Forwarded-Prefix is enabled.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.proto-append | +++true+++ | If appending X-Forwarded-Proto as a list is enabled.
|spring.cloud.gateway.server.webmvc.x-forwarded-request-headers-filter.proto-enabled | +++true+++ | If X-Forwarded-Proto is enabled.

|===

Modules ROOT Partials Conventions (`docs/modules/ROOT/partials/_conventions.adoc`) Copy Section

[[observability-conventions]]
=== Observability - Conventions

Below you can find a list of all GlobalObservationConvention and ObservationConvention declared by this project.

.ObservationConvention implementations
|===
|ObservationConvention Class Name | Applicable ObservationContext Class Name
|org.springframework.cloud.gateway.filter.headers.observation.DefaultGatewayObservationConvention|GatewayContext
|org.springframework.cloud.gateway.filter.headers.observation.GatewayObservationConvention|GatewayContext
|===

Modules ROOT Partials Metrics (`docs/modules/ROOT/partials/_metrics.adoc`) Copy Section

[[observability-metrics]]
=== Observability - Metrics

Below you can find a list of all metrics declared by this project.

[[observability-metrics-gateway-http-client-observation]]
==== Gateway Http Client Observation

Observation created when sending a request through the gateway.

Metric name http.client.requests (defined by convention class org.springframework.cloud.gateway.filter.headers.observation.DefaultGatewayObservationConvention). Type timer.

Metric name http.client.requests.active (defined by convention class org.springframework.cloud.gateway.filter.headers.observation.DefaultGatewayObservationConvention). Type long task timer.

IMPORTANT: KeyValues that are added after starting the Observation might be missing from the *.active metrics.

IMPORTANT: Micrometer internally uses nanoseconds for the baseunit. However, each backend determines the actual baseunit. (i.e. Prometheus uses seconds)

Fully qualified name of the enclosing class org.springframework.cloud.gateway.filter.headers.observation.GatewayDocumentedObservation.

.Low cardinality Keys
[cols="a,a"]
|===
|Name | Description
|http.method (required)|HTTP Method.
|http.status_code (required)|HTTP Status.
|spring.cloud.gateway.route.id (required)|Route ID.
|spring.cloud.gateway.route.uri (required)|HTTP URI taken from the Route.
|===

Modules ROOT Partials Spans (`docs/modules/ROOT/partials/_spans.adoc`) Copy Section

[[observability-spans]]
=== Observability - Spans

Below you can find a list of all spans declared by this project.

[[observability-spans-gateway-http-client-observation]]
==== Gateway Http Client Observation Span

Observation created when sending a request through the gateway.

Span name http.client.requests (defined by convention class org.springframework.cloud.gateway.filter.headers.observation.DefaultGatewayObservationConvention).

Fully qualified name of the enclosing class org.springframework.cloud.gateway.filter.headers.observation.GatewayDocumentedObservation.

.Tag Keys
|===
|Name | Description
|http.method (required)|HTTP Method.
|http.status_code (required)|HTTP Status.
|http.uri (required)|Full HTTP URI.
|spring.cloud.gateway.route.id (required)|Route ID.
|spring.cloud.gateway.route.uri (required)|HTTP URI taken from the Route.
|===

Src Main Asciidoc README (`docs/src/main/asciidoc/README.adoc`) Copy Section

image::https://github.com/spring-cloud/spring-cloud-gateway/workflows/Build/badge.svg?style=svg["Actions Status", link="https://github.com/spring-cloud/spring-cloud-gateway/actions"]
image::https://codecov.io/gh/spring-cloud/spring-cloud-gateway/branch/main/graph/badge.svg["Codecov", link="https://codecov.io/gh/spring-cloud/spring-cloud-gateway/branch/main"]

[[features]]
= Features

• Java 17
• Spring Framework 6
• Spring Boot 3
• Dynamic routing
• Route matching built into Spring Handler Mapping
• Route matching on HTTP Request (Path, Method, Header, Host, etc...)
• Filters scoped to Matching Route
• Filters can modify downstream HTTP Request and HTTP Response (Add/Remove Headers, Add/Remove Parameters, Rewrite Path, Set Path, Circuit Breaker, etc...)
• API or configuration driven
• Supports Spring Cloud DiscoveryClient for configuring Routes

[[building]]
= Building

include::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/main/docs/modules/ROOT/partials/building.adoc[]

[[contributing]]
= Contributing

include::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/main/docs/modules/ROOT/partials/contributing.adoc[]

Src Main Asciidoc Gateway Alarming (`docs/src/main/asciidoc/gateway-alarming.adoc`) Copy Section

groups:

• name: Gateway_Service
  rules:

  • alert: Gateway Total Unsuccessful Requests Served
    expr: sum(rate(spring_cloud_gateway_requests_seconds_count{outcome!="SUCCESSFUL"}[1m])) by (routeId, httpStatusCode, outcome, status)>1
    for: 1m
    labels:
    severity: critical
    annotations:
    summary: "Total Unsuccessful Requests Served increases quickly"
    value: "Current:{{$value}}"

  • alert: Gateway QPS
    expr: sum(rate(spring_cloud_gateway_requests_seconds_count[5m]))>10000
    for: 1m
    labels:
    severity: warning
    annotations:
    summary: "QPS increases quickly"
    value: "Current:{{$value}}"

  • alert: Gateway Too many threads
    expr: max(jvm_threads_live_threads)>220
    for: 1m
    labels:
    severity: warning
    annotations:
    summary: "Too many threads"
    value: "Current:{{$value}}"

  • alert: Gateway minor GC
    expr: max(rate(jvm_gc_pause_seconds_count{action="end of minor GC"}[5m]))*300>200
    for: 1m
    labels:
    severity: warning
    annotations:
    summary: "minor GC has problem"
    value: "Current:{{$value}}"

  • alert: Gateway major GC
    expr: max(rate(jvm_gc_pause_seconds_count{action="end of major GC"}[5m]))*300>10
    for: 1m
    labels:
    severity: warning
    annotations:
    summary: "major GC has problem"
    value: "Current:{{$value}}"

  • alert: Gateway Latency is too high
    expr: (sum(rate(spring_cloud_gateway_requests_seconds_sum[30s])) by (routeId))/(sum(rate(spring_cloud_gateway_requests_seconds_count[30s])) by (routeId))*1000>5000
    for: 30s
    labels:
    severity: critical
    annotations:
    summary: " Gateway Latency is too high"
    value: "Current:{{$value}} ms"

Src Main Asciidoc Gateway Grafana Dashboard.Json (`docs/src/main/asciidoc/gateway-grafana-dashboard.json`) Copy Section

{
"__inputs": [
{
"name": "DS_PROMETHEUS",
"label": "prometheus",
"description": "",
"type": "datasource",
"pluginId": "prometheus",
"pluginName": "Prometheus"
}
],
"__requires": [
{
"type": "grafana",
"id": "grafana",
"name": "Grafana",
"version": "5.0.0"
},
{
"type": "panel",
"id": "graph",
"name": "Graph",
"version": "5.0.0"
},
{
"type": "datasource",
"id": "prometheus",
"name": "Prometheus",
"version": "5.0.0"
}
],
"annotations": {
"list": [
{
"builtIn": 1,
"datasource": "-- Grafana --",
"enable": true,
"hide": true,
"iconColor": "rgba(0, 211, 255, 1)",
"name": "Annotations & Alerts",
"type": "dashboard"
}
]
},
"editable": true,
"gnetId": null,
"graphTooltip": 0,
"id": null,
"iteration": 1550777954006,
"links": [],
"panels": [
{
"collapsed": true,
"gridPos": {
"h": 1,
"w": 24,
"x": 0,
"y": 0
},
"id": 50,
"panels": [
{
"cacheTimeout": null,
"colorBackground": false,
"colorValue": false,
"colors": [
"rgba(245, 54, 54, 0.9)",
"rgba(191, 148, 112, 0.89)",
"rgba(50, 172, 45, 0.97)"
],
"datasource": "${DS_PROMETHEUS}",
"description": "",
"format": "none",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"gridPos": {
"h": 3,
"w": 8,
"x": 0,
"y": 2
},
"hideTimeOverride": false,
"id": 28,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"postfix": "",
"postfixFontSize": "50%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "Value",
"targets": [
{
"expr": "sum(spring_cloud_gateway_requests_seconds_count{job="$gatewayService"})",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 1200
}
],
"thresholds": "",
"timeFrom": null,
"timeShift": null,
"title": "Total Requests Served",
"type": "stat",
"valueFontSize": "80%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "current"
},
{
"cacheTimeout": null,
"colorBackground": false,
"colorValue": false,
"colors": [
"rgba(245, 54, 54, 0.9)",
"rgba(191, 148, 112, 0.89)",
"rgba(50, 172, 45, 0.97)"
],
"datasource": "${DS_PROMETHEUS}",
"description": "",
"format": "none",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"gridPos": {
"h": 3,
"w": 8,
"x": 8,
"y": 2
},
"hideTimeOverride": false,
"id": 29,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"postfix": "",
"postfixFontSize": "50%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "Value",
"targets": [
{
"expr": "sum(spring_cloud_gateway_requests_seconds_count{outcome="SUCCESSFUL", job="$gatewayService"})",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 1200
}
],
"thresholds": "",
"timeFrom": null,
"timeShift": null,
"title": "Total Successful Requests Served",
"type": "stat",
"valueFontSize": "80%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "current"
},
{
"cacheTimeout": null,
"colorBackground": false,
"colorValue": false,
"colors": [
"rgba(245, 54, 54, 0.9)",
"rgba(191, 148, 112, 0.89)",
"rgba(50, 172, 45, 0.97)"
],
"datasource": "${DS_PROMETHEUS}",
"description": "",
"format": "none",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"gridPos": {
"h": 3,
"w": 8,
"x": 16,
"y": 2
},
"hideTimeOverride": false,
"id": 30,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"postfix": "",
"postfixFontSize": "50%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "Value",
"targets": [
{
"expr": "sum(spring_cloud_gateway_requests_seconds_count{outcome!="SUCCESSFUL", job="$gatewayService"})",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 1200
}
],
"thresholds": "",
"timeFrom": null,
"timeShift": null,
"title": "Total Unsuccessful Requests Served",
"type": "stat",
"valueFontSize": "80%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "current"
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "Total Unsuccessful Requests By routeId",
"gridPos": {
"h": 8,
"w": 24,
"x": 0,
"y": 4
},
"id": 80,
"links": [],
"nullPointMode": "null",
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
},
"renderer": "flot",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "sum(rate(spring_cloud_gateway_requests_seconds_count{outcome!="SUCCESSFUL", job="$gatewayService"}[1m])) by (routeId, httpStatusCode, outcome, status)",
"format": "time_series",
"intervalFactor": 1,
"legendFormat": "",
"refId": "A"
}
],
"timeFrom": null,
"timeRegions": [],
"timeShift": null,
"title": "Total Unsuccessful Requests By routeId",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"yaxis": {
"align": false,
"alignLevel": null
},
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 2,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "Total QPS for spring cloud gateway requests",
"gridPos": {
"h": 8,
"w": 24,
"x": 0,
"y": 4
},
"id": 88,
"links": [],
"nullPointMode": "null",
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
},
"renderer": "flot",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "sum(rate(spring_cloud_gateway_requests_seconds_count{job="$gatewayService"}[5m]))",
"format": "time_series",
"intervalFactor": 1,
"legendFormat": "total qps",
"refId": "A"
},
{
"expr": "sum(rate(spring_cloud_gateway_requests_seconds_count{job="$gatewayService",status="OK"}[5m]))",
"format": "time_series",
"intervalFactor": 1,
"legendFormat": "total ok qps",
"refId": "B"
}
],
"timeFrom": null,
"timeRegions": [],
"timeShift": null,
"title": "Total QPS",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"yaxis": {
"align": false,
"alignLevel": null
},
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 2,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "QPS for spring cloud gateway requests by service",
"gridPos": {
"h": 8,
"w": 24,
"x": 0,
"y": 4
},
"id": 81,
"links": [],
"nullPointMode": "null",
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
},
"renderer": "flot",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "sum(rate(spring_cloud_gateway_requests_seconds_count{routeId="$routeId", job="$gatewayService"}[5m])) by (routeId)",
"format": "time_series",
"intervalFactor": 1,
"legendFormat": "{{routeId}}",
"refId": "A"
}
],
"timeFrom": null,
"timeRegions": [],
"timeShift": null,
"title": "QPS by service",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"yaxis": {
"align": false,
"alignLevel": null
},
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 2,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "Latency for spring cloud gateway requests",
"gridPos": {
"h": 8,
"w": 24,
"x": 0,
"y": 12
},
"id": 82,
"links": [],
"nullPointMode": "null",
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
},
"renderer": "flot",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "(sum(rate(spring_cloud_gateway_requests_seconds_sum{job="$gatewayService"}[30s])) by (routeId)) / \n(sum(rate(spring_cloud_gateway_requests_seconds_count{job="$gatewayService"}[30s])) by (routeId)) * 1000",
"format": "time_series",
"intervalFactor": 1,
"legendFormat": "",
"refId": "A"
}
],
"timeFrom": null,
"timeRegions": [],
"timeShift": null,
"title": "Latency",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"yaxis": {
"align": false,
"alignLevel": null
},
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 2,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "ms",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
}
}
],
"repeat": null,
"title": "Total Throughput",
"type": "row"
},
{
"collapsed": true,
"gridPos": {
"h": 1,
"w": 24,
"x": 0,
"y": 1
},
"id": 51,
"panels": [
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"gridPos": {
"h": 7,
"w": 6,
"x": 0,
"y": 3
},
"id": 49,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"repeat": "routeId",
"scopedVars": {
"routeId": {
"selected": false,
"text": "ms-test",
"value": "ms-test"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "spring_cloud_gateway_requests_seconds_sum{routeId="$routeId", job="$gatewayService"}/spring_cloud_gateway_requests_seconds_count{routeId="$routeId", job="$gatewayService"}",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ status }}",
"metric": "gateway_api_time_seconds_sum",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "s",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"gridPos": {
"h": 7,
"w": 6,
"x": 6,
"y": 3
},
"id": 70,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"repeat": null,
"repeatIteration": 1550777954005,
"repeatPanelId": 49,
"scopedVars": {
"routeId": {
"selected": false,
"text": "msnext",
"value": "msnext"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "spring_cloud_gateway_requests_seconds_sum{routeId="$routeId", job="$gatewayService"}/spring_cloud_gateway_requests_seconds_count{routeId="$routeId", job="$gatewayService"}",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ status }}",
"metric": "gateway_api_time_seconds_sum",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "s",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"gridPos": {
"h": 7,
"w": 6,
"x": 12,
"y": 3
},
"id": 71,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"repeat": null,
"repeatIteration": 1550777954005,
"repeatPanelId": 49,
"scopedVars": {
"routeId": {
"selected": false,
"text": "msnext-a3s",
"value": "msnext-a3s"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "spring_cloud_gateway_requests_seconds_sum{routeId="$routeId", job="$gatewayService"}/spring_cloud_gateway_requests_seconds_count{routeId="$routeId", job="$gatewayService"}",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ status }}",
"metric": "gateway_api_time_seconds_sum",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "s",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"gridPos": {
"h": 7,
"w": 6,
"x": 18,
"y": 3
},
"id": 72,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"repeat": null,
"repeatIteration": 1550777954005,
"repeatPanelId": 49,
"scopedVars": {
"routeId": {
"selected": false,
"text": "msnext-sample",
"value": "msnext-sample"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "spring_cloud_gateway_requests_seconds_sum{routeId="$routeId", job="$gatewayService"}/spring_cloud_gateway_requests_seconds_count{routeId="$routeId", job="$gatewayService"}",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ status }}",
"metric": "gateway_api_time_seconds_sum",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "s",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
}
],
"repeat": null,
"title": "Request Processing Time",
"type": "row"
},
{
"collapsed": true,
"gridPos": {
"h": 1,
"w": 24,
"x": 0,
"y": 2
},
"id": 52,
"panels": [
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "",
"gridPos": {
"h": 7,
"w": 6,
"x": 0,
"y": 4
},
"id": 2,
"links": [],
"minSpan": null,
"nullPointMode": "null",
"renderer": "flot",
"repeat": "routeId",
"scopedVars": {
"routeId": {
"selected": false,
"text": "ms-test",
"value": "ms-test"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "spring_cloud_gateway_requests_seconds_count{outcome="SUCCESSFUL", routeId="$routeId", job="$gatewayService"}",
"format": "time_series",
"hide": false,
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ job }} / {{ routeUri }}",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId Success API Gateway Calls",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "cumulative"
},
"transparent": false,
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "normal",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "",
"gridPos": {
"h": 7,
"w": 6,
"x": 6,
"y": 4
},
"id": 73,
"links": [],
"minSpan": null,
"nullPointMode": "null",
"renderer": "flot",
"repeat": null,
"repeatIteration": 1550777954005,
"repeatPanelId": 2,
"scopedVars": {
"routeId": {
"selected": false,
"text": "msnext",
"value": "msnext"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "spring_cloud_gateway_requests_seconds_count{outcome="SUCCESSFUL", routeId="$routeId", job="$gatewayService"}",
"format": "time_series",
"hide": false,
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ job }} / {{ routeUri }}",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId Success API Gateway Calls",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "cumulative"
},
"transparent": false,
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "normal",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "",
"gridPos": {
"h": 7,
"w": 6,
"x": 12,
"y": 4
},
"id": 74,
"links": [],
"minSpan": null,
"nullPointMode": "null",
"renderer": "flot",
"repeat": null,
"repeatIteration": 1550777954005,
"repeatPanelId": 2,
"scopedVars": {
"routeId": {
"selected": false,
"text": "msnext-a3s",
"value": "msnext-a3s"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "spring_cloud_gateway_requests_seconds_count{outcome="SUCCESSFUL", routeId="$routeId", job="$gatewayService"}",
"format": "time_series",
"hide": false,
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ job }} / {{ routeUri }}",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId Success API Gateway Calls",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "cumulative"
},
"transparent": false,
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "normal",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "",
"gridPos": {
"h": 7,
"w": 6,
"x": 18,
"y": 4
},
"id": 75,
"links": [],
"minSpan": null,
"nullPointMode": "null",
"renderer": "flot",
"repeat": null,
"repeatIteration": 1550777954005,
"repeatPanelId": 2,
"scopedVars": {
"routeId": {
"selected": false,
"text": "msnext-sample",
"value": "msnext-sample"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "spring_cloud_gateway_requests_seconds_count{outcome="SUCCESSFUL", routeId="$routeId", job="$gatewayService"}",
"format": "time_series",
"hide": false,
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ job }} / {{ routeUri }}",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId Success API Gateway Calls",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "cumulative"
},
"transparent": false,
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "normal",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
}
],
"repeat": null,
"title": "Successful API Calls",
"type": "row"
},
{
"collapsed": true,
"gridPos": {
"h": 1,
"w": 24,
"x": 0,
"y": 3
},
"id": 53,
"panels": [
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "",
"gridPos": {
"h": 7,
"w": 8,
"x": 0,
"y": 14
},
"id": 3,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"repeat": "routeId",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "spring_cloud_gateway_requests_seconds_count{outcome!="SUCCESSFUL", routeId="$routeId", job="$gatewayService"}",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ job }} / {{ routeUri }}",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId Unsuccessful GW Calls",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "cumulative"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "normal",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
}
],
"repeat": null,
"title": "Unsuccessful API Calls",
"type": "row"
},
{
"collapsed": true,
"gridPos": {
"h": 1,
"w": 24,
"x": 0,
"y": 4
},
"id": 54,
"panels": [
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "",
"gridPos": {
"h": 7,
"w": 6,
"x": 0,
"y": 15
},
"id": 35,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"repeat": "routeId",
"scopedVars": {
"routeId": {
"selected": false,
"text": "ms-test",
"value": "ms-test"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "sum(spring_cloud_gateway_requests_seconds_count{routeId="$routeId", job="$gatewayService"}) by (job, status)",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ job }} / {{ status }}",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "",
"gridPos": {
"h": 7,
"w": 6,
"x": 6,
"y": 15
},
"id": 58,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"repeat": null,
"repeatIteration": 1550775166360,
"repeatPanelId": 35,
"scopedVars": {
"routeId": {
"selected": false,
"text": "msnext",
"value": "msnext"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "sum(spring_cloud_gateway_requests_seconds_count{routeId="$routeId", job="$gatewayService"}) by (job, status)",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ job }} / {{ status }}",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "",
"gridPos": {
"h": 7,
"w": 6,
"x": 12,
"y": 15
},
"id": 59,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"repeat": null,
"repeatIteration": 1550775166360,
"repeatPanelId": 35,
"scopedVars": {
"routeId": {
"selected": false,
"text": "msnext-a3s",
"value": "msnext-a3s"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "sum(spring_cloud_gateway_requests_seconds_count{routeId="$routeId", job="$gatewayService"}) by (job, status)",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ job }} / {{ status }}",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"description": "",
"gridPos": {
"h": 7,
"w": 6,
"x": 18,
"y": 15
},
"id": 60,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"repeat": null,
"repeatIteration": 1550775166360,
"repeatPanelId": 35,
"scopedVars": {
"routeId": {
"selected": false,
"text": "msnext-sample",
"value": "msnext-sample"
}
},
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "sum(spring_cloud_gateway_requests_seconds_count{routeId="$routeId", job="$gatewayService"}) by (job, status)",
"format": "time_series",
"interval": "",
"intervalFactor": 2,
"legendFormat": "{{ job }} / {{ status }}",
"metric": "spring_cloud_gateway_requests_seconds_count",
"refId": "A",
"step": 240
}
],
"timeFrom": null,
"timeShift": null,
"title": "$routeId",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
}
],
"repeat": null,
"title": "API / HTTP Status",
"type": "row"
},
{
"collapsed": false,
"gridPos": {
"h": 1,
"w": 24,
"x": 0,
"y": 5
},
"id": 64,
"panels": [],
"title": "JVM",
"type": "row"
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"gridPos": {
"h": 9,
"w": 6,
"x": 0,
"y": 6
},
"id": 62,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "process_cpu_usage{job="$gatewayService"}",
"format": "time_series",
"hide": false,
"interval": "",
"intervalFactor": 1,
"legendFormat": "{{ instance }}",
"refId": "A"
}
],
"timeFrom": null,
"timeShift": null,
"title": "CPU Usage",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"gridPos": {
"h": 9,
"w": 6,
"x": 6,
"y": 6
},
"id": 69,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "sum(jvm_memory_used_bytes{job="$gatewayService"}) by (job, instance)",
"format": "time_series",
"hide": false,
"interval": "",
"intervalFactor": 1,
"legendFormat": "{{ instance }}",
"refId": "A"
}
],
"timeFrom": null,
"timeShift": null,
"title": "Memory Used",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"gridPos": {
"h": 9,
"w": 6,
"x": 12,
"y": 6
},
"id": 77,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "jvm_threads_live_threads{job=~"$gatewayService"}",
"format": "time_series",
"hide": false,
"intervalFactor": 1,
"legendFormat": "{{ instance }}",
"refId": "A"
}
],
"timeFrom": null,
"timeShift": null,
"title": "Live Threads",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"alert": {
"conditions": [
{
"evaluator": {
"params": [
0.3
],
"type": "gt"
},
"operator": {
"type": "and"
},
"query": {
"params": [
"A",
"5m",
"now"
]
},
"reducer": {
"params": [],
"type": "avg"
},
"type": "query"
}
],
"executionErrorState": "alerting",
"frequency": "60s",
"handler": 1,
"name": "Memory Saturation alert",
"noDataState": "no_data",
"notifications": []
},
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"gridPos": {
"h": 9,
"w": 6,
"x": 18,
"y": 6
},
"id": 79,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "jvm_gc_memory_promoted_bytes_total/jvm_gc_memory_allocated_bytes_total",
"format": "time_series",
"hide": false,
"intervalFactor": 1,
"legendFormat": "{{ instance }}",
"refId": "A"
}
],
"timeFrom": null,
"timeShift": null,
"title": "Memory Saturation",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"gridPos": {
"h": 9,
"w": 6,
"x": 0,
"y": 6
},
"id": 90,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "max(rate(jvm_gc_pause_seconds_count{action="end of minor GC"}[5m])) * 300",
"format": "time_series",
"hide": false,
"intervalFactor": 1,
"legendFormat": "{{ instance }}",
"refId": "A"
}
],
"timeFrom": null,
"timeShift": null,
"title": "Minor GC",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
},
{
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "${DS_PROMETHEUS}",
"gridPos": {
"h": 9,
"w": 6,
"x": 6,
"y": 6
},
"id": 92,
"links": [],
"nullPointMode": "null",
"renderer": "flot",
"spaceLength": 10,
"steppedLine": false,
"targets": [
{
"expr": "max(rate(jvm_gc_pause_seconds_count{action="end of major GC"}[5m])) * 300",
"format": "time_series",
"hide": false,
"intervalFactor": 1,
"legendFormat": "{{ instance }}",
"refId": "A"
}
],
"timeFrom": null,
"timeShift": null,
"title": "Major GC",
"tooltip": {
"shared": false,
"sort": 0,
"value_type": "individual"
},
"type": "timeseries",
"fieldConfig": {
"defaults": {
"custom": {
"drawStyle": "line",
"lineInterpolation": "linear",
"barAlignment": 0,
"lineWidth": 1,
"fillOpacity": 10,
"gradientMode": "none",
"spanNulls": true,
"showPoints": "never",
"pointSize": 5,
"stacking": {
"mode": "none",
"group": "A"
},
"axisPlacement": "auto"
},
"unit": "short",
"thresholds": {
"mode": "absolute",
"steps": [
{
"color": "green",
"value": null
}
]
}
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "list",
"placement": "bottom",
"calcs": []
},
"tooltip": {
"mode": "single",
"sort": "none"
}
}
}
],
"refresh": "1m",
"schemaVersion": 36,
"style": "dark",
"tags": [],
"templating": {
"list": [
{
"allValue": null,
"current": {},
"datasource": "${DS_PROMETHEUS}",
"hide": 0,
"includeAll": true,
"label": "Gateway Service",
"multi": true,
"name": "gatewayService",
"options": [],
"query": "label_values(spring_cloud_gateway_requests_seconds_count,job)",
"refresh": 1,
"regex": "",
"sort": 1,
"tagValuesQuery": "",
"tags": [],
"tagsQuery": "",
"type": "query",
"useTags": false
},
{
"allValue": null,
"current": {},
"datasource": "${DS_PROMETHEUS}",
"hide": 0,
"includeAll": true,
"label": "Route Id",
"multi": true,
"name": "routeId",
"options": [],
"query": "label_values(spring_cloud_gateway_requests_seconds_count,routeId)",
"refresh": 1,
"regex": "",
"sort": 1,
"tagValuesQuery": "",
"tags": [],
"tagsQuery": "",
"type": "query",
"useTags": false
}
]
},
"time": {
"from": "now/d",
"to": "now"
},
"timepicker": {
"refresh_intervals": [
"5s",
"10s",
"30s",
"1m",
"5m",
"15m",
"30m",
"1h",
"2h",
"1d"
],
"time_options": [
"5m",
"15m",
"1h",
"6h",
"12h",
"24h",
"2d",
"7d",
"30d"
]
},
"timezone": "",
"title": "Spring Cloud Gateway",
"uid": "7voUGKrik",
"version": 5
}

Src Main Asciidoc Sagan Index (`docs/src/main/asciidoc/sagan-index.adoc`) Copy Section

This project provides a library for building an API Gateway on top of Spring. Spring Cloud Gateway aims to provide a simple, yet effective way to route to APIs and provide cross-cutting concerns to them such as: security, monitoring/metrics, and resiliency.

Features Copy Chapter

Spring Cloud Gateway features:

• Built on Spring Framework and Spring Boot
• Compatible with both Spring WebFlux and Spring Web MVC
• Able to match routes on any request attribute.
• Predicates and filters are specific to routes.
• Spring Cloud Circuit Breaker integration.
• Spring Cloud DiscoveryClient integration
• Easy to write Predicates and Filters
• Request Rate Limiting
• Path Rewriting

Getting Started with Spring Cloud Gateway Server WebFlux Copy Chapter

@SpringBootApplication
public class DemogatewayApplication {
	@Bean
	public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
		return builder.routes()
			.route("path_route", r -> r.path("/get")
				.uri("https://httpbin.org"))
			.route("host_route", r -> r.host("*.myhost.org")
				.uri("https://httpbin.org"))
			.route("rewrite_route", r -> r.host("*.rewrite.org")
				.filters(f -> f.rewritePath("/foo/(?<segment>.*)", "/${segment}"))
				.uri("https://httpbin.org"))
			.route("circuit_breaker_route", r -> r.host("*.circuitbreaker.org")
				.filters(f -> f.circuitBreaker(c -> c.setName("slowcmd")))
				.uri("https://httpbin.org"))
			.route("circuit_breaker_fallback_route", r -> r.host("*.circuitbreakerfallback.org")
				.filters(f -> f.circuitBreaker(c -> c.setName("slowcmd").setFallbackUri("forward:/circuitbrekerfallback")))
				.uri("https://httpbin.org"))
			.route("limit_route", r -> r
				.host("*.limited.org").and().path("/anything/**")
				.filters(f -> f.requestRateLimiter(c -> c.setRateLimiter(redisRateLimiter())))
				.uri("https://httpbin.org"))
			.build();
	}
}

To run your own Gateway Server WebFlux use the spring-cloud-starter-gateway-server-webflux dependency.

Getting Started with Spring Cloud Gateway Server Web MVC Copy Chapter

/* Detailed source-code truncated for AI context efficiency. */

To run your own Gateway Server WebMVC use the spring-cloud-starter-gateway-server-webmvc dependency.

Modules ROOT Pages Spring Cloud Gateway Server Webflux Actuator Api (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/actuator-api.adoc`) Copy Section

[[actuator-api]]
= Actuator API

The /gateway actuator endpoint lets you monitor and interact with a Spring Cloud Gateway application.
The `/gateway' actuator endpoint has its access disabled by default. To enable the endpoint you need to set the access to https://docs.spring.io/spring-boot/reference/actuator/endpoints.html#actuator.endpoints.controlling-access['read-only' or 'unrestricted'] and https://docs.spring.io/spring-boot/reference/actuator/endpoints.html#actuator.endpoints.exposing[exposed it over HTTP or JMX] in the application properties.
The following listing shows how to do so:

.application.properties [source,properties] Copy Chapter

management.endpoint.gateway.access=read-only management.endpoints.web.exposure.include=gateway Copy Chapter

WARNING: It is suggested that you set management.endpoint.gateway.access to read-only. This will disable the ability
to refresh, create, and delete routes. If you need the ability to create, refresh, and delete routes using the actuator
endpoint you need to set management.endpoint.gateway.access to unrestricted OR set management.endpoint.gateway.enabled=true.
If you enable the ability to create, delete, and refresh routes via the actuator endpoint you should take the proper steps to
make sure your actuator endpoints are https://docs.spring.io/spring-boot/reference/actuator/endpoints.html#actuator.endpoints.security[secured].

This endpoint provides an overview of what is available on the child actuator endpoint and the available methods for each reference. The resulting response is similar to the following:

[source,json] Copy Chapter

[
{
"href":"/actuator/gateway/",
"methods":[ "GET" ]
},
{
"href":"/actuator/gateway/routedefinitions",
"methods":[ "GET" ]
},
{
"href":"/actuator/gateway/globalfilters",
"methods":[ "GET" ]
},
{
"href":"/actuator/gateway/routefilters",
"methods":[ "GET" ]
},
{
"href":"/actuator/gateway/routes",
"methods":[ "POST", "GET" ]
},
{
"href":"/actuator/gateway/routepredicates",
"methods":[ "GET" ]
},
{
"href":"/actuator/gateway/refresh",
"methods":[ "POST" ]
},
{
"href":"/actuator/gateway/routes/route-id-1/combinedfilters",
"methods":[ "GET" ]
},
{
"href":"/actuator/gateway/routes/route-id-1",
"methods":[ "POST", "DELETE", "GET" ]
}

] Copy Chapter

[[verbose-actuator-format]]
== Verbose Actuator Format

A new, more verbose format has been added to Spring Cloud Gateway.
It adds more detail to each route, letting you view the predicates and filters associated with each route along with any configuration that is available.
The following example configures /actuator/gateway/routes:

[source,json] Copy Chapter

[
{
"predicate": "(Hosts: [**.addrequestheader.org] && Paths: [/headers], match trailing slash: true)",
"route_id": "add_request_header_test",
"filters": [
"[[AddResponseHeader X-Response-Default-Foo = 'Default-Bar'], order = 1]",
"[[AddRequestHeader X-Request-Foo = 'Bar'], order = 1]",
"[[PrefixPath prefix = '/httpbin'], order = 2]"
],
"uri": "lb://testservice",
"order": 0
}

] Copy Chapter

This feature is enabled by default. To disable it, set the following property:

.application.properties [source,properties] Copy Chapter

spring.cloud.gateway.server.webflux.actuator.verbose.enabled=false Copy Chapter

This will default to true in a future release.

[[retrieving-route-filters]]
== Retrieving Route Filters

This section details how to retrieve route filters, including:

• xref:spring-cloud-gateway-server-webflux/actuator-api.adoc#gateway-global-filters[Global Filters]
• <>

[[gateway-global-filters]]
=== Global Filters

To retrieve the xref:spring-cloud-gateway-server-webflux/global-filters.adoc[global filters] applied to all routes, make a GET request to /actuator/gateway/globalfilters. The resulting response is similar to the following:

{ "org.springframework.cloud.gateway.filter.ReactiveLoadBalancerClientFilter@77856cc5": 10100, "org.springframework.cloud.gateway.filter.RouteToRequestUrlFilter@4f6fd101": 10000, "org.springframework.cloud.gateway.filter.NettyWriteResponseFilter@32d22650": -1, "org.springframework.cloud.gateway.filter.ForwardRoutingFilter@106459d9": 2147483647, "org.springframework.cloud.gateway.filter.NettyRoutingFilter@1fbd5e0": 2147483647, "org.springframework.cloud.gateway.filter.ForwardPathFilter@33a71d23": 0, "org.springframework.cloud.gateway.filter.AdaptCachedBodyGlobalFilter@135064ea": 2147483637, "org.springframework.cloud.gateway.filter.WebsocketRoutingFilter@23c05889": 2147483646 } Copy Chapter

The response contains the details of the global filters that are in place.
For each global filter, there is a string representation of the filter object (for example, org.springframework.cloud.gateway.filter.ReactiveLoadBalancerClientFilter@77856cc5) and the corresponding xref:spring-cloud-gateway-server-webflux/global-filters.adoc#gateway-combined-global-filter-and-gatewayfilter-ordering[order] in the filter chain.

[[gateway-route-filters]]
=== Route Filters
To retrieve the xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories.adoc[GatewayFilter factories] applied to routes, make a GET request to /actuator/gateway/routefilters.
The resulting response is similar to the following:

{ "[AddRequestHeaderGatewayFilterFactory@570ed9c configClass = AbstractNameValueGatewayFilterFactory.NameValueConfig]": null, "[SecureHeadersGatewayFilterFactory@fceab5d configClass = Object]": null, "[SaveSessionGatewayFilterFactory@4449b273 configClass = Object]": null } Copy Chapter

The response contains the details of the GatewayFilter factories applied to any particular route.
For each factory there is a string representation of the corresponding object (for example, [SecureHeadersGatewayFilterFactory@fceab5d configClass = Object]).
Note that the null value is due to an incomplete implementation of the endpoint controller, because it tries to set the order of the object in the filter chain, which does not apply to a GatewayFilter factory object.

[[refreshing-the-route-cache]]
== Refreshing the Route Cache

To clear the routes cache, make a POST request to /actuator/gateway/refresh.
The request returns a 200 without a response body.

To clear the routes with specific metadata values, add the Query parameter metadata specifying the key:value pairs that the routes to be cleared should match.
If an error is produced during the asynchronous refresh, the refresh will not modify the existing routes.

Sending `POST` request to `/actuator/gateway/refresh?metadata=group:group-1` will only refresh the routes whose `group` metadata is `group-1`: `first_route` and `third_route`. [source,json] Copy Chapter

[{
"route_id": "first_route",
"route_object": {
"predicate": "...",
},
"metadata": { "group": "group-1" }
},
{
"route_id": "second_route",
"route_object": {
"predicate": "...",
},
"metadata": { "group": "group-2" }
},
{
"route_id": "third_route",
"route_object": {
"predicate": "...",
},
"metadata": { "group": "group-1" }

}] Copy Chapter

[[retrieving-the-routes-defined-in-the-gateway]]
== Retrieving the Routes Defined in the Gateway

To retrieve the routes defined in the gateway, make a GET request to /actuator/gateway/routes.
The resulting response is similar to the following (verbose format, which is the default):

[{
"predicate": "Paths: [/first], match trailing slash: true",
"route_id": "first_route",
"filters": [
"[[PreserveHostHeader], order = 0]"
],
"uri": "https://www.uri-destination.org",
"order": 0
},
{
"predicate": "Paths: [/second], match trailing slash: true",
"route_id": "second_route",
"filters": [],
"uri": "https://www.uri-destination.org",
"order": 0

}] Copy Chapter

NOTE: When spring.cloud.gateway.server.webflux.actuator.verbose.enabled=false, predicates and filters are shown as raw Java class strings instead of human-readable descriptions.

The response contains the details of all the routes defined in the gateway.
The following table describes the structure of each element (each is a route) of the response:

[cols="3,2,4"]
|===
| Path | Type | Description

|route_id
| String
| The route ID.

|predicate
| String
| A human-readable string representation of the route predicates (verbose format).

|filters
| Array
| The xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories.adoc[GatewayFilter factories] applied to the route.

|uri
| String
| The destination URI of the route.

|order
| Number
| The route order.

|===

[[gateway-retrieving-information-about-a-particular-route]]
== Retrieving Information about a Particular Route

To retrieve information about a single route, make a GET request to /actuator/gateway/routes/\{id} (for example, /actuator/gateway/routes/first_route).
The resulting response is similar to the following:

{ "route_id": "first_route", "predicate": "(Paths: [/first], match trailing slash: true)", "filters": [], "uri": "https://www.uri-destination.org", "order": 0 } Copy Chapter

NOTE: The response format for GET /actuator/gateway/routes/\{id} represents predicates as a single human-readable string. This is different from the shortcut DSL string format required when creating routes via POST. See <> for the correct POST request body format.

The following table describes the structure of the response:

[cols="3,2,4"]
|===
| Path | Type | Description

|route_id
| String
| The route ID.

|predicate
| String
| A human-readable string representation of the route predicates.

|filters
| Array
| The collection of filters applied to the route.

|uri
| String
| The destination URI of the route.

|order
| Number
| The route order.

|===

[[creating-and-deleting-a-particular-route-definition]]
== Creating and Deleting a Particular Route Definition

WARNING: Only routes created through the actuator endpoint can be modified or deleted via these endpoints.
Routes defined in application configuration (for example, application.yml or via @Bean) are read-only from the actuator's perspective.
Attempting to delete a configuration-defined route will return 404 Not Found.

To create a route definition, make a POST request to /actuator/gateway/routes/\{id_route_to_create} with a JSON body specifying the route fields.
Predicates and filters must be provided as shortcut DSL strings (for example, "Path=/foo/**" or "StripPrefix=1"), which is different from the structured format returned by GET /actuator/gateway/routes/\{id}.
The following example shows the correct request format:

{ "predicates": ["Path=/mypath/**", "Weight=mygroup,20"], "filters": ["StripPrefix=1"], "uri": "http://backend-service:8080", "order": 0 } Copy Chapter

A successful creation returns 201 Created.
After creating a route, call POST /actuator/gateway/refresh to apply the change without restarting the application.

WARNING: Do not POST to an existing route ID without first deleting it.
Doing so duplicates the route definition internally, which causes a 500 Internal Server Error on subsequent GET /actuator/gateway/routes requests.
To update an existing actuator-managed route, you must delete it first and then recreate it:

. Send DELETE to /actuator/gateway/routes/\{id}.
. Send POST to /actuator/gateway/routes/\{id} with the updated definition.
. Send POST to /actuator/gateway/refresh.

To delete a route definition, make a DELETE request to /actuator/gateway/routes/\{id_route_to_delete}.
A successful deletion returns 200 OK.
After deleting a route, call POST /actuator/gateway/refresh to apply the change without restarting the application.

[[creating-multiple-route-definitions]]
== Creating multiple Route Definitions

To create multiple route definitions in a single request, make a POST request to /gateway/routes with a JSON body that specifies the fields of the route, including the route id (see xref:spring-cloud-gateway-server-webflux/actuator-api.adoc#gateway-retrieving-information-about-a-particular-route[Retrieving Information about a Particular Route]).

The route definitions will be discarded if any route raises an error during the creation of the routes.

[[recap:-the-list-of-all-endpoints]]
== Recap: The List of All endpoints

The following table below summarizes the Spring Cloud Gateway actuator endpoints (note that each endpoint has /actuator/gateway as the base-path):

[cols="2,2,5"]
|===
| ID | HTTP Method | Description

|globalfilters
|GET
| Displays the list of global filters applied to the routes.

|routefilters
|GET
| Displays the list of GatewayFilter factories applied to a particular route.

|refresh
|POST
| Clears the routes cache.

|routes
|GET
| Displays the list of routes defined in the gateway.

|routes/\{id}
|GET
| Displays information about a particular route.

|routes/\{id}
|POST
| Adds a new route to the gateway. Uses shortcut DSL string format for predicates and filters. Returns 201 Created on success.

|routes/\{id}
|DELETE
| Removes an existing route from the gateway. Routes defined in application configuration cannot be removed via this endpoint (returns 404 Not Found).

|===

Modules ROOT Pages Spring Cloud Gateway Server Webflux Aot And Native Image Support (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/aot-and-native-image-support.adoc`) Copy Section

[[aot-and-native-image-support]]
= AOT and Native Image Support
:page-section-summary-toc: 1

Since 4.0.0, Spring Cloud Gateway supports Spring AOT transformations and native images.

TIP: If you're using load-balanced routes, you need to explicitly define your LoadBalancerClient service IDs. You can do so by using the value or name attributes of the @LoadBalancerClient annotation or as values of the spring.cloud.loadbalancer.eager-load.clients property.

Modules ROOT Pages Spring Cloud Gateway Server Webflux Configuration Properties (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/configuration-properties.adoc`) Copy Section

[[configuration-properties]]
= Configuration properties
:page-section-summary-toc: 1

To see the list of all Spring Cloud Gateway related configuration properties, see link:../appendix.html[the appendix].

Modules ROOT Pages Spring Cloud Gateway Server Webflux Configuration (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/configuration.adoc`) Copy Section

[[configuration]]
= Configuration

Configuration for Spring Cloud Gateway is driven by a collection of RouteDefinitionLocator instances.
The following listing shows the definition of the RouteDefinitionLocator interface:

.RouteDefinitionLocator.java [source,java] Copy Chapter

public interface RouteDefinitionLocator {
Flux getRouteDefinitions();

} Copy Chapter

By default, a PropertiesRouteDefinitionLocator loads properties by using Spring Boot's @ConfigurationProperties mechanism.

The earlier configuration examples all use a shortcut notation that uses positional arguments rather than named ones.
The following two examples are equivalent:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: setstatus_route
uri: https://example.org
filters:
- name: SetStatus
args:
status: 401
- id: setstatusshortcut_route
uri: https://example.org
filters:
- SetStatus=401

For some usages of the gateway, properties are adequate, but some production use cases benefit from loading configuration from an external source, such as a database. Future milestone versions will have RouteDefinitionLocator implementations based off of Spring Data Repositories, such as Redis, MongoDB, and Cassandra.

[[routedefinition-metrics]]
== RouteDefinition Metrics

To enable RouteDefinition metrics, add spring-boot-starter-actuator as a project dependency. Then, by default, the metrics will be available as long as the property spring.cloud.gateway.metrics.enabled is set to true. A gauge metric named spring.cloud.gateway.routes.count will be added, whose value is the number of RouteDefinitions. This metric will be available from /actuator/metrics/spring.cloud.gateway.routes.count.

Modules ROOT Pages Spring Cloud Gateway Server Webflux Configuring Route Predicate Factories And Filter Factories (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/configuring-route-predicate-factories-and-filter-factories.adoc`) Copy Section

[[configuring-route-predicate-factories-and-gateway-filter-factories]]
= Configuring Route Predicate Factories and Gateway Filter Factories

There are two ways to configure predicates and filters: shortcuts and fully expanded arguments. Most examples below use the shortcut way.

The name and argument names are listed as code in the first sentence or two of each section. The arguments are typically listed in the order that are needed for the shortcut configuration.

[[shortcut-configuration]]
== Shortcut Configuration

Shortcut configuration is recognized by the filter name, followed by an equals sign (=), followed by argument values separated by commas (,).

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: after_route
uri: https://example.org
predicates:
- Cookie=mycookie,mycookievalue

The previous sample defines the Cookie Route Predicate Factory with two arguments, the cookie name, mycookie and the value to match mycookievalue.

[[fully-expanded-arguments]]
== Fully Expanded Arguments

Fully expanded arguments appear more like standard yaml configuration with name/value pairs. Typically, there will be a name key and an args key. The args key is a map of key value pairs to configure the predicate or filter.

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: after_route
uri: https://example.org
predicates:
- name: Cookie
args:
name: mycookie
regexp: mycookievalue

This is the full configuration of the shortcut configuration of the Cookie predicate shown above.

Modules ROOT Pages Spring Cloud Gateway Server Webflux Cors Configuration (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/cors-configuration.adoc`) Copy Section

[[cors-configuration]]
= CORS Configuration
:cors-configuration-docs-uri: https://docs.spring.io/spring/docs/5.0.x/javadoc-api/org/springframework/web/cors/CorsConfiguration.html

You can configure the gateway to control CORS behavior globally or per route.
Both offer the same possibilities.

[[global-cors-configuration]]
== Global CORS Configuration

The "global" CORS configuration is a map of URL patterns to {cors-configuration-docs-uri}[Spring Framework CorsConfiguration].
The following example configures CORS:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
globalcors:
cors-configurations:
'[/**]':
allowedOrigins: "https://docs.spring.io"
allowedMethods:
- GET

In the preceding example, CORS requests are allowed from requests that originate from docs.spring.io for all GET requested paths.

To provide the same CORS configuration to requests that are not handled by some gateway route predicate, set the spring.cloud.gateway.server.webflux.globalcors.add-to-simple-url-handler-mapping property to true.
This is useful when you try to support CORS preflight requests and your route predicate does not evaluate to true because the HTTP method is options.

[[route-cors-configuration]]
== Route CORS Configuration

The "route" configuration allows applying CORS directly to a route as metadata with key cors.
Like in the case of global configuration, the properties belong to {cors-configuration-docs-uri}[Spring Framework CorsConfiguration].

NOTE: If no Path predicate is present in the route '/**' will be applied.

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: cors_route
uri: https://example.org
predicates:
- Path=/service/**
metadata:
cors:
allowedOrigins: ''
allowedMethods:
- GET
- POST
allowedHeaders: ''
maxAge: 30

Modules ROOT Pages Spring Cloud Gateway Server Webflux Developer Guide (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/developer-guide.adoc`) Copy Section

[[developer-guide]]
= Developer Guide

These are basic guides to writing some custom components of the gateway.

[[writing-custom-route-predicate-factories]]
== Writing Custom Route Predicate Factories

In order to write a Route Predicate you will need to implement RoutePredicateFactory as a bean. There is an abstract class called AbstractRoutePredicateFactory which you can extend.

.MyRoutePredicateFactory.java [source,java] Copy Chapter

@Component
public class MyRoutePredicateFactory extends AbstractRoutePredicateFactory<MyRoutePredicateFactory.Config> {

public MyRoutePredicateFactory() {
    super(Config.class);
}

@Override
public Predicate<ServerWebExchange> apply(Config config) {
    // grab configuration from Config object
    return exchange -> {
        //grab the request
        ServerHttpRequest request = exchange.getRequest();
        //take information from the request to see if it
        //matches configuration.
        return matches(config, request);
    };
}

public static class Config {
    //Put the configuration properties for your filter here
}

} Copy Chapter

[[writing-custom-gatewayfilter-factories]]
== Writing Custom GatewayFilter Factories

To write a GatewayFilter, you must implement GatewayFilterFactory as a bean.
You can extend an abstract class called AbstractGatewayFilterFactory.
The following examples show how to do so:

.PreGatewayFilterFactory.java

[source,java] Copy Chapter

@Component
public class PreGatewayFilterFactory extends AbstractGatewayFilterFactory {

public PreGatewayFilterFactory() {
	super(Config.class);
}

@Override
public GatewayFilter apply(Config config) {
	// grab configuration from Config object
	return (exchange, chain) -> {
		//If you want to build a "pre" filter you need to manipulate the
		//request before calling chain.filter
		ServerHttpRequest.Builder builder = exchange.getRequest().mutate();
		//use builder to manipulate the request
		return chain.filter(exchange.mutate().request(builder.build()).build());
	};
}

public static class Config {
	//Put the configuration properties for your filter here
}

} Copy Chapter

.PostGatewayFilterFactory.java [source,java] Copy Chapter

@Component
public class PostGatewayFilterFactory extends AbstractGatewayFilterFactory {

public PostGatewayFilterFactory() {
	super(Config.class);
}

@Override
public GatewayFilter apply(Config config) {
	// grab configuration from Config object
	return (exchange, chain) -> {
		return chain.filter(exchange).then(Mono.fromRunnable(() -> {
			ServerHttpResponse response = exchange.getResponse();
			//Manipulate the response in some way
		}));
	};
}

public static class Config {
	//Put the configuration properties for your filter here
}

} Copy Chapter

====

[[naming-custom-filters-and-references-in-configuration]]
=== Naming Custom Filters And References In Configuration

Custom filters class names should end in GatewayFilterFactory.

For example, to reference a filter named Something in configuration files, the filter
must be in a class named SomethingGatewayFilterFactory.

WARNING: It is possible to create a gateway filter named without the
GatewayFilterFactory suffix, such as class AnotherThing. This filter could be
referenced as AnotherThing in configuration files. This is not a supported naming
convention and this syntax may be removed in future releases. Please update the filter
name to be compliant.

[[writing-custom-global-filters]]
== Writing Custom Global Filters

To write a custom global filter, you must implement GlobalFilter interface as a bean.
This applies the filter to all requests.

The following examples show how to set up global pre- and post-filters, respectively:

[source,java] Copy Chapter

@Bean
public GlobalFilter customGlobalFilter() {
return (exchange, chain) -> exchange.getPrincipal()
.map(Principal::getName)
.defaultIfEmpty("Default User")
.map(userName -> {
//adds header to proxied request
ServerHttpRequest.Builder builder = exchange.getRequest().mutate().header("CUSTOM-REQUEST-HEADER", userName);
//use builder to manipulate the request
return exchange.mutate().request(builder.build()).build();
})
.flatMap(chain::filter);
}

@Bean
public GlobalFilter customGlobalPostFilter() {
return (exchange, chain) -> chain.filter(exchange)
.then(Mono.just(exchange))
.map(serverWebExchange -> {
//adds header to response
serverWebExchange.getResponse().getHeaders().set("CUSTOM-RESPONSE-HEADER",
HttpStatus.OK.equals(serverWebExchange.getResponse().getStatusCode()) ? "It worked": "It did not work");
return serverWebExchange;
})
.then();

} Copy Chapter

Modules ROOT Pages Spring Cloud Gateway Server Webflux Fluent Java Routes Api (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/fluent-java-routes-api.adoc`) Copy Section

[[fluent-java-routes-api]]
= Fluent Java Routes API

To allow for simple configuration in Java, the RouteLocatorBuilder bean includes a fluent API.
The following listing shows how it works:

.GatewaySampleApplication.java [source,java] Copy Chapter

// static imports from GatewayFilters and RoutePredicates
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder, ThrottleGatewayFilterFactory throttle) {
return builder.routes()
.route(r -> r.host(".abc.org").and().path("/image/png")
.filters(f ->
f.addResponseHeader("X-TestHeader", "foobar"))
.uri("http://httpbin.org:80")
)
.route(r -> r.path("/image/webp")
.filters(f ->
f.addResponseHeader("X-AnotherHeader", "baz"))
.uri("http://httpbin.org:80")
.metadata("key", "value")
)
.route(r -> r.order(-1)
.host(".throttle.org").and().path("/get")
.filters(f -> f.filter(throttle.apply(1,
1,
10,
TimeUnit.SECONDS)))
.uri("http://httpbin.org:80")
.metadata("key", "value")
)
.build();

} Copy Chapter

This style also allows for more custom predicate assertions.
The predicates defined by RouteDefinitionLocator beans are combined using logical and.
By using the fluent Java API, you can use the and(), or(), and negate() operators on the Predicate class.

Modules ROOT Pages Spring Cloud Gateway Server Webflux Gatewayfilter Factories (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/gatewayfilter-factories.adoc`) Copy Section

[[gatewayfilter-factories]]
= GatewayFilter Factories
:page-section-summary-toc: 1

Route filters allow the modification of the incoming HTTP request or outgoing HTTP response in some manner.
Route filters are scoped to a particular route.
Spring Cloud Gateway includes many built-in GatewayFilter Factories.

NOTE: For more detailed examples of how to use any of the following filters, take a look at the https://github.com/spring-cloud/spring-cloud-gateway/tree/main/spring-cloud-gateway-server-webflux/src/test/java/org/springframework/cloud/gateway/filter/factory[unit tests].

Modules ROOT Pages Spring Cloud Gateway Server Webflux Global Filters (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/global-filters.adoc`) Copy Section

[[global-filters]]
= Global Filters

The GlobalFilter interface has the same signature as GatewayFilter.
These are special filters that are conditionally applied to all routes.

NOTE: This interface and its usage are subject to change in future milestone releases.

[[gateway-combined-global-filter-and-gatewayfilter-ordering]]
== Combined Global Filter and GatewayFilter Ordering

When a request matches a route, the filtering web handler adds all instances of GlobalFilter and all route-specific instances of GatewayFilter to a filter chain.
This combined filter chain is sorted by the org.springframework.core.Ordered interface, which you can set by implementing the getOrder() method.

As Spring Cloud Gateway distinguishes between "pre" and "post" phases for filter logic execution (see xref:spring-cloud-gateway-server-webflux/how-it-works.adoc[How it Works]), the filter with the highest precedence is the first in the "pre"-phase and the last in the "post"-phase.

The following listing configures a filter chain:

.ExampleConfiguration.java [source,java] Copy Chapter

@Bean
public GlobalFilter customFilter() {
return new CustomGlobalFilter();
}

public class CustomGlobalFilter implements GlobalFilter, Ordered {

@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    log.info("custom global filter");
    return chain.filter(exchange);
}

@Override
public int getOrder() {
    return -1;
}

} Copy Chapter

[[gateway-metrics-filter]]
== The Gateway Metrics Filter

To enable gateway metrics, add spring-boot-starter-actuator as a project dependency. Then, by default, the gateway metrics filter runs as long as the spring.cloud.gateway.metrics.enabled property is not set to false.
This filter adds a timer metric named spring.cloud.gateway.requests with the following tags:

• routeId: The route ID.
• routeUri: The URI to which the API is routed.
• outcome: The outcome, as classified by link:https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/http/HttpStatus.Series.html[HttpStatus.Series].
• status: The HTTP status of the request returned to the client.
• httpStatusCode: The HTTP Status of the request returned to the client.
• httpMethod: The HTTP method used for the request.

In addition, through the spring.cloud.gateway.server.webflux.metrics.path-tags.enabled property (by default, false), you can activate an extra metric with the path tag:

• path: The path of the request.

WARNING: The property spring.cloud.gateway.server.webflux.metrics.tags.path.enabled will also add the above metric but has the side effect of the value ending up as a tag. This property is deprecated and will be removed in a future release.

These metrics are then available to be scraped from /actuator/metrics/spring.cloud.gateway.requests and can be easily integrated with Prometheus to create a link:images/gateway-grafana-dashboard.jpeg[Grafana] link:gateway-grafana-dashboard.json[dashboard].
You can also alarm with these useful metrics to take an example from link:gateway-alarming.adoc[alarming-template].

NOTE: To enable the prometheus endpoint, add micrometer-registry-prometheus as a project dependency.

[[local-cache-response-global-filter]]
== The Local Response Cache Filter

The LocalResponseCache runs if associated properties are enabled:

• spring.cloud.gateway.global-filter.local-response-cache.enabled: Activates the global cache for all routes
• spring.cloud.gateway.filter.local-response-cache.enabled: Activates the associated filter to use at route level

This feature enables a local cache using Caffeine for all responses that meet the following criteria:

• The request is a bodiless GET.
• The response has one of the following status codes: HTTP 200 (OK), HTTP 206 (Partial Content), or HTTP 301 (Moved Permanently).
• The HTTP Cache-Control header allows caching (that means it does not have any of the following values: no-store present in the request and no-store or private present in the response).

It accepts two configuration parameters:

• spring.cloud.gateway.filter.local-response-cache.size: Sets the maximum size of the cache to evict entries for this route (in KB, MB and GB).
• spring.cloud.gateway.filter.local-response-cache.time-to-live Sets the time to expire a cache entry (expressed in s for seconds, m for minutes, and h for hours).

If none of these parameters are configured but the global filter is enabled, by default, it configures 5 minutes of time to live for the cached response.

This filter also implements the automatic calculation of the max-age value in the HTTP Cache-Control header.
If max-age is present on the original response, the value is rewritten with the number of seconds set in the timeToLive configuration parameter.
In subsequent calls, this value is recalculated with the number of seconds left until the response expires.

Setting spring.cloud.gateway.global-filter.local-response-cache.enabled to false deactivate the local response cache for all routes, the xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/local-cache-response-filter.adoc[LocalResponseCache filter] allows to use this functionality at route level.

NOTE: To enable this feature, add com.github.ben-manes.caffeine:caffeine and spring-boot-starter-cache as project dependencies.

WARNING: If your project creates custom CacheManager beans, it will either need to be marked with @Primary or injected using @Qualifier.

[[forward-routing-filter]]
== Forward Routing Filter

The ForwardRoutingFilter looks for a URI in the exchange attribute ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR.
If the URL has a forward scheme (such as forward:///localendpoint), it uses the Spring DispatcherHandler to handle the request.
The path part of the request URL is overridden with the path in the forward URL.
The unmodified original URL is appended to the list in the ServerWebExchangeUtils.GATEWAY_ORIGINAL_REQUEST_URL_ATTR attribute.

[[netty-routing-filter]]
== The Netty Routing Filter

The Netty routing filter runs if the URL located in the ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR exchange attribute has a http or https scheme.
It uses the Netty HttpClient to make the downstream proxy request.
The response is put in the ServerWebExchangeUtils.CLIENT_RESPONSE_ATTR exchange attribute for use in a later filter.
(There is also an experimental WebClientHttpRoutingFilter that performs the same function but does not require Netty.)

[[netty-write-response-filter]]
== The Netty Write Response Filter

The NettyWriteResponseFilter runs if there is a Netty HttpClientResponse in the ServerWebExchangeUtils.CLIENT_RESPONSE_ATTR exchange attribute.
It runs after all other filters have completed and writes the proxy response back to the gateway client response.
(There is also an experimental WebClientWriteResponseFilter that performs the same function but does not require Netty.)

[[reactive-loadbalancer-client-filter]]
== ReactiveLoadBalancerClientFilter

The ReactiveLoadBalancerClientFilter looks for a URI in the exchange attribute named ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR.
If the URL has a lb scheme (such as lb://myservice), it uses the Spring Cloud ReactorLoadBalancer to resolve the name (myservice in this example) to an actual host and port and replaces the URI in the same attribute.
The unmodified original URL is appended to the list in the ServerWebExchangeUtils.GATEWAY_ORIGINAL_REQUEST_URL_ATTR attribute.
The filter also looks in the ServerWebExchangeUtils.GATEWAY_SCHEME_PREFIX_ATTR attribute to see if it equals lb.
If so, the same rules apply.
The following listing configures a ReactiveLoadBalancerClientFilter:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: myRoute
uri: lb://service
predicates:
- Path=/service/**

NOTE: By default, when a service instance cannot be found by the ReactorLoadBalancer, a 503 is returned.
You can configure the gateway to return a 404 by setting spring.cloud.gateway.loadbalancer.use404=true.

NOTE: The isSecure value of the ServiceInstance returned from the ReactiveLoadBalancerClientFilter overrides
the scheme specified in the request made to the Gateway.
For example, if the request comes into the Gateway over HTTPS but the ServiceInstance indicates it is not secure, the downstream request is made over HTTP.
The opposite situation can also apply.
However, if GATEWAY_SCHEME_PREFIX_ATTR is specified for the route in the Gateway configuration, the prefix is stripped and the resulting scheme from the route URL overrides the ServiceInstance configuration.

TIP: Gateway supports all the LoadBalancer features. You can read more about them in the https://docs.spring.io/spring-cloud-commons/docs/current/reference/html/#spring-cloud-loadbalancer[Spring Cloud Commons documentation].

[[routetorequesturl-filter]]
== RouteToRequestUrl Filter

If there is a Route object in the ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR exchange attribute, the RouteToRequestUrlFilter runs.
It creates a new URI, based off of the request URI but updated with the URI attribute of the Route object.
The new URI is placed in the ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR exchange attribute.

If the URI has a scheme prefix, such as lb:ws://serviceid, the lb scheme is stripped from the URI and placed in the ServerWebExchangeUtils.GATEWAY_SCHEME_PREFIX_ATTR for use later in the filter chain.

[[websocket-routing-filter]]
== The Websocket Routing Filter

If the URL located in the ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR exchange attribute has a ws or wss scheme, the websocket routing filter runs. It uses the Spring WebSocket infrastructure to forward the websocket request downstream.

You can load-balance websockets by prefixing the URI with lb, such as lb:ws://serviceid.

NOTE: If you use https://github.com/sockjs[SockJS] as a fallback over normal HTTP, you should configure a normal HTTP route as well as the websocket Route.

The following listing configures a websocket routing filter:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
# SockJS route
- id: websocket_sockjs_route
uri: http://localhost:3001
predicates:
- Path=/websocket/info/**
# Normal Websocket route
- id: websocket_route
uri: ws://localhost:3001
predicates:
- Path=/websocket/**

[[marking-an-exchange-as-routed]]
== Marking An Exchange As Routed

After the gateway has routed a ServerWebExchange, it marks that exchange as "routed" by adding gatewayAlreadyRouted
to the exchange attributes. Once a request has been marked as routed, other routing filters will not route the request again,
essentially skipping the filter. There are convenience methods that you can use to mark an exchange as routed
or check if an exchange has already been routed.

• ServerWebExchangeUtils.isAlreadyRouted takes a ServerWebExchange object and checks if it has been "routed".
• ServerWebExchangeUtils.setAlreadyRouted takes a ServerWebExchange object and marks it as "routed".

Modules ROOT Pages Spring Cloud Gateway Server Webflux Glossary (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/glossary.adoc`) Copy Section

[[glossary]]
= Glossary
:page-section-summary-toc: 1

• Route: The basic building block of the gateway.
  It is defined by an ID, a destination URI, a collection of predicates, and a collection of filters. A route is matched if the aggregate predicate is true.
• Predicate: This is a https://docs.oracle.com/javase/8/docs/api/java/util/function/Predicate.html[Java 8 Function Predicate]. The input type is a https://docs.spring.io/spring/docs/5.0.x/javadoc-api/org/springframework/web/server/ServerWebExchange.html[Spring Framework ServerWebExchange].
  This lets you match on anything from the HTTP request, such as headers or parameters.
• Filter: These are instances of https://github.com/spring-cloud/spring-cloud-gateway/blob/main/spring-cloud-gateway-server-webflux/src/main/java/org/springframework/cloud/gateway/filter/GatewayFilter.java[`GatewayFilter`] that have been constructed with a specific factory.
  Here, you can modify requests and responses before or after sending the downstream request.

Modules ROOT Pages Spring Cloud Gateway Server Webflux How It Works (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/how-it-works.adoc`) Copy Section

[[gateway-how-it-works]]
= How It Works
:page-section-summary-toc: 1

The following diagram provides a high-level overview of how Spring Cloud Gateway works:

image::spring_cloud_gateway_diagram.png[Spring Cloud Gateway Diagram]

Clients make requests to Spring Cloud Gateway. If the Gateway Handler Mapping determines that a request matches a route, it is sent to the Gateway Web Handler.
This handler runs the request through a filter chain that is specific to the request.
The reason the filters are divided by the dotted line is that filters can run logic both before and after the proxy request is sent.
All "pre" filter logic is executed. Then the proxy request is made. After the proxy request is made, the "post" filter logic is run.

NOTE: URIs defined in routes without a port get default port values of 80 and 443 for the HTTP and HTTPS URIs, respectively.

WARNING: Any path defined on a route URI will be ignored.

Modules ROOT Pages Spring Cloud Gateway Server Webflux Http Client (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/http-client.adoc`) Copy Section

[[http-client]]
= The HttpClientCustomizer

The HttpClientCustomizer interface in spring-cloud-gateway allows for the customization of the HTTP client used by the gateway. It provides a single method, customize, which takes an HttpClient as an argument and returns a customized version of it.

This interface is useful for scenarios where you need to configure specific settings or behaviors for the HTTP client, such as setting timeouts, adding custom headers, or enabling specific features. By implementing this interface, you can provide a custom implementation that meets your specific requirements.

Here's an example of how you might use the HttpClientCustomizer interface:

.MyHttpClientCustomizer.java [source,java] Copy Chapter

import org.springframework.cloud.gateway.config.HttpClientCustomizer;
import reactor.netty.http.client.HttpClient;

public class MyHttpClientCustomizer implements HttpClientCustomizer {

@Override
public HttpClient customize(HttpClient httpClient) {
    // Customize the HTTP client here
    return httpClient.tcpConfiguration(tcpClient -> {
        // Set the connect timeout to 5 seconds
        tcpClient.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000);
        // Set the read timeout to 10 seconds
        tcpClient.option(ChannelOption.SO_TIMEOUT, 10000);
        return tcpClient;
    });
}

} Copy Chapter

In this example, the MyHttpClientCustomizer class implements the HttpClientCustomizer interface and overrides the customize method. Within this method, the HTTP client is customized by setting the connect timeout to 5 seconds and the read timeout to 10 seconds.

To use this customizer, you would need to register it with the Spring Cloud Gateway configuration:

.GatewayConfiguration.java [source,java] Copy Chapter

@Configuration
public class GatewayConfiguration {

@Bean
public HttpClientCustomizer myHttpClientCustomizer() {
    return new MyHttpClientCustomizer();
}

} Copy Chapter

By registering the customizer as a bean, it will be automatically applied to the HTTP client used by the gateway.

Modules ROOT Pages Spring Cloud Gateway Server Webflux Http Timeouts Configuration (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/http-timeouts-configuration.adoc`) Copy Section

[[http-timeouts-configuration]]
= Http timeouts configuration

Http timeouts (response and connect) can be configured for all routes and overridden for each specific route.

[[global-timeouts]]
== Global timeouts
To configure Global http timeouts: +
connect-timeout must be specified in milliseconds. +
response-timeout must be specified as a java.time.Duration

.global http timeouts example [source,yaml] Copy Chapter

spring:
cloud:
gateway:
httpclient:
connect-timeout: 1000
response-timeout: 5s

[[per-route-timeouts]]
== Per-route timeouts
To configure per-route timeouts: +
connect-timeout must be specified in milliseconds. +
response-timeout must be specified in milliseconds.

.per-route http timeouts configuration via configuration [source,yaml] Copy Chapter

- id: per_route_timeouts
    uri: https://example.org
    predicates:
      - name: Path
        args:
          pattern: /delay/{timeout}
    metadata:
      response-timeout: 200
      connect-timeout: 200

.per-route timeouts configuration using Java DSL [source,java] Copy Chapter

import static org.springframework.cloud.gateway.support.RouteMetadataUtils.CONNECT_TIMEOUT_ATTR;
import static org.springframework.cloud.gateway.support.RouteMetadataUtils.RESPONSE_TIMEOUT_ATTR;

@Bean
  public RouteLocator customRouteLocator(RouteLocatorBuilder routeBuilder){
     return routeBuilder.routes()
           .route("test1", r -> {
              return r.host("*.somehost.org").and().path("/somepath")
                    .filters(f -> f.addRequestHeader("header1", "header-value-1"))
                    .uri("http://someuri")
                    .metadata(RESPONSE_TIMEOUT_ATTR, 200)
                    .metadata(CONNECT_TIMEOUT_ATTR, 200);
           })
           .build();
  }

A per-route response-timeout with a negative value will disable the global response-timeout value.

- id: per_route_timeouts
    uri: https://example.org
    predicates:
      - name: Path
        args:
          pattern: /delay/{timeout}
    metadata:
      response-timeout: -1

Modules ROOT Pages Spring Cloud Gateway Server Webflux Httpheadersfilters (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/httpheadersfilters.adoc`) Copy Section

[[httpheadersfilters]]
= HttpHeadersFilters

HttpHeadersFilters are applied to the requests before sending them downstream, such as in the NettyRoutingFilter.

[[forwarded-headers-filter]]
== Forwarded Headers Filter
The Forwarded Headers Filter creates a Forwarded header to send to the downstream service. It adds the Host header, scheme and port of the current request to any existing Forwarded header. To activate this filter set the spring.cloud.gateway.server.webflux.trusted-proxies property to a Java Regular Expression. This regular expression defines the proxies that are trusted when they appear in the Forwarded header.

The Forwarded by header part can be enabled by setting the following property to true (defaults to false):

• spring.cloud.gateway.server.webflux.forwarded.by.enabled=true

[[removehopbyhop-headers-filter]]
== RemoveHopByHop Headers Filter
The RemoveHopByHop Headers Filter removes headers from forwarded requests. The default list of headers that is removed comes from the https://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-14#section-7.1.3[IETF].

.The default removed headers are:

• Connection
• Keep-Alive
• Proxy-Authenticate
• Proxy-Authorization
• TE
• Trailer
• Transfer-Encoding
• Upgrade

To change this, set the spring.cloud.gateway.server.webflux.filter.remove-hop-by-hop.headers property to the list of header names to remove.

[[xforwarded-headers-filter]]
== XForwarded Headers Filter
The XForwarded Headers Filter creates various X-Forwarded-* headers to send to the downstream service. It uses the Host header, scheme, port and path of the current request to create the various headers. To activate this filter set the spring.cloud.gateway.server.webflux.trusted-proxies property to a Java Regular Expression. This regular expression defines the proxies that are trusted when they appear in the Forwarded header.

Creating of individual headers can be controlled by the following boolean properties (defaults to true):

• spring.cloud.gateway.server.webflux.x-forwarded.for-enabled
• spring.cloud.gateway.server.webflux.x-forwarded.host-enabled
• spring.cloud.gateway.server.webflux.x-forwarded.port-enabled
• spring.cloud.gateway.server.webflux.x-forwarded.proto-enabled
• spring.cloud.gateway.server.webflux.x-forwarded.prefix-enabled

Appending multiple headers can be controlled by the following boolean properties (defaults to true):

• spring.cloud.gateway.server.webflux.x-forwarded.for-append
• spring.cloud.gateway.server.webflux.x-forwarded.host-append
• spring.cloud.gateway.server.webflux.x-forwarded.port-append
• spring.cloud.gateway.server.webflux.x-forwarded.proto-append
• spring.cloud.gateway.server.webflux.x-forwarded.prefix-append

Modules ROOT Pages Spring Cloud Gateway Server Webflux Reactor Netty Access Logs (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/reactor-netty-access-logs.adoc`) Copy Section

[[reactor-netty-access-logs]]
= Reactor Netty Access Logs

To enable Reactor Netty access logs, set -Dreactor.netty.http.server.accessLogEnabled=true.

IMPORTANT: It must be a Java System Property, not a Spring Boot property.

You can configure the logging system to have a separate access log file. The following example creates a Logback configuration:

.logback.xml [source,xml] Copy Chapter

<appender name="accessLog" class="ch.qos.logback.core.FileAppender">
    <file>access_log.log</file>
    <encoder>
        %msg%n
    </encoder>
</appender>
<appender name="async" class="ch.qos.logback.classic.AsyncAppender">
    <appender-ref ref="accessLog" />
</appender>

<logger name="reactor.netty.http.server.AccessLog" level="INFO" additivity="false">
    <appender-ref ref="async"/>
</logger>

Modules ROOT Pages Spring Cloud Gateway Server Webflux Request Predicates Factories (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/request-predicates-factories.adoc`) Copy Section

[[gateway-request-predicates-factories]]
= Route Predicate Factories

Spring Cloud Gateway matches routes as part of the Spring WebFlux HandlerMapping infrastructure.
Spring Cloud Gateway includes many built-in route predicate factories.
All of these predicates match on different attributes of the HTTP request.
You can combine multiple route predicate factories with logical and statements.

[[after-route-predicate-factory]]
== The After Route Predicate Factory

The After route predicate factory takes one parameter, a datetime (which is a java ZonedDateTime).
This predicate matches requests that happen after the specified datetime.
The following example configures an after route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: after_route
uri: https://example.org
predicates:
- After=2017-01-20T17:42:47.789-07:00[America/Denver]

This route matches any request made after Jan 20, 2017 17:42 Mountain Time (Denver).

[[before-route-predicate-factory]]
== The Before Route Predicate Factory

The Before route predicate factory takes one parameter, a datetime (which is a java ZonedDateTime).
This predicate matches requests that happen before the specified datetime.
The following example configures a before route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: before_route
uri: https://example.org
predicates:
- Before=2017-01-20T17:42:47.789-07:00[America/Denver]

This route matches any request made before Jan 20, 2017 17:42 Mountain Time (Denver).

[[between-route-predicate-factory]]
== The Between Route Predicate Factory

The Between route predicate factory takes two parameters, datetime1 and datetime2
which are java ZonedDateTime objects.
This predicate matches requests that happen after datetime1 and before datetime2.
The datetime2 parameter must be after datetime1.
The following example configures a between route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: between_route
uri: https://example.org
predicates:
- Between=2017-01-20T17:42:47.789-07:00[America/Denver], 2017-01-21T17:42:47.789-07:00[America/Denver]

This route matches any request made after Jan 20, 2017 17:42 Mountain Time (Denver) and before Jan 21, 2017 17:42 Mountain Time (Denver).
This could be useful for maintenance windows.

[[cookie-route-predicate-factory]]
== The Cookie Route Predicate Factory

The Cookie route predicate factory takes two parameters, the cookie name and a regexp (which is a Java regular expression).
This predicate matches cookies that have the given name and whose values match the regular expression.
The following example configures a cookie route predicate factory:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: cookie_route
uri: https://example.org
predicates:
- Cookie=chocolate, ch.p

This route matches requests that have a cookie named chocolate whose value matches the ch.p regular expression.

[[header-route-predicate-factory]]
== The Header Route Predicate Factory

The Header route predicate factory takes two parameters, the header and a regexp (which is a Java regular expression).
This predicate matches with a header that has the given name whose value matches the regular expression.
The following example configures a header route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: header_route
uri: https://example.org
predicates:
- Header=X-Request-Id, \d+

This route matches if the request has a header named X-Request-Id whose value matches the \d+ regular expression (that is, it has a value of one or more digits).

[[host-route-predicate-factory]]
== The Host Route Predicate Factory

The Host route predicate factory takes one parameter: a list of host name patterns.
The pattern is an Ant-style pattern with . as the separator.
This predicates matches the Host header that matches the pattern.
The following example configures a host route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: host_route
uri: https://example.org
predicates:
- Host=.somehost.org,.anotherhost.org

URI template variables (such as \{sub}.myhost.org) are supported as well.

This route matches if the request has a Host header with a value of www.somehost.org or beta.somehost.org or www.anotherhost.org.

This predicate extracts the URI template variables (such as sub, defined in the preceding example) as a map of names and values and places it in the ServerWebExchange.getAttributes() with a key defined in ServerWebExchangeUtils.URI_TEMPLATE_VARIABLES_ATTRIBUTE.
Those values are then available for use by <<gateway-route-filters,GatewayFilter factories>>

[[method-route-predicate-factory]]
== The Method Route Predicate Factory

The Method Route Predicate Factory takes a methods argument which is one or more parameters: the HTTP methods to match.
The following example configures a method route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: method_route
uri: https://example.org
predicates:
- Method=GET,POST

This route matches if the request method was a GET or a POST.

[[path-route-predicate-factory]]
== The Path Route Predicate Factory

The Path Route Predicate Factory takes two parameters: a list of Spring PathMatcher patterns and an optional flag called matchTrailingSlash (defaults to true).
The following example configures a path route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: path_route
uri: https://example.org
predicates:
- Path=/red/{segment},/blue/{segment}

This route matches if the request path was, for example: /red/1 or /red/1/ or /red/blue or /blue/green.

If matchTrailingSlash is set to false, then request path /red/1/ will not be matched.

[[path-route-predicate-factory-expanded-arguments]]
=== Fully Expanded Arguments

When using the fully expanded argument format (for example, when configuring routes via the Actuator API or programmatically), the Path predicate uses indexed keys for list parameters. The following example shows the fully expanded configuration:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: path_route
uri: https://example.org
predicates:
- name: Path
args:
patterns.0: /red/{segment}
patterns.1: /blue/{segment}
matchTrailingSlash: false

When posting route definitions via the Actuator API, use the same indexed notation in the JSON request body:

[source,json] Copy Chapter

{
"id": "path_route",
"uri": "https://example.org",
"predicates": [
{
"name": "Path",
"args": {
"patterns.0": "/red/{segment}",
"patterns.1": "/blue/{segment}",
"matchTrailingSlash": "false"
}
}
]

} Copy Chapter

NOTE: The args map accepts only String key-value pairs. List parameters like patterns must be specified using indexed keys (patterns.0, patterns.1, etc.) rather than JSON arrays. This indexed notation is automatically converted to a List<String> when the predicate is configured.

If you have set spring.webflux.base-path property, this will influence the path matching. The property value will be automatically prepended to the path patterns. For example, with spring.webflux.base-path=/app and a path pattern of /red/\{segment\}, the full pattern used for matching would be /app/red/\{segment\}.

This predicate extracts the URI template variables (such as segment, defined in the preceding example) as a map of names and values and places it in the ServerWebExchange.getAttributes() with a key defined in ServerWebExchangeUtils.URI_TEMPLATE_VARIABLES_ATTRIBUTE.
Those values are then available for use by <<gateway-route-filters,GatewayFilter factories>>

A utility method (called get) is available to make access to these variables easier.
The following example shows how to use the get method:

[source,java] Copy Chapter

Map<String, String> uriVariables = ServerWebExchangeUtils.getUriTemplateVariables(exchange);

String segment = uriVariables.get("segment"); Copy Chapter

[[query-route-predicate-factory]]
== The Query Route Predicate Factory

The Query route predicate factory takes two parameters: a required param and an optional regexp (which is a Java regular expression).
The following example configures a query route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: query_route
uri: https://example.org
predicates:
- Query=green

The preceding route matches if the request contained a green query parameter.

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: query_route
uri: https://example.org
predicates:
- Query=red, gree.

The preceding route matches if the request contained a red query parameter whose value matched the gree. regexp, so green and greet would match.

[[remoteaddr-route-predicate-factory]]
== The RemoteAddr Route Predicate Factory

The RemoteAddr route predicate factory takes a list (min size 1) of sources, which are CIDR-notation (IPv4 or IPv6) strings, such as 192.168.0.1/16 (where 192.168.0.1 is an IP address and 16 is a subnet mask).
The following example configures a RemoteAddr route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: remoteaddr_route
uri: https://example.org
predicates:
- RemoteAddr=192.168.1.1/24

This route matches if the remote address of the request was, for example, 192.168.1.10.

[[modifying-the-way-remote-addresses-are-resolved]]
=== Modifying the Way Remote Addresses Are Resolved

By default, the RemoteAddr route predicate factory uses the remote address from the incoming request.
This may not match the actual client IP address if Spring Cloud Gateway sits behind a proxy layer.

You can customize the way that the remote address is resolved by setting a custom RemoteAddressResolver.
Spring Cloud Gateway comes with one non-default remote address resolver that is based off of the https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For[X-Forwarded-For header], XForwardedRemoteAddressResolver.

XForwardedRemoteAddressResolver has two static constructor methods, which take different approaches to security:

• XForwardedRemoteAddressResolver::trustAll returns a RemoteAddressResolver that always takes the first IP address found in the X-Forwarded-For header.
  This approach is vulnerable to spoofing, as a malicious client could set an initial value for the X-Forwarded-For, which would be accepted by the resolver.

• XForwardedRemoteAddressResolver::maxTrustedIndex takes an index that correlates to the number of trusted infrastructure running in front of Spring Cloud Gateway.
  If Spring Cloud Gateway is, for example only accessible through HAProxy, then a value of 1 should be used.
  If two hops of trusted infrastructure are required before Spring Cloud Gateway is accessible, then a value of 2 should be used.

Consider the following header value:

[source] Copy Chapter

X-Forwarded-For: 0.0.0.1, 0.0.0.2, 0.0.0.3 Copy Chapter

The following maxTrustedIndex values yield the following remote addresses:

[options="header"]
|===
|maxTrustedIndex | result
|[Integer.MIN_VALUE,0] | (invalid, IllegalArgumentException during initialization)
|1 | 0.0.0.3
|2 | 0.0.0.2
|3 | 0.0.0.1
|[4, Integer.MAX_VALUE] | 0.0.0.1
|===

[[gateway-route-filters]]
The following example shows how to achieve the same configuration with Java:

.GatewayConfig.java [source,java] Copy Chapter

RemoteAddressResolver resolver = XForwardedRemoteAddressResolver
.maxTrustedIndex(1);

...

.route("direct-route",
r -> r.remoteAddr("10.1.1.1", "10.10.1.1/24")
.uri("https://downstream1")
.route("proxied-route",
r -> r.remoteAddr(resolver, "10.10.1.1", "10.10.1.1/24")
.uri("https://downstream2")

) Copy Chapter

[[weight-route-predicate-factory]]
== The Weight Route Predicate Factory

The Weight route predicate factory takes two arguments: group and weight (an int). The weights are calculated per group.
The following example configures a weight route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: weight_high
uri: https://weighthigh.org
predicates:
- Weight=group1, 8
- id: weight_low
uri: https://weightlow.org
predicates:
- Weight=group1, 2

This route would forward ~80% of traffic to https://weighthigh.org and ~20% of traffic to https://weightlow.org

[[xforwarded-remote-addr-route-predicate-factory]]
== The XForwarded Remote Addr Route Predicate Factory

The XForwarded Remote Addr route predicate factory takes a list (min size 1) of sources, which are CIDR-notation (IPv4 or IPv6) strings, such as 192.168.0.1/16 (where 192.168.0.1 is an IP address and 16 is a subnet mask).

This route predicate allows requests to be filtered based on the X-Forwarded-For HTTP header.

This can be used with reverse proxies such as load balancers or web application firewalls where
the request should only be allowed if it comes from a trusted list of IP addresses used by those
reverse proxies.

The following example configures a XForwardedRemoteAddr route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: xforwarded_remoteaddr_route
uri: https://example.org
predicates:
- XForwardedRemoteAddr=192.168.1.1/24

This route matches if the X-Forwarded-For header contains, for example, 192.168.1.10.

[[version-route-predicate-factory]]
== The Version Route Predicate Factory

The Version route predicate factory matches requests based on the API version extracted from
the incoming request.
The version is resolved and parsed by the ApiVersionStrategy that is configured through
Spring Framework's API versioning support (spring.webflux.apiversion.*).

[[version-route-predicate-factory-version-strategy]]
=== Configuring the API Version Strategy

Before using the Version predicate you must configure at least one version resolver so that
Spring (and Gateway) knows how to extract the version from each incoming request.
The following example configures version resolution from an HTTP header, a query parameter, and
an application/json media-type parameter:

.application.yml [source,yaml] Copy Chapter

spring:
webflux:
apiversion:
use:
header: X-API-Version # extract version from this header
query-parameter: apiVersion # or from this query parameter
media-type-parameter: # or from the named media-type parameter
"[application/json]": version
required: false # allow requests without an explicit version

To extract the version from a path segment instead, set path-segment to the zero-based
index of the segment that carries the version:

.application.yml [source,yaml] Copy Chapter

spring:
webflux:
apiversion:
use:
path-segment: 1 # /v1/users → version = "1"

[[version-route-predicate-factory-usage]]
=== Using the Version Predicate

The predicate accepts a single version argument and supports two forms:

• Fixed version — the route matches only requests whose resolved version equals the given
  version exactly.
• Baseline version (version+) — the route matches requests whose resolved version is
  greater than or equal to the given version.

The following example configures a fixed-version route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: version_13_route
uri: https://example.org
predicates:
- Path=/api/**
- Version=1.3

This route matches only requests that carry exactly version 1.3.

The following example uses a baseline version:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: version_11_plus_route
uri: https://example.org
predicates:
- Path=/api/**
- Version=1.1+

This route matches requests with version 1.1 or any later version (for example 1.2, 1.5,
or 2.0).
A baseline version lets a single route continue to serve requests across multiple API
versions until a breaking change makes a new route necessary.

NOTE: If no ApiVersionStrategy bean is present (that is, no spring.webflux.apiversion.use.*
property is set), the Version predicate is still registered but always passes — any request
without a resolved version is treated as matching.

[[read-body-route-predicate-factory]]
== The ReadBody Route Predicate Factory

The ReadBody route predicate factory reads the request body and applies a user-provided
predicate against it. The body is cached in memory after the first read, so subsequent
evaluations do not need to deserialize it again.

NOTE: This predicate can only be configured programmatically via the Java DSL.
It cannot be configured via YAML because the predicate parameter requires a Java
Predicate lambda, which cannot be expressed in a configuration file.

The following example configures a ReadBody route predicate:

.GatewayConfig.java [source,java] Copy Chapter

@Bean
public RouteLocator routes(RouteLocatorBuilder builder) {
return builder.routes()
.route("read-body-route", r -> r
.readBody(String.class, body -> body.contains("yes"))
.uri("https://example.org"))
.build();

} Copy Chapter

In the preceding example, the predicate checks whether the request body (deserialized as
a String) contains the word yes. If so, the route matches and the request is forwarded
to https://example.org.

The readBody method accepts two parameters:

• inClass - the class to deserialize the request body into (for example, String.class
  or a custom request DTO class).
• predicate - a Java Predicate<T> that receives the deserialized body and returns
  true if the route should match.

Modules ROOT Pages Spring Cloud Gateway Server Webflux Route Metadata Configuration (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/route-metadata-configuration.adoc`) Copy Section

[[route-metadata-configuration]]
= Route Metadata Configuration

You can configure additional parameters for each route by using metadata, as follows:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: route_with_metadata
uri: https://example.org
metadata:
optionName: "OptionValue"
compositeObject:
name: "value"
iAmNumber: 1

You could acquire all metadata properties from an exchange, as follows:

[source] Copy Chapter

Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR); // get all metadata properties route.getMetadata(); // get a single metadata property route.getMetadata(someKey); Copy Chapter

Modules ROOT Pages Spring Cloud Gateway Server Webflux Sharing Routes (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/sharing-routes.adoc`) Copy Section

[[sharing-routes-between-multiple-gateway-instances]]
= Sharing Routes between multiple Gateway instances

Spring Cloud Gateway offers two RouteDefinitionRepository implementations. The first one is the
InMemoryRouteDefinitionRepository which only lives within the memory of one Gateway instance.
This type of Repository is not suited to populate Routes across multiple Gateway instances.

In order to share Routes across a cluster of Spring Cloud Gateway instances, RedisRouteDefinitionRepository can be used.
To enable this kind of repository, the following property has to set to true: spring.cloud.gateway.redis-route-definition-repository.enabled
Likewise to the RedisRateLimiter Filter Factory it requires the use of the spring-boot-starter-data-redis-reactive Spring Boot starter.

Modules ROOT Pages Spring Cloud Gateway Server Webflux Spring Security (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/spring-security.adoc`) Copy Section

[[spring-security]]
= Spring Security Integration

Spring Cloud Gateway Server WebFlux works with https://spring.io/projects/spring-security[Spring Security] to secure routes and relay tokens to downstream services.

== Dependencies

To add Spring Security to the gateway, include one or more of the following starters:

.pom.xml [source,xml] Copy Chapter

== Default Behavior

When spring-boot-starter-security is on the classpath, Spring Boot auto-configures a SecurityWebFilterChain that requires all requests to be authenticated.
You must provide an explicit SecurityWebFilterChain bean to open up specific paths or apply custom rules.

The following example allows health-check endpoints without authentication and requires a valid JWT on all other requests:

.RouteSecurityConfiguration.java [source,java] Copy Chapter

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
import org.springframework.security.config.web.server.ServerHttpSecurity;
import org.springframework.security.web.server.SecurityWebFilterChain;

@Configuration
@EnableWebFluxSecurity
public class RouteSecurityConfiguration {

@Bean
public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
    return http
            .authorizeExchange(exchanges -> exchanges
                    .pathMatchers("/actuator/health/**").permitAll()
                    .anyExchange().authenticated())
            .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults()))
            .build();
}

} Copy Chapter

== Token Relay

When the gateway acts as an OAuth2 client, it can forward the currently authenticated user's access token to downstream services.
See the xref:spring-cloud-gateway-server-webflux/gatewayfilter-factories/tokenrelay-factory.adoc[TokenRelay GatewayFilter Factory] documentation for usage and required dependencies.

== Further Reading

See the https://docs.spring.io/spring-security/reference/reactive/index.html[Spring Security Reactive Web Applications] reference for full details on SecurityWebFilterChain, method security, and OAuth2 integration.

Modules ROOT Pages Spring Cloud Gateway Server Webflux Starter (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/starter.adoc`) Copy Section

[[gateway-starter]]
= How to Include Spring Cloud Gateway
:page-section-summary-toc: 1

To include Spring Cloud Gateway in your project, use the starter with a group ID of org.springframework.cloud and an artifact ID of spring-cloud-starter-gateway-server-webflux.
See the https://projects.spring.io/spring-cloud/[Spring Cloud Project page] for details on setting up your build system with the current Spring Cloud Release Train.

If you include the starter, but you do not want the gateway to be enabled, set spring.cloud.gateway.enabled=false.

IMPORTANT: Spring Cloud Gateway is built on https://spring.io/projects/spring-boot#learn[Spring Boot], https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html[Spring WebFlux], and https://projectreactor.io/docs[Project Reactor].
As a consequence, many of the familiar synchronous libraries (Spring Data and Spring Security, for example) and patterns you know may not apply when you use Spring Cloud Gateway.
If you are unfamiliar with these projects, we suggest you begin by reading their documentation to familiarize yourself with some new concepts before working with Spring Cloud Gateway.

IMPORTANT: Spring Cloud Gateway requires the Netty runtime provided by Spring Boot and Spring Webflux.
It does not work in a traditional Servlet Container or when built as a WAR.

Modules ROOT Pages Spring Cloud Gateway Server Webflux The Discoveryclient Route Definition Locator (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/the-discoveryclient-route-definition-locator.adoc`) Copy Section

[[discoveryclient-route-definition-locator]]
= DiscoveryClient Route Definition Locator

You can configure the gateway to create routes based on services registered with a DiscoveryClient compatible service registry.

By default, the routes created use the protocol lb://service-name (where service-name is the String that DiscoveryClient::getServices will return) and this means that they are load-balanced. For that reason, you also need to include the org.springframework.cloud:spring-cloud-starter-loadbalancer dependency, so that it is available on the classpath.

To enable this, set spring.cloud.gateway.discovery.locator.enabled=true and make sure a DiscoveryClient implementation (such as Netflix Eureka, Consul, Zookeeper or Kubernetes) is on the classpath and enabled.

[[configuring-predicates-and-filters-for-discoveryclient-routes]]
== Configuring Predicates and Filters For DiscoveryClient Routes

By default, the gateway defines a single predicate and filter for routes created with a DiscoveryClient.

The default predicate is a path predicate defined with the pattern /serviceId/**, where serviceId is
the ID of the service from the DiscoveryClient.

The default filter is a rewrite path filter with the regex /serviceId/?(?<remaining>.*) and the replacement /$\{remaining}.
This strips the service ID from the path before the request is sent downstream.

If you want to customize the predicates or filters used by the DiscoveryClient routes, set spring.cloud.gateway.discovery.locator.predicates[x] and spring.cloud.gateway.discovery.locator.filters[y].

[IMPORTANT]

Setting `spring.cloud.gateway.discovery.locator.filters` *replaces* the entire default filter list. If you only add your own filters without re-declaring `RewritePath`, the service ID will *not* be stripped from the path and requests will fail with a `404` on the downstream service. Always include the default `RewritePath` filter when defining custom filters, as shown in the examples below.

The following examples shows what this looks like in properties and yaml format:

.application.properties [soure,properties]

spring.cloud.gateway.discovery.locator.predicates[0].name=Path spring.cloud.gateway.discovery.locator.predicates[0].args[pattern]="'/'+serviceId+'/**'" spring.cloud.gateway.discovery.locator.predicates[1].name=Host spring.cloud.gateway.discovery.locator.predicates[1].args[pattern]="'**.foo.com'" spring.cloud.gateway.discovery.locator.filters[0].name=CircuitBreaker spring.cloud.gateway.discovery.locator.filters[0].args[name]=serviceId spring.cloud.gateway.discovery.locator.filters[1].name=RewritePath spring.cloud.gateway.discovery.locator.filters[1].args[regexp]="'/' + serviceId + '/?(?.*)'" spring.cloud.gateway.discovery.locator.filters[1].args[replacement]="'/$\{remaining}'" Copy Chapter

====

.application.yml

[source,yaml] Copy Chapter

spring:
cloud:
gateway:
discovery:
locator:
predicates:
- name: Host
args:
pattern: "'.foo.com'"
- name: Path
args:
pattern: "'/'+serviceId+'/'"
filters:
- name: CircuitBreaker
args:
name: serviceId
- name: RewritePath
args:
regexp: "'/' + serviceId + '/?(?.*)'"
replacement: "'/${remaining}'"

====

Modules ROOT Pages Spring Cloud Gateway Server Webflux Tls And Ssl (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/tls-and-ssl.adoc`) Copy Section

[[tls-and-ssl]]
= TLS and SSL

The gateway can listen for requests on HTTPS by following the usual Spring server configuration.
The following example shows how to do so:

.application.yml [source,yaml] Copy Chapter

server:
ssl:
enabled: true
key-alias: scg
key-store-password: scg1234
key-store: classpath:scg-keystore.p12
key-store-type: PKCS12

You can route gateway routes to both HTTP and HTTPS backends.
If you are routing to an HTTPS backend, you can configure the gateway to trust all downstream certificates with the following configuration:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
httpclient:
ssl:
useInsecureTrustManager: true

Using an insecure trust manager is not suitable for production.
For a production deployment, you can configure the gateway with a set of known certificates that it can trust with the following configuration:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
httpclient:
ssl:
trustedX509Certificates:
- cert1.pem
- cert2.pem

If the Spring Cloud Gateway is not provisioned with trusted certificates, the default trust store is used (which you can override by setting the javax.net.ssl.trustStore system property).

[[tls-handshake]]
== TLS Handshake

The gateway maintains a client pool that it uses to route to backends.
When communicating over HTTPS, the client initiates a TLS handshake.
A number of timeouts are associated with this handshake.
You can configure these timeouts can be configured (defaults shown) as follows:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
httpclient:
ssl:
handshake-timeout-millis: 10000
close-notify-flush-timeout-millis: 3000
close-notify-read-timeout-millis: 0

Modules ROOT Pages Spring Cloud Gateway Server Webflux Troubleshooting (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/troubleshooting.adoc`) Copy Section

[[troubleshooting]]
= Troubleshooting
:page-section-summary-toc: 1

This section covers common problems that may arise when you use Spring Cloud Gateway.

[[log-levels]]
== Log Levels

The following loggers may contain valuable troubleshooting information at the DEBUG and TRACE levels:

• org.springframework.cloud.gateway
• org.springframework.http.server.reactive
• org.springframework.web.reactive
• org.springframework.boot.autoconfigure.web
• reactor.netty
• redisratelimiter

[[wiretap]]
== Wiretap

The Reactor Netty HttpClient and HttpServer can have wiretap enabled.
When combined with setting the reactor.netty log level to DEBUG or TRACE, it enables the logging of information, such as headers and bodies sent and received across the wire.
To enable wiretap, set spring.cloud.gateway.httpserver.wiretap=true or spring.cloud.gateway.httpclient.wiretap=true for the HttpServer and HttpClient, respectively.

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Gateway Handler Filter Functions (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/gateway-handler-filter-functions.adoc`) Copy Section

[[gateway-handler-filter-functions]]
= Gateway Handler Filter Functions

[[beforefilterfunctions]]
== Before Filter Functions

The WebMvc.fn API has the concept of a "before" filter function, a java.util.Function<ServerRequest, ServerRequest> that only acts on the request. Many before filter functions are referenced in org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions as static factory methods. They are adapted to generic org.springframework.web.servlet.function.HandlerFilterFunction<ServerResponse, ServerResponse> in org.springframework.cloud.gateway.server.mvc.filter.FilterFunctions. Either may be used, but the more specific BeforeFilterFunctions is preferred, where possible, as it is more explicit.

[[afterfilterfunctions]]
== After Filter Functions

The WebMvc.fn API has the concept of a "after" filter function, a java.util.BiFunction<ServerRequest, ServerResponse, ServerResponse> that can modify the response. Many after filter functions are referenced in org.springframework.cloud.gateway.server.mvc.filter.AfterFilterFunctions as static factory methods. They are adapted to generic org.springframework.web.servlet.function.HandlerFilterFunction<ServerResponse, ServerResponse> in org.springframework.cloud.gateway.server.mvc.filter.FilterFunctions. Either may be used, but the more specific AfterFilterFunctions is preferred, where possible, as it is more explicit.

== Advanced Filter Functions

Some filters can not be classified as a simple before or after filter. These filters do work both prior to and after the proxy request has been made. Some of these include filters located in BodyFilterFunctions, Bucket4jFilterFunctions, CircuitBreakerFilterFunctions, LoadBalancerFilterFunctions, RetryFilterFunctions, and TokenRelayFilterFunctions, all located in the org.springframework.cloud.gateway.server.mvc.filter` package.

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Gateway Request Predicates (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/gateway-request-predicates.adoc`) Copy Section

[[gateway-request-predicates]]
= Gateway Request Predicates

Spring Cloud Gateway MVC matches routes as part of the Spring WebMvc.fn HandlerMapping infrastructure.
Spring Cloud Gateway reuses many https://docs.spring.io/spring-framework/reference/web/webmvc-functional.html#webmvc-fn-predicates[`RequestPredicate`] implementations from WebMvc.fn and includes other custom RequestPredicate implementations
All of these predicates match on different attributes of the HTTP request.
You can combine multiple route predicate factories with the RequestPredicate.and() and RequestPredicate.or() methods.

[[after-request-predicate]]
== The After Request Predicate

The After route predicate factory takes one parameter, a datetime (which is a java ZonedDateTime).
This predicate matches requests that happen after the specified datetime.
The datetime can be specified as a ZonedDateTime string or as epoch milliseconds.
The following example configures an after route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: after_route
uri: https://example.org
predicates:
- After=2017-01-20T17:42:47.789-07:00[America/Denver]

The datetime can also be specified as epoch milliseconds:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
mvc:
routes:
- id: after_route
uri: https://example.org
predicates:
- After=1484968967789

.GatewaySampleApplication.java [source,java] Copy Chapter

import java.time.ZonedDateTime;
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.after;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsAfter() {
    return route("after_route")
        .route(after(ZonedDateTime.parse("2017-01-20T17:42:47.789-07:00[America/Denver]")), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

This route matches any request made after Jan 20, 2017 17:42 Mountain Time (Denver).

[[before-request-predicate]]
== The Before Request Predicate

The Before route predicate factory takes one parameter, a datetime (which is a java ZonedDateTime).
This predicate matches requests that happen before the specified datetime.
The datetime can be specified as a ZonedDateTime string or as epoch milliseconds.
The following example configures a before route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: before_route
uri: https://example.org
predicates:
- Before=2017-01-20T17:42:47.789-07:00[America/Denver]

The datetime can also be specified as epoch milliseconds:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
mvc:
routes:
- id: before_route
uri: https://example.org
predicates:
- Before=1484968967789

.GatewaySampleApplication.java [source,java] Copy Chapter

import java.time.ZonedDateTime;
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.before;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsBefore() {
    return route("before_route")
        .route(before(ZonedDateTime.parse("2017-01-20T17:42:47.789-07:00[America/Denver]")), http()
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

This route matches any request made before Jan 20, 2017 17:42 Mountain Time (Denver).

[[between-request-predicate]]
== The Between Request Predicate

The Between route predicate factory takes two parameters, datetime1 and datetime2
which are java ZonedDateTime objects.
This predicate matches requests that happen after datetime1 and before datetime2.
The datetime2 parameter must be after datetime1.
The datetimes can be specified as ZonedDateTime strings or as epoch milliseconds.
The following example configures a between route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: between_route
uri: https://example.org
predicates:
- Between=2017-01-20T17:42:47.789-07:00[America/Denver], 2017-01-21T17:42:47.789-07:00[America/Denver]

The datetimes can also be specified as epoch milliseconds:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
mvc:
routes:
- id: between_route
uri: https://example.org
predicates:
- Between=1484968967789, 1485055367789

.GatewaySampleApplication.java [source,java] Copy Chapter

import java.time.ZonedDateTime;
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.between;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsBetween() {
    return route("between_route")
        .route(between(ZonedDateTime.parse("2017-01-20T17:42:47.789-07:00[America/Denver]"),
            ZonedDateTime.parse("2017-01-21T17:42:47.789-07:00[America/Denver]")), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

This route matches any request made after Jan 20, 2017 17:42 Mountain Time (Denver) and before Jan 21, 2017 17:42 Mountain Time (Denver).
This could be useful for maintenance windows.

[[cookie-request-predicate]]
== The Cookie Request Predicate

The Cookie route predicate factory takes two parameters, the cookie name and a regexp (which is a Java regular expression).
This predicate matches cookies that have the given name and whose values match the regular expression.
The following example configures a cookie route predicate factory:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: cookie_route
uri: https://example.org
predicates:
- Cookie=chocolate, ch.p

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.cookie;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsCookie() {
    return route("cookie_route")
        .route(cookie("chocolate", "ch.p"), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

This route matches requests that have a cookie named chocolate whose value matches the ch.p regular expression.

[[header-request-predicate]]
== The Header Request Predicate

The Header route predicate factory takes two parameters, the header and a regexp (which is a Java regular expression).
This predicate matches with a header that has the given name whose value matches the regular expression.
The following example configures a header route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
server:
webmvc:
routes:
- id: header_route
uri: https://example.org
predicates:
- Header=X-Request-Id, \d+

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.header;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsHeader() {
    return route("header_route")
        .route(header("X-Request-Id", "\\d+"), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

This route matches if the request has a header named X-Request-Id whose value matches the \d+ regular expression (that is, it has a value of one or more digits).

[[host-request-predicate]]
== The Host Request Predicate

The Host route predicate factory takes one parameter: a list of host name patterns.
The pattern is an Ant-style pattern with . as the separator.
This predicates matches the Host header that matches the pattern.
The following example configures a host route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: host_route
uri: https://example.org
predicates:
- Host=.somehost.org,.anotherhost.org

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.host;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsHost() {
    return route("host_route")
        .route(host("**.somehost.org", "**.anotherhost.org"), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

URI template variables (such as \{sub}.myhost.org) are supported as well.

This route matches if the request has a Host header with a value of www.somehost.org or beta.somehost.org or www.anotherhost.org.

This predicate extracts the URI template variables (such as sub, defined in the preceding example) as a map of names and values and places it in the ServerRequest.attributes() with a key defined in MvcUtils.URI_TEMPLATE_VARIABLES_ATTRIBUTE.
// TODO: figure out link to gateway-handler-filter-functions
Those values are then available for use by Gateway Handler Filter Functions.

[[method-request-predicate]]
== The Method Request Predicate

The Method Request Predicate takes a methods argument which is one or more parameters: the HTTP methods to match.
The following example configures a method route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: method_route
uri: https://example.org
predicates:
- Method=GET,POST

.GatewaySampleApplication.java [source,java] Copy Chapter

import org.springframework.http.HttpMethod;
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.method;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsMethod() {
    return route("method_route")
        .route(method(HttpMethod.GET, HttpMethod.POST), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

This route matches if the request method was a GET or a POST.

GatewayRequestPredicates.method is a simple alias for https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RequestPredicates.html#methods(org.springframework.http.HttpMethod...)[`RequestPredicates.methods`]. Also, the RouterFunctions.Builder API includes convenience methods that combine the method and path RequestPredicates.

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsMethodAndPath() {
    return route("method_and_path_route")
        .GET("/mypath", http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

This route matches if the request method was a GET and the path was /mypath.

[[path-request-predicate]]
== The Path Request Predicate

The Path Request Predicate takes two parameters: a list of Spring PathPattern patterns.
// and an optional flag called matchTrailingSlash (defaults to true).
This Request Predicate uses https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RequestPredicates.html#path(java.lang.String)[`RequestPredicates.path()`] as the underlying implementation.
The following example configures a path route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: path_route
uri: https://example.org
predicates:
- Path=/red/{segment},/blue/{segment}

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.path;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsPath() {
    return route("path_route")
        .route(path("/red/{segment}", "/blue/{segment}"), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

This route matches if the request path was, for example: /red/1 or /red/1/ or /red/blue or /blue/green.

//If matchTrailingSlash is set to false, then request path /red/1/ will not be matched.

This predicate extracts the URI template variables (such as segment, defined in the preceding example) as a map of names and values and places it in the ServerRequest.attributes() with a key defined in RouterFunctions.URI_TEMPLATE_VARIABLES_ATTRIBUTE.
// TODO: figure out link
Those values are then available for use by Gateway Handler Filter Functions.

A utility method (called get) is available to make access to these variables easier.
The following example shows how to use the get method:

[source,java] Copy Chapter

Map<String, Object> uriVariables = MvcUtils.getUriTemplateVariables(request);

String segment = uriVariables.get("segment"); Copy Chapter

[[query-request-predicate]]
== The Query Request Predicate

The Query route predicate factory takes two parameters: a required param and an optional regexp (which is a Java regular expression).
The following example configures a query route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: query_route
uri: https://example.org
predicates:
- Query=green

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.query;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsQuery() {
    return route("query_route")
        .route(query("green"), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

The preceding route matches if the request contained a green query parameter.

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: query_route
uri: https://example.org
predicates:
- Query=red, gree.

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.query;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsQuery() {
    return route("query_route")
        .route(query("red", "gree."), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

The preceding route matches if the request contained a red query parameter whose value matched the gree. regexp, so green and greet would match.

////
TODO: remoteAddr predicate
[[remoteaddr-request-predicate]]
== The RemoteAddr Request Predicate

The RemoteAddr route predicate factory takes a list (min size 1) of sources, which are CIDR-notation (IPv4 or IPv6) strings, such as 192.168.0.1/16 (where 192.168.0.1 is an IP address and 16 is a subnet mask).
The following example configures a RemoteAddr route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: remoteaddr_route
uri: https://example.org
predicates:
- RemoteAddr=192.168.1.1/24

This route matches if the remote address of the request was, for example, 192.168.1.10.

[[modifying-the-way-remote-addresses-are-resolved]]
=== Modifying the Way Remote Addresses Are Resolved

By default, the RemoteAddr route predicate factory uses the remote address from the incoming request.
This may not match the actual client IP address if Spring Cloud Gateway sits behind a proxy layer.

You can customize the way that the remote address is resolved by setting a custom RemoteAddressResolver.
Spring Cloud Gateway comes with one non-default remote address resolver that is based off of the https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For[X-Forwarded-For header], XForwardedRemoteAddressResolver.

XForwardedRemoteAddressResolver has two static constructor methods, which take different approaches to security:

• XForwardedRemoteAddressResolver::trustAll returns a RemoteAddressResolver that always takes the first IP address found in the X-Forwarded-For header.
  This approach is vulnerable to spoofing, as a malicious client could set an initial value for the X-Forwarded-For, which would be accepted by the resolver.

• XForwardedRemoteAddressResolver::maxTrustedIndex takes an index that correlates to the number of trusted infrastructure running in front of Spring Cloud Gateway.
  If Spring Cloud Gateway is, for example only accessible through HAProxy, then a value of 1 should be used.
  If two hops of trusted infrastructure are required before Spring Cloud Gateway is accessible, then a value of 2 should be used.

Consider the following header value:

[source] Copy Chapter

X-Forwarded-For: 0.0.0.1, 0.0.0.2, 0.0.0.3 Copy Chapter

The following maxTrustedIndex values yield the following remote addresses:

[options="header"]
|===
|maxTrustedIndex | result
|[Integer.MIN_VALUE,0] | (invalid, IllegalArgumentException during initialization)
|1 | 0.0.0.3
|2 | 0.0.0.2
|3 | 0.0.0.1
|[4, Integer.MAX_VALUE] | 0.0.0.1
|===

[[gateway-route-filters]]
The following example shows how to achieve the same configuration with Java:

.GatewayConfig.java [source,java] Copy Chapter

RemoteAddressResolver resolver = XForwardedRemoteAddressResolver
.maxTrustedIndex(1);

...

.route("direct-route",
r -> r.remoteAddr("10.1.1.1", "10.10.1.1/24")
.uri("https://downstream1")
.route("proxied-route",
r -> r.remoteAddr(resolver, "10.10.1.1", "10.10.1.1/24")
.uri("https://downstream2")

) Copy Chapter

////

[[weight-request-predicate]]
== The Weight Request Predicate

The Weight route predicate factory takes two arguments: group and weight (an int). The weights are calculated per group.
The following example configures a weight route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: weight_high
uri: https://weighthigh.org
predicates:
- Weight=group1, 8
- id: weight_low
uri: https://weightlow.org
predicates:
- Weight=group1, 2

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.path;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.weight;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctionsWeights() {
    return route("weight_high")
            .route(weight("group1", 8).and(path("/**")), http())
            .before(uri("https://weighthigh.org"))
            .build().and(
        route("weight_low")
            .route(weight("group1", 2).and(path("/**")), http())
            .before(uri("https://weightlow.org"))
            .build());
}

} Copy Chapter

This route would forward ~80% of traffic to https://weighthigh.org and ~20% of traffic to https://weightlow.org.

[[version-request-predicate]]
== The Version Request Predicate

The version predicate matches requests based on the API version extracted from the incoming
request.
The version is resolved and parsed by the ApiVersionStrategy that is configured through
Spring Framework's API versioning support (spring.mvc.apiversion.*).

[[version-request-predicate-version-strategy]]
=== Configuring the API Version Strategy

Before using the version predicate you must configure at least one version resolver so that
Spring (and Gateway MVC) knows how to extract the version from each incoming request.
The following example configures version resolution from an HTTP header, a query parameter, and
an application/json media-type parameter:

.application.yml [source,yaml] Copy Chapter

spring:
mvc:
apiversion:
use:
header: X-API-Version # extract version from this header
query-parameter: apiVersion # or from this query parameter
media-type-parameter: # or from the named media-type parameter
"[application/json]": version
required: false # allow requests without an explicit version

To extract the version from a path segment instead, set path-segment to the zero-based
index of the segment that carries the version:

.application.yml [source,yaml] Copy Chapter

spring:
mvc:
apiversion:
use:
path-segment: 1 # /v1/users → version = "1"

[[version-request-predicate-usage]]
=== Using the Version Predicate

The predicate accepts a single version argument and supports two forms:

• Fixed version — the route matches only requests whose resolved version equals the given
  version exactly.
• Baseline version (version+) — the route matches requests whose resolved version is
  greater than or equal to the given version.

The following example configures a fixed-version route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: version_13_route
uri: https://example.org
predicates:
- Path=/api/**
- Version=1.3

This route matches only requests that carry exactly version 1.3.

The following example uses a baseline version:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: version_11_plus_route
uri: https://example.org
predicates:
- Path=/api/**
- Version=1.1+

This route matches requests with version 1.1 or any later version (for example 1.2, 1.5,
or 2.0).
A baseline version lets a single route continue to serve requests across multiple API
versions until a breaking change makes a new route necessary.

The predicate can also be used in the Java DSL with
GatewayRequestPredicates.version(String):

[source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;
import static org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates.version;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> gatewayRouterFunctions() {
    return route("version_13_route")
        .route(version("1.3"), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

NOTE: If no ApiVersionStrategy bean is present (that is, no spring.mvc.apiversion.use.*
property is set), the version predicate always passes — any request without a resolved
version is treated as matching.

////
TODO: XForwardedRemoteAddr predicate
[[xforwarded-remote-addr-request-predicate]]
== The XForwarded Remote Addr Request Predicate

The XForwarded Remote Addr route predicate factory takes a list (min size 1) of sources, which are CIDR-notation (IPv4 or IPv6) strings, such as 192.168.0.1/16 (where 192.168.0.1 is an IP address and 16 is a subnet mask).

This route predicate allows requests to be filtered based on the X-Forwarded-For HTTP header.

This can be used with reverse proxies such as load balancers or web application firewalls where
the request should only be allowed if it comes from a trusted list of IP addresses used by those
reverse proxies.

The following example configures a XForwardedRemoteAddr route predicate:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: xforwarded_remoteaddr_route
uri: https://example.org
predicates:
- XForwardedRemoteAddr=192.168.1.1/24

This route matches if the X-Forwarded-For header contains, for example, 192.168.1.10.
////

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Glossary (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/glossary.adoc`) Copy Section

[[glossary]]
= Glossary
:page-section-summary-toc: 1

• Route: The basic building block of the gateway.
  It is defined by an ID, a destination URI, a collection of predicates, and a collection of filters. A route is matched if the aggregate predicate is true.
• Predicate: This is a https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RequestPredicate.html[Spring WebMvc.fn RequestPredicate]. The input type is a https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/ServerRequest.html[Spring WebMvc.fn ServerRequest].
  This lets you match on anything from the HTTP request, such as headers or parameters.
• Filter: These are instances of https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/HandlerFilterFunction.html[`HandlerFilterFunction`].
  Here, you can modify requests and responses before or after sending the downstream request. Filters may also implement Function<ServerRequest, ServerRequest> and adapted to a HandlerFilterFunction by https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/HandlerFilterFunction.html#ofRequestProcessor(java.util.function.Function)[`HandlerFilterFunction.ofRequestProcessor()`] for 'before' filters. For 'after' filters, BiFunction<ServerRequest,T extends ServerResponse,R extends ServerResponse> may be implemented and adapted by https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/HandlerFilterFunction.html#ofResponseProcessor(java.util.function.BiFunction)[`HandlerFilterFunction.ofResponseProcessor()`].

Modules ROOT Pages Spring Cloud Gateway Server Webmvc How It Works (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/how-it-works.adoc`) Copy Section

[[gateway-how-it-works]]
= How It Works
:page-section-summary-toc: 1

The following diagram provides a high-level overview of how Spring Cloud Gateway works:

image::spring_cloud_gateway_mvc_diagram.png[Spring Cloud Gateway Server MVC Diagram]

In Spring Cloud Gateway Server MVC routes are normal WebMvc.fn RouterFunction instances with a special https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/HandlerFunction.html[HandlerFunction] to forward the requests over HTTP defined in https://github.com/spring-cloud/spring-cloud-gateway/blob/main/spring-cloud-gateway-server-webmvc/src/main/java/org/springframework/cloud/gateway/server/mvc/handler/HandlerFunctions.java[org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions]. Please see the https://docs.spring.io/spring-framework/reference/web/webmvc-functional.html[WebMvc.fn] documentation for regular use of the functional API.

In addition to custom HandlerFunctions for HTTP forwarding, Spring Cloud Gateway Server MVC provides additional RequestPredicate implementations in https://github.com/spring-cloud/spring-cloud-gateway/blob/main/spring-cloud-gateway-server-webmvc/src/main/java/org/springframework/cloud/gateway/server/mvc/predicate/GatewayRequestPredicates.java[org.springframework.cloud.gateway.server.mvc.predicate.GatewayRequestPredicates] and HandlerFilterFunctions implementations in https://github.com/spring-cloud/spring-cloud-gateway/blob/main/spring-cloud-gateway-server-webmvc/src/main/java/org/springframework/cloud/gateway/server/mvc/filter/FilterFunctions.java[org.springframework.cloud.gateway.server.mvc.filter.FilterFunctions]. All the custom filters that can be pure 'before' filters are implemented in https://github.com/spring-cloud/spring-cloud-gateway/blob/main/spring-cloud-gateway-server-webmvc/src/main/java/org/springframework/cloud/gateway/server/mvc/filter/BeforeFilterFunctions.java[org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions] and adapted in FilterFunctions as request processors. The custom 'after' filters in https://github.com/spring-cloud/spring-cloud-gateway/blob/main/spring-cloud-gateway-server-webmvc/src/main/java/org/springframework/cloud/gateway/server/mvc/filter/AfterFilterFunctions.java[org.springframework.cloud.gateway.server.mvc.filter.AfterFilterFunctions] are also adapted in FilterFunctions as response processors.

There are additional *FilterFunctions classes for optional filters that are documented along with each filter.

WARNING: Any path defined on a route URI will be ignored.

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Httpheadersfilters (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/httpheadersfilters.adoc`) Copy Section

[[httpheadersfilters]]
= HttpHeadersFilters

HttpHeadersFilters are applied to the requests before sending them downstream, such as in the NettyRoutingFilter.

[[forwarded-headers-filter]]
== Forwarded Headers Filter
The Forwarded Headers Filter creates a Forwarded header to send to the downstream service, as defined in https://tools.ietf.org/html/rfc7239[RFC 7239]. It adds the Host header, scheme and port of the current request to any existing Forwarded header. To activate this filter set the spring.cloud.gateway.server.webmvc.trusted-proxies property to a Java Regular Expression. This regular expression defines the proxies that are trusted when they appear in the Forwarded header.

The filter supports the following optional parameters:

=== Forwarded "by" Parameter
The by parameter identifies the proxy interface where the request was received. This is useful for debugging and tracing in multi-hop proxy environments. To enable the by parameter, set the following property:

• spring.cloud.gateway.server.webmvc.forwarded-by-enabled (defaults to false)

When enabled, the filter adds the server's local address and port to the Forwarded header. For example:

[source] Copy Chapter

Forwarded: for="192.0.2.60:47011";proto=https;host="example.com:443";by="198.51.100.17:8080" Copy Chapter

NOTE: The by parameter includes the port number only when it is greater than 0. IPv6 addresses are properly formatted with brackets.

[[removehopbyhop-headers-filter]]
== RemoveHopByHop Headers Filter
The RemoveHopByHop Headers Filter removes headers from forwarded requests. The default list of headers that is removed comes from the https://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-14#section-7.1.3[IETF].

.The default removed headers are:

• Connection
• Keep-Alive
• Proxy-Authenticate
• Proxy-Authorization
• TE
• Trailer
• Transfer-Encoding
• Upgrade

//To change this, set the spring.cloud.gateway.filter.remove-hop-by-hop.headers property to the list of header names to remove.

[[xforwarded-headers-filter]]
== XForwarded Headers Filter
The XForwarded Headers Filter creates various X-Forwarded-* headers to send to the downstream service. It uses the Host header, scheme, port and path of the current request to create the various headers. To activate this filter set the spring.cloud.gateway.server.webmvc.trusted-proxies property to a Java Regular Expression. This regular expression defines the proxies that are trusted when they appear in the Forwarded header.

Creating of individual headers can be controlled by the following boolean properties (defaults to true):

• spring.cloud.gateway.server.webmvc.x-forwarded.for-enabled
• spring.cloud.gateway.server.webmvc.x-forwarded.host-enabled
• spring.cloud.gateway.server.webmvc.x-forwarded.port-enabled
• spring.cloud.gateway.server.webmvc.x-forwarded.proto-enabled
• spring.cloud.gateway.server.webmvc.x-forwarded.prefix-enabled

Appending multiple headers can be controlled by the following boolean properties (defaults to true):

• spring.cloud.gateway.server.webmvc.x-forwarded.for-append
• spring.cloud.gateway.server.webmvc.x-forwarded.host-append
• spring.cloud.gateway.server.webmvc.x-forwarded.port-append
• spring.cloud.gateway.server.webmvc.x-forwarded.proto-append
• spring.cloud.gateway.server.webmvc.x-forwarded.prefix-append

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Java Routes Api (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/java-routes-api.adoc`) Copy Section

[[java-routes-api]]
= Java Routes API

Spring Cloud Gateway Server MVC uses the Spring WebMvc.fn https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RouterFunctions.Builder.html[RouterFunctions.Builder] as the default way to create Routes, which are WebMvc.fn https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RouterFunction.html[RouterFunction] instances.

A https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RouterFunctions.Builder.html[`RouterFunctions.Builder`] instance is obtained by calling https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RouterFunctions.html#route()[RouterFunctions.route()]

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.web.servlet.function.RouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;

class SimpleGateway {
@Bean
public RouterFunction getRoute() {
return route().GET("/get", http())
.before(uri("https://example.org"))
.build();
}

} Copy Chapter

There are methods in RouterFunctions.Builder for each HTTP methods (GET, POST, etc...) combined with a path predicate, such as /get as above. The final parameter is the HandlerFilterFunction, in this case HandlerFunctions.http(). There are overloaded methods for each HTTP method for additional RequestPredicate parameters as well as a generic route(RequestPredicate, HandlerFunction) method for general use.

[[gateway-routerfunctions-builder]]
== Gateway MVC implementation of RouterFunctions.Builder

Some advanced filters require some metadata to be added to request attributes. To accommodate this, there is a org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions class. GatewayRouterFunctions.route(String routeId) creates a RouterFunctions.Builderinstance then adds a 'before' filter to add therouteId` as request metadata.

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;

class SimpleGateway {
@Bean
public RouterFunction getRoute() {
return route("simple_route").GET("/get", http())
.before(uri("https://example.org"))
.build();
}

} Copy Chapter

[[gateway-handlerfunctions]]
== Gateway MVC Handler Functions

Various RouterFunctions.Builder methods require a HandlerFunction<ServerResponse>. To create a route that is proxied by the MVC Gateway, HandlerFunction implementations are supplied in org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.

=== HTTP Handler Function
The most basic handler function is http() HandlerFunction. If a URI is supplied as a parameter, that is the URI used as the downstream target for sending the HTTP requests (as seen in the example above). If no parameter is passed, the function looks for a URI in the org.springframework.cloud.gateway.server.mvc.common.MvcUtils.GATEWAY_REQUEST_URL_ATTR request attribute. This allows for dynamic targets such as load balancing to set the URI.

WARNING: As of version 4.1.7, HandlerFunctions.http(String) and HandlerFunctions.http(URI) are now deprecated. Please use HandlerFunctions.http() in combination with the BeforeFilterFunctions.uri() filter instead. This fixes inconsistencies in dealing with the route url request attribute.

=== Spring Cloud Function Handler Function
By placing https://spring.io/projects/spring-cloud-function[Spring Cloud Function] on the classpath, Spring Cloud Gateway will automatically configure routes to invoke functions you define as beans. The bean names of the functions will be used as the path of the routes.

For example, given the following configuration:

[source,xml] Copy Chapter

Once Spring Cloud Function dependency is provided the name of the Java function bean becomes the path you can use to route to functions.

For example, assume the following application:

[source,java] Copy Chapter

@SpringBootApplication
public class DemoFunctionGatewayApplication {

public static void main(String[] args) {
	SpringApplication.run(DemoFunctionGatewayApplication.class, args);
}


@Bean
public Function<String, String> uppercase() {
	return v -> v.toUpperCase();
}

@Bean
public Function<String, String> concat() {
	return v -> v + v;
}

} Copy Chapter

You can invoke the concat or uppercase functions by issuing a GET or POST request to /concat or /uppercase.

Making a GET request to ``http://localhost:8080/uppercase/hello` will invoke the uppercase function with the String hello and return HELLO in the GET response body.

Instead of passing the function parameter as a path parameter you can use a POST request. For example the following cURL command can issued to invoke the concat function:

[source,bash] Copy Chapter

$ curl -d ‘"hello"' -H "Content-Type: application/json" -X POST http://localhost:8080/concat Copy Chapter

The response body will contain hellohello.

Spring Cloud Gateway also supports function composition by issuing a request to a path composed of function names separated by a comma. For example:

[source,bash] Copy Chapter

$ curl -d ‘"hello"' -H "Content-Type: application/json" -X POST http://localhost:8080/concat,uppercase Copy Chapter

The response body will contain HELLOHELLO.

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Spring Security (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/spring-security.adoc`) Copy Section

[[spring-security]]
= Spring Security Integration

Spring Cloud Gateway Server MVC works with https://spring.io/projects/spring-security[Spring Security] to secure routes and relay tokens to downstream services.

== Dependencies

To add Spring Security to the gateway, include one or more of the following starters:

.pom.xml [source,xml] Copy Chapter

== Default Behavior

When spring-boot-starter-security is on the classpath, Spring Boot auto-configures a SecurityFilterChain that requires all requests to be authenticated.
Provide an explicit SecurityFilterChain bean to customize access rules for your gateway routes.

The following example allows health-check endpoints without authentication and requires a valid JWT on all other requests:

.RouteSecurityConfiguration.java [source,java] Copy Chapter

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class RouteSecurityConfiguration {

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/actuator/health/**").permitAll()
                .anyRequest().authenticated())
        .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults()));
    return http.build();
}

} Copy Chapter

[[spring-security-http-firewall]]
== HTTP Firewall

Spring Security includes a StrictHttpFirewall that rejects HTTP requests whose URLs contain certain characters — such as encoded path separators (%2F), double forward slashes (//), or backslashes.
These patterns can be legitimate in a gateway that proxies requests to downstream services that accept such paths.

If the gateway is rejecting requests with a 400 Bad Request before any route is matched, the StrictHttpFirewall may be blocking them.
You can relax it as follows:

.RouteSecurityConfiguration.java [source,java] Copy Chapter

import org.springframework.security.config.annotation.web.configuration.WebSecurityCustomizer;
import org.springframework.security.web.firewall.HttpFirewall;
import org.springframework.security.web.firewall.StrictHttpFirewall;

@Configuration
@EnableWebSecurity
public class RouteSecurityConfiguration {

@Bean
public HttpFirewall relaxedHttpFirewall() {
    StrictHttpFirewall firewall = new StrictHttpFirewall();
    firewall.setAllowUrlEncodedSlash(true);         // allow %2F in path
    firewall.setAllowUrlEncodedDoubleSlash(true);   // allow %2F%2F
    firewall.setAllowBackSlash(true);               // allow \ in path
    return firewall;
}

@Bean
public WebSecurityCustomizer webSecurityCustomizer() {
    return web -> web.httpFirewall(relaxedHttpFirewall());
}

} Copy Chapter

[CAUTION]

Only relax the `StrictHttpFirewall` when your downstream services explicitly require it and your threat model accounts for the implications. See the https://docs.spring.io/spring-security/reference/servlet/exploits/firewall.html[Spring Security HTTP Firewall] reference for details.

== Token Relay

When the gateway acts as an OAuth2 client, it can forward the currently authenticated user's access token to downstream services.
See the xref:spring-cloud-gateway-server-webmvc/filters/tokenrelay.adoc[TokenRelay filter] documentation for usage and required dependencies.

== Further Reading

See the https://docs.spring.io/spring-security/reference/servlet/index.html[Spring Security Servlet Applications] reference for full details on SecurityFilterChain, method security, and OAuth2 integration.

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Starter (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/starter.adoc`) Copy Section

[[gateway-starter]]
= How to Include Spring Cloud Gateway Server Web MVC
:page-section-summary-toc: 1

To include Spring Cloud Gateway Server Web MVC in your project, use the starter with a group ID of org.springframework.cloud and an artifact ID of spring-cloud-starter-gateway-server-webmvc.
See the https://projects.spring.io/spring-cloud/[Spring Cloud Project page] for details on setting up your build system with the current Spring Cloud Release Train.

If you include the starter, but you do not want the gateway to be enabled, set spring.cloud.gateway.server.webmvc.enabled=false.

IMPORTANT: Spring Cloud Gateway Server MVC is built on https://spring.io/projects/spring-boot#learn[Spring Boot] and https://docs.spring.io/spring-framework/reference/web/webmvc-functional.html[Spring WebMvc.fn].
As a consequence, many of the asynchronous or reactive libraries may not apply when you use Spring Cloud Gateway Server MVC.

IMPORTANT: Spring Cloud Gateway Server MVC works with traditional Servlet runtimes such as Tomcat and Jetty.

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Tls And Ssl (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/tls-and-ssl.adoc`) Copy Section

[[tls-and-ssl]]
= TLS and SSL

Spring Cloud MVC Gateway uses Spring Boot's RestClient infrastructure for backend proxy calls.
TLS/SSL configuration for those backend calls is handled through Spring Boot's spring.http.client and spring.ssl.bundle properties.

NOTE: The spring.cloud.gateway.mvc.http-client.ssl-bundle property is deprecated since Spring Cloud Gateway 4.2.0
in favor of spring.http.client.ssl.bundle.

== Examples

=== Configure an SSL Bundle (JKS)

Below is an example of how to define a JKS-based SSL bundle and reference:

.application.yml [source,yaml] Copy Chapter

spring:
http:
client:
ssl:
bundle: mybundle
connect-timeout: 5s
read-timeout: 30s
ssl:
bundle:
jks:
mybundle:
key-store:
location: classpath:keystore.jks
password: changeit
trust-store:
location: classpath:truststore.jks
password: changeit

=== Configure PEM Certificates

Below is an example of how to configure an SSL bundle using PEM-formatted certificates and private keys:

.application.yml [source,yaml] Copy Chapter

spring:
http:
client:
ssl:
bundle: mybundle
ssl:
bundle:
pem:
mybundle:
keystore:
certificate: classpath:client-cert.pem
key: classpath:client-key.pem
truststore:
certificate: classpath:ca-cert.pem

== Related Spring Boot Documentation

For full details on SSL bundle configuration and available properties, see:

• https://docs.spring.io/spring-boot/appendix/application-properties/index.html#application-properties.web.spring.http.client.ssl.bundle[spring.http.client.ssl.bundle reference]
• https://docs.spring.io/spring-boot/reference/features/ssl.html[Spring Boot SSL documentation]

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Websockets (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/websockets.adoc`) Copy Section

[[websockets]]
= WebSockets

Spring Cloud Gateway Server Web MVC can proxy WebSocket connections. To enable it, add spring-boot-starter-websocket:

[source,xml] Copy Chapter

With WebSocket support on the classpath, a route can proxy WebSockets in either of two ways:

• Use a ws or wss URI.
• Use an http, https or lb URI. A request with an Upgrade: websocket header is proxied as a WebSocket, and http and https become ws and wss.

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
routes:
- id: websocket_route
uri: ws://localhost:3001
predicates:
- Path=/websocket/**

The following example configures the same route with the Java DSL:

.GatewaySampleApplication.java [source,java] Copy Chapter

import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.websocket;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> websocketRoute() {
    return route("websocket_route")
        .GET("/websocket/**", websocket())
        .before(uri("ws://localhost:3001"))
        .build();
}

} Copy Chapter

The gateway connects to the backend before it completes the client's handshake. The client is offered the subprotocol the backend accepted, and gets 502 Bad Gateway if the backend cannot be reached.

Text, binary and pong messages are relayed in both directions. Ping messages are not relayed: the servlet WebSocket API does not deliver them to applications, and the container answers each ping with a pong itself. A client that pings the gateway gets a reply even if the backend is slow or unresponsive. To check that the backend itself is alive, use application-level heartbeat messages.

Request filters such as StripPrefix, AddRequestHeader and TokenRelay apply to the handshake. Headers added by response filters are set on the handshake response. Once the connection is established, messages are relayed as they are. Filters that act on a response body, as well as retry and circuit breaker filters, do not apply.

[[websocket-allowed-origins]]
== Allowed Origins

Browsers do not enforce CORS on WebSocket handshakes, so the gateway checks the Origin header itself. By default, it accepts only same-origin handshakes and handshakes without an Origin header (such as those from non-browser clients). Cross-origin handshakes are rejected with 403 Forbidden.

To accept handshakes from other origins, set spring.cloud.gateway.server.webmvc.websocket.allowed-origins. Patterns such as https://*.example.com are supported, and * allows all origins:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webmvc:
websocket:
allowed-origins:
- https://*.example.com

[[websocket-properties]]
== Configuration Properties

All properties are under spring.cloud.gateway.server.webmvc.websocket.

|===
| Property | Default | Description

| enabled
| true
| Whether WebSocket proxying is enabled.

| allowed-origins
| (same origin only)
| Additional origins allowed to open a connection.

| connect-timeout
| 10s
| Time allowed to connect to the backend.

| send-time-limit
| 10s
| Time allowed to send a single message to either side before the session is closed.

| send-buffer-size-limit
| 512KB
| Outbound data buffered per session before the session is closed.

| max-message-size
| 64KB
| Largest message accepted from either side. Larger messages close the connection with status 1009.
|===

Servlet WebSocket has no backpressure. When one side reads more slowly than the other sends, outbound messages are buffered up to send-buffer-size-limit, and then the connection is closed.

Each open connection holds container resources for its lifetime. For gateways with many long-lived connections, consider enabling virtual threads with spring.threads.virtual.enabled=true.

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Working With Servlets And Filters (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/working-with-servlets-and-filters.adoc`) Copy Section

[[working-with-servlets-and-filters]]
= Working with Servlets and Servlet Filters

Spring Cloud Gateway Server MVC is built for Servlet-stack web applications built on the Servlet API and deployed to Servlet containers. If your applications uses Servlets or Servlet Filters you may need to take care in their ordering.

Because of the way Servlet Containers handle request parameters, when a Spring WebMVC application receives a content type of application/x-www-form-urlencoded, Servlet containers combine those with query parameters into "request" parameters. A special FormFilter bean is included in Spring Cloud Gateway Server MVC to rebuild the form body for downstream applications. Any Servlet Filter that reads request parameters before the filter chain is run will need to be ordered before FormFilter. See the example below.

.MyFilter.java [source,java] Copy Chapter

import jakarta.servlet.Filter;
import org.springframework.cloud.gateway.server.mvc.filter.FormFilter;
import org.springframework.core.Ordered;

class MyFilter implements Filter, Ordered {

@Override
public int getOrder() {
    return FormFilter.FORM_FILTER_ORDER - 1;
}

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
        throws IOException, ServletException {
    // ...
    filterChain.doFilter(request, response);
    // ...
}

} Copy Chapter

Modules ROOT Pages Spring Cloud Gateway Server Webmvc Writing Custom Predicates And Filters (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webmvc/writing-custom-predicates-and-filters.adoc`) Copy Section

[[writing-custom-predicates-and-filters]]
= Writing Custom Predicates and Filters

Spring Cloud Gateway Server MVC uses the https://docs.spring.io/spring-framework/reference/web/webmvc-functional.html[Spring WebMvc.fn] API (https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/package-summary.html[javadoc]) as the basis for the API Gateway functionality.

Spring Cloud Gateway Server MVC is extensible using these APIs. Users might commonly expect to write custom implementations of https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RequestPredicate.html[`RequestPredicate`] and https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/HandlerFilterFunction.html[`HandlerFilterFunction`] and two variations of HandlerFilterFunction, one for "before" filters and another for "after" filters.

== Fundamentals

The most basic interfaces that are a part of the Spring WebMvc.fn API are https://docs.spring.io/spring-framework/reference/web/webmvc-functional.html#webmvc-fn-request[`ServerRequest`] (https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/ServerRequest.html[javadoc]) and https://docs.spring.io/spring-framework/reference/web/webmvc-functional.html#webmvc-fn-response[ServerResponse] (https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/ServerResponse.html[javadoc]). These provide access to all parts of the HTTP request and response.

NOTE: The Spring WebMvc.fn docs https://docs.spring.io/spring-framework/reference/web/webmvc-functional.html#webmvc-fn-handler-functions[declare] that "ServerRequest and ServerResponse are immutable interfaces. In some cases, Spring Cloud Gateway Server MVC has to provide alternate implementations so that some things can be mutable to satisfy the proxy requirements of an API gateway.

== Implementing a RequestPredicate

The Spring WebMvc.fn https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RouterFunctions.Builder.html[RouterFunctions.Builder] expects a https://docs.spring.io/spring-framework/reference/web/webmvc-functional.html#webmvc-fn-predicates[`RequestPredicate`] (https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RequestPredicate.html[javadoc]) to match a given https://docs.spring.io/spring-framework/reference/web/webmvc-functional.html#webmvc-fn-routes[Route]. RequestPredicate is a functional interface and can therefor be implemented with lambdas. The method signature to implement is:

[source] Copy Chapter

boolean test(ServerRequest request) Copy Chapter

=== Example RequestPredicate Implementation

For this example, we will show the implementation of a predicate to test that a particular HTTP headers is part of the HTTP request.

The RequestPredicate implementations in Spring WebMvc.fn https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RequestPredicates.html[`RequestPredicates`] and in https://github.com/spring-cloud/spring-cloud-gateway/blob/main/spring-cloud-gateway-server-webmvc/src/main/java/org/springframework/cloud/gateway/server/mvc/predicate/GatewayRequestPredicates.java[GatewayRequestPredicates] are all implemented as static methods. We will do the same here.

.SampleRequestPredicates.java [source,java] Copy Chapter

import org.springframework.web.servlet.function.RequestPredicate;

class SampleRequestPredicates {
public static RequestPredicate headerExists(String header) {
return request -> request.headers().asHttpHeaders().containsKey(header);
}

} Copy Chapter

The implementation is a simple lambda that transforms the https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/ServerRequest.Headers.html[ServerRequest.Headers] object to the richer API of https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/http/HttpHeaders.html[HttpHeaders]. This allows the predicate to test for the presence of the named header.

=== How To Use A Custom RequestPredicate

To use our new headerExists RequestPredicate, we need to plug it in to an appropriate method on the RouterFunctions.Builder such as https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RouterFunctions.Builder.html#route(org.springframework.web.servlet.function.RequestPredicate,org.springframework.web.servlet.function.HandlerFunction)[route()]. Of course, the lambda in the headerExists method could be written inline in the example below.

.RouteConfiguration.java [source,java] Copy Chapter

import static SampleRequestPredicates.headerExists;
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> headerExistsRoute() {
    return route("header_exists_route")
        .route(headerExists("X-Green"), http())
        .before(uri("https://example.org"))
        .build();
}

} Copy Chapter

The above route will be matched when an HTTP request has a header named X-Green.

== Writing Custom HandlerFilterFunction Implementations

The RouterFunctions.Builder has three options to add filters: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RouterFunctions.Builder.html#filter(org.springframework.web.servlet.function.HandlerFilterFunction)[filter], https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RouterFunctions.Builder.html#before(java.util.function.Function)[before], and https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RouterFunctions.Builder.html#after(java.util.function.BiFunction)[after]. The before and after methods are specializations of the general filter method.

=== Implementing a HandlerFilterFunction

The filter method takes a https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/HandlerFilterFunction.html[HandlerFilterFunction] as a parameter. HandlerFilterFunction<T extends ServerResponse, R extends ServerResponse> is a functional interface and can therefor be implemented with lambdas. The method signature to implement is:

[source] Copy Chapter

R filter(ServerRequest request, HandlerFunction next) Copy Chapter

This allows access to the ServerRequest and after calling next.handle(request) access to the ServerResponse is available.

==== Example HandlerFilterFunction Implementation

This example will show adding a header to both the request and response.

.SampleHandlerFilterFunctions.java [source,java] Copy Chapter

import org.springframework.web.servlet.function.HandlerFilterFunction;
import org.springframework.web.servlet.function.ServerRequest;
import org.springframework.web.servlet.function.ServerResponse;

class SampleHandlerFilterFunctions {
public static HandlerFilterFunction<ServerResponse, ServerResponse> instrument(String requestHeader, String responseHeader) {
return (request, next) -> {
ServerRequest modified = ServerRequest.from(request).header(requestHeader, generateId()).build();
ServerResponse response = next.handle(modified);
response.headers().add(responseHeader, generateId());
return response;
};
}

} Copy Chapter

First, a new ServerRequest is created from the existing request. This allows us to add the header using the header() method. Then we call next.handle() passing in the modified ServerRequest. Then using the returned ServerResponse we add the header to the response.

==== How To Use Custom HandlerFilterFunction Implementations

.RouteConfiguration.java [source,java] Copy Chapter

import static SampleHandlerFilterFunctions.instrument;
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> instrumentRoute() {
	return route("instrument_route")
            .GET("/**", http())
			.filter(instrument("X-Request-Id", "X-Response-Id"))
            .before(uri("https://example.org"))
            .build();
}

} Copy Chapter

The above route will add a X-Request-Id header to the request and a X-Response-Id header to the response.

=== Writing Custom Before Filter Implementations

The before method takes a Function<ServerRequest, ServerRequest> as a parameter. This allows for creating a new ServerRequest with updated data to be returned from the function.

NOTE: Before functions may be adapted to HandlerFilterFunction instances via https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/HandlerFilterFunction.html#ofRequestProcessor(java.util.function.Function)[HandlerFilterFunction.ofRequestProcessor()].

==== Example Before Filter Implementation

In this example we will add a header with a generated value to the request.

.SampleBeforeFilterFunctions.java [source,java] Copy Chapter

import java.util.function.Function;
import org.springframework.web.servlet.function.ServerRequest;

class SampleBeforeFilterFunctions {
public static Function<ServerRequest, ServerRequest> instrument(String header) {
return request -> ServerRequest.from(request).header(header, generateId()).build();
}

} Copy Chapter

A new ServerRequest is created from the existing request. This allows us to add the header using the header() method. This implementation is simpler than the HandlerFilterFunction because we only deal with the ServerRequest.

==== How To Use Custom Before Filter Implementations

.RouteConfiguration.java [source,java] Copy Chapter

import static SampleBeforeFilterFunctions.instrument;
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> instrumentRoute() {
    return route("instrument_route").GET("/**", http())
        .before(uri("https://example.org"))
        .before(instrument("X-Request-Id"))
        .build();
}

} Copy Chapter

The above route will add a X-Request-Id header to the request. Note the use of the before() method, rather than filter().

=== Writing Custom After Filter Implementations

The after method takes a BiFunction<ServerRequest,ServerResponse,ServerResponse>. This allows access to both the ServerRequest and the ServerResponse and the ability to return a new ServerResponse with updated information.

NOTE: After functions may be adapted to HandlerFilterFunction instances via https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/HandlerFilterFunction.html#ofResponseProcessor(java.util.function.BiFunction)[HandlerFilterFunction.ofResponseProcessor()].

==== Example After Filter Implementation

In this example we will add a header with a generated value to the response.

.SampleAfterFilterFunctions.java [source,java] Copy Chapter

import java.util.function.BiFunction;
import org.springframework.web.servlet.function.ServerRequest;
import org.springframework.web.servlet.function.ServerResponse;

class SampleAfterFilterFunctions {
public static BiFunction<ServerRequest, ServerResponse, ServerResponse> instrument(String header) {
return (request, response) -> {
response.headers().add(header, generateId());
return response;
};
}

} Copy Chapter

In this case we simply add the header to the response and return it.

==== How To Use Custom After Filter Implementations

.RouteConfiguration.java [source,java] Copy Chapter

import static SampleAfterFilterFunctions.instrument;
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.handler.GatewayRouterFunctions.route;
import static org.springframework.cloud.gateway.server.mvc.handler.HandlerFunctions.http;

@Configuration
class RouteConfiguration {

@Bean
public RouterFunction<ServerResponse> instrumentRoute() {
    return route("instrument_route")
        .GET("/**", http())
        .before(uri("https://example.org"))
        .after(instrument("X-Response-Id"))
        .build();
}

} Copy Chapter

The above route will add a X-Response-Id header to the response. Note the use of the after() method, rather than filter().

== How To Register Custom Predicates and Filters for Configuration

To use custom Predicates and Filters in external configuration you need to create a special Supplier class and register it a bean in the application context.

=== Registering Custom Predicates

To register custom predicates you need to implement PredicateSupplier. The PredicateDiscoverer looks for static methods that return RequestPredicates to register.

SampleFilterSupplier.java [source,java] Copy Chapter

package com.example;

import org.springframework.cloud.gateway.server.mvc.predicate.PredicateSupplier;

class SamplePredicateSupplier implements PredicateSupplier {

@Override
public Collection<Method> get() {
	return Arrays.asList(SampleRequestPredicates.class.getMethods());
}

} Copy Chapter

To register the PredicateSupplier for use in config files, you then need to add the class as a bean as in the example below:

.PredicateConfiguration.java [source,java] Copy Chapter

package com.example;

@Configuration
class PredicateConfiguration {

@Bean
public SamplePredicateSupplier samplePredicateSupplier() {
    return new SamplePredicateSupplier();
}

} Copy Chapter

The requirement to add the class to META-INF/spring.factories is deprecated and will be removed in the next major release.

.META-INF/spring.factories [source] Copy Chapter

org.springframework.cloud.gateway.server.mvc.predicate.PredicateSupplier=\ com.example.SamplePredicateSupplier Copy Chapter

=== Registering Custom Filters

The SimpleFilterSupplier allows for easily registering custom filters. The FilterDiscoverer looks for static methods that return HandlerFilterFunction to register. If you need more flexibility than SimpleFilterSupplier you can implement FilterSupplier directly.

.SampleFilterSupplier.java [source,java] Copy Chapter

package com.example;

import org.springframework.cloud.gateway.server.mvc.filter.SimpleFilterSupplier;

class SampleFilterSupplier extends SimpleFilterSupplier {

public SampleFilterSupplier() {
	super(SampleAfterFilterFunctions.class);
}

} Copy Chapter

To register the FilterSupplier for use in config files, you then need to add the class as a bean as in the example below:

.FilterConfiguration.java [source,java] Copy Chapter

package com.example;

@Configuration
class FilterConfiguration {

@Bean
public SampleFilterSupplier sampleFilterSupplier() {
    return new SampleFilterSupplier();
}

} Copy Chapter

The requirement to add the class to META-INF/spring.factories is deprecated and will be removed in the next major release.

.META-INF/spring.factories [source] Copy Chapter

org.springframework.cloud.gateway.server.mvc.filter.FilterSupplier=\ com.example.SampleFilterSupplier Copy Chapter

// TODO: advanced topics such as attributes, beans and more

Modules ROOT Pages Spring Cloud Gateway Server Webflux Gatewayfilter Factories Addrequestheader Factory (`docs/modules/ROOT/pages/spring-cloud-gateway-server-webflux/gatewayfilter-factories/addrequestheader-factory.adoc`) Copy Section

[[addrequestheader-gatewayfilter-factory]]
= AddRequestHeader GatewayFilter Factory

The AddRequestHeader GatewayFilter factory takes a name and value parameter.
The following example configures an AddRequestHeader GatewayFilter:

.application.yml [source,yaml] Copy Chapter

spring:
cloud:
gateway:
server:
webflux:
routes:
- id: add_request_header_route
uri: https://example.org
filters:
- AddRequestHeader=X-Request-red, blue

This listing adds X-Request-red:blue header to the downstream request's headers for all matching requests.

AddRequestHeader is aware of the URI variables used to match a path or host.
URI variables may be used in the value and are expanded at runtime.
The following example configures an AddRequestHeader GatewayFilter that uses a variable: