Spring Cloud Gateway - 为每条路由设置不同的代理

Question

Is their any way we can configure proxy for each route.

Incoming request A -> route A matched -> just forward to target system Incoming request B -> route B matched -> set proxy for target system call -> forward to target system using the proxy

if I use set proxy using spring cloud gateway it is getting applied to all the routes

spring.cloud.gateway.httpclient.proxy.host= spring.cloud.gateway.httpclient.proxy.port=

Do you have any idea/ link/ code snippet how to solve that issue? Any hint is welcome.

Answer 1

spring:
  cloud:
    gateway:
      routes:
        - id: route1
          metadata:
            proxy-host: proxyhost
            proxy-port: 1000
          predicates:
          - Path=...
          uri: ...

        - id: route2
          metadata:
            proxy-host: proxyhost2
            proxy-port: 1000
          predicates:
          - Path=...
          uri: ...

kotlin

@Component
class CustomNettyRoutingFilter(
    private val httpClient: HttpClient,
    headersFiltersProvider: ObjectProvider<List<HttpHeadersFilter>>,
    properties: HttpClientProperties,
) : NettyRoutingFilter(
    httpClient,
    headersFiltersProvider,
    properties
) {
    private val httpClientCacheMap: ConcurrentMap<String, HttpClient> = ConcurrentHashMap()

    override fun getHttpClient(route: Route, exchange: ServerWebExchange): HttpClient {
        val proxyHost = route.metadata["proxy-host"] as? String
        val proxyPort = route.metadata["proxy-port"] as? Int
        return httpClientCacheMap.getOrPut(route.id) {
            when {
                proxyHost != null && proxyPort != null -> {
                    httpClient.proxy { proxySpec ->
                        proxySpec.type(ProxyProvider.Proxy.HTTP)
                            .host(proxyHost)
                            .port(proxyPort)
                    }
                }
                else -> httpClient
            }
        }
    }
}

Answer 2

Is this gonna help you?

In my service, every client has their own API server. So different endpoints are assigned according to the clientId by the OriginMappingFilter .

For example, After authentication,
if clientId header matched client1,
http://gateway.com/shops/every-resource is reached to http://client1.com/shops/every-resource

if clientId header matched client2,
http://gateway.com/shops/every-resource is reached to http://client2.com/shops/every-resource

@SpringBootApplication
public class GatewayApplication {

    @Value("${token.secret}")
    String tokenSecret;
    
    @Autowired
    private AuthenticationFilter authenticationfilter;
    
    @Autowired
    private OriginMappingFilter originMappingFilter;
    
    public static void main(String[] args) {
        SpringApplication.run(AutomangatewayApplication.class, args);
    }
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        
        return builder.routes()
                .route(r -> r.path("/clients/*/tokens-with/*").uri("http://localhost:8081"))
                                    
                .route(r -> r.path("/shops/**").filters(f -> f.filter(authenticationfilter).filter(originMappingFilter)).uri("no://op"))
                
                .build();
    }
    
    @Bean
    public TokenUtils tokenUtils() {
        return new TokenUtils(tokenSecret);
    }
    
    @Bean
    public RestTemplate restTemplate() {
       return new RestTemplate();
    }
    
}

@Component
public class OriginMappingFilter implements GatewayFilter, Ordered {
    
    private static final String LEGACY_WEBSERVER_ORIGIN = "http://localhost:9095";
    
    @Autowired
    private RestTemplate restTemplate;

    @Override
    public int getOrder() {
        return 10000;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        try {

            ServerHttpRequest request = exchange.getRequest();
            
            String clientId = request.getHeaders().get("clientId").get(0);
            String origin = originOfClient(clientId);

            URI newURI = new URI(origin + request.getPath().pathWithinApplication().value());
            
            System.out.println("destination: " + newURI.toString());

            exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, newURI);
            return chain.filter(exchange);
            
            
        } catch (URISyntaxException e ) {
            e.printStackTrace();
            throw new IllegalStateException("can't map client to origin",e);
        } catch (HttpServerErrorException e) {
            e.printStackTrace();
            throw new IllegalStateException("can't access to client resource",e);
        }
    }

    private String originOfClient(String clientId) {
        
        ResponseEntity<String> response =  restTemplate.getForEntity(LEGACY_WEBSERVER_ORIGIN+"/clients/"+clientId+"/ip", String.class);
        String ip = response.getBody();
        String origin = "http://"+ip+":8082";
        
        return origin;
    }
}

Answer 3

I could solve it like this

Step 1 : Define metadata for proxy in route

@Configuration
public class MyRouteConfiguration {
    @Bean
    public RouteLocator routes( //
            final RouteLocatorBuilder locatorBuilder, //
            final MyRoutingConfiguration routingConfiguration) {
        RouteLocatorBuilder.Builder builder = locatorBuilder.routes();
        routingConfiguration //
                .getRoutings() //
                .stream() //
                .forEach(routing -> builder //
                        .route(p -> p //
                                .path(toPatternString(routing.getPaths())) //
                                .filters(f -> f //
                                        .rewritePath(routing.getRewriteRegex(), routing.getRewriteReplacement()) //
                                .metadata("proxy-host", routing.getProxyHost()) //
                                .metadata("proxy-port", routing.getProxyPort()) //
                                .metadata("proxy-username", routing.getProxyUsername()) //
                                .metadata("proxy-password", routing.getProxyPassword()) //
                                .uri(routing.getUri())));
    
        return builder.build();
    }

Step 2 : Create a component extending from NettyRoutingFilter

@Component
public class HttpClientFilter extends NettyRoutingFilter {
    public HttpClientFilter(HttpClient httpClient, ObjectProvider<List<HttpHeadersFilter>> headersFiltersProvider,
            HttpClientProperties properties) {
        super(httpClient, headersFiltersProvider, properties);
    }
    @Override
    protected HttpClient getHttpClient(Route route, ServerWebExchange exchange) {
        Map<String, Object> metadata = route.getMetadata();
        String proxyHost = (String) metadata.getOrDefault("proxy-host", "default-host");
        String proxyPort = (String) metadata.getOrDefault("proxy-port", "default-port");
        String username = (String) metadata.getOrDefault("proxy-username", "default-user");
        String pass = (String) metadata.getOrDefault("proxy-password", "default-password");
        return super.getHttpClient(route, exchange) .proxy(proxy -> proxy //
                .type(ProxyProvider.Proxy.HTTP) //
                .host(proxyHost) //
                .port(Integer.valueOf(proxyPort)) //
                .username(username) //
                .password(password -> password = pass));
    }
}