Kubernetes no Linux: Conceitos Fundamentais e Preparação para o CKA

Kubernetes (K8s) é uma plataforma de orquestração de containers que automatiza deploy, escalonamento e gerenciamento de aplicações. Se você já usa Docker, Kubernetes é o próximo passo para rodar containers em escala, com alta disponibilidade e recuperação automática de falhas.

Docker vs Kubernetes

A distinção mais importante antes de começar:

• Docker resolve: como empacotar e rodar uma aplicação em container
• Docker Compose resolve: como orquestrar múltiplos containers em uma máquina
• Kubernetes resolve: como gerenciar containers em um cluster de N máquinas com auto-escalonamento e zero-downtime

Para projetos com 1–3 serviços em uma única máquina, Docker Compose é suficiente. Kubernetes faz sentido quando você precisa escalar horizontalmente ou garantir alta disponibilidade.

Conceitos Fundamentais

Node

Uma máquina (física ou VM) que faz parte do cluster. O Control Plane (antigo Master) gerencia o cluster. Os Worker Nodes executam os containers.

Pod

A menor unidade do Kubernetes. Contém 1 ou mais containers que compartilham rede e armazenamento. Pods são efêmeros — podem morrer e renascer com outro IP a qualquer momento.

Deployment

Descreve o estado desejado de um conjunto de Pods: quantas réplicas, qual imagem usar, estratégia de atualização (rolling update). O Kubernetes garante que o estado real corresponda ao desejado.

Service

Como os Pods têm IP dinâmico, o Service fornece um endereço fixo (IP ou DNS interno) para acessá-los. Tipos: ClusterIP (interno), NodePort (porta no node), LoadBalancer (IP externo via cloud).

Namespace

Divide o cluster em ambientes isolados. Exemplo: producao, staging, dev — cada um com seus próprios recursos e políticas.

kubectl: O Comando Essencial

# Ver os nodes do cluster
kubectl get nodes

# Ver todos os pods em todos os namespaces
kubectl get pods -A

# Criar um deployment de nginx
kubectl create deployment nginx --image=nginx

# Escalar para 3 réplicas
kubectl scale deployment nginx --replicas=3

# Expor como serviço
kubectl expose deployment nginx --port=80 --type=LoadBalancer

# Ver logs de um pod
kubectl logs nome-do-pod

# Executar shell dentro de um container
kubectl exec -it nome-do-pod -- /bin/bash

# Debugar um recurso
kubectl describe pod nome-do-pod

# Deletar recurso
kubectl delete deployment nginx

Manifesto YAML

Na prática, você descreve recursos em arquivos YAML e aplica com kubectl apply:

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: minha-api
  namespace: producao
spec:
  replicas: 3
  selector:
    matchLabels:
      app: minha-api
  template:
    metadata:
      labels:
        app: minha-api
    spec:
      containers:
      - name: api
        image: minha-api:1.2.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "128Mi"
            cpu: "250m"
          limits:
            memory: "256Mi"
            cpu: "500m"
---
apiVersion: v1
kind: Service
metadata:
  name: minha-api-svc
spec:
  selector:
    app: minha-api
  ports:
  - port: 80
    targetPort: 8080
  type: ClusterIP

kubectl apply -f deployment.yaml
kubectl get deployments -n producao
kubectl rollout status deployment/minha-api -n producao

Certificação CKA

A CKA (Certified Kubernetes Administrator) é a certificação mais reconhecida de Kubernetes. Diferente da maioria das provas, ela é 100% prática: você recebe acesso a um cluster real e resolve problemas em 2 horas no terminal.

O que cai na CKA

• Cluster Architecture: entender os componentes do control plane
• Workloads: Deployments, DaemonSets, StatefulSets, Jobs, CronJobs
• Networking: Services, Network Policies, Ingress, CoreDNS
• Storage: PersistentVolumes, PersistentVolumeClaims, StorageClasses
• Security: RBAC, ServiceAccounts, Secrets, SecurityContext
• Troubleshooting: diagnosticar pods com crash, nodes NotReady, falha de rede

Como estudar para o CKA

• Pratique no terminal — a prova não tem múltipla escolha
• Domine o kubectl com a flag --dry-run=client -o yaml para gerar manifests rápido
• Conheça o kubernetes.io/docs — você pode consultar durante a prova
• Use o Killer.sh (simulador oficial, mais difícil que a prova real, de propósito)
• Monte um cluster local com kind ou minikube para praticar diariamente

Começando Localmente

# Instalar minikube (cluster local de 1 node)
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# Iniciar cluster
minikube start

# kubectl já vem configurado para o minikube
kubectl get nodes