Kubernetes do Zero - Parte 3: Subindo um "mini cluster" com kind

Fala pessoal, tudo bem?

Na postagem da parte 2, nós criamos um cluster do inicio ao fim, semelhante a forma que criaríamos um cluster kubernetes em um ambiente "corporativo" por assim dizer.

Ambiente virtual, mais de uma máquina, IPs para cada node, instalação de CNI, etc ...

Mas e se não tivermos como subir um ambiente desse porte? Um lugar que possamos apenas usar para estudar boa parte, se não todos, os conceitos do kubernetes?

Pensando nisso, vamos fazer a parte 3 com base nessa possibilidade.

Sem necessidade de hardware parrudo, sem a necessidade de várias máquinas, sem uso de cloud.

Apenas  o nosso notebook (pode ser ele Windows, Linux ou Mac).

Existe uma alternativa muito legal que é o Kind - Kubernetes in Docker.

Ele faz uso do Docker para subir containers que vão simular os nodes do kubernetes.

Site do projeto - https://kind.sigs.k8s.io

A parte legal de olhar sempre o site oficial, é que teremos a documentação atualizada.

Clicando em Quick Start - Installation, temos as instruções para cada tipo de sistema operacional.

O meu é um Debian Linux, então vou seguir o passo a passo do "On Linux".

Essa primeira parte, consiste na verdade em baixar o binário do kind mediante ao seu respectivo host.

Dar permissão de execução ao binário.

Mover para o path default de execução e assim todos os usuários deste computador, terão acesso a rodar o kind.

O próximo passo para testar e ver se tudo deu certo, é executar o comando kind com qualquer usuário.

Obs - no meu caso, eu já baixei e movi o arquivo como root, pois no Debian é um pouco diferente do Ubuntu na questão de usuários. Meu usuário convencional não é adicionado por padrão com permissões sudo. Ele libera diretamente o root.

Primeiro teste executando o kind como root e o segundo com meu usuário convencional.

Até aqui, tudo fácil e mais que lindo/maravilhoso.

Agora, o próximo passo é instalar alguns componentes que o kind vai precisar e nós vamos precisar depois para administrar nosso poderoso cluster kubernetes.

Eu vou fazer por etapas, mas saiba que podemos preparar tudo e depois rodar tudo em uma única instalação. Mas vamos com calma.

Instalando o Docker

# apt install docker.io

Assim que a instalação finalizar, vamos validar se o Docker está em execução:

# systemctl status docker

Por estar usando o Debian, eu tive um passo adicional que foi permitir o meu usuário convencional a ter acesso ao Docker. Para isso, eu adicionei o usuário ao grupo do Docker.

Caso vc também esteja no Debian, basta rodar esse comando como root:

# gpasswd -a joao docker

(tem um modo menos elegante que é dar um vim /etc/group e adicionar o usuário ao final da linha onde contém o nome do grupo do Docker =D ).

Para que seu usuário leia as novas configurações, vc precisará fazer logout e login novamente.

Instalando o kubectl

Para podermos administrar o cluster kubernetes, precisamos do kubectl. Para instalar no Debian:

# apt install kubectl

Agora, temos o nosso ambiente preparado para criarmos o cluster com o kind.

Criando nosso cluster com Kind

Existem duas formas de criamos o cluster:

1. Rodando diretamente na linha de comando com o kind
2. Criando um manifesto (arquivo yaml) e pedir ao Kind para ler este arquivo

Vantagem de um para o outro:

• Direto pelo comando, cria o cluster default mais rápido
• Pelo manifesto, podemos otimizar e customizar algumas configurações (como quantidade de control-planes, workers, regras de ingress, etc)

Para o nosso lab, vou criar usando o manifesto para garantir que seja criado como eu quero.

Para isso, no linux vamos criar o arquivo conforme abaixo:

$ vi create-kind-cluster.yaml

Dentro dele, teremos o seguinte conteúdo:

kind: Cluster // o tipo de recurso que estamos querendo criar
apiVersion: kind.x-k8s.io/v1alpha4 // a versão da API que vamos usar para isso
name: kind-k8s // o nome que queremos para nosso cluster
nodes: //o bloco onde iremos informar quantos e o tipo de workers que queremos
- role: control-plane // worker do tipo control-plane
- role: worker
- role: worker // tipo worker

Veja que para nosso ambiente, estamos pedindo um recurso do tipo cluster, de nome kind-k8s, 1 node control-plane e 2 nodes worker.

Salve o arquivo.

Agora para podermos iniciar a criação do cluster:

$ kind create cluster --name=create-kind-cluster.yaml

Prontinho!!!

Nosso cluster kubernetes local foi criado.

Vamos conferir?

Temos duas formas...

Uma é a já sugerida pelo kind quando ele termina de criar o cluster:

$ kubectl cluster-info

Podemos usar o comando até o "cluster-info" se tivermos apenas este cluster criado e rodando.

Caso vc tenha mais de um, informar o contexto para o recurso específico.

A outra forma, é ir direto pelo Docker com o comando docker ps, e ver a saída dos containers rodando:

$ docker ps

Exatamente o que pedimos no nosso arquivo yaml

• 1 control-plane
• 2 workers

Podemos também rodar:

$ kubectl get nodes

Legal!!!

Mas e agora, como posso testar e ver se ele está pronto para receber meus pods, minhas aplicações para testar?

Vamos subir um pod do nginx para teste...

$ kubectl run nginx --image=nginx --port=80

Para irmos acompanhando se o STATUS do pod muda para Running:

$ kubectl get pods

Dando tudo certo, temos a saída abaixo:

E para testarmos se ele está respondendo:

$ kubectl port-forward pod/nginx 8080:80

Mas o que esse comando faz?

Ele faz o com que nosso pod nginx tenha suporta exposta remotamente na porta localhost:8080.

Abrindo o navegador do nosso computador e acessando http://localhost:8080 veremos a página default do nginx.

Sei lá... tá meio estranho isso! Como vou ter certeza que esse conteúdo é mesmo do pod do nginx que acabamos de subir?

Certo, vamos brincar um pouco dentro do pod.

Para acessar o shell do pod, vamos executar a seguinte linha de comando:

obs - abra uma nova aba do seu terminal para não perdermos o port-forward ...

$ kubectl exec nginx -it -- bash

Esse comando é um exec com o parametro it informando que o comando que queremos executar para este pod é um bash.

Isso nos dará acesso bash direto no pod:

Agora, vamos apagar o conteúdo do arquivo index.html default do nginx:

# echo > /usr/share/nginx/html/index.html

Validar que ele está em branco:

# cat /usr/share/nginx/html/index.html

Agora vamos adicionar um novo conteúdo a ele:

# echo "Site testado no kind-k8s" > /usr/share/nginx/html/index.html

Agora, vamos sair do container com o comando exit

Caso vc tenha parado o port-forward, inicie ele novamente. Caso não, retorne ao navegador e dê um refresh na página http://localhost:8080

Agora vc pode de fato acreditar que subimos nosso cluster kubernetes localmente, ele está funcional, pois conseguimos subir um pod com um nginx, conectar nesse pod, trocar o arquivo html e testar o acesso de fora do cluster.

Por agora é isso.

Temos até aqui, duas opções de lab para testar o que será preparado nas próximas postagens.

Seja no seu cluster com as VMs, CNI, mais de 3 nós ... ou mesmo no nosso kind local com 1 control-plane e 2 workers.

Abs e até o próximo post...

:wq!