4월 둘째 주 : Docker 가상화 + Refresh Token with Redis

도입 취지

- 그 동안의 프로젝트 경험을 통해 다양한 언어, 그 외 실행 환경 등에 대해 공부하며 각 프로젝트마다 필요 환경이 다르고 개발자의 로컬 머신 환경 또한 매우 다양하므로, 이 경우 도커를 활용한다면 환경 조성을 매우 효율적으로 진행할 수 있어 도입해보게 되었다.

-  JWT 토큰을 활용한 로그인 방식에 보안을 더 강화한 방식을 도입해보고자, 리프레시 토큰에 대해 배우고 도입하기로 결정했다.

장점

- 로컬에서 언어, 데이터베이스 등을 따로 설치하지 않아도 도커 명령을 통해 호스트 머신에서 프로젝트를 실행할 수 있다.

- 원격 리모트 머신에 도커화한 프로젝트를 배포해 효율적으로 개발을 진행할 수 있다.

- 액세스 토큰의 유효기간을 짧게 설정해 보안을 강화하면서도, 사용자의 로그인 주기를 길게 유지시킬 수 있다.

구현 목표

- JWT Refresh Token을 저장하는 Redis 구현 맟 프로젝트 이미지를 도커 허브에 푸시

- AWS EC2 인스턴스를 리모트 머신으로 활용해 프로젝트 배포

구현 전 예상되는 트러블 슈팅

- Node.js로 학습 및 실습했기 때문에 Java 및 스프링, 스프링 부트에 도커를 적용하는 것은 시행착오가 예상된다.

- 레디스로 리프레쉬 토큰을 구현할 때의 시행착오가 예상된다.

실행 환경

- Java 17

- Springboot 2.7.6

- Gradle

- Redis 2.7.6

1. Redis로 Refresh 토큰 구현

- 리프레시 토큰 구현에 레디스를 사용하는 이유 : 레디스는 데이터를 RAM에 저장하므로 영속성이 없다. 대신 데이터 엑세스 속도가 매우 빠르기 때문에 주로 캐싱할 때 사용하고, 리프레시 토큰의 경우 영속성이 필요없고, 빠른 엑세스 속도가 중요하므로 선택하게 되었다. 또한 레디스에서는 기본적으로 데이터의 유효 기간을 지정할 수 있어, 일정 기간 후 만료되어야 하는 토큰의 경우에 적합하다.

 

Refresh 토큰 원리

- 로그인 시 엑세스 토큰과 리프레시 토큰을 JWT 토큰으로 발급받고, 리프레시 토큰만 서버의 DB에 저장하고 클라이언트에게 액세스 토큰과 리프레시 토큰을 모두 발급한다.

- 클라이언트가 서비스를 이용할 때마다 요청에 액세스 & 리프레시 토큰을 담아 보내고, 액세스 토큰의 유효기간이 만료되었을 때 리프레시 토큰이 유효하다면 서버에서 액세스 토큰을 재발급한다.

 

아직 도메인별로 나눈 코드가 아니어서, 각 비즈니스 로직이 서로를 직접 호출하고 있습니다. 변경 후 다시 업데이트 예정입니다.

 

1) 로그인

- JWT 토큰 발급 : 사용자가 로그인 할때, access token은 발급후 사용자에게 응답 헤더에 추가된다.

@Component
@RequiredArgsConstructor
public class JwtUtil {

  private static final String BEARER_PREFIX = "Bearer ";
  
  private static final long ACCESS_TOKEN_TIME = (long) 60 * 60;
  
  @Value("${jwt.secret.key}")
  private String secretKey;
  
  private Key key;
  
  private final SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
  
  @PostConstruct
  public void init() {
    byte[] bytes = Base64.getDecoder().decode(secretKey);
    key = Keys.hmacShaKeyFor(bytes);
  }

  public String createAccessToken(String username) {
    Date date = new Date();

    return BEARER_PREFIX +
        Jwts.builder()
            .setSubject(username)
            .setExpiration(new Date(date.getTime() + ACCESS_TOKEN_TIME))
            .setIssuedAt(date)
            .signWith(key, signatureAlgorithm)
            .compact();
  }
}

- refresh token은 임의의 토큰 형식으로 발급 후 서버에 저장된다. 또한 HttpOnly 쿠키에 담겨 응답 헤더에 추가된다.

@Service
@RequiredArgsConstructor
public class RefreshTokenService {

  private final UserRepository userRepository;

  private final UserService userService;

  private final RefreshTokenRepository refreshTokenRepository;

  public String createRefreshToken(String username) {
    RefreshToken refreshToken = new RefreshToken(UUID.randomUUID().toString(),
        findByUsername(username).getUsername());
    saveRefreshToken(refreshToken);
    return refreshToken.toString();
  }

  public Cookie createRefreshCookie(String stringRefreshToken) {
    Cookie cookie = new Cookie("refreshToken", stringRefreshToken);
    cookie.setMaxAge(60 * 60 * 336);
    cookie.setHttpOnly(true);
    cookie.setSecure(true);
    return cookie;
  }

  private void saveRefreshToken(RefreshToken refreshToken) {
    refreshTokenRepository.save(refreshToken);
  }

  private User findByUsername(String username) {
    return userRepository.findByUsername(username)
        .orElseThrow(() -> new IllegalArgumentException("해당 유저는 존재하지 않습니다"));
  }
}

- 발급된 리프레시 토큰은 서버에 저장된다.

public interface RefreshTokenRepository extends CrudRepository<RefreshToken, String> {

}

- login 컨트롤러

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/user")
public class UserController {

  private final UserService userService;

  @PostMapping("/login")
  public ResponseEntity<MessageResponseDto> login(@RequestBody LoginRequestDto loginRequestDto,
      HttpServletResponse response) {
    userService.login(loginRequestDto, response);
    return ResponseEntity.status(HttpStatus.OK).build();
  }
}

- UserService의 Login 메서드

@Service
@RequiredArgsConstructor
public class UserService {

  private final UserRepository userRepository;

  private final JwtUtil jwtUtil;

  private final RefreshTokenService refreshTokenService;

  @Transactional
  public void login(LoginRequestDto loginRequestDto, HttpServletResponse response) {
    User user = findByUsername(loginRequestDto.getUsername());

    // 비밀번호 확인
    if (!user.getPassword().equals(loginRequestDto.getPassword())) {
      throw new IllegalArgumentException("비밀번호가 일치하지 않습니다.");
    }

    // token 발급
    response.addHeader(JwtUtil.AUTHORIZATION_HEADER, jwtUtil.createAccessToken(user.getUsername()));

    response.addCookie(
        refreshTokenService.createRefreshCookie(
            refreshTokenService.createRefreshToken(user.getUsername())));
  }

  private User findByUsername(String username) {
    return userRepository.findByUsername(username)
        .orElseThrow(() -> new IllegalArgumentException("해당 유저는 존재하지 않습니다"));
  }
}

- Redis는 키 : 값 형태로 데이터를 저장하기 때문에 아이디도 문자열이다.

@RedisHash(value = "refreshToken", timeToLive = 60 * 60 * 336L)
@Getter
public class RefreshToken {

  @Id
  private String refreshToken;

  private String username;

  public RefreshToken(String refreshToken, String username) {
    this.refreshToken = refreshToken;
    this.username = username;
  }

2) JWT 토큰 검증 및 재발급

- 요청 시 마다 Spring Security 인증/인가 진행

@Slf4j // 로깅에 대해 추상 레이어를 제공하는 인터페이스 라이브러리
@RequiredArgsConstructor
public class JwtAuthFilter extends OncePerRequestFilter {

  private final JwtUtil jwtUtil;

 @Override
  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
      FilterChain filterChain) throws ServletException, IOException {
    String resolveAccessToken = jwtUtil.resolveAccessToken(request);
    String refreshToken = separateRefreshToken(resolveRefreshTokenFromCookies(request))[0];
    String username = separateRefreshToken(resolveRefreshTokenFromCookies(request))[1];

    if (resolveAccessToken != null) {
      if (!jwtUtil.validateAccessToken(resolveAccessToken) && jwtUtil.checkExpirationToken(
          resolveAccessToken, refreshToken, username, response)) {
        jwtExceptionHandler(response, "Token Error", HttpStatus.UNAUTHORIZED.value());
      }
      setAuthentication(jwtUtil.getUserInfoFromToken(resolveAccessToken).getSubject());
    }
    filterChain.doFilter(request, response);
  }

  private void setAuthentication(String username) { // 인증 객체 생성 및 등록 : 코드 간소화 및 책임 분리 목적
    SecurityContext context = SecurityContextHolder.createEmptyContext(); // ContextHolder에 인증 객체 저장
    Authentication authentication = jwtUtil.createAuthentication(username);
    context.setAuthentication(authentication);

    SecurityContextHolder.setContext(context);
  }

  // 쿠키에서 리프레시 토큰 추출
  public String resolveRefreshTokenFromCookies(HttpServletRequest request) {
    Cookie[] cookies = request.getCookies();
    String resolveRefreshToken = null;
    for (Cookie cookie : cookies) {
      if (cookie.getName().equals("refreshToken")) {
        resolveRefreshToken = cookie.getValue();
      }
    }
    return resolveRefreshToken;
  }

  // 토큰과 username 분리
  public String[] separateRefreshToken(String cookieValue) {
    return cookieValue.split(":");
  }

  // 토큰 오류가 발생한 경우, Exception 결과값을 사용자에게 반환한다
  private void jwtExceptionHandler(HttpServletResponse response, String msg, int statusCode) {
    response.setStatus(statusCode);
    response.setContentType("application/json");
    try {
      // ObjectMapper를 통해 변환한다
      String json = new ObjectMapper().writeValueAsString(new MessageResponseDto(msg, statusCode));
      response.getWriter().write(json);
    } catch (Exception e) {
      log.error(e.getMessage());
    }
  }
}

0) 엑세스 토큰이 만료되었다면

1) 리프레시 토큰을 확인, 만료되어 있지 않다면 액세스 토큰을 재발급하고 이미 만료되었다면 로그아웃한다.

2) 로그아웃 시 액세스 토큰과 리프레시 토큰은 삭제된다.

- refreshService

@Service
@RequiredArgsConstructor
public class RefreshTokenService {

  private final RefreshTokenRepository refreshTokenRepository;

  private static final String BEARER_PREFIX = "Bearer ";

  private static final long ACCESS_TOKEN_TIME = (long) 60 * 60;

  @Value("${jwt.secret.key}")
  private String secretKey;

  private Key key;

  private final SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

  @PostConstruct
  private void init() {
    byte[] bytes = Base64.getDecoder().decode(secretKey);
    key = Keys.hmacShaKeyFor(bytes);
  }

  // 리프레시 토큰 검증 및 로그아웃 연결
  public void checkRefreshToken(String StringRefreshToken, String username,
      HttpServletResponse response) {
    if (refreshTokenRepository.existsById(StringRefreshToken)) {
      regenerateRefreshToken(username, response);

    } else {
      RefreshToken refreshToken = refreshTokenRepository.findById(StringRefreshToken).orElseThrow(
          () -> new IllegalArgumentException("존재하지 않는 토큰입니다.")
      );
      deleteRefreshToken(refreshToken);
    }
  }

  public void deleteRefreshToken(RefreshToken refreshToken) {
    refreshTokenRepository.delete(refreshToken);
  }

  private void regenerateRefreshToken(String username, HttpServletResponse response) {
    Date date = new Date();

    String newAccessToken = BEARER_PREFIX +
        Jwts.builder()
            .setSubject(username)
            .setExpiration(new Date(date.getTime() + ACCESS_TOKEN_TIME))
            .setIssuedAt(date)
            .signWith(key, signatureAlgorithm)
            .compact();

    response.addHeader(JwtUtil.AUTHORIZATION_HEADER, newAccessToken);
  }

  public RefreshToken findById(String refreshToken) {
    return refreshTokenRepository.findById(refreshToken).orElseThrow(
        () -> new IllegalArgumentException("존재하지 않는 토큰입니다.")
    );
  }
}

 

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/user")
public class UserController {

  private final UserService userService;

  @PostMapping("/logout")
  public ResponseEntity<MessageResponseDto> logout(HttpServletRequest request,
      HttpServletResponse response) {
    userService.logout(request, response);
    return ResponseEntity.status(HttpStatus.OK).build();
  }

}

- userService

@Service
@RequiredArgsConstructor
public class UserService {

  private final UserRepository userRepository;

  private final JwtAuthFilter jwtAuthFilter;

  private final RefreshTokenService refreshTokenService;

  public void logout(HttpServletRequest request, HttpServletResponse response) {
    response.setHeader(JwtUtil.AUTHORIZATION_HEADER, null);
    refreshTokenService.deleteRefreshToken(refreshTokenService.findById(
        jwtAuthFilter.separateRefreshToken(
            jwtAuthFilter.resolveRefreshTokenFromCookies(request))[0]));
  }

  private User findByUsername(String username) {
    return userRepository.findByUsername(username)
        .orElseThrow(() -> new IllegalArgumentException("해당 유저는 존재하지 않습니다"));
  }
}

2. 프로젝트 배포를 위한 Dockerfile 작성

- 도커파일을 작성해 도커가 명령을 수행할 수 있도록 한다.

1) 프로젝트 Dockerize

- Gradle의 bootjar를 이용해 스냅샷을 만든다

- Dockfile 생성

FROM openjdk:17-alpine

VOLUME /tmp

ARG JAR_FILE

COPY ${JAR_FILE} app.jar

ENTRYPOINT ["java","-jar","/app.jar"]

2) Docker-Compose.yaml

version: "2.17.2"
services:
  redis:
    image: 'redis'
  backend:
    build:
      context: .
      args:
        JAR_FIlE: build/libs/*.jar
    image: backend
    depends_on:
      - redis

3. EC2인스턴스를 원격 리모트 머신으로 하여 배포하기

- 강의에서 배운 ECS 서비스는 실제로 결제가 되고, 그 서비스까지 필요하다고는 생각하지 않아 수동 배포 방식을 선택하고 도입해보았다.

https://cdaosldk.tistory.com/242

Udemy : Docker & Kubernetes 실전 가이드 (9) - 1

4. 트러블슈팅

- 레디스를 연결하는 도중 토큰을 검증하고 재발급하는 과정에서 리소스가 많이 소요되었다. 검색을 통한 학습 및 실제 여러 시행착오를 통해 구현해본 코드여서, 품질 여부에 관계없이 매우 뿌듯하다.

- 강의에서는 Node.js를 도커라이즈하고 배포해서, 자바의 경우에도 뭐 크게 다를까 싶었지만, 자바의 경우 지금까지 내가 이해한 것으로는 스냅샷을 먼저 찍고 이 스냅샷을 이미지로 만드는 것이어서 바인드 마운트에 대해서는 어떻게 적용할지 아직은 미지수다. 우선 스냅샷을 이미지화해서 배포하는 것까지가 이번 과정의 목표였기 때문에 이번엔 이걸로 만족한다.

 

참고한 글

https://inpa.tistory.com/entry/WEB-%F0%9F%93%9A-Access-Token-Refresh-Token-%EC%9B%90%EB%A6%AC-feat-JWT

https://medium.com/@uk960214/refresh-token-%EB%8F%84%EC%9E%85%EA%B8%B0-f12-dd79de9fb0f0