google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
Pod Disruption Budget in Java: Complete Guide
awiskar acharya
November 18, 2025
9:37 am

Introduction

Pod Disruption Budget (PDB) is a Kubernetes resource that limits the number of concurrent disruptions to your application pods during voluntary disruptions like node drains, cluster upgrades, or pod evictions. This ensures high availability and prevents simultaneous downtime of critical application components.

PDB Concepts

Key PDB Parameters:

  • minAvailable: Minimum number of pods that must be available
  • maxUnavailable: Maximum number of pods that can be unavailable
  • selector: Label selector to identify protected pods

Fabric8 Kubernetes Client Implementation

1. Dependencies

<dependencies> <dependency> <groupId>io.fabric8</groupId> <artifactId>kubernetes-client</artifactId> <version>6.9.2</version> </dependency> <dependency> <groupId>io.fabric8</groupId> <artifactId>kubernetes-model</artifactId> <version>6.9.2</version> </dependency> </dependencies>

2. Basic PDB Service

package com.example.k8s.pdb; import io.fabric8.kubernetes.api.model.policy.v1.PodDisruptionBudget; import io.fabric8.kubernetes.api.model.policy.v1.PodDisruptionBudgetBuilder; import io.fabric8.kubernetes.api.model.policy.v1.PodDisruptionBudgetSpec; import io.fabric8.kubernetes.api.model.policy.v1.PodDisruptionBudgetSpecBuilder; import io.fabric8.kubernetes.client.KubernetesClient; import io.fabric8.kubernetes.client.KubernetesClientException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Service; import java.util.Map; import java.util.Optional; @Service public class PodDisruptionBudgetService { private static final Logger log = LoggerFactory.getLogger(PodDisruptionBudgetService.class); private final KubernetesClient kubernetesClient; private final String namespace; public PodDisruptionBudgetService(KubernetesClient kubernetesClient) { this.kubernetesClient = kubernetesClient; this.namespace = kubernetesClient.getNamespace(); // Uses current context namespace } public PodDisruptionBudget createMinAvailablePDB(String name, Map<String, String> selectorLabels, int minAvailable) { log.info("Creating PDB '{}' with minAvailable: {}", name, minAvailable); PodDisruptionBudget pdb = new PodDisruptionBudgetBuilder() .withNewMetadata() .withName(name) .withNamespace(namespace) .addToLabels("app", name) .addToLabels("managed-by", "java-application") .endMetadata() .withNewSpec() .withMinAvailable(minAvailable) .withNewSelector() .withMatchLabels(selectorLabels) .endSelector() .endSpec() .build(); return kubernetesClient.policy().v1().podDisruptionBudget() .inNamespace(namespace) .resource(pdb) .create(); } public PodDisruptionBudget createMaxUnavailablePDB(String name, Map<String, String> selectorLabels, int maxUnavailable) { log.info("Creating PDB '{}' with maxUnavailable: {}", name, maxUnavailable); PodDisruptionBudget pdb = new PodDisruptionBudgetBuilder() .withNewMetadata() .withName(name) .withNamespace(namespace) .addToLabels("app", name) .endMetadata() .withNewSpec() .withMaxUnavailable(maxUnavailable) .withNewSelector() .withMatchLabels(selectorLabels) .endSelector() .endSpec() .build(); return kubernetesClient.policy().v1().podDisruptionBudget() .inNamespace(namespace) .resource(pdb) .create(); } public PodDisruptionBudget createPercentagePDB(String name, Map<String, String> selectorLabels, String maxUnavailablePercentage) { log.info("Creating PDB '{}' with maxUnavailable: {}", name, maxUnavailablePercentage); PodDisruptionBudget pdb = new PodDisruptionBudgetBuilder() .withNewMetadata() .withName(name) .withNamespace(namespace) .endMetadata() .withNewSpec() .withMaxUnavailable(maxUnavailablePercentage) // e.g., "50%" .withNewSelector() .withMatchLabels(selectorLabels) .endSelector() .endSpec() .build(); return kubernetesClient.policy().v1().podDisruptionBudget() .inNamespace(namespace) .resource(pdb) .create(); } }

3. Advanced PDB Manager

package com.example.k8s.pdb; import io.fabric8.kubernetes.api.model.policy.v1.PodDisruptionBudget; import io.fabric8.kubernetes.api.model.policy.v1.PodDisruptionBudgetList; import io.fabric8.kubernetes.client.KubernetesClient; import io.fabric8.kubernetes.client.KubernetesClientException; import org.springframework.stereotype.Component; import java.util.List; import java.util.Map; import java.util.Optional; @Component public class PDBManager { private final KubernetesClient client; private final String namespace; public PDBManager(KubernetesClient client) { this.client = client; this.namespace = client.getNamespace(); } public Optional<PodDisruptionBudget> getPDB(String name) { try { PodDisruptionBudget pdb = client.policy().v1().podDisruptionBudget() .inNamespace(namespace) .withName(name) .get(); return Optional.ofNullable(pdb); } catch (KubernetesClientException e) { log.error("Error retrieving PDB: {}", name, e); return Optional.empty(); } } public List<PodDisruptionBudget> listPDBs() { PodDisruptionBudgetList pdbList = client.policy().v1().podDisruptionBudget() .inNamespace(namespace) .list(); return pdbList.getItems(); } public List<PodDisruptionBudget> listPDBsByLabels(Map<String, String> labels) { PodDisruptionBudgetList pdbList = client.policy().v1().podDisruptionBudget() .inNamespace(namespace) .withLabels(labels) .list(); return pdbList.getItems(); } public boolean deletePDB(String name) { try { return client.policy().v1().podDisruptionBudget() .inNamespace(namespace) .withName(name) .delete(); } catch (KubernetesClientException e) { log.error("Error deleting PDB: {}", name, e); return false; } } public PodDisruptionBudget updatePDB(String name, PodDisruptionBudget updatedPDB) { return client.policy().v1().podDisruptionBudget() .inNamespace(namespace) .withName(name) .replace(updatedPDB); } public PodDisruptionBudget createOrUpdatePDB(PodDisruptionBudget pdb) { String name = pdb.getMetadata().getName(); if (getPDB(name).isPresent()) { return updatePDB(name, pdb); } else { return client.policy().v1().podDisruptionBudget() .inNamespace(namespace) .resource(pdb) .create(); } } }

4. PDB Factory for Common Patterns

package com.example.k8s.pdb; import io.fabric8.kubernetes.api.model.policy.v1.PodDisruptionBudget; import io.fabric8.kubernetes.api.model.policy.v1.PodDisruptionBudgetBuilder; import org.springframework.stereotype.Component; import java.util.Map; @Component public class PDBFactory { public PodDisruptionBudget createHighAvailabilityPDB(String appName, Map<String, String> selectorLabels, int totalReplicas) { // For high availability, allow only 1 pod to be disrupted at a time int maxUnavailable = Math.max(1, totalReplicas / 4); // 25% or 1, whichever is larger return new PodDisruptionBudgetBuilder() .withNewMetadata() .withName(appName + "-pdb") .addToLabels("app", appName) .addToLabels("pdb-type", "high-availability") .endMetadata() .withNewSpec() .withMaxUnavailable(maxUnavailable) .withNewSelector() .withMatchLabels(selectorLabels) .endSelector() .endSpec() .build(); } public PodDisruptionBudget createCriticalServicePDB(String appName, Map<String, String> selectorLabels, int totalReplicas) { // For critical services, require at least 50% availability int minAvailable = (int) Math.ceil(totalReplicas * 0.5); return new PodDisruptionBudgetBuilder() .withNewMetadata() .withName(appName + "-critical-pdb") .addToLabels("app", appName) .addToLabels("pdb-type", "critical") .endMetadata() .withNewSpec() .withMinAvailable(minAvailable) .withNewSelector() .withMatchLabels(selectorLabels) .endSelector() .endSpec() .build(); } public PodDisruptionBudget createSingleInstancePDB(String appName, Map<String, String> selectorLabels) { // For single-instance applications, prevent any disruption return new PodDisruptionBudgetBuilder() .withNewMetadata() .withName(appName + "-pdb") .addToLabels("app", appName) .addToLabels("pdb-type", "single-instance") .endMetadata() .withNewSpec() .withMinAvailable(1) // Must always be available .withNewSelector() .withMatchLabels(selectorLabels) .endSelector() .endSpec() .build(); } public PodDisruptionBudget createStatefulPDB(String appName, Map<String, String> selectorLabels, int replicas) { // For stateful applications, allow disruption of only one pod at a time return new PodDisruptionBudgetBuilder() .withNewMetadata() .withName(appName + "-pdb") .addToLabels("app", appName) .addToLabels("pdb-type", "stateful") .endMetadata() .withNewSpec() .withMaxUnavailable(1) .withNewSelector() .withMatchLabels(selectorLabels) .endSelector() .endSpec() .build(); } public PodDisruptionBudget createPercentageBasedPDB(String appName, Map<String, String> selectorLabels, String maxUnavailablePercentage) { return new PodDisruptionBudgetBuilder() .withNewMetadata() .withName(appName + "-pdb") .addToLabels("app", appName) .endMetadata() .withNewSpec() .withMaxUnavailable(maxUnavailablePercentage) .withNewSelector() .withMatchLabels(selectorLabels) .endSelector() .endSpec() .build(); } }

5. PDB Validation Service

package com.example.k8s.pdb; import io.fabric8.kubernetes.api.model.policy.v1.PodDisruptionBudget; import io.fabric8.kubernetes.client.KubernetesClient; import org.springframework.stereotype.Service; import java.util.ArrayList; import java.util.List; @Service public class PDBValidationService { private final KubernetesClient client; private final String namespace; public PDBValidationService(KubernetesClient client) { this.client = client; this.namespace = client.getNamespace(); } public ValidationResult validatePDB(PodDisruptionBudget pdb) { List<String> errors = new ArrayList<>(); List<String> warnings = new ArrayList<>(); String name = pdb.getMetadata().getName(); var spec = pdb.getSpec(); // Check if both minAvailable and maxUnavailable are set if (spec.getMinAvailable() != null && spec.getMaxUnavailable() != null) { errors.add("Both minAvailable and maxUnavailable cannot be set simultaneously"); } // Check if neither is set if (spec.getMinAvailable() == null && spec.getMaxUnavailable() == null) { errors.add("Either minAvailable or maxUnavailable must be set"); } // Check selector if (spec.getSelector() == null) { errors.add("Selector must be specified"); } else if (spec.getSelector().getMatchLabels() == null || spec.getSelector().getMatchLabels().isEmpty()) { warnings.add("PDB selector has no matchLabels, ensure this is intentional"); } // Validate numeric values if (spec.getMinAvailable() != null) { try { int minAvailable = Integer.parseInt(spec.getMinAvailable().toString()); if (minAvailable < 0) { errors.add("minAvailable cannot be negative"); } } catch (NumberFormatException e) { // It might be a percentage, validate percentage format if (!spec.getMinAvailable().toString().endsWith("%")) { errors.add("minAvailable must be an integer or percentage"); } } } if (spec.getMaxUnavailable() != null) { try { int maxUnavailable = Integer.parseInt(spec.getMaxUnavailable().toString()); if (maxUnavailable < 0) { errors.add("maxUnavailable cannot be negative"); } } catch (NumberFormatException e) { // It might be a percentage, validate percentage format if (!spec.getMaxUnavailable().toString().endsWith("%")) { errors.add("maxUnavailable must be an integer or percentage"); } } } return new ValidationResult(name, errors, warnings); } public boolean isPDBCompliant(String pdbName) { Optional<PodDisruptionBudget> pdbOpt = getPDB(pdbName); if (pdbOpt.isEmpty()) { return false; } PodDisruptionBudget pdb = pdbOpt.get(); var status = pdb.getStatus(); if (status == null) { return false; } // Check if current healthy pods meet PDB requirements Integer desiredHealthy = status.getDesiredHealthy(); Integer currentHealthy = status.getCurrentHealthy(); return desiredHealthy != null && currentHealthy != null && currentHealthy >= desiredHealthy; } public static class ValidationResult { private final String pdbName; private final List<String> errors; private final List<String> warnings; private final boolean isValid; public ValidationResult(String pdbName, List<String> errors, List<String> warnings) { this.pdbName = pdbName; this.errors = errors; this.warnings = warnings; this.isValid = errors.isEmpty(); } // Getters public String getPdbName() { return pdbName; } public List<String> getErrors() { return errors; } public List<String> getWarnings() { return warnings; } public boolean isValid() { return isValid; } } private Optional<PodDisruptionBudget> getPDB(String name) { try { PodDisruptionBudget pdb = client.policy().v1().podDisruptionBudget() .inNamespace(namespace) .withName(name) .get(); return Optional.ofNullable(pdb); } catch (Exception e) { return Optional.empty(); } } }

6. PDB Controller for Automated Management

package com.example.k8s.pdb; import io.fabric8.kubernetes.api.model.apps.Deployment; import io.fabric8.kubernetes.api.model.apps.StatefulSet; import io.fabric8.kubernetes.client.KubernetesClient; import io.fabric8.kubernetes.client.Watcher; import io.fabric8.kubernetes.client.WatcherException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @Component public class PDBAutoManager { private static final Logger log = LoggerFactory.getLogger(PDBAutoManager.class); private final KubernetesClient client; private final PDBFactory pdbFactory; private final PDBManager pdbManager; private final String namespace; private final Map<String, String> managedDeployments = new ConcurrentHashMap<>(); private Watcher<Deployment> deploymentWatcher; public PDBAutoManager(KubernetesClient client, PDBFactory pdbFactory, PDBManager pdbManager) { this.client = client; this.pdbFactory = pdbFactory; this.pdbManager = pdbManager; this.namespace = client.getNamespace(); } @PostConstruct public void init() { startDeploymentWatcher(); reconcileExistingDeployments(); } @PreDestroy public void cleanup() { if (deploymentWatcher != null) { // Watcher is automatically closed by the client } } private void startDeploymentWatcher() { deploymentWatcher = client.apps().deployments() .inNamespace(namespace) .watch(new Watcher<Deployment>() { @Override public void eventReceived(Action action, Deployment deployment) { handleDeploymentEvent(action, deployment); } @Override public void onClose(WatcherException cause) { if (cause != null) { log.error("Deployment watcher closed with error", cause); // Implement reconnection logic } } }); } private void handleDeploymentEvent(Watcher.Action action, Deployment deployment) { String deploymentName = deployment.getMetadata().getName(); Map<String, String> labels = deployment.getMetadata().getLabels(); if (labels != null && "true".equals(labels.get("auto-pdb"))) { switch (action) { case ADDED: case MODIFIED: manageDeploymentPDB(deployment); break; case DELETED: removeDeploymentPDB(deploymentName); break; } } } private void manageDeploymentPDB(Deployment deployment) { String deploymentName = deployment.getMetadata().getName(); Map<String, String> selectorLabels = deployment.getSpec().getSelector().getMatchLabels(); Integer replicas = deployment.getSpec().getReplicas(); if (replicas == null || replicas < 1) { log.warn("Deployment {} has invalid replica count: {}", deploymentName, replicas); return; } Map<String, String> labels = deployment.getMetadata().getLabels(); String pdbStrategy = labels != null ? labels.get("pdb-strategy") : "default"; PodDisruptionBudget pdb; switch (pdbStrategy) { case "high-availability": pdb = pdbFactory.createHighAvailabilityPDB(deploymentName, selectorLabels, replicas); break; case "critical": pdb = pdbFactory.createCriticalServicePDB(deploymentName, selectorLabels, replicas); break; case "single-instance": if (replicas == 1) { pdb = pdbFactory.createSingleInstancePDB(deploymentName, selectorLabels); } else { log.warn("Single-instance PDB strategy used for multi-replica deployment: {}", deploymentName); pdb = pdbFactory.createHighAvailabilityPDB(deploymentName, selectorLabels, replicas); } break; default: pdb = pdbFactory.createHighAvailabilityPDB(deploymentName, selectorLabels, replicas); } pdbManager.createOrUpdatePDB(pdb); managedDeployments.put(deploymentName, pdb.getMetadata().getName()); log.info("Managed PDB for deployment: {}", deploymentName); } private void removeDeploymentPDB(String deploymentName) { String pdbName = managedDeployments.remove(deploymentName); if (pdbName != null) { pdbManager.deletePDB(pdbName); log.info("Removed PDB for deleted deployment: {}", deploymentName); } } @Scheduled(fixedDelay = 300000) // Run every 5 minutes public void reconcileExistingDeployments() { log.info("Starting PDB reconciliation"); client.apps().deployments() .inNamespace(namespace) .list() .getItems() .stream() .filter(deployment -> { Map<String, String> labels = deployment.getMetadata().getLabels(); return labels != null && "true".equals(labels.get("auto-pdb")); }) .forEach(this::manageDeploymentPDB); log.info("Completed PDB reconciliation"); } }

7. Spring Boot Configuration

package com.example.k8s.config; import io.fabric8.kubernetes.client.Config; import io.fabric8.kubernetes.client.ConfigBuilder; import io.fabric8.kubernetes.client.DefaultKubernetesClient; import io.fabric8.kubernetes.client.KubernetesClient; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class KubernetesConfig { @Value("${kubernetes.namespace:default}") private String namespace; @Value("${kubernetes.master.url:}") private String masterUrl; @Value("${kubernetes.oauth.token:}") private String oauthToken; @Bean public KubernetesClient kubernetesClient() { Config config = new ConfigBuilder() .withNamespace(namespace) .withMasterUrl(masterUrl.isEmpty() ? null : masterUrl) .withOauthToken(oauthToken.isEmpty() ? null : oauthToken) .withTrustCerts(true) .build(); return new DefaultKubernetesClient(config); } }

8. Usage Examples

package com.example.k8s.controller; import com.example.k8s.pdb.*; import io.fabric8.kubernetes.api.model.policy.v1.PodDisruptionBudget; import org.springframework.web.bind.annotation.*; import java.util.List; import java.util.Map; @RestController @RequestMapping("/api/pdb") public class PDBController { private final PodDisruptionBudgetService pdbService; private final PDBManager pdbManager; private final PDBValidationService validationService; public PDBController(PodDisruptionBudgetService pdbService, PDBManager pdbManager, PDBValidationService validationService) { this.pdbService = pdbService; this.pdbManager = pdbManager; this.validationService = validationService; } @PostMapping("/min-available") public PodDisruptionBudget createMinAvailablePDB( @RequestParam String name, @RequestParam int minAvailable, @RequestBody Map<String, String> selectorLabels) { return pdbService.createMinAvailablePDB(name, selectorLabels, minAvailable); } @PostMapping("/max-unavailable") public PodDisruptionBudget createMaxUnavailablePDB( @RequestParam String name, @RequestParam int maxUnavailable, @RequestBody Map<String, String> selectorLabels) { return pdbService.createMaxUnavailablePDB(name, selectorLabels, maxUnavailable); } @GetMapping public List<PodDisruptionBudget> listPDBs() { return pdbManager.listPDBs(); } @GetMapping("/{name}") public PodDisruptionBudget getPDB(@PathVariable String name) { return pdbManager.getPDB(name) .orElseThrow(() -> new RuntimeException("PDB not found: " + name)); } @DeleteMapping("/{name}") public void deletePDB(@PathVariable String name) { pdbManager.deletePDB(name); } @PostMapping("/{name}/validate") public PDBValidationService.ValidationResult validatePDB(@PathVariable String name) { PodDisruptionBudget pdb = pdbManager.getPDB(name) .orElseThrow(() -> new RuntimeException("PDB not found: " + name)); return validationService.validatePDB(pdb); } @GetMapping("/{name}/compliant") public boolean isPDBCompliant(@PathVariable String name) { return validationService.isPDBCompliant(name); } }

9. Application Properties

# application.yml kubernetes: namespace: my-app-namespace master: url: https://kubernetes.default.svc oauth: token: ${KUBERNETES_TOKEN} management: endpoints: web: exposure: include: health,info,metrics endpoint: health: show-details: always logging: level: com.example.k8s: DEBUG

Best Practices

  1. Use PDBs for Stateful Applications: Protect databases, message queues, and other stateful services
  2. Balance Availability and Upgradability: Don't set minAvailable too high, as it can prevent cluster maintenance
  3. Monitor PDB Compliance: Regularly check if your PDBs are being respected
  4. Use Labels Strategically: Ensure PDB selectors match your pod labels accurately
  5. Test Disruption Scenarios: Verify PDB behavior during controlled node drains

Conclusion

Pod Disruption Budgets are essential for maintaining application availability during Kubernetes cluster operations. The Java implementation using Fabric8 Kubernetes Client provides a robust way to programmatically manage PDBs, ensuring your applications remain available during voluntary disruptions while allowing necessary cluster maintenance operations.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper