[프로젝트] Redis로 캐싱 구현하기

💡 개념

Redis
- 오픈 소스 In-memory 데이터 저장소
- String / Hash / Set / List 등을 저장 가능
- 전통적인 디스크 방식보다 훨씬 빠르며, 주로 캐시(cache)용도로 사용
- 현재는 단순 캐시 용도 이외에도 데이터베이스, 메시지 브로커, 스트리밍 엔진으로도 사용

캐시로 사용?
- 호출할 때마다 계산을 해야하고 계산이 오래걸리거나, 시점에 따라 결과값이 바뀌지 않는경우
(예시: 어제까지 발생한 서비스의 총 매출같은 통계값)

 

🔥 개발 방향

사용자 정보는 현재 프로젝트에서 변경될 일이 없으므로 인증 부분에서 캐싱을 적용하려고 함

기존
: 사용자 인증(로그인)을 진행할 때, 항상 DB에서 사용자 정보를 가져옴

개발 진행 방향:
- 처음 사용자 인증(로그인) 시 DB select 후, 캐시에 저장
- 카카오 로그인 시 인증 후에 카카오 유저 정보 DB insert 하고, 캐시에 저장
→ 이후 같은 userId로 인증시 캐시에서 먼저 조회

 

 

1. Docker를 통해 Redis 실행

docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest​

-p 6379:6379
:로컬 컴퓨터의 6379 포트를 컨테이너 내부의 6379 포트에 연결하여 포트가 외부에서 접근 가능하도록 설정함
(Redis 서버는 기본적으로 6379 포트에서 동작)

-p 8001:8001
:Redis Stack 의 웹 인터페이스(RedisInsight)에 접속할 수 있는 포트를 매핑함
http://localhost:8001/redis-stack/browser 로 RedisInsight에 접속

 

2. 의존성 추가

👾 build.gradle

    implementation 'org.springframework.boot:spring-boot-starter-data-redis' //redis
    implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'

 

3. redis host, port 설정

👾 application.yaml

redis:
  host: localhost
  port: 6379

 

4. Cache 관련 빈 설정

👾 CacheConfig.java

@Configuration
public class CacheConfig {

    private static final ObjectMapper objectMapper =
            new ObjectMapper().registerModule(new JavaTimeModule());

    @Bean // redis에 접속하기 위한 설정
    RedisConnectionFactory redisConnectionFactory(
            @Value("${redis.host}") String redisHost,
            @Value("${redis.port}") int redisPort
    ) {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(redisHost);
        config.setPort(redisPort);
        return new LettuceConnectionFactory(config); // lettuce : 최신, 성능 좋다고 알려진 구현체
    }

    @Bean
    public RedisTemplate<String, UserAccount> userAccountRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, UserAccount> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer()); //문자열로 변환하여 키값 세팅
        //value: 데이터가 복잡.. 필드 데이터도 있고 -> Json형태의 문자열로
        redisTemplate.setValueSerializer(
                new Jackson2JsonRedisSerializer<>(objectMapper, UserAccount.class));

        return redisTemplate;
    }
}

 

 

5. 캐싱 기능 구현

👾 UserAccountService.java

@Transactional(readOnly = true)
public Optional<UserAccountDto> searchUser(String username) {
    return userAccountCacheRepository.getUserAccountCache(username)
                    .or(() -> userAccountRepository.findById(username)
                            .map(userAccount -> {
                                userAccountCacheRepository.setUserAccountCache(userAccount);
                                return userAccount;
                            }))
                    .map(UserAccountDto::fromEntity);
}

public UserAccountDto saveUser(String username, String password, String email, String nickname, String memo) {
    UserAccount userAccount = userAccountRepository.save(UserAccount.of(username, password, email, nickname, memo, username));
    userAccountCacheRepository.setUserAccountCache(userAccount);
    return UserAccountDto.fromEntity(userAccount);
}

searchUser
: 사용자 로그인 시 아래 Spring Security 로직에서 DB에 사용자가 있는지 확인하는 로직
- redis에서 사용자가 있는지 조회하고
- 없으면 DB에서 조회 후, 엔티티 redis에 저장
(map : 카카오 처음 로그인 시 redis, DB에 모두 없기때문에 엔티티가 있는 경우에만 redis에 저장함)
 

SecurityConfig.java - userDetailsService
- 폼 로그인을 통해 사용자가 로그인을 시도할 때 호출됨
- username을 받아서 UserAccountService를 통해 사용자를 조회한다
- UserDetailsService는 Spring Security에서 인증 정보를 조회할 때 사용됨

   @Bean
    public UserDetailsService userDetailsService(UserAccountService userAccountService) {
        return username -> userAccountService
                .searchUser(username)
                .map(SnsPrincipal::fromDto)
                .orElseThrow(() -> new UsernameNotFoundException("유저를 찾을 수 없습니다 - username: " + username));
    }​

 

saveUser
: 카카오 로그인 시 아래 OAuth2 사용자 정보를 처리하고 DB에 저장하는 로직
- DB에 저장 후, redis에 저장

SecurityConfig.java - oAuth2UserService
- OAuth2 사용자 정보를 처리하는 서비스 객체를 생성
- 이 메서드가 반환한 OAuth2User 객체가 Spring Security의 인증 정보로 사용됨

 @Bean
    public OAuth2UserService<OAuth2UserRequest, OAuth2User> oAuth2UserService(
            UserAccountService userAccountService,
            PasswordEncoder passwordEncoder
    ) {
        final DefaultOAuth2UserService delegate = new DefaultOAuth2UserService();

        return userRequest -> {
            OAuth2User oAuth2User = delegate.loadUser(userRequest);

            KakaoOAuth2Response kakaoResponse = KakaoOAuth2Response.from(oAuth2User.getAttributes());
            String registrationId = userRequest.getClientRegistration().getRegistrationId();
            String providerId = String.valueOf(kakaoResponse.id());
            String username = registrationId + "_" + providerId;
            String dummyPassword = passwordEncoder.encode("{bcrypt}" + UUID.randomUUID());

            return userAccountService.searchUser(username)
                    .map(SnsPrincipal::fromDto)
                    .orElseGet(() ->
                            SnsPrincipal.fromDto(
                                    userAccountService.saveUser(
                                            username,
                                            dummyPassword,
                                            kakaoResponse.email(),
                                            kakaoResponse.nickname(),
                                            null
                                    )
                            )
                    );
        };
    }​

 

 

👾 UserAccountCacheRepository.java

@Slf4j
@Repository
@RequiredArgsConstructor
public class UserAccountCacheRepository {

    private final RedisTemplate<String, UserAccount> userAccountRedisTemplate;
    private final static Duration USER_CACHE_TTL = Duration.ofDays(3); //redis공간을 효율적으로 사용하기 위해 3일동안만 저장

    public void setUserAccountCache(UserAccount userAccount) {
        log.info("Set User to Redis {}:{}", getRedisKey(userAccount.getUserId()), userAccount);
        userAccountRedisTemplate.opsForValue().set(getRedisKey(userAccount.getUserId()), userAccount, USER_CACHE_TTL);
    }

    public Optional<UserAccount> getUserAccountCache(String username) {
        String redisKey = getRedisKey(username);
        UserAccount userAccount = userAccountRedisTemplate.opsForValue().get(redisKey);
        log.info("Get User from Redis {}:{}", getRedisKey(username), userAccount);
        return Optional.ofNullable(userAccount);
    }

    private String getRedisKey(String username) {
        return "user:" + username;
    }
}

 

💡 결과

📌 일반 form 로그인 시 (처음)

- redis에서 먼저 조회

- 없어서 DB에서 조회 후 redis에 저장

2024-09-18T23:04:38.633+09:00  INFO 99096 --- [nio-8080-exec-7] c.p.s.r.UserAccountCacheRepository       : Get User from Redis user:ella:null
Hibernate: 
    select
        ua1_0.user_id,
        ua1_0.created_at,
        ua1_0.created_by,
        ua1_0.email,
        ua1_0.memo,
        ua1_0.modified_at,
        ua1_0.modified_by,
        ua1_0.nickname,
        ua1_0.user_password 
    from
        user_account ua1_0 
    where
        ua1_0.user_id=?
2024-09-18T23:04:38.635+09:00 TRACE 99096 --- [nio-8080-exec-7] org.hibernate.orm.jdbc.bind              : binding parameter (1:VARCHAR) <- [ella]
2024-09-18T23:04:38.636+09:00  INFO 99096 --- [nio-8080-exec-7] c.p.s.r.UserAccountCacheRepository       : Set User to Redis user:ella:UserAccount(super=AuditingFields(createdAt=2024-01-01T16:47:05, createdBy=ella, modifiedAt=2024-01-01T16:47:05, modifiedBy=ella), userId=ella, userPassword={noop}qwer1234, email=ella@mail.com, nickname=EllaCoo, memo=I am Ella.)

 

📌 카카오 로그인 시 (처음)

- redis에서 조회했으나 없음

- DB에서 조회했으나 없음

- service의 saveUser 통해 DB에 카카오 인증 정보 저장 및 redis 에 저장

2024-09-18T23:07:01.215+09:00  INFO 99096 --- [nio-8080-exec-6] c.p.s.r.UserAccountCacheRepository       : Get User from Redis user:kakao_1111:null
Hibernate: 
    select
        ua1_0.user_id,
        ua1_0.created_at,
        ua1_0.created_by,
        ua1_0.email,
        ua1_0.memo,
        ua1_0.modified_at,
        ua1_0.modified_by,
        ua1_0.nickname,
        ua1_0.user_password 
    from
        user_account ua1_0 
    where
        ua1_0.user_id=?
2024-09-18T23:07:01.220+09:00 TRACE 99096 --- [nio-8080-exec-6] org.hibernate.orm.jdbc.bind              : binding parameter (1:VARCHAR) <- [kakao_1111]
2024-09-18T23:07:01.238+09:00  INFO 99096 --- [nio-8080-exec-6] c.p.s.r.UserAccountCacheRepository       : Set User to Redis user:kakao_1111:UserAccount(super=AuditingFields(createdAt=2024-09-18T23:07:01.230980, createdBy=kakao_1111, modifiedAt=2024-09-18T23:07:01.230980, modifiedBy=kakao_1111), userId=kakao_1111, userPassword={bcrypt}$2a$10$xMQ2EHRKE9T1eq8ZoVY5Uujwlltl7x5z2KDnyvn5.JvV3jWa9NBV6, email=null, nickname=이서영, memo=null)
Hibernate: 
    insert 
    into
        user_account
        (created_at, created_by, email, memo, modified_at, modified_by, nickname, user_password, user_id) 
    values
        (?, ?, ?, ?, ?, ?, ?, ?, ?)

 

redis에 저장됨

이후 동일한 유저 인증 시, redis에서 먼저 조회 진행

 

추가 고민사항

- API 가 단일 노드 구성이라면 오히려 로컬 캐시가 더 빠를 수 있다. 

(굳이 원격의 redis와 통신할 필요가 없음)

 

- 메모리 기반으로 연산하는 것이 빠른 것이지 네트워크로 데이터를 주고 받는게 빠른 것은 아님

 

- 단일 노드가 아닌 경우로 고도화를 진행할 때, 각 노드 별로 관리하는 캐시 데이터가 서로 달라진다는 문제 발생하는 점을 고려해야 함 

 

 

✅ 성능 테스트

DB - 10000개 
캐시 - 10000개

 

JMeter 로 테스트

쓰레드 수(사용자 수) : 5000

loop : 10

redis get

 

DB select

redis를 통해

- 귀중한 DB 리소스를 아낄 수 있고

- 클라이언트에게 응답을 내려줄 때 응답속도 향상