OAuth2 与多个网关实例共享主体对象

Posted 2023-02-27

【中文标题】OAuth2 与多个网关实例共享主体对象

【英文标题】：OAuth2 Share Principal Object with Multiple Gateway Instances

【发布时间】：2020-11-18 21:01:19

【问题描述】：

我已将 Spring Cloud Gateway 与 OAuth2 服务器集成。它适用于单实例网关。这是我的安全配置。

@EnableWebFluxSecurity
public class GatewaySecurityConfiguration 

    @Bean
    public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) 
        http
                .authorizeExchange().pathMatchers("/user/v3/api-docs", "/actuator/**").permitAll()
                .anyExchange().authenticated()
            .and()
                .oauth2Login()
            .and()
                .csrf().disable();
        return http.build();
    

但是，当我将网关扩展到 2 个实例时，一些请求可以正常工作，但是一些请求返回 401。

    load balancer (kubernetes nodeport service)
       /    \
  gateway   gateway
       \    /
(microservice clusters)

当我登录网关的第一个实例时，主体对象已成功创建，并将会话分配给 redis。如果下一个请求到达第二个实例，它会返回 401，因为它没有主体。

我该如何解决这个问题？

ps：我正在使用 redis 进行 Web 会话，以使网关之间的会话信息通用。

【参考方案1】：

TL;DR

您可以通过 WebSession 在 Redis 上共享会话主体信息。但是您不能共享访问令牌 (JWT)，因为它们存储在服务器的内存中。

解决方案 1：您的请求应始终发送到您登录的服务器。（详情如下） Solution-2：实现新的 ReactiveOAuth2AuthorizedClientService bean，将会话存储在 redis 中。 （详情如下）

长答案

来自 Spring Cloud 文档 (https://cloud.spring.io/spring-cloud-static/Greenwich.SR5/multi/multi__more_detail.html)；

ReactiveOAuth2AuthorizedClientService 的默认实现 TokenRelayGatewayFilterFactory 使用的内存数据存储。 您将需要提供自己的实现 如果您需要更强大的 ReactiveOAuth2AuthorizedClientService 解决方案。

你知道的第一件事：当你登录成功时，访问令牌（as jwt）由oauth2服务器返回，服务器创建会话并将此会话映射到ConcurrentHashMap上的访问令牌（authorizedClients实例InMemoryReactiveOAuth2AuthorizedClientService类）。

当你用你的 session id 请求 API Gateway 访问微服务时，访问 token(jwt) 由 gateway 中的 TokenRelayGatewayFilterFactory 解析，这个访问 token 设置在 Authorization 头中，请求转发到微服务。

那么，让我解释一下 TokenRelayGatewayFilterFactory 的工作原理（假设您通过 Redis 使用 WebSession，并且您有 2 个网关实例，并且您在 instance-1 登录。）

如果您的请求发往 instance-1，则主体通过会话 ID 从 redis 中获取，然后在过滤器中调用 authorizedClientRepository.loadAuthorizedClient(..)。此存储库是 AuthenticatedPrincipalServerOAuth2AuthorizedClientRepository 对象的实例。 isPrincipalAuthenticated() 方法返回 true，因此流程继续进行 authorizedClientService.loadAuthorizedClient()。该服务被定义为 ReactiveOAuth2AuthorizedClientService 接口，它只有一个实现（InMemoryReactiveOAuth2AuthorizedClientService）。这个实现有 ConcurrentHashMap(key: principal object, value: JWT) 如果您的请求转到实例 2，则上述所有流程均有效。但是提醒一下，ConcurrentHashMap 没有对 principal 的访问令牌，因为访问令牌存储在 instance-1 的 ConcurrentHashMap 中。因此，访问令牌为空，然后您的请求在没有 Authorization 标头的情况下向下游发送。您将收到 401 Unauthorized。

解决方案 1

因此，您的请求应始终发送到您登录的服务器以获取有效的访问令牌。

如果您使用 nginx 作为负载均衡器，请在

upstream

中使用

ip_hash

。 如果您使用 kubernetes 服务作为负载均衡器，请在

会话关联

中使用

ClientIP

。

解决方案 2

InMemoryReactiveOAuth2AuthorizedClientService 只是 ReactiveOAuth2AuthorizedClientService 的实现。因此，创建使用 Redis 的新实现，然后使用 primary bean。

@RequiredArgsConstructor
@Slf4j
@Component
@Primary
public class AccessTokenRedisConfiguration implements ReactiveOAuth2AuthorizedClientService 

    private final SessionService sessionService;

    @Override
    @SuppressWarnings("unchecked")
    public <T extends OAuth2AuthorizedClient> Mono<T> loadAuthorizedClient(String clientRegistrationId, String principalName) 
        log.info("loadAuthorizedClient for user ", principalName);
        Assert.hasText(clientRegistrationId, "clientRegistrationId cannot be empty");
        Assert.hasText(principalName, "principalName cannot be empty");

        // TODO: When changed immutability of OAuth2AuthorizedClient, return directly object without map.
        return (Mono<T>) sessionService.getSessionRecord(principalName, "accessToken").cast(String.class)
                .map(mapper -> 
                    return new OAuth2AuthorizedClient(clientRegistration(), principalName, accessToken(mapper));
        );
    

    @Override
    public Mono<Void> saveAuthorizedClient(OAuth2AuthorizedClient authorizedClient, Authentication principal) 
        log.info("saveAuthorizedClient for user ", principal.getName());
        Assert.notNull(authorizedClient, "authorizedClient cannot be null");
        Assert.notNull(principal, "principal cannot be null");

        return Mono.fromRunnable(() -> 
            // TODO: When changed immutability of OAuth2AuthorizedClient , persist OAuthorizedClient instead of access token.
            sessionService.addSessionRecord(principal.getName(), "accessToken", authorizedClient.getAccessToken().getTokenValue());
        );
    

    @Override
    public Mono<Void> removeAuthorizedClient(String clientRegistrationId, String principalName) 
        log.info("removeAuthorizedClient for user ", principalName);
        Assert.hasText(clientRegistrationId, "clientRegistrationId cannot be empty");
        Assert.hasText(principalName, "principalName cannot be empty");
        return null;
    

    private static ClientRegistration clientRegistration() 
        return ClientRegistration.withRegistrationId("login-client")
                .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
                .clientId("dummy").registrationId("dummy")
                .redirectUriTemplate("dummy")
                .authorizationUri("dummy").tokenUri("dummy")
                .build();
    

    private static OAuth2AccessToken accessToken(String value) 
        return new OAuth2AccessToken(OAuth2AccessToken.TokenType.BEARER, value, null, null);
    

注意事项：

SessionService 是我的自定义类，用于将 redis 与 reactivehashoperations 实例进行交互。 最好的方法是存储 OAuth2AuthorizedClient 而不是访问令牌。但是，现在太难了(https://github.com/spring-projects/spring-security/issues/8905)

【参考方案2】：

TokenRelayGatewayFilterFactory 使用内存数据存储来存储包含 (JWT) 访问令牌的 OAuth2AuthorizedClient。此数据存储不在多个网关之间共享。

通过Redis与Spring Session共享OAuth2AuthorizedClient信息，提供如下配置：

@Bean
public OAuth2AuthorizedClientRepository authorizedClientRepository() 
    return new HttpSessionOAuth2AuthorizedClientRepository();

对于响应式 WebSession：

@Bean
public ServerOAuth2AuthorizedClientRepository authorizedClientRepository() 
    return new WebSessionServerOAuth2AuthorizedClientRepository();

有关此配置的更多信息，请访问https://github.com/spring-projects/spring-security/issues/7889