redis clients lettuce2 lettuce2_sentinel

Lettuce Redis Sentinel

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Lettuce Redis Sentinel

이 문서는 레터스(Lettuce)를 이용해서 레디스 센티널(Redis Sentinel) 용 Java Spring 애플리케이션을 개발하는 방법을 설명합니다.
레디스 센티널에 연결(접속)하는 방법, 마스터가 다운되는 장애 발생 시 레터스 작동 방식, Pub/Sub과의 관계 등을 설명하고 관련 자바 소스 코드(source code)를 제공합니다.

기본 사용법

센티널 구성에서는 레디스 서버의 주소를 사용하지 않고 센티널 서버 주소로 연결(접속)합니다.
레터스(Lettuce)는 센티널에 접속해서 레디스 서버의 주소를 얻어와서 레디스 서버에 연결(접속)합니다. 그러므로 레디스 마스터가 다운되어 마스터 주소가 바꾸었어도 센티널이 최신 정보를 가지고 있기 때문에 새 마스터에 연결할 수 있습니다.
센티널이 3대이면 3대 주소 모두 등록합니다.

① .sentinel(node[0],Integer.parseInt(node[1]), redisProps.getSentinelMaster())

첫 번째 Sentinel 서버의 주소(ip와 port)와 MasterId 등 추가 정보로 RedisURI를 생성합니다.

② sentinelUri.getSentinels().add(RedisURI.create(node[0],Integer.parseInt(node[1])));

나머지 2대 센티널 서버의 주소를 등록합니다.

③ redisClient = RedisClient.create();

RedisClient 인스턴스를 생성합니다.

④ sentinelConnection = redisClient.connectSentinel();

센티널 서버에 연결합니다.

⑤ masterReplicaConnection = MasterReplica.connect(redisClient, StringCodec.UTF8, sentinelUri);

Redis 서버(Master/Replica)에 연결합니다.

⑥ masterReplicaConnection.setReadFrom(redisProps.getReadFrom());

조회 명령은 복제서버에서 실행하기 위해 ReadFrom을 설정합니다.
ReadFrom 각 값에 대한 자세한 설명은 여기를 보세요.

⑦ masterReplicaCommands = masterReplicaConnection.sync();

Sync 명령 실행용 API를 얻습니다.

Source code
① RedisURI sentinelUri = RedisURI.Builder .sentinel(node[0],Integer.parseInt(node[1]), redisProps.getSentinelMaster()) // IP, Port, MasterId 설정 .withPassword(redisProps.getPassword()) // Redis password 설정 .withDatabase(redisProps.getDatabase()) // Database 설정 .withTimeout(redisProps.getTimeout()) // Command timeout 설정 .withClientName(redisProps.getClientName()) // Client name 설정 .build(); ② sentinelUri.getSentinels().add(RedisURI.create(node[0],Integer.parseInt(node[1]))); ③ redisClient = RedisClient.create(sentinelUri); ④ sentinelConnection = redisClient.connectSentinel(); ⑤ masterReplicaConnection = MasterReplica.connect(redisClient, StringCodec.UTF8, sentinelUri); ⑥ masterReplicaConnection.setReadFrom(redisProps.getReadFrom()); ⑦ masterReplicaCommands = masterReplicaConnection.sync();

장애복구(failover)와 Application 연결

• 마스터가 다운되면 센티널은 복제서버 중 하나를 마스터로 승격시키는 명령을 실행하고, 기존 클라이언트(애플리케이션) 연결(normal | pubsub)을 끊습니다.
  MULTI
  SLAVEOF NO ONE
  CONFIG REWRITE
  CLIENT KILL TYPE normal
  CLIENT KILL TYPE pubsub
  EXEC
  • Sentinel 이 CLIENT KILL TYPE normal | pubsub 명령을 실행해서 client 연결을 끊는다.
    Source code: sentinel.c sentinelSendSlaveOf()
  • Redis-4.0 : CLIENT KILL TYPE normal -> pubsub은 하지 않는다.
  • Redis-5.0 : CLIENT KILL TYPE normal -> pubsub은 하지 않는다.
  • Redis-6.0 : CLIENT KILL TYPE normal | pubsub도 한다.
  • Master-Replica 연결은 끊지 않습니다.
• 다른 복제서버에도 마스터가 변경되었음 알리고 기존 클라이언트(애플리케이션) 연결(normal | pubsub)을 끊습니다.
  MULTI
  SLAVEOF 192.168.56.102 6001
  CONFIG REWRITE
  CLIENT KILL TYPE normal
  CLIENT KILL TYPE pubsub
  EXEC
  애플리케이션은 재연결을 시도해서 다시 연결합니다.
  • 자동 재연결은 ClientOptions에서 설정하며, 기본이 true입니다.
  • 재연결은 1,2,4,8,16,30초, 이후 30초마다 반복해서 재연결 시도합니다.
  • clientOptions.autoReconnect(true);
• 센티널은 다운된 레디스 서버 주소로 1초에 한번씩 PING을 보내서 다시 시작했는지 확인합니다.
  다운되었던 레디스 서버가 다시 시작하면 처음에는 마스터로 시작합니다.
  센티널은 이를 감지해서 복제서버로 만들고, 기존 클라이언트 연결을 끊습니다.
  다음 명령은 레디스 서버 시작하고 약 10초 후에 진행됩니다.
  MULTI
  SLAVEOF 192.168.56.102 6001
  CONFIG REWRITE
  CLIENT KILL TYPE normal
  CLIENT KILL TYPE pubsub
  EXEC
• 마스터가 다운되면 센티널은 복제서버 중 하나를 마스터로 승격시킵니다.
  센티널은 "Publish +switch-master mymaster ip port"로 애플리케이션에 마스터가 변경되었음을 알립니다.
  애플리케이션(lettuce)은 받은 주소로 새 마스터에 연결합니다.
  센티널로 부터 Publish를 받기 위해서 MasterReplica.connect() 시 3대 센티널에 아래 명령으로 SUBSCRIBE(등록)합니다.
  PSUBSCRIBE *
• 레터스(lettcue)는 SentinelTopologyRefresh class (package io.lettuce.core.masterreplica)에서 아래 채널명으로 들어오는 메시지를 받아 적절한 처리를 합니다.
  "+slave", "+sdown", "-sdown", "fix-slave-config", "+convert-to-slave", "+role-change" "+elected-leader", "+reset-master" "+switch-master" "+sentinel"
• 다운되었던 마스터가 다시 시작하면 센티널은 publish -sdown 메시지를 보내서 애플리케이션에게 다시 시작했음을 알리고, 이후 publish +convert-to-slave 메시지를 보내서 복제로 변경되었음을 알립니다. 애플리케이션은 메시지를 받아 복제서버로 등록(처리)합니다.

센티널 구성과 Pub/Sub과의 관계

센티널에서 Pub/Sub을 사용하려면 "redisClient.connectPubSub();"를 사용하세요. Publish와 Subscribe 용 연결(connection)을 구분해서 사용하시기 바랍니다.
장애복구(failover) 시 레터스(lettuce)가 이전 마스터에 실행(등록)했던 subscribe 명령을 기억했다가 새 마스터에 자동으로 subscribe 명령을 실행합니다.
예) 이전 마스터에 ch01 ~ ch05까지 5번 SUBSCRIBE를 했다면 새 마스터에 이렇게 실행합니다.
    SUBSCRIBE ch05 ch03 ch04 ch01 ch02
그러므로 새 마스터에 다시 subscribe 명령을 실행할 필요 없습니다.
Pub/Sub에 대한 소개와 사용법은 여기를 보세요.

센티널 서버 password 설정

아래와 같이 사용할 수 있으나, 해당 메서드가 "@Deprecated" 되었습니다. 센티널 서버에는 가능한 password을 설정하지 말 것을 권장드립니다. RedisURI sentinelUri1 = RedisURI.Builder .sentinel("192.168.56.102",7000, "mymaster","sentinelpassword") // Sentinel password 설정 .withPassword("redisgate".toCharArray()) // Redis password 설정 .build();

Connect String(URI)을 이용한 연결(접속) 방법

redis-sentinel URI syntax
redis-sentinel://[[username:]password@]host1 [: port1][, host2 [:port2]][, hostN [:portN]][/ database] [? [timeout=timeout[d|h|m|s|ms|us|ns]] [ &sentinelMasterId=sentinelMasterId] [&database=database] [&clientName=clientName] ]
아래와 같은 방법으로 Connect String(URI)을 만들어서 센티널에 연결한다. StringBuilder redisUri = new StringBuilder("redis-sentinel://" + redisProps.getPassword() + "@"); int i=0; for(String node: redisProps.getSentinelNodes()) { redisUri.append(node); // comma(,) 추가, 마지막 노드 다음에는 comma를 넣지 않는다. if (++i < redisProps.getSentinelNodes().size()) redisUri.append(","); } redisUri.append("/").append(redisProps.getDatabase()); redisUri.append("?&timeout=").append(redisProps.getTimeout()); redisUri.append("&sentinelMasterId=").append(redisProps.getSentinelMaster()); redisUri.append("&clientName=").append(redisProps.getClientName()); RedisURI redisURI = RedisURI.create(redisUri.toString()); redisClient = RedisClient.create(redisURI);

Lettuce Spring Project

Spring Project 생성

Java Spring Project 생성 URL: start.spring.io

• Project: Gradle-Groovy
• Language: Java
• Spring Boot: 3.1.8
• Project Metadata
  • Group: com.redisgate
  • Artifact: SentinelLettuce -> Project 명칭, 이 이름으로 압축파일이 생긴다.
  • Name: Main -> Main Class Name
  • Description: Redis Sentinel Lettuce Application -> 설명
  • Package name: com.redisgate.redis -> Package Name
  • Packaging: Jar
  • Java: 17 -> Java 버전 선택
• Dependencies에서 [ADD … CTRL + B] 버튼을 클릭해서 아래 3개를 추가합니다.
  • Spring Web
  • Lombok
  • Spring Data Redis(Access+Driver)
• 마지막으로 [GENERATE CTRL + ⏎ ] 버튼 클릭해서 압축 파일(zip)을 다운받는다.
• 스프링부트3.x 는 자바17 이상, 스프링부트 2.x는 자바11을 사용합니다.

이 프로젝트에 사용된 Lettuce, Spring, Redis 버전

• Lettuce-6.2.7
• Spring-Boot: 3.1.8, Spring: 6.0.16
• Redis-7.2.3

Class/File 구성

• Main Class: 메인 클래스
• application.properties: 센티널/레디스 서버 연결 값들
• RedisProps class: application.properties 파일을 읽어오는 클래스
• RedisConn class: 센티널/레디스 서버에 연결하는 클래스
• RedisController class: 센티널/레디스 명령 테스트 클래스
• RedisPubSub class: Pub/Sub 테스트 클래스

Main Class

package com.redisgate.redis; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class MainApplication { public static void main(String[] args) { SpringApplication.run(MainApplication.class, args); System.out.println("----- Redis Sentinel Lettuce Application 시작 -----"); } }

application.properties

# Redis Seltinel Properties redis.sentinelNodes: 192.168.56.102:7000, 192.168.56.102:7001, 192.168.56.102:7002 redis.sentinelMaster: mymaster redis.password: redisgate redis.database: 0 redis.timeout: 5s redis.connectTimeout: 5s redis.clientName: redisgate redis.readFrom: replicaPreferred #server.port: 9090 #logging.level.root: debug

RedisProps class

application.properties 파일을 읽어오는 클래스.

• sentinelNodes는 센티널 노드 주소(ip:port)를 읽어옵니다. List를 사용했습니다.
• sentinelMaster는 sentinel.conf에서 지정한 masterid를 읽어옵니다.
• password는 char[]를 사용합니다. String을 사용하면 적용 시 getPassword().toCharArray()를 사용해야 합니다.
• getReadFrom()은 readFrom 문자열을 ReadFrom 값으로 변경합니다.

package com.redisgate.redis; import io.lettuce.core.ReadFrom; import lombok.Getter; import lombok.Setter; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Configuration; import java.time.Duration; import java.util.List; @Configuration @ConfigurationProperties(prefix = "redis") @Getter @Setter public class RedisProps { private List<String> sentinelNodes; private String sentinelMaster; private char[] password; private int database; private Duration timeout; private Duration connectTimeout; private String clientName; private String readFrom; /** * 조회 명령을 복제서버에 실행하도록하는 ReadFrom * application.properties에 입력한 문자열(String)을 ReadFrom 값으로 만든다. * 자세한 설명은 아래 URL을 참고하세요. * http://redisgate.kr/redis/clients/lettuce2_readfrom.php * @return ReadFrom */ public ReadFrom getReadFrom() { return ReadFrom.valueOf(readFrom); } /** * application.properties에 입력한 문자열(String)을 리턴한다. * @return String */ public String getReadFromString() { return readFrom; } }

RedisConn class

센티널/레디스 서버에 연결합니다.
ConnectTimeout은 ClientOptions을 사용해서 설정합니다.

다음은 3종류의 connect 메서드 실행 시 센티널/레디스 서버에 실행되는 명령입니다.

• redisClient.connectSentinel() : Sentinel-1에 접속하고, 2,3에는 접속하지 않는다.
  
  Sentinel-1
      HELLO 3 SETNAME redisgate
• redisClient.connect() : 센티널에 접속해서 masterid로 마스터 주소를 얻어서 마스터에 접속한다.
  
  Sentinel-1
      HELLO 3 SETNAME redisgate
      SENTINEL get-master-addr-by-name mymaster
      closed connection
  Master
      HELLO 3 AUTH default redisgate SETNAME redisgate
• MasterReplica.connect() : 센티널에 접속해서 마스터와 복제 서버의 주소를 얻어오고 마스터와 복제 서버에 연결해본다. 센티널 서버에는 PSUBSCRIBE 명령을 실행한다.
  Sentinel-1
      HELLO 3 SETNAME redisgate
      SENTINEL master mymaster -> 마스터 서버의 주소를 얻는다.
      SENTINEL REPLICAS mymaster -> 복제 서버 주소를 얻는다.
      closed connection
      HELLO 3
      PSUBSCRIBE * -> 센티널로부터 publish msg를 받도록 등록한다.
  Sentinel-2
      HELLO 3
      PSUBSCRIBE * -> 센티널로부터 publish msg를 받도록 등록한다.
  Sentinel-3
      HELLO 3
      PSUBSCRIBE * -> 센티널로부터 publish msg를 받도록 등록한다.
  Master
      HELLO 3 AUTH default redisgate SETNAME redisgate
      CLIENT SETNAME lettuce#MasterReplicaTopologyRefresh
      PING NODES
      closed connection
  Replica-1
      HELLO 3 AUTH default redisgate SETNAME redisgate
      CLIENT SETNAME lettuce#MasterReplicaTopologyRefresh
      PING NODES
      closed connection
  Replica-2
      HELLO 3 AUTH default redisgate SETNAME redisgate
      CLIENT SETNAME lettuce#MasterReplicaTopologyRefresh
      PING NODES
      closed connection
  

package com.redisgate.redis; import io.lettuce.core.ClientOptions; import io.lettuce.core.RedisClient; import io.lettuce.core.RedisURI; import io.lettuce.core.SocketOptions; import io.lettuce.core.api.StatefulRedisConnection; import io.lettuce.core.api.sync.RedisCommands; import io.lettuce.core.codec.StringCodec; import io.lettuce.core.masterreplica.MasterReplica; import io.lettuce.core.masterreplica.StatefulRedisMasterReplicaConnection; import io.lettuce.core.pubsub.StatefulRedisPubSubConnection; import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands; import io.lettuce.core.sentinel.api.StatefulRedisSentinelConnection; import io.lettuce.core.sentinel.api.sync.RedisSentinelCommands; import lombok.Getter; import lombok.extern.slf4j.Slf4j; import org.springframework.context.annotation.Configuration; @Configuration @Getter @Slf4j public class RedisConn { private final RedisClient redisClient; private final StatefulRedisConnection<String, String> redisConnection; private final StatefulRedisSentinelConnection<String, String> sentinelConnection; private final RedisSentinelCommands<String, String> sentinelCommands; private final StatefulRedisMasterReplicaConnection<String, String> masterReplicaConnection; private final RedisCommands<String, String> redisCommands; private final RedisCommands<String, String> masterReplicaCommands; private final StatefulRedisPubSubConnection<String, String> redisPubConn; private final RedisPubSubCommands<String, String> redisPubCommands; private final StatefulRedisPubSubConnection<String, String> redisSubConn; private final RedisPubSubCommands<String, String> redisSubCommands; public RedisConn(RedisProps redisProps) throws InterruptedException { // Sentinel Connection 설정 // 첫번째 sentinelNodes를 읽어서 IP와 port로 나눈다 -> 192.168.56.102:7000 String[] node = redisProps.getSentinelNodes().get(0).split(":"); RedisURI sentinelUri = RedisURI.Builder .sentinel(node[0],Integer.parseInt(node[1]), redisProps.getSentinelMaster()) // IP, Port, MasterId 설정 .withPassword(redisProps.getPassword()) // Redis password 설정 .withDatabase(redisProps.getDatabase()) // Database 설정 .withTimeout(redisProps.getTimeout()) // Command timeout 설정 .withClientName(redisProps.getClientName()) // Client name 설정 .build(); // 나머지 Sentinel node 설정: 192.168.56.102:7001, 192.168.56.102:7002 int size = redisProps.getSentinelNodes().size(); for (int i=1; i < size; i++) { node = redisProps.getSentinelNodes().get(i).split(":"); sentinelUri.getSentinels().add(RedisURI.create(node[0],Integer.parseInt(node[1]))); } // RedisClient 생성 redisClient = RedisClient.create(sentinelUri); // connectTimeout 설정 -> ClientOptions ClientOptions.Builder clientOptions = ClientOptions.builder(); clientOptions.autoReconnect(true); // default true: 1,2,4,8,16,30초, 이후 30초마다 반복해서 재연결 시도 clientOptions.socketOptions(SocketOptions.builder().connectTimeout(redisProps.getConnectTimeout()).build()); redisClient.setOptions(clientOptions.build()); // Sentinel 연결 log.info("Sentinel 연결"); sentinelConnection = redisClient.connectSentinel(); sentinelCommands = sentinelConnection.sync(); Thread.sleep(5000); // Redis Master에 연결 log.info("Redis Master에 연결"); redisConnection = redisClient.connect(); redisCommands = redisConnection.sync(); Thread.sleep(5000); // MasterReplica 연결 log.info("MasterReplica 연결"); masterReplicaConnection = MasterReplica.connect(redisClient, StringCodec.UTF8, sentinelUri); masterReplicaConnection.setReadFrom(redisProps.getReadFrom()); masterReplicaCommands = masterReplicaConnection.sync(); Thread.sleep(5000); // Pub/Sub 연결 redisPubConn = redisClient.connectPubSub(); redisPubCommands = redisPubConn.sync(); redisSubConn = redisClient.connectPubSub(); redisSubCommands = redisSubConn.sync(); //-------------------------------------------------------------------------------- // Case1: Sentinel 서버에 password를 설정한 경우 // @SuppressWarnings("deprecation") // RedisURI sentinelUri1 = RedisURI.Builder // .sentinel("192.168.56.102",7000, "mymaster","sentinelpassword") // Sentinel password 설정 // .withPassword("redisgate".toCharArray()) // Redis password 설정 // .build(); // Case2: Redis 서버에만 password를 설정한 경우 // RedisURI sentinelUri3 = RedisURI.Builder // .sentinel("192.168.56.102",7000, "mymaster") // .withPassword("redisgate".toCharArray()) // .build(); //-------------------------------------------------------------------------------- // Connect String을 작성해서 연결하는 방법 // redis-sentinel://[[username:]password@]host1 [: port1][, host2 [:port2]][, hostN [:portN]][/ database][? [timeout=timeout[d|h|m|s|ms|us|ns]] [ &sentinelMasterId=sentinelMasterId] [&database=database] [&clientName=clientName] ] // 여기 password는 redis server password를 의미하는 것임. /* StringBuilder redisUri = new StringBuilder("redis-sentinel://" + redisProps.getPassword() + "@"); int i=0; for(String node: redisProps.getSentinelNodes()) { redisUri.append(node); // comma(,) 추가, 마지막 노드 다음에는 comma를 넣지 않는다. if (++i < redisProps.getSentinelNodes().size()) redisUri.append(","); } redisUri.append("/").append(redisProps.getDatabase()); redisUri.append("?&timeout=").append(redisProps.getTimeout()); redisUri.append("&sentinelMasterId=").append(redisProps.getSentinelMaster()); redisUri.append("&clientName=").append(redisProps.getClientName()); System.out.println("Sentinel URI: "+redisUri); RedisURI redisURI = RedisURI.create(redisUri.toString()); redisClient = RedisClient.create(redisURI); */ } }

RedisController class

센티널, 레디스 명령 테스트 클래스

1. masterid로 주소(IP:Port) 조회: SENTINEL get-master-addr-by-name masterid
   http://localhost:8080/getMasterAddrByName/mymaster
2. masterid로 마스터 정보 조회: SENTINEL MASTER masterid
   http://localhost:8080/master/mymaster
3. masterid로 복제서버 정보 조회: SENTINEL REPLICAS masterid
   http://localhost:8080/replicas/mymaster
4. ROLE: 마스터에서 실행
   http://localhost:8080/role
5. SET 키-값 저장
   http://localhost:8080/set/key01
6. GET 조회, 복제에서 읽는지 readFrom 설정 확인
   http://localhost:8080/get/key01
   GET 명령이 복제서버에 실행되는 것을 확인하기 위해서 아래와 같이 redis-cli를 실행 후 위 get 명령을 실행합니다.
   $ bin/redis-cli -p 6001 -a redisgate --stat
7. PING: 마스터에서 실행
   http://localhost:8080/ping

package com.redisgate.redis; import io.lettuce.core.api.sync.RedisCommands; import io.lettuce.core.sentinel.api.sync.RedisSentinelCommands; import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import java.util.List; import java.util.Map; @RestController @Slf4j public class RedisController { private final RedisSentinelCommands<String, String> sentinelCommands; private final RedisCommands<String, String> redisCommands; private final RedisCommands<String, String> masterReplicaCommands; public RedisController(RedisConn redisConn) { sentinelCommands = redisConn.getSentinelCommands(); redisCommands = redisConn.getRedisCommands(); masterReplicaCommands = redisConn.getMasterReplicaCommands(); } // 예제 1) SENTINEL get-master-addr-by-name masterid // masterid로 주소(IP:Port)를 조회한다. // http://localhost:8080/getMasterAddrByName/mymaster @GetMapping("/getMasterAddrByName/{masterid}") public String getMasterAddrByName(@PathVariable("masterid") String masterid) { String msg = "예제 1) getMasterAddrByName -> "; // Sentinel 서버에 접속해서 명령 실행 String result = sentinelCommands.getMasterAddrByName(masterid).toString(); msg += result; System.out.println(msg); return msg; } // 예제 2) SENTINEL MASTER masterid // masterid로 마스터 정보를 조회한다. // http://localhost:8080/master/mymaster @GetMapping("/master/{masterid}") public String master(@PathVariable("masterid") String masterid) { String msg = "예제 2) MASTER -> "; // Sentinel 서버에 접속해서 명령 실행 Map<String,String> result = sentinelCommands.master(masterid); msg += result; System.out.println(msg); return msg; } // 예제 3) SENTINEL REPLICAS masterid // masterid로 마스터 정보를 조회한다. // http://localhost:8080/replicas/mymaster @GetMapping("/replicas/{masterid}") public String replicas(@PathVariable("masterid") String masterid) { String msg = "예제 3) REPLICAS -> "; // Sentinel 서버에 접속해서 명령 실행 List<Map<String,String>> result = sentinelCommands.replicas(masterid); msg += result; System.out.println(msg); return msg; } // 예제 4) ROLE -> 마스터에서 실행된다. // ROLE // http://localhost:8080/role @GetMapping("/role") public String role() { String msg = "예제 4) ROLE -> "; List<Object> result = redisCommands.role(); msg += result; System.out.println(msg); return msg; } // 예제 5) SET: 키-값 저장 // SET key value [NX|XX] [EX 초] [PX 밀리초] [EXAT timestamp] [PXAT milliseconds-timestamp] [KEEPTTL] [GET] // http://localhost:8080/set/key01 @GetMapping("/set/{key}") public String set(@PathVariable("key") String key) { String msg = "예제 5) SET -> "; String result = masterReplicaCommands.set(key,"value-"+key); msg += result; System.out.println(msg); return msg; } // 예제 6) GET: 조회, 복제에서 읽는지 readFrom 설정 확인 // $ bin/redis-cli -p 6000 -a redisgate --stat // $ bin/redis-cli -p 6001 -a redisgate --stat // $ bin/redis-cli -p 6002 -a redisgate --stat // GET key // http://localhost:8080/get/key01 @GetMapping("/get/{key}") public String get(@PathVariable("key") String key) { String msg = "예제 6) GET -> "; int count = 10000; // 1만번 실행 for (int i=0; i<count; i++ ) { masterReplicaCommands.get(key); } msg += count; System.out.println(msg); return msg; } // 예제 7) PING -> 마스터에서 실행된다. // PING // http://localhost:8080/ping @GetMapping("/ping") public String ping() { String msg = "예제 7) PING -> "; String result = masterReplicaCommands.ping(); msg += result; System.out.println(msg); return msg; } }

RedisPubSub class

Publish/Subscribe 테스트 클래스

1. PubSub Connection에 Listener를 등록
   http://localhost:8080/pubsubAddListener
2. Subscribe 테스트
   http://localhost:8080/subscribe/ch01
3. Publish 테스트
   http://localhost:8080/publish/ch01:Hello

package com.redisgate.redis; import io.lettuce.core.pubsub.RedisPubSubAdapter; import io.lettuce.core.pubsub.StatefulRedisPubSubConnection; import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands; import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; @RestController @Slf4j public class RedisPubSub { private final RedisPubSubCommands<String, String> redisPubCommands; private final StatefulRedisPubSubConnection<String, String> redisSubConn; private final RedisPubSubCommands<String, String> redisSubCommands; public RedisPubSub(RedisConn redisConn) { // Publish commands redisPubCommands = redisConn.getRedisPubConn().sync(); // Subscribe commands redisSubConn = redisConn.getRedisSubConn(); redisSubCommands = redisConn.getRedisSubConn().sync(); } // PubSub Connection에 Listener를 등록한다. // 여기서 subscribe 한다. // http://localhost:8080/pubsubAddListener @GetMapping("/pubsubAddListener") public String pubsubAddListener() { // PubSub 메시지 수신 redisSubConn.addListener(new RedisPubSubAdapter<String, String>() { // 이 메서드는 Publish 명령 실행 시 실행된다. // Channel으로 수신한다. @Override public void message(String channel, String message) { System.out.println("Subscribe(channel) "+channel+" "+message); } // 이 메서드는 Publish 명령 실행 시 실행된다. // Pattern으로 수신한다. @Override public void message(String pattern, String channel, String message) { System.out.println("Subscribe(pattern) "+pattern+" "+channel+" "+message); } }); String msg = "OK - pubsubAddListener"; System.out.println(msg); return msg; } // Sync Subscribe // SUBSCRIBE channel [channel ...] // http://localhost:8080/subscribe/ch01 @GetMapping("/subscribe/{channel}") public String subscribe(@PathVariable("channel") String channel) { try { redisSubCommands.subscribe(channel); } catch (Exception e) { System.out.println(e.getMessage()); return "Error - subscribe "+channel; } return "OK - subscribe "+channel; } /** * Publish channel message * @param channelMsg channel:message로 구성됩니다. * @return "Publish channel message" */ // PUBLISH channel message // http://localhost:8080/publish/ch01:Hello @GetMapping("/publish/{channelMsg}") public String publish(@PathVariable("channelMsg") String channelMsg) { String[] msg = channelMsg.split(":"); String result = "Publish "+msg[0]+" "+msg[1]; System.out.println(result); Long num = redisPubCommands.publish(msg[0], msg[1]); return result+" -> "+num; } }