spring-boot - 如何使用 JDBC 实现水平扩展 spring-boot oauth2 服务器

Question

我有一个使用 JDBC 实现的 spring boot oauth2 服务器。使用@EnableAuthorizationServer 将其配置为授权服务器。

我想水平扩展该应用程序，但它似乎无法正常工作。

只有当我有一个服务器实例(pod)时我才能连接。

我使用来自另一个客户端服务的 autorisation_code_client 授权来获取 token 。因此，首先客户端服务将用户重定向到 oauth2 服务器表单，然后一旦用户通过身份验证，他应该被重定向到客户端服务，并带有附加到 url 的代码，最后客户端使用该代码请求 oauth2 服务器再次获取 token 。

如果我有多个 oauth2-server 实例，则根本不会重定向用户。在一个实例中效果很好。

当我实时检查两个实例的日志时，我可以看到身份验证在其中一个上有效。我没有任何特定错误，用户只是没有被重定向。

有没有办法将 oauth2-server 配置为无状态或其他方式来解决该问题？

这是我的配置，AuthorizationServerConfigurerAdapter 实现。

@Configuration
public class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter {


    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource oauthDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Autowired
    @Qualifier("authenticationManagerBean")
    private AuthenticationManager authenticationManager;

    @Bean
    public JdbcClientDetailsService clientDetailsSrv() {
        return new JdbcClientDetailsService(oauthDataSource());
    }

    @Bean
    public TokenStore tokenStore() {
        return new JdbcTokenStore(oauthDataSource());
    }

    @Bean
    public ApprovalStore approvalStore() {
        return new JdbcApprovalStore(oauthDataSource());
    }

    @Bean
    public AuthorizationCodeServices authorizationCodeServices() {
        return new JdbcAuthorizationCodeServices(oauthDataSource());
    }

    @Bean
    public TokenEnhancer tokenEnhancer() {

        return new CustomTokenEnhancer();
    }

    @Bean
    @Primary
    public AuthorizationServerTokenServices tokenServices() {


        DefaultTokenServices tokenServices = new DefaultTokenServices();

        tokenServices.setTokenStore(tokenStore());

        tokenServices.setTokenEnhancer(tokenEnhancer());

        return tokenServices;
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {

        clients.withClientDetails(clientDetailsSrv());
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer oauthServer)  {

        oauthServer
                .tokenKeyAccess("permitAll()")
                .checkTokenAccess("isAuthenticated()")
                .allowFormAuthenticationForClients();

    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints)  {
        endpoints
                .authenticationManager(authenticationManager)
                .approvalStore(approvalStore())
                //.approvalStoreDisabled()
                .authorizationCodeServices(authorizationCodeServices())
                .tokenStore(tokenStore())
                .tokenEnhancer(tokenEnhancer());
    }

}

主类

@SpringBootApplication
@EnableResourceServer
@EnableAuthorizationServer
@EnableConfigurationProperties
@EnableFeignClients("com.oauth2.proxies")
public class AuthorizationServerApplication {


    public static void main(String[] args) {

        SpringApplication.run(AuthorizationServerApplication.class, args);

    }

}

网络安全配置

@Configuration
@Order(1)
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {


    @Bean
    @Override
    public UserDetailsService userDetailsServiceBean() throws Exception {
        return new JdbcUserDetails();
    }

    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception { // @formatter:off

        http.requestMatchers()
                .antMatchers("/",
                        "/login",
                        "/login.do",
                        "/registration",
                        "/registration/confirm/**",
                        "/registration/resendToken",
                        "/password/forgot",
                        "/password/change",
                        "/password/change/**",
                        "/oauth/authorize**")
                .and()
                .authorizeRequests()//autorise les requetes
                .antMatchers(
                        "/",
                        "/login",
                        "/login.do",
                        "/registration",
                        "/registration/confirm/**",
                        "/registration/resendToken",
                        "/password/forgot",
                        "/password/change",
                        "/password/change/**")
                .permitAll()
                .and()
                .requiresChannel()
                .anyRequest()
                .requiresSecure()
                .and()
                .authorizeRequests()
                .anyRequest()
                .authenticated()
                .and()
                .formLogin()
                .loginPage("/login")
                .loginProcessingUrl("/login.do")
                .usernameParameter("username")
                .passwordParameter("password")
                .and()
                .userDetailsService(userDetailsServiceBean());


    } // @formatter:on


    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsServiceBean()).passwordEncoder(passwordEncoder());
    }


}

WebSecurityConfigurerAdapter 客户端

@EnableOAuth2Sso
@Configuration
public class UiSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {

        http.antMatcher("/**")
                .authorizeRequests()
                .antMatchers(
                        "/",
                        "/index.html",
                        "/login**",
                        "/logout**",
                        //resources
                        "/assets/**",
                        "/static/**",
                        "/*.ico",
                        "/*.js",
                        "/*.json").permitAll()
                .anyRequest()
                .authenticated()
                .and()
                .csrf().csrfTokenRepository(csrfTokenRepository())
                .and()
                .addFilterAfter(csrfHeaderFilter(), SessionManagementFilter.class);
    }

}

oauth2 配置属性

oauth2-server 是 kubernetes 上的服务名称(负载均衡器)，也是它出现两次的服务器路径。

security:
    oauth2:
        client:
            clientId: **********
            clientSecret: *******
            accessTokenUri: https://oauth2-server/oauth2-server/oauth/token
            userAuthorizationUri: https://oauth2.mydomain.com/oauth2-server/oauth/authorize
        resource:
            userInfoUri: https://oauth2-server/oauth2-server/me

这里有个重要的细节，userAuthorizationUri的值是k8s集群外部访问oauth2-server的地址。如果用户未连接并尝试访问客户端服务的/login 路径，客户端服务会将该地址发送回带有 302 http 代码的响应中。然后用户被重定向到 oauth2-server 的/login 路径。
https://oauth2.mydomain.com定位一个处理重定向到负载均衡器服务的 Nginx Ingress Controller 。

Answer 1

这是解决此问题的方法。这根本不是 Spring 问题，而是 Nginx Ingress Controller 的错误配置。

身份验证过程分几个阶段完成:

1 - 用户单击登录按钮，该按钮以客户端-服务器的/login 路径为目标

2 - 客户端-服务器，如果用户尚未通过身份验证，则向客户端发送响应浏览器使用 302 http 代码将用户重定向到 oauth2-server，值为重定向由security.oauth2.client.userAuthorizationUri 属性以及浏览器将使用的重定向 url，以允许客户端服务器在用户通过身份验证后获取 token 。该网址如下所示:

h*tps://oauth2.mydomain.com/oauth2-server/oauth/authorize?client_id=autorisation_code_client&redirect_uri=h*tps://www.mydomain.com/login&response_type=code&state=bSWtGx

3 - 用户被重定向到上一个 url

4 - oauth2-server 向浏览器发送一个 302 http 代码，其登录 url 为oauth2-server, h*tps://oauth2.mydomain.com/oauth2-server/login

5 - 用户提交他的凭据，如果正确，则创建 token 。

6 - 用户被重定向到与第二步相同的地址，并且 oauth-server向 redirect_uri 值添加信息

7 - 用户被重定向到客户端-服务器。响应的重定向部分如下所示:

location: h*tps://www.mydomain.com/login?code=gnpZ0r&state=bSWtGx

8 - 客户端-服务器联系 oauth2-server 并从代码和验证它的状态中获取 token 。 oauth2 的实例是否无关紧要服务器不同于用户用来验证自己的服务器。这里客户端-服务器使用 security.oauth2.client.accessTokenUri 的值来获取 token ，这是针对 oauth2 服务器的内部负载均衡服务地址pods，因此它不会通过任何 Ingress Controller 。

因此，在第 3 步到第 6 步中，用户必须通过负载平衡器服务前面的 Ingress Controller 与同一 oauth2-server 实例进行通信。

通过使用一些注释配置 Nginx Ingress Controller 是可能的:

"annotations": {
  ...
  "nginx.ingress.kubernetes.io/affinity": "cookie",
  "nginx.ingress.kubernetes.io/session-cookie-expires": "172800",
  "nginx.ingress.kubernetes.io/session-cookie-max-age": "172800",
  "nginx.ingress.kubernetes.io/session-cookie-name": "route"
}

这样，我们确保用户在身份验证过程中被重定向到 oauth2-server 的相同 pod/实例，只要他使用相同的 cookie 进行标识。

亲和 session 机制是扩展身份验证服务器和客户端服务器的好方法。一旦用户通过身份验证，他将始终使用相同的客户端实例并保留其 session 信息。

感谢 Christian Altamirano Ayala 的帮助。