Docker Compose to Kubernetes Converter

Convert Docker Compose files to Kubernetes manifests and Helm charts

Use the Converter

Access the Docker Compose to Kubernetes converter tool

The Docker Compose to Kubernetes converter helps you migrate Docker Compose applications to Kubernetes by automatically generating Kubernetes manifests and Helm charts from your docker-compose.yaml files.

What It Does

The converter transforms Docker Compose services into Kubernetes resources:

• Services → Kubernetes Deployments and Services
• Volumes → PersistentVolumeClaims or other volume types
• Networks → Kubernetes Services with ClusterIP
• Ports → Service ports and optional Ingress resources
• Environment variables → ConfigMaps and Secrets
• Health checks → Liveness and readiness probes

The converter also generates a complete Helm chart with all resources bundled together, making it easy to deploy your converted application.

When to Use

Use the converter when:

• Migrating from Docker Compose - You have a working Docker Compose setup and want to deploy to Kubernetes
• Quick prototyping - You want to quickly test a Docker Compose app on Kubernetes
• Learning Kubernetes - You want to see how Docker Compose concepts map to Kubernetes resources
• CI/CD integration - You need to convert Compose files as part of an automated pipeline

The converter provides a good starting point, but you may need to adjust the generated manifests for production use. Review the generated resources and customize them based on your specific requirements.

How to Use

Access the Converter

The converter is available at https://cnap.tech/kompose. You can paste your Docker Compose YAML directly into the interface.

Conversion Options

The converter supports several options to customize the output:

• Provider - Choose Kubernetes or OpenShift
• Controller type - Deployment, DaemonSet, or ReplicationController
• Replicas - Number of pod replicas to create
• Volume type - PersistentVolumeClaim, emptyDir, hostPath, or ConfigMap
• Namespace - Target Kubernetes namespace
• Network policies - Generate NetworkPolicy resources for service isolation
• Helm chart - Generate a complete Helm chart (enabled by default)

Output Formats

The converter generates:

1. Kubernetes Manifests - Individual YAML files for each resource (Deployments, Services, ConfigMaps, etc.)
2. Helm Chart - A complete Helm chart with:
   • Chart.yaml - Chart metadata
   • values.yaml - Configurable values
   • templates/ - All Kubernetes manifests as Helm templates

You can download the output as a ZIP file containing all generated files, or copy individual files from the interface.

Example

Convert a simple web application with Redis:

Input (docker-compose.yaml):

docker-compose.yaml

services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    environment:
      - NODE_ENV=production
    depends_on:
      - redis
      
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"

Output (Kubernetes manifests):

web-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    io.kompose.service: web
  name: web
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      io.kompose.service: web
  template:
    metadata:
      labels:
        io.kompose.service: web
    spec:
      containers:
        - env:
            - name: NODE_ENV
              value: production
          image: nginx:latest
          name: web
          ports:
            - containerPort: 80
              protocol: TCP
      restartPolicy: Always

The converter generates Kubernetes manifests for each service, including Deployments and Services. When you enable Helm chart generation, it also creates a complete Helm chart with all resources bundled together.

Limitations

The converter handles most common Docker Compose features, but some features are not supported or require manual adjustment:

Feature	Status	Notes
Build contexts	Not supported	Docker Compose build: directives are not converted. Use pre-built container images instead.
Docker Compose versions	Limited support	Versions 2.1 and 3.2 have limited support due to their experimental nature. Use stable versions (1, 2, or 3) for best results.
Docker-specific features	Not supported	Some Docker-only features don’t have direct Kubernetes equivalents and may be skipped or require manual configuration.
Networking	Converted with limitations	Docker Compose networks are simplified to Kubernetes Services. Complex network configurations may need manual adjustment.
depends_on	Converted with limitations	Service dependencies are converted to init containers or startup order hints where possible, but exact startup ordering isn’t guaranteed.
Volumes	Converted with limitations	Volume configurations are converted, but you may need to adjust volume types (PersistentVolumeClaim, emptyDir, hostPath, or ConfigMap) based on your requirements.
Resource limits	Converted with limitations	Basic resource constraints are converted, but you may want to add more detailed resource requests and limits for production use.

Next Steps

After converting:

1. Review generated manifests - Check that all resources are correctly configured
2. Customize values - Adjust resource limits, environment variables, and configurations
3. Test locally - Use kubectl apply or helm install to test the converted application
4. Deploy to CNAP - Use the generated Helm chart as a source when creating products in CNAP

Related Topics

• Application Sources → - Learn about different source types in CNAP
• Templates → - Understand how templates work
• Create a Product → - Deploy your converted application as a product