Kind + Kubernetes Local: clusters rápidos para testes e CI

Introdução

O Kubernetes (K8s) se consolidou como a principal ferramenta de orquestração de containers, mas configurar clusters locais para testes ou desenvolvimento pode ser trabalhoso. É nesse cenário que surge o Kind (Kubernetes in Docker) — uma solução leve que roda clusters Kubernetes completos dentro de containers Docker.

Criado inicialmente para testes do próprio Kubernetes, o Kind rapidamente se tornou útil também para desenvolvedores e engenheiros DevOps que desejam experimentar e validar aplicações em um ambiente Kubernetes local, sem a complexidade da nuvem.

TL;DR

Kind (Kubernetes in Docker) é uma ferramenta open source que cria clusters Kubernetes completos dentro de containers Docker, sem precisar de VMs. Ideal para desenvolvimento local, testes e pipelines de CI/CD, o Kind provisiona clusters descartáveis em segundos — permitindo validar manifests e aplicações sem depender de ambientes em nuvem.

O que é o Kind?

Kind é um projeto open source que executa clusters Kubernetes dentro de containers Docker.

Cada nó do cluster é um container.
O cluster é totalmente descartável.
É ideal para testes locais, pipelines de CI/CD e aprendizado.

Em resumo: com poucos comandos você tem um cluster Kubernetes completo rodando na sua máquina.

Arquitetura: Kind em uma única visão

graph TD
    A["Máquina Host"] --> B["Docker Engine"]
    B --> C["Kind Cluster"]
    C --> D["Control Plane<br/>(container)"]
    C --> E["Worker 1<br/>(container)"]
    C --> F["Worker N<br/>(container)"]
    D --> G["API Server<br/>etcd<br/>Controller Manager"]
    E --> H["Kubelet<br/>Container Runtime<br/>Network Proxy"]
    F --> H
    I["kubectl"] --> D
    J["Docker CLI"] --> B

Vantagens do Kind

Rapidez – Criação de clusters em segundos.
Portabilidade – Funciona em qualquer máquina com Docker.
Simplicidade – Não depende de VMs, como o Minikube.
Integração em CI/CD – Muito usado em pipelines de testes.
Flexibilidade – Suporte a múltiplos nós e configuração via YAML.

Instalação

Pré-requisitos:

Docker instalado.
Go (opcional, se for compilar do código-fonte).

Instalação simples (Linux/MacOS):

# Via Go
go install sigs.k8s.io/kind@latest

Ou via binário pré-compilado

curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.23.0/kind-linux-amd64
chmod +x ./kind
mv ./kind /usr/local/bin/kind

Criando um cluster

Com um único comando você já tem um cluster rodando:

kind create cluster --name meu-cluster

Verificando os nós:

kubectl get nodes

Customizando o cluster

Você pode criar clusters com múltiplos nós via arquivo de configuração:

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
networking:
  disableDefaultCNI: false
  kubeProxyMode: ipvs
nodes:
  - role: control-plane
  - role: worker
  - role: worker

Criando o cluster:

kind create cluster --config kind-config.yaml --name cluster-dev

Topologia de um cluster multi-nó

graph TB
    subgraph cluster["Kind Cluster: cluster-dev"]
        CP["Control Plane Node<br/>(container)"]
        W1["Worker Node 1<br/>(container)"]
        W2["Worker Node 2<br/>(container)"]

        CP --> API["API Server<br/>Scheduler<br/>Controller Manager"]
        W1 --> KB1["Kubelet<br/>Container Runtime"]
        W2 --> KB2["Kubelet<br/>Container Runtime"]

        API -->|manages| KB1
        API -->|manages| KB2
    end

    kubectl["kubectl<br/>(client)"] -->|API calls| API

Integração com Docker

Como os nós são containers Docker, você pode listá-los:

docker ps
docker exec -it <container-id> bash

Ciclo de vida: do local para CI/CD

graph LR
    A["kind create cluster<br/>--config kind-config.yaml"] --> B["Cluster<br/>Running"]
    B --> C["kubectl apply<br/>-f deployment.yaml"]
    C --> D["App<br/>Deployed"]
    D --> E["Execute Tests<br/>Integration Tests<br/>E2E Tests"]
    E --> F{Tests<br/>Pass?}
    F -->|Yes| G["CI/CD Success<br/>Push to Registry"]
    F -->|No| H["Debug Logs<br/>Fix Issues"]
    H --> I["kind delete cluster<br/>--name cluster-dev"]
    G --> I
    I --> J["Cleanup<br/>Next Run"]
    J -->|Repeat| A

Casos de uso

Desenvolvimento local: testar aplicações antes da nuvem.
CI/CD: validar deployments em pipelines.
Aprendizado: praticar comandos de Kubernetes.
Testes de configuração: validar manifests e CRDs em ambiente isolado.

Limitações

Apesar de útil, o Kind não substitui clusters reais em produção:

Não foi feito para workloads críticos.
Rede e performance diferem de ambientes em nuvem.
Recursos limitados à máquina host.

Conclusão

O Kind é uma ferramenta poderosa para quem trabalha com Kubernetes. Ele simplifica a criação de clusters locais, acelera o desenvolvimento e é ideal para cenários de teste, aprendizado e integração contínua.

Se você busca praticidade e agilidade com Kubernetes, o Kind é uma das melhores opções disponíveis.