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

问题描述 投票：0回答：2

我已将 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 会话，以共享网关之间的会话信息。

spring-security-oauth2 spring-oauth2 spring-cloud-gateway spring-cloud-security
2个回答
2
投票

TL；博士

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

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

长答案

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

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

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

当您使用会话 ID 请求 API Gateway 访问微服务时，网关中的 TokenRelayGatewayFilterFactory 会解析访问令牌（jwt），并将此访问令牌设置在 Authorization header 中，并将请求转发到微服务。

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

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

解决方案-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);
    }

}

备注：

1
投票

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
    



      

      
    

  

  

    
最新问题


  





  

    © www.soinside.com 2019 - 2024. All rights reserved.