Predefinição
Alternativa ao Kompose no navegadorZero transmissão ao servidor

Conversor de Docker Compose para Manifestos Kubernetes (Compose to K8s)

Converta serviços, variáveis de ambiente, portas e volumes de docker-compose.yml em manifestos YAML de Deployment e Service prontos para Kubernetes.

Presets:
Opções do gerador 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
Serviços analisados
4

4 portas mapeadas em 4 imagens de contêiner

Manifestos K8s
10

4 Deployments, 4 Services, 1 PVCs

Processamento no cliente
0 ms Latência

Processamento AST em memória 100% no navegador com atualizações instantâneas

Conversão no Navegador

Converte docker-compose.yml instantaneamente em Deployments, Services e PVCs sem envio de dados para servidores.

Padrões Prontos para Produção

Cria manifestos apps/v1 e v1 com etiquetas consistentes, seletores e limites de recursos.

Alternativa ao Kompose sem Instalação

Não precisa de binários adicionais ou Go instalados: funciona de forma 100% autônoma no navegador.

Referência técnica e guia de arquitetura

Conversor de Docker Compose para Manifestos Kubernetes (Compose para K8s) — Guia de referência

Converta serviços, variáveis de ambiente, portas e volumes de docker-compose.yml em manifestos YAML de Deployment e Service prontos para Kubernetes.

Parâmetros principais e controles

servicesmap[string]Service

Define as cargas de trabalho que são convertidas em recursos Deployment apps/v1 do Kubernetes com réplicas e especificações de contêiner.

Padrão: Obrigatório
portsarray[string | object]

Mapeamentos de portas convertidos em containerPort nos Pods e port/targetPort nos Services ClusterIP correspondentes no Kubernetes.

Padrão: Opcional
environment / env_filemap | array[string]

Variáveis de ambiente do contêiner convertidas em pares chave-valor diretos ou referências seguras a ConfigMap e Secret.

Padrão: Opcional
volumesarray[string | object]

Mapeamentos de armazenamento traduzidos em volumeMounts suportados por volumes emptyDir, HostPath ou PersistentVolumeClaim (PVC).

Padrão: Opcional
deploy.resourcesmap[string]object

Restrições de recursos mapeadas para resources.limits e resources.requests de CPU e memória no Kubernetes.

Padrão: Opcional

Dicas profissionais e melhores práticas

Evite manter senhas de banco de dados

Evite manter senhas de banco de dados diretamente no YAML do Deployment. Extraia-as para recursos Kubernetes Secret e ConfigMap utilizando a diretiva envFrom.

Volumes nomeados do Compose funcionam

Volumes nomeados do Compose funcionam apenas no host local. No Kubernetes, adote PersistentVolumeClaims (PVCs) vinculados a StorageClasses dinâmicas para suportar migração de Pods.

O Compose utiliza a rede bridge

O Compose utiliza a rede bridge padrão. No Kubernetes, configure um Service do tipo ClusterIP para cada Deployment, permitindo a comunicação interna por DNS (ex.: http://nome-servico:porta).

Defina sempre resources.requests e

Defina sempre resources.requests e limits para CPU e memória. Sem limites declarados, o escalonador do Kubernetes não consegue alocar Pods com precisão, aumentando o risco de OOMKilled.

Problemas comuns e solução de problemas

Comunicação entre serviços falha com Connection Refused ou erro de DNS NXDOMAIN

Verifique se o Service do Kubernetes possui labels de seleção (selector: app: <nome-servico>) correspondentes às labels do Pod e use o nome do Service em vez de localhost.

Bind mounts locais (ex.: ./src:/app) causam pastas vazias ou falhas de inicialização do Pod

Caminhos relativos locais (./) não existem nos nós remotos do Kubernetes. Compile o código dentro da imagem do contêiner ou use volumes efêmeros emptyDir.

Pod entra em CrashLoopBackOff por incompatibilidade entre command e entrypoint

No Docker Compose, 'command' equivale a 'args' no Kubernetes, enquanto 'entrypoint' equivale a 'command'. Inspecione os eventos com 'kubectl describe pod <nome>' e ajuste a sintaxe.

Perguntas frequentes (FAQ)

Como esta ferramenta traduz serviços do Docker Compose para manifestos Kubernetes?▼

O conversor analisa cada serviço do docker-compose.yml e gera automaticamente um manifesto Deployment apps/v1 e um Service v1 (ClusterIP) para comunicação interna. Imagens, variáveis, portas e volumes são adaptados aos padrões do Kubernetes.

Qual é a diferença entre este conversor online e a ferramenta Kompose CLI?▼

Enquanto o Kompose exige instalação de binários e ambiente Go local, este conversor roda 100% no navegador. Ele entrega manifestos limpos e prontos para uso imediatamente, sem downloads ou dependências de cluster.

Como as portas do Docker Compose são mapeadas para os Services do Kubernetes?▼

Uma porta como '8080:80' é mapeada para um Service onde 'port: 8080' define o ponto de entrada no cluster e 'targetPort: 80' encaminha as requisições para o 'containerPort: 80' configurado no Deployment.

Os arquivos de configuração ou segredos do meu ambiente são enviados a servidores externos?▼

Não. Todo o processo de interpretação e compilação de YAML ocorre localmente na memória JavaScript do seu navegador. Nenhuma informação de infraestrutura ou senha é transmitida.

Ferramentas e utilitários relacionados

Todas as ferramentas →