Compose to Kubernetes Converter

How to use it

1. Paste a docker-compose.yaml, or drop the file onto the input pane. Conversion runs as you type; files up to 256 KiB stay live.
2. Read the object cards on the output side — each one is a complete Kubernetes manifest with a kompose-style file name such as web-deployment.yaml or webdata-persistentvolumeclaim.yaml.
3. Check the notices under the output: portless services that get no Service object, depends_on entries that convert to nothing, and compose keys outside the converted subset are each named there.
4. Copy or download per card, switch to the single-stream view for one kubectl apply -f, or take every file at once with Download all (.zip).

A compose file names services; a cluster wants Deployments, Services and PersistentVolumeClaims. Paste docker-compose.yaml and read the manifests back as one card per object, named the way the kompose CLI names its files, with a notice for every unconverted key. Kompose-compatible output — this site is not affiliated with or endorsed by the Kompose project. Nothing you paste leaves this device.

How it works

The restart policy decides the controller. A service with restart: always — or no restart key at all — becomes a Deployment whose pod template carries restartPolicy: Always. restart: "no" and restart: on-failure become bare Pods with restartPolicy: Never or OnFailure, because a Deployment exists to keep pods running and a run-to-completion container contradicts it. restart: unless-stopped has no cluster equivalent and is treated as always, with a notice saying so.

Volumes become PersistentVolumeClaims. A named volume turns into a claim carrying the volume's own name, mounted through a matching volumes: entry in the pod spec. An anonymous volume such as - /var/lib/postgresql/data gets a generated claim named <service>-claim0, counting up per service. A host bind mount keeps only its container side — the host path is ignored, a claim stands in, and a notice records the substitution. Every claim requests 100Mi and ReadWriteOnce (ReadOnlyMany for :ro mounts), and any service that mounts a claim gets strategy: type: Recreate, since two pods cannot share it during a rolling update.

Resource limits translate into container resources. cpus: "0.5" becomes cpu: 500m; deploy.resources.reservations become requests; and memory is printed as a quoted byte count — 256M becomes memory: "268435456", and mem_limit: 512m becomes a limits.memory of "536870912". The quotes are deliberate: the value is a string in the emitted YAML, exactly as the kompose CLI prints it.

Compose labels ride along as annotations in three places — the controller's metadata, its pod template, and the Service — while every object is selected through one generated io.kompose.service label. Ports map twice: the container lists each target port, and published ports become Service entries whose name is the published port number as a string.

Compatibility is measured, not assumed: the engine is verified byte-for-byte against a frozen corpus of twenty Kubernetes objects produced by kompose v1.38.0 across six compose fixtures — key order, indentation and quoting included. The one deliberate difference: kompose stamps kompose.cmd and kompose.version annotations recording its own invocation, and this page omits them, because it does not run Kompose.

Examples

services:
  web:
    image: nginx:1.27-alpine
    ports:
      - "8080:80"
    environment:
      - NGINX_HOST=example.com
      - NGINX_PORT=80
    volumes:
      - webdata:/usr/share/nginx/html
volumes:
  webdata: {}

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    io.kompose.service: web
  name: web
spec:
  replicas: 1
  selector:
    matchLabels:
      io.kompose.service: web
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        io.kompose.service: web
    spec:
      containers:
        - env:
            - name: NGINX_HOST
              value: example.com
            - name: NGINX_PORT
              value: "80"
          image: nginx:1.27-alpine
          name: web
          ports:
            - containerPort: 80
              protocol: TCP
          volumeMounts:
            - mountPath: /usr/share/nginx/html
              name: webdata
      restartPolicy: Always
      volumes:
        - name: webdata
          persistentVolumeClaim:
            claimName: webdata

services:
  task-once:
    image: busybox:1.36
    command: ["sh", "-c", "echo done"]
    restart: "no"
  task-retry:
    image: busybox:1.36
    command: ["sh", "-c", "echo retry"]
    restart: on-failure
  web-always:
    image: nginx:1.27-alpine
    ports:
      - "8090:80"
    restart: always

apiVersion: v1
kind: Pod
metadata:
  labels:
    io.kompose.service: task-once
  name: task-once
spec:
  containers:
    - args:
        - sh
        - -c
        - echo done
      image: busybox:1.36
      name: task-once
  restartPolicy: Never

services:
  api:
    image: node:22-alpine
    command: ["node", "server.js"]
    ports:
      - "3000:3000"
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 256M
        reservations:
          cpus: "0.25"
          memory: 128M
  worker:
    image: python:3.12-alpine
    command: ["python", "worker.py"]
    mem_limit: 512m

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    io.kompose.service: api
  name: api
spec:
  replicas: 1
  selector:
    matchLabels:
      io.kompose.service: api
  template:
    metadata:
      labels:
        io.kompose.service: api
    spec:
      containers:
        - args:
            - node
            - server.js
          image: node:22-alpine
          name: api
          ports:
            - containerPort: 3000
              protocol: TCP
          resources:
            limits:
              cpu: 500m
              memory: "268435456"
            requests:
              cpu: 250m
              memory: "134217728"
      restartPolicy: Always

services:
  db:
    image: postgres:16.3-alpine
    environment:
      - POSTGRES_PASSWORD=localdev
    volumes:
      - /var/lib/postgresql/data

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  labels:
    io.kompose.service: db-claim0
  name: db-claim0
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 100Mi

services:
  frontend:
    image: nginx:1.27-alpine
    ports:
      - "8082:80"
    depends_on:
      - backend
  backend:
    image: node:22-alpine
    command: ["node", "api.js"]
    ports:
      - "3000:3000"
    environment:
      - DB_HOST=db
    depends_on:
      - db
  db:
    image: postgres:16.3-alpine
    environment:
      - POSTGRES_PASSWORD=localdev
    volumes:
      - dbdata:/var/lib/postgresql/data
volumes:
  dbdata: {}

apiVersion: v1
kind: Service
metadata:
  labels:
    io.kompose.service: backend
  name: backend
spec:
  ports:
    - name: "3000"
      port: 3000
      targetPort: 3000
  selector:
    io.kompose.service: backend

Every example on this page is executed against the same engine that powers the tool, on every build.

Common errors

Flow sequence in block collection must be sufficiently indented and end with a ] at line 4, column 1:

YAML syntax errors stop the conversion before any object is emitted — this one is an unclosed [ from a half-pasted list. The message keeps the parser's own line and column, and Jump to error puts the cursor there.

No services found — a compose file declares each container under a top-level services: mapping.

A file holding only volumes:, networks:, or a bare fragment has nothing to convert. Nest each container under services: — the top-level key is the whole grammar this converter reads.

Service "web" is not a mapping — each entry under services: must be a mapping of configuration keys.

services:\n web: nginx names a scalar where a mapping belongs. Compose wants the image on its own line — web: then image: nginx beneath it — and the converter refuses rather than guessing what the scalar meant.

This compose file expands to 81 Kubernetes objects — the cap for this tool is 80 objects. Nothing was emitted; split the file and convert it in parts.

Every service can fan out to a controller, a Service and several claims, so a large file multiplies quickly. The refusal names the real count against the 80-object cap and emits nothing, keeping the all-or-none guarantee.

Input is larger than the 256 KiB limit for this tool. For bigger files use the CLI: kompose convert -f docker-compose.yaml

The cap refuses outright instead of truncating, so a conversion always covers your whole file. 256 KiB outruns any hand-written compose file; past it, the same conversion belongs to the native CLI on your machine.

Keyboard shortcuts

⌘/Ctrl + Enter

Re-run the conversion immediately.

⌘/Ctrl + S

Download the Kubernetes YAML, overriding the browser's save dialog.

⌘/Ctrl + C

Copy the whole output while no text is selected.

⌘/Ctrl + Shift + C

Copy the whole output even mid-selection.

t

Advance the theme.

?

Open the shortcut help overlay.

Esc

Dismiss the topmost overlay.