Preajuste
Alternativa a Kompose en navegadorCero transmisión al servidor

Convertidor de Docker Compose a Kubernetes Manifests (Compose a K8s)

Convierte servicios, variables de entorno, puertos y volúmenes de docker-compose.yml en YAML de Kubernetes Deployment y Service.

Presets:
Opciones del generador K8s
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
Servicios analizados
4

4 puertos mapeados en 4 imágenes de contenedor

Manifiestos K8s
10

4 Deployments, 4 Services, 1 PVCs

Procesamiento local
0 ms Latencia

Procesamiento AST en memoria 100% en navegador con actualizaciones instantáneas

Conversión en el navegador

Convierte docker-compose.yml instantáneamente en Deployments, Services y PVCs sin enviar datos al servidor.

Conformidad con estándares K8s

Genera manifiestos apps/v1 y v1 listos para producción con selectores, etiquetas y límites de recursos.

Alternativa ligera a Kompose

Sin necesidad de instalar binarios CLI ni herramientas externas: todo funciona localmente en tu navegador.

Referencia técnica y guía de arquitectura

Conversor de Docker Compose a Manifiestos de Kubernetes (Compose a K8s) — Guía de referencia

Convierte servicios, variables de entorno, puertos y volúmenes de docker-compose.yml en YAML de Kubernetes Deployment y Service.

Parámetros clave y controles

servicesmap[string]Service

Define las cargas de trabajo transformadas en recursos Deployment apps/v1 de Kubernetes con controladores de réplicas y especificaciones de contenedor.

Por defecto: Requerido
portsarray[string | object]

Asignaciones de puertos vinculadas a containerPort en los Pods y a port/targetPort en los recursos Service ClusterIP de Kubernetes correspondientes.

Por defecto: Opcional
environment / env_filemap | array[string]

Variables de entorno convertidas en pares clave-valor directos o referencias seguras mediante ConfigMap o Secret (envFrom).

Por defecto: Opcional
volumesarray[string | object]

Montajes de almacenamiento transformados en volumeMounts de contenedor respaldados por emptyDir, HostPath o PersistentVolumeClaim (PVC).

Por defecto: Opcional
deploy.resourcesmap[string]object

Límites de cómputo mapeados a resources.limits y resources.requests para CPU y memoria en Kubernetes.

Por defecto: Opcional

Consejos profesionales y mejores prácticas

En lugar de mantener contraseñas o

En lugar de mantener contraseñas o variables sensibles escritas en texto plano en el YAML de Deployment, extráigalas a recursos Kubernetes Secret y ConfigMap utilizando envFrom.

Los volúmenes nombrados de Compose

Los volúmenes nombrados de Compose están atados al host local. En Kubernetes, transfórmelos en PersistentVolumeClaims (PVC) asociados a StorageClasses dinámicas para permitir la reprogramación de Pods entre nodos.

Compose utiliza la red puente local.

Compose utiliza la red puente local. En Kubernetes, defina un Service de tipo ClusterIP para cada Deployment, permitiendo que los Pods se comuniquen mediante DNS estándar (ej. http://nombre-servicio:puerto).

Asigne siempre límites y solicitudes

Asigne siempre límites y solicitudes de recursos. Sin requests explícitos, el planificador de Kubernetes no podrá programar los Pods de forma predecible, exponiendo los nodos a fallos de OOMKilled.

Errores comunes y solución de problemas

Fallo de comunicación entre servicios por Connection Refused o error DNS NXDOMAIN

Compruebe que se haya generado un Service en Kubernetes con etiquetas selector que coincidan exactamente con las etiquetas del Pod (app: <nombre-servicio>), y use el nombre del servicio en lugar de localhost.

Los bind mounts locales (ej. ./src:/app) provocan carpetas vacías o caídas del Pod en el clúster

Las rutas relativas locales (./) no existen en los nodos remotos de Kubernetes. Construya la imagen con el código embebido o use volúmenes efímeros tipo emptyDir.

El Pod entra en CrashLoopBackOff por discrepancias de sintaxis entre command y entrypoint

En Docker Compose, 'command' se traduce a 'args' en Kubernetes, mientras que 'entrypoint' se convierte en 'command'. Verifique los eventos del Pod con 'kubectl describe pod <nombre>'.

Preguntas frecuentes (FAQ)

¿Cómo transforma esta herramienta los servicios de Docker Compose a manifiestos de Kubernetes?▼

La herramienta analiza cada servicio del archivo docker-compose.yml y genera automáticamente un manifiesto Deployment apps/v1 y un Service v1 (ClusterIP) para la comunicación interna. Las imágenes, puertos, variables y volúmenes se reestructuran conforme a las mejores prácticas de Kubernetes.

¿Qué diferencia existe entre este conversor y la herramienta de línea de comandos Kompose?▼

Kompose requiere instalación local, entorno Go y dependencias del sistema, mientras que este conversor opera 100% en su navegador. Proporciona conversión instantánea y validación visual sin necesidad de descargar binarios ni conectarse al clúster.

¿Cómo se traducen los puertos de Docker Compose a Kubernetes?▼

Una regla como '8080:80' genera un Service en el que 'port: 8080' define el puerto expuesto en el clúster y 'targetPort: 80' redirige el tráfico al 'containerPort: 80' especificado en el contenedor del Deployment.

¿Se envían mis configuraciones o contraseñas a servidores externos?▼

No. Todo el procesamiento de análisis y generación de YAML se realiza estrictamente en la memoria JavaScript de su navegador. Ningún dato de infraestructura ni credencial confidencial sale de su dispositivo.

Herramientas y utilidades relacionadas

Todas las herramientas →
Guía de Desarrollo del Conversor de JSON a Variables de Entorno .env (Aplanar y Exportar)Desarrollo

Aplana cargas útiles JSON anidadas en configuraciones .env en mayúsculas SNAKE_CASE con delimitadores y prefijos personalizables.

Abrir herramienta→
Generador de Esquemas SQL DDL a Drizzle ORM (PostgreSQL, MySQL, SQLite) - Guía de DesarrolladorDesarrollo

Convierte sentencias SQL CREATE TABLE en esquemas fuertemente tipados de Drizzle ORM con definiciones pgTable, mysqlTable y sqliteTable.

Abrir herramienta→
Guía del Desarrollador: Generador de Esquemas Valibot desde JSON (Validación Modular TypeScript)Desarrollo

Transforme datos JSON en definiciones de esquemas Valibot ligeras y con soporte de tree-shaking mediante v.object, v.string, v.number y validadores de arrays.

Abrir herramienta→
Generador de esquemas JSON a TypeBox (Proveedor de tipos JSON Schema rápido)Desarrollo

Convierta estructuras JSON en definiciones TypeBox Type.Object de alto rendimiento para validación en tiempo de ejecución en Fastify, Ajv y TypeScript.

Abrir herramienta→
Generador de Migración Prisma Schema a SQL DDLDesarrollo

Guía técnica para convertir esquemas de Prisma a sentencias SQL DDL compatibles con PostgreSQL, MySQL y SQLite.

Abrir herramienta→
Guía de Desarrollo: Generador de Interfaces y Tipos TypeScript desde Prisma SchemaDesarrollo

Extrae modelos, enums, campos opcionales y relaciones de Prisma Schema en interfaces TypeScript independientes sin depender del runtime de Prisma Client.

Abrir herramienta→