Rasimsen: /* Host Route Predicate Factor */

2018-11-28T13:56:48Z

‎Host Route Predicate Factor

Rasimsen: /* Query Route Predicate Factory */

2018-11-28T13:49:27Z

‎Query Route Predicate Factory

Rasimsen at 13:46, 28 November 2018

2018-11-28T13:46:11Z

Rasimsen: Created page with "= Overview= In this article, we’ll explore the main features of the Spring Cloud Gateway project, a new API based on Spring 5, Spring Boot 2 and Project Reactor. The tool p..."

2018-11-28T13:43:37Z

Created page with "= Overview= In this article, we’ll explore the main features of the Spring Cloud Gateway project, a new API based on Spring 5, Spring Boot 2 and Project Reactor. The tool p..."

New page

= Overview=
In this article, we’ll explore the main features of the Spring Cloud Gateway project, a new API based on Spring 5, Spring Boot 2 and Project Reactor.

The tool provides out-of-the-box routing mechanisms often used in microservices applications as a way of hiding multiple services behind a single facade.

For an explanation of the Gateway pattern without the Spring Cloud Gateway project, check out our previous article.

=Routing Handler=
Being focused on routing requests, the Spring Cloud Gateway forwards requests to a Gateway Handler Mapping – which determines what should be done with requests matching a specific route.

Let’s start with a quick example of how to the Gateway Handler resolves route configurations by using RouteLocator:
<syntaxhighlight lang="java">
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
return builder.routes()
.route("r1", r -> r.host("**.rasimsen.com")
.and()
.path("/rasimsen")
.uri("http://rasimsen.com"))
.route(r -> r.host("**.rasimsen.com")
.and()
.path("/myOtherRouting")
.filters(f -> f.prefixPath("/myPrefix"))
.uri("http://othersite.com")
.id("myOtherID"))
.build();
}
</syntaxhighlight>

Notice how we made use of the main building blocks of this API:

* Route – the primary API of the gateway. It is defined by a given identification (ID), a destination (URI) and set of predicates and filters
* Predicate – a Java 8’s Predicate – which is used for matching HTTP requests using headers, methods or parameters
* Filter – a standard Spring’s WebFilter

=Dynamic Routing=
Just like Zuul, Spring Cloud Gateway provides means for routing requests to different services.

The routing configuration can be created by using pure Java (RouteLocator, as shown in the example in section 2.1) or by using properties configuration:

<syntaxhighlight lang="java">
spring:
application:
name: gateway-service
cloud:
gateway:
routes:
- id: rasimsen
uri: rasimsen.com
- id: myOtherRouting
uri: localhost:9999
</syntaxhighlight>

=Routing Factories=
Spring Cloud Gateway matches routes using the Spring WebFlux HandlerMapping infrastructure.

It also includes many built-in Route Predicate Factories. All of these predicates match different attributes of the HTTP request. Multiple Route Predicate Factories can be combined via the logical “and”.

Route matching can be applied both programmatically or via configuration properties file using a different type of Route Predicate Factories.

==Before Route Predicate Factory==
The Before Route Predicate Factory takes one parameter: a datetime. This predicate matches requests that happen before the current datetime:

<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: before_route
uri: http://rasimsen.com
predicates:
- Before=2017-09-11T17:42:47.789-07:00[America/Alaska]
</syntaxhighlight>

The Java configuration can be represented as:

<syntaxhighlight lang="java">
//..route definition
.route(r -> r.before(LocalDateTime.now().atZone(ZoneId.systemDefault()))
.id("before_route")
.uri("http://rasimsen.com")
</syntaxhighlight>

==Between Route Predicate Factory==
The Between Route Predicate Factory takes two parameters: datetime1, and datetime2. This predicate matches requests that happen after datetime1 (inclusive) and before datetime2 (exclusive). The datetime2 parameter must be after datetime1:

<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: between_route
uri: http://rasimsen.com
predicates:
- Between=2017-09-10T17:42:47.789-07:00[America/Alaska], 2017-09-11T17:42:47.789-07:00[America/Alaska]
</syntaxhighlight>

And the Java configuration looks like this:
<syntaxhighlight lang="java">
ZonedDateTime datetime1 = LocalDateTime.now().minusDays(1).atZone(ZoneId.systemDefault());
ZonedDateTime datetime2 = LocalDateTime.now().atZone(ZoneId.systemDefault())
//..route definition
.route(r -> r.between(datetime1, datetime2))
.id("between_route")
.uri("http://rasimsen.com")
</syntaxhighlight>

==Header Route Predicate Factory==

The Header Route Predicate Factory takes two parameters: the header name, and a regular expression. This predicate matches a header matching the regular expression:

<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: header_route
uri: http://rasimsen.com
predicates:
- Header=X-Request-Id, \d+

</syntaxhighlight>

The Java configuration can be represented as:
<syntaxhighlight lang="java">
//..route definition
.route(r -> r.header("X-Request-Id", "\\d+")
.id("header_route")
.uri("http://rasimsen.com")
</syntaxhighlight>

==Host Route Predicate Factor==
The Host Route Predicate Factory takes one parameter: the hostname pattern. The pattern is an Ant-style pattern with “.” as the separator.

This predicate matches the Host header with the given the pattern:

<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: host_route
uri: http://rasimsen.com
predicates:
- Host=**.rasimsen.com
</syntaxhighlight>

Here’s the Java configuration alternative:
<syntaxhighlight lang="java">
//..route definition
.route(r -> r.host("**.baeldung.com")
.id("host_route")
.uri("http://rasimsen.com")
</syntaxhighlight>

==Method Route Predicate Factory==
The Method Route Predicate Factory takes one parameter: the HTTP method to match:

<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: method_route
uri: http://rasimsen.com
predicates:
- Method=GET
</syntaxhighlight>

The Java configuration can be represented as:
<syntaxhighlight lang="java">
//..route definition
.route(r -> r.method("GET")
.id("method_route")
.uri("http://rasimsen.com")
</syntaxhighlight>

==Path Route Predicate Factory==
The Path Route Predicate Factory takes one parameter: a Spring PathMatcher pattern:
<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: path_route
uri: http://rasimsen.com
predicates:
- Path=/articles/{articleId}
</syntaxhighlight>

The Java configuration:
<syntaxhighlight lang="java">
//..route definition
.route(r -> r.path("/articles/"+articleId)
.id("path_route")
.uri("http://rasimsen.com")
</syntaxhighlight>

==Query Route Predicate Factory==
The Query Route Predicate Factory takes two parameters: a required param and an optional regexp:

<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: query_route
uri: http://baeldung.com
predicates:
- Query=articleId, \w
</syntaxhighlight>

And the Java configuration:
<syntaxhighlight lang="java">
//..route definition
.route(r -> r.query("articleId", "\w")
.id("query_route")
.uri("http://rasimsen.com")
</syntaxhighlight>

==RemoteAddr Route Predicate Factory==
The RemoteAddr Route Predicate Factory takes a list (minimum of 1) of CIDR-notation strings, e.g., 192.168.0.1/16 (where 192.168.0.1 is an IP address, and 16 is a subnet mask):
<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: remoteaddr_route
uri: http://rasimsen.com
predicates:
- RemoteAddr=192.168.1.1/24
</syntaxhighlight>

And the corresponding Java configuration:
<syntaxhighlight lang="java">
//..route definition
.route(r -> r.remoteAddr("192.168.1.1/24")
.id("remoteaddr_route")
.uri("http://rasimsen.com")
</syntaxhighlight>

=WebFilter Factories=
Route filters make the modification of the incoming HTTP request or outgoing HTTP response possible.

Spring Cloud Gateway includes many built-in WebFilter Factories.

==AddRequestHeader WebFilter Factory==
The AddRequestHeader WebFilter Factory takes a name and value parameter:
<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: addrequestheader_route
uri: http://rasimsen.com
predicates:
- Path=/articles
filters:
- AddRequestHeader=X-SomeHeader, bael
</syntaxhighlight>

Here’s the corresponding Java config:
<syntaxhighlight lang="java">
//...route definition
.route(r -> r.path("/articles")
.filters(f -> f.addRequestHeader("X-TestHeader", "rewrite_request"))
.uri("http://rasimsen.com")
.id("addrequestheader_route")
</syntaxhighlight>

==AddRequestParameter WebFilter Factory==
The AddRequestParameter WebFilter Factory takes a name and value parameter:
<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: addrequestparameter_route
uri: http://rasimsen.com
predicates:
- Path=/articles
filters:
- AddRequestParameter=foo, bar
</syntaxhighlight>

The corresponding Java configuration:
<syntaxhighlight lang="java">
//...route definition
.route(r -> r.path("/articles")
.filters(f -> f.addRequestParameter("foo", "bar"))
.uri("http://rasimsen.com")
.id("addrequestparameter_route")
</syntaxhighlight>

==AddResponseHeader WebFilter Factory==

The AddResponseHeader WebFilter Factory takes a name and value parameter:

<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: addrequestheader_route
uri: http://rasimsen.com
predicates:
- Path=/articles
filters:
- AddResponseHeader=X-SomeHeader, Bar

</syntaxhighlight>

The corresponding Java configuration:
<syntaxhighlight lang="java">
//...route definition
.route(r -> r.path("/articles")
.filters(f -> f.addResponseHeader("X-SomeHeader", "Bar"))
.uri("http://rasimsen.com")
.id("addresponseheader_route")
</syntaxhighlight>

==Circuit Breaker WebFilter Factory==

Hystrix is used as Circuit-Breaker WebFilter Factory and takes a single name parameter, which is the name of the Hystrix command:

<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: hystrix_route
uri: http://rasimsen.com
predicates:
- Path=/articles
filters:
- Hystrix=someCommand

</syntaxhighlight>
The corresponding Java configuration:
<syntaxhighlight lang="java">
//...route definition
.route(r -> r.path("/articles")
.filters(f -> f.hystrix("some-command"))
.uri("http://rasimsen.com")
.id("hystrix_route")
</syntaxhighlight>

==RedirectTo WebFilter Factory==
The RedirectTo WebFilter Factory takes a status and a URL parameter. The status should be a 300 redirect HTTP code, such as 301:

<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: redirectto_route
uri: http://rasimsen.com
predicates:
- Path=/articles
filters:
- RedirectTo=302, http://foo.bar

</syntaxhighlight>

And the corresponding Java configuration:
<syntaxhighlight lang="java">
//...route definition
.route(r -> r.path("/articles")
.filters(f -> f.redirect("302","http://foo.bar"))
.uri("http://rasimsen.com")
.id("redirectto_route")
</syntaxhighlight>

==RewritePath WebFilter Factory==
The RewritePath WebFilter Factory takes a path regexp parameter and a replacement parameter. This uses Java regular expressions to rewrite the request path.

Here is a configuration example:

<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: rewritepath_route
uri: http://rasimsen.com
predicates:
- Path=/articles/**
filters:
- RewritePath=/articles/(?<articleId>.*), /$\{articleId}

</syntaxhighlight>

The Java configuration can be represented as:
<syntaxhighlight lang="java">
//...route definition
.route(r -> r.path("/articles")
.filters(f -> f.rewritePath("(?<articleId>.*)", articleId))
.uri("http://rasimsen.com")
.id("rewritepath_route")
</syntaxhighlight>

==RequestRateLimiter WebFilter Factory==
The RequestRateLimiter WebFilter Factory takes three parameters: replenishRate, capacity, and keyResolverName.

* replenishRate – represents how many requests per second do you want a user to be allowed to do
* capacity – defines how much bursting capacity would be allowed
* keyResolverName – is the name of a bean that implements the KeyResolver interface

The KeyResolver interface allows pluggable strategies to derive the key for limiting requests:
<syntaxhighlight lang="java">
spring:
  cloud:
    gateway:
      routes:
      - id: requestratelimiter_route
        uri: http://rasimsen.com
        predicates:
        - Path=/articles
        filters:
        - RequestRateLimiter=10, 50, userKeyResolver
</syntaxhighlight>
The Java configuration can be represented as:
<syntaxhighlight lang="java">
//...route definition
.route(r -> r.path("/articles")
  .filters(f -> f.requestRateLimiter().configure(c -> c.setRateLimiter(myRateLimiter)))
  .uri("http://rasimsen.com")
  .id("requestratelimiter_route")
</syntaxhighlight>

=Spring Cloud DiscoveryClient Support=
Spring Cloud Gateway can be easily integrated with Service Discovery and Registry libraries, such as Eureka Server and Consul:
<syntaxhighlight lang="java">
@Configuration
@EnableDiscoveryClient
public class GatewayDiscoveryConfiguration {

@Bean
public DiscoveryClientRouteDefinitionLocator
discoveryClientRouteLocator(DiscoveryClient discoveryClient) {

return new DiscoveryClientRouteDefinitionLocator(discoveryClient);
}
}
</syntaxhighlight>

==LoadBalancerClient Filter==
The LoadBalancerClientFilter looks for a URI in the exchange attribute property using ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR.

If the URL has a lb scheme (e.g., lb://rasimsen-service) it’ll use the Spring Cloud LoadBalancerClient to resolve the name (i.e., rasimsen-service) to an actual host and port.

The unmodified original URL is placed in the ServerWebExchangeUtils.GATEWAY_ORIGINAL_REQUEST_URL_ATTR attribute.

= Monitoring=
Spring Cloud Gateway makes use of the Actuator API, a well-known Spring-Boot library that provides several out-of-the-box services for monitoring the application.

Once the Actuator API is installed and configured, the gateway monitoring features can be visualized by accessing /gateway/ endpoint.

=Implementation=

We’ll now create a simple example of the usage of Spring Cloud Gateway as a proxy server using the path predicate.
== Dependencies==
The Spring Cloud Gateway is currently in the milestones repository, on version 2.0.0.RC2. This is also the version we’re using here.

To add the project, we’ll use the dependency management system:
<syntaxhighlight lang="xml">
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-gateway</artifactId>
<version>2.0.0.RC2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
</syntaxhighlight>

Next, we’ll add the necessary dependencies:

<syntaxhighlight lang="xml">
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
</syntaxhighlight>

==Code Implementation==
And now we create a simple routing configuration in the application.yml file:
<syntaxhighlight lang="java">
spring:
cloud:
gateway:
routes:
- id: rasimsen_route
uri: http://rasimsen.com
predicates:
- Path=/rasimsen/
management:
endpoints:
web:
exposure:
include: "*'

</syntaxhighlight>
And the Gateway application code:
<syntaxhighlight lang="java">
@SpringBootApplication
public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class, args);
}
}
</syntaxhighlight>

After the application starts, we can access the url: “http://localhost/actuator/gateway/routes/baeldung_route” to check all routing configuration created:
<syntaxhighlight lang="java">
{
"id":"rasimsen_route",
"predicates":[{
"name":"Path",
"args":{"_genkey_0":"/rasimsen"}
}],
"filters":[],
"uri":"http://rasimsen.com",
"order":0
}
</syntaxhighlight>

We see that the relative url: “/baeldung” is configured as a route, so hitting the url “http://localhost/baeldung” we’ll be redirected to “http://baeldung.com“, as was configured in our example.

=Conclusion=
In this article, we explored some of the features and components that are part of Spring Cloud Gateway. This new API provides out-of-the-box tools for gateway and proxy support.

source: https://www.baeldung.com/spring-cloud-gateway

@@ Line 151: / Line 151: @@
 <syntaxhighlight lang="java">
 //..route definition
-.route(r -> r.host("**.baeldung.com")
+.route(r -> r.host("**.rasimsen.com")
 .id("host_route")
 .uri("http://rasimsen.com")

@@ Line 208: / Line 208: @@
        routes:
        - id: query_route
-         uri: http://baeldung.com
+         uri: http://rasimsen.com
          predicates:
          - Query=articleId, \w

@@ Line 540: / Line 540: @@
 </syntaxhighlight>
-We see that the relative url: “/baeldung” is configured as a route, so hitting the url “http://localhost/baeldung” we’ll be redirected to “http://baeldung.com“, as was configured in our example.
+We see that the relative url: “/rasimsen” is configured as a route, so hitting the url “http://localhost/rasimsen” we’ll be redirected to “http://rasimsen.com“, as was configured in our example.
 =Conclusion=

New Spring Cloud Gateway - Revision history

Rasimsen: /* Host Route Predicate Factor */

Rasimsen: /* Query Route Predicate Factory */

Rasimsen at 13:46, 28 November 2018

Rasimsen: Created page with "= Overview= In this article, we’ll explore the main features of the Spring Cloud Gateway project, a new API based on Spring 5, Spring Boot 2 and Project Reactor. The tool p..."