Zuul + OAuth2.0 + JWT 实现单点登录

雨点打透心脏的1/2处 2023-05-30 03:47 17阅读 0赞

### 文章目录 ###

*  1. 应用权限概述
 *   *  1.1 自定义权限认证Filter
     *  1.2 OAuth2.0 + JWT
 *  2. Zuul + OAuth2.0 + JWT 实战
 *   *  2.1 zuul-server编写
     *  2.2 auth-server编写
     *  2.3 user服务编写
     *  2.4 测试

--------------------

本文内容出自《重新定义Spring Cloud实战》

--------------------

# 1. 应用权限概述 #

权限，是整个微服务体系乃至软件业永恒的话题，有资源的地方，就有权限约束。以往在构建单体应用的时候，比较流行的方式是使用Apache Shiro，大家的印象都是Apache Shiro比Spring Security上手容易，学习成本相对较小，但是，到了Spring Cloud这里，面对成千上万的服务，而且服务之间无状态，难免显得力不从心，所以，Spring Cloud没有选择它也是由原因的。在解决方案的选择上面，传统的譬如单点登录（SSO），后者分布式Session，要么致使权限服务器集中化导致流量臃肿，要么需要实现一套复杂的存储同步机制，都不是最好的解决方案。作为Spring Cloud微服务体系流量前门的Zuul，除去与它特性毫无相关的实现方式，比较好的有：

## 1.1 自定义权限认证Filter ##

由于Zuul对请求转发全程的可控性，我们可以在RequestContext的基础上做任何事情，如只需要在zuul请求转发的基础上设置一个执行顺序靠前的Filter，就可专门用于对请求特定内容做权限认证。如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70]  
这种方式的优点是实现灵活度高，可整合已有权限系统，对原始系统微服务化特别友好，缺点是需要开发一套新的逻辑，维护增加成本，而且也会使得调用链路变得紊乱。

## 1.2 OAuth2.0 + JWT ##

OAuth2.0是业界对于“授权 - 认证”比较成熟的面向资源的授权协议。怎么理解这句话呢？举个例子，除了可以使用本站用户名与密码登录系统外，还提供微信、QQ等登录方式。第三方登录功能对用户十分有亲和力，而OAuth2.0就是用于定义系统与用户之间的哪个“授权层”的。OAuth2.0的运行原理如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 1]  
在整个流程中，用户是资源拥有者，其关键还是在于客户端需要资源拥有者的授权，这个过程就相当于键入密码或者是其他第三方登录，出发了这个操作之后，客户端就可以向授权服务器申请Token，拿到后再携带Token到资源所在服务器拉取相应资源。

JWT（JSON Web Token）是一种使用JSON格式来规约Token后者Session的协议。由于传统认证方式免不了会发生一个凭证，这个凭证可以是Token后者Session，保存于服务端或者其他持久化工具中，这样一来，凭证的存取就变得十分麻烦，JWT的出现打破了这一瓶颈，实现了“客户端Session”的愿景。JWT通常由三部分组成：

*  Header头部：指定JWT使用的签名算法。
 *  Payload载荷：包含一些自定义与非自定义的认证信息。
 *  Signature签名：将头部与载荷使用“.”连接之后，使用头部的签名算法生成签名信息并拼装到末尾。

OAuth2.0+JWT的意义就在于，使用OAuth2.0协议的思想拉取认证生成Token，使用JWT瞬时保存这个Token，在客户端与资源端进行对称或非对称加密，使得这个规约具有定时、定量的授权认证功能，从而免去Token存储所带来的的安全或系统扩展问题。

# 2. Zuul + OAuth2.0 + JWT 实战 #

我们知道，在服务注册到注册中心之后，是由Zuul来引导各个请求到内部敏感服务的，因此，在Zuul网关层实现与下游服务之间的鉴权至关重要。

## 2.1 zuul-server编写 ##

zuul-server中需要做的就是当请求接口时，判断是否登录鉴权，如果未登录，则跳转到auth-server的登录界面（这里使用的是 Spring Security OAuth的默认登录界面，也可以重写相关代码定制页面），登陆成功后auth-server颁发jwt token，zuul-server在访问下游服务时将jwt token放入header中即可。

首先引入OAuth2.0和Security的依赖到pom中：

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-oauth2</artifactId>
    </dependency>

编写核心配置文件bootstrap.yml，提供对引入框架的支持：

spring:
      application:
        name: zuul
    
    server:
      port: 5555
    
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
      instance:
        prefer-ip-address: true
    
    zuul:
      routes:
        user:
          path: /user/** serviceId: user bank1: path: /bank1/** serviceId: bank1 bank2: path: /bank2/** serviceId: bank2 security: basic: enabled: false oauth2: client: access-token-uri: http://localhost:7777/uaa/oauth/token #令牌端点 user-authorization-uri: http://localhost:7777/uaa/oauth/authorize #授权端点 client-id: zuul #OAuth2客户端ID client-secret: secret #OAuth2客户端密钥 resource: jwt: key-value: springcloud123 #使用对称加密方式，默认算法为HS256

这里我们主要看security跟下面的配置，包括验证授权端点，jwt token的颁发地址，声明jwt头部签名算法为对称加密方式，默认加密算法为HS256，密钥为springcloud123，当然如果安全性要求更高，应该使用非对称加密方式，生成公钥与私钥放置于服务中。

编写启动类ZuulApplication.java

package com.herobin.scd;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    
    /** * @author binzhang * @date 2019-11-06 */
    @SpringBootApplication
    @EnableDiscoveryClient
    @EnableZuulProxy
    @EnableOAuth2Sso
    public class ZuulApplication extends WebSecurityConfigurerAdapter { 
        public static void main(String[] args) { 
            SpringApplication.run(ZuulApplication.class, args);
        }
    
    
        @Override
        protected void configure(HttpSecurity http) throws Exception { 
            http
            .authorizeRequests()
            .antMatchers("/login", "/user/**")
            .permitAll()
            .anyRequest()
            .authenticated()
            .and()
            .csrf()
            .disable();
        }
    }

重写WebSecurityConfigurerAdapter适配器的configure(HttpSecurity http)方法，声明需要鉴权的url信息。

## 2.2 auth-server编写 ##

整个实例的另一个核心就是auth-server，它作为认证鉴权中心，会颁发jwt token凭证。  
pom中引入OAuth2的依赖：

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-oauth2</artifactId>
    </dependency>

编写核心配置文件bootstrap.yml：

spring:
      application:
        name: auth
    server:
      port: 7777
      servlet:
        context-path: /uaa # web基路径
    eureka:
      client:
        service-url: 
          defaultZone: http://localhost:8761/eureka/
      instance:
        prefer-ip-address: true

编写认证授权服务适配器类OAuthConfiguration.java：

package com.herobin.scd;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.authentication.AuthenticationManager;
    import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
    import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
    import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
    import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
    import org.springframework.security.oauth2.provider.token.TokenStore;
    import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
    import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
    
    @Configuration
    @EnableAuthorizationServer
    public class OAuthConfiguration extends AuthorizationServerConfigurerAdapter { 
    
        @Autowired
        private AuthenticationManager authenticationManager;
    
        @Override
        public void configure(ClientDetailsServiceConfigurer clients) throws Exception { 
            clients
                    .inMemory()
                    .withClient("zuul")
                    .secret("secret")
                    .scopes("WRIGTH", "read").autoApprove(true)
                    .authorities("WRIGTH_READ", "WRIGTH_WRITE")
                    .authorizedGrantTypes("implicit", "refresh_token", "password", "authorization_code");
        }
    
        @Override
        public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception { 
            endpoints
                    .tokenStore(jwtTokenStore())
                    .tokenEnhancer(jwtTokenConverter())
                    .authenticationManager(authenticationManager);
        }
    
        @Bean
        public TokenStore jwtTokenStore() { 
            return new JwtTokenStore(jwtTokenConverter());
        }
    
        @Bean
        protected JwtAccessTokenConverter jwtTokenConverter() { 
            JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
            converter.setSigningKey("springcloud123");
            return converter;
        }
    }

这个类主要用于指定客户端ID、密钥，以及权限定义与作用域声明，指定TokenStore为JWT，不同于以往将TokenStore指定为Redis或是其他持久化工具，主要的不同就是在这里。

编写启动配置类AuthServerApplication.java:

package com.herobin.scd;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.context.annotation.Bean;
    import org.springframework.security.authentication.AuthenticationManager;
    import org.springframework.security.config.BeanIds;
    import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    import org.springframework.security.crypto.password.NoOpPasswordEncoder;
    
    @SpringBootApplication
    @EnableDiscoveryClient
    public class AuthServerApplication extends WebSecurityConfigurerAdapter { 
    
    	public static void main(String[] args) { 
    		SpringApplication.run(AuthServerApplication.class, args);
    	}
    	
        @Bean(name = BeanIds.AUTHENTICATION_MANAGER)
        @Override
        public AuthenticationManager authenticationManagerBean() throws Exception { 
            return super.authenticationManagerBean();
        }
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception { 
            auth
            .inMemoryAuthentication()
            .withUser("guest").password("guest").authorities("WRIGTH_READ")
            .and()
            .withUser("admin").password("admin").authorities("WRIGTH_READ", "WRIGTH_WRITE");
        }
        
        @Bean
        public static NoOpPasswordEncoder passwordEncoder() { 
          return (NoOpPasswordEncoder) NoOpPasswordEncoder.getInstance();
        }
    }

声明用户admin具有读写权限，用户guest具有读权限，authernticationManagerBean()方法用于手动注入AuthenticationManager；passwordEncoder()用于声明用户名和密码的加密方式。

## 2.3 user服务编写 ##

首先引入auth的依赖：

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-oauth2</artifactId>
    </dependency>

user作为zuul的下游服务，需要的功能很简单，能够被注册发现，以及能够按照规则解析jwt token即可。

user服务中写一个新的启动类 ClientAApplication：

package com.herobin.scd.authtest;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.context.annotation.Bean;
    import org.springframework.http.HttpMethod;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
    import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
    import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
    import org.springframework.security.oauth2.provider.token.TokenStore;
    import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
    import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Enumeration;
    
    @SpringBootApplication
    @EnableDiscoveryClient
    @EnableResourceServer
    @RestController
    public class ClientAApplication extends ResourceServerConfigurerAdapter { 
    	
        public static void main(String[] args) { 
            SpringApplication.run(ClientAApplication.class, args);
        }
        
    	@RequestMapping("/test")
    	public String test(HttpServletRequest request) { 
    		System.out.println("----------------header----------------");
    		Enumeration headerNames = request.getHeaderNames();
    		while (headerNames.hasMoreElements()) { 
    			String key = (String) headerNames.nextElement();
    			System.out.println(key + ": " + request.getHeader(key));
    		}
    		System.out.println("----------------header----------------");
    		return "hellooooooooooooooo!";
    	}
    
    	@Override
    	public void configure(HttpSecurity http) throws Exception { 
    		http
    		.csrf().disable()
    		.authorizeRequests()
    		.antMatchers("/**").authenticated()
    		.antMatchers(HttpMethod.GET, "/test")
    		.hasAuthority("WRIGTH_READ");
    	}
    
    	@Override
    	public void configure(ResourceServerSecurityConfigurer resources) throws Exception { 
    		resources
    		.resourceId("WRIGTH")
    		.tokenStore(jwtTokenStore());
    	}
    
    	@Bean
    	protected JwtAccessTokenConverter jwtTokenConverter() { 
    		JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
    		converter.setSigningKey("springcloud123");
    		return converter;
    	}
    
    	@Bean
    	public TokenStore jwtTokenStore() { 
    		return new JwtTokenStore(jwtTokenConverter());
    	}
    }

可以看出它的配置和auth的配置其实相差无几：如分析jwt token配置，声明接口权限可见范围等。这里写了一个/test接口用于返回内容与打印header到控制台。

## 2.4 测试 ##

整个实例的流程图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 2]  
依次启动服务 eureka、zuul、user、auth。注意这里user启动用ClientAApplication启动类。

访问 [http://localhost:5555/user/test][http_localhost_5555_user_test] ，自动跳转到了如下图页面。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 3]  
使用默认的admin，admin登录后再次访问 [http://localhost:5555/user/test][http_localhost_5555_user_test] 。结果如下：  
![在这里插入图片描述][20191107194719753.png]

本项目github地址：[https://github.com/zhangbin1995/SpringCloudDemo.git][https_github.com_zhangbin1995_SpringCloudDemo.git]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191107102657409.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191107103523461.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191107131111627.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1,size_16,color_FFFFFF,t_70
[http_localhost_5555_user_test]: http://localhost:5555/user/test
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191107131950561.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1,size_16,color_FFFFFF,t_70
[20191107194719753.png]: https://img-blog.csdnimg.cn/20191107194719753.png
[https_github.com_zhangbin1995_SpringCloudDemo.git]: https://github.com/zhangbin1995/SpringCloudDemo.githttps://github.com/zhangbin1995/SpringCloudDemo.git