GateWay란?

📌 1. GateWay란? 

• MSA (Microservices Architecture)에서 Gateway는 여러 마이크로서비스를 단일 진입점(Entry Point)으로 통합하고 관리하는 중앙 집중식 API 라우터이다.
• 주로 API Gateway라고 불린다.

 

👉 단일 진입점 설정

*각 서비스 port에 직접 접근이 불가능하도록 방화벽 등 네트워크 설정으로 개별 서비스 포트에 대한 외부 접속을 차단.

*Spring Boot를 사용하면, server.port=8083 server.address=127.0.0.1설정하여 로컬에서만 접근 가능하도록 제한할 수 // Gateway에서 사용자 정보를 설정

exchange.getRequest().mutate().header("X-User-Roles", "ROLE_USER,ROLE_ADMIN").build();

있습니다.

 

 

✅ API Gateway의 역할

1. 요청 라우팅 (Request Routing): 클라이언트는 하나의 엔드포인트만 호출하면 되며, Gateway가 이를 적절한 서비스로 전달한다.
2. 인증 및 인가 (Authentication & Authorization): 인증 토큰 검증을 수행한다.
3. 로드 밸런싱 (Load Balancing): 여러 인스턴스가 배포된 마이크로서비스에 대해 로드 밸런싱을 수행하여 트래픽을 분배한다.
4. API 조합 (API Aggregation): 여러 마이크로서비스에서 데이터를 받아 하나의 응답으로 클라이언트에 전달할 수 있다.
5. 모니터링 및 로깅 (Monitoring & Logging): 모든 트래픽을 모니터링하고, 요청 및 응답에 대한 로깅을 수행하여 문제를 추적하거나 성능을 분석할 수 있다.

 

📌 2. 라이브러리 및 의존성 추가 

Spring Cloud Gateway를 이용하여 구현한다.

 

✅ 2-1. Spring Cloud Gateway란? 

Spring Cloud Gateway는 Spring Boot 애플리케이션에서 API Gateway 기능을 제공하는 라이브러리로 주로 외부 API 요청을 내부 서비스로 라우팅하는 역할

• 여러 서비스 간의 라우팅, 필터링, 인증/인가 등을 처리하는 역할로 많은 동시성을 처리한다.
• ⭐ WebFlux 기반으로 동작하므로, WebMVC와 차이를 이해해야 한다.

 

✅ 2-2. WebFlux란? 

WebFlux는 비동기 및 논블로킹 웹 애플리케이션을 위한 스타터

• Spring Cloud Gateway는 WebFlux를 기반으로 동작한다.
• Spring Cloud Gateway가 리액티브 프로그래밍 모델(Mono, Flux 등)을 활용하는 구조

 

🔥 spring-boot-starter-webflux vs spring-boot-starter-web

• spring-boot-starter-webflux: 비동기 및 논블로킹 웹 애플리케이션을 위한 스타터
• spring-boot-starter-web: 동기 웹 애플리케이션을 위한 스타터

 

✅ 2-3. 의존성 추가 

📖 build.gradle

// implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-webflux'
implementation 'org.springframework.cloud:spring-cloud-starter-gateway' // Spring Cloud

dependencyManagement {
    imports {
        // Spring Cloud 관련 의존성들의 버전 관리
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:2024.0.0"
    }
}

 

📌 3. Eureka와 통합 

유레카 클라이언트 설정 참고! 

🔗 Eureka

 

✅ 3-1. 사용 방법

• Eureka 미사용
  spring.cloud.gateway.routes[0].uri=http://localhost:8081,http://localhost:8082
• Eureka 사용
  spring.cloud.gateway.routes[0].uri=lb://SERVICE-1

⚠️ 참고

• SERVICE-1은 spring.application.name=service-1 설정된 이름이다.
• Eureka에 등록하려면 application name에 ‘_’를 포함하면 안 된다!! (‘-’ 사용)

 

📌 4. Configuration 

✅ 4-1. application.properties에서 설정

📖 application.properties

# 라우팅 ID (이 설정은 이 라우팅 규칙의 고유 식별자)
spring.cloud.gateway.routes[0].id=to_service1

# 요청을 라우팅할 URI (로드 밸런서를 사용하여 SERVICE-1으로 라우팅)
spring.cloud.gateway.routes[0].uri=lb://SERVICE-1

# 요청이 들어올 경로 (예: `/service1/**`에 맞는 요청을 해당 URI로 라우팅)
spring.cloud.gateway.routes[0].predicates[0]=Path=/service1/**

# 요청 헤더에 'X-Gateway-Header'라는 키와 'Gateway-Value'라는 값을 추가
dpring.cloud.gateway.routes[0].filters[0]=AddRequestHeader=X-Gateway-Header, Gateway-Value

 

📖 application.yml

spring:
  application:
    name: gateway
  cloud:
    gateway:
      routes:
        - id: service1
          uri: lb://SERVICE-1
          predicates:
            - Path=/service1/**
          filters:
            - StripPrefix=1

 

🚀 정리

• Gateway는 MSA에서 중요한 역할을 수행하며, Spring Cloud Gateway를 사용하여 쉽게 구현할 수 있다.
• Eureka를 통해 동적 라우팅을 설정할 수 있다.
• application.properties 또는 application.yml을 활용하여 유연하게 설정 가능하다.

 

✅ 4-2. GatewayConfig 작성

• Application설정 파일이 Configuration로 설정할 수 도 있다.
• 추가 로직이 필요할 때나 디버깅을 용이하게 하기위해 사용.

📖 GatewayConfig.java: 기본 형태

import org.springframework.cloud.gateway.config.EnableGateway;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class GatewayConfig {
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                // 상품 서비스
                .route("product_route", r -> r.path("/product/api/products/all")
                        .filters(f -> f.stripPrefix(1))
                        .uri("lb://product-service"))
                // 상품 서비스 - 권한 필요
                .route("product_route_auth_user", r -> r.path("/product/**")
                        .filters(f -> f.stripPrefix(1))
                        .filter((exchange, chain) -> { // ⭐ 조건에 따라 요청 차단 가능
                            List<String> roles = exchange.getAttribute("roles");
                             if (roles != null && roles.contains("ADMIN")) {
                                 return chain.filter(exchange); // 요청을 다음 필터로 전달
                            } else {                     
                                 exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
                                 return exchange.getResponse().setComplete();
                             }
            		})
                        .uri("lb://product-service"))

                .build();
    }
}

 

⭐ 재사용 가능한 Filter를 적용하고 싶다면?

🔥 GatewayFilter 종류

특성	GatewayFilter	GatewayFilterFactory
설정 방식	생성자 주입으로 필터의 동작을 설정	Config 클래스를 통해 동적으로 설정 가능
동적 파라미터	생성자에서 정적 값으로 설정	apply 메서드에서 동적으로 파라미터 설정
유연성	정적인 값에 의존	다양한 설정값을 동적으로 처리 가능
주 용도	고정된 동작을 하는 필터 구현	재사용 가능하고 동적으로 파라미터를 처리하는 필터

⭐ 아래 예시는 jwt 검증 필터인데 Spring Security에서 검증 할 경우 gateway filter에서는 검증할 필요 없다!!

 

📖 GatewayConfig.java: GatewayFilter 필터를 적용

import com.example.gateway.filter.JwtGatewayFilter;

@Configuration
public class GatewayConfig {
    private final JwtGatewayFilter jwtGatewayFilter;
    public GatewayConfig(JwtGatewayFilter jwtGatewayFilter) {
        this.jwtGatewayFilter = jwtGatewayFilter;
    }
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                // 상품 조회 서비스 (인증 생략)
                .route("product_route", r -> r.path("/product/api/products/all")
                        .filters(f -> f.stripPrefix(1))
                        .uri("lb://product-service"))
                // 상품 서비스 (인증 필요)
                .route("product_service", r -> r.path("/product/**")
                        .filters(f -> f.stripPrefix(1)
                                      .filter(jwtGatewayFilter))
                        .uri("lb://product-service"))
                .build();
    }
}

 

📖 JwtGatewayFilter.java: GatewayFilter

import java.util.List;

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;

import com.example.gateway.util.JwtTokenProvider;

import reactor.core.publisher.Mono;

@Component
public class JwtGatewayFilter implements GatewayFilter {

    private final JwtTokenProvider jwtTokenProvider;

    public JwtGatewayFilter(JwtTokenProvider jwtTokenProvider) {
        this.jwtTokenProvider = jwtTokenProvider;
    }
   
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = extractTokenFromRequest(exchange);

        if (token != null && jwtTokenProvider.validateToken(token)) {
            String username = jwtTokenProvider.getUsernameFromToken(token);
            List<String> roles = jwtTokenProvider.getRolesFromToken(token);
           
        // 권한 체크
        // if (requiredRole  != null && !roles.contains(requiredRole)) {
        //     //log.info("권한 부족: 필요한 역할 = {}, 사용자의 역할 = {}", requiredRole, roles);
        //     exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
        //     return exchange.getResponse().setComplete();
        // }
       
        /* 사용자 정보 저장 */

        // 1.  속성 맵에 추가: gateway 내 요청-응답 흐름 내의 로직에서만 사용
        // exchange.getAttributes().put("username", username);
        // exchange.getAttributes().put("roles", roles);

        // 2. 헤더 추가: 하위 서비스나 외부 API에도 반영
        ServerHttpRequest modifiedRequest = exchange.getRequest().mutate()
                .header("X-User-Id", username)
                .header("X-User-Roles", String.join(", ", roles))
                .build();

        exchange = exchange.mutate().request(modifiedRequest).build();

        // 3. SecurityContext에 설정: gateWay쪽 springSecurity만 적용되는거라 사용자 서비스랑 연동x
        // List<GrantedAuthority> authorities = roles.stream()
        //         .map(role -> new SimpleGrantedAuthority("ROLE_" + role))  // ROLE_ prefix 추가
        //         .collect(Collectors.toList());
       
        // Authentication authentication = new UsernamePasswordAuthenticationToken(username, null, authorities);
        // SecurityContextHolder.getContext().setAuthentication(authentication);

        } else {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }

        return chain.filter(exchange);
    }

    private String extractTokenFromRequest(ServerWebExchange exchange) {
        String bearerToken = exchange.getRequest().getHeaders().getFirst("Authorization");
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

📖 GatewayConfig.java: GatewayFilterFactory 필터를 적용

import com.example.gateway.filter.JwtGatewayFilterFactory;

@Configuration
public class GatewayConfig {

    private JwtGatewayFilterFactory jwtGatewayFilterFactory;

    public GatewayConfig(JwtGatewayFilterFactory jwtGatewayFilterFactory) {
        this.jwtGatewayFilterFactory = jwtGatewayFilterFactory;
    }

     // 공통 메서드: 역할을 설정하는 메서드
     private JwtGatewayFilterFactory.Config createConfigWithRole(String role) {
        JwtGatewayFilterFactory.Config config = new JwtGatewayFilterFactory.Config();
        config.setRequiredRole(role);
        return config;
    }

    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                // 상품 서비스
                .route("product_route", r -> r.path("/product/api/products/all")
                        .filters(f -> f.stripPrefix(1))
                        .uri("lb://product-service"))
                .route("product_route_auth_user", r -> r.path("/product/**")
                        .filters(f -> f.stripPrefix(1)
                                        .filter(jwtGatewayFilterFactory.apply(createConfigWithRole("USER")))
                                )
                        .uri("lb://product-service")) 
                .build();
    }
}

 

📖 JwtGatewayFilterFactory.java: GatewayFilterFactory

import java.util.List;

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;

import com.example.gateway.util.JwtTokenProvider;

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

    private final JwtTokenProvider jwtTokenProvider;

    public JwtGatewayFilterFactory(JwtTokenProvider jwtTokenProvider) {
        super(Config.class);
        this.jwtTokenProvider = jwtTokenProvider;
    }

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            String token = extractTokenFromRequest(exchange);

            if (token != null && jwtTokenProvider.validateToken(token)) {
                String username = jwtTokenProvider.getUsernameFromToken(token);
                List<String> roles = jwtTokenProvider.getRolesFromToken(token);

                // 권한 체크
                if (config.getRequiredRole() != null && !roles.contains(config.getRequiredRole())) {
                    exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN); //403
                    return exchange.getResponse().setComplete();
                }
           
                // 헤더 추가: 하위 서비스나 외부 API에도 반영
                ServerHttpRequest modifiedRequest = exchange.getRequest().mutate()
                        .header("X-User-Name", username)
                        .header("X-User-Roles", String.join(", ", roles))
                        .build();

                exchange = exchange.mutate().request(modifiedRequest).build();
            } else {
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED); //401
                return exchange.getResponse().setComplete();
            }

            return chain.filter(exchange);
        };
    }

    public static class Config {
        private String requiredRole;

        public String getRequiredRole() {
            return requiredRole;
        }

        public void setRequiredRole(String requiredRole) {
            this.requiredRole = requiredRole;
        }
    }

    private String extractTokenFromRequest(ServerWebExchange exchange) {
        String bearerToken = exchange.getRequest().getHeaders().getFirst("Authorization");  
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }

}