Rolling Deployment in Microservices: Update Without Taking the Service Down

spec:
  replicas: 4
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1        # default 25%, rounded up
      maxUnavailable: 0  # default 25%, rounded down

public class RollingUpdateDemo {

    // Kubernetes rounds maxSurge up and maxUnavailable down when they are percentages
    static int surgeFromPercent(int replicas, int percent) { return (int) Math.ceil(replicas * percent / 100.0); }
    static int unavailableFromPercent(int replicas, int percent) { return replicas * percent / 100; }

    static void rollOut(String title, int replicas, int maxSurge, int maxUnavailable) {
        int minAvailable = replicas - maxUnavailable, maxTotal = replicas + maxSurge;
        System.out.printf("%s (maxSurge=%d, maxUnavailable=%d): always >= %d ready, never > %d pods%n",
                title, maxSurge, maxUnavailable, minAvailable, maxTotal);
        int oldPods = replicas, newReady = 0, newStarting = 0;
        for (int step = 1; newReady < replicas || oldPods > 0; step++) {
            newReady += newStarting;            // pods started last step pass their readiness probe now
            newStarting = 0;
            int removable = Math.max(0, oldPods + newReady - minAvailable);
            int removed = Math.min(removable, oldPods);
            oldPods -= removed;                 // old pods get SIGTERM and leave the load balancer
            int room = maxTotal - (oldPods + newReady);
            newStarting = Math.max(0, Math.min(room, replicas - newReady));
            System.out.printf("  step %d: v1 ready=%d  v2 ready=%d  v2 starting=%d  (stopped %d v1)%n",
                    step, oldPods, newReady, newStarting, removed);
        }
    }

    public static void main(String[] args) {
        rollOut("Defaults for 4 replicas, 25%/25%", 4, surgeFromPercent(4, 25), unavailableFromPercent(4, 25));
        rollOut("Zero-downtime setting", 4, 1, 0);
    }
}

Defaults for 4 replicas, 25%/25% (maxSurge=1, maxUnavailable=1): always >= 3 ready, never > 5 pods
  step 1: v1 ready=3  v2 ready=0  v2 starting=2  (stopped 1 v1)
  step 2: v1 ready=1  v2 ready=2  v2 starting=2  (stopped 2 v1)
  step 3: v1 ready=0  v2 ready=4  v2 starting=0  (stopped 1 v1)
Zero-downtime setting (maxSurge=1, maxUnavailable=0): always >= 4 ready, never > 5 pods
  step 1: v1 ready=4  v2 ready=0  v2 starting=1  (stopped 0 v1)
  step 2: v1 ready=3  v2 ready=1  v2 starting=1  (stopped 1 v1)
  step 3: v1 ready=2  v2 ready=2  v2 starting=1  (stopped 1 v1)
  step 4: v1 ready=1  v2 ready=3  v2 starting=1  (stopped 1 v1)
  step 5: v1 ready=0  v2 ready=4  v2 starting=0  (stopped 1 v1)

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

public class MixedVersionsDemo {

    // A shared store (database or cache) that every pod reads and writes, holding JSON-like maps
    static final Map<String, Map<String, String>> store = new HashMap<>();

    interface Pod { void save(String id, int cents); int read(String id); }

    static Pod v1() {
        return new Pod() {
            public void save(String id, int cents) { store.put(id, Map.of("price", String.valueOf(cents / 100.0))); }
            public int read(String id) { // throws if the field is missing
                return (int) Math.round(Double.parseDouble(store.get(id).get("price")) * 100);
            }
        };
    }

    // v2, breaking change: renames "price" (euros) to "priceCents"
    static Pod v2Breaking() {
        return new Pod() {
            public void save(String id, int cents) { store.put(id, Map.of("priceCents", String.valueOf(cents))); }
            public int read(String id) { return Integer.parseInt(store.get(id).get("priceCents")); }
        };
    }

    // v2, compatible ("expand" step): writes both fields, reads whichever exists
    static Pod v2Compatible() {
        return new Pod() {
            public void save(String id, int cents) {
                store.put(id, Map.of("priceCents", String.valueOf(cents), "price", String.valueOf(cents / 100.0)));
            }
            public int read(String id) {
                Map<String, String> row = store.get(id);
                return row.containsKey("priceCents") ? Integer.parseInt(row.get("priceCents"))
                        : (int) Math.round(Double.parseDouble(row.get("price")) * 100);
            }
        };
    }

    // Halfway through the rollout: 2 old pods and 2 new pods behind a load balancer
    static int errorsDuringRollout(Pod newPod) {
        store.clear();
        List<Pod> pods = List.of(v1(), v1(), newPod, newPod);
        Random balancer = new Random(42); // seeded, so every run picks the same pods
        int errors = 0;
        for (int order = 1; order <= 100; order++) {
            String id = "ORD-" + order;
            Pod writer = pods.get(balancer.nextInt(pods.size())); // "create order" lands on any pod
            Pod reader = pods.get(balancer.nextInt(pods.size())); // "show order" may land on another
            writer.save(id, 1999);
            try {
                if (reader.read(id) != 1999) errors++;
            } catch (RuntimeException e) {
                errors++;                                    // missing field: NumberFormatException or NPE
            }
        }
        return errors;
    }

    public static void main(String[] args) {
        System.out.println("Breaking v2:   " + errorsDuringRollout(v2Breaking()) + " of 100 orders failed to load");
        System.out.println("Compatible v2: " + errorsDuringRollout(v2Compatible()) + " of 100 orders failed to load");
    }
}

Breaking v2:   58 of 100 orders failed to load
Compatible v2: 0 of 100 orders failed to load

import com.sun.net.httpserver.HttpServer;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;

public class GracefulShutdownDemo {

    // One "pod": a server whose /checkout request takes 800 ms
    static int run(String title, int drainSeconds) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress("localhost", 0), 0);
        server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
        server.createContext("/checkout", exchange -> {
            try { Thread.sleep(800); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            byte[] body = "paid".getBytes();
            exchange.sendResponseHeaders(200, body.length);
            exchange.getResponseBody().write(body);
            exchange.close();
        });
        server.start();

        HttpClient client = HttpClient.newHttpClient();
        URI uri = URI.create("http://localhost:" + server.getAddress().getPort() + "/checkout");
        List<CompletableFuture<String>> inFlight = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            inFlight.add(client.sendAsync(HttpRequest.newBuilder(uri).build(), HttpResponse.BodyHandlers.ofString())
                    .thenApply(HttpResponse::body)
                    .exceptionally(e -> "failed"));
        }
        Thread.sleep(200);         // the requests are now being processed
        server.stop(drainSeconds); // "SIGTERM": stop accepting, then wait up to drainSeconds for running requests
        int ok = 0;
        for (var f : inFlight) if (f.join().equals("paid")) ok++;
        System.out.println(title + ok + " of 3 in-flight checkouts completed");
        return ok;
    }

    public static void main(String[] args) throws Exception {
        run("Stop immediately:  ", 0);
        run("Drain for 5 s:     ", 5);
    }
}

Stop immediately:  0 of 3 in-flight checkouts completed
Drain for 5 s:     3 of 3 in-flight checkouts completed