[Spring Cloud Gateway] Route, Predicates, Filter 기본 개념

주요개념설명  

 

1. Routing Handler (RouteLocator)

spring:
  profiles: sandbox
  cloud:
    gateway:
      routes:
        - id: spring_cloud_test_id
          uri: http://my_url
          predicates:
            - Path=/api/v1/**, /api/v2/**
          filters:
            - SetRequestHeader=Host, my-domain.com
            - MyCustomFilter

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
      .route("r1", r -> r.host("**.baeldung.com")
        .and()
        .path("/baeldung")
        .uri("http://baeldung.com"))
      .route(r -> r.host("**.baeldung.com")
        .and()
        .path("/myOtherRouting")
        .filters(f -> f.prefixPath("/myPrefix"))
        .uri("http://othersite.com")
        .id("myOtherID"))
    .build();
}

- Route: id, uri, set of predicatest and filters. (uri -> 여러 destination에서 dynamic routing 가능)

- Predicate: Java8's predicate. HTTP request의 header, method, parameter 매칭을 위해 사용됨 

- Filter: Spring's WebFilter

 

2. Routing Factories 

SCG는 WebFlux HandlerMapping를 사용하여 라우팅한다. 다양한 Built-in Route Predicate Factories이 이미 정의되어 있다.

 

1) Before

datetime값을 받아서, 현재시간이 해당시간 이전이면 ok

predicates:
        - Before=2017-09-11T17:42:47.789-07:00[America/Alaska]

.route(r -> r.before(LocalDateTime.now().atZone(ZoneId.systemDefault())) 

 

2)  Between

datetime  2개를 받아서, 현재시간이 해당 시간 사이이면  ok

predicates:
        - Between=2017-09-10T17:42:47.789-07:00[America/Alaska], 2017-09-11T17:42:47.789-07:00[America/Alaska]

ZonedDateTime datetime1 = LocalDateTime.now().minusDays(1).atZone(ZoneId.systemDefault());
ZonedDateTime datetime2 = LocalDateTime.now().atZone(ZoneId.systemDefault())
//..route definition
.route(r -> r.between(datetime1, datetime2))

 

3) Header

헤더명과 정규식을 받아서 해당 헤더의 값이 정규식 패턴에 맞으면 ok

predicates:
	- Header=X-Request-Id, \d+

.route(r -> r.header("X-Request-Id", "\\d+")

 

4) Host

host name pattern을 받아서 패턴에 맞으면 ok

predicates:
        - Host=**.baeldung.com

.route(r -> r.host("**.baeldung.com")

 

5) Method

메소드를 받아서 맞으면 ok

predicates:
        - Method=GET

route(r -> r.method("GET")

 

6) Path

Spring PathMather pattern을 받아서 패턴에 맞으면 ok

predicates:
        - Path=/articles/{articleId}

.route(r -> r.path("/articles/"+articleId)

 

7) Query

필수값과 정규식(Optional)을 받아서 정규식 패턴에 맞으면 ok

predicates:
        - Query=articleId, \w

.route(r -> r.query("articleId", "\w")

 

8) RemoteAddr

CIDR-notation strings 목록을 받아서 remoteAddr을 통과하면  ok

predicates:
        - RemoteAddr=192.168.1.1/24

 

.route(r -> r.remoteAddr("192.168.1.1/24")

 

3. WebFilter Factories

routing filter는 들어오는(incoming) HTTP request와 나가는(outgoing) HTTP response를 수정한다. SCG에는 다양한 built-in WebFilter Factories가 이미 정의되어 있다.

 

1) AddRequestHeader

filters:
        - AddRequestHeader=X-SomeHeader, bael

.filters(f -> f.addRequestHeader("X-TestHeader", "rewrite_request"))

 

2) AddRequestParameter

filters:
        - AddRequestParameter=foo, bar

.filters(f -> f.addRequestParameter("foo", "bar"))

 

3) AddResponseHeader

filters:
        - AddResponseHeader=X-SomeHeader, Bar

.filters(f -> f.addResponseHeader("X-SomeHeader", "Bar"))

 

4) Circuit Breaker

filters:
        - Hystrix=someCommand

.filters(f -> f.hystrix("some-command"))

 

5) RedirectTo

status를 캐치해서 url로 redirect 시킨다. status는 3xx 여야한다.

filters:
        - RedirectTo=302, http://foo.bar

.filters(f -> f.redirect("302","http://foo.bar"))

 

6) RewirtePath

요청을 rewrite한다.

filters:
        - RewritePath=/articles/(?<articleId>.*), /$\{articleId}

.filters(f -> f.rewritePath("(?<articleId>.*)", articleId))

 

7) RequestRateLimiter

• eplenishRate – 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

filters:
        - RequestRateLimiter=10, 50, userKeyResolver

.filters(f -> f.requestRateLimiter().configure(c -> c.setRateLimiter(myRateLimiter)))

 

즉 predicates는 특정 요청을 통과시키기 위한 조건들이고, filters는 필터를 통해 req/res의 변형이 일어나는 것.