[Spring Cloud로 구현하는 마이크로서비스] Section 4: 로그인 처리와 JWT 적용

apigateway 구성

application.yml에 마이크로서비스 정보 추가

	- id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/user-service/login
            - Method=POST
          filters:
            - RemoveRequestHeader=Cookie # 쿠키 삭제 후 실행
            - RewritePath=/user-service/(?<segment>.*), /$\{segment}
        - id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/user-service/users
            - Method=POST
          filters:
            - RemoveRequestHeader=Cookie # 쿠키 삭제 후 실행
            - RewritePath=/user-service/(?<segment>.*), /$\{segment}
        - id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/user-service/**
            - Method=GET
          filters:
            - RemoveRequestHeader=Cookie # 쿠키 삭제 후 실행
            - RewritePath=/user-service/(?<segment>.*), /$\{segment}
            - AuthorizationHeaderFilter

• user-service에 login과 users(회원가입) 기능은 쿠키 삭제 후 'AuthorizationHeaderFilter'를 적용하지 않음. (권한체크가 없다는 뜻)
• 나머지 GET메서드에 관해서는 'AuthorizationHeaderFilter'를 적용

AuthorizationHeaderFilter (권한 필터)

@Component
@Slf4j
public class AuthorizationHeaderFilter extends AbstractGatewayFilterFactory<AuthorizationHeaderFilter.Config> {
    Environment env;

    public AuthorizationHeaderFilter(Environment env) {
        super(Config.class);
        this.env = env;
    }

    // login -> token -> users(with token) -> header에 토큰 검사
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();

            if (!request.getHeaders().containsKey(HttpHeaders.AUTHORIZATION)) {
                return onError(exchange, "no authorization header", HttpStatus.UNAUTHORIZED);
            }

            String authorizationHeader = request.getHeaders().get(HttpHeaders.AUTHORIZATION).get(0);
            String jwt = authorizationHeader.replace("Bearer", "");
            if (!isJwtValid(jwt)) {
                return onError(exchange, "JWT token is not valid", HttpStatus.UNAUTHORIZED);
            }

            return chain.filter(exchange);
        };
    }

    private Mono<Void> onError(ServerWebExchange exchange, String err, HttpStatus httpStatus) {
        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(httpStatus);
        log.error(err);
        return response.setComplete();
    }

    private boolean isJwtValid(String jwt) {
        boolean returnValue = true;
        String subject = null;

        try {
            subject = Jwts.parser().setSigningKey(env.getProperty("token.secret"))
                    .parseClaimsJws(jwt).getBody()
                    .getSubject();
        } catch (Exception exception) {
            returnValue = false;
        }

        if (subject == null || subject.isEmpty()) {
            returnValue = false;
        }

        return returnValue;
    }

    public static class Config {

    }
}

 

• AbstractGatewayFilterFactory를 상속받아서 구현
• apply(Config config)를 오버라이드하여 적용할 필터기능 작성
  • request의 헤더의 AUTHORIZATION정보를 확인하여 .yml파일에 저장된 'token.secret'정보를 이용해 jwt정보를 파싱해본다.
  • 유효한 정보라면 다음 필터를 진행하고 아니라면 Error를 발생시킨다.

User-Service 마이크로서비스

회원가입 API (POST user-service/users)

• Controller

@PostMapping("/users")
public ResponseEntity<ResponseUser> createUser(@RequestBody RequestUser user) {
    ModelMapper mapper = new ModelMapper();
    mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
    UserDto userDto = mapper.map(user, UserDto.class);
    userService.createUser(userDto);

    ResponseUser responseUser = mapper.map(userDto, ResponseUser.class);

    return ResponseEntity.status(HttpStatus.CREATED).body(responseUser);
}

Client로 부터 받은 RequestUser정보를 UserDto로 변환후 서비스를 실행하고 실행 후 받은 dto정보를 ResponseUser정보로 변환하여 201상태메시지와 함께 반환한다.

 

• Service

@Override
public UserDto createUser(UserDto userDto) {
    userDto.setUserId(UUID.randomUUID().toString());

    ModelMapper mapper = new ModelMapper();
    mapper.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
    UserEntity userEntity = mapper.map(userDto, UserEntity.class);
    userEntity.setEncryptedPwd(passwordEncoder.encode(userDto.getPwd()));

    userRepository.save(userEntity);

    UserDto retrunUserDto = mapper.map(userEntity, UserDto.class);
    return retrunUserDto;
}

이 서비스에서 중요한 것은 클라이언트로부터 받아온 패스워드정보를 인코딩하여 db에 저장하는 부분이다.

 

회원정보 조회 API

@GetMapping("/users")
public ResponseEntity<List<ResponseUser>> getUser() {
    Iterable<UserEntity> userList = userService.getUserByAll();

    List<ResponseUser> result = new ArrayList<>();
    userList.forEach(v -> {
        result.add(new ModelMapper().map(v, ResponseUser.class));
    });

    return ResponseEntity.status(HttpStatus.OK).body(result);
}

@GetMapping("/users/{userId}")
public ResponseEntity<ResponseUser> getUser(@PathVariable("userId") String userId) {
    UserDto userDto = userService.getUserByUserId(userId);

    ResponseUser result = new ModelMapper().map(userDto, ResponseUser.class);
    return ResponseEntity.status(HttpStatus.OK).body(result);
}

회원정보를 아무나 조회하면 안된다. 따라서, 권한이 있는지 확인하는 과정이 필요하다. 여기서는 이 과정을 필터를 통해 구현하였다.

Security (권한 조회)

@Slf4j
public class AuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    private UserService userService;
    private Environment env;

    public AuthenticationFilter(AuthenticationManager authenticationManager,
                                UserService userService,
                                Environment env) {
        super.setAuthenticationManager(authenticationManager);
        this.userService = userService;
        this.env = env;
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request,
                                                HttpServletResponse response) throws AuthenticationException {
        try {
            RequestLogin creds = new ObjectMapper().readValue(request.getInputStream(), RequestLogin.class);

            return getAuthenticationManager().authenticate(
                    new UsernamePasswordAuthenticationToken(
                            creds.getEmail(),
                            creds.getPassword(),
                            new ArrayList<>())
                    );
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request,
                                            HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        // 서비스에서 반환한 User객체
        String userName = ((User)authResult.getPrincipal()).getUsername();
        UserDto userDetails = userService.getUserDetailsByEmail(userName);

        String token = Jwts.builder()
                .setSubject(userDetails.getUserId())
                .setExpiration(new Date(System.currentTimeMillis() +
                        Long.parseLong(env.getProperty("token.expiration_time"))))
                .signWith(SignatureAlgorithm.HS512, env.getProperty("token.secret"))
                .compact();

        response.addHeader("token", token);
        response.addHeader("userId", userDetails.getUserId());

    }
}

'UsernamePasswordAuthenticationFilter'를 상속하여 구현하도록 한다. 이는 '로그인 시 실행되는 필터' (/login) 이다.

 

먼저 요청시 권한체크로 attemptAuthentication(~)를 오버라이드했다.

body에 실려온 정보를 RequestLogin정보로 변환하여 '이메일', '패스워드' 정보를 이용한 권한정보를 설정하여 반환한다.

 

userServiceImpl에서 UserDetailService의 loadByUserName을 오버라이드하여 User객체를 반환하도록 한다. 이를 통해 서비스 성공 시 user정보를 활용하여 jwt token을 만들 수 있다. (successfulAuthentication메서드)

 

만든 jwt정보를 header의 token에 저장하여 반환하도록 한다. 클라이언트에서는 이 정보를 이용하여 회원정보조회 요청에 사용한다.

 

WebSecurity 설정 정보

@Configuration
@EnableWebSecurity
public class WebSecurity extends WebSecurityConfigurerAdapter {

    private UserService userService;
    private BCryptPasswordEncoder bCryptPasswordEncoder;
    private Environment env;

    public WebSecurity(UserService userService, BCryptPasswordEncoder bCryptPasswordEncoder, Environment env) {
        this.userService = userService;
        this.bCryptPasswordEncoder = bCryptPasswordEncoder;
        this.env = env;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable();
//        http.authorizeRequests().antMatchers("/users/**").permitAll();
        http.authorizeRequests().antMatchers("/**").permitAll()
                .and()
                .addFilter(getAuthenticationFilter());

        http.headers().frameOptions().disable();
    }

    private AuthenticationFilter getAuthenticationFilter() throws Exception {
        AuthenticationFilter authenticationFilter = new AuthenticationFilter(authenticationManager(), userService, env);
        return authenticationFilter;
    }

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

상속받은 필터를 등록하고 로그인 시 활용한다.

 

api-gateway -> 권한조회가 필요하다면 헤더에 jwt정보가 valid한지 검사 후 마이크로서비스로 요청 보냄

user-service -> login시에는 username(or email)로 jwt정보를 생성하여 헤더에 추가하여 반환한다.