Curso básico de Kubernetes

RESUMO EM CONSTRUÇÃO

Material complementar:

• Conteúdo no YouTube: Acesse
• Conteúdo no GitHub: Acesse em breve

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)

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.Conhecendo o kubectl:

Em breve.