google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
Custom Resource Definitions (CRDs) in Java
awiskar acharya
November 18, 2025
9:26 am

Comprehensive CRD Implementation Guide

1. CRD Definition for Java Application

Custom Resource Definition YAML

# crds/javapp-crd.yaml apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: name: javapps.example.com spec: group: example.com names: kind: JavApp listKind: JavAppList plural: javapps singular: javapp shortNames: - ja scope: Namespaced versions: - name: v1alpha1 served: true storage: true schema: openAPIV3Schema: type: object properties: spec: type: object properties: applicationName: type: string description: Name of the Java application version: type: string description: Application version replicas: type: integer minimum: 1 maximum: 10 default: 1 image: type: string description: Container image for the application jvmOptions: type: string description: JVM options resources: type: object properties: requests: type: object properties: cpu: type: string default: "100m" memory: type: string default: "256Mi" limits: type: object properties: cpu: type: string default: "500m" memory: type: string default: "512Mi" service: type: object properties: type: type: string enum: [ClusterIP, NodePort, LoadBalancer] default: ClusterIP port: type: integer minimum: 1 maximum: 65535 default: 8080 ingress: type: object properties: enabled: type: boolean default: false host: type: string config: type: object additionalProperties: type: string required: - applicationName - version - image status: type: object properties: phase: type: string enum: [Pending, Deploying, Ready, Failed, Updating] message: type: string deployedReplicas: type: integer availableReplicas: type: integer serviceUrl: type: string lastUpdated: type: string format: date-time subresources: status: {} additionalPrinterColumns: - name: Phase type: string jsonPath: .status.phase - name: Version type: string jsonPath: .spec.version - name: Replicas type: integer jsonPath: .spec.replicas - name: Age type: date jsonPath: .metadata.creationTimestamp

2. Java Model Classes for CRD

Custom Resource Model

// JavApp.java package com.example.crd.model; import io.fabric8.kubernetes.client.CustomResource; import io.fabric8.kubernetes.model.annotation.Group; import io.fabric8.kubernetes.model.annotation.Version; @Group("example.com") @Version("v1alpha1") public class JavApp extends CustomResource<JavAppSpec, JavAppStatus> { @Override protected JavAppSpec initSpec() { return new JavAppSpec(); } @Override protected JavAppStatus initStatus() { return new JavAppStatus(); } } // JavAppSpec.java package com.example.crd.model; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; @JsonDeserialize public class JavAppSpec { @JsonProperty("applicationName") private String applicationName; @JsonProperty("version") private String version; @JsonProperty("replicas") private Integer replicas = 1; @JsonProperty("image") private String image; @JsonProperty("jvmOptions") private String jvmOptions = "-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0"; @JsonProperty("resources") private ResourceRequirements resources = new ResourceRequirements(); @JsonProperty("service") private ServiceConfig service = new ServiceConfig(); @JsonProperty("ingress") private IngressConfig ingress = new IngressConfig(); @JsonProperty("config") private java.util.Map<String, String> config = new java.util.HashMap<>(); // Getters and Setters public String getApplicationName() { return applicationName; } public void setApplicationName(String applicationName) { this.applicationName = applicationName; } public String getVersion() { return version; } public void setVersion(String version) { this.version = version; } public Integer getReplicas() { return replicas; } public void setReplicas(Integer replicas) { this.replicas = replicas; } public String getImage() { return image; } public void setImage(String image) { this.image = image; } public String getJvmOptions() { return jvmOptions; } public void setJvmOptions(String jvmOptions) { this.jvmOptions = jvmOptions; } public ResourceRequirements getResources() { return resources; } public void setResources(ResourceRequirements resources) { this.resources = resources; } public ServiceConfig getService() { return service; } public void setService(ServiceConfig service) { this.service = service; } public IngressConfig getIngress() { return ingress; } public void setIngress(IngressConfig ingress) { this.ingress = ingress; } public java.util.Map<String, String> getConfig() { return config; } public void setConfig(java.util.Map<String, String> config) { this.config = config; } } // JavAppStatus.java package com.example.crd.model; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; @JsonDeserialize public class JavAppStatus { public enum Phase { Pending, Deploying, Ready, Failed, Updating } @JsonProperty("phase") private Phase phase = Phase.Pending; @JsonProperty("message") private String message; @JsonProperty("deployedReplicas") private Integer deployedReplicas = 0; @JsonProperty("availableReplicas") private Integer availableReplicas = 0; @JsonProperty("serviceUrl") private String serviceUrl; @JsonProperty("lastUpdated") private String lastUpdated; // Getters and Setters public Phase getPhase() { return phase; } public void setPhase(Phase phase) { this.phase = phase; } public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } public Integer getDeployedReplicas() { return deployedReplicas; } public void setDeployedReplicas(Integer deployedReplicas) { this.deployedReplicas = deployedReplicas; } public Integer getAvailableReplicas() { return availableReplicas; } public void setAvailableReplicas(Integer availableReplicas) { this.availableReplicas = availableReplicas; } public String getServiceUrl() { return serviceUrl; } public void setServiceUrl(String serviceUrl) { this.serviceUrl = serviceUrl; } public String getLastUpdated() { return lastUpdated; } public void setLastUpdated(String lastUpdated) { this.lastUpdated = lastUpdated; } } // Supporting classes class ResourceRequirements { private Resource requests = new Resource("100m", "256Mi"); private Resource limits = new Resource("500m", "512Mi"); // Getters and Setters public Resource getRequests() { return requests; } public void setRequests(Resource requests) { this.requests = requests; } public Resource getLimits() { return limits; } public void setLimits(Resource limits) { this.limits = limits; } } class Resource { private String cpu; private String memory; public Resource() {} public Resource(String cpu, String memory) { this.cpu = cpu; this.memory = memory; } // Getters and Setters public String getCpu() { return cpu; } public void setCpu(String cpu) { this.cpu = cpu; } public String getMemory() { return memory; } public void setMemory(String memory) { this.memory = memory; } } class ServiceConfig { private String type = "ClusterIP"; private Integer port = 8080; // Getters and Setters public String getType() { return type; } public void setType(String type) { this.type = type; } public Integer getPort() { return port; } public void setPort(Integer port) { this.port = port; } } class IngressConfig { private Boolean enabled = false; private String host; // Getters and Setters public Boolean getEnabled() { return enabled; } public void setEnabled(Boolean enabled) { this.enabled = enabled; } public String getHost() { return host; } public void setHost(String host) { this.host = host; } }

3. Custom Controller Implementation

Main Controller Class

// JavAppController.java package com.example.crd.controller; import com.example.crd.model.JavApp; import com.example.crd.model.JavAppStatus; import io.fabric8.kubernetes.api.model.*; import io.fabric8.kubernetes.api.model.apps.Deployment; import io.fabric8.kubernetes.api.model.apps.DeploymentBuilder; import io.fabric8.kubernetes.client.KubernetesClient; import io.fabric8.kubernetes.client.informers.ResourceEventHandler; import io.fabric8.kubernetes.client.informers.SharedIndexInformer; import io.fabric8.kubernetes.client.informers.SharedInformerFactory; import io.javaoperatorsdk.operator.api.*; import io.javaoperatorsdk.operator.api.Context; import io.javaoperatorsdk.operator.processing.event.source.EventSource; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; import java.time.Instant; import java.util.HashMap; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @Component @Controller public class JavAppController implements ResourceController<JavApp> { private static final Logger logger = LoggerFactory.getLogger(JavAppController.class); private final KubernetesClient kubernetesClient; private final Map<String, Long> lastProcessed = new ConcurrentHashMap<>(); public JavAppController(KubernetesClient kubernetesClient) { this.kubernetesClient = kubernetesClient; } @Override public UpdateControl<JavApp> createOrUpdateResource(JavApp javApp, Context<JavApp> context) { String namespace = javApp.getMetadata().getNamespace(); String name = javApp.getMetadata().getName(); logger.info("Processing JavApp: {}/{}", namespace, name); try { // Check if we recently processed this resource String key = namespace + "/" + name; long currentTime = System.currentTimeMillis(); if (lastProcessed.containsKey(key)) { long lastTime = lastProcessed.get(key); if (currentTime - lastTime < 30000) { // 30 seconds cooldown logger.debug("Skipping recently processed resource: {}", key); return UpdateControl.noUpdate(); } } lastProcessed.put(key, currentTime); // Create or update deployment Deployment deployment = createDeployment(javApp); kubernetesClient.apps().deployments() .inNamespace(namespace) .withName(name) .createOrReplace(deployment); // Create or update service Service service = createService(javApp); kubernetesClient.services() .inNamespace(namespace) .withName(name) .createOrReplace(service); // Create ingress if enabled if (javApp.getSpec().getIngress().getEnabled()) { createIngress(javApp); } // Create config map for application configuration createConfigMap(javApp); // Update status updateStatus(javApp, deployment); logger.info("Successfully processed JavApp: {}/{}", namespace, name); return UpdateControl.updateStatus(javApp); } catch (Exception e) { logger.error("Error processing JavApp: {}/{}", namespace, name, e); updateStatusWithError(javApp, e.getMessage()); return UpdateControl.updateStatus(javApp); } } private Deployment createDeployment(JavApp javApp) { Map<String, String> labels = createLabels(javApp); return new DeploymentBuilder() .withNewMetadata() .withName(javApp.getMetadata().getName()) .withNamespace(javApp.getMetadata().getNamespace()) .withLabels(labels) .endMetadata() .withNewSpec() .withReplicas(javApp.getSpec().getReplicas()) .withNewSelector() .withMatchLabels(labels) .endSelector() .withNewTemplate() .withNewMetadata() .withLabels(labels) .endMetadata() .withNewSpec() .addNewContainer() .withName(javApp.getSpec().getApplicationName()) .withImage(javApp.getSpec().getImage()) .withPorts(new ContainerPortBuilder() .withContainerPort(javApp.getSpec().getService().getPort()) .build()) .withEnv(createEnvironmentVariables(javApp)) .withResources(createResourceRequirements(javApp)) .withLivenessProbe(createLivenessProbe(javApp)) .withReadinessProbe(createReadinessProbe(javApp)) .withNewSecurityContext() .withRunAsNonRoot(true) .withNewRunAsUser(1000L) .endSecurityContext() .endContainer() .withServiceAccountName(javApp.getMetadata().getName() + "-sa") .endSpec() .endTemplate() .endSpec() .build(); } private Service createService(JavApp javApp) { Map<String, String> labels = createLabels(javApp); return new ServiceBuilder() .withNewMetadata() .withName(javApp.getMetadata().getName()) .withNamespace(javApp.getMetadata().getNamespace()) .withLabels(labels) .endMetadata() .withNewSpec() .withType(javApp.getSpec().getService().getType()) .withPorts(new ServicePortBuilder() .withPort(javApp.getSpec().getService().getPort()) .withTargetPort(new IntOrString(javApp.getSpec().getService().getPort())) .build()) .withSelector(labels) .endSpec() .build(); } private void createIngress(JavApp javApp) { // Ingress creation implementation logger.info("Creating ingress for: {}", javApp.getMetadata().getName()); } private void createConfigMap(JavApp javApp) { ConfigMap configMap = new ConfigMapBuilder() .withNewMetadata() .withName(javApp.getMetadata().getName() + "-config") .withNamespace(javApp.getMetadata().getNamespace()) .endMetadata() .withData(javApp.getSpec().getConfig()) .build(); kubernetesClient.configMaps() .inNamespace(javApp.getMetadata().getNamespace()) .withName(javApp.getMetadata().getName() + "-config") .createOrReplace(configMap); } private Map<String, String> createLabels(JavApp javApp) { Map<String, String> labels = new HashMap<>(); labels.put("app", javApp.getMetadata().getName()); labels.put("version", javApp.getSpec().getVersion()); labels.put("managed-by", "javapp-controller"); return labels; } private EnvVar[] createEnvironmentVariables(JavApp javApp) { return new EnvVar[] { new EnvVarBuilder() .withName("JAVA_OPTS") .withValue(javApp.getSpec().getJvmOptions()) .build(), new EnvVarBuilder() .withName("SPRING_PROFILES_ACTIVE") .withValue("kubernetes") .build(), new EnvVarBuilder() .withName("APPLICATION_NAME") .withValue(javApp.getSpec().getApplicationName()) .build() }; } private io.fabric8.kubernetes.api.model.ResourceRequirements createResourceRequirements(JavApp javApp) { return new io.fabric8.kubernetes.api.model.ResourceRequirementsBuilder() .addToRequests("cpu", new Quantity(javApp.getSpec().getResources().getRequests().getCpu())) .addToRequests("memory", new Quantity(javApp.getSpec().getResources().getRequests().getMemory())) .addToLimits("cpu", new Quantity(javApp.getSpec().getResources().getLimits().getCpu())) .addToLimits("memory", new Quantity(javApp.getSpec().getResources().getLimits().getMemory())) .build(); } private Probe createLivenessProbe(JavApp javApp) { return new ProbeBuilder() .withNewHttpGet() .withPath("/actuator/health/liveness") .withPort(new IntOrString(javApp.getSpec().getService().getPort())) .endHttpGet() .withInitialDelaySeconds(30) .withPeriodSeconds(10) .build(); } private Probe createReadinessProbe(JavApp javApp) { return new ProbeBuilder() .withNewHttpGet() .withPath("/actuator/health/readiness") .withPort(new IntOrString(javApp.getSpec().getService().getPort())) .endHttpGet() .withInitialDelaySeconds(5) .withPeriodSeconds(5) .build(); } private void updateStatus(JavApp javApp, Deployment deployment) { JavAppStatus status = javApp.getStatus(); if (deployment != null) { status.setDeployedReplicas(deployment.getStatus().getReplicas()); status.setAvailableReplicas(deployment.getStatus().getAvailableReplicas()); if (deployment.getStatus().getAvailableReplicas() != null && deployment.getStatus().getAvailableReplicas() >= javApp.getSpec().getReplicas()) { status.setPhase(JavAppStatus.Phase.Ready); status.setMessage("Application is ready and serving traffic"); } else { status.setPhase(JavAppStatus.Phase.Deploying); status.setMessage("Application is being deployed"); } } status.setServiceUrl(createServiceUrl(javApp)); status.setLastUpdated(Instant.now().toString()); } private void updateStatusWithError(JavApp javApp, String errorMessage) { JavAppStatus status = javApp.getStatus(); status.setPhase(JavAppStatus.Phase.Failed); status.setMessage("Error: " + errorMessage); status.setLastUpdated(Instant.now().toString()); } private String createServiceUrl(JavApp javApp) { return String.format("http://%s.%s:%d", javApp.getMetadata().getName(), javApp.getMetadata().getNamespace(), javApp.getSpec().getService().getPort()); } @Override public DeleteControl deleteResource(JavApp javApp, Context<JavApp> context) { String namespace = javApp.getMetadata().getNamespace(); String name = javApp.getMetadata().getName(); logger.info("Deleting JavApp resources: {}/{}", namespace, name); // Clean up resources kubernetesClient.apps().deployments() .inNamespace(namespace) .withName(name) .delete(); kubernetesClient.services() .inNamespace(namespace) .withName(name) .delete(); kubernetesClient.configMaps() .inNamespace(namespace) .withName(name + "-config") .delete(); logger.info("Successfully deleted JavApp resources: {}/{}", namespace, name); return DeleteControl.DEFAULT_DELETE; } }

4. Operator Configuration

Spring Boot Configuration

// OperatorConfiguration.java package com.example.crd.config; import com.example.crd.model.JavApp; import io.fabric8.kubernetes.client.KubernetesClient; import io.javaoperatorsdk.operator.Operator; import io.javaoperatorsdk.operator.api.config.ConfigurationService; import io.javaoperatorsdk.operator.config.runtime.DefaultConfigurationService; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class OperatorConfiguration { @Bean public Operator operator(KubernetesClient kubernetesClient, ConfigurationService configurationService) { return new Operator(kubernetesClient, configurationService); } @Bean public ConfigurationService configurationService() { return DefaultConfigurationService.instance(); } } // KubernetesClientConfiguration.java package com.example.crd.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; import org.springframework.context.annotation.Profile; @Configuration public class KubernetesClientConfiguration { @Value("${kubernetes.master.url:}") private String masterUrl; @Value("${kubernetes.namespace:default}") private String namespace; @Bean @Profile("!test") public KubernetesClient kubernetesClient() { Config config = new ConfigBuilder() .withMasterUrl(masterUrl) .withNamespace(namespace) .withTrustCerts(true) .build(); return new DefaultKubernetesClient(config); } @Bean @Profile("test") public KubernetesClient mockKubernetesClient() { // Return mock client for testing return new DefaultKubernetesClient(); } }

5. Custom Resource Examples

Sample JavApp Resource

# examples/javapp-example.yaml apiVersion: example.com/v1alpha1 kind: JavApp metadata: name: user-service namespace: production labels: environment: production team: backend spec: applicationName: user-service version: "1.2.0" replicas: 3 image: "ghcr.io/my-org/user-service:1.2.0" jvmOptions: "-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0 -Xmx512m" resources: requests: cpu: "200m" memory: "512Mi" limits: cpu: "1000m" memory: "1024Mi" service: type: ClusterIP port: 8080 ingress: enabled: true host: users.example.com config: SPRING_DATASOURCE_URL: "jdbc:postgresql://postgresql:5432/users" SPRING_DATASOURCE_USERNAME: "user" LOGGING_LEVEL_COM_EXAMPLE: "INFO"

6. Webhook Validation

Validation Webhook

// JavAppValidationWebhook.java package com.example.crd.webhook; import com.example.crd.model.JavApp; import io.fabric8.kubernetes.api.model.admission.v1.AdmissionRequest; import io.fabric8.kubernetes.api.model.admission.v1.AdmissionResponse; import io.fabric8.kubernetes.api.model.admission.v1.AdmissionReview; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; import java.util.regex.Pattern; @RestController public class JavAppValidationWebhook { private static final Logger logger = LoggerFactory.getLogger(JavAppValidationWebhook.class); private static final Pattern NAME_PATTERN = Pattern.compile("^[a-z0-9]([-a-z0-9]*[a-z0-9])?$"); @PostMapping("/validate") public AdmissionReview validate(@RequestBody AdmissionReview admissionReview) { AdmissionRequest request = admissionReview.getRequest(); AdmissionResponse response = new AdmissionResponse(); try { if (request.getObject() instanceof JavApp) { JavApp javApp = (JavApp) request.getObject(); ValidationResult result = validateJavApp(javApp); response.setUid(request.getUid()); response.setAllowed(result.isValid()); if (!result.isValid()) { response.setStatus(new io.fabric8.kubernetes.api.model.Status( "Failure", null, result.getMessage(), 422, null )); } } } catch (Exception e) { logger.error("Error validating JavApp", e); response.setUid(request.getUid()); response.setAllowed(false); response.setStatus(new io.fabric8.kubernetes.api.model.Status( "Error", null, "Validation error: " + e.getMessage(), 500, null )); } admissionReview.setResponse(response); return admissionReview; } private ValidationResult validateJavApp(JavApp javApp) { // Validate name if (!NAME_PATTERN.matcher(javApp.getMetadata().getName()).matches()) { return ValidationResult.invalid("Name must consist of lower case alphanumeric characters or '-', and must start and end with an alphanumeric character"); } // Validate replicas if (javApp.getSpec().getReplicas() < 1 || javApp.getSpec().getReplicas() > 10) { return ValidationResult.invalid("Replicas must be between 1 and 10"); } // Validate image format if (!isValidImage(javApp.getSpec().getImage())) { return ValidationResult.invalid("Image must be in the format: [registry/]repository[:tag]"); } // Validate resource requests if (!isValidResource(javApp.getSpec().getResources().getRequests().getCpu()) || !isValidResource(javApp.getSpec().getResources().getRequests().getMemory()) || !isValidResource(javApp.getSpec().getResources().getLimits().getCpu()) || !isValidResource(javApp.getSpec().getResources().getLimits().getMemory())) { return ValidationResult.invalid("Resource requests and limits must be valid Kubernetes quantities"); } return ValidationResult.valid(); } private boolean isValidImage(String image) { return image != null && !image.trim().isEmpty() && image.contains(":"); } private boolean isValidResource(String resource) { try { new io.fabric8.kubernetes.api.model.Quantity(resource); return true; } catch (Exception e) { return false; } } private static class ValidationResult { private final boolean valid; private final String message; private ValidationResult(boolean valid, String message) { this.valid = valid; this.message = message; } public static ValidationResult valid() { return new ValidationResult(true, null); } public static ValidationResult invalid(String message) { return new ValidationResult(false, message); } public boolean isValid() { return valid; } public String getMessage() { return message; } } }

7. Monitoring and Metrics

Custom Metrics Collector

// JavAppMetricsCollector.java package com.example.crd.metrics; import com.example.crd.model.JavApp; import io.fabric8.kubernetes.client.KubernetesClient; import io.micrometer.core.instrument.Gauge; import io.micrometer.core.instrument.MeterRegistry; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; @Component public class JavAppMetricsCollector { private final KubernetesClient kubernetesClient; private final MeterRegistry meterRegistry; private final AtomicInteger totalJavApps = new AtomicInteger(0); private final AtomicInteger readyJavApps = new AtomicInteger(0); public JavAppMetricsCollector(KubernetesClient kubernetesClient, MeterRegistry meterRegistry) { this.kubernetesClient = kubernetesClient; this.meterRegistry = meterRegistry; initializeMetrics(); } private void initializeMetrics() { Gauge.builder("javapp_controller_resources_total") .description("Total number of JavApp resources") .register(meterRegistry, totalJavApps); Gauge.builder("javapp_controller_resources_ready") .description("Number of ready JavApp resources") .register(meterRegistry, readyJavApps); } @Scheduled(fixedRate = 30000) // Every 30 seconds public void collectMetrics() { try { List<JavApp> javApps = kubernetesClient.resources(JavApp.class) .inAnyNamespace() .list() .getItems(); totalJavApps.set(javApps.size()); long readyCount = javApps.stream() .filter(app -> app.getStatus() != null && app.getStatus().getPhase() == JavAppStatus.Phase.Ready) .count(); readyJavApps.set((int) readyCount); } catch (Exception e) { // Log error but don't fail } } }

8. Testing Framework

Controller Unit Tests

// JavAppControllerTest.java package com.example.crd.controller; import com.example.crd.model.JavApp; import com.example.crd.model.JavAppSpec; import io.fabric8.kubernetes.api.model.ObjectMeta; import io.fabric8.kubernetes.client.KubernetesClient; import io.fabric8.kubernetes.client.server.mock.EnableKubernetesMockClient; import io.javaoperatorsdk.operator.api.Context; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; import static org.junit.jupiter.api.Assertions.*; @SpringBootTest @EnableKubernetesMockClient class JavAppControllerTest { private JavAppController controller; private KubernetesClient kubernetesClient; @BeforeEach void setUp() { controller = new JavAppController(kubernetesClient); } @Test void testCreateOrUpdateResource() { // Given JavApp javApp = createTestJavApp(); // When var result = controller.createOrUpdateResource(javApp, new TestContext()); // Then assertNotNull(result); assertEquals("Ready", javApp.getStatus().getPhase().name()); } private JavApp createTestJavApp() { JavApp javApp = new JavApp(); ObjectMeta metadata = new ObjectMeta(); metadata.setName("test-app"); metadata.setNamespace("default"); javApp.setMetadata(metadata); JavAppSpec spec = new JavAppSpec(); spec.setApplicationName("test-app"); spec.setVersion("1.0.0"); spec.setReplicas(1); spec.setImage("test/image:1.0.0"); javApp.setSpec(spec); return javApp; } private static class TestContext implements Context<JavApp> { @Override public JavApp getResource() { return null; } @Override public <T> T getSecondaryResource(Class<T> aClass, String s) { return null; } @Override public RetryInfo getRetryInfo() { return null; } } }

This comprehensive CRD implementation provides:

  • Complete CRD definition with validation schema
  • Java operator using Java Operator SDK
  • Automatic resource management (Deployments, Services, ConfigMaps)
  • Status updates and health monitoring
  • Validation webhooks for admission control
  • Metrics collection for monitoring
  • Comprehensive testing framework
  • Spring Boot integration

The operator automatically manages the complete lifecycle of Java applications in Kubernetes based on the custom resource specifications.

Category : JAVA

Leave a Reply

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


Macro Nepal Helper