Docker: Fundamentos do Kubernetes

Última atualização: 2026-08-26

1. O Que Você Vai Aprender

• Arquitetura Central e Conceitos do K8s
• Pod / Deployment / Service — três objetos principais
• Comandos kubectl Comuns
• Uma Abordagem para Migrar do Compose para o K8s
• Configurando um Cluster Minikube Local

2. A História de uma Expansão de Cluster

(1) Ponto de Dor: Swarm já não é suficiente

O cluster Swarm que Alice implantou não era mais suficiente — cinco réplicas não conseguiam lidar com o tráfego, os rolling updates não eram flexíveis o suficiente, não havia escalonamento automático e a gestão de configuração era inadequada. A equipe decidiu migrar para Kubernetes, mas Alice estava completamente perdida com os conceitos de Pods, Deployments e Services do K8s.

(2) Solução para Aprender minikube Localmente

Bob configurou um ambiente de desenvolvimento K8s usando minikube no laptop da Alice.

# Iniciar cluster K8s local
minikube start --driver=docker

# Implantar uma aplicação
kubectl create deployment nginx --image=nginx:1.25-alpine --replicas=3
kubectl expose deployment nginx --port=80 --type=NodePort

(3) Benefícios: Entenda os conceitos principais do K8s em 5 minutos

Alice descobriu que Pods K8s e contêineres Docker têm muitas semelhanças: um Deployment corresponde às replicas do Compose, e um Service corresponde à rede e mapeamento de portas do Docker.

3. Arquitetura Central do K8s

(1) Visão Geral da Arquitetura

graph TB
    K["kubectl CLI"] --> API["API Server<br/>Entrada REST API"]
    API --> SCHED["Scheduler<br/>Agendamento de Pods"]
    API --> ETCD["etcd<br/>Armazenamento de Estado do Cluster"]
    API --> CTRL["Controller Manager<br/>Deployment/ReplicaSet"]
    API --> KUBELET["Kubelet<br/>Proxy do Nó"]
    KUBELET --> CRI["Container Runtime<br/>containerd/Docker"]
    CRI --> POD["Pod<br/>Grupo de Contêineres"]

graph TB
    K["kubectl CLI"] --> API["API Server<br/>Entrada REST API"]
    API --> SCHED["Scheduler<br/>Agendamento de Pods"]
    API --> ETCD["etcd<br/>Armazenamento de Estado do Cluster"]
    API --> CTRL["Controller Manager<br/>Deployment/ReplicaSet"]
    API --> KUBELET["Kubelet<br/>Proxy do Nó"]
    KUBELET --> CRI["Container Runtime<br/>containerd/Docker"]
    CRI --> POD["Pod<br/>Grupo de Contêineres"]

(2) Componentes Principais do K8s

4. Conceitos Principais do K8s

(1) Pod / Deployment / Service

(2) Mapa de Conceitos Docker Compose → K8s

5. Comandos kubectl Comuns

▶ Exemplo: Iniciando um cluster com minikube (Dificuldade: ⭐⭐)

# Iniciar um cluster K8s local
minikube start --driver=docker --kubernetes-version=v1.28.0

# Verificar status do cluster
kubectl cluster-info
kubectl get nodes

Kubernetes control plane is running at https://127.0.0.1:32768
CoreDNS is running at https://127.0.0.1:32768/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   60s   v1.28.0

▶ Exemplo: kubectl create deployment (Dificuldade: ⭐⭐)

# Criar um deployment com 3 réplicas
kubectl create deployment nginx --image=nginx:1.25-alpine --replicas=3

# Verificar status do deployment
kubectl get deployments
kubectl get pods

NAME    READY   UP-TO-DATE   AVAILABLE   AGE
nginx   3/3     3            3           30s

NAME                     READY   STATUS    RESTARTS   AGE
nginx-6c8b5f4d8f-abc12   1/1     Running   0          30s
nginx-6c8b5f4d8f-def34   1/1     Running   0          30s
nginx-6c8b5f4d8f-ghi56   1/1     Running   0          30s

▶ Exemplo: kubectl expose service (Dificuldade: ⭐⭐)

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

# Obter a URL do serviço
minikube service nginx --url

# Ou usar port-forward para acesso local
kubectl port-forward svc/nginx 8080:80

▶ Exemplo: Escalonamento com kubectl scale (Dificuldade: ⭐⭐)

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

# Verificar
kubectl get pods

▶ Exemplo: kubectl rollout (Dificuldade: ⭐⭐⭐)

# Atualizar a imagem
kubectl set image deployment/nginx nginx=nginx:1.26-alpine

# Verificar status do rollout
kubectl rollout status deployment/nginx

# Rollback se algo der errado
kubectl rollout undo deployment/nginx

# Ver histórico de rollout
kubectl rollout history deployment/nginx

6. Configuração Declarativa YAML

(1) Deployment + Service YAML

# nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25-alpine
        ports:
        - containerPort: 80
        resources:
          limits:
            cpu: "0.5"
            memory: "128Mi"
---
apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80
  type: NodePort

# Aplicar o YAML
kubectl apply -f nginx-deployment.yaml

# Verificar
kubectl get all

7. K8s de Nó Único vs. Multi-Nó

8. Exemplo Completo: Implantando uma Aplicação com minikube

# ============================================
# Passo a passo completo: K8s no minikube
# Abrange: cluster, deploy, service, scale, update
# ============================================

# 1. Iniciar cluster minikube
minikube start --driver=docker

# 2. Criar deployment
kubectl create deployment web --image=nginx:1.25-alpine --replicas=2

# 3. Expor como serviço
kubectl expose deployment web --port=80 --type=NodePort

# 4. Acessar a aplicação
minikube service web --url
# Ou: kubectl port-forward svc/web 8080:80

# 5. Escalar para 5 réplicas
kubectl scale deployment web --replicas=5
kubectl get pods -w

# 6. Rolling update
kubectl set image deployment/web nginx=nginx:1.26-alpine
kubectl rollout status deployment/web

# 7. Rollback
kubectl rollout undo deployment/web

# 8. Limpar
kubectl delete deployment web
kubectl delete service web
minikube stop

❓ Perguntas Frequentes

P: Qual devo escolher, K8s ou Docker Swarm? R: Swarm é simples e fácil de aprender, adequado para equipes pequenas (<20 pessoas) e casos de uso simples. K8s é poderoso mas complexo, adequado para equipes grandes, cenários que exigem escalonamento automático e um ecossistema robusto. Regra prática: Use Swarm para 3-5 nós em uma única máquina; use K8s para 5 ou mais nós ou quando recursos avançados são necessários.

P: Qual é a diferença entre um Pod e um Contêiner? R: Um Pod é a menor unidade de agendamento no K8s e pode conter um ou mais contêineres. Contêineres dentro de um Pod compartilham rede e armazenamento. A maioria dos Pods contém apenas um contêiner — neste caso, um Pod é aproximadamente equivalente a um Contêiner. Pods multi-contêiner são usados em cenários fortemente acoplados (como uma aplicação e um proxy sidecar).

P: Quantos servidores o K8s requer? R: Para aprendizado: 1 servidor (Minikube). Para desenvolvimento: 1-3 servidores. Para produção: 3+ nós Master + N nós Worker. Com serviços K8s gerenciados de provedores de nuvem (EKS/GKE/AKS), você não precisa gerenciar os nós Master; um mínimo de 1 nó Worker é suficiente.

P: Devo aprender K8s diretamente do Compose? R: Recomendo dominar Docker + Compose primeiro (Aulas 1-22 deste curso) antes de passar para K8s. O Compose cobre 80% dos casos de uso; K8s só é necessário quando você precisa de um cluster. Se pular direto para K8s, é provável que você fique sobrecarregado pelos conceitos — primeiro entenda os fundamentos de contêineres e orquestração, depois aprenda as abstrações do K8s.

P: Qual é melhor para aprender — minikube ou kind? R: minikube oferece mais recursos (Dashboard, add-ons, múltiplos drivers) e é mais adequado para iniciantes. kind (Kubernetes in Docker) é mais leve e inicia mais rápido, ideal para CI e testes multi-cluster. Recomendamos minikube para aprendizado.

📖 Resumo

• Arquitetura Central do K8s: API Server + etcd + Scheduler + Kubelet + Kube-proxy
• Pod (menor unidade de agendamento) ≈ Container, Deployment (gestão de réplicas) ≈ Compose replicas, Service (rede) ≈ Docker DNS
• kubectl é a CLI do K8s, equivalente ao comando docker
• minikube: Inicie um cluster K8s local com um único comando — perfeito para aprendizado
• A configuração YAML declarativa do K8s corresponde ao docker-compose.yml do Compose
• Migração do Docker para K8s: Compose service → Deployment + Service, Volume → PV/PVC, env → ConfigMap + Secret

📝 Exercícios

1. Exercício Básico (Dificuldade: ⭐): Use minikube para iniciar um cluster K8s local, implante uma instância Nginx e acesse-a via port forwarding.
2. Exercício Avançado (Dificuldade: ⭐⭐): Crie um Deployment e um Service usando um arquivo YAML, implante com kubectl apply -f e exponha as portas.
3. Desafio (Dificuldade: ⭐⭐⭐): Realize um rolling update (nginx: 1.25 → 1.26), observe kubectl rollout status e depois faça rollback usando kubectl rollout undo.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós