Spring Cloud Gateway

https://docs.spring.io/spring-cloud-gateway/reference/
Admin
Spring Cloud Gateway is an API Gateway built on Spring 6, Spring Boot 3, and Project Reactor that...
Tokens:97,966
Snippets:713
Trust Score:10
Update:14 hours ago
Show doc for...
Tokens:
Raw
### GET /actuator/gateway/routes/{id} response example

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Example JSON response from a GET request to retrieve a single route. The response uses a human-readable predicate string, unlike the shortcut DSL format used in POST requests.

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

--------------------------------

### Define method and path route with Java DSL

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/gateway-request-predicates.html

Java configuration using the convenience GET method to combine method and path predicates. The route matches GET requests to /mypath and forwards to https://example.org.

```java
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();
    }
}
```

--------------------------------

### Global Filters Response from /actuator/gateway/globalfilters

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Example response from a GET request to /actuator/gateway/globalfilters. Shows global filters with their string representation and order in the filter chain.

```text
{
  "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
}
```

--------------------------------

### X-Forwarded-For header example

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/request-predicates-factories.html

Example header value used to illustrate how maxTrustedIndex values affect remote address resolution.

```none
X-Forwarded-For: 0.0.0.1, 0.0.0.2, 0.0.0.3
```

--------------------------------

### Route Filters Response from /actuator/gateway/routefilters

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Example response from a GET request to /actuator/gateway/routefilters. Shows GatewayFilter factories with their string representation and a null value due to incomplete implementation.

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

--------------------------------

### WebFlux ProxyExchange Example

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-proxy-exchange.html

Example of using ProxyExchange in a Spring WebFlux controller to proxy a GET request to /test downstream to a remote server. Requires the spring-cloud-gateway-proxyexchange-webflux module on the classpath.

```java
@RestController
@SpringBootApplication
public class GatewaySampleApplication {

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

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

}
```

--------------------------------

### Host Predicate Configuration

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/gateway-request-predicates.html

Configuration examples for the Host predicate in both YAML and Java DSL. The predicate matches the Host header against the provided patterns.

```APIDOC
## Host Predicate

### Description
The `Host` route predicate factory matches the `Host` header against a list of Ant-style patterns. It supports URI template variables and extracts them into `ServerRequest.attributes()` under `MvcUtils.URI_TEMPLATE_VARIABLES_ATTRIBUTE`.

### Configuration

#### YAML Configuration

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

#### Java DSL Configuration

```java
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();
    }
}
```

### Parameters
- **patterns** (list of strings) - Required - Ant-style host name patterns with `.` as separator. Supports URI template variables (e.g., `{sub}.myhost.org`).

### Behavior
- Matches if the `Host` header value matches any of the provided patterns.
- Extracts URI template variables (e.g., `sub`) into `ServerRequest.attributes()` under `MvcUtils.URI_TEMPLATE_VARIABLES_ATTRIBUTE`.
- Extracted values are available for use by Gateway Handler Filter Functions.

### Example Matching
- Pattern `**.somehost.org` matches `www.somehost.org` and `beta.somehost.org`.
- Pattern `**.anotherhost.org` matches `www.anotherhost.org`.
```

--------------------------------

### ProxyExchange Path Extraction Example

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-proxy-exchange.html

Example of using the path() method on ProxyExchange to extract trailing path elements from the incoming request and pass them downstream.

```java
@GetMapping("/proxy/path/**")
public ResponseEntity<?> proxyPath(ProxyExchange<byte[]> proxy) throws Exception {
  String path = proxy.path("/proxy/path/");
  return proxy.uri(home.toString() + "/foos/" + path).get();
}
```

--------------------------------

### Create a simple route with RouterFunctions.route()

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/java-routes-api.html

Use RouterFunctions.route() to build a route that matches GET /get and forwards to https://example.org. The http() handler function is used as the final parameter.

```java
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<ServerResponse> getRoute() {
        return route().GET("/get", http())
            .before(uri("https://example.org"))
            .build();
    }
}
```

--------------------------------

### SampleBeforeFilterFunctions.java - custom Before filter implementation

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/writing-custom-predicates-and-filters.html

Example implementation of a Before filter that adds a header with a generated value to the request. It is simpler than the HandlerFilterFunction because it only deals with the ServerRequest.

```java
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();
	}
}
```

--------------------------------

### GET /actuator/gateway/

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Provides an overview of the available child actuator endpoints and their supported HTTP methods.

```APIDOC
## GET /actuator/gateway/

### Description
Provides an overview of the available child actuator endpoints and their supported HTTP methods.

### Method
GET

### Endpoint
/actuator/gateway/

### Response
#### Success Response (200)
Returns a list of objects with href and methods fields.

#### Response Example
```json
[
   {
      "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" ]
   }
]
```
```

--------------------------------

### Method Route Predicate Factory configuration (application.yml)

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/request-predicates-factories.html

Configures a route with the Method predicate to match GET or POST requests. The route id is 'method_route' and the URI is 'https://example.org'.

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

--------------------------------

### Configure StripPrefix filter in Java

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/filters/stripprefix.html

Java configuration using GatewayRouterFunctions and BeforeFilterFunctions to define the same route as the YAML example. The stripPrefix(2) filter is applied before the uri filter.

```java
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.stripPrefix;
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> gatewayRouterFunctionsStripPrefix() {
        return route("strip_prefix_route")
            .GET("/name/**", http())
            .before(uri("https://example.org"))
            .before(stripPrefix(2))
            .build();
    }
}
```

--------------------------------

### Enable Permissions-Policy on a specific route

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/gatewayfilter-factories/secureheaders-factory.html

Shows how to configure Permissions-Policy separately for a route by using the enable and permissions-policy arguments in the SecureHeaders filter. The example allows geolocation only for https://anotherexample.org.

```yaml
      - id: secureheaders_route
        uri: http://anotherexample.org
        predicates:
        - Path=/**
        filters:
          - name: SecureHeaders
            args:
              disable: x-frame-options
              enable: permissions-policy
              permissions-policy : geolocation=("https://anotherexample.org")
```

--------------------------------

### Define Path route with Java DSL in GatewaySampleApplication.java

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/gateway-request-predicates.html

Java configuration using the fluent API to create a route with the path predicate, forwarding to https://example.org. Requires imports for route, http, path, and uri functions.

```java
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();
    }
}

```

--------------------------------

### Equivalent Retry filter configurations: full and shortcut notation

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/gatewayfilter-factories/retry-factory.html

Two YAML configurations showing the full Retry filter arguments and the equivalent shortcut notation 'Retry=3,INTERNAL_SERVER_ERROR,GET,10ms,50ms,2,false,0.5,100ms'. Both routes use the same parameters: retries=3, statuses=INTERNAL_SERVER_ERROR, methods=GET, backoff (firstBackoff=10ms, maxBackoff=50ms, factor=2, basedOnPreviousValue=false), jitter (randomFactor=0.5), and timeout=100ms. The shortcut notation is simplified with a single status and method.

```yaml
spring:
  cloud:
    gateway:
      server:
        webflux:
          routes:
          - id: retry_route
            uri: https://example.org
            filters:
            - name: Retry
              args:
                retries: 3
                statuses: INTERNAL_SERVER_ERROR
                methods: GET
                backoff:
                  firstBackoff: 10ms
                  maxBackoff: 50ms
                  factor: 2
                  basedOnPreviousValue: false
                jitter:
                  randomFactor: 0.5
                timeout: 100ms

          - id: retryshortcut_route
            uri: https://example.org
            filters:
            - Retry=3,INTERNAL_SERVER_ERROR,GET,10ms,50ms,2,false,0.5,100ms
```

--------------------------------

### MVC ProxyExchange Example

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-proxy-exchange.html

Example of using ProxyExchange in a Spring MVC controller to proxy a GET request to /test downstream to a remote server. Requires the spring-cloud-gateway-proxyexchange-webmvc module on the classpath.

```java
@RestController
@SpringBootApplication
public class GatewaySampleApplication {

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

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

}
```

--------------------------------

### Java configuration with XForwardedRemoteAddressResolver (GatewayConfig.java)

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/request-predicates-factories.html

Shows how to use XForwardedRemoteAddressResolver.maxTrustedIndex(1) and configure routes with remoteAddr predicates, including a direct route and a proxied route using the resolver.

```java
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")
)
```

--------------------------------

### Route CORS Configuration in application.yml

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/cors-configuration.html

Applies CORS directly to a route via metadata with key 'cors'. If no Path predicate is present, '/**' is applied. This example allows all origins, GET and POST methods, all headers, and a max age of 30 seconds.

```yaml
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
```

--------------------------------

### application.yml - Custom DiscoveryClient predicates and filters

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/the-discoveryclient-route-definition-locator.html

YAML format for customizing predicates and filters for DiscoveryClient routes. Same caveat: include RewritePath to avoid 404s.

```yaml
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 + '/?(?<remaining>.*)'"
              replacement: "'/${remaining}'"
```

--------------------------------

### GET /actuator/gateway/routes

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Retrieves all routes defined in the gateway.

```APIDOC
## GET /actuator/gateway/routes

### Description
Retrieves all routes defined in the gateway.

### Method
GET

### Endpoint
/actuator/gateway/routes

### Response
#### Success Response (200)
Returns a list of routes.

#### Response Example
(Not provided in source)
```

--------------------------------

### POST /actuator/gateway/routes/{id} request body example

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

JSON body for creating a route via the actuator endpoint. Predicates and filters must be shortcut DSL strings (e.g., "Path=/mypath/**"). A successful creation returns 201 Created, and you must call POST /actuator/gateway/refresh to apply the change.

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

--------------------------------

### GET /actuator/gateway/routedefinitions

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Retrieves the route definitions for the gateway.

```APIDOC
## GET /actuator/gateway/routedefinitions

### Description
Retrieves the route definitions for the gateway.

### Method
GET

### Endpoint
/actuator/gateway/routedefinitions

### Response
#### Success Response (200)
Returns the route definitions.

#### Response Example
(Not provided in source)
```

--------------------------------

### GET /actuator/gateway/routes/{id}

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Displays information about a particular route.

```APIDOC
## GET /actuator/gateway/routes/{id}

### Description
Displays information about a particular route.

### Method
GET

### Endpoint
/actuator/gateway/routes/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the route to retrieve.

### Response
#### Success Response (200)
Returns information about the specified route.
```

--------------------------------

### RouteConfiguration.java - Using cacheAndReadBody and adaptCachedBody

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/filters/adaptcachedbody.html

Configures a gateway route with a before filter that caches the request body as a String and then adapts it for downstream re-reading. Requires the Java DSL and the static imports shown. The adaptCachedBody filter must be registered after cacheAndReadBody; otherwise it is a no-op and the downstream service receives an empty body.

```java
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.adaptCachedBody;
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> gatewayRouterFunctionsCachedBody() {
        return route("cached_body_route")
            .route(path("/api/**"), http())
            .before(uri("https://example.org"))
            .before(request -> {
                // Read the body and store it in the request attributes.
                // Subsequent calls to request.body() or servletRequest().getInputStream()
                // will see the cached bytes.
                Optional<String> body = MvcUtils.cacheAndReadBody(request, String.class); (1)
                body.ifPresent(b -> {
                    // e.g. validate an HMAC, log, or transform
                });
                return request;
            })
            .before(adaptCachedBody())   (2)
            .build();
    }
}
```

--------------------------------

### GET /actuator/gateway/routes

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Displays the list of routes defined in the gateway.

```APIDOC
## GET /actuator/gateway/routes

### Description
Displays the list of routes defined in the gateway.

### Method
GET

### Endpoint
/actuator/gateway/routes

### Response
#### Success Response (200)
Returns a list of routes.
```

--------------------------------

### Configure Host route predicate in Java

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/gateway-request-predicates.html

Java configuration using RouterFunction to define a route with the host predicate and a before filter that sets the URI to https://example.org.

```java
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();
    }
}

```

--------------------------------

### GET /actuator/gateway/routes/{routeId}

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Retrieves a specific route by its ID.

```APIDOC
## GET /actuator/gateway/routes/{routeId}

### Description
Retrieves a specific route by its ID.

### Method
GET

### Endpoint
/actuator/gateway/routes/{routeId}

### Parameters
#### Path Parameters
- **routeId** (string) - Required - The ID of the route.

### Response
#### Success Response (200)
Returns the route details.

#### Response Example
(Not provided in source)
```

--------------------------------

### Add Spring Security starters to pom.xml

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/spring-security.html

Include these dependencies in your Maven pom.xml to add core security, OAuth2 client, and resource server support to the gateway.

```xml
<!-- Core security (authentication and authorization) -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<!-- OAuth2 login and token relay to downstream services -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>

<!-- Resource server: validate JWT or opaque tokens on each request -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>
```

--------------------------------

### GET /actuator/gateway/routepredicates

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Retrieves the route predicates available for routes.

```APIDOC
## GET /actuator/gateway/routepredicates

### Description
Retrieves the route predicates available for routes.

### Method
GET

### Endpoint
/actuator/gateway/routepredicates

### Response
#### Success Response (200)
Returns the route predicates.

#### Response Example
(Not provided in source)
```

--------------------------------

### Equivalent YAML route configurations using named and shortcut filters

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/configuration.html

Shows two equivalent route definitions in application.yml: one using named filter arguments and one using the shortcut notation. Both set the status to 401.

```yaml
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
```

--------------------------------

### GET /actuator/gateway/routefilters

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Retrieves the route filters available for routes.

```APIDOC
## GET /actuator/gateway/routefilters

### Description
Retrieves the route filters available for routes.

### Method
GET

### Endpoint
/actuator/gateway/routefilters

### Response
#### Success Response (200)
Returns the route filters.

#### Response Example
(Not provided in source)
```

--------------------------------

### Before predicate configuration with epoch milliseconds (application.yml)

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/gateway-request-predicates.html

Configures a route with the Before predicate using epoch milliseconds. The route matches requests before the specified datetime.

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

--------------------------------

### GET /actuator/gateway/globalfilters

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Retrieves the global filters applied to all routes.

```APIDOC
## GET /actuator/gateway/globalfilters

### Description
Retrieves the global filters applied to all routes.

### Method
GET

### Endpoint
/actuator/gateway/globalfilters

### Response
#### Success Response (200)
Returns the global filters.

#### Response Example
(Not provided in source)
```

--------------------------------

### GET /actuator/gateway/globalfilters

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Displays the list of global filters applied to the routes.

```APIDOC
## GET /actuator/gateway/globalfilters

### Description
Displays the list of global filters applied to the routes.

### Method
GET

### Endpoint
/actuator/gateway/globalfilters

### Response
#### Success Response (200)
Returns a list of global filters.
```

--------------------------------

### Configure a route with rate limiting using Bucket4j

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/filters/ratelimiter.html

Sets up a route that applies rate limiting with a capacity of 100 tokens per minute. The key resolver extracts the principal name from the servlet request. The filter uses the rateLimit function from Bucket4jFilterFunctions.

```java
import static org.springframework.cloud.gateway.server.mvc.filter.BeforeFilterFunctions.uri;
import static org.springframework.cloud.gateway.server.mvc.filter.Bucket4jFilterFunctions.rateLimit;
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> gatewayRouterFunctionsRateLimited() {
        return route("rate_limited_route")
            .GET("/api/**", http())
            .before(uri("https://example.org"))
            .filter(rateLimit(c -> c.setCapacity(100)
                    .setPeriod(Duration.ofMinutes(1))
                    .setKeyResolver(request -> request.servletRequest().getUserPrincipal().getName())))
            .build();
    }
}
```

--------------------------------

### Before predicate Java configuration (GatewaySampleApplication.java)

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/gateway-request-predicates.html

Java configuration for a before route using the GatewayRouterFunctions API. The route matches requests before the specified ZonedDateTime.

```java
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();
    }
}
```

--------------------------------

### GET /actuator/gateway/routefilters

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

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

```APIDOC
## GET /actuator/gateway/routefilters

### Description
Displays the list of GatewayFilter factories applied to a particular route.

### Method
GET

### Endpoint
/actuator/gateway/routefilters

### Parameters
#### Query Parameters
- **routeId** (string) - Required - The ID of the route for which to display filters.

### Response
#### Success Response (200)
Returns a list of GatewayFilter factories for the specified route.
```

--------------------------------

### GET /actuator/gateway/routes/{routeId}/combinedfilters

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

Retrieves the combined filters for a specific route.

```APIDOC
## GET /actuator/gateway/routes/{routeId}/combinedfilters

### Description
Retrieves the combined filters for a specific route.

### Method
GET

### Endpoint
/actuator/gateway/routes/{routeId}/combinedfilters

### Parameters
#### Path Parameters
- **routeId** (string) - Required - The ID of the route.

### Response
#### Success Response (200)
Returns the combined filters for the route.

#### Response Example
(Not provided in source)
```

--------------------------------

### Implement HttpClientCustomizer to set timeouts

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/http-client.html

Implements the HttpClientCustomizer interface, overriding the customize method to set connect and read timeouts on the HTTP client. The example sets CONNECT_TIMEOUT_MILLIS to 5000 and SO_TIMEOUT to 10000.

```java
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;
        });
    }
}
```

--------------------------------

### Configure Bucket4j RateLimiter in application.yml

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/gatewayfilter-factories/requestratelimiter-factory.html

Example configuration for a request rate limit of 10 per user with a burst of 20. The refill period is 1 second and each request costs 1 token. This configuration is not recommended for production.

```yaml
spring:
  cloud:
    gateway:
      server:
        webflux:
          routes:
          - id: requestratelimiter_route
            uri: https://example.org
            filters:
            - name: RequestRateLimiter
              args:
                bucket4j-rate-limiter.capacity: 20
                bucket4j-rate-limiter.refillTokens: 10
                bucket4j-rate-limiter.refillPeriod: 1s
                bucket4j-rate-limiter.requestedTokens: 1
```

--------------------------------

### Enable Permissions-Policy header globally

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/gatewayfilter-factories/secureheaders-factory.html

Shows how to enable the Permissions-Policy header globally by setting the enable property to permissions-policy and providing a permissions-policy value. The example disables geolocation except for the site's own origin and https://example.com.

```yaml
spring:
  cloud:
    gateway:
      filter:
        secure-headers:
          enable: permissions-policy
          permissions-policy : geolocation=(self "https://example.com")
```

--------------------------------

### Actuator gateway endpoint overview response

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/actuator-api.html

JSON response from GET /actuator/gateway/ listing available sub-endpoints and their HTTP methods.

```json
[
   {
      "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" ]
   }
]
```

--------------------------------

### Configure Trusted X.509 Certificates - application.yml

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webflux/tls-and-ssl.html

For production, provide a list of known certificates that the gateway can trust using the trustedX509Certificates property. If not provisioned, the default trust store is used (overridable via javax.net.ssl.trustStore).

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

--------------------------------

### Define function beans for routing

Source: https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway-server-webmvc/java-routes-api.html

Example Spring Boot application with two Function beans, uppercase and concat, that become route paths.

```java
@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;
	}
}
```
Tokens:
Raw