Curso básico de Kubernetes

Introdução ao orquestrador de containers
Voltar

RESUMO EM CONSTRUÇÃO

Material complementar:


1.Introdução ao Kubernetes:

Objetivo do curso é compreender principais conceitos e tecnologias do Kubernetes (K8s) de forma simples e moderna, utilizando ferramentas como WSL2 Ubuntu, Docker e VSCode como base para aprendizado. Enquanto Docker cria 1 container, Docker Compose é capaz de criar vários containers em 1 máquina. Kubernetes, por sua vez, é capaz de gerenciar vários containers em várias máquinas (cluster). Portanto, Kubernetes é software para gerenciar, de forma inteligente, cluster composto por várias máquinas e, respectivamente, vários containers, aplicações e configurações relacionadas. Kubernetes automatiza essas questões:

  • Em qual máquina cada container será executado?
  • O que acontece se máquina ou container parar?
  • Como criar nova instância da aplicação?
  • Como distribuir várias instâncias entre servidores, de forma inteligente?
  • Como atualizar aplicação sem interromper serviço?
  • Como permitir que containers se comuniquem em rede?
  • Como descobrir em qual máquina a aplicação está sendo executada?

                  (multi-node)
                Kubernetes Cluster
        (context default, namespace default)
                       │
       ┌───────────────┴──────────────────┐
       │                                  │
Master Node (Control Plane)         Worker Node(s)
                                          │
                                  Deployment (3 réplicas)
                                          │
                               ┌──────────┼──────────┐
                               │          │          │
                              Pod        Pod        Pod (containers, ConfigMap/Secret)
                               │          │          │
                               └──────────┼──────────┘
                                          │
                                      Service (IP)

Progresso de criação de cluster K8s:


Cluster
│
├── Context
│
├── Nodes
│   ├── Single Node
│   └── Multi Node
│
├── Namespace
│
├── Deployment
│   └── ReplicaSet
│       └── Pods
│           ├── Containers
│           ├── ConfigMaps
│           └── Secrets
│
└── Service

2.Preparando o ambiente Kubernetes:

Nesse curso, criaremos estrutura simples de laboratório K8s, envolvendo Windows → WSL2 Ubuntu → Docker → kubectl → Kind.

  1. Instalar VSCode no Windows, e extensões (Docker, Kubernetes, WSL, Copilot);
  2. No PowerShell, instalar WSL2 e Ubuntu: 
    
wsl --install
wsl --set-default-version 2
wsl --install -d Ubuntu
  3. No Ubuntu WSL2, instalar pré-requisitos e Docker: 
    
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
  4. No Ubuntu WSL2, 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
  5. No Ubuntu WSL2, instalar Kind (ferramenta para criar clusters K8s locais): 
    
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

3.Criando o primeiro cluster Kubernetes:

Criação de cluster K8s single-node local (Master node control plane), via Kind (Kubernetes IN Docker - transforma container em node). Em ambientes corporativos, utiliza-se Kubeadm (trabalha com nodes reais, máquinas físicas) ao invés do Kind. Cluster é conjunto de máquinas (nodes) que trabalham unidas como 1 só, para executar aplicações em containers (Pods). Node é máquina com recursos computacionais (CPU, memória, armazenamento e rede). Exemplo, cluster com 3 nodes: 1 master (control plane, gerencia workers) e 2 workers (executam Pods). Pod é menor unidade do Kubernetes, composto de containers que compartilham mesmo espaço e recursos (IP, rede, volume). Kubernetes gerencia Pods, de forma inteligente, entre nodes.

  1. Criar cluster: kind create cluster
  2. Listar clusters: kind get clusters
    • Listar containers: docker ps -a
  3. Ver detalhes do cluster: kubectl cluster-info
  4. Listar nodes: kubectl get nodes
  5. Listar Pods: kubectl get pods
    • Listar Pods de todos Namespaces: kubectl get pods -A
  6. Ver contexto atual (cluster de trabalho): kubectl config current-context
    • Listar todos contextos: kubectl config get-contexts
  7. Ver detalhes do node: kubectl describe node kind-control-plane
    • Ver detalhes básicos: kubectl get node kind-control-plane -o wide
  8. Criar outro cluster: kind create cluster --name laboratorio
    • Listar clusters: kind get clusters
    • Listar todos contextos: kubectl config get-contexts
  9. Mudar contexto: kubectl config use-context kind-laboratorio
  10. Excluir cluster: kind delete cluster
    • Excluir cluster específico: kind delete cluster --name laboratorio

4.Criando e gerenciando Pods:

Enquanto container é único, Pod é composto por 1 ou mais containers simultaneamente, além de características específicas (recursos, volumes, rede, etc). Kubernetes gerencia Pods. Amplamente, Kubernetes gerencia clusters, compostos por nodes contendo Pods, que possuem 1 ou mais containers e características específicas relacionadas. Exemplo: Pod contendo container Apache e container MySQL, que compartilham mesmos recursos de armazenamento e rede.

  1. (Revisão) Criar infraestrutura:
    1. Criar cluster: kind create cluster
    2. Listar clusters: kind get clusters
    3. Ver contexto atual: kubectl config current-context
      • Usar contexto: kubectl config use-context kind-kind
      • Listar todos contextos: kubectl config get-contexts
    4. Listar nodes: kubectl get nodes
  2. Criar Pod: kubectl run nginx --image=nginx
  3. Listar Pods: kubectl get pods
    • Ver Pod específico: kubectl get pod nginx
  4. Ver detalhes do Pod: kubectl describe pod nginx
    • Ver detalhes básicos: kubectl get pod nginx -o wide
  5. Ver logs do Pod: kubectl logs nginx
  6. Executar comando no container do Pod: kubectl exec nginx -- curl -I http://localhost
    • Ver logs do Pod novamente: kubectl logs nginx
  7. Acessar container do Pod: kubectl exec -it nginx -- /bin/bash
    • Executar comandos dentro do container: cat /etc/*-release
    • Sair do container do Pod: exit (ou ctrl+d)
  8. Excluir Pod: kubectl delete pod nginx

E se o Pod falhar? O Kubernetes irá reiniciá-lo automaticamente. Em qual máquina física está o Pod? O Kubernetes irá distribuí-lo entre as máquinas físicas disponíveis automaticamente, de forma inteligente (balanceamento de carga e escalonamento).


5.Deployment e Réplicas:

Deployment é camada K8s criar e gerenciar Pods de forma controlada, evitando falhas e garantindo que quantidade desejada de réplicas (ReplicaSet) esteja sempre funcionando. Caso Pod falhe, Deployment criará novo Pod para substituí-lo.

  • Sem deployment: Cluster - Context - Node(s) - Pod - Container Nginx - Aplicação
  • Com deployment: Cluster - Context - Node(s) - Deployment e ReplicaSet - Pod(s) - Container Nginx - Aplicação
  1. (Revisão) Criar infraestrutura:
    1. Criar cluster: kind create cluster
    2. Listar clusters: kind get clusters
    3. Ver contexto atual: kubectl config current-context
      • Usar contexto: kubectl config use-context kind-kind
      • Listar todos contextos: kubectl config get-contexts
    4. Listar nodes: kubectl get nodes
  2. Criar deployment: kubectl create deployment nginx --image=nginx
  3. Listar deployments: kubectl get deployments
    • Listar Pods: kubectl get pods
  4. Listar réplicas: kubectl get rs
  5. Listar todos recursos: kubectl get all
  6. Alterar quantidade de réplicas: kubectl scale deployment nginx --replicas=3
    • Listar réplicas: kubectl get rs
    • Listar Pods: kubectl get pods
    • Ver distribuição de Pods: kubectl get pods -o wide
  7. Excluir Pod: kubectl delete pod nginx-xxx
  8. Listar Pods: kubectl get pods
    • Deployment e ReplicaSet criam automaticamente novos Pods quando necessário
  9. Ver detalhes do deployment: kubectl describe deployment nginx
  10. Ver detalhes do ReplicaSet: kubectl describe rs
  11. Ver detalhes do Pod: kubectl describe pods
  12. Excluir deployment: kubectl delete deployment nginx
    • Listar deployments: kubectl get deployments
    • Listar réplicas: kubectl get rs
    • Listar Pods: kubectl get pods

6.Services:

Cada Pod possui IP único no cluster. Se Pod for substituído, seu IP também será alterado, impossibilitando acesso. Service é camada 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.

  • Sem Service: Cluster - Context - Node(s) - Deployment e ReplicaSet - Pods (IPs alteráveis) - Container Nginx - Aplicação
  • Com Service: Cluster - Context - Node(s) - Deployment e ReplicaSet - Pods (IPs alteráveis) - Service (IP fixo) - Container Nginx - Aplicação
  1. (Revisão) Criar infraestrutura:
    1. Criar cluster: kind create cluster
    2. Listar clusters: kind get clusters
    3. Ver contexto atual: kubectl config current-context
      • Usar contexto: kubectl config use-context kind-kind
      • Listar todos contextos: kubectl config get-contexts
    4. Criar deployment: kubectl create deployment nginx --image=nginx
    5. Escalar 3 réplicas: kubectl scale deployment nginx --replicas=3
      • Listar deployments: kubectl get deployments
      • Listar réplicas: kubectl get rs
      • Listar Pods: kubectl get pods
    6. Cada Pod tem IP único: kubectl get pods -o wide
      • Excluir Pod: kubectl delete pod nome_do_pod
      • Listar Pods: kubectl get pods -o wide
        • IP do novo Pod mudou
  2. Ver labels: kubectl get pods --show-labels
    • O Service usa labels (selector) para identificar e selecionar Pods
  3. Criar Service (ClusterIP, IP acessível internamente no cluster): kubectl expose deployment nginx --port=80
  4. Listar Services: kubectl get svc
  5. Ver detalhes do Service: kubectl describe service nginx
  6. Ver endpoints do Service: kubectl get endpoints nginx
  7. Entrar temporariamente no container de um Pod do Service: kubectl run curl --image=curlimages/curl --rm -it -- sh
    • Acessar nginx via curl e nome do Service (DNS): curl http://nginx
      • Em produção, DNS do service pode ser: nginx.default.svc.cluster.local
      • Testar: curl http://nginx.default.svc.cluster.local
  8. Excluir Service: kubectl delete service nginx
  9. Criar Service NodePort (IP acessível externamente do cluster): kubectl expose deployment nginx --type=NodePort --port=80
    • Listar services: kubectl get svc
    • Listar service específico (ver NodePort): kubectl get svc nginx
    • Acessar service externamente: kubectl port-forward service/nginx 8080:80
      • Acessar via curl: curl http://localhost:8080
      • Acessar no Browser: http://localhost:8080
  10. Listar todos recursos: kubectl get all
  11. Listar Deployments: kubectl get deployments
  12. Listar ReplicaSets: kubectl get rs
  13. Listar Pods: kubectl get pods
  14. Listar Services: kubectl get svc

Há também Service LoadBalancer (cria IP público e porta para acesso externo ao cluster), e ExternalName (cria alias/apelido para nome DNS externo).


7.ConfigMaps e Secrets:

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), enquanto Secret armazena dados sensíveis nesse mesmo padrão (senhas, tokens, chaves de API, certificados). ConfigMaps e Secrets são consumidos via variáveis de ambiente (env) nos Pods ou via arquivos montados em volumes.

  1. (Revisão) Criar infraestrutura:
    1. Criar cluster: kind create cluster
    2. Verificar contexto: kubectl config current-context
    3. Criar deployment: kubectl create deployment nginx --image=nginx
    4. Escalar 3 réplicas: kubectl scale deployment nginx --replicas=3
    5. Criar service: kubectl expose deployment nginx --port=80
    6. Listar clusters: kind get clusters
    7. Listar deployments: kubectl get deployments
    8. Listar réplicas: kubectl get rs
    9. Listar Pods: kubectl get pods
    10. Listar Services: kubectl get svc
  2. Criar ConfigMap: 
    
kubectl create configmap app-config \
--from-literal=APP_NAME=UBSocial \
--from-literal=APP_ENV=Desenvolvimento \
--from-literal=APP_VERSION=1.0
  3. Listar ConfigMaps: kubectl get configmaps
  4. Ver detalhes de ConfigMap: kubectl describe configmap app-config
    • Ver em arquivo YAML: kubectl get configmap app-config -o yaml
  5. Consumir ConfigMap em deployment:
    1. Gerar YAML do deployment: kubectl get deployment nginx -o yaml
    2. Editar (Vim) arquivo YAML do deployment, adicionando ConfigMap: kubectl edit deployment nginx 
      
containers:
- image: nginx
  name: nginx

  envFrom:
  - configMapRef:
      name: app-config
    3. Verificar rollout (status do deployment): kubectl rollout status deployment nginx
    4. Listar Pods: kubectl get pods
    5. Acessar Pod: kubectl exec -it nomePod -- /bin/bash
      • Verificar variáveis de ambiente do ConfigMap: printenv | grep APP
  6. Alterar (Vim) ConfigMap: kubectl edit configmap app-config 
    
Alterar 'APP_ENV=Desenvolvimento' para 'APP_ENV=Produção'
    1. Reiniciar deployment: kubectl rollout restart deployment nginx
    2. Acessar Pod: kubectl exec -it nomePod -- /bin/bash
      • Verificar novas variáveis de ambiente do ConfigMap: printenv | grep APP
  7. Criar Secret: 
    
kubectl create secret generic app-secret \
  --from-literal=DB_USER=admin \
  --from-literal=DB_PASSWORD=123456 \
  --from-literal=JWT_SECRET=minha-chave-super-secreta
  8. Listar Secrets: kubectl get secrets
  9. Ver detalhes do Secret: kubectl describe secret app-secret
    • Ver em arquivo YAML (valores codificados Base64): kubectl get secret app-secret -o yaml
  10. Consumir Secret em deployment:
    1. Editar (Vim) arquivo YAML do deployment: kubectl edit deployment nginx 
      
envFrom:
- configMapRef:
    name: app-config
- secretRef:
    name: app-secret
    2. Reiniciar deployment: kubectl rollout restart deployment nginx
    3. Acessar Pod: kubectl exec -it nomePod -- /bin/bash
      • Verificar variáveis de ambiente do Secret: printenv | grep DB
      • Verificar variáveis de ambiente do Secret: printenv | grep JWT
  11. Listar todos recursos: kubectl get all
  12. Listar ConfigMaps: kubectl get configmaps
  13. Listar Secrets: kubectl get secrets

8.Namespaces:

Namespaces são pastas de trabalho, para separar recursos em ambientes distintos (Ex: financeiro, vendas, compras). Estrutura exemplo com namespaces:


Cluster
    │
    ├── Namespace default
    │      ├── Deployment
    │      ├── ReplicaSet
    │      ├── Pods
    │      ├── Service
    │      ├── ConfigMap
    │      └── Secret
    │
    ├── Namespace desenvolvimento
    │      ├── Deployment
    │      ├── ReplicaSet
    │      ├── Pods
    │      ├── Service
    │      ├── ConfigMap
    │      └── Secret
    │
    └── Namespace producao
  1. (Revisão) Criar infraestrutura:
    1. Criar cluster: kind create cluster
    2. Verificar contexto: kubectl config current-context
    3. Listar clusters: kind get clusters
    4. Listar contexts: kubectl config get-contexts
    5. Listar nodes: kubectl get nodes
  2. Listar namespaces: kubectl get ns
  3. Listar Pods de namespace específico: kubectl get pods -n kube-system
  4. Criar namespace: kubectl create namespace desenvolvimento
  5. Criar namespace: kubectl create namespace producao
  6. Listar namespaces: kubectl get ns
  7. Criar deployment no namespace padrão: kubectl create deployment nginx --image=nginx
  8. Listar deployments: kubectl get deployments
  9. Criar service: kubectl expose deployment nginx --port=80
  10. Listar services: kubectl get svc
  11. Criar deployment no namespace específico: kubectl create deployment nginx-dev --image=nginx -n desenvolvimento
  12. Criar service no namespace específico: kubectl expose deployment nginx-dev --port=80 -n desenvolvimento
  13. Listar deployments do namespace atual: kubectl get deployments
  14. Listar deployments do namespace específico: kubectl get deployments -n desenvolvimento
  15. Listar Pods do namespace específico: kubectl get pods -n desenvolvimento
  16. Listar services do namespace específico: kubectl get svc -n desenvolvimento
  17. Listar Pods de todos namespaces: kubectl get pods -A
  18. Listar deployments de todos namespaces: kubectl get deployments -A
  19. Listar services de todos namespaces: kubectl get svc -A
  20. Mudar de namespace: kubectl config set-context --current --namespace=desenvolvimento
  21. Verificar namespace atual (desenvolvimento): kubectl config view --minify | grep namespace
  22. Listar Pods desse namespace atual (desenvolvimento): kubectl get pods
  23. Criar deployment no namespace atual (desenvolvimento): kubectl create deployment apache --image=httpd
  24. Listar deployments desse namespace atual (desenvolvimento): kubectl get deployments
  25. Retornar ao namespace padrão: kubectl config set-context --current --namespace=default
  26. Listar deployments do namespace atual (padrão): kubectl get deployments
    • Deployment Apache não aparecerá, pois está no namespace "desenvolvimento"
  27. Excluir namespace: kubectl delete namespace desenvolvimento
  28. Listar namespaces: kubectl get ns

9.Cluster Multi-Node:

Cluster multi-node é composto por Master Node (control plane que gerencia e agenda Pods, gerencia estado do cluster e worker nodes, além de recursos do K8s) e Worker Nodes (executam Pods). Cada node possui recursos (CPU, memória, SO, armazenamento, rede-IP). Clusters multi-node oferecem alta disponibilidade, distribuição de carga escalável (load balancing, scheduler) e maior tolerância a falhas.

  1. Criar arquivo YAML para gerar cluster multi-node: code multinode.yaml 
    
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4

nodes:
- role: control-plane
- role: worker
- role: worker
  2. Criar cluster multi-node a partir do arquivo YAML: kind create cluster --config multinode.yaml
    • Criará cluster contendo 1 master node (control-plane) e 2 worker nodes (worker 1 e 2)
  3. Listar clusters: kind get clusters
  4. Verificar contexto: kubectl config current-context
  5. Listar nodes: kubectl get nodes
    • Ver com menos detalhes: kubectl get nodes -o wide
  6. Ver detalhes de node: kubectl describe node kind-worker
  7. Criar deployment: kubectl create deployment nginx --image=nginx
  8. Escalar réplicas: kubectl scale deployment nginx --replicas=6
  9. Listar deployments: kubectl get deployments
  10. Listar réplicas: kubectl get rs
  11. Listar pods: kubectl get pods
    • Ver detalhes básicos (observar node de cada pod): kubectl get pods -o wide
  12. Remover pod: kubectl delete pod nomePod
  13. Listar pods: kubectl get pods -o wide
    • Deployment e ReplicaSet criam automaticamente novos Pods quando necessário, scheduler escolhe em qual node implantá-los
  14. Criar service de rede: kubectl expose deployment nginx --port=80
  15. Listar services: kubectl get svc
  16. Criar port-forward: kubectl port-forward service/nginx 8080:80
    • Acessar no browser: http://localhost:8080
  17. Listar todos recursos: kubectl get all

Elaborado por Mateus Schwede
ubsocial.github.io


                  (multi-node)
                Kubernetes Cluster
        (context default, namespace default)
                       │
       ┌───────────────┴──────────────────┐
       │                                  │
Master Node (Control Plane)         Worker Node(s)
                                          │
                                  Deployment (3 réplicas)
                                          │
                               ┌──────────┼──────────┐
                               │          │          │
                              Pod        Pod        Pod (containers, ConfigMap/Secret)
                               │          │          │
                               └──────────┼──────────┘
                                          │
                                      Service (IP)



Cluster
│
├── Context
│
├── Nodes
│   ├── Single Node
│   └── Multi Node
│
├── Namespace
│
├── Deployment
│   └── ReplicaSet
│       └── Pods
│           ├── Containers
│           ├── ConfigMaps
│           └── Secrets
│
└── Service