Preset
Kompose-Browser-AlternativeNull Serverübertragung

Docker Compose zu Kubernetes Manifest Konverter (Compose to K8s)

Konvertieren Sie docker-compose.yml-Dienste, Umgebungsvariablen, Ports und Volume-Mounts in produktionsreife Kubernetes Deployment- und Service-YAML-Dateien.

Presets:
K8s-Generator-Optionen
docker-compose.ymlv3.8
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: db-data-pvc
  namespace: default
  labels:
    app.kubernetes.io/name: db-data
    app.kubernetes.io/managed-by: compose-to-k8s
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  namespace: default
  labels:
    app: frontend
    app.kubernetes.io/name: frontend
    app.kubernetes.io/managed-by: compose-to-k8s
spec:
  replicas: 2
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
        app.kubernetes.io/name: frontend
    spec:
      containers:
        - name: frontend
          image: node:20-alpine
          imagePullPolicy: IfNotPresent
          args:
            - npm
            - start
          workingDir: /app
          ports:
            - name: port-3000
              containerPort: 3000
              protocol: TCP
          env:
            - name: NODE_ENV
              value: production
            - name: API_URL
              value: http://backend:4000
          resources:
            limits:
              cpu: "1"
              memory: 1024Mi
            requests:
              cpu: 200m
              memory: 256Mi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
  namespace: default
  labels:
    app: backend
    app.kubernetes.io/name: backend
    app.kubernetes.io/managed-by: compose-to-k8s
spec:
  replicas: 2
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
        app.kubernetes.io/name: backend
    spec:
      containers:
        - name: backend
          image: node:20-alpine
          imagePullPolicy: IfNotPresent
          args:
            - node
            - dist/index.js
          workingDir: /app
          ports:
            - name: port-4000
              containerPort: 4000
              protocol: TCP
          env:
            - name: PORT
              value: "4000"
            - name: DATABASE_URL
              value: postgres://user:password@postgres:5432/appdb
            - name: REDIS_URL
              value: redis://redis:6379
          livenessProbe:
            exec:
              command:
                - curl
                - -f
                - http://localhost:4000/health
            initialDelaySeconds: 10
            periodSeconds: 30
            timeoutSeconds: 5
            failureThreshold: 3
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
  namespace: default
  labels:
    app: postgres
    app.kubernetes.io/name: postgres
    app.kubernetes.io/managed-by: compose-to-k8s
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
        app.kubernetes.io/name: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:16-alpine
          imagePullPolicy: IfNotPresent
          ports:
            - name: port-5432
              containerPort: 5432
              protocol: TCP
          env:
            - name: POSTGRES_DB
              value: appdb
            - name: POSTGRES_USER
              value: user
            - name: POSTGRES_PASSWORD
              value: secretpassword123
          volumeMounts:
            - name: db-data
              mountPath: /var/lib/postgresql/data
      volumes:
        - name: db-data
          persistentVolumeClaim:
            claimName: db-data-pvc
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
  namespace: default
  labels:
    app: redis
    app.kubernetes.io/name: redis
    app.kubernetes.io/managed-by: compose-to-k8s
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
        app.kubernetes.io/name: redis
    spec:
      containers:
        - name: redis
          image: redis:7-alpine
          imagePullPolicy: IfNotPresent
          ports:
            - name: port-6379
              containerPort: 6379
              protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
  name: frontend
  namespace: default
  labels:
    app: frontend
    app.kubernetes.io/name: frontend
    app.kubernetes.io/managed-by: compose-to-k8s
spec:
  type: ClusterIP
  selector:
    app: frontend
  ports:
    - name: port-3000
      protocol: TCP
      port: 3000
      targetPort: 3000
---
apiVersion: v1
kind: Service
metadata:
  name: backend
  namespace: default
  labels:
    app: backend
    app.kubernetes.io/name: backend
    app.kubernetes.io/managed-by: compose-to-k8s
spec:
  type: ClusterIP
  selector:
    app: backend
  ports:
    - name: port-4000
      protocol: TCP
      port: 4000
      targetPort: 4000
---
apiVersion: v1
kind: Service
metadata:
  name: postgres
  namespace: default
  labels:
    app: postgres
    app.kubernetes.io/name: postgres
    app.kubernetes.io/managed-by: compose-to-k8s
spec:
  type: ClusterIP
  selector:
    app: postgres
  ports:
    - name: port-5432
      protocol: TCP
      port: 5432
      targetPort: 5432
---
apiVersion: v1
kind: Service
metadata:
  name: redis
  namespace: default
  labels:
    app: redis
    app.kubernetes.io/name: redis
    app.kubernetes.io/managed-by: compose-to-k8s
spec:
  type: ClusterIP
  selector:
    app: redis
  ports:
    - name: port-6379
      protocol: TCP
      port: 6379
      targetPort: 6379
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: frontend-ingress
  namespace: default
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: frontend
                port:
                  number: 3000
          - path: /backend
            pathType: Prefix
            backend:
              service:
                name: backend
                port:
                  number: 4000
Services analysiert
4

4 gemappte Ports über 4 Container-Images

K8s Manifeste
10

4 Deployments, 4 Services, 1 PVCs

Client-Verarbeitung
0 ms Latenz

100% browserbasierte AST-Verarbeitung im Speicher mit sofortigen Live-Updates

Client-Side Konvertierung

Parst docker-compose.yml direkt im Browser in Kubernetes Deployments, Services und PVCs ohne Server-Upload.

Produktionsreife Spezifikationen

Erzeugt apps/v1 Deployments und v1 Services mit optimierten Labels, Selektoren und Ressourcenbeschränkungen.

Keine Kompose-Installation erforderlich

Eine schlanke Browser-Alternative zu Kompose ohne lokale CLI- oder Go-Abhängigkeiten.

Technische Referenz & Architektur-Leitfaden

Docker Compose zu Kubernetes Manifest Konverter (Compose zu K8s) — Referenz-Leitfaden

Konvertieren Sie docker-compose.yml-Dienste, Umgebungsvariablen, Ports und Volume-Mounts in produktionsreife Kubernetes Deployment- und Service-YAML-Dateien.

Wichtige Parameter & Steuerelemente

servicesmap[string]Service

Definiert Workloads, die in Kubernetes apps/v1 Deployment-Ressourcen mit Replikaten und Container-Spezifikationen umgewandelt werden.

Standard: Erforderlich
portsarray[string | object]

Port-Zuordnungen, die zu containerPort in Pod-Spezifikationen und port/targetPort in Kubernetes ClusterIP-Services abgebildet werden.

Standard: Optional
environment / env_filemap | array[string]

Container-Umgebungsvariablen, konvertiert in env-Schlüssel-Wert-Paare oder ConfigMap/Secret-Referenzen.

Standard: Optional
volumesarray[string | object]

Speicherzuordnungen, übersetzt in container volumeMounts gestützt durch emptyDir, HostPath oder PersistentVolumeClaim (PVC).

Standard: Optional
deploy.resourcesmap[string]object

Ressourceneinschränkungen abgebildet auf Kubernetes resources.limits und resources.requests für CPU und Arbeitsspeicher.

Standard: Optional

Profi-Tipps & Best Practices

ConfigMaps und Secrets sauber entkoppeln

Lagern Sie vertrauliche Datenbankpasswörter und Umgebungsvariablen aus den Deployment-Manifesten in separate Kubernetes Secrets und ConfigMaps aus und binden Sie diese mit envFrom ein.

Docker Compose Named Volumes sind an

Docker Compose Named Volumes sind an einen einzelnen Host gebunden. Konvertieren Sie diese in Kubernetes in PersistentVolumeClaims (PVCs), um dynamischen Speicher und Pod-Migrationen zu unterstützen.

Docker Compose nutzt ein

Docker Compose nutzt ein standardmäßiges Bridge-DNS. In Kubernetes benötigt jedes Deployment einen ClusterIP-Service, damit Pods über ihren Dienstnamen (z. B. http://service-name:port) kommunizieren können.

Definieren Sie immer CPU- und

Definieren Sie immer CPU- und Speichergrenzen (resources.requests/limits). Ohne Requests kann der Kubernetes-Scheduler Pods nicht verlässlich verteilen, was zu OOMKilled-Fehlern führen kann.

Häufige Fallstricke & Fehlerbehebung

Dienst-zu-Dienst-Kommunikation schlägt fehl mit Connection Refused oder DNS NXDOMAIN

Prüfen Sie, ob ein Kubernetes Service mit passendem Selector-Label (z. B. app: <dienstname>) erstellt wurde, und stellen Sie sicher, dass Ihr Code den Dienstnamen statt localhost anfragt.

Lokale Bind-Mounts (z. B. ./src:/app) führen zu leeren Verzeichnissen oder Pod-Abstürzen im Cluster

Relative Pfade existieren auf Kubernetes-Worker-Knoten nicht. Erstellen Sie ein Container-Image mit integriertem Anwendungscode oder nutzen Sie temporäre emptyDir-Volumes.

Pod wechselt in CrashLoopBackOff wegen Syntaxunterschieden bei command und entrypoint

Docker Compose 'command' entspricht in Kubernetes 'args', während 'entrypoint' zu 'command' wird. Überprüfen Sie die Pod-Ereignisse mit 'kubectl describe pod <name>' und passen Sie die Parameter an.

Häufig gestellte Fragen (FAQ)

Wie konvertiert dieses Tool Docker Compose-Dienste in Kubernetes-Manifeste?▼

Jeder in der docker-compose.yml definierte Dienst wird in ein Kubernetes apps/v1 Deployment und einen zugehörigen v1 ClusterIP-Service übersetzt. Container-Images, Ports, Umgebungsvariablen und Volumes werden in standardkonforme Spezifikationen überführt.

Was unterscheidet dieses Online-Tool vom Kompose-CLI-Dienstprogramm?▼

Während Kompose eine lokale Go-Installation und Terminal-Konfiguration erfordert, führt dieses Tool alle Konvertierungen zu 100 % im Webbrowser aus. Sie erhalten sofortige YAML-Ausgaben ohne Binärdownloads oder Clusterverbindungen.

Wie werden Docker Compose Ports auf Kubernetes Services übertragen?▼

Ein Port-Mapping wie '8080:80' wird in einen Service übersetzt, bei dem 'port: 8080' den internen Cluster-Port definiert und 'targetPort: 80' den Datenverkehr an den 'containerPort: 80' des Ziel-Containers leitet.

Bleiben meine Infrastruktur-Konfigurationen und Anmeldedaten privat?▼

Ja, garantiert. Sämtliches Parsing und die Generierung der Kubernetes-Dateien erfolgen ausschließlich lokal im Speicher Ihres Browsers. Keine Zeile Ihrer Konfiguration wird an externe Server gesendet.

Verwandte Werkzeuge & Dienstprogramme

Alle Werkzeuge →