[Redis] Redis을 통해 JWT 로그인, 로그아웃 구현하기

프로젝트에서 JWT을 사용했는데 로그아웃 구현을 위해 Redis를 사용해야했다.

JWT의 특성상 한 번 발급된 토큰은 만료되기 전까지 계속 유효하게 남아있기때문에 로그아웃을 위해서는 서버는 해당 사용자의 토큰을 블랙리스트에 추가해야 한다. Redis는 이러한 블랙리스트를 쉽게 관리할 수 있는 메모리 기반의 데이터 구조를 제공하며, 높은 성능을 제공한다.

Redis를 사용하여 간단하게 로그인, 로그아웃을 구현해보자.

 

---

 

의존성 추가 & Redis 설정

 

build.gradle에 redis dependency를 추가해주자.

implementation 'org.springframework.boot:spring-boot-starter-data-redis'

 

 

RedisRepositoryConfig.java

Redis 설정하기 위한 클래스이다. 

@Configuration
@EnableRedisRepositories
public class RedisRepositoryConfig {

    @Value("${spring.redis.host}")
    private String redisHost;

    @Value("${spring.redis.port}")
    private int redisPort;

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory(redisHost, redisPort);
    }

    @Bean
    public RedisTemplate<?, ?> redisTemplate() {
        RedisTemplate<?, ?> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

 

RedisConnectionFactory

RedisConnection이 생성되어 Redis 서버와의 통신을 할수 있게 한다.

 

RedisTemplate

RedisTemplate 객체를 이용하여 Redis를 사용할 수 있게한다. RedisConnection의 경우 binary value를 주고 받는데 RedisTemplate의 경우 높은 수준의 추상화와 직렬화를 제공한다. RedisTemplate은 데이터를 직렬화 / 역직렬화 하여 저장 / 조회를 하므로 적절한 직렬화 방식을 설정해주어야 한다. 

setKeySerializer, setValueSerializer 설정해주는 이유는 RedisTemplate를 사용할 때 Spring - Redis 간 데이터 직렬화, 역직렬화 시 사용하는 방식이 Jdk 직렬화 방식이기 때문이다. 동작에는 문제가 없지만 redis-cli을 통해 직접 데이터를 보려고 할 때 알아볼 수 없는 형태로 출력되기 때문에 적용한 설정이다.

 

StringRedisSerializer

Redis에 문자열을 저장하고 검색하기 위해 사용된다. Java의 문자열을 Redis에서 사용할 수 있는 형식으로 직렬화하고, Redis에서 읽은 데이터를 다시 Java의 문자열로 역직렬화한다.

 

 

2. AuthenticationConfig.java

Security + JWT 토큰 검증을 한다.

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class AuthenticationConfig {

    private final UserServiceImpl userServiceImpl;
    @Value("${jwt.token.secret}")
    private String secretKey;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity httpSecurity) throws Exception {
        return httpSecurity
                .httpBasic().disable()
                .csrf().disable()
                .cors().and()
                .authorizeRequests()
                .antMatchers("/user/signup", "/user/login", "/search/**", "/item/**","/sendmail", "/newpassword")
                .permitAll()
                .antMatchers(HttpMethod.POST, "/**").authenticated()
                .and()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .addFilterBefore(new JwtFilter(userServiceImpl, secretKey), UsernamePasswordAuthenticationFilter.class)
                .build();
    }
 }

 

 

SecurityFilterChain에 JWT 토큰을 검증하는 클래스를 넣어준다.

 

 

3.JwtFilter.java

토큰의 유효성을 검증한다.

@RequiredArgsConstructor
@Slf4j
public class JwtFilter extends OncePerRequestFilter {

    private final UserServiceImpl userServiceImpl;
    private final String secretKey;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

        final String authorization = request.getHeader(HttpHeaders.AUTHORIZATION);
        log.info("authorization : {}", authorization);

        if(authorization == null || !authorization.startsWith("Bearer")){
            log.error("authorization is null or not Bearer");
            filterChain.doFilter(request, response);
            return;
        }

        if (authorization.split(" ").length != 2) {
            log.error("Token is not valid");
            filterChain.doFilter(request, response);
            return;
        }

        // Token 꺼내기
        String token = authorization.split(" ")[1].trim();


        // 토큰 유효성 검사
        if (!userServiceImpl.isValid(token)) {
            log.error("Logged out user");
            filterChain.doFilter(request, response);
            return;
        }

        // UserName Token에서 꺼내기
        String userName = JwtUtil.getUserEmail(token, secretKey);
        log.info("userName : {}", userName);

        //권한 부여
        UsernamePasswordAuthenticationToken authenticationToken=
                new UsernamePasswordAuthenticationToken(userName, null, List.of(new SimpleGrantedAuthority("USER")));

        //Detail을 넣어줍니다.
        authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        filterChain.doFilter(request, response);
    }
}

 

HTTP 요청에서 "Authorization" 헤더의 값을 가져와서 토큰을 추출한다. 해당 토큰을 userServiceImpl.isValid() 메서드를 통해 검증한다.

 

 

UserServiceImpl.java

로그인, 로그아웃, 토큰 검증을 한다.

실습을 위해 반환값을 String 으로 설정하였다.

@Service
@RequiredArgsConstructor
@Slf4j
public class UserServiceImpl implements UserService {

    private final UserRepository userRepository;
    private final BCryptPasswordEncoder encoder;
    private final StringRedisTemplate redisTemplate;

    @Value("${jwt.token.secret}")
    private String secretKey;
    private Long expiredMs = 1000 * 60 * 60 * 24 * 7L; //일주일


    @Override
    public LoginResponseDTO login(String userEmail, String password) {
        //userEmail 없음
        EntityUser selectedUser = userRepository.findByUserEmail(userEmail)
                .orElseThrow(() -> new AppException(ErrorCode.USERMAIL_NOT_FOUND, userEmail + " 존재하지 않는 회원입니다."));

        //password 틀림
        if (!encoder.matches(password, selectedUser.getUserPassword())) { //순서 중요. inputpassword, DBpassword
            throw new AppException(ErrorCode.INVALID_PASSWORD, "비밀번호가 틀렸습니다.");
        }
        String token = JwtUtil.createToken(selectedUser.getUserEmail(), secretKey, expiredMs);
        // 레디스에 키 벨류 형식으로 회원 이메일, 토큰 저장
        redisTemplate.opsForValue().set("RT:" + userEmail, token);
        return new LoginResponseDTO(selectedUser.getUserName(), token);
    }

    @Override
    public Boolean isValid(String userToken) {
        try {
            ValueOperations<String, String> logoutValueOperations = redisTemplate.opsForValue();
            if(logoutValueOperations.get(userToken) != null){
                System.out.println("로그아웃된 토큰 입니다.");
                return false;
            }
            return !Jwts.parser().setSigningKey(secretKey).parseClaimsJws(userToken)
                    .getBody().getExpiration().before(new Date());
        } catch (ExpiredJwtException e) {
            e.getMessage();
            return false;
        }
    }

    @Override
    public String logout(HttpServletRequest request) {
        String token = request.getHeader(HttpHeaders.AUTHORIZATION).split(" ")[1].trim();
        String userEmail = JwtUtil.getUserEmail(token, secretKey);
        System.out.println(userEmail);
        if (redisTemplate.opsForValue().get("RT:" + userEmail)!= null) {
            redisTemplate.delete("RT:" + userEmail);}
        redisTemplate.opsForValue().set(token, "logout");
        return "LOGOUT_SUCCESS";
    }
 }

 

우선 redis 연산하기위해 StringRedisTemplate 의존성 주입을 해야한다.

 

StringRedisTemplate Redis는 Redis 데이터 저장소에 대한 문자열 기반 작업을 수행하는 데 사용된다.

 

회원이 로그인을 하면 토큰을 redis에 key, value 형식으로 이메일, 토큰을 저장한다.

 

StringRedisTemplate.opsForValue() 메서드는 문자열 값을 다루기 위한 연산자를 가져오는 메서드이다.

set을 통해서 사용자의 이메일과 토큰을 저장한다.

RT는 "Redis Token"의 축약어이며, 토큰 데이터를 구별하기 위해 사용했다. 이렇게 구별함으로써 Redis 데이터베이스 내에서 여러 종류의 데이터를 저장하고 관리할 때 특정 유형의 데이터를 식별하기 쉽게 할 수 있다.

 

토큰의 유효성을 검증하는 메서드이다.

 

로그아웃을 하면 토큰을 key로 저장하는데 get(토큰) 값이 있다면 로그아웃된 토큰이라고 정의해준다.

 

로그아웃 메서드이다.

우선 redis에 key로 저장한 이메일에 해당하는 value 값이 있다면 삭제해준다.

그리고 토큰값을 key로 저장한다.

 

 

잘 실행되는지 실습을 해보자.

포스트맨으로 접속후 로그인을 하면 토큰을 반환한다.

 

redis 컨테이너로 접속해서 key값으로 이메일이 잘 저장되었는지 확인해보자

docker ps

실행중인 컨테이너를 보여준다.

docker exec -it <container Id> redis-cli --raw

이 명령어를 통해서 redis 컨테이너로 접속한다.

// 모든 Key 조회
keys *

// key에 해당하는 value 조회
get <key>

명령어를 입력해보면 토큰이 잘 저장되었다!!

 

 

이제 로그아웃을 해보자

포스트맨에서 Authorization -> Bearer Token을 선택후 토큰을 입력한다.

 

 

로그아웃이 되었으면 redis로 가서 해당 토큰을 저장하였는지 확인해보자

redis 컨테이너에서 모든 keys 값들을 조회해보면 토큰이 잘 저장된걸 확인할수 있다.

 

다시 이 토큰으로 접속을 실행해보자.

 

로그를 보면 로그아웃 토큰이라고 알려준다.

끝!!

 

 

 

<주의>

프로젝트용으로 Redis를 사용하여 AWS을 통해 배포하면 과금이 엄청 나올수있다.

필자는 약 250만원 정도 과금이 나온 경험이 있다...^^;

만약 프로젝트를 위해 redis를 사용한다면 배포한후에는 가능한 빨리 서버를 중지시키고 꼭 모든 서비스를 삭제하자!!

 

 

 

참고하면 좋을 자료

https://freeblogger.tistory.com/10

redis-cli 명령어 정리

 

 

참고 

https://velog.io/@hkyo96/Spring-RedisTemplate-Serializer-설정

Spring RedisTemplate Serializer 설정