Kompose: Docker Compose to Kubernetes

From Compose to Kubernetes: Introducing Kompose

As a DevOps Engineer, you're always looking for ways to streamline workflows. Migrating applications from a local Docker Compose setup to a Kubernetes cluster is a common task. Kompose is a tool designed specifically for this purpose.

Let's start with the official documentation to get a clear definition and then dive into using it.

The Basic Conversion: kompose convert

At its heart, Kompose has one primary command: convert. This command reads your docker-compose.yml and generates the equivalent Kubernetes YAML files.

Let's see this in action with a simple example.

As you can see, Kompose translates each service in your Compose file into two main Kubernetes objects:

1. A Deployment: Manages the pods running your application container.
2. A Service: Exposes the pods to the network.

This direct translation is a great starting point, but production applications often require more nuance.

A More Realistic Example: Refining the Output

Simple conversions are useful, but real-world Compose files contain volumes, build contexts, resource limits, and secrets. Let's look at a more complex example and see how we can guide Kompose to produce better manifests.

The article "From Your Docker-Compose File to a Cluster with Kompose" provides an excellent, production-oriented example.

The Power of Labels

From the article, you saw that Kompose isn't just a blind translator. You can add specific labels to your docker-compose.yml to control the conversion process. This is where your analysis skills from the previous lesson come into play.

By adding kompose.service.type: loadbalancer to your app-front service in the Compose file, you tell Kompose to generate a Service that will provision an external load balancer in a cloud environment—something you'd otherwise have to do manually.

Beyond the Defaults: Advanced Conversions

Kompose defaults to creating Deployment and Service objects, but it can do more. This is particularly useful when you need to create different types of workloads or package your application for Helm.

The ability to generate a Helm chart skeleton is especially valuable. It gives you a head start in packaging your application for repeatable deployments, a core practice in modern DevOps.

The StatefulSet Gap

One critical point to remember: Kompose does not automatically create StatefulSet resources. It defaults to creating Deployments for all services.

As we learned in the last lesson, databases and other stateful applications should be run as StatefulSets in Kubernetes to get stable network identifiers and persistent storage. After running kompose convert on a stack with a database, a crucial manual step is to convert the generated Deployment manifest for the database into a StatefulSet manifest.

version: '3.8'

services:
  frontend:
    image: my-frontend-app:latest
    ports:
      - "8080:80"
    networks:
      - app-net

  cache:
    image: redis:alpine
    volumes:
      - redis-data:/data
    networks:
      - app-net

volumes:
  redis-data:

networks:
  app-net:

An Alternative Approach: podman generate kube

While Kompose is the most well-known tool for this job in the Docker ecosystem, it's worth knowing that other container tools offer similar functionality. Podman, a popular daemonless container engine, has this capability built-in with the podman generate kube command.

This provides a different workflow: instead of converting a file, you can run your containers with Podman and then generate Kubernetes manifests from the running state.

This shows that the core idea—generating declarative Kubernetes manifests from a simpler definition or a running state—is a powerful pattern that exists across different tools in the container ecosystem.

Conclusion

Congratulations on completing this module! You have bridged the gap between local development with Docker Compose and production orchestration with Kubernetes.

Key Takeaways:

• Kompose is an accelerator: It automates the translation of Docker Compose files into Kubernetes manifests, saving significant time.
• Translation maps concepts: It converts Compose services to Deployments and Services, ports to Service definitions, and named volumes to PersistentVolumeClaims.
• Human oversight is essential: Kompose is not a magic wand. Its output must be reviewed and refined. A key example is manually converting Deployments for stateful services into StatefulSets.
• You can guide the process: Using Kompose-specific labels in your docker-compose.yml allows you to control the generated output, such as Service types and Ingress creation.

You have now journeyed from writing production-grade Dockerfiles and optimizing images to analyzing and preparing entire applications for a Kubernetes environment. The skills you've built throughout this course are foundational for any modern DevOps or cloud engineering role. Your next step is to apply them to build robust CI/CD pipelines, manage live clusters, and continue exploring the vast and exciting world of cloud-native technologies.