[Spring][Redis] Redis & 캐싱

Redis

📌 Redis(Remote Dictionary Server)
"key-value" 구조의 비정형 데이터를 저장하고 관리하기 위한 오픈 소스 기반의 비관계형 데이터베이스 관리 시스템(DBMS)이다.
데이터 처리 속도가 엄청 빠른 NoSQL 데이터베이스이다.

📌 NoSQL(Not Only SQL)
key-value 형태로 저장하는 데이터베이스 
비관계형 데이터 모델을 통해 데이터를 유연하게 저장할 수 있어 쿼리 없이도 쉽게 접근 가능하다.

Redis 장점

in-memory

Redis는 in-memory에 모든 데이터를 저장한다. 때문에 데이터 처리 성능이 굉장히 빠르다.

MySQL과 같은 RDBMS의 데이터베이스는 대부분 디스크(Disk)에 데이터를 저장한다.
하지만 Redis는 메모리(RAM)에 데이터를 저장한다. 디스크(Disk)보다 메모리(RAM)에서의 데이터 처리속도가 월등하게 빠르다. 이 때문에 Redis의 데이터 처리 속도가 RDBMS에 비해 훨씬 빠르다.

주요 사용 사례

• 캐싱 (Caching)
• 세션 관리 (Sessino Management)
• 실시간 분석 및 통계 (Real-time Analystics)
• 메시지 큐 (Message Queue)
• 지리공간 인덱싱 (Geospatial Indexing)
• 속도 제한 (Rate Limiting)
• 실시간 채팅 및 메시징 (Real-time Chat And Messaging)

레디스(Redis)에는 내장된 기능이 다양해 여러 용도로 사용된다.

 

여기서는 현업에서 많이 사용되는 ‘캐싱(데이터 조회 성능 향상)’에 대해 집중적으로 공부해볼 것이다.

대용량 트래픽을 처리하기 위해 필수적으로 사용되는 기능이 Redis 캐싱(Caching) 기능이다.

Redis 기본 명령어

데이터(Key, Value) 저장

# set [key 이름] [value]
$ set jaeseong:name "jaeseong park" # 띄워쓰기 해서 저장하려면 쌍따옴표로 묶어주면 됨
$ set jaeseong:hobby soccer

 

데이터 조회

Key로 Value 값 조회

# get [key 이름]
$ get jaeseong:name
$ get jaeseong:hobby

$ get pjs:name # 없는 데이터를 조회할 경우 (nil)이라고 출력됨

 

저장된 모든 key 조회

$ keys *

 

데이터 삭제

Key로 데이터 삭제

# del [key 이름]
$ del jaeseong:hobby

$ get jaeseong:hobby # 삭제됐는 지 확인

 

데이터 저장 시 만료시간(TTL) 정하기

# set [key 이름] [value] ex [만료 시간(초)]
$ set jaeseong:pet dog ex 30 # 딘위는 s 다.

redis는 RDBMS와는 다르게 데이터 저장 시 만료 시간을 설정할 수 있다.

영구 저장이 아닌 일정 시간이 지나면 데이터가 삭제되도록 세팅할 수 있다.

 

레디스의 특성상 메모리 공간이 한정 되어 있기 때문에 모든 데이터를 레디스에 저장할 수 없다. 따라서 만료시간(TTL)을 활용해 자주 사용하는 데이터만 레디스에 저장해놓고 쓰는 식으로 활용한다.

만료시간(TTL) 확인

# ttl [key 이름]
$ ttl jaeseong:pet 
$ ttl jaeseong:name
$ ttl pjs:name

• 만료 시간이 몇 초 남았는 지 반환한다.
• 키가 없는 경우 -2를 반환한다.
• 키는 존재하지만 만료 시간이 설정돼 있지 않은 경우에는 -1을 반환한다.

모든 데이터 삭제

$ flushall

 

key 네이밍 컨벤션

현업에서 자주 활용하는 네이밍 컨벤션은 콜론(:)을 활용해 계층적으로 의미를 구분하는 방법이다.

 

• 예시
  • users:100:profile : 사용자들(users) 중에서 PK가 100인 사용자(user)의 프로필(profile)
  • products:123:details : 상품들(products) 중에서 PK가 123인 상품(product)의 세부사항(details)
• 장점
  • 가독성 : 데이터의 의미와 용도를 쉽게 파악
  • 일관성 : 컨벤션을 따름으로써 코드의 일관성이 높아지고 유지보수가 쉬워짐
  • 검색 및 필터링 용이성 : 패턴 매칭을 사용해 특정 유형의 Key를 쉽게 찾음
  • 확장성 : 서로 다른 Key와 이름이 겹쳐 충돌 가능성을 줄여줌

캐시(Cache)

📌 캐시(Cache)
원본 저장소보다 빠르게 가져올 수 있는 임시 데이터 저장소

📌 캐싱(Caching)
캐시에 접근해서 데이터를 빠르게 가져오는 방식

캐싱 전략

데이터를 어떻게 캐싱하고 어떻게 조회할 것인지에 대한 전략이 다양하다. 

Cache Aside(=Look Aside, Lazy Loading) 전략

데이터를 조회할 때 주로 사용하는 전략이다. Look Aside 전략 또는 Lazy Loading 전략이라고 부른다.

전략 방식

1. 처음 게시판 서비스를 배포했을 때, 데이터베이스와 레디스에는 아무런 데이터도 저장이 안 되어 있음
2. 사용자가 게시글 작성을 함으로써 데이터를 저장
   • 이 데이터는 데이터베이스에 저장된다. 레디스에는 저장되지 않는다.
3. 사용자가 데이터를 조회 요청
   • 이 때, 데이터베이스로부터 바로 데이터 조회하기 전에 레디스에 있는 지 먼저 확인한다.
4. 레디스에 데이터가 없는 걸 확인한 후, 데이터베이스로부터 데이터를 조회해서 응답
5. 데이터베이스로부터 조회한 데이터를 응답한 뒤에 레디스에도 데이터를 저장
6. 다시 사용자가 데이터를 조회하려고 요청
7. 레디스에 조회하고자 하는 데이터가 있는 지 확인 후 존재하면 레디스로부터 데이터를 바로 가져옴

이게 Cache Aside 전략을 적용시킨 형태이다.

📌 Cache Hit: 데이터를 요청했을 때 캐시에 데이터가 있는 경우
📌 Cache Miss: 데이터를 요청했을 때 캐시에 없는 경우

Cache Aside전략은 캐시(Cache)에서 데이터를 확인하고, 없다면 DB를 통해 조회해오는 방식이라 볼 수 있다.

Write Around 전략

Cache Aside 전략이 데이터를 어떻게 조회할 지에 대한 전략이었다면, Write Around 전략은 데이터를 어떻게 쓸 지(저장, 수정, 삭제)에 대한 전략이다. Cache Aside 전략과 같이 자주 활용되는 전략이다.

전략 방식

데이터를 저장할 때는 레디스에 저장하지 않고 데이터베이스에만 저장하는 방식이다. 그러다 데이터를 조회할 때 레디스에 데이터가 없으면 데이터베이스로부터 데이터를 조회해와서 레디스에 저장시켜주는 방식이다.

Write Around 전략은 쓰기 작업(저장, 수정, 삭제)을 캐시에는 반영하지 않고, DB에만 반영하는 방식을 뜻한다.

Cache Aside, Write Around 전략 한계점

일관성

캐시된 데이터와 DB 데이터와 일치하지 않을 수 있다.

 

Cache Asdie와 Write Around 전략을 같이 썼을 때의 한계점 중 하나는 캐시된 데이터와 DB 데이터가 일치하지 않을 수 있다는 점이다. 즉, 데이터의 일관성을 보장할 수 없다.

 

Write Around 전략에 따르면 데이터를 수정할 때 DB만 업데이트를 시키기 때문에 기존에 저장된 레디스의 데이터 값과 DB의 데이터 값은 다를 수 밖에 없다.

 

캐시와 DB의 데이터를 일치시키기 위해, 데이터를 수정할 때마다 동시에 업데이트 시키면 성능적으로 느려진다. 그렇다고 성능 향상을 위해 DB의 데이터만 업데이트 시키면 캐시와 DB의 데이터가 일치하지 않게 된다.

 

어떤 선택을 하든 기회 비용(Trade Off)이 발생한다. 무언가를 얻으면 무언가를 포기해야 한다. 대부분의 개발 기술들이 장점이 있으면 단점이 있다. 따라서 데이터 조회 성능 개선 목적으로 레디스를 쓰는 경우에는 데이터의 일관성을 포기하고 성능 향상을 택한 것이다.

✅ 캐시를 적용시키기에 적절한 데이터
- 자주 조회되는 데이터
- 잘 변하지 않는 데이터
- 실시간으로 정확하게 일치하지 않아도 되는 데이터

하지만 장기간 데이터가 일치하지 않는 건 문제가 될 수 있다. 따라서 적절한 주기로 데이터를 동기화시켜주어야 한다. 이 때 활용하는 기능이 레디스의 TTL 기능(만료 시간 설정 기능)이다.

 

일정 시간이 지나면 데이터가 캐시에서 삭제된다. 그럼 특정 사용자가 조회를 하는 순간 Cache Miss가 발생하는데 그때

DB의 데이터를 새로 조회해와서 캐시에 데이터를 넣게 된다. 즉, 데이터가 새롭게 갱신되는 효과가 있게 된다.

작은 공간

DB는 디스크(Disk)에 저장해서 많은 양을 저장하기 용이하지만,

캐시는 메모리(RAM)에 저장하기 때문에 DB에 비해 많은 양의 데이터를 저장할 수가 없다.

 

TTL 기능(만료 시간 설정 기능)을 활용하면 캐시의 공간을 효율적으로 쓸 수 있다. 왜냐면 자주 조회하지 않는 데이터는 만료 시간에 의해 데이터가 삭제되기 때문이다.

Cache Aside, Write Around 전략을 사용할 때 주로 TTL을 같이 활용한다.

Springboot에서 사용하기

# local
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/rediscache
    username: root
    password: rootpassword
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  data:
    redis:
      host: localhost
      port: 6379

logging:
  level:
    org.springframework.cache: trace # Redis 사용에 대한 로그가 조회되도록 설정

@Cacheable은 spring-context에 포함되어 있다.
spring-boot-starter-data-jpa
spring-boot-starter-data-redis
spring-boot-starter-web
등 모두 포함

@Cacheable

import org.springframework.cache.annotation.Cacheable;
...

@Service
@RequiredArgsConstructor
public class BoardService {
  private final BoardRepository boardRepository;

  /**
   * - cacheNames : 캐시 이름을 설정, 사용할 캐시 규칙을 지정하기 위한 이름
   * - key : Redis에 저장할 Key의 이름을 설정
   * - cacheManager : 사용할 cacheManager의 Bean 이름을 지정
   * @param page 페이지
   * @param size 사이즈
   * @return 조회 데이터
   */
  @Cacheable(cacheNames = "getBoards", key = "'boards:page:' + #page + ':size:' + #size", cacheManager = "boardCacheManager")
  public List<Board> getBoards(int page, int size) {
    Pageable pageable = PageRequest.of(page - 1, size);
    Page<Board> pageOfBoards = boardRepository.findAllByOrderByCreatedAtDesc(pageable);
    return pageOfBoards.getContent();
  }
}

 

@CachePut

@CachePut(cacheNames = "itemCache", key = "#result.id")
public ItemDto create(ItemDto dto) {
    return ItemDto.fromEntity(itemRepository.save(Item.builder()
            .name(dto.getName())
            .description(dto.getDescription())
            .price(dto.getPrice())
            .stock(dto.getStock())
            .build()
    ));
}

@Cacheable은 데이터를 캐시에서 발견할 경우(Hit), 메서드 자체를 실행하지 않는다.

반면, @CachePut은 항상 메서드를 실행하고, 결과를 캐싱한다.

 

생성, 또는 수정에 대해서 적용하면 Write Through 전략처럼 동작한다.

 

create()의 key인 #result.id: 반환되는 ItemDto.id를 활용한다는 의미인데, 이렇게 만들어진 데이터가 캐시에 저장되기 때문에 readOne 메서드도 그 결과를 활용할 수 있다.

@CacheEvict

update 메서드에 @CachePut과 @CacheEvict를 추가

@CachePut(cacheNames = "itemCache", key = "args[0]")
@CacheEvict(cacheNames = "itemAllCache", allEntries = true) // allEntries = true 대신 key = "readAll" 처럼 지정할 수 있다.
public ItemDto update(Long id, ItemDto dto) {
    Item item = itemRepository.findById(id)
                    .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    item.setName(dto.getName());
    item.setDescription(dto.getDescription());
    item.setPrice(dto.getPrice());
    item.setStock(dto.getStock());
    return ItemDto.fromEntity(itemRepository.save(item));
}

@CacheEvict는 주어진 정보를 바탕으로 저장된 캐시를 지워준다.

key를 통해서 명확히 하나의 캐시를 지정할수도 있지만, 모든 아이템을 저장한 캐시인 itemAllCache를 목표로 하고 있다. 아이템의 정보가 바뀌었으니, 데이터를 전부 돌려준 결과가 더이상 유효하지 않다고 이야기 하는거라 생각할 수 있다.

@EnableCaching, CacheConfig

import java.time.Duration;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@EnableCaching // Spring Boot의 캐싱 설정을 활성화
public class RedisCacheConfig {
  @Bean
  // 게시글 조회용 캐시 매니저
  public CacheManager boardCacheManager(RedisConnectionFactory redisConnectionFactory) {
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration
        .defaultCacheConfig()
        // Redis에 Key를 저장할 때 String으로 직렬화(변환)해서 저장
        .serializeKeysWith(
            RedisSerializationContext.SerializationPair.fromSerializer(
                new StringRedisSerializer()))
        // Redis에 Value를 저장할 때 Json으로 직렬화(변환)해서 저장
        .serializeValuesWith(
            RedisSerializationContext.SerializationPair.fromSerializer(
                new Jackson2JsonRedisSerializer<Object>(Object.class)
//                new GenericJackson2JsonRedisSerializer() 이렇게 작성하면 클래스 이름까지 저장된다.
            )
        )
        // 데이터의 만료기간(TTL) 설정
        .entryTtl(Duration.ofMinutes(1L));

    return RedisCacheManager
        .RedisCacheManagerBuilder
        .fromConnectionFactory(redisConnectionFactory)
        .cacheDefaults(redisCacheConfiguration)
        .build();
  }
}

RedisConfig

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

@Configuration
public class RedisConfig {
  @Value("${spring.data.redis.host}")
  private String host;

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

  @Bean
  public LettuceConnectionFactory redisConnectionFactory() {
    // Lettuce: Redis와 연결을 해주는 라이브러리
    // Lettuce를 활용해서 redis와 연결을 관리하는 객체를 생성하고
    // Redis 서버에 대한 정보(host, port)를 설정한다.
    return new LettuceConnectionFactory(new RedisStandaloneConfiguration(host, port));
  }
}

Hibernate: select b1_0.id,b1_0.content,b1_0.created_at,b1_0.title from boards b1_0 order by b1_0.created_at desc limit ?
Hibernate: select count(b1_0.id) from boards b1_0
2024-09-10T03:30:46.328+09:00 TRACE 19744 --- [nio-8080-exec-1] o.s.cache.interceptor.CacheInterceptor   : Creating cache entry for key 'boards:page:1:size:10' in cache(s) [getBoards]
2024-09-10T03:31:31.547+09:00 TRACE 19744 --- [nio-8080-exec-2] o.s.cache.interceptor.CacheInterceptor   : Computed cache key 'boards:page:1:size:10' for operation Builder[public java.util.List com.rediscaching.api.service.BoardService.getBoards(int,int)] caches=[getBoards] | key=''boards:page:' + #page + ':size:' + #size' | keyGenerator='' | cacheManager='boardCacheManager' | cacheResolver='' | condition='' | unless='' | sync='false'
2024-09-10T03:31:31.581+09:00 TRACE 19744 --- [nio-8080-exec-2] o.s.cache.interceptor.CacheInterceptor   : Cache entry for key 'boards:page:1:size:10' found in cache(s) [getBoards]

Cache entry는 캐시가 있었다는 의미다.

value는 아래와 같이 저장된다.

[{"id":795007,"title":"Title0795007","content":"Content0795007","createdAt":"2024-09-10T03:33:52"},{"id":435766,"title":"Title0435766","content":"Content0435766","createdAt":"2024-09-10T03:18:06"},{"id":433560,"title":"Title0433560","content":"Content0433560","createdAt":"2024-09-10T03:15:42"},{"id":17098,"title":"Title0017098","content":"Content0017098","createdAt":"2024-09-10T03:10:25"},{"id":790848,"title":"Title0790848","content":"Content0790848","createdAt":"2024-09-10T03:09:18"},{"id":940990,"title":"Title0940990","content":"Content0940990","createdAt":"2024-09-10T03:07:36"},{"id":132154,"title":"Title0132154","content":"Content0132154","createdAt":"2024-09-10T02:35:47"},{"id":120837,"title":"Title0120837","content":"Content0120837","createdAt":"2024-09-10T02:33:11"},{"id":873326,"title":"Title0873326","content":"Content0873326","createdAt":"2024-09-10T02:31:34"},{"id":441443,"title":"Title0441443","content":"Content0441443","createdAt":"2024-09-10T02:28:40"}]

대략 10배정도 향상

127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> keys *
1) "getBoards::boards:page:1:size:10"
127.0.0.1:6379> get getBoards::boards:page:1:size:10
"[{\"id\":740344,\"title\":\"Title0740344\",\"content\":\"Content0740344\",\"createdAt\":\"2024-09-09T16:33:26\"},{\"id\":24559,\"title\":\"Title0024559\",\"content\":\"Content0024559\",\"createdAt\":\"2024-09-09T16:26:01\"},{\"id\":8406,\"title\":\"Title0008406\",\"content\":\"Content0008406\",\"createdAt\":\"2024-09-09T16:22:46\"},{\"id\":301583,\"title\":\"Title0301583\",\"content\":\"Content0301583\",\"createdAt\":\"2024-09-09T16:22:43\"},{\"id\":595094,\"title\":\"Title0595094\",\"content\":\"Content0595094\",\"createdAt\":\"2024-09-09T16:21:38\"},{\"id\":244583,\"title\":\"Title0244583\",\"content\":\"Content0244583\",\"createdAt\":\"2024-09-09T16:19:29\"},{\"id\":274110,\"title\":\"Title0274110\",\"content\":\"Content0274110\",\"createdAt\":\"2024-09-09T16:17:33\"},{\"id\":256964,\"title\":\"Title0256964\",\"content\":\"Content0256964\",\"createdAt\":\"2024-09-09T16:13:56\"},{\"id\":395993,\"title\":\"Title0395993\",\"content\":\"Content0395993\",\"createdAt\":\"2024-09-09T16:07:12\"},{\"id\":961766,\"title\":\"Title0961766\",\"content\":\"Content0961766\",\"createdAt\":\"2024-09-09T16:01:57\"}]"
127.0.0.1:6379> ttl getBoards::boards:page:1:size:10 
(integer) 29

AWS 사용하기

📌 AWS 비용
EC2
- EC2 인스턴스 (t3a.small) : 시간당 0.026 USD (24시간당 약 800원)
- 데이터 전송 비용 : 1 GB당 0.1368 USD (1GB당 약 200원)
(실습 과정 동안 1GB 이하의 데이터만 전송)
- Public IPv4 비용 : 시간당 0.005 USD (24시간당 약 200원)
RDS
- RDS 인스턴스 (t3.micro) : 시간당 0.026 USD (24시간당 약 800원)(프리티어일 경우 월 750시간까지 무료)
- 스토리지 비용 : GB-월당 0.131 USD (20GB-24시간당 약 200원)(프리티어일 경우 20GB까지 무료)
- Public IPv4 비용 : 시간당 0.005 USD (24시간당 약 200원)
ElastiCache
- 캐시 (cache.t3micro) : 시간당 0.025 USD (24시간당 약 800원)(프리티어일 경우 월 750시간까지 무료)

EC2 세팅

RDB 세팅

보안그룹 인바운드 규칙 허용 필요

EC2에 Redis 설치

1. Redis 설치
$ sudo apt update
$ sudo apt install redis

2. 설치 확인
$ redis-cli
127.0.0.1:6379> ping
PONG

Spring Boot 셋팅

$ sudo apt install openjdk-17-jdk
$ java -version

application 파일 수정

# local 환경
spring:
  profiles:
    default: local
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  data:
    redis:
      host: localhost
      port: 6379

logging:
  level:
    org.springframework.cache: trace 

---
# prod 환경
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:mysql://{rds 주소}:3306/mydb
    username: admin
    password: password

rds 주소는 rds의 엔드포인트

# git clone
$ git clone {Github Repository 주소}
$ cd {프로젝트 경로}

# 서버 실행 스프링 프로젝트 경로로 들어가서 아래 명령어 실행
$ ./gradlew clean build -x test # 안되면 chmod +x gradlew
$ cd build/libs
$ java -jar -Dspring.profiles.active=prod {빌드된 jar 파일명} # plain말고

github password는 토큰 사용함

부하 테스트

서비스를 배포하기 전에 백엔드 서버가 어느 정도의 요청을 견딜 수 있는 지 부하 테스트를 해봐야 한다.

 

📌 Throughput
부하 테스트에서 서비스가 1초당 처리할 수 있는 작업량
- 단위: TPS(Transaction Per Seconds, 1초당 처리한 트랜잭션의 수)

서비스가 1초에 최대 100개의 API 요청을 처리할 수 있다면, 이 서비스의 Throughput은 100 TPS

 

K6

성능 비교를 위해 k6라는 부하테스트 툴을 사용할 것이다.

부하테스트 툴에는 k6 이외에도 ngrinder, jmeter, ab, locust 등 다양한 툴이 있다.

그 중 간단하고 빠르게 테스트 해볼 수 있는 툴인 k6를 활용하고자 한다.

 

https://grafana.com/docs/k6/latest/set-up/install-k6/#fedoracentos

k6 설치 방법

공식문서 : https://k6.io/docs/get-started/installation/

• Windows - 설치 방법 1
  • 아래 영상을 참고해서 설치해보도록 하자. k6 프로그램을 직접 다운받아서 설치하는 방법이다.
  • https://www.youtube.com/watch?v=eVmcDt5C8io&feature=youtu.be

• Windows - 설치 방법 2
  • Package Manager를 활용해서 설치하는 방법이다.
  • https://yscho03.tistory.com/101#google_vignette

 

요청을 어떻게 보낼 것인지에 대한 스크립트 적어줘야 한다.

 

이번에는 백오피스로 서버를 실행시켜 테스트 해보자. 백그라운드에서 실행을 시켜야 출력 화면을 띄우지 않아 더 정확한 성능 테스트가 가능하다.

# 스프링 프로젝트 경로로 들어가서 아래 명령어 실행
$ ./gradlew clean build -x test 

# 정확한 테스트를 위해 Spring Boot 서버를 백그라운드에서 실행
$ cd build/libs
$ nohup java -jar -Dspring.profiles.active=prod {빌드된 jar 파일명} &

# 8080번 포트에 Spring Boot 서버가 잘 실행되고 있는 지 확인
$ lsof -i:8080

 

k6 script.js 작성

import http from 'k6/http';
import { sleep } from 'k6';

export default function () {
  http.get('http://{EC2 IP 주소}:8080/boards');
}

실행

# K6의 스크립트 파일이 위치한 경로에서 아래 명령어 실행시키기
$ k6 run --vus 30 --duration 10s script.js

• --vus 30 : 가상 유저(Virtual Users)를 30명으로 셋팅 (API 요청을 보내는 사용자가 30명인 것처럼 부하 생성)
• --duration 30s : 30초 동안 테스트를 유지

결과

redis 적용 전

현재 구축한 서비스에서 게시글 조회 API의 throughput은 1.585228이다.

평균적으로 1초에 처리할 수 있는 요청은 1.585228개 이다.

redis 적용 후(api 한번 호출 후 결과이다.)

redis cache를 적용한 서비스에서 게시글 조회 API의 throughput은 44.355323이다.

평균적으로 1초에 처리할 수 있는 요청은 44.355323개 이다.

Docker Compose

Dockerfile

FROM openjdk:17-jdk

COPY build/libs/*SNAPSHOT.jar app.jar

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

compose.yml

services:
  api-server:
    build: . # 도커파일을 기준으로 빌드를 할 것이기 때문에 Dockerfile 경로를 나타내준다.
    ports:
      - 8080:8080
    depends_on:
      cache-server:
        condition: service_healthy 
        # spring boot 서버가 캐시 서버와 연결을 해야하기 때문에
        # 캐시 서버가 띄어져있지 않다면 에러를 띄움
  cache-server:
    image: redis
    ports:
      - 6379:6379
    healthcheck: # redis가 잘 실행되었는지 조건
      test: [ "CMD", "redis-cli", "ping" ]
      interval: 5s
      retries: 10

application.yml

# local 환경
spring:
  profiles:
    default: local
  datasource:
    url: jdbc:mysql://host.docker.internal:3306/mydb # host 컴퓨터 주소
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  data:
    redis:
      host: cache-server // compose-yml에 있는 이름과 동일하게
      port: 6379

logging:
  level:
    org.springframework.cache: trace


---
# prod 환경
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:mysql://instagram-db.coseefawhrzc.ap-northeast-2.rds.amazonaws.com:3306/mydb
    username: admin
    password: password

스프링 부트가 실행되는건 컨테이너 안에서의 주소다.

해당 컨테이너 안에는 MySQL이 없어 localhost라고 적으면 연결을 못한다. 

host.doccker.internal로 적어서 호스트 컴퓨터의 주소를 뜻하도록 한다.

Docker 컨테이너로 띄우기

$ ./gradlew clean build -x test
$ docker compose up --build -d

$ docker ps # 잘 띄워졌는 지 확인
$ docker compose logs -f # 실시간 로그 확인하기

EC2에 Docker Compose로 띄우기

Dockerfile-prod

FROM openjdk:17-jdk

COPY build/libs/*SNAPSHOT.jar app.jar

ENTRYPOINT ["java", "-jar", "-Dspring.profiles.active=prod", "/app.jar"]

• -Dspring.profiles.active=prod

Compose-prod.yml

services:
  api-server:
    build: 
      context: .
      dockerfile: ./Dockerfile-prod
    ports:
      - 8080:8080
    depends_on:
      cache-server:
        condition: service_healthy
  cache-server:
    image: redis
    ports:
      - 6379:6379
    healthcheck:
      test: [ "CMD", "redis-cli", "ping" ]
      interval: 5s
      retries: 10

Git Pull

$ cd {프로젝트 경로}
$ git pull origin main

EC2에 Docker 설치

$ sudo apt-get update && \
	sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common && \
	curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - && \
	sudo apt-key fingerprint 0EBFCD88 && \
	sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" && \
	sudo apt-get update && \
	sudo apt-get install -y docker-ce && \
	sudo usermod -aG docker ubuntu && \
	newgrp docker && \
	sudo curl -L "https://github.com/docker/compose/releases/download/2.27.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose && \
	sudo chmod +x /usr/local/bin/docker-compose && \
	sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
	
$ docker -v # Docker 버전 확인
$ docker compose version # Docker Compose 버전 확인

기존 실행 중인 Redis, Spring Boot 종료

# Redis 중지
$ sudo systemctl stop redis
$ sudo systemctl status redis # 잘 종료됐는 지 확인

# Spring Boot 종료
$ sudo lsof -i:8080 # 8080번 포트 실행되고 있는 프로세스 확인
$ kill {Spring Boot의 PID} # 프로세스 종료
$ sudo lsof -i:8080 # 잘 종료됐는 지 확인

Docker 컨테이너로 띄우기

$ ./gradlew clean build -x test
$ docker compose -f compose-prod.yml up --build -d 

$ docker ps # 잘 띄워졌는 지 확인
$ docker compose logs -f # 실시간 로그 확인하기