[MSA] Spring Cloud Gateway로 API 게이트웨이 구축하기

📌 Spring Cloud Gateway

1) 스프링 클라우드 게이트웨이란

• 스프링에서 제공하는 API 게이트웨이 구축을 위한 라이브러리 중 하나임
• API 게이트웨이가 추상적인 개념이라면, 스프링 클라우드 게이트웨이는 구현체 느낌

 

2) 구성 요소

크게 3가지 구성요소가 존재함

• Route
  • 고유ID, 목적지 URI, Predicate, Filter로 구성됨
  • 게이트웨이로 요청된 URI의 조건이 참일 경우, 매핑된 해당 경로로 요청을 전달해줌
• Predicate
  • 주어진 요청이 조건을 충족하는지 테스트하는 구성요소
  • 각 요청 경로에 대해 충족해야 하는 1개 이상의 조건자를 정의할 수 있음
  • 만약 정의된 모든 Predicate에 매칭되지 않는다면 HTTP 404 Not Found를 반환함
• Filter
  • 요청 및 응답에 대한 전처리, 후처리를 담당하는 구성요소
• 이러한 설정은 Java DSL로 정의하거나 application.yml 등의 설정 파일에 정의할 수 있음

 

위 설정들은 RouteDefinition 객체로 매핑되고, 매핑된 설정정보들을 바탕으로 게이트웨이가 동작함

public class RouteDefinition {  
  
   private String id;  
  
   @NotEmpty  
   @Valid   private List<PredicateDefinition> predicates = new ArrayList<>();  
  
   @Valid  
   private List<FilterDefinition> filters = new ArrayList<>();  
  
   @NotNull  
   private URI uri;  
  
   private Map<String, Object> metadata = new HashMap<>();  
  
   private int order = 0;  
  
   public RouteDefinition() {  
   }

	...
}

 

3) 동작 방식

API 게이트웨이로서 작동하기 위해서는 API 게이트웨이가 제공하는 기능들을 제공해줘야 하는데, 이를 위해 스프링 클라우드 게이트웨이 어떻게 구현되어 동작하는가?

 

흐름

1. 클라이언트가 스프링 클라우드 게이트웨이로 요청함
2. Gateway Handler Mapping는 Route마다 설정된 Predicate을 적용해 알맞은 Route Instance를 찾고, 요청을 Gateway Web Handler로 전달함
3. Gateway Web Handler가 Route에 정의된 Filter들로 Filter Chain을 생성하여 실행함
4. 모든 Pre-Filter 로직이 수행되면, Proxy 요청이 만들어지고, 이에 대한 응답이 오면, Post-Filter 로직이 수행되어 최종적으로 클라이언트에게 반환됨

 

즉, Filter를 정의해 인증/인가 및 로깅, 모니터링 및 메트릭 수집 등을 수행할 수 있음

 

📌 클루터에 도입하기 - API 라우팅 및 공통 인증 수행

1) API 라우팅

• yaml 파일에 API 엔드포인트별 Route, Predicate, Filter를 정의함

개선 포인트

• 서비스의 개수가 많아질 경우, yaml 파일의 사이즈가 커지고, API 라우팅 조건 관리가 어려워짐
• API 엔드포인트 관리자 페이지를 만들어 라우팅 조건 추가, 삭제가 쉽도록 개선할 수 있을 것으로 예상됨

 

2) 공통 인증 수행

수행 전

수행 후

• Authorization 필요하지 않은 요청 - 로그인/회원가입

• Authorization 필요한 요청

 

구현 방식

• 위의 스프링 클라우드 게이트웨이 동작방식을 보면, 공통 인증을 수행할 Filter를 정의해 인증이 필요한 API의 경우 해당 Filter를 거치도록 설정할 수 있음

 

1) Filter 정의

//공통 인증을 수행하는 AuthorizationHeaderFilter

@Component
public class AuthorizationHeaderGatewayFilterFactory extends AbstractGatewayFilterFactory<AuthorizationHeaderGatewayFilterFactory.Config> {

    private static final Logger logger = LoggerFactory.getLogger(AuthorizationHeaderGatewayFilterFactory.class);

    private final FilterUtils filterUtils;
    private final JwtUtils jwtUtils;

    private static final Pattern BEARER_TOKEN_PATTERN = Pattern.compile("Bearer (.*)");

    public AuthorizationHeaderGatewayFilterFactory(FilterUtils filterUtils, JwtUtils jwtUtils) {
        super(Config.class);
        this.filterUtils = filterUtils;
        this.jwtUtils = jwtUtils;
    }

    @Override
    public GatewayFilter apply(AuthorizationHeaderGatewayFilterFactory.Config config) {
        return (exchange, chain) -> {
            String token = resolveToken(exchange);
            String userId = getUserId(token);
            return chain.filter(filterUtils.setRequestHeader(exchange, JwtUtils.USER_ID, userId));
        };
    }

    private String resolveToken(ServerWebExchange exchange) {
        String token = filterUtils.getHeaderValue(exchange.getRequest().getHeaders(), JwtUtils.AUTHORIZATION);
        if (!StringUtils.hasText(token)) throw new GatewayErrorException(GatewayError.AUTHENTICATION_FAIL);
        Matcher matcher = BEARER_TOKEN_PATTERN.matcher(token);
        if (!matcher.matches()) throw new GatewayErrorException(GatewayError.AUTHENTICATION_FAIL);
        return matcher.group(1);
    }

    private String getUserId(String token) {
        String userId = jwtUtils.getUserId(token);
        if (!StringUtils.hasText(userId)) throw new GatewayErrorException(GatewayError.NO_USERID_IN_TOKEN);
        return userId;
    }

    static class Config { }
}

참고

• 게이트웨이 필터 생성
• 인가 필터 구현 예시

 

2) 인증이 필요한 URI에 Filter 적용

참고

• yml 설정 파일에 filter 설정

 

3) Filter 적용 테스트

• WireMock을 사용해 설정 조건에 따라 Filter가 적용되는지 테스트 가능함

@SpringBootTest(
        webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
        classes = AuthorizationHeaderGatewayFilterFactoryTest.AuthorizationHeaderFilterTestConfig.class)
@AutoConfigureWebTestClient
public class AuthorizationHeaderGatewayFilterFactoryTest {

    @TestConfiguration
    static class AuthorizationHeaderFilterTestConfig {

        @Autowired
        AuthorizationHeaderGatewayFilterFactory authorizationHeaderGatewayFilterFactory;

        @Bean(destroyMethod = "stop")
        WireMockServer wireMockServer() {
            WireMockConfiguration options = WireMockConfiguration.wireMockConfig().dynamicPort();
            WireMockServer wireMock = new WireMockServer(options);
            wireMock.start();
            return wireMock;
        }

        @Bean
        RouteLocator testRoutes(RouteLocatorBuilder builder, WireMockServer wireMock) {
            AuthorizationHeaderGatewayFilterFactory.Config config = new AuthorizationHeaderGatewayFilterFactory.Config();
            GatewayFilter gatewayFilter = authorizationHeaderGatewayFilterFactory.apply(config);
            return builder.routes()
                    .route(predicateSpec -> predicateSpec
                            .path("/api/user/health")
                            .uri(wireMock.baseUrl()))
                    .route(predicateSpec -> predicateSpec
                            .path("/api/user/**")
                            .filters(filterSpec -> filterSpec.filter(gatewayFilter))
                            .uri(wireMock.baseUrl()))
                    .build();
        }
    }

    @Autowired
    WebTestClient webTestClient;

    @Autowired
    WireMockServer wireMockServer;

    @AfterEach
    void afterAll() {
        wireMockServer.resetAll();
    }

    @Value("${jwt.secret}")
    String secretKey;

    @Test
    @DisplayName("health check api는 인가 필터를 거치지 않음")
    void healthCheck() {
        //given
        wireMockServer.stubFor(WireMock.get("/api/user/health").willReturn(WireMock.ok()));

        //when, then
        webTestClient.get().uri("/api/user/health")
                .exchange()
                .expectStatus()
                .isEqualTo(HttpStatus.OK);
    }

    @Test
    @DisplayName("토큰 검증 성공 시 요청 헤더에 userId 값이 포함됨")
    void tokenValidationSuccess() {
        //given
        //토큰
        long now = new Date().getTime();
        Date exp = new Date(now + 1000 * 60 * 30);

        byte[] keyBytes = Decoders.BASE64.decode(secretKey);
        Key signingKey = Keys.hmacShaKeyFor(keyBytes);

        String token = Jwts.builder()
                .setSubject("clutter")
                .claim("auth", "ROLE_USER")
                .claim("userId", "1")
                .signWith(signingKey, SignatureAlgorithm.HS512)
                .setExpiration(exp)
                .compact();
        //요청
        String expectedUserId = "1";
        wireMockServer.stubFor(WireMock.get("/api/user/1").willReturn(WireMock.ok()));

        //when, then
        webTestClient.get().uri("/api/user/1")
                .headers(httpHeaders -> httpHeaders.add("Authorization", "Bearer " + token))
                .exchange()
                .expectStatus()
                .isEqualTo(HttpStatus.OK);

        wireMockServer.verify(WireMock.getRequestedFor(WireMock.urlEqualTo("/api/user/1"))
                .withHeader("userId", equalTo(expectedUserId)));
    }

    @Test
    @DisplayName("토큰 유효기간 만료 시 예외 반환함")
    void tokenInvalidThrowException() {
        //given
        //토큰
        long now = new Date().getTime();
        Date exp = new Date(now - 1000 * 60 * 30);

        byte[] keyBytes = Decoders.BASE64.decode(secretKey);
        Key signingKey = Keys.hmacShaKeyFor(keyBytes);

        String token = Jwts.builder()
                .setSubject("clutter")
                .claim("auth", "ROLE_USER")
                .claim("userId", "1")
                .signWith(signingKey, SignatureAlgorithm.HS512)
                .setExpiration(exp)
                .compact();
        //요청
        wireMockServer.stubFor(WireMock.get("/api/user/1").willReturn(WireMock.ok()));

        //when, then
        webTestClient.get().uri("/api/user/1")
                .headers(httpHeaders -> httpHeaders.add("Authorization", "Bearer " + token))
                .exchange()
                .expectStatus()
                .isEqualTo(HttpStatus.UNAUTHORIZED)
                .expectBody()
                .jsonPath("$.code").isEqualTo("-521");
    }

    @Test
    @DisplayName("토큰에 userId가 없는 경우 예외 반환함")
    void withoutUserIdThrowException() {
        //given
        //토큰
        long now = new Date().getTime();
        Date exp = new Date(now + 1000 * 60 * 30);

        byte[] keyBytes = Decoders.BASE64.decode(secretKey);
        Key signingKey = Keys.hmacShaKeyFor(keyBytes);

        String token = Jwts.builder()
                .setSubject("clutter")
                .claim("auth", "ROLE_USER")
//                .claim("userId", "1")
                .signWith(signingKey, SignatureAlgorithm.HS512)
                .setExpiration(exp)
                .compact();
        //요청
        wireMockServer.stubFor(WireMock.get("/api/user/1").willReturn(WireMock.ok()));

        //when, then
        webTestClient.get().uri("/api/user/1")
                .headers(httpHeaders -> httpHeaders.add("Authorization", "Bearer " + token))
                .exchange()
                .expectStatus()
                .isEqualTo(HttpStatus.UNAUTHORIZED)
                .expectBody()
                .jsonPath("$.code").isEqualTo("-520")
                .jsonPath("$.message").isEqualTo("토큰에 userId 값이 없습니다.");
    }

    @Test
    @DisplayName("요청에 Authorization 헤더가 없으면 예외 반환함")
    void noAuthorizationThrowException() {
        //given
        wireMockServer.stubFor(WireMock.get("/api/user/1").willReturn(WireMock.ok()));

        //when, then
        webTestClient.get().uri("/api/user/1")
                .exchange()
                .expectStatus()
                .isEqualTo(HttpStatus.UNAUTHORIZED)
                .expectBody()
                .jsonPath("$.code").isEqualTo("-522")
                .jsonPath("$.message").isEqualTo("인증에 실패했습니다.");
    }
}

참고

• WireMock을 사용한 테스트 코드 작성
• 공식 레포지토리의 필터 테스트 코드 예시