> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cnap.tech/llms.txt
> Use this file to discover all available pages before exploring further.

# Docker Compose to Kubernetes Converter

> Convert Docker Compose files to Kubernetes manifests and Helm charts

<Card title="Use the Converter" icon="external-link" href="https://cnap.tech/kompose">
  Access the Docker Compose to Kubernetes converter tool
</Card>

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

<Note>
  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.
</Note>

## How to Use

### Access the Converter

The converter is available at [https://cnap.tech/kompose](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):**

```yaml docker-compose.yaml expandable highlight={2-8,10-13} theme={null}
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):**

<CodeGroup>
  ```yaml web-deployment.yaml expandable highlight={1-2,6-7,15-20} theme={null}
  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
  ```

  ```yaml web-service.yaml expandable theme={null}
  apiVersion: v1
  kind: Service
  metadata:
    labels:
      io.kompose.service: web
    name: web
    namespace: default
  spec:
    ports:
      - name: "80"
        port: 80
        targetPort: 80
    selector:
      io.kompose.service: web
  ```

  ```yaml redis-deployment.yaml expandable theme={null}
  apiVersion: apps/v1
  kind: Deployment
  metadata:
    labels:
      io.kompose.service: redis
    name: redis
    namespace: default
  spec:
    replicas: 1
    selector:
      matchLabels:
        io.kompose.service: redis
    template:
      metadata:
        labels:
          io.kompose.service: redis
      spec:
        containers:
          - image: redis:alpine
            name: redis
            ports:
              - containerPort: 6379
                protocol: TCP
        restartPolicy: Always
  ```

  ```yaml redis-service.yaml expandable theme={null}
  apiVersion: v1
  kind: Service
  metadata:
    labels:
      io.kompose.service: redis
    name: redis
    namespace: default
  spec:
    ports:
      - name: "6379"
        port: 6379
        targetPort: 6379
    selector:
      io.kompose.service: redis
  ```
</CodeGroup>

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 →](/app-sources) - Learn about different source types in CNAP
* [Templates →](/products/templates) - Understand how templates work
* [Create a Product →](/products) - Deploy your converted application as a product