Translate a Docker Compose File to Kubernetes Resources using Kompose

Table of Contents

Docker Compose is a tool for defining and running multi-container Docker applications. It is a popular choice for developing and deploying applications locally. However, it can be difficult to translate a Docker Compose file to Kubernetes manifests.

This is where Kompose comes in. Kompose is a tool that can automatically convert Docker Compose files to Kubernetes manifests. This can save you a lot of time and effort, especially if you are not familiar with Kubernetes YAML syntax.

How Kompose Works

Kompose works by analyzing your Docker Compose file and generating the equivalent Kubernetes manifests. It takes into account the various features of Docker Compose, such as ports, volumes, and links, and translates them into the corresponding Kubernetes constructs.

Benefits of Using Kompose

There are several benefits to using Kompose:

It saves time and effort. Kompose can automatically convert your Docker Compose files to Kubernetes manifests, saving you the time and effort of doing it manually.
It reduces errors. Kompose is a mature tool that is well-tested and reliable. This means that you can be confident that the Kubernetes manifests it generates are correct.
It makes it easier to migrate to Kubernetes. If you are already using Docker Compose, Kompose can make it easy to migrate your applications to Kubernetes.

How to Use Kompose

Getting Started

Prerequisite

Install Docker Desktop

Enable Kubernetes

Installing Kompose

Kompose is released via GitHub, you can see all current releases on the GitHub release page.This is the recommended way of installing Kompose.

Linux and macOS:

# Linux
curl -L https://github.com/kubernetes/kompose/releases/download/v1.31.2/kompose-linux-amd64 -o kompose

# Linux ARM64
curl -L https://github.com/kubernetes/kompose/releases/download/v1.31.2/kompose-linux-arm64 -o kompose

# macOS
curl -L https://github.com/kubernetes/kompose/releases/download/v1.31.2/kompose-darwin-amd64 -o kompose

# macOS ARM64
curl -L https://github.com/kubernetes/kompose/releases/download/v1.31.2/kompose-darwin-arm64 -o kompose

chmod +x kompose
sudo mv ./kompose /usr/local/bin/kompose

Windows:

Download from GitHub and add the binary to your PATH.

How to use Kompose

Using Kompose is simple. To convert a Docker Compose file to Kubernetes manifests, simply run the following command:

kompose convert

This will generate a directory of Kubernetes manifests that you can then deploy to your Kubernetes cluster using kubectl.

A Simple Redis Application

Here is an example of how to use Kompose to convert a Docker Compose file for a simple web application:

wget https://raw.githubusercontent.com/kubernetes/kompose/main/examples/docker-compose.yaml

Here’s the content of docker-compose YAML file:

services:

  redis-master:
    image: registry.k8s.io/redis:e2e 
    ports:
      - "6379"

  redis-replica:
    image: registry.k8s.io/redis-slave:v2

    ports:
      - "6379"
    environment:
      - GET_HOSTS_FROM=dns

  frontend:
    image: registry.k8s.io/guestbook:v3
    ports:
      - "80:80"
    environment:
      - GET_HOSTS_FROM=dns
    labels:
      kompose.service.type: LoadBalancer

The compose file defines three services:

redis-master,
redis-replica, and
frontend.

Each service has the following properties:

Image: This specifies the Docker image that the service should run.
Ports: This specifies the ports that the service should expose.
Environment: This specifies the environment variables that should be set for the service.
Labels: This specifies the labels that should be attached to the service.

redis-master:

The redis-master service is responsible for running the Redis master server. It uses the registry.k8s.io/redis:e2e Docker image and exposes port 6379.

redis-replica:

The redis-replica service is responsible for running the Redis slave server. It uses the registry.k8s.io/redis-slave:v2 Docker image and exposes port 6379. It also sets the GET_HOSTS_FROM environment variable to dns. This tells the Redis slave server to automatically discover the hostname of the Redis master server.

frontend:

The frontend service is responsible for running the web application. It uses the registry.k8s.io/guestbook:v3 Docker image and exposes port 80:80. It also sets the GET_HOSTS_FROM environment variable to dns. This tells the web application to automatically discover the hostname of the Redis master server.

kompose.service.type:

The kompose.service.type label tells Kompose that the frontend service should be created as a LoadBalancer service. This means that Kubernetes will create an external load balancer that will route traffic to the frontend service.

To convert this Docker Compose file to Kubernetes manifests, run the following command:

kompose convert

This will generate the following directory of Kubernetes manifests:

INFO Kubernetes file "frontend-service.yaml" created
INFO Kubernetes file "redis-master-service.yaml" created
INFO Kubernetes file "redis-replica-service.yaml" created
INFO Kubernetes file "frontend-deployment.yaml" created
INFO Kubernetes file "redis-master-deployment.yaml" created
INFO Kubernetes file "redis-replica-deployment.yaml" created

You can then deploy these manifests to your Kubernetes cluster using kubectl.

Diagram

Here is a diagram that illustrates how Kompose works:

[Docker Compose File] -> Kompose -> [Kubernetes Manifests] -> kubectl -> [Kubernetes Cluster]

Conclusion

Kompose is a powerful tool that can save you time and effort when migrating your applications to Kubernetes. It is a mature and reliable tool that is easy to use. If you are looking for a way to automate the conversion of your Docker Compose files to Kubernetes manifests, I highly recommend Kompose.