MACRO NEPAL
Quarkus Kubernetes Extension: Complete Guide for Cloud-Native Java
awiskar acharya
November 18, 2025
9:30 am

The Quarkus Kubernetes extension provides seamless integration with Kubernetes, enabling easy deployment, configuration, and management of Quarkus applications in Kubernetes environments.

Setup and Dependencies

1. Maven Configuration
<project> <modelVersion>4.0.0</modelVersion> <groupId>com.company</groupId> <artifactId>quarkus-k8s-app</artifactId> <version>1.0.0-SNAPSHOT</version> <properties> <quarkus.version>3.2.0.Final</quarkus.version> <compiler-plugin.version>3.11.0</compiler-plugin.version> <surefire-plugin.version>3.0.0</surefire-plugin.version> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-bom</artifactId> <version>${quarkus.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <dependencies> <!-- Kubernetes Extension --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-kubernetes</artifactId> </dependency> <!-- Kubernetes Client --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-kubernetes-client</artifactId> </dependency> <!-- Configurations for specific Kubernetes distributions --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-openshift</artifactId> </dependency> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-minikube</artifactId> </dependency> <!-- Health checks --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-smallrye-health</artifactId> </dependency> <!-- Metrics --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-micrometer-registry-prometheus</artifactId> </dependency> <!-- RESTEasy Reactive --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-resteasy-reactive</artifactId> </dependency> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-resteasy-reactive-jackson</artifactId> </dependency> <!-- Configuration --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-config-yaml</artifactId> </dependency> <!-- Testing --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-junit5</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>io.rest-assured</groupId> <artifactId>rest-assured</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>io.quarkus</groupId> <artifactId>quarkus-maven-plugin</artifactId> <version>${quarkus.version}</version> <extensions>true</extensions> <executions> <execution> <goals> <goal>build</goal> <goal>generate-code</goal> <goal>generate-code-tests</goal> </goals> </execution> </executions> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>${compiler-plugin.version}</version> <configuration> <parameters>true</parameters> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>${surefire-plugin.version}</version> <configuration> <systemPropertyVariables> <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager> </systemPropertyVariables> </configuration> </plugin> </plugins> </build> </project>
2. Application Configuration
# src/main/resources/application.yml quarkus: application: name: user-service version: 1.0.0 # Kubernetes Configuration kubernetes: # Generate Kubernetes resources generate: true export: true # Deployment configuration deployment: kind: Deployment replicas: 3 labels: app.kubernetes.io/part-of: user-management app.kubernetes.io/version: ${quarkus.application.version} annotations: description: "User Management Microservice" # Container configuration container: image: quay.io/company/user-service:${quarkus.application.version} image-pull-policy: IfNotPresent ports: - name: http container-port: 8080 env: - name: JAVA_OPTS value: "-Xmx256m -Xms128m" resources: requests: memory: "256Mi" cpu: "100m" limits: memory: "512Mi" cpu: "500m" # Service configuration service: type: ClusterIP ports: - name: http port: 8080 target-port: 8080 # Ingress configuration ingress: expose: true annotations: nginx.ingress.kubernetes.io/rewrite-target: / rules: - host: users.company.com path: / # Liveness and Readiness probes liveness-probe: http-action-path: /q/health/live initial-delay: 30 period: 10 readiness-probe: http-action-path: /q/health/ready initial-delay: 5 period: 10 # Service Account service-account: user-service-account # Security Context security-context: run-as-user: 1001 run-as-non-root: true # Node Selector and Affinity node-selector: disktype: ssd affinity: node-affinity: required-during-scheduling-ignored-during-execution: node-selector-terms: - match-expressions: - key: kubernetes.io/arch operator: In values: - amd64 # Health Configuration smallrye-health: root-path: /q/health # Metrics Configuration micrometer: export: prometheus: path: /q/metrics binders: process: enabled: true enabled: true # Logging log: level: INFO category: "com.company": DEBUG # HTTP Server http: port: 8080 host: 0.0.0.0 cors: true # Kubernetes Client kubernetes-client: namespace: default trust-certs: true

Kubernetes Resource Generation

1. Custom Resource Configuration
package com.company.config; import io.quarkus.kubernetes.client.KubernetesConfigSourceProvider; import io.smallrye.config.ConfigMapping; import io.smallrye.config.WithName; import java.util.Map; import java.util.Optional; /** * Kubernetes-specific configuration mapping */ @ConfigMapping(prefix = "k8s") public interface KubernetesConfig { @WithName("deployment") DeploymentConfig deployment(); @WithName("service") ServiceConfig service(); @WithName("ingress") Optional<IngressConfig> ingress(); @WithName("resources") ResourceConfig resources(); interface DeploymentConfig { int replicas(); Map<String, String> labels(); Map<String, String> annotations(); } interface ServiceConfig { String type(); Map<String, String> annotations(); } interface IngressConfig { String host(); String path(); Map<String, String> annotations(); } interface ResourceConfig { Memory memory(); Cpu cpu(); interface Memory { String request(); String limit(); } interface Cpu { String request(); String limit(); } } }
2. Custom Kubernetes Resources
package com.company.k8s; import io.fabric8.kubernetes.api.model.Namespaced; import io.fabric8.kubernetes.client.CustomResource; import io.fabric8.kubernetes.model.annotation.Group; import io.fabric8.kubernetes.model.annotation.Version; import io.fabric8.kubernetes.model.annotation.Kind; /** * Custom Resource Definition for Application Configuration */ @Group("company.com") @Version("v1") @Kind("ApplicationConfig") public class ApplicationConfig extends CustomResource<ApplicationConfigSpec, ApplicationConfigStatus> implements Namespaced { // Custom Resource implementation } class ApplicationConfigSpec { private String environment; private DatabaseConfig database; private CacheConfig cache; private SecurityConfig security; // Getters and setters public String getEnvironment() { return environment; } public void setEnvironment(String environment) { this.environment = environment; } public DatabaseConfig getDatabase() { return database; } public void setDatabase(DatabaseConfig database) { this.database = database; } public CacheConfig getCache() { return cache; } public void setCache(CacheConfig cache) { this.cache = cache; } public SecurityConfig getSecurity() { return security; } public void setSecurity(SecurityConfig security) { this.security = security; } } class ApplicationConfigStatus { private String phase; private String message; private Conditions conditions; // Getters and setters public String getPhase() { return phase; } public void setPhase(String phase) { this.phase = phase; } public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } public Conditions getConditions() { return conditions; } public void setConditions(Conditions conditions) { this.conditions = conditions; } } // Supporting classes class DatabaseConfig { private String url; private String username; private String passwordSecret; // Getters and setters } class CacheConfig { private String redisUrl; private int ttl; // Getters and setters } class SecurityConfig { private boolean tlsEnabled; private String secretName; // Getters and setters } class Conditions { private boolean available; private boolean ready; // Getters and setters }

Kubernetes Client Integration

1. Kubernetes Client Service
package com.company.k8s.client; import io.fabric8.kubernetes.api.model.*; import io.fabric8.kubernetes.api.model.apps.Deployment; import io.fabric8.kubernetes.api.model.apps.DeploymentList; import io.fabric8.kubernetes.client.KubernetesClient; import io.fabric8.kubernetes.client.dsl.MixedOperation; import io.fabric8.kubernetes.client.dsl.Resource; import io.quarkus.kubernetes.client.KubernetesClientObjectMapper; import org.eclipse.microprofile.config.inject.ConfigProperty; import javax.enterprise.context.ApplicationScoped; import javax.inject.Inject; import java.util.List; import java.util.Map; import java.util.Optional; /** * Service for Kubernetes API operations */ @ApplicationScoped public class KubernetesClientService { @Inject KubernetesClient kubernetesClient; @Inject @KubernetesClientObjectMapper com.fasterxml.jackson.databind.ObjectMapper objectMapper; @ConfigProperty(name = "quarkus.kubernetes-client.namespace", defaultValue = "default") String namespace; // Deployment Operations public Deployment createDeployment(Deployment deployment) { return kubernetesClient.apps() .deployments() .inNamespace(namespace) .create(deployment); } public List<Deployment> getDeployments() { return kubernetesClient.apps() .deployments() .inNamespace(namespace) .list() .getItems(); } public Optional<Deployment> getDeployment(String name) { Deployment deployment = kubernetesClient.apps() .deployments() .inNamespace(namespace) .withName(name) .get(); return Optional.ofNullable(deployment); } public Deployment updateDeployment(String name, Deployment deployment) { return kubernetesClient.apps() .deployments() .inNamespace(namespace) .withName(name) .patch(deployment); } public boolean deleteDeployment(String name) { return kubernetesClient.apps() .deployments() .inNamespace(namespace) .withName(name) .delete(); } // Pod Operations public List<Pod> getPodsByLabel(String labelSelector) { return kubernetesClient.pods() .inNamespace(namespace) .withLabelSelector(labelSelector) .list() .getItems(); } public List<Pod> getPodsForDeployment(String deploymentName) { Optional<Deployment> deployment = getDeployment(deploymentName); if (deployment.isEmpty()) { return List.of(); } Map<String, String> labels = deployment.get().getSpec().getSelector().getMatchLabels(); StringBuilder labelSelector = new StringBuilder(); labels.forEach((key, value) -> { if (!labelSelector.isEmpty()) { labelSelector.append(","); } labelSelector.append(key).append("=").append(value); }); return getPodsByLabel(labelSelector.toString()); } // ConfigMap Operations public ConfigMap createConfigMap(String name, Map<String, String> data) { ConfigMap configMap = new ConfigMapBuilder() .withNewMetadata() .withName(name) .withNamespace(namespace) .endMetadata() .withData(data) .build(); return kubernetesClient.configMaps() .inNamespace(namespace) .create(configMap); } public Optional<ConfigMap> getConfigMap(String name) { ConfigMap configMap = kubernetesClient.configMaps() .inNamespace(namespace) .withName(name) .get(); return Optional.ofNullable(configMap); } // Secret Operations public Secret createSecret(String name, Map<String, String> data) { Secret secret = new SecretBuilder() .withNewMetadata() .withName(name) .withNamespace(namespace) .endMetadata() .withStringData(data) .build(); return kubernetesClient.secrets() .inNamespace(namespace) .create(secret); } // Namespace Operations public List<Namespace> getNamespaces() { return kubernetesClient.namespaces() .list() .getItems(); } public Namespace createNamespace(String name) { Namespace namespaceObj = new NamespaceBuilder() .withNewMetadata() .withName(name) .endMetadata() .build(); return kubernetesClient.namespaces() .create(namespaceObj); } // Custom Resource Operations public <T extends io.fabric8.kubernetes.client.CustomResource<?, ?>> MixedOperation<T, ?, ?> getCustomResourceClient(Class<T> resourceClass) { return kubernetesClient.resources(resourceClass); } // Scale Deployment public Deployment scaleDeployment(String name, int replicas) { return kubernetesClient.apps() .deployments() .inNamespace(namespace) .withName(name) .scale(replicas); } // Get Pod Logs public String getPodLogs(String podName) { return kubernetesClient.pods() .inNamespace(namespace) .withName(podName) .getLog(); } // Execute Command in Pod public String executeCommandInPod(String podName, String containerName, String... command) { return kubernetesClient.pods() .inNamespace(namespace) .withName(podName) .inContainer(containerName) .writingOutput(System.out) .exec(command); } // Health Check - Verify cluster connectivity public boolean isClusterHealthy() { try { kubernetesClient.getApiGroups(); return true; } catch (Exception e) { return false; } } }
2. Custom Resource Watcher
package com.company.k8s.watcher; import io.fabric8.kubernetes.client.Watcher; import io.fabric8.kubernetes.client.WatcherException; import io.fabric8.kubernetes.client.dsl.MixedOperation; import com.company.k8s.ApplicationConfig; import org.jboss.logging.Logger; import javax.enterprise.context.ApplicationScoped; import javax.inject.Inject; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; /** * Watcher for ApplicationConfig custom resources */ @ApplicationScoped public class ApplicationConfigWatcher implements Watcher<ApplicationConfig> { private static final Logger LOG = Logger.getLogger(ApplicationConfigWatcher.class); @Inject MixedOperation<ApplicationConfig, ?, ?> applicationConfigClient; @Inject ApplicationConfigService applicationConfigService; private final ConcurrentMap<String, ApplicationConfig> cache = new ConcurrentHashMap<>(); public void startWatching() { LOG.info("Starting ApplicationConfig watcher..."); applicationConfigClient.inAnyNamespace().watch(this); } @Override public void eventReceived(Action action, ApplicationConfig resource) { String name = resource.getMetadata().getName(); String namespace = resource.getMetadata().getNamespace(); LOG.infof("ApplicationConfig %s in namespace %s: %s", name, namespace, action); switch (action) { case ADDED: case MODIFIED: cache.put(getCacheKey(namespace, name), resource); applicationConfigService.handleConfigUpdate(resource); break; case DELETED: cache.remove(getCacheKey(namespace, name)); applicationConfigService.handleConfigDeletion(resource); break; case ERROR: LOG.errorf("Error watching ApplicationConfig %s in namespace %s", name, namespace); break; } } @Override public void onClose(WatcherException cause) { if (cause != null) { LOG.error("Watcher closed with error", cause); // Attempt to restart watcher restartWatcher(); } else { LOG.info("Watcher closed normally"); } } private void restartWatcher() { try { Thread.sleep(5000); // Wait 5 seconds before restart startWatching(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); LOG.error("Failed to restart watcher", e); } } private String getCacheKey(String namespace, String name) { return namespace + "/" + name; } public ApplicationConfig getCachedConfig(String namespace, String name) { return cache.get(getCacheKey(namespace, name)); } }

Health Checks and Metrics

1. Custom Health Checks
package com.company.health; import org.eclipse.microprofile.health.HealthCheck; import org.eclipse.microprofile.health.HealthCheckResponse; import org.eclipse.microprofile.health.Liveness; import org.eclipse.microprofile.health.Readiness; import org.eclipse.microprofile.health.Startup; import javax.enterprise.context.ApplicationScoped; import javax.inject.Inject; /** * Kubernetes health checks */ @ApplicationScoped public class KubernetesHealthChecks { @Inject com.company.k8s.client.KubernetesClientService kubernetesClientService; @Liveness HealthCheck liveness() { return () -> HealthCheckResponse.named("user-service-liveness") .status(isServiceAlive()) .withData("timestamp", System.currentTimeMillis()) .build(); } @Readiness HealthCheck readiness() { return () -> HealthCheckResponse.named("user-service-readiness") .status(isServiceReady()) .withData("database", checkDatabaseConnectivity()) .withData("cache", checkCacheConnectivity()) .withData("kubernetes", checkKubernetesConnectivity()) .build(); } @Startup HealthCheck startup() { return () -> HealthCheckResponse.named("user-service-startup") .status(isStartupComplete()) .withData("migrations", checkDatabaseMigrations()) .withData("config", checkConfigurationLoaded()) .build(); } private boolean isServiceAlive() { // Basic liveness check - is the application running? return true; } private boolean isServiceReady() { // Readiness check - can the application handle requests? return checkDatabaseConnectivity() && checkCacheConnectivity() && checkKubernetesConnectivity(); } private boolean isStartupComplete() { // Startup check - is the application fully initialized? return checkDatabaseMigrations() && checkConfigurationLoaded(); } private boolean checkDatabaseConnectivity() { // Implement database connectivity check return true; } private boolean checkCacheConnectivity() { // Implement cache connectivity check return true; } private boolean checkKubernetesConnectivity() { return kubernetesClientService.isClusterHealthy(); } private boolean checkDatabaseMigrations() { // Check if database migrations completed successfully return true; } private boolean checkConfigurationLoaded() { // Check if all required configuration is loaded return true; } }
2. Custom Metrics
package com.company.metrics; import io.micrometer.core.instrument.Counter; import io.micrometer.core.instrument.MeterRegistry; import io.micrometer.core.instrument.Timer; import org.eclipse.microprofile.metrics.MetricUnits; import org.eclipse.microprofile.metrics.annotation.Gauge; import javax.enterprise.context.ApplicationScoped; import javax.inject.Inject; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.TimeUnit; /** * Application metrics for Kubernetes monitoring */ @ApplicationScoped public class ApplicationMetrics { @Inject MeterRegistry meterRegistry; private final Counter requestsTotal; private final Counter errorsTotal; private final Timer requestDuration; private final ConcurrentMap<String, Counter> endpointCounters; public ApplicationMetrics(MeterRegistry meterRegistry) { this.meterRegistry = meterRegistry; this.requestsTotal = Counter.builder("app_requests_total") .description("Total number of requests") .register(meterRegistry); this.errorsTotal = Counter.builder("app_errors_total") .description("Total number of errors") .register(meterRegistry); this.requestDuration = Timer.builder("app_request_duration_seconds") .description("Request duration in seconds") .register(meterRegistry); this.endpointCounters = new ConcurrentHashMap<>(); } public void recordRequest(String endpoint, long durationMs) { requestsTotal.increment(); requestDuration.record(durationMs, TimeUnit.MILLISECONDS); // Record per-endpoint metrics String counterName = "app_endpoint_requests_total"; endpointCounters.computeIfAbsent(endpoint, ep -> Counter.builder(counterName) .tag("endpoint", ep) .register(meterRegistry) ).increment(); } public void recordError(String endpoint, String errorType) { errorsTotal.increment(); String counterName = "app_endpoint_errors_total"; endpointCounters.computeIfAbsent(endpoint + "_" + errorType, key -> Counter.builder(counterName) .tag("endpoint", endpoint) .tag("type", errorType) .register(meterRegistry) ).increment(); } @Gauge(name = "app_active_connections", unit = MetricUnits.NONE) public int getActiveConnections() { // Implement active connections tracking return 0; } @Gauge(name = "app_cache_size", unit = MetricUnits.NONE) public long getCacheSize() { // Implement cache size tracking return 0L; } @Gauge(name = "app_queue_size", unit = MetricUnits.NONE) public int getQueueSize() { // Implement queue size tracking return 0; } }

REST API with Kubernetes Integration

1. REST Resource with Kubernetes Operations
package com.company.resource; import com.company.k8s.client.KubernetesClientService; import com.company.metrics.ApplicationMetrics; import org.eclipse.microprofile.config.inject.ConfigProperty; import org.jboss.logging.Logger; import javax.inject.Inject; import javax.ws.rs.*; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import java.util.List; import java.util.Map; /** * REST resource exposing Kubernetes operations */ @Path("/api/k8s") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) public class KubernetesResource { private static final Logger LOG = Logger.getLogger(KubernetesResource.class); @Inject KubernetesClientService kubernetesClientService; @Inject ApplicationMetrics metrics; @ConfigProperty(name = "quarkus.application.name") String applicationName; @GET @Path("/deployments") public Response getDeployments() { long startTime = System.currentTimeMillis(); try { List<io.fabric8.kubernetes.api.model.apps.Deployment> deployments = kubernetesClientService.getDeployments(); metrics.recordRequest("getDeployments", System.currentTimeMillis() - startTime); return Response.ok(deployments).build(); } catch (Exception e) { metrics.recordError("getDeployments", "kubernetes_error"); LOG.error("Failed to get deployments", e); return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to retrieve deployments")) .build(); } } @GET @Path("/deployments/{name}") public Response getDeployment(@PathParam("name") String name) { long startTime = System.currentTimeMillis(); try { var deployment = kubernetesClientService.getDeployment(name); if (deployment.isEmpty()) { return Response.status(Response.Status.NOT_FOUND) .entity(Map.of("error", "Deployment not found: " + name)) .build(); } metrics.recordRequest("getDeployment", System.currentTimeMillis() - startTime); return Response.ok(deployment.get()).build(); } catch (Exception e) { metrics.recordError("getDeployment", "kubernetes_error"); LOG.errorf("Failed to get deployment: %s", name, e); return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to retrieve deployment: " + name)) .build(); } } @POST @Path("/deployments/{name}/scale") public Response scaleDeployment( @PathParam("name") String name, @QueryParam("replicas") int replicas) { long startTime = System.currentTimeMillis(); if (replicas < 0 || replicas > 10) { return Response.status(Response.Status.BAD_REQUEST) .entity(Map.of("error", "Replicas must be between 0 and 10")) .build(); } try { var deployment = kubernetesClientService.scaleDeployment(name, replicas); metrics.recordRequest("scaleDeployment", System.currentTimeMillis() - startTime); return Response.ok(Map.of( "message", "Deployment scaled successfully", "deployment", deployment.getMetadata().getName(), "replicas", deployment.getSpec().getReplicas() )).build(); } catch (Exception e) { metrics.recordError("scaleDeployment", "kubernetes_error"); LOG.errorf("Failed to scale deployment: %s to %d replicas", name, replicas, e); return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to scale deployment: " + name)) .build(); } } @GET @Path("/pods") public Response getPods(@QueryParam("labelSelector") String labelSelector) { long startTime = System.currentTimeMillis(); try { List<io.fabric8.kubernetes.api.model.Pod> pods; if (labelSelector != null && !labelSelector.isEmpty()) { pods = kubernetesClientService.getPodsByLabel(labelSelector); } else { // Get pods for current application pods = kubernetesClientService.getPodsForDeployment(applicationName); } metrics.recordRequest("getPods", System.currentTimeMillis() - startTime); return Response.ok(pods).build(); } catch (Exception e) { metrics.recordError("getPods", "kubernetes_error"); LOG.error("Failed to get pods", e); return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to retrieve pods")) .build(); } } @GET @Path("/cluster/health") public Response getClusterHealth() { long startTime = System.currentTimeMillis(); try { boolean isHealthy = kubernetesClientService.isClusterHealthy(); metrics.recordRequest("getClusterHealth", System.currentTimeMillis() - startTime); return Response.ok(Map.of( "healthy", isHealthy, "timestamp", System.currentTimeMillis() )).build(); } catch (Exception e) { metrics.recordError("getClusterHealth", "kubernetes_error"); LOG.error("Failed to check cluster health", e); return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to check cluster health")) .build(); } } @GET @Path("/configmaps/{name}") public Response getConfigMap(@PathParam("name") String name) { long startTime = System.currentTimeMillis(); try { var configMap = kubernetesClientService.getConfigMap(name); if (configMap.isEmpty()) { return Response.status(Response.Status.NOT_FOUND) .entity(Map.of("error", "ConfigMap not found: " + name)) .build(); } metrics.recordRequest("getConfigMap", System.currentTimeMillis() - startTime); return Response.ok(configMap.get()).build(); } catch (Exception e) { metrics.recordError("getConfigMap", "kubernetes_error"); LOG.errorf("Failed to get ConfigMap: %s", name, e); return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to retrieve ConfigMap: " + name)) .build(); } } }
2. Application Configuration Resource
package com.company.resource; import com.company.k8s.ApplicationConfig; import com.company.k8s.client.KubernetesClientService; import io.fabric8.kubernetes.client.dsl.MixedOperation; import javax.inject.Inject; import javax.ws.rs.*; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import java.util.List; import java.util.Map; /** * Resource for managing ApplicationConfig custom resources */ @Path("/api/configs") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) public class ApplicationConfigResource { @Inject KubernetesClientService kubernetesClientService; private MixedOperation<ApplicationConfig, ?, ?> getApplicationConfigClient() { return kubernetesClientService.getCustomResourceClient(ApplicationConfig.class); } @GET public Response getAllConfigs(@QueryParam("namespace") String namespace) { try { List<ApplicationConfig> configs; if (namespace != null && !namespace.isEmpty()) { configs = getApplicationConfigClient().inNamespace(namespace).list().getItems(); } else { configs = getApplicationConfigClient().inAnyNamespace().list().getItems(); } return Response.ok(configs).build(); } catch (Exception e) { return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to retrieve application configs")) .build(); } } @GET @Path("/{namespace}/{name}") public Response getConfig( @PathParam("namespace") String namespace, @PathParam("name") String name) { try { ApplicationConfig config = getApplicationConfigClient() .inNamespace(namespace) .withName(name) .get(); if (config == null) { return Response.status(Response.Status.NOT_FOUND) .entity(Map.of("error", "ApplicationConfig not found")) .build(); } return Response.ok(config).build(); } catch (Exception e) { return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to retrieve application config")) .build(); } } @POST public Response createConfig(ApplicationConfig config) { try { String namespace = config.getMetadata().getNamespace(); if (namespace == null) { namespace = "default"; config.getMetadata().setNamespace(namespace); } ApplicationConfig created = getApplicationConfigClient() .inNamespace(namespace) .create(config); return Response.status(Response.Status.CREATED) .entity(created) .build(); } catch (Exception e) { return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to create application config")) .build(); } } @PUT @Path("/{namespace}/{name}") public Response updateConfig( @PathParam("namespace") String namespace, @PathParam("name") String name, ApplicationConfig config) { try { ApplicationConfig updated = getApplicationConfigClient() .inNamespace(namespace) .withName(name) .patch(config); return Response.ok(updated).build(); } catch (Exception e) { return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to update application config")) .build(); } } @DELETE @Path("/{namespace}/{name}") public Response deleteConfig( @PathParam("namespace") String namespace, @PathParam("name") String name) { try { boolean deleted = getApplicationConfigClient() .inNamespace(namespace) .withName(name) .delete(); if (deleted) { return Response.ok(Map.of("message", "ApplicationConfig deleted successfully")).build(); } else { return Response.status(Response.Status.NOT_FOUND) .entity(Map.of("error", "ApplicationConfig not found")) .build(); } } catch (Exception e) { return Response.status(Response.Status.INTERNAL_SERVER_ERROR) .entity(Map.of("error", "Failed to delete application config")) .build(); } } }

Deployment and Build Configuration

1. Dockerfile Configuration
# Multi-stage Dockerfile FROM quay.io/quarkus/ubi-quarkus-native-image:22.3-java17 AS build WORKDIR /project COPY --chown=quarkus:quarkus mvnw /project/mvnw COPY --chown=quarkus:quarkus .mvn /project/.mvn COPY --chown=quarkus:quarkus pom.xml /project/ COPY --chown=quarkus:quarkus src /project/src USER quarkus RUN ./mvnw package -Dnative FROM registry.access.redhat.com/ubi8/ubi-minimal:8.7 WORKDIR /work/ COPY --from=build /project/target/*-runner /work/application RUN chmod 775 /work EXPOSE 8080 USER 1001 CMD ["./application", "-Dquarkus.http.host=0.0.0.0"]
2. Kubernetes Deployment Manifests
# Generated by Quarkus Kubernetes extension apiVersion: apps/v1 kind: Deployment metadata: name: user-service namespace: default labels: app.kubernetes.io/name: user-service app.kubernetes.io/version: 1.0.0 app.kubernetes.io/part-of: user-management annotations: description: "User Management Microservice" spec: replicas: 3 selector: matchLabels: app.kubernetes.io/name: user-service template: metadata: labels: app.kubernetes.io/name: user-service app.kubernetes.io/version: 1.0.0 spec: serviceAccountName: user-service-account securityContext: runAsUser: 1001 runAsNonRoot: true containers: - name: user-service image: quay.io/company/user-service:1.0.0 imagePullPolicy: IfNotPresent ports: - name: http containerPort: 8080 env: - name: JAVA_OPTS value: "-Xmx256m -Xms128m" - name: KUBERNETES_NAMESPACE valueFrom: fieldRef: fieldPath: metadata.namespace resources: requests: memory: "256Mi" cpu: "100m" limits: memory: "512Mi" cpu: "500m" livenessProbe: httpGet: path: /q/health/live port: http initialDelaySeconds: 30 periodSeconds: 10 readinessProbe: httpGet: path: /q/health/ready port: http initialDelaySeconds: 5 periodSeconds: 10 startupProbe: httpGet: path: /q/health/started port: http initialDelaySeconds: 5 periodSeconds: 10 failureThreshold: 30 --- apiVersion: v1 kind: Service metadata: name: user-service namespace: default labels: app.kubernetes.io/name: user-service app.kubernetes.io/version: 1.0.0 spec: ports: - name: http port: 8080 targetPort: 8080 selector: app.kubernetes.io/name: user-service type: ClusterIP --- apiVersion: v1 kind: ServiceAccount metadata: name: user-service-account namespace: default --- apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: namespace: default name: user-service-role rules: - apiGroups: [""] resources: ["pods", "services", "configmaps", "secrets"] verbs: ["get", "list", "watch"] - apiGroups: ["apps"] resources: ["deployments"] verbs: ["get", "list", "watch", "patch"] - apiGroups: ["company.com"] resources: ["applicationconfigs"] verbs: ["get", "list", "watch", "create", "update", "patch", "delete"] --- apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding metadata: name: user-service-role-binding namespace: default subjects: - kind: ServiceAccount name: user-service-account namespace: default roleRef: kind: Role name: user-service-role apiGroup: rbac.authorization.k8s.io

Testing

1. Kubernetes Client Test
package com.company.k8s.test; import io.fabric8.kubernetes.client.KubernetesClient; import io.fabric8.kubernetes.client.server.mock.KubernetesServer; import io.quarkus.test.junit.QuarkusTest; import io.quarkus.test.kubernetes.client.KubernetesTestServer; import io.quarkus.test.kubernetes.client.WithKubernetesTestServer; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import javax.inject.Inject; import static org.junit.jupiter.api.Assertions.*; @QuarkusTest @WithKubernetesTestServer class KubernetesClientServiceTest { @KubernetesTestServer KubernetesServer mockServer; @Inject KubernetesClient kubernetesClient; @Inject com.company.k8s.client.KubernetesClientService kubernetesClientService; @BeforeEach void setup() { // Setup mock responses mockServer.expect().get().withPath("/api/v1/namespaces/default/pods") .andReturn(200, "{\"items\": []}") .always(); } @Test void testClusterHealth() { assertTrue(kubernetesClientService.isClusterHealthy()); } @Test void testGetDeployments() { var deployments = kubernetesClientService.getDeployments(); assertNotNull(deployments); assertTrue(deployments.isEmpty()); } }
2. Resource Test
package com.company.resource.test; import io.quarkus.test.junit.QuarkusTest; import io.restassured.RestAssured; import org.junit.jupiter.api.Test; import static org.hamcrest.Matchers.*; @QuarkusTest class KubernetesResourceTest { @Test void testClusterHealth() { RestAssured.given() .when().get("/api/k8s/cluster/health") .then() .statusCode(200) .body("healthy", is(true)); } @Test void testGetDeployments() { RestAssured.given() .when().get("/api/k8s/deployments") .then() .statusCode(200) .body("$", hasSize(greaterThanOrEqualTo(0))); } }

Summary

The Quarkus Kubernetes extension provides:

  1. Seamless Kubernetes Integration: Automatic resource generation and deployment
  2. Type-Safe Kubernetes Client: Easy interaction with Kubernetes API
  3. Health and Metrics: Built-in health checks and Prometheus metrics
  4. Custom Resources: Support for Custom Resource Definitions
  5. Security: RBAC configuration and security context
  6. Development Experience: Fast development with live coding and testing

Key Benefits:

  • Reduced boilerplate for Kubernetes deployments
  • Native compilation for fast startup and low memory footprint
  • Comprehensive monitoring and observability
  • Easy configuration management
  • Excellent developer experience with live reload

This setup enables rapid development of cloud-native Java applications that are optimized for Kubernetes environments.

Category : JAVA

Leave a Reply

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


Macro Nepal Helper