Redis-Sentinel Java App on Kubernetes ①

Overview

Java (Spring) app for Redis-Sentinel

We write and test a Java app for Redis-Sentinel running as Kubernetes Pods.

Java 21
Spring Boot 3.4.3
Redis 8.8.2 🔗 Use the Redis-Sentinel we built here.
Develop the Java (Spring) app in IntelliJ on a PC (laptop)
Server: Linux (Rocky 9.6), Redis-Sentinel already running

Java Spring Project

Create a Java Spring project

Create a Java Spring project and write the application.
URL to create a Java Spring project with Spring Initializr: start.spring.io

Project: Gradle-Groovy
Language: Java
Spring Boot: 4.1.0 ➡📍Change it to 3.4.3 in IntelliJ build.gradle.
Project Metadata
- Group: com.redisgate
- Artifact: KubeRedis -> project name; the zip file uses this name
- Package name: com.redisgate.KubeRedis -> Package Name
- Packaging: Jar
- Configuration: Properties
- Java: 21 -> choose Java version
In Dependencies, click [ADD … CTRL + B] and add the three items below.
- Spring Web
- Lombok
- Spring Data Redis(Access+Driver)
Finally click [GENERATE CTRL + ⏎ ] and download the zip.

💾 build.gradle file

Change 'org.springframework.boot' version '4.1.0' -> '3.4.3'
Change 'webmvc' -> 'web' in two places
Add these two libraries
implementation 'org.springframework.retry:spring-retry' // add Spring Retry
implementation 'org.springframework:spring-aspects' // AOP support
Click the elephant (Gradle) icon at the top right -> click the first menu icon 'Reload All Gradle Projects'

📄 build.gradle

plugins {
	id 'java'
	id 'org.springframework.boot' version '3.4.3'	📍
	id 'io.spring.dependency-management' version '1.1.7'
}
group = 'com.redisgate'
version = '0.0.1-SNAPSHOT'
java {
	toolchain {
		languageVersion = JavaLanguageVersion.of(21)
	}
}
repositories {
	mavenCentral()
}
dependencies {
	implementation 'org.springframework.retry:spring-retry' // add Spring Retry 📍
	implementation 'org.springframework:spring-aspects' // AOP support 📍
	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
	implementation 'org.springframework.boot:spring-boot-starter-web'  📍
	compileOnly 'org.projectlombok:lombok'
	annotationProcessor 'org.projectlombok:lombok'
	testImplementation 'org.springframework.boot:spring-boot-starter-data-redis-test'
	testImplementation 'org.springframework.boot:spring-boot-starter-web-test'  📍
	testCompileOnly 'org.projectlombok:lombok'
	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
	testAnnotationProcessor 'org.projectlombok:lombok'
}
tasks.named('test') {
	useJUnitPlatform()
}

💾 Dockerfile

📄 Dockerfile

# 1. Java 21 runtime (lightweight Alpine Linux)
FROM eclipse-temurin:21-jre-alpine
# 2. Working directory inside the container (created automatically)
WORKDIR /app
# 3. Copy the built JAR into the container as app.jar
COPY *.jar app.jar
# 4. Run the Spring Boot app when the container starts
ENTRYPOINT ["java", "-jar", "app.jar"]

💾 application.properties file

List sentinel-0 through sentinel-2 in 'spring.data.redis.sentinel.nodes' as shown below.

📄 application.properties

spring.application.name=KubeRedis
# JVM Heap / CPU memory note: each thread allocates about 1MB of stack (`-Xss`).
# With 'threads.max=600', threads alone need about 600MB,
# so give the K8s Pod a generous memory Limit (e.g. `2Gi`+) and CPU Request.
# Tomcat max worker threads (500–800)
server.tomcat.threads.max=600
# queue size when max threads are exceeded
server.tomcat.accept-count=1000
# max concurrent accepted socket connections
server.tomcat.max-connections=8192

# Redis Sentinel Config 📍
spring.data.redis.sentinel.nodes=sentinel-0.sentinel-service.default.svc.cluster.local:28504,\
  sentinel-1.sentinel-service.default.svc.cluster.local:28504,\
  sentinel-2.sentinel-service.default.svc.cluster.local:28504
spring.data.redis.sentinel.master=mymaster
spring.data.redis.database=0
# 👨‍💻 password, clientName: Set it up according to the project.
spring.data.redis.sentinel.password=redisgate
spring.data.redis.password=redisgate
spring.data.redis.clientName=redisgate
# 🔗 ref: https://redisgate.kr/redis/clients/springboot_readfrom.php
# Recommended: replicaPreferred -> (1) Replica -> (2) Master
spring.data.redis.readFrom=replicaPreferred
# 📝 NOTE: The 'connect-timeout' and 'timeout' configurations are explicitly
# defined in RedisSentinelConfig.java via LettuceClientConfigurationBuilderCustomizer.
# To change these timeout values, please update RedisSentinelConfig.java directly.
#spring.data.redis.connect-timeout=1s ➡ set in code
#spring.data.redis.timeout=1s ➡ set in code

💾 KubeRedisApplication.java

📄 KubeRedisApplication.java

package com.redisgate.KubeRedis;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.retry.annotation.EnableRetry;

@SpringBootApplication
@EnableScheduling // 📍 required: enable scheduler
@EnableRetry // 📍 enable Spring Retry
@Slf4j
public class KubeRedisApplication {
	public static void main(String[] args) {
		SpringApplication.run(KubeRedisApplication.class, args);
		log.info("----- Kubernetes Redis Spring (Spring Boot 3.4.3)/Lettuce, Java 21 App ------");
	}
}

💾 RedisSentinelConfig.java

Key settings are marked with ✅ or 📍

📄 RedisSentinelConfig.java

package com.redisgate.KubeRedis;

import io.lettuce.core.ClientOptions;
import io.lettuce.core.SocketOptions;
import io.lettuce.core.TimeoutOptions;
import org.springframework.boot.autoconfigure.data.redis.LettuceClientConfigurationBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.Duration;

@Configuration
public class RedisSentinelConfig {

    @Bean
    public LettuceClientConfigurationBuilderCustomizer lettuceCustomizer() {
        return builder -> builder
                // 1. Cap command timeout at 1s (avoid waiting forever during failover)
                .commandTimeout(Duration.ofSeconds(1)) ✅
                // 2. Lettuce client options
                .clientOptions(ClientOptions.builder()
                        // Fail immediately if a command is sent to an old master in replica (readonly) state
                        .disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
                        // Force command response timeout
                        .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(1))) ✅
                        // Socket connect timeout 1s
                        .socketOptions(SocketOptions.builder()
                                .connectTimeout(Duration.ofSeconds(1)) 📍
                                .build())
                        .build());
    }
}

✅ How do commandTimeout() and timeoutOptions() differ? ▼

1. Spring setting: commandTimeout(Duration.ofSeconds(1))
- Where: `LettuceClientConfigurationBuilder` (Spring Data Redis upper layer)
- Role: the default synchronous command timeout Spring Data Redis uses when sending commands through the Lettuce client.
- Behavior: with `RedisTemplate` or `StringRedisTemplate`, if Redis does not respond within 1s, it throws `QueryTimeoutException` or `RedisCommandTimeoutException`.
- Notes: this is the standard default. If no TimeoutOptions are defined, Lettuce uses this value internally as the default timeout and cancels the command.
2. Lettuce setting: timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(1)))
- Where: `ClientOptions` (native Lettuce driver option)
- Role: fine-grained control of each command's lifecycle and timeout strategy inside the Lettuce engine.
- Behavior: in Lettuce's async/reactive pipeline, after a command is sent, if there is no response for 1s (or the network is delayed), a custom timeout scheduler cancels the command.
- Notes:
  - Finer failure control: combined with `disconnectedBehavior(REJECT_COMMANDS)`, commands waiting in the queue while disconnected or reconnecting are not stuck forever; they are cancelled after 1s.
  - Dynamic timeout: `TimeoutOptions` can use not only a single `Duration` but also a `TimeoutSource` that varies by command type (READ/WRITE) or situation. (e.g. `GET` 500ms, `FLUSHALL` 5s)

💾 RedisOperationService.java

📄 RedisOperationService.java

package com.redisgate.KubeRedis;

import lombok.RequiredArgsConstructor;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class RedisOperationService {

    private final StringRedisTemplate redisTemplate;

    // 📍 On failure, retry up to 5 times at 1s intervals
    @Retryable(
            retryFor = { Exception.class },
            maxAttempts = 5,
            backoff = @Backoff(delay = 1000)
    )
    public String executeSetAndGet(String key, String value) {
        // 1. Redis SET
        redisTemplate.opsForValue().set(key, value);
        // 2. Redis GET
        return redisTemplate.opsForValue().get(key);
    }
}

💾 RedisFailoverTestService.java

📄 RedisFailoverTestService.java

package com.redisgate.KubeRedis;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.util.concurrent.atomic.AtomicLong;

@Service
@RequiredArgsConstructor
@Slf4j
public class RedisFailoverTestService {
    private final RedisOperationService redisOperationService; // 📍 inject retry service
    private final AtomicLong counter = new AtomicLong(1);

    @Scheduled(fixedRate = 100)
    public void runFailoverTest() {
        long seq = counter.getAndIncrement();
        String key = String.format("keyA-%08d", seq);
        String value = String.format("valueA-%08d", seq);

        try {
            // 📍 call method that includes retry
            String retrievedValue = redisOperationService.executeSetAndGet(key, value);

            if (value.equals(retrievedValue)) {
                if (seq % 10 == 0) {
                    log.info(" [SUCCESS] Key: {} -> Normal operation in progress...", key);
                }
            } else {
                log.warn(" [MISMATCH ERROR] Key: {}, Expected: {}, Got: {}", key, value, retrievedValue);
            }

        } catch (Exception e) {
            // 📍 error log only if it still fails after 5 retries (5s)
            log.error(" [FAIL] Key: {} -> Error after retries: {}", key, e.getMessage());
        }
    }
}

App Docker image build and YAML

Build the App Docker image

1) Compile (make)
IntelliJ [KubeRedis]> ./gradlew clean bootJar
2) Copy 'KubeRedis-0.0.1-SNAPSHOT.jar' and 'Dockerfile' to the server (~/kube/app/sentinel/).
app\IntelliJ\workspace\KubeRedis\build\libs\KubeRedis-0.0.1-SNAPSHOT.jar
app\IntelliJ\workspace\KubeRedis\Dockerfile
3) Build the Docker image (on the server)
[~/kube/app/sentinel/] $ docker build -t spring-redis-sentinel-app:1.0 .
4) Import the image into k3s (containerd)
[~/kube/app/sentinel/] $ docker save spring-redis-sentinel-app:1.0 | sudo k3s ctr images import -

💾 app-deployment.yaml

Write this under "~/kube/app/sentinel" on the server

📄 app-deployment.yaml

  1	apiVersion: apps/v1
  2	kind: Deployment
  3	metadata:
  4	  name: spring-redis-sentinel-app
  5	spec:
  6	  replicas: 1
  7	  selector:
  8	    matchLabels:
  9	      app: spring-redis-sentinel-app
 10	  template:
 11	    metadata:
 12	      labels:
 13	        app: spring-redis-sentinel-app
 14	    spec:
 15	      containers:
 16	      - name: spring-app
 17	        image: spring-redis-sentinel-app:1.0
 18	        imagePullPolicy: IfNotPresent   # 📍 prefer the image imported into local k3s
 19	        ports:
 20	        - containerPort: 8080
 21	        env:
 22	        - name: TZ
 23	          value: Asia/Seoul             # 📍 timezone env var
 24	        volumeMounts:
 25	        - name: host-time
 26	          mountPath: /etc/localtime     # 📍 mount Host OS time file
 27	          readOnly: true
 28	      volumes:
 29	      - name: host-time
 30	        hostPath:
 31	          path: /etc/localtime          # 📍 Host OS /etc/localtime path
 32	---
 33	apiVersion: v1
 34	kind: Service
 35	metadata:
 36	  name: spring-redis-sentinel-app-service
 37	spec:
 38	  type: NodePort    # 📍 for external test access (browser/Postman)
 39	  ports:
 40	  - port: 8080
 41	    targetPort: 8080
 42	    nodePort: 30080   # reachable at Rocky9 IP:30080
 43	  selector:
 44	    app: spring-redis-sentinel-app

➡ The Java app and Pod YAML are ready. Next: failover test.

<< K8s Redis-Sentinel Test ③	K8s Redis-Sentinel App ② >>

Email 답글이 올라오면 이메일로 알려드리겠습니다.