Spring Boot + CRaC: Coordinated Restore at Checkpoint

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- CRaC API — provided at runtime by the CRaC JDK; scope=provided avoids shipping it -->
<dependency>
  <groupId>io.github.crac</groupId>
  <artifactId>org-crac</artifactId>
  <version>0.1.3</version>
</dependency>

# Download Azul Zulu JDK with CRaC support (Linux x64)
curl -L -o zulu-crac.tar.gz \
  https://cdn.azul.com/zulu/bin/zulu21.36.17-ca-crac-jdk21.0.4-linux_x64.tar.gz
tar xzf zulu-crac.tar.gz

# Verify CRaC support
./zulu21-crac/bin/java -XX:CRaCCheckpointTo=/tmp/test -version

# Run the application with checkpoint output directory specified
java -XX:CRaCCheckpointTo=/path/to/checkpoint \
     -jar target/myapp.jar &

# Wait for application to fully start and reach steady state
sleep 10

# Trigger checkpoint externally using jcmd
jcmd $(jps -q) JDK.checkpoint

# The JVM writes checkpoint files and exits
# /path/to/checkpoint/ now contains core image files

// Programmatic checkpoint — trigger after readiness probe passes
@SpringBootApplication
public class MyApp implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        // App is fully initialised here — good time to checkpoint
        if (Arrays.asList(args).contains("--checkpoint")) {
            log.info("Taking CRaC checkpoint...");
            Core.getGlobalContext().checkpointRestore();
            // Execution resumes here after restore
            log.info("Restored from checkpoint!");
        }
    }
}

# Restore from checkpoint — instant startup
java -XX:CRaCRestoreFrom=/path/to/checkpoint

import org.crac.Context;
import org.crac.Core;
import org.crac.Resource;

@Component
public class RedisConnectionHook implements Resource {

    private final RedisConnectionFactory connectionFactory;

    public RedisConnectionHook(RedisConnectionFactory connectionFactory) {
        this.connectionFactory = connectionFactory;
        // Register with the global CRaC context
        Core.getGlobalContext().register(this);
    }

    @Override
    public void beforeCheckpoint(Context<? extends Resource> context) {
        // Called just before checkpoint — close connections so they aren't captured in image
        log.info("CRaC beforeCheckpoint: closing Redis connections");
        connectionFactory.destroy();   // returns connections to pool and closes idle ones
    }

    @Override
    public void afterRestore(Context<? extends Resource> context) {
        // Called immediately after restore — re-establish connections with fresh sockets
        log.info("CRaC afterRestore: reconnecting to Redis");
        connectionFactory.getConnection();   // triggers pool initialisation
    }
}

# application.yml — no CRaC-specific properties needed for built-in components
# Spring Boot detects the CRaC JDK automatically via Runtime.version()
spring:
  datasource:
    hikari:
      max-lifetime: 1800000    # 30 min — ensure connections refresh before pool cycle
  lifecycle:
    timeout-per-shutdown-phase: 30s

# Stage 1: build the JAR
FROM maven:3.9-eclipse-temurin-21 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline -q
COPY src ./src
RUN mvn package -DskipTests -q

# Stage 2: create CRaC checkpoint inside a privileged container
FROM azul/zulu-openjdk-debian:21-crac AS checkpoint
WORKDIR /app
COPY --from=build /app/target/myapp.jar .

# Run app, wait for it to start, trigger checkpoint, capture image
RUN java -XX:CRaCCheckpointTo=/checkpoint -jar myapp.jar & \
    sleep 15 && \
    jcmd $(jps -q -J-XX:+UseG1GC myapp) JDK.checkpoint && \
    wait

# Stage 3: lean runtime image with checkpoint baked in
FROM azul/zulu-openjdk-debian:21-crac
WORKDIR /app
COPY --from=checkpoint /checkpoint /checkpoint
CMD ["java", "-XX:CRaCRestoreFrom=/checkpoint"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
spec:
  replicas: 3
  template:
    spec:
      containers:
        - name: product-service
          image: myregistry/product-service:crac-1.0
          # No privileged: true needed for restore — only for checkpoint creation
          resources:
            requests:
              memory: "512Mi"
              cpu: "250m"
            limits:
              memory: "1Gi"
              cpu: "1"
          readinessProbe:
            httpGet:
              path: /actuator/health/readiness
              port: 8080
            initialDelaySeconds: 1    # CRaC: ready almost immediately
            periodSeconds: 2
          livenessProbe:
            httpGet:
              path: /actuator/health/liveness
              port: 8080
            initialDelaySeconds: 2
            periodSeconds: 10

---
# HPA — CRaC makes scale-out fast enough for bursty traffic
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: product-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: product-service
  minReplicas: 2
  maxReplicas: 20
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 60