Kubernetes do Zero: Crie seu Primeiro Cluster Multinode

Curso teórico e prático

Voltar

Material complementar:

Curso gratuito na Udemy: Acesse em breve

Objetivo:

Explorar conceitos base de Kubernetes, através da criação de cluster kind multinode Kubernetes para hospedagem de aplicação NGINX. Kubernetes (K8s) é software para gerenciar containers em clusters.

Pré-requisitos:

O curso será desenvolvido em Ubuntu CLI via WSL2 em Windows 10.

Ambiente Linux Ubuntu (será utilizado WSL2);
Conhecimentos básicos de lógica de programação;
Conhecimentos básicos de comandos em terminal Linux;
Conhecimento básico de containers Docker.

1.Preparando o ambiente:

Instalar pré-requisitos e Docker no Ubuntu:


sudo apt update && sudo apt full-upgrade -y && sudo apt install -y curl wget ca-certificates gnupg
sudo install -m 0755 -d /etc/apt/keyrings && sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc && sudo chmod a+r /etc/apt/keyrings/docker.asc && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null && sudo apt update && sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y && sudo usermod -aG docker $USER

docker --version

Instalar kubectl (software CLI do K8s):


curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl" && sudo chmod +x kubectl && sudo mv kubectl /usr/local/bin/kubectl

kubectl version --client

Instalar kind (ferramenta para criar clusters K8s localmente, substituto do Minikube kubeadm):


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

kind version

2.Criando o cluster K8s:

Cluster é grupo de máquinas (nós/nodes) trabalhando juntas como 1 só. Pode ser single-node (única máquina node - Master Node Control Plane) ou multi-node (várias máquinas, Master Node Control Plane controla/gerencia os Workers Nodes que executam as aplicações).

Criar arquivo IaC (Infrastructure as Code) YAML para criar o cluster multi-node K8s: nano multinode.yaml


kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4

nodes:
- role: control-plane
- role: worker
- role: worker

Construir cluster a partir do arquivo YAML: kind create cluster --config multinode.yaml
- Listar clusters: kind get clusters

Cluster K8s multi-node contendo 3 nodes, sendo 1 master node (control-plane) e 2 worker nodes (workers 1 e 2).


Cluster Kind
├── Control Plane
├── Worker 1
└── Worker 2

Configurar contexto (ambiente de execução): kubectl config current-context
- Listar todos contextos: kubectl config get-contexts
- (não executar) Mudar contexto: kubectl config use-context kind-laboratorio
Criar namespace (pasta de trabalho para organização): kubectl create namespace projeto
- Listar namespaces: kubectl get ns
- Ver namespace atual: kubectl config view --minify | grep namespace
- (Não executar) Alterar namespace: kubectl config set-context --current --namespace=desenvolvimento
- (Não executar) Excluir namespace: kubectl delete namespace projeto

Namespaces são locais de trabalho para separar diferentes ambientes ou projetos dentro do mesmo cluster K8s. Exemplo: namespace financeiro possui todos recursos k8s relacionados a finanças, namespace vendas possui todos recursos k8s relacionados a vendas. Os recursos k8s de financeiro não interagem com os recursos k8s de vendas. Quando não são criados namespaces, todos os recursos são criados no namespace default.


Cluster Kind
├── Control Plane
├── Worker 1
└── Worker 2
        │
        ▼
   Namespace: projeto

3.Gerenciando recursos no cluster k8s:

Criar deployment no namespace projeto: kubectl create deployment nginx --image=nginx -n projeto
- Listar deployments: kubectl get deployments -n projeto

Deployment é recurso k8s ideal para criar Pods permanentes e replicáveis. Pod é unidade gerenciável do K8s. Kubernetes não gerencia containers, mas sim Pods. Enquanto container é único, Pod é composto por 1 ou mais containers simultaneamente, além de características específicas (recursos (CPU, memória), volumes (pastas para armazenar dados permanentemente), rede (IP, portas, protocolos), etc).

Escalar réplicas ao deployment: kubectl scale deployment nginx --replicas=3 -n projeto
- Listar replicas: kubectl get rs -n projeto
- Listar pods: kubectl get pods -n projeto
- Listar pods com detalhes: kubectl get pods -n projeto -o wide

ReplicaSet é recurso k8s ideal para replicar/multiplicar Pods e manter a quantidade desejada deles. Se um Pod morrer/falhar, ReplicaSet criará novo Pod automaticamente com mesmas características ao anterior para manter a quantidade desejada (self-healing).


Cluster Kind
├── Control Plane
├── Worker 1
└── Worker 2
        │
        ▼
   Namespace: projeto
        ├── Deployment
        │      └── ReplicaSet
        │              ├── Pod Nginx
        │              ├── Pod Nginx
        │              └── Pod Nginx

Implementar serviço de rede ao deployment: kubectl expose deployment nginx --port=80 -n projeto
- Listar serviços: kubectl get svc -n projeto

Cada Pod possui IP único no cluster. Se Pod for substituído, seu IP também será alterado, impossibilitando acesso. Service é camada ideal de rede que cria IP único e fixo no Deployment para todos seus Pods, garantindo acesso consistente, independentemente das alterações nos IPs dos Pods internos no Deployment. Ao invés de acessar diretamente IPs de cada Pod no Deployment, acessamos via IP único e fixo do Service todos Pods do Deployment, independentemente das alterações nos IPs dos Pods internos no Deployment.


Cluster Kind
├── Control Plane
├── Worker 1
└── Worker 2
        │
        ▼
   Namespace: projeto
        ├── Deployment
        │      └── ReplicaSet
        │              ├── Pod Nginx
        │              ├── Pod Nginx
        │              └── Pod Nginx
        │
        ├── Service

4.Inserindo dados no cluster k8s:

Criar ConfigMap nos pods:


kubectl create configmap app-config \
  --from-literal=APP_NAME=UBSocial-Kubernetes \
  --from-literal=APP_ENV=producao \
  --from-literal=APP_VERSION=1.0 \
  -n projeto

Listar ConfigMaps: kubectl get configmaps -n projeto
Descrever ConfigMap: kubectl describe configmap app-config -n projeto

ConfigMap armazena dados gerais do Pod em variáveis de ambiente (nome da aplicação, ambiente, porta, URL de serviços, outras configurações gerais).

Criar Secret nos pods:


kubectl create secret generic app-secret \
  --from-literal=DB_USER=admin \
  --from-literal=DB_PASSWORD=123456 \
  --from-literal=API_KEY=minha-chave \
  -n projeto

Listar Secrets: kubectl get secrets -n projeto
Descrever Secret: kubectl describe secret app-secret -n projeto

Secret armazena dados sensíveis no mesmo padrão de ConfigMap (senhas, tokens, chaves de API, certificados).

Integrar ConfigMap e Secret nos deployments: kubectl edit deployment nginx -n projeto:


containers:
- image: nginx
  name: nginx
  envFrom:
  - configMapRef:
      name: app-config
  - secretRef:
      name: app-secret

Verificar rollout (status do deployment): kubectl rollout status deployment nginx -n projeto


Cluster Kind
├── Control Plane
├── Worker 1
└── Worker 2
        │
        ▼
   Namespace: projeto
        ├── Deployment
        │      └── ReplicaSet
        │              ├── Pod Nginx
        │              ├── Pod Nginx
        │              └── Pod Nginx
        │
        ├── Service
        │
        ├── ConfigMap
        └── Secret

5.Acessando os recursos do cluster k8s:

Listar pods: kubectl get pods -n projeto
Acessar pod: kubectl exec -it nomePod -n projeto -- /bin/bash
- Listar variáveis de ambiente ConfigMap: printenv | grep APP
- Listar variáveis de ambiente Secret: printenv | grep DB
- Listar variáveis de ambiente Secret: printenv | grep API
Disponibilizar aplicação em rede: kubectl port-forward service/nginx 8080:80 -n projeto
- Acessar no browser: http://localhost:8080
- Acessar internamente: kubectl run curl --image=curlimages/curl -n projeto --rm -it -- sh
  - Acessar aplicação: curl http://nginx
Listar todos recursos do namespace projeto: kubectl get all -n projeto
Listar todos ConfigMaps: kubectl get configmaps -n projeto
Listar todos Secrets: kubectl get secrets -n projeto

6.Tratamento de erros e gestão no K8s:

Listar pods: kubectl get pods -n projeto -o wide
- Observe a distribuição dos pods entre os workers nodes de forma equilibrada/balanceada (scheduler, load balancing)
Excluir pod: kubectl delete pod nomePod -n projeto
Listar pods: kubectl get pods -n projeto -o wide
- Deployment e ReplicaSet criam novo pod automaticamente (self-healing)
Alterar ConfigMap: kubectl edit configmap app-config -n projeto
```
APP_VERSION=2.0
```
Reiniciar deployment: kubectl rollout restart deployment nginx -n projeto
Verificar rollout: kubectl rollout status deployment nginx -n projeto
Listar pods: kubectl get pods -n projeto
Acessar pod: kubectl exec -it nomePod -n projeto -- /bin/bash
- Listar variáveis ConfigMap: printenv | grep APP

7.Revisão:

Criação de cluster kind multi-node K8s via YAML;
Definição de context e namespace para trabalho;
Criação e replicação de pods via Deployment e ReplicaSet;
Exposição de pods em rede via Service;
Injeção de dados via ConfigMap e Secret;
Acesso e disponibilização de aplicação NGINX em rede via k8s;
Tratamento de erros (self-healing) e escalabilidade (scheduler e load balancing) de recursos k8s.