Checklist: Kubernetes ou Docker Compose para VPS em 2026

18 min de leitura  ·  Guia técnico

Kubernetes e Docker Compose são ferramentas de orquestração de contêineres com propósitos distintos: Docker Compose gerencia múltiplos serviços em um único host com um arquivo YAML simples, enquanto Kubernetes orquestra contêineres em clusters de múltiplos nós com recursos avançados de escalonamento e alta disponibilidade. A escolha certa depende do tamanho do projeto, dos recursos do VPS e da complexidade operacional que sua equipe está disposta a gerenciar.

Pré-requisitos para avaliar Kubernetes ou Docker Compose no VPS

• Acesso SSH ao VPS com privilégios de root ou sudo
• VPS com no mínimo 2 vCPUs e 2 GB de RAM para Docker Compose; 4 vCPUs e 8 GB de RAM para Kubernetes
• Sistema operacional: Debian 12, Ubuntu 24.04 LTS, Rocky Linux 9 ou AlmaLinux 9
• Docker Engine 26+ instalado (para ambos os cenários)
• Conhecimento básico de linha de comando Linux e conceitos de contêineres
• Definição clara do número de serviços, tráfego esperado e necessidade de alta disponibilidade

Kubernetes vs Docker Compose: entenda as diferenças fundamentais

A comparação entre Kubernetes e Docker Compose para VPS começa pela arquitetura de cada ferramenta. Docker Compose foi projetado para definir e executar aplicações multi-contêiner em um único host. Você descreve todos os serviços — Nginx, PHP-FPM, MySQL, Redis — em um arquivo docker-compose.yml e sobe tudo com um único comando. É simples, previsível e funciona muito bem para a maioria dos projetos de médio porte.

Kubernetes, por outro lado, é um sistema de orquestração distribuída. Ele gerencia contêineres em um cluster de múltiplos nós, oferecendo recursos como auto-healing (reinicialização automática de pods com falha), rolling updates sem downtime, escalonamento horizontal automático (HPA), balanceamento de carga nativo e controle granular de recursos via RBAC. Esses recursos têm um custo: a curva de aprendizado é significativamente maior e o overhead de recursos é real.

Para contextualizar: um cluster Kubernetes mínimo funcional consome entre 1,5 GB e 2 GB de RAM apenas para os componentes do plano de controle (API Server, etcd, Controller Manager, Scheduler). Em um VPS de 4 GB, isso representa metade da memória disponível antes de rodar qualquer aplicação. Docker Compose, em contraste, não tem overhead de orquestração — os contêineres consomem apenas o que a aplicação precisa.

• Docker Compose: ideal para 1 servidor, até ~10 serviços, equipes pequenas, projetos sem requisito de alta disponibilidade multi-nó
• Kubernetes: ideal para múltiplos servidores, escalonamento automático, ambientes com SLA rigoroso, equipes com DevOps dedicado
• K3s / MicroK8s: distribuições leves de Kubernetes para VPS único, mas ainda com overhead maior que Compose
• Docker Swarm: meio-termo — orquestração multi-nó com sintaxe próxima ao Compose, menos recursos que Kubernetes

Checklist: quando escolher Docker Compose para o VPS

O Docker Compose em produção é uma escolha sólida e subestimada. Muitos desenvolvedores assumem que Compose é "só para desenvolvimento", mas ele é amplamente usado para hospedar stacks completas em VPS com excelente resultado. Use este checklist para confirmar se Compose é a escolha certa:

1. Seu VPS tem menos de 8 GB de RAM: Compose não tem overhead de orquestração, deixando mais memória para as aplicações.
2. Você roda tudo em um único servidor: Compose foi projetado para single-host. Se não há plano de escalar para múltiplos nós, Kubernetes adiciona complexidade sem benefício.
3. Sua stack tem até 10-15 serviços: Nginx, PHP-FPM, MySQL, Redis, Certbot — Compose gerencia isso com facilidade.
4. Sua equipe não tem experiência com Kubernetes: A curva de aprendizado do Compose é de horas; a do Kubernetes, de semanas a meses.
5. Downtime de minutos é aceitável durante deploys: Compose não oferece rolling updates nativos sem configuração adicional.
6. Você quer simplicidade operacional: Um arquivo YAML, um comando docker compose up -d, e a stack está no ar.

Um exemplo de docker-compose.yml para uma stack web completa no Debian 12:

version: "3.9"
services:
  nginx:
    image: nginx:1.26-alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./certbot/www:/var/www/certbot
      - ./certbot/conf:/etc/letsencrypt
    depends_on:
      - php-fpm
    restart: unless-stopped

  php-fpm:
    image: php:8.3-fpm-alpine
    volumes:
      - ./app:/var/www/html
    restart: unless-stopped

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
    volumes:
      - mysql_data:/var/lib/mysql
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    restart: unless-stopped

volumes:
  mysql_data:

[+] Running 4/4
 ✔ Container nginx      Started
 ✔ Container php-fpm    Started
 ✔ Container mysql      Started
 ✔ Container redis      Started

Para subir a stack, execute:

docker compose up -d

Para verificar o status dos serviços:

docker compose ps

NAME        IMAGE                COMMAND                  SERVICE     STATUS      PORTS
nginx       nginx:1.26-alpine    "/docker-entrypoint.…"   nginx       running     0.0.0.0:80->80/tcp
php-fpm     php:8.3-fpm-alpine   "docker-php-entrypoi…"   php-fpm     running
mysql       mysql:8.0            "docker-entrypoint.s…"   mysql       running
redis       redis:7-alpine       "docker-entrypoint.s…"   redis       running

Se você ainda não tem o Docker instalado no seu VPS, consulte o artigo Como Instalar e Configurar o Docker no VPS Linux para Hospedar Aplicações antes de prosseguir.

Checklist: quando escolher Kubernetes para o VPS

A orquestração com Kubernetes em VPS faz sentido em cenários específicos. Antes de adotar Kubernetes, confirme cada item deste checklist — se você não marcar a maioria, Docker Compose provavelmente atende melhor:

1. Você tem ou planeja ter múltiplos nós: O principal benefício do Kubernetes é distribuir carga e garantir failover entre servidores. Em um único VPS, você perde esse benefício.
2. Seu VPS tem 8 GB de RAM ou mais: O plano de controle do Kubernetes consome recursos significativos antes de rodar qualquer aplicação.
3. Você precisa de escalonamento automático: O Horizontal Pod Autoscaler (HPA) do Kubernetes escala réplicas automaticamente com base em métricas de CPU e memória.
4. Zero downtime em deploys é obrigatório: Rolling updates e canary deployments são nativos no Kubernetes.
5. Sua equipe tem ou está disposta a aprender Kubernetes: Conceitos como Pods, Deployments, Services, Ingress, ConfigMaps, Secrets e PersistentVolumeClaims têm curva de aprendizado real.
6. Você precisa de isolamento granular de recursos: Kubernetes permite definir requests e limits de CPU/memória por contêiner com precisão.
7. Você usa CI/CD com múltiplos ambientes: Kubernetes se integra nativamente com GitOps (ArgoCD, Flux) e pipelines de deploy automatizados.

Para VPS único com Kubernetes, K3s é a distribuição mais indicada. Instalação no Rocky Linux 9:

curl -sfL https://get.k3s.io | sh -

[INFO]  Finding release for channel stable
[INFO]  Using v1.29.x+k3s1 as release
[INFO]  Downloading hash https://github.com/k3s-io/k3s/releases/download/v1.29.x+k3s1/sha256sum-amd64.txt
[INFO]  Downloading binary https://github.com/k3s-io/k3s/releases/download/v1.29.x+k3s1/k3s
[INFO]  Verifying binary download
[INFO]  Installing k3s to /usr/local/bin/k3s
[INFO]  Creating /usr/local/lib/systemd/system/k3s.service
[INFO]  Enabling k3s unit
[INFO]  Starting k3s

Verifique se o cluster está funcionando:

kubectl get nodes

NAME           STATUS   ROLES                  AGE   VERSION
vps-hostname   Ready    control-plane,master   2m    v1.29.x+k3s1

Um exemplo de Deployment básico no Kubernetes para uma aplicação web:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
spec:
  replicas: 2
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp
        image: nginx:1.26-alpine
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"
        ports:
        - containerPort: 80

Aplique o manifest:

kubectl apply -f webapp-deployment.yaml

deployment.apps/webapp created

Comparativo direto: Docker Compose vs Kubernetes por critério

Para facilitar a decisão sobre qual ferramenta de contêineres usar no VPS, veja a comparação critério a critério:

• Complexidade de configuração: Compose — baixa (1 arquivo YAML) | Kubernetes — alta (múltiplos manifests: Deployment, Service, Ingress, ConfigMap, PVC)
• Consumo de recursos base: Compose — praticamente zero overhead | Kubernetes — 1,5 GB a 2 GB de RAM para o plano de controle
• Escalonamento horizontal: Compose — manual (ajuste de réplicas no arquivo) | Kubernetes — automático via HPA
• Alta disponibilidade multi-nó: Compose — não suportado nativamente | Kubernetes — nativo
• Rolling updates sem downtime: Compose — requer configuração manual | Kubernetes — nativo
• Curva de aprendizado: Compose — horas | Kubernetes — semanas a meses
• Ecossistema e ferramentas: Compose — limitado | Kubernetes — vasto (Helm, ArgoCD, Prometheus, Grafana)
• Ideal para: Compose — VPS único, projetos pequenos a médios, equipes enxutas | Kubernetes — clusters multi-nó, alta escala, equipes DevOps
• Custo operacional: Compose — baixo | Kubernetes — alto (tempo de aprendizado, manutenção do cluster)

Para entender melhor as opções de infraestrutura disponíveis antes de decidir, veja o artigo Cloud Computing, Servidor VPS e Dedicado: Qual é a Melhor Opção para o Seu Negócio?

Como migrar de Docker Compose para Kubernetes com Kompose

Quando o projeto crescer e a migração de Docker Compose para Kubernetes se tornar necessária, a ferramenta Kompose automatiza a conversão dos arquivos Compose em manifests Kubernetes. O processo não é perfeito — você precisará revisar e ajustar os arquivos gerados — mas economiza horas de trabalho manual.

Atenção: Antes de migrar em produção, teste todo o processo em um ambiente de staging. A migração envolve mudanças na forma como volumes, redes e variáveis de ambiente são gerenciados.

1. Instale o Kompose no Ubuntu 24.04:

curl -L https://github.com/kubernetes/kompose/releases/latest/download/kompose-linux-amd64 -o kompose
chmod +x kompose
sudo mv kompose /usr/local/bin/

2. No diretório com o docker-compose.yml, execute a conversão:

kompose convert

INFO Kubernetes file "nginx-service.yaml" created
INFO Kubernetes file "php-fpm-service.yaml" created
INFO Kubernetes file "mysql-service.yaml" created
INFO Kubernetes file "redis-service.yaml" created
INFO Kubernetes file "nginx-deployment.yaml" created
INFO Kubernetes file "php-fpm-deployment.yaml" created
INFO Kubernetes file "mysql-deployment.yaml" created
INFO Kubernetes file "redis-deployment.yaml" created
INFO Kubernetes file "mysql-data-persistentvolumeclaim.yaml" created

3. Revise os manifests gerados, especialmente os PersistentVolumeClaims e as variáveis de ambiente sensíveis (converta para Secrets do Kubernetes).
4. Aplique todos os manifests no cluster:

kubectl apply -f .

5. Verifique se os pods estão rodando:

kubectl get pods

NAME                       READY   STATUS    RESTARTS   AGE
nginx-7d4b9c8f6-xk2p9      1/1     Running   0          45s
php-fpm-6c5d8b7f4-mn3q1    1/1     Running   0          45s
mysql-5f9c7d6b8-pq4r2      1/1     Running   0          45s
redis-4b8e6c5d7-rs5t3      1/1     Running   0          45s

Problemas comuns e como resolver

Sintoma: Docker Compose não sobe o serviço MySQL — "port is already allocated"

Causa: Outra instância do MySQL (ou outro processo) já está usando a porta 3306 no host.
Solução: Verifique qual processo está usando a porta com sudo ss -tlnp | grep 3306. Se for uma instalação nativa do MySQL, pare o serviço com sudo systemctl stop mysql antes de subir o Compose. Alternativamente, mapeie a porta do contêiner para uma porta diferente no host, como 3307:3306, no arquivo Compose.

Sintoma: K3s instalado mas kubectl retorna "connection refused"

Causa: O arquivo kubeconfig não está configurado corretamente para o usuário atual, ou o serviço K3s ainda está inicializando.
Solução: Exporte a variável de ambiente do kubeconfig: export KUBECONFIG=/etc/rancher/k3s/k3s.yaml. Para tornar permanente, adicione essa linha ao ~/.bashrc. Verifique o status do serviço com sudo systemctl status k3s.

Sintoma: Pods Kubernetes em estado "Pending" indefinidamente

Causa: Recursos insuficientes no nó (CPU ou memória) ou PersistentVolumeClaim não provisionado.
Solução: Execute kubectl describe pod [nome-do-pod] e verifique a seção "Events" para a causa exata. Se for falta de recursos, reduza os requests de CPU e memória nos manifests. Se for PVC, verifique se há um StorageClass disponível com kubectl get storageclass.

Sintoma: docker compose up falha com "no space left on device"

Causa: O disco do VPS está cheio, frequentemente por imagens Docker antigas e volumes não utilizados acumulados.
Solução: Execute docker system prune -a --volumes para remover imagens, contêineres parados e volumes não utilizados. Atenção: este comando remove dados de volumes não associados a contêineres em execução — faça backup antes. Verifique o espaço em disco com df -h antes e depois.

Sintoma: Kompose convert gera manifests com erros de versão de API

Causa: O Kompose pode gerar manifests com versões de API depreciadas dependendo da versão do Kubernetes alvo.
Solução: Após a conversão, verifique as versões de API nos manifests gerados. Substitua apps/v1beta1 por apps/v1 e extensions/v1beta1 por networking.k8s.io/v1 para Ingress. Use kubectl api-versions para listar as versões disponíveis no seu cluster.

Perguntas frequentes sobre Kubernetes vs Docker Compose

Kubernetes é melhor que Docker Compose para VPS pequeno?

Para VPS com menos de 4 vCPUs e 8 GB de RAM, Docker Compose é a escolha mais prática: consome menos recursos, tem curva de aprendizado menor e cobre a maioria dos casos de uso de um único servidor. Kubernetes faz sentido quando você precisa de alta disponibilidade, escalonamento automático e gerenciamento de múltiplos nós.

É possível rodar Kubernetes em um único VPS?

Sim, com distribuições leves como K3s ou MicroK8s é possível rodar Kubernetes em um único VPS a partir de 2 vCPUs e 4 GB de RAM. Porém, você perde os principais benefícios do Kubernetes — como failover entre nós e escalonamento horizontal — tornando Docker Compose uma alternativa mais eficiente para esse cenário.

Docker Compose funciona em produção ou é só para desenvolvimento?

Docker Compose funciona perfeitamente em produção para aplicações de médio porte rodando em um único servidor. Ele é amplamente usado para hospedar stacks completas com Nginx, PHP-FPM, MySQL e Redis em VPS. A limitação é a ausência de orquestração multi-nó nativa, o que não é problema para a maioria dos projetos.

Qual a diferença entre Docker Swarm e Kubernetes?

Docker Swarm é a solução nativa de orquestração multi-nó do Docker, mais simples de configurar que o Kubernetes e compatível com arquivos Compose. Kubernetes oferece recursos mais avançados como auto-healing, rolling updates granulares, RBAC e um ecossistema maior de ferramentas. Para equipes pequenas, Swarm é um meio-termo entre Compose e Kubernetes.

Como migrar de Docker Compose para Kubernetes quando o projeto crescer?

A migração envolve converter os arquivos docker-compose.yml em manifests Kubernetes (Deployment, Service, ConfigMap, PersistentVolumeClaim). A ferramenta Kompose automatiza parte dessa conversão com o comando kompose convert. Após a conversão, revise os manifests gerados, ajuste recursos e limites, e aplique com kubectl apply -f.

Conclusão

• Use Docker Compose se você tem um VPS único com menos de 8 GB de RAM, uma stack de até 15 serviços e uma equipe sem experiência prévia em Kubernetes — você terá menos overhead, mais simplicidade e resultado equivalente para a maioria dos projetos.
• Adote Kubernetes (ou K3s) quando o projeto exigir escalonamento automático, alta disponibilidade multi-nó, zero downtime em deploys e sua equipe tiver capacidade técnica para operar o cluster com segurança.
• Planeje a migração desde o início: estruture seus serviços Docker Compose com variáveis de ambiente, volumes nomeados e redes explícitas — isso facilita a conversão para Kubernetes com Kompose quando o momento chegar.

Leia também

• Checklist: como configurar Traefik como proxy reverso para Docker
• Comparativo: Portainer vs CLI Docker para gerenciar containers
• Configurar Servidor LAMP no Ubuntu/Debian 2026: Passo a Passo

Precisa de ajuda com Docker e contêineres no VPS?

Escolher entre Kubernetes e Docker Compose é apenas o primeiro passo — configurar o ambiente de produção com segurança, backups e monitoramento exige atenção a detalhes que fazem diferença no dia a dia. Os planos de VPS da AviraHost oferecem recursos adequados para ambos os cenários, com suporte técnico disponível para ajudar na configuração inicial.

Conheça os planos de VPS da AviraHost e escolha o ideal para sua stack