Pular para o conteúdo principal

Lab 1.1 - Primeiro Deploy no Kubernetes

Objetivos do Lab​

Ao final deste lab, você será capaz de:

  • Fazer o deploy da sua primeira aplicação no Kubernetes
  • Utilizar o kubectl para criar recursos
  • Entender Pods e Deployments
  • Verificar o estado do seu deploy
  • Acessar sua aplicação

Duração Estimada​

30-45 minutos

Pré-requisitos​

  • kubectl instalado e configurado
  • Cluster Kubernetes local funcional (minikube ou kind)
  • Conexão com a Internet (para baixar as imagens Docker)

Verificação do Ambiente​

Antes de começar, vamos verificar se tudo está pronto:

# 1. Verificar kubectl
kubectl version --client

# 2. Verificar a conexão com o cluster
kubectl cluster-info

# 3. Listar os nodes (deve mostrar pelo menos 1 node)
kubectl get nodes

Resultado esperado:

NAME           STATUS   ROLES           AGE   VERSION
minikube       Ready    control-plane   5m    v1.28.0

Se você ver algum erro, volte ao Capítulo 1 para configurar seu ambiente.

Parte 1: Deploy Simples com kubectl​

Passo 1: Criar um Pod Simples​

Vamos começar criando um Pod simples que executa o nginx:

kubectl run nginx-pod --image=nginx:latest

Explicação:

  • kubectl run: Comando para criar um Pod
  • nginx-pod: Nome do Pod
  • --image=nginx:latest: Imagem Docker a ser utilizada

Passo 2: Verificar o Pod​

Vamos verificar se o Pod foi criado:

kubectl get pods

Resultado esperado:

NAME        READY   STATUS    RESTARTS   AGE
nginx-pod   1/1     Running   0          30s

Explicação das colunas:

  • NAME: Nome do Pod
  • READY: Número de containers prontos / total (1/1 = pronto)
  • STATUS: Estado do Pod (Running = em execução)
  • RESTARTS: Número de reinicializações
  • AGE: Tempo desde a criação

Passo 3: Obter Mais Detalhes​

Para ver mais informações sobre o Pod:

kubectl describe pod nginx-pod

Este comando mostra:

  • Os eventos do Pod
  • O estado dos containers
  • Os recursos alocados
  • Os labels e anotações

Passo 4: Ver os Logs​

Consulte os logs do Pod:

kubectl logs nginx-pod

Você deve ver os logs do servidor nginx.

Passo 5: Executar um Comando no Pod​

Vamos executar um comando dentro do Pod:

kubectl exec -it nginx-pod -- /bin/bash

Explicação:

  • exec: Executa um comando em um container
  • -it: Modo interativo com terminal
  • -- /bin/bash: Comando a ser executado

Uma vez dentro do Pod, tente:

# Ver o conteúdo do diretório
ls -la

# Verificar se o nginx está funcionando
curl localhost

# Sair do Pod
exit

Passo 6: Deletar o Pod​

Vamos deletar o Pod que acabamos de criar:

kubectl delete pod nginx-pod

Vamos verificar se ele foi removido:

kubectl get pods

Parte 2: Deploy com um Arquivo YAML​

Agora, vamos criar um deploy mais profissional usando um arquivo YAML.

Passo 1: Criar o Arquivo YAML​

Crie um arquivo nginx-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25
        ports:
        - containerPort: 80

Explicação do arquivo:

  • apiVersion: Versão da API do Kubernetes
  • kind: Tipo de recurso (Deployment)
  • metadata: Metadados (nome, labels)
  • spec: Especificação do deploy
    • replicas: Número de instâncias (3)
    • selector: Como identificar os Pods
    • template: Modelo para criar os Pods

Passo 2: Aplicar o Deploy​

Vamos aplicar o arquivo YAML:

kubectl apply -f nginx-deployment.yaml

Resultado esperado:

deployment.apps/nginx-deployment created

Passo 3: Verificar o Deploy​

Vamos verificar se o deploy foi criado:

kubectl get deployments

Resultado esperado:

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

Explicação:

  • READY: 3/3 = 3 Pods prontos de 3 desejados
  • UP-TO-DATE: 3 Pods atualizados
  • AVAILABLE: 3 Pods disponíveis

Passo 4: Ver os Pods Criados​

O Deployment criou 3 Pods:

kubectl get pods -l app=nginx

Resultado esperado:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-7d4b8c9f5c-abc12   1/1     Running   0          1m
nginx-deployment-7d4b8c9f5c-def34   1/1     Running   0          1m
nginx-deployment-7d4b8c9f5c-ghi56   1/1     Running   0          1m

Nota: Os nomes dos Pods são gerados automaticamente com um hash único.

Passo 5: Detalhes do Deploy​

Vamos obter mais informações sobre o deploy:

kubectl describe deployment nginx-deployment

Este comando mostra:

  • O número de réplicas
  • A estratégia de deploy
  • Os eventos
  • As condições

Parte 3: Expor a Aplicação​

Agora, vamos expor a aplicação para acessá-la de fora.

Passo 1: Criar um Service​

Crie um arquivo nginx-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: NodePort
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
      nodePort: 30080

Explicação:

  • kind: Service: Cria um Service
  • type: NodePort: Expõe o serviço em uma porta de cada node
  • selector: Seleciona os Pods com o label app: nginx
  • nodePort: 30080: Porta acessível externamente

Passo 2: Aplicar o Service​

kubectl apply -f nginx-service.yaml

Passo 3: Verificar o Service​

kubectl get services

Resultado esperado:

NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
nginx-service   NodePort    10.96.123.45    <none>        80:30080/TCP   30s

Passo 4: Acessar a Aplicação​

Com minikube:​

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

# Ou abrir diretamente no navegador
minikube service nginx-service

Com kind:​

# Encontrar o endereço IP do node
kubectl get nodes -o wide

# Acessar via http://<NODE-IP>:30080

Teste com curl:​

# Da sua máquina
curl http://localhost:30080

# Ou de dentro de um Pod
kubectl run curl-test --image=curlimages/curl --rm -it -- curl http://nginx-service

Você deve ver a página inicial padrão do nginx!

Parte 4: Scaling e Atualização​

Passo 1: Aumentar o Número de Réplicas​

Vamos aumentar o número de Pods de 3 para 5:

kubectl scale deployment nginx-deployment --replicas=5

Vamos verificar:

kubectl get pods -l app=nginx

Agora você deve ver 5 Pods!

Passo 2: Reduzir o Número de Réplicas​

Vamos reduzir para 2 Pods:

kubectl scale deployment nginx-deployment --replicas=2

Passo 3: Atualizar a Imagem​

Vamos atualizar a imagem do nginx para uma versão mais recente:

kubectl set image deployment/nginx-deployment nginx=nginx:1.26

Vamos verificar a atualização:

kubectl rollout status deployment/nginx-deployment

Este comando mostra o progresso do rolling update.

Passo 4: Ver o Histórico de Deploys​

kubectl rollout history deployment/nginx-deployment

Passo 5: Rollback (Opcional)​

Se algo der errado, podemos voltar atrás:

kubectl rollout undo deployment/nginx-deployment

Parte 5: Limpeza​

Vamos limpar os recursos criados:

# Deletar o Service
kubectl delete -f nginx-service.yaml

# Deletar o Deployment (também remove os Pods)
kubectl delete -f nginx-deployment.yaml

# Verificar se tudo foi removido
kubectl get all

Resumo do Lab​

Neste lab, você:

Criou seu primeiro Pod com kubectl
Criou um Deployment com um arquivo YAML
Expôs a aplicação com um Service NodePort
Fez scaling do deploy (aumentou/reduziu o número de réplicas)
Atualizou a imagem Docker
Limpou os recursos

Perguntas para Reflexão​

  1. Qual a diferença entre um Pod e um Deployment?

    • Um Pod é uma instância única de um container
    • Um Deployment gerencia múltiplos Pods (réplicas) e seu ciclo de vida

  2. Por que usar um Deployment ao invés de um Pod diretamente?

    • O Deployment gerencia automaticamente as réplicas
    • Permite rolling updates
    • Reinicia automaticamente Pods que falham

  3. O que é um Service e por que precisamos dele?

    • Um Service expõe um conjunto de Pods de forma estável
    • Ele fornece load balancing
    • Permite acesso de fora do cluster

Próximos Passos​

Agora que você fez o deploy da sua primeira aplicação, você está pronto para:

Capítulo 2: Exploração aprofundada de Pods
Módulo 2: Arquitetura detalhada do Kubernetes

Recursos​

Lab criado em: Dezembro 2024