If you've ever built an application for Kubernetes, you've spent a significant amount of time writing, debugging, and maintaining YAML manifests. While powerful, this process can be error-prone, difficult to reuse, and disconnected from your application's primary language. What if you could define your Kubernetes infrastructure using the full power of a mature, object-oriented language like Java?

Enter CDK8s (Cloud Development Kit for Kubernetes). It allows you to define your Kubernetes applications and reusable components using familiar programming languages, and then synthesizes them into standard YAML. Let's explore how CDK8s brings the power of code to your Kubernetes workflows in Java.

What is CDK8s?

CDK8s is an open-source framework (part of the CNCF) that lets you define Kubernetes resources and applications using high-level programming languages instead of YAML. You can use constructs, loops, classes, and functions—everything you're used to in software development—to create your manifests.

The core value proposition is simple: Use code to define infrastructure.

Why CDK8s with Java?

While CDK8s also supports TypeScript, Python, and Go, using Java offers unique advantages for teams already invested in the Java ecosystem:

1. Type Safety: The Java CDK8s library is fully typed. This means you get compile-time checks, autocompletion in your IDE (like IntelliJ or Eclipse), and immediate feedback if you've misspelled a property or used an invalid value. No more kubectl apply surprises due to a simple indentation or typo.
2. Abstraction and Reusability: You can encapsulate common patterns into reusable classes. Need a standardized "Microservice" construct with specific labels, services, and probes? Create a Java class for it and instantiate it across your projects.
3. Integration with Build Tools: Your CDK8s definitions can be part of your existing Maven or Gradle build process, allowing you to generate manifests as part of your CI/CD pipeline.
4. Leverage Java Ecosystem: You can integrate configuration libraries (like Spring Boot's @ConfigurationProperties), write unit tests with JUnit, and generally apply all the best practices of Java development to your Kubernetes definitions.

How it Works: A Practical Example

Let's build a simple Kubernetes Deployment and Service for a Java application. We'll compare the traditional YAML approach with the CDK8s/Java approach.

The Traditional YAML Way (k8s.yaml)

# k8s.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-java-app
spec:
replicas: 3
selector:
matchLabels:
app: my-java-app
template:
metadata:
labels:
app: my-java-app
spec:
containers:
- name: app
image: my-registry/my-java-app:latest
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
name: my-java-app-service
spec:
type: LoadBalancer
ports:
- port: 80
targetPort: 8080
selector:
app: my-java-app

The CDK8s + Java Way

First, add the CDK8s dependency to your pom.xml:

<dependency>
<groupId>org.cdk8s</groupId>
<artifactId>cdk8s</artifactId>
<version>2.68.24</version> <!-- Check for the latest version -->
</dependency>
<dependency>
<groupId>org.cdk8s</groupId>
<artifactId>cdk8s-plus-25</artifactId>
<version>2.68.24</version>
</dependency>

Now, let's write the Java code (src/main/java/com/mycompany/MyJavaAppChart.java):

import org.cdk8s.App;
import org.cdk8s.Chart;
import org.cdk8s.ChartProps;
import org.cdk8s.plus25.*;
import software.constructs.Construct;
public class MyJavaAppChart extends Chart {
public MyJavaAppChart(final Construct scope, final String id, final MyJavaAppProps props) {
this(scope, id, null, props);
}
public MyJavaAppChart(final Construct scope, final String id, final ChartProps props, final MyJavaAppProps appProps) {
super(scope, id, props);
// 1. Create a Deployment using the high-level cdk8s-plus API
Deployment deployment = new Deployment(this, "deployment");
deployment.addContainer(ContainerProps.builder()
.image(appProps.getImage())
.port(appProps.getPort())
.build());
deployment.getMetadata().addAnnotation("app", "my-java-app");
deployment.getReplicas().setValue(appProps.getReplicas());
// 2. Expose the Deployment via a Service
deployment.exposeViaService(DeploymentExposeViaServiceOptions.builder()
.name("service")
.serviceType(ServiceType.LOAD_BALANCER)
.ports(ServicePort.builder()
.port(80)
.targetPort(appProps.getPort())
.build())
.build());
}
public static void main(String[] args) {
final App app = new App();
MyJavaAppProps appProps = new MyJavaAppProps();
appProps.setImage("my-registry/my-java-app:latest");
appProps.setPort(8080);
appProps.setReplicas(3);
new MyJavaAppChart(app, "my-java-app", appProps);
// This synthesizes the manifest to the `dist` directory
app.synth();
}
// A simple properties class to configure our app
static class MyJavaAppProps {
private String image;
private int port;
private int replicas;
// ... Getters and Setters ...
}
}

To generate the YAML, you simply run your Java application. CDK8s will create a dist/my-java-app.k8s.yaml file containing the exact same YAML as our manual example, but it was generated from type-safe, reusable, and testable Java code.

Key Benefits Revisited

• No More Copy-Pasting: Parameterize your app name, image, and replica count. Use loops to create multiple similar resources.
• Validation at Compile Time: Your IDE will warn you about incorrect types or missing required fields.
• True Reusability: You can publish your custom constructs (e.g., a DatabaseChart or RedisClusterChart) as JAR files for your entire team to use.
• Software Engineering Practices: You can write unit tests for your charts to ensure they produce the expected Kubernetes resources, a task that is incredibly difficult with plain YAML.

Getting Started

1. Install the CDK8s CLI: npm install -g cdk8s-cli
2. Generate a New Project: cdk8s init java-app
3. Explore: The generated project in your IDE has a Main.java file showing a basic example. Start modifying it to match your application's needs.

Conclusion

CDK8s for Java is a game-changer for developers and platform teams who want to bring software engineering rigor to their Kubernetes infrastructure. It reduces the cognitive load of YAML, eliminates whole classes of errors, and unlocks powerful abstraction capabilities. By treating your Kubernetes manifests as code, you can build, share, and maintain your applications with more confidence and efficiency than ever before.

Give CDK8s a try on your next Java-based Kubernetes project—you might never want to write raw YAML again.