MACRO NEPAL
Fabric8 Kubernetes Client in Java: Comprehensive Guide to Kubernetes Operations
awiskar acharya
November 19, 2025
10:59 am

Fabric8 Kubernetes Client provides a fluent DSL for working with Kubernetes resources in Java, offering a more intuitive alternative to the official Kubernetes client.

Core Concepts

What is Fabric8 Kubernetes Client?

  • Fluent DSL for Kubernetes operations
  • Type-safe Kubernetes resource management
  • Support for Kubernetes and OpenShift
  • Comprehensive CRD (Custom Resource Definition) support
  • Watch and informer capabilities for real-time updates

Key Features:

  • Fluent API: Builder pattern for resource creation
  • Watch Support: Real-time resource monitoring
  • Resource Scaling: Easy pod and deployment scaling
  • Log Streaming: Real-time pod log access
  • Exec Commands: Execute commands in pods
  • YAML/JSON Parsing: Seamless resource serialization

Dependencies and Setup

Maven Dependencies
<properties>
<kubernetes-client.version>6.7.2</kubernetes-client.version>
<fabric8-maven-plugin.version>4.4.1</fabric8-maven-plugin.version>
<spring-boot.version>3.1.0</spring-boot.version>
</properties>
<dependencies>
<!-- Fabric8 Kubernetes Client -->
<dependency>
<groupId>io.fabric8</groupId>
<artifactId>kubernetes-client</artifactId>
<version>${kubernetes-client.version}</version>
</dependency>
<!-- OpenShift Client (if needed) -->
<dependency>
<groupId>io.fabric8</groupId>
<artifactId>openshift-client</artifactId>
<version>${kubernetes-client.version}</version>
</dependency>
<!-- Spring Boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<!-- YAML Processing -->
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-yaml</artifactId>
<version>2.15.2</version>
</dependency>
<!-- Testing -->
<dependency>
<groupId>io.fabric8</groupId>
<artifactId>kubernetes-server-mock</artifactId>
<version>${kubernetes-client.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
Configuration Classes
@Configuration
@ConfigurationProperties(prefix = "kubernetes")
@Data
public class KubernetesConfig {
private String masterUrl;
private String namespace;
private String oauthToken;
private String username;
private String password;
private boolean trustCerts = false;
private int connectionTimeout = 10000;
private int requestTimeout = 10000;
// For in-cluster configuration
private boolean inCluster = false;
}
@Configuration
@EnableConfigurationProperties(KubernetesConfig.class)
public class KubernetesClientConfig {
@Bean
@ConditionalOnMissingBean
public KubernetesClient kubernetesClient(KubernetesConfig config) {
ConfigBuilder configBuilder = new ConfigBuilder();
if (config.isInCluster()) {
// In-cluster configuration
try {
return new DefaultKubernetesClient(Config.autoConfigure(null));
} catch (Exception e) {
throw new KubernetesClientException("Failed to configure in-cluster client", e);
}
}
// External cluster configuration
if (config.getMasterUrl() != null) {
configBuilder.withMasterUrl(config.getMasterUrl());
}
if (config.getNamespace() != null) {
configBuilder.withNamespace(config.getNamespace());
}
if (config.getOauthToken() != null) {
configBuilder.withOauthToken(config.getOauthToken());
}
if (config.getUsername() != null && config.getPassword() != null) {
configBuilder.withUsername(config.getUsername())
.withPassword(config.getPassword());
}
configBuilder.withTrustCerts(config.isTrustCerts())
.withConnectionTimeout(config.getConnectionTimeout())
.withRequestTimeout(config.getRequestTimeout());
return new DefaultKubernetesClient(configBuilder.build());
}
@Bean
@ConditionalOnProperty(name = "kubernetes.openshift.enabled", havingValue = "true")
public OpenShiftClient openShiftClient(KubernetesClient kubernetesClient) {
return kubernetesClient.adapt(OpenShiftClient.class);
}
}

Core Kubernetes Operations

1. Pod Operations Service
@Service
@Slf4j
public class PodOperationsService {
private final KubernetesClient kubernetesClient;
private final String namespace;
public PodOperationsService(KubernetesClient kubernetesClient, 
KubernetesConfig config) {
this.kubernetesClient = kubernetesClient;
this.namespace = config.getNamespace();
}
// List pods
public List<Pod> listPods() {
log.debug("Listing pods in namespace: {}", namespace);
return kubernetesClient.pods()
.inNamespace(namespace)
.list()
.getItems();
}
public List<Pod> listPodsByLabel(String labelKey, String labelValue) {
log.debug("Listing pods with label {}={} in namespace: {}", 
labelKey, labelValue, namespace);
return kubernetesClient.pods()
.inNamespace(namespace)
.withLabel(labelKey, labelValue)
.list()
.getItems();
}
public List<Pod> listPodsByLabels(Map<String, String> labels) {
return kubernetesClient.pods()
.inNamespace(namespace)
.withLabels(labels)
.list()
.getItems();
}
// Get pod
public Pod getPod(String podName) {
log.debug("Getting pod: {} in namespace: {}", podName, namespace);
return kubernetesClient.pods()
.inNamespace(namespace)
.withName(podName)
.get();
}
// Create pod
public Pod createPod(Pod pod) {
log.info("Creating pod: {} in namespace: {}", 
pod.getMetadata().getName(), namespace);
return kubernetesClient.pods()
.inNamespace(namespace)
.create(pod);
}
public Pod createPodFromYaml(String yamlContent) {
log.debug("Creating pod from YAML in namespace: {}", namespace);
return kubernetesClient.pods()
.inNamespace(namespace)
.load(new ByteArrayInputStream(yamlContent.getBytes()))
.create();
}
// Delete pod
public boolean deletePod(String podName) {
log.info("Deleting pod: {} in namespace: {}", podName, namespace);
return kubernetesClient.pods()
.inNamespace(namespace)
.withName(podName)
.delete();
}
// Execute command in pod
public String executeCommand(String podName, String containerName, String... command) {
log.debug("Executing command in pod: {}, container: {}", podName, containerName);
try {
return kubernetesClient.pods()
.inNamespace(namespace)
.withName(podName)
.inContainer(containerName)
.exec(command)
.toString();
} catch (Exception e) {
log.error("Failed to execute command in pod: {}", podName, e);
throw new KubernetesOperationException("Command execution failed", e);
}
}
// Get pod logs
public String getPodLogs(String podName, String containerName) {
log.debug("Getting logs for pod: {}, container: {}", podName, containerName);
return kubernetesClient.pods()
.inNamespace(namespace)
.withName(podName)
.inContainer(containerName)
.getLog();
}
public InputStream getPodLogsStream(String podName, String containerName) {
log.debug("Getting logs stream for pod: {}, container: {}", podName, containerName);
return kubernetesClient.pods()
.inNamespace(namespace)
.withName(podName)
.inContainer(containerName)
.watchLog()
.getOutput();
}
// Watch pods
public void watchPods(Watcher<Pod> watcher) {
log.debug("Starting pod watch in namespace: {}", namespace);
kubernetesClient.pods()
.inNamespace(namespace)
.watch(watcher);
}
public void watchPodsByLabel(String labelKey, String labelValue, Watcher<Pod> watcher) {
log.debug("Starting pod watch with label {}={} in namespace: {}", 
labelKey, labelValue, namespace);
kubernetesClient.pods()
.inNamespace(namespace)
.withLabel(labelKey, labelValue)
.watch(watcher);
}
// Pod status
public boolean isPodReady(String podName) {
Pod pod = getPod(podName);
return pod != null && isPodReady(pod);
}
public boolean isPodReady(Pod pod) {
return pod.getStatus().getConditions().stream()
.filter(condition -> "Ready".equals(condition.getType()))
.findFirst()
.map(condition -> "True".equals(condition.getStatus()))
.orElse(false);
}
public PodPhase getPodPhase(String podName) {
Pod pod = getPod(podName);
return pod != null ? PodPhase.fromString(pod.getStatus().getPhase()) : PodPhase.UNKNOWN;
}
// Wait for pod condition
public boolean waitForPodReady(String podName, Duration timeout) {
log.info("Waiting for pod {} to be ready, timeout: {}", podName, timeout);
try {
return kubernetesClient.pods()
.inNamespace(namespace)
.withName(podName)
.waitUntilCondition(pod -> isPodReady(pod), 
timeout.toMillis(), 
TimeUnit.MILLISECONDS);
} catch (Exception e) {
log.error("Error waiting for pod readiness: {}", podName, e);
return false;
}
}
}
2. Deployment Operations Service
@Service
@Slf4j
public class DeploymentOperationsService {
private final KubernetesClient kubernetesClient;
private final String namespace;
public DeploymentOperationsService(KubernetesClient kubernetesClient,
KubernetesConfig config) {
this.kubernetesClient = kubernetesClient;
this.namespace = config.getNamespace();
}
// List deployments
public List<Deployment> listDeployments() {
log.debug("Listing deployments in namespace: {}", namespace);
return kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.list()
.getItems();
}
// Get deployment
public Deployment getDeployment(String deploymentName) {
log.debug("Getting deployment: {} in namespace: {}", deploymentName, namespace);
return kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.withName(deploymentName)
.get();
}
// Create deployment
public Deployment createDeployment(Deployment deployment) {
log.info("Creating deployment: {} in namespace: {}", 
deployment.getMetadata().getName(), namespace);
return kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.create(deployment);
}
public Deployment createDeploymentFromYaml(String yamlContent) {
log.debug("Creating deployment from YAML in namespace: {}", namespace);
return kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.load(new ByteArrayInputStream(yamlContent.getBytes()))
.create();
}
// Update deployment
public Deployment updateDeployment(Deployment deployment) {
log.info("Updating deployment: {} in namespace: {}", 
deployment.getMetadata().getName(), namespace);
return kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.withName(deployment.getMetadata().getName())
.patch(deployment);
}
// Scale deployment
public Deployment scaleDeployment(String deploymentName, int replicas) {
log.info("Scaling deployment {} to {} replicas", deploymentName, replicas);
return kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.withName(deploymentName)
.scale(replicas);
}
// Rolling update (update image)
public Deployment rollingUpdate(String deploymentName, String containerName, String newImage) {
log.info("Performing rolling update for deployment: {}, container: {}, image: {}", 
deploymentName, containerName, newImage);
return kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.withName(deploymentName)
.updateImage(newImage);
}
// Delete deployment
public boolean deleteDeployment(String deploymentName) {
log.info("Deleting deployment: {} in namespace: {}", deploymentName, namespace);
return kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.withName(deploymentName)
.delete();
}
// Deployment status
public DeploymentStatus getDeploymentStatus(String deploymentName) {
Deployment deployment = getDeployment(deploymentName);
return deployment != null ? 
DeploymentStatus.fromDeployment(deployment) : 
DeploymentStatus.unknown(deploymentName);
}
// Wait for deployment readiness
public boolean waitForDeploymentReady(String deploymentName, Duration timeout) {
log.info("Waiting for deployment {} to be ready, timeout: {}", deploymentName, timeout);
try {
return kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.withName(deploymentName)
.waitUntilCondition(deployment -> {
Integer replicas = deployment.getStatus().getReplicas();
Integer readyReplicas = deployment.getStatus().getReadyReplicas();
return replicas != null && readyReplicas != null && 
replicas.equals(readyReplicas);
}, timeout.toMillis(), TimeUnit.MILLISECONDS);
} catch (Exception e) {
log.error("Error waiting for deployment readiness: {}", deploymentName, e);
return false;
}
}
// Get pods for deployment
public List<Pod> getDeploymentPods(String deploymentName) {
Deployment deployment = getDeployment(deploymentName);
if (deployment == null) {
return Collections.emptyList();
}
Map<String, String> selector = deployment.getSpec().getSelector().getMatchLabels();
return kubernetesClient.pods()
.inNamespace(namespace)
.withLabels(selector)
.list()
.getItems();
}
// Watch deployments
public void watchDeployments(Watcher<Deployment> watcher) {
log.debug("Starting deployment watch in namespace: {}", namespace);
kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.watch(watcher);
}
}
3. Service Operations Service
@Service
@Slf4j
public class ServiceOperationsService {
private final KubernetesClient kubernetesClient;
private final String namespace;
public ServiceOperationsService(KubernetesClient kubernetesClient,
KubernetesConfig config) {
this.kubernetesClient = kubernetesClient;
this.namespace = config.getNamespace();
}
// List services
public List<Service> listServices() {
log.debug("Listing services in namespace: {}", namespace);
return kubernetesClient.services()
.inNamespace(namespace)
.list()
.getItems();
}
// Get service
public Service getService(String serviceName) {
log.debug("Getting service: {} in namespace: {}", serviceName, namespace);
return kubernetesClient.services()
.inNamespace(namespace)
.withName(serviceName)
.get();
}
// Create service
public Service createService(Service service) {
log.info("Creating service: {} in namespace: {}", 
service.getMetadata().getName(), namespace);
return kubernetesClient.services()
.inNamespace(namespace)
.create(service);
}
// Delete service
public boolean deleteService(String serviceName) {
log.info("Deleting service: {} in namespace: {}", serviceName, namespace);
return kubernetesClient.services()
.inNamespace(namespace)
.withName(serviceName)
.delete();
}
// Get service URL
public String getServiceUrl(String serviceName, String portName) {
Service service = getService(serviceName);
if (service == null) {
throw new KubernetesResourceNotFoundException("Service not found: " + serviceName);
}
Integer port = service.getSpec().getPorts().stream()
.filter(portSpec -> portName.equals(portSpec.getName()))
.map(ServicePort::getPort)
.findFirst()
.orElseThrow(() -> new KubernetesOperationException(
"Port not found: " + portName + " in service: " + serviceName));
return String.format("http://%s.%s.svc.cluster.local:%d", 
serviceName, namespace, port);
}
// Expose deployment as service
public Service exposeDeployment(String deploymentName, String serviceName, 
int port, int targetPort) {
log.info("Exposing deployment {} as service {} on port {}", 
deploymentName, serviceName, port);
Service service = new ServiceBuilder()
.withNewMetadata()
.withName(serviceName)
.withNamespace(namespace)
.endMetadata()
.withNewSpec()
.withSelector(Collections.singletonMap("app", deploymentName))
.addNewPort()
.withPort(port)
.withTargetPort(new IntOrString(targetPort))
.endPort()
.endSpec()
.build();
return createService(service);
}
}
4. ConfigMap and Secret Operations
@Service
@Slf4j
public class ConfigOperationsService {
private final KubernetesClient kubernetesClient;
private final String namespace;
public ConfigOperationsService(KubernetesClient kubernetesClient,
KubernetesConfig config) {
this.kubernetesClient = kubernetesClient;
this.namespace = config.getNamespace();
}
// ConfigMap operations
public ConfigMap createConfigMap(String name, Map<String, String> data) {
log.info("Creating ConfigMap: {} in namespace: {}", name, namespace);
return kubernetesClient.configMaps()
.inNamespace(namespace)
.create(new ConfigMapBuilder()
.withNewMetadata()
.withName(name)
.withNamespace(namespace)
.endMetadata()
.withData(data)
.build());
}
public ConfigMap getConfigMap(String name) {
return kubernetesClient.configMaps()
.inNamespace(namespace)
.withName(name)
.get();
}
public ConfigMap updateConfigMap(String name, Map<String, String> data) {
log.info("Updating ConfigMap: {} in namespace: {}", name, namespace);
return kubernetesClient.configMaps()
.inNamespace(namespace)
.withName(name)
.edit()
.withData(data)
.done();
}
// Secret operations
public Secret createSecret(String name, Map<String, String> stringData) {
log.info("Creating Secret: {} in namespace: {}", name, namespace);
return kubernetesClient.secrets()
.inNamespace(namespace)
.create(new SecretBuilder()
.withNewMetadata()
.withName(name)
.withNamespace(namespace)
.endMetadata()
.withStringData(stringData)
.build());
}
public Secret getSecret(String name) {
return kubernetesClient.secrets()
.inNamespace(namespace)
.withName(name)
.get();
}
public String getSecretData(String secretName, String key) {
Secret secret = getSecret(secretName);
if (secret == null || secret.getData() == null) {
return null;
}
String base64Data = secret.getData().get(key);
return base64Data != null ? new String(Base64.getDecoder().decode(base64Data)) : null;
}
// Create Secret from literal values
public Secret createSecretFromLiterals(String name, Map<String, String> literals) {
Map<String, String> encodedData = literals.entrySet().stream()
.collect(Collectors.toMap(
Map.Entry::getKey,
entry -> Base64.getEncoder().encodeToString(entry.getValue().getBytes())
));
return kubernetesClient.secrets()
.inNamespace(namespace)
.create(new SecretBuilder()
.withNewMetadata()
.withName(name)
.withNamespace(namespace)
.endMetadata()
.withData(encodedData)
.build());
}
}
5. Namespace Operations Service
@Service
@Slf4j
public class NamespaceOperationsService {
private final KubernetesClient kubernetesClient;
public NamespaceOperationsService(KubernetesClient kubernetesClient) {
this.kubernetesClient = kubernetesClient;
}
// List namespaces
public List<Namespace> listNamespaces() {
log.debug("Listing all namespaces");
return kubernetesClient.namespaces()
.list()
.getItems();
}
// Get namespace
public Namespace getNamespace(String namespaceName) {
log.debug("Getting namespace: {}", namespaceName);
return kubernetesClient.namespaces()
.withName(namespaceName)
.get();
}
// Create namespace
public Namespace createNamespace(String namespaceName) {
log.info("Creating namespace: {}", namespaceName);
return kubernetesClient.namespaces()
.create(new NamespaceBuilder()
.withNewMetadata()
.withName(namespaceName)
.endMetadata()
.build());
}
public Namespace createNamespaceWithLabels(String namespaceName, Map<String, String> labels) {
log.info("Creating namespace: {} with labels: {}", namespaceName, labels);
return kubernetesClient.namespaces()
.create(new NamespaceBuilder()
.withNewMetadata()
.withName(namespaceName)
.withLabels(labels)
.endMetadata()
.build());
}
// Delete namespace
public boolean deleteNamespace(String namespaceName) {
log.info("Deleting namespace: {}", namespaceName);
return kubernetesClient.namespaces()
.withName(namespaceName)
.delete();
}
// Check if namespace exists
public boolean namespaceExists(String namespaceName) {
return getNamespace(namespaceName) != null;
}
// Switch context to different namespace
public void switchNamespace(String namespaceName) {
log.info("Switching to namespace: {}", namespaceName);
// This would typically involve creating a new client instance
// or using the existing client with the new namespace context
}
}

Advanced Features

1. Resource Builder Factory
@Component
public class KubernetesResourceBuilder {
public DeploymentBuilder deployment() {
return new DeploymentBuilder();
}
public ServiceBuilder service() {
return new ServiceBuilder();
}
public ConfigMapBuilder configMap() {
return new ConfigMapBuilder();
}
public static class DeploymentBuilder {
private String name;
private String namespace = "default";
private Map<String, String> labels = new HashMap<>();
private int replicas = 1;
private String image;
private int containerPort = 8080;
private Map<String, String> envVars = new HashMap<>();
public DeploymentBuilder withName(String name) {
this.name = name;
return this;
}
public DeploymentBuilder withNamespace(String namespace) {
this.namespace = namespace;
return this;
}
public DeploymentBuilder withLabel(String key, String value) {
this.labels.put(key, value);
return this;
}
public DeploymentBuilder withReplicas(int replicas) {
this.replicas = replicas;
return this;
}
public DeploymentBuilder withImage(String image) {
this.image = image;
return this;
}
public DeploymentBuilder withContainerPort(int port) {
this.containerPort = port;
return this;
}
public DeploymentBuilder withEnvVar(String key, String value) {
this.envVars.put(key, value);
return this;
}
public Deployment build() {
if (name == null || image == null) {
throw new IllegalStateException("Name and image are required");
}
return new DeploymentBuilder()
.withNewMetadata()
.withName(name)
.withNamespace(namespace)
.withLabels(labels)
.endMetadata()
.withNewSpec()
.withReplicas(replicas)
.withNewSelector()
.addToMatchLabels("app", name)
.endSelector()
.withNewTemplate()
.withNewMetadata()
.withLabels(labels)
.endMetadata()
.withNewSpec()
.addNewContainer()
.withName(name)
.withImage(image)
.addNewPort()
.withContainerPort(containerPort)
.endPort()
.withEnv(envVars.entrySet().stream()
.map(entry -> new EnvVarBuilder()
.withName(entry.getKey())
.withValue(entry.getValue())
.build())
.collect(Collectors.toList()))
.endContainer()
.endSpec()
.endTemplate()
.endSpec()
.build();
}
}
// Similar builder patterns for Service, ConfigMap, etc.
}
2. Watch and Event Handling
@Service
@Slf4j
public class KubernetesWatcherService {
private final KubernetesClient kubernetesClient;
private final String namespace;
private final Map<String, Watch> activeWatches = new ConcurrentHashMap<>();
public KubernetesWatcherService(KubernetesClient kubernetesClient,
KubernetesConfig config) {
this.kubernetesClient = kubernetesClient;
this.namespace = config.getNamespace();
}
// Pod watcher
public String watchPods(PodWatcherListener listener) {
String watchId = UUID.randomUUID().toString();
Watch watch = kubernetesClient.pods()
.inNamespace(namespace)
.watch(new Watcher<Pod>() {
@Override
public void eventReceived(Action action, Pod pod) {
listener.onPodEvent(action, pod);
}
@Override
public void onClose(WatcherException cause) {
listener.onWatchClose(cause);
activeWatches.remove(watchId);
}
});
activeWatches.put(watchId, watch);
return watchId;
}
// Deployment watcher
public String watchDeployments(DeploymentWatcherListener listener) {
String watchId = UUID.randomUUID().toString();
Watch watch = kubernetesClient.apps()
.deployments()
.inNamespace(namespace)
.watch(new Watcher<Deployment>() {
@Override
public void eventReceived(Action action, Deployment deployment) {
listener.onDeploymentEvent(action, deployment);
}
@Override
public void onClose(WatcherException cause) {
listener.onWatchClose(cause);
activeWatches.remove(watchId);
}
});
activeWatches.put(watchId, watch);
return watchId;
}
// Stop watch
public void stopWatch(String watchId) {
Watch watch = activeWatches.get(watchId);
if (watch != null) {
watch.close();
activeWatches.remove(watchId);
}
}
public void stopAllWatches() {
activeWatches.values().forEach(Watch::close);
activeWatches.clear();
}
// Informer for more efficient watching
public SharedInformerFactory createInformerFactory() {
return kubernetesClient.informers();
}
}
// Listener interfaces
public interface PodWatcherListener {
void onPodEvent(Watcher.Action action, Pod pod);
void onWatchClose(WatcherException cause);
}
public interface DeploymentWatcherListener {
void onDeploymentEvent(Watcher.Action action, Deployment deployment);
void onWatchClose(WatcherException cause);
}
3. Custom Resource Definition (CRD) Support
// Custom Resource Model
@Data
public class MyCustomResource extends CustomResource {
private MyCustomResourceSpec spec;
private MyCustomResourceStatus status;
@Data
public static class MyCustomResourceSpec {
private String message;
private int replicas;
private Map<String, String> config;
}
@Data
public static class MyCustomResourceStatus {
private String phase;
private String message;
private List<String> conditions;
}
}
// CRD Operations Service
@Service
@Slf4j
public class CustomResourceOperationsService {
private final KubernetesClient kubernetesClient;
private final String namespace;
public CustomResourceOperationsService(KubernetesClient kubernetesClient,
KubernetesConfig config) {
this.kubernetesClient = kubernetesClient;
this.namespace = config.getNamespace();
}
// Create custom resource
public MyCustomResource createCustomResource(String name, MyCustomResource resource) {
log.info("Creating custom resource: {} in namespace: {}", name, namespace);
return kubernetesClient.resources(MyCustomResource.class)
.inNamespace(namespace)
.create(resource);
}
// Get custom resource
public MyCustomResource getCustomResource(String name) {
return kubernetesClient.resources(MyCustomResource.class)
.inNamespace(namespace)
.withName(name)
.get();
}
// List custom resources
public List<MyCustomResource> listCustomResources() {
return kubernetesClient.resources(MyCustomResource.class)
.inNamespace(namespace)
.list()
.getItems();
}
// Update custom resource
public MyCustomResource updateCustomResource(MyCustomResource resource) {
log.info("Updating custom resource: {}", resource.getMetadata().getName());
return kubernetesClient.resources(MyCustomResource.class)
.inNamespace(namespace)
.withName(resource.getMetadata().getName())
.patch(resource);
}
// Watch custom resources
public void watchCustomResources(Watcher<MyCustomResource> watcher) {
kubernetesClient.resources(MyCustomResource.class)
.inNamespace(namespace)
.watch(watcher);
}
}

REST Controller

@RestController
@RequestMapping("/api/kubernetes")
@Slf4j
public class KubernetesController {
private final PodOperationsService podService;
private final DeploymentOperationsService deploymentService;
private final ServiceOperationsService serviceService;
private final ConfigOperationsService configService;
private final NamespaceOperationsService namespaceService;
public KubernetesController(PodOperationsService podService,
DeploymentOperationsService deploymentService,
ServiceOperationsService serviceService,
ConfigOperationsService configService,
NamespaceOperationsService namespaceService) {
this.podService = podService;
this.deploymentService = deploymentService;
this.serviceService = serviceService;
this.configService = configService;
this.namespaceService = namespaceService;
}
// Pod endpoints
@GetMapping("/pods")
public ResponseEntity<List<Pod>> listPods() {
try {
List<Pod> pods = podService.listPods();
return ResponseEntity.ok(pods);
} catch (Exception e) {
log.error("Failed to list pods", e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
@GetMapping("/pods/{name}")
public ResponseEntity<Pod> getPod(@PathVariable String name) {
try {
Pod pod = podService.getPod(name);
return pod != null ? ResponseEntity.ok(pod) : ResponseEntity.notFound().build();
} catch (Exception e) {
log.error("Failed to get pod: {}", name, e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
@GetMapping("/pods/{name}/logs")
public ResponseEntity<String> getPodLogs(@PathVariable String name,
@RequestParam(required = false) String container) {
try {
String logs = podService.getPodLogs(name, container != null ? container : name);
return ResponseEntity.ok(logs);
} catch (Exception e) {
log.error("Failed to get logs for pod: {}", name, e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
// Deployment endpoints
@GetMapping("/deployments")
public ResponseEntity<List<Deployment>> listDeployments() {
try {
List<Deployment> deployments = deploymentService.listDeployments();
return ResponseEntity.ok(deployments);
} catch (Exception e) {
log.error("Failed to list deployments", e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
@PostMapping("/deployments/{name}/scale")
public ResponseEntity<Deployment> scaleDeployment(@PathVariable String name,
@RequestParam int replicas) {
try {
Deployment deployment = deploymentService.scaleDeployment(name, replicas);
return ResponseEntity.ok(deployment);
} catch (Exception e) {
log.error("Failed to scale deployment: {}", name, e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
@PostMapping("/deployments/{name}/rolling-update")
public ResponseEntity<Deployment> rollingUpdate(@PathVariable String name,
@RequestParam String container,
@RequestParam String image) {
try {
Deployment deployment = deploymentService.rollingUpdate(name, container, image);
return ResponseEntity.ok(deployment);
} catch (Exception e) {
log.error("Failed to perform rolling update: {}", name, e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
// Service endpoints
@GetMapping("/services")
public ResponseEntity<List<Service>> listServices() {
try {
List<Service> services = serviceService.listServices();
return ResponseEntity.ok(services);
} catch (Exception e) {
log.error("Failed to list services", e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
// Namespace endpoints
@GetMapping("/namespaces")
public ResponseEntity<List<Namespace>> listNamespaces() {
try {
List<Namespace> namespaces = namespaceService.listNamespaces();
return ResponseEntity.ok(namespaces);
} catch (Exception e) {
log.error("Failed to list namespaces", e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
// Health check
@GetMapping("/health")
public ResponseEntity<Map<String, String>> health() {
try {
// Test connectivity by listing namespaces
namespaceService.listNamespaces();
return ResponseEntity.ok(Map.of("status", "connected"));
} catch (Exception e) {
log.error("Kubernetes health check failed", e);
return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
.body(Map.of("status", "disconnected", "error", e.getMessage()));
}
}
}

Error Handling and Custom Exceptions

public class KubernetesOperationException extends RuntimeException {
public KubernetesOperationException(String message) {
super(message);
}
public KubernetesOperationException(String message, Throwable cause) {
super(message, cause);
}
}
public class KubernetesResourceNotFoundException extends KubernetesOperationException {
public KubernetesResourceNotFoundException(String message) {
super(message);
}
public KubernetesResourceNotFoundException(String message, Throwable cause) {
super(message, cause);
}
}
@ControllerAdvice
public class KubernetesExceptionHandler {
@ExceptionHandler(KubernetesResourceNotFoundException.class)
public ResponseEntity<ErrorResponse> handleNotFound(KubernetesResourceNotFoundException e) {
ErrorResponse error = new ErrorResponse("RESOURCE_NOT_FOUND", e.getMessage());
return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
}
@ExceptionHandler(KubernetesOperationException.class)
public ResponseEntity<ErrorResponse> handleOperationException(KubernetesOperationException e) {
ErrorResponse error = new ErrorResponse("KUBERNETES_OPERATION_FAILED", e.getMessage());
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
}
@ExceptionHandler(KubernetesClientException.class)
public ResponseEntity<ErrorResponse> handleClientException(KubernetesClientException e) {
ErrorResponse error = new ErrorResponse("KUBERNETES_CLIENT_ERROR", e.getMessage());
return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(error);
}
}
@Data
@AllArgsConstructor
@NoArgsConstructor
class ErrorResponse {
private String code;
private String message;
private Instant timestamp;
public ErrorResponse(String code, String message) {
this.code = code;
this.message = message;
this.timestamp = Instant.now();
}
}

Testing with Kubernetes Server Mock

@SpringBootTest
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class KubernetesClientTest {
@MockServer
private KubernetesServer kubernetesServer;
private KubernetesClient kubernetesClient;
private PodOperationsService podService;
@BeforeEach
void setUp() {
kubernetesClient = kubernetesServer.getClient();
KubernetesConfig config = new KubernetesConfig();
config.setNamespace("test");
podService = new PodOperationsService(kubernetesClient, config);
}
@Test
void testListPods() {
// Given
kubernetesServer.expect().get()
.withPath("/api/v1/namespaces/test/pods")
.andReturn(200, new PodListBuilder()
.addNewItem()
.withNewMetadata()
.withName("test-pod")
.endMetadata()
.endItem()
.build())
.once();
// When
List<Pod> pods = podService.listPods();
// Then
assertThat(pods).hasSize(1);
assertThat(pods.get(0).getMetadata().getName()).isEqualTo("test-pod");
}
@Test
void testCreatePod() {
// Given
Pod pod = new PodBuilder()
.withNewMetadata()
.withName("test-pod")
.endMetadata()
.build();
kubernetesServer.expect().post()
.withPath("/api/v1/namespaces/test/pods")
.andReturn(201, pod)
.once();
// When
Pod createdPod = podService.createPod(pod);
// Then
assertThat(createdPod).isNotNull();
assertThat(createdPod.getMetadata().getName()).isEqualTo("test-pod");
}
}

Configuration

# application.yml
kubernetes:
master-url: ${KUBERNETES_MASTER:https://kubernetes.default.svc}
namespace: ${KUBERNETES_NAMESPACE:default}
oauth-token: ${KUBERNETES_TOKEN:}
trust-certs: ${KUBERNETES_TRUST_CERTS:false}
connection-timeout: 10000
request-timeout: 10000
in-cluster: ${KUBERNETES_IN_CLUSTER:false}
logging:
level:
io.fabric8: INFO
com.example.kubernetes: DEBUG

Best Practices

  1. Resource Cleanup: Always close watches and informers
  2. Error Handling: Implement comprehensive error handling
  3. Connection Management: Use connection pooling and timeouts
  4. Security: Use service accounts and RBAC appropriately
  5. Monitoring: Monitor Kubernetes API usage and limits
  6. Testing: Use Kubernetes mock server for testing
@Component
public class KubernetesResourceCleanup {
@PreDestroy
public void cleanup() {
// Close any open watches, informers, or exec sessions
}
}

Conclusion

Fabric8 Kubernetes Client provides:

  • Fluent API: Intuitive, type-safe Kubernetes operations
  • Comprehensive Coverage: Support for all Kubernetes resource types
  • Real-time Monitoring: Watch and informer capabilities
  • CRD Support: Full custom resource definition support
  • Production Ready: Robust error handling and connection management

This implementation enables seamless integration with Kubernetes clusters, providing programmatic control over container orchestration with a clean, fluent Java API. The combination of service classes, builders, and comprehensive error handling creates an enterprise-grade Kubernetes integration solution.

Pyroscope Profiling in Java
Explains how to use Pyroscope for continuous profiling in Java applications, helping developers analyze CPU and memory usage patterns to improve performance and identify bottlenecks.
https://macronepal.com/blog/pyroscope-profiling-in-java/

OpenTelemetry Metrics in Java: Comprehensive Guide
Provides a complete guide to collecting and exporting metrics in Java using OpenTelemetry, including counters, histograms, gauges, and integration with monitoring tools. (MACRO NEPAL)
https://macronepal.com/blog/opentelemetry-metrics-in-java-comprehensive-guide/

OTLP Exporter in Java: Complete Guide for OpenTelemetry
Explains how to configure OTLP exporters in Java to send telemetry data such as traces, metrics, and logs to monitoring systems using HTTP or gRPC protocols. (MACRO NEPAL)
https://macronepal.com/blog/otlp-exporter-in-java-complete-guide-for-opentelemetry/

Thanos Integration in Java: Global View of Metrics
Explains how to integrate Thanos with Java monitoring systems to create a scalable global metrics view across multiple Prometheus instances.

https://macronepal.com/blog/thanos-integration-in-java-global-view-of-metrics

Time Series with InfluxDB in Java: Complete Guide (Version 2)
Explains how to manage time-series data using InfluxDB in Java applications, including storing, querying, and analyzing metrics data.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide-2

Time Series with InfluxDB in Java: Complete Guide
Provides an overview of integrating InfluxDB with Java for time-series data handling, including monitoring applications and managing performance metrics.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide

Implementing Prometheus Remote Write in Java (Version 2)
Explains how to configure Java applications to send metrics data to Prometheus-compatible systems using the remote write feature for scalable monitoring.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide-2

Implementing Prometheus Remote Write in Java: Complete Guide
Provides instructions for sending metrics from Java services to Prometheus servers, enabling centralized monitoring and real-time analytics.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide

Building a TileServer GL in Java: Vector and Raster Tile Server
Explains how to build a TileServer GL in Java for serving vector and raster map tiles, useful for geographic visualization and mapping applications.

https://macronepal.com/blog/building-a-tileserver-gl-in-java-vector-and-raster-tile-server

Indoor Mapping in Java
Explains how to create indoor mapping systems in Java, including navigation inside buildings, spatial data handling, and visualization techniques.

Category : JAVA

Leave a Reply

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


Macro Nepal Helper