KinD – Crie clusters Kubernetes no seu Laptop
Tags: kubernetes, docker, devops
Published: 2020-06-20 16:32:02

Se você trabalha com Kubernetes ou está no processo de aprendizagem, conta atualmente com algumas ferramentas que podem substituir satisfatoriamente um cluster Kubernetes, parcial ou integralmente, para que possa fazer as suas experiências.

O uso dessas ferramentas possibilita, por exemplo, que um desenvolvedor crie localmente a sua própria instância de cluster para realizar experiências, implantar aplicações e realizar testes relacionados aos processos de Integração Contínua (CI) ou Deployment Contínuo (CD). Tudo isso acontecendo em uma máquina com poucos recursos, se comparada às máquinas destinadas ao ambiente produtivo. Isso mesmo, dá para ter um ou mais clusters Kubernetes no seu Laptop!

O foco desse artigo é a sugestão de utilização da ferramenta **KinD**, mas seria estranho deixar de mencionar as principais ferramentas oferecidas atualmente e mostrar algumas de suas características, para que você possa fazer comparações e tirar algumas conclusões.

## Minikube

O [Minikube](https://kubernetes.io/docs/setup/learning-environment/minikube/) é uma das ferramentas mais antigas e conhecidas, e foi criada pelo grupo de usuários da própria comunidade Kubernetes (**K8s**). Possibilita a execução do K8s em uma máquina comum, criando um cluster que contém apenas um node (**single-node cluster**) dentro de uma Máquina Virtual (**VM**).

Trata-se de uma ferramenta simples e muito amigável, ideal para iniciantes. Após o seu processo de instalação, para iniciar um cluster basta executar `minikube start` e em apenas alguns minutos você poderá disparar comandos com o seu `kubectl`.

Apesar de simples, é um pouco pesado para ser executado em uma máquina comum. Devido a sua dependência de uma VM, o consumo de memória e de recursos do sistema é grande. Além disso existe a limitação imposta de um único node por cluster (que por sua vez também é único), o que exige a criação de uma ou mais instâncias, em máquinas distintas, se houver a necessidade de paralelismo. Essas foram as características que fizeram com que eu tirasse o Minikube da minha caixa de ferramentas.

## Microk8s

O [MicroK8s](https://microk8s.io/) foi desenvolvido pela [Canonical](https://canonical.com/) e permite criar um **single-node cluster** em uma máquina comum, mas diferentemente do Minikube, o MicroK8s foi projetado para ser usado em ambientes produtivos.

O fato de possuir a limitação de um único node por cluster não é um fator negativo, pois em alguns cenários os **single-node clusters** fazem muito mais sentido (IoT, por exemplo).

Apesar de oferecer um processo de instalação simples, ser amigável e muito leve, o que já é um grande diferencial em relação ao Minikube, ainda assim oferece algumas limitações que o torna menos atrativo para a maioria dos desenvolvedores (exceto se você estiver trabalhando com clusters de Raspberry PI).

## K3S

O [K3s](https://k3s.io/) é uma “miniatura” do Kubernetes desenvolvida pela [Rancher Labs](https://rancher.com/), que realizou a façanha de remover recursos dispensáveis do sistema e substituir componentes pesados por similares e mais leves (Ex.: SQLite3 em vez do etcd3), obtendo assim um _downsizing_ significativo. 

O resultado de todo esse “enxugamento” é um binário com menos de 40 MB que implementa toda a API do Kubernetes, e possibilita criar clusters em máquinas com pouco mais de 512 MB RAM. Por ser minúsculo, a sua instalação é quase instantânea se comparada a de um cluster Kubernetes comum (nos testes que fiz, levou menos de um minuto para levantar um cluster com cinco nodes). É outra alternativa excelente destinada ao mundo do IoT.

Ainda não a descartei como ferramenta de trabalho, pois falta validar algumas características. Uma das coisas que ainda estou avaliando é a confusão causada no sistema de arquivos, e uma das recomendações para evitar esse problema é a de se utilizar o K3S em um contêiner (imagem sugerida: `rancher/k3s`), o que possibilita a execução de várias instâncias independentes de forma bem simplificada.

Mas se for para executar o Kubernetes em um container Docker, por que não usar o **KinD**?

## KinD

O [KinD](https://kind.sigs.k8s.io/) é outro projeto criado pelo grupo de usuários da própria comunidade K8s, e a sua proposta é bem diferente da oferecida pelo Minikube, pois não depende de uma VM, permite a criação de clusters multi-node e até mesmo clusters multi-master, semelhante ao que se pode fazer nos ambientes produtivos.

A ferramenta foi inicialmente projetada para testar o próprio Kubernetes, executando clusters locais usando contêineres Docker como _nodes_ de um _cluster_, o que deu origem ao nome **KinD** (**K**ubernetes **in D**ocker, inspirado no já conhecido Docker-in-Docker, ou simplesmente **DinD**).

Devido a sua simplicidade na instalação, agilidade na inicialização, leveza e semelhança de operação ao Kubernetes real, acabou agradando os desenvolvedores e foi adotado como uma das principais ferramentas para realizar experiências e agilizar a validação durante o desenvolvimento de aplicações.

Apesar de ser um pouco mais pesado que o K3S, percebo muitas vantagens na utilização do KinD em um ambiente de desenvolvimento local, dentre elas destaco o suporte nativo ao multi-cluster e a capacidade de carregar imagens para um cluster diretamente do cache local, sem a necessidade de configurar um _registry_ e ter que fazer o _pull_ da nova imagem para um repositório remoto quando ocorre uma modificação que precisa ser testada.

O [Guia de Introdução Rápida](https://kind.sigs.k8s.io/docs/user/quick-start/) oferecido no website do KinD é muito amigável e oferece um passo-a-passo detalhado para a instalação da ferramenta, com opções para diversos sistemas operacionais.

A seguir será apresentado um guia bem resumido de instalação e operação do KinD em um ambiente **Linux**.

### Instalação do KinD

Para fazer a instalação do Kind, execute a sequência de instruções a seguir em um terminal:

```
$ curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.8.1/kind-$(uname)-amd64
$ chmod +x ./kind
$ sudo mv ./kind /usr/local/bin/kind
```

Pronto! A instalação foi finalizada. Bem simples, não é mesmo?!

Feito isso, para testar e saber se deu tudo certo:

```
$ kind version
```

Você deverá receber uma resposta semelhante a que está sendo apresentada a seguir:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/k20fgkn0umc2o9lhbwxi.png)

### Instalação do kubectl

O [kubectl](https://kubernetes.io/docs/reference/kubectl/overview/) é uma ferramenta de linha de comando (CLI) que possibilita fazer o controle de clusters Kubernetes. A ferramenta não acompanha a instalação do KinD, e sem ela não conseguiremos fazer muita coisa. Então é necessário instalar essa ferramenta também.

Se precisar de mais informações, o [Guia de Instalação e Configuração do kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl) é bem completo, mas para o momento precisamos executar apenas o que se segue no terminal de comandos:

```
$ curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/linux/amd64/kubectl
$ chmod +x ./kubectl
$ sudo mv ./kubectl /usr/local/bin/kubectl
```

Para testar se deu tudo certo:

```
$ kubectl version --client
```

Você deverá receber uma resposta semelhante a que está sendo apresentada a seguir:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/u0vgsvm6dsntdo86798e.png)

### Criação de clusters no Kind

O processo de criação de um cluster no Kind é bem similar ao que é feito no Minikube, basta executar:

```
$ kind create cluster
```
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/jcrlq4qrkjt8rsccaqeu.png)

Em poucos minutos já temos o primeiro cluster criado. Como não fornecemos nenhum nome, perceba na figura anterior que foi criado um cluster com o nome padrão “kind”.

Para criar um cluster com um nome diferenciado, basta usar a flag `--name`, conforme o exemplo a seguir:

```
$ kind create cluster --name summa-tech
```

Agora temos um novo cluster com o nome “summa-tech”, conforme demonstrado a seguir na saída do comando (desconsidere o comando “time”, que foi usado apenas para obter o tempo de execução).

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/36y4sicx1qo12go3j4xc.png)

O interessante é que a saída do comando fornece algumas dicas sobre a utilização do cluster criado.

### Alguns testes para validação

A ideia aqui não é a de fornecer um guia completo de operação da ferramenta, mas sim a de apresentá-la e introduzir o assunto para que o leitor possa explorar as opções no seu cotidiano.

Então, apenas para finalizar e validar o que fizemos até o momento, executaremos alguns comandos.

#### Listar os nomes dos clusters criados

```
$ kind get clusters
```
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/y8gvpjxwaldv3zrn2gvp.png)

#### Listar os nodes de um cluster

```
$ kubectl get nodes
```
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/rin2jno44f3qj4moytmt.png)

## Conclusão

O que vimos até aqui foi só um pontapé inicial para que se consiga experimentar o KinD. Espero que as informações tenham sido úteis, que você consiga fazer a adesão da ferramenta, e que isso torne o seu cotidiano ainda mais produtivo.

Depois conte pra gente como foi.