Kubernetes para Iniciantes: Seu Primeiro Deploy em Minutos (Guia Prático)

Kubernetes. A palavra pode soar intimidadora, carregada de jargões e a promessa de complexidade. Mas, na verdade, ele é uma ferramenta poderosa e prática, projetada para resolver problemas reais no gerenciamento de aplicações modernas. Se você é um desenvolvedor iniciante, um QA curioso ou um fundador técnico buscando entender a orquestração de contêineres, este guia é para você.

Nosso objetivo é desmistificar o Kubernetes, mostrando como você pode ter um cluster local rodando e uma aplicação exposta em questão de minutos, sem custos com provedores de nuvem. Vamos focar na prática, com exemplos claros e um passo a passo que você pode replicar agora mesmo.

Docker vs. Kubernetes: Qual é a diferença real?

É comum que iniciantes confundam Docker e Kubernetes, ou os vejam como concorrentes. Na realidade, eles são tecnologias complementares que trabalham juntas para otimizar o ciclo de vida das aplicações. Para entender o conceito de contêineres e orquestração de forma definitiva, é crucial compreender essa relação.

Docker é uma plataforma para criar, empacotar e executar contêineres. Pense nele como a ferramenta que permite isolar sua aplicação e suas dependências em um pacote leve e portátil. Ele garante que sua aplicação rode da mesma forma em qualquer ambiente, seja na sua máquina local ou em um servidor de produção. Se você quer isolar o ambiente de desenvolvimento com Docker, ele é a escolha ideal.

Kubernetes, por outro lado, é um orquestrador de contêineres. Ele entra em cena quando você precisa gerenciar múltiplos contêineres em larga escala, automatizando a implantação, o dimensionamento, a autocorreção e o balanceamento de carga de suas aplicações. Enquanto o Docker cria o “tijolo” (o contêiner), o Kubernetes é o “arquiteto” que organiza e gerencia esses tijolos para construir e manter um edifício robusto e resiliente. ¹

Em resumo, você usa Docker para construir suas imagens de contêiner, e Kubernetes para gerenciar onde e como essas imagens rodam em um cluster de máquinas.

Os Três Pilares Fundamentais: Pods, Deployments e Services

Para começar a trabalhar com Kubernetes, você precisa entender três conceitos essenciais. Eles são os blocos de construção de qualquer aplicação no cluster:

1. Pods: A menor unidade de execução no Kubernetes. Um Pod é uma abstração que representa uma instância de uma aplicação em execução. Ele pode conter um ou mais contêineres (geralmente um, a menos que haja uma boa razão para ter mais, como um sidecar). Pods são efêmeros e podem ser recriados a qualquer momento. ²

2. Deployments: Um objeto que gerencia o ciclo de vida dos Pods. Ele permite que você descreva o estado desejado da sua aplicação, como o número de réplicas de Pods que devem estar rodando, qual imagem de contêiner usar e como atualizá-los. O Deployment garante que o número especificado de Pods esteja sempre ativo e saudável, lidando com falhas e escalonamento automático. ³

3. Services: Um mecanismo de rede que expõe sua aplicação. Pods são efêmeros e têm IPs que mudam. Um Service fornece um IP e um nome DNS estáveis para um conjunto de Pods, permitindo que outras aplicações dentro ou fora do cluster se comuniquem com eles. Existem diferentes tipos de Services, como ClusterIP (acesso interno), NodePort (acesso externo via porta do nó) e LoadBalancer (integração com balanceadores de carga de nuvem).

Configurando o Ambiente Local com Minikube e kubectl

Para nosso primeiro deploy, vamos usar o Minikube. Ele permite que você execute um cluster Kubernetes de nó único na sua máquina local, sendo perfeito para aprendizado e desenvolvimento. Além disso, precisaremos do kubectl, a ferramenta de linha de comando para interagir com o cluster. ⁴

Passo 1: Instalar um Hypervisor (se necessário)

Minikube precisa de um driver para criar a máquina virtual onde o Kubernetes rodará. Os mais comuns são Docker Desktop (já inclui um driver), VirtualBox ou Hyper-V. Se você já tem Docker Desktop instalado, pode pular este passo.

Passo 2: Instalar Minikube

Siga as instruções oficiais do Minikube para seu sistema operacional:

• macOS (Homebrew):

  brew install minikube

• Windows (Chocolatey):

  choco install minikube

• Linux (apt):

  curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
  sudo install minikube-linux-amd64 /usr/local/bin/minikube

Passo 3: Instalar kubectl

Siga as instruções oficiais do Kubernetes para seu sistema operacional:

• macOS (Homebrew):

  brew install kubectl

• Windows (Chocolatey):

  choco install kubernetes-cli

• Linux (apt):

  sudo apt-get update && sudo apt-get install -y apt-transport-https
  curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
  echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
  sudo apt-get update
  sudo apt-get install -y kubectl

Passo 4: Iniciar o Minikube

Abra seu terminal e execute:

minikube start

Este comando pode levar alguns minutos para baixar as imagens necessárias e iniciar o cluster. Se você tiver Docker Desktop, pode especificar o driver:

minikube start --driver=docker

Após a inicialização, você pode verificar o status do cluster:

minikube status
kubectl cluster-info

Escrevendo os Arquivos YAML: Deployment e Service na Prática

No Kubernetes, a configuração é declarativa, ou seja, você descreve o estado desejado da sua aplicação em arquivos YAML, e o Kubernetes se encarrega de fazer com que o cluster atinja esse estado. ⁵

Vamos criar dois arquivos: um para o Deployment e outro para o Service.

Crie um arquivo chamado nginx-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 2 # Queremos 2 instâncias do nosso Pod
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest # Usaremos a imagem oficial do Nginx
        ports:
        - containerPort: 80 # O Nginx escuta na porta 80 dentro do contêiner

Explicação do nginx-deployment.yaml:

• apiVersion: apps/v1: Define a versão da API do Kubernetes que estamos usando para Deployments.
• kind: Deployment: Indica que estamos criando um Deployment.
• metadata.name: Nome do nosso Deployment (nginx-deployment).
• labels: Rótulos para identificar o Deployment.
• spec.replicas: Define que queremos 2 réplicas do Pod Nginx rodando.
• spec.selector.matchLabels: Como o Deployment encontra os Pods que ele deve gerenciar. Ele busca Pods com o rótulo app: nginx.
• spec.template: O modelo para criar os Pods.
  • metadata.labels: Rótulos que serão aplicados aos Pods criados por este Deployment.
  • spec.containers: Lista de contêineres dentro do Pod.
    • name: Nome do contêiner (nginx).
    • image: A imagem Docker a ser usada (nginx:latest).
    • ports.containerPort: A porta que o contêiner expõe (porta 80 para Nginx).

Agora, crie um arquivo chamado nginx-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx # Este Service irá direcionar o tráfego para Pods com o rótulo app: nginx
  type: NodePort # Permite acesso externo via uma porta no nó do Minikube
  ports:
    - protocol: TCP
      port: 80 # Porta do Service (interna ao cluster)
      targetPort: 80 # Porta do contêiner (onde o Nginx está escutando)
      nodePort: 30080 # Porta no nó do Minikube (acessível de fora do cluster)

Explicação do nginx-service.yaml:

• apiVersion: v1: Versão da API para Services.
• kind: Service: Indica que estamos criando um Service.
• metadata.name: Nome do nosso Service (nginx-service).
• spec.selector: Como o Service encontra os Pods para os quais ele deve rotear o tráfego. Ele busca Pods com o rótulo app: nginx.
• spec.type: NodePort: Este tipo de Service expõe a aplicação em uma porta estática em cada nó do cluster. É ideal para testes locais com Minikube.
• spec.ports:
  • port: A porta que o Service expõe dentro do cluster.
  • targetPort: A porta do contêiner para a qual o Service redireciona o tráfego.
  • nodePort: A porta que será aberta no nó do Minikube, permitindo acesso externo. Deve estar entre 30000-32767.

Executando o Deploy e Escalando a Aplicação em Tempo Real

Com os arquivos YAML prontos, é hora de fazer o deploy da sua aplicação no Minikube.

Passo 1: Aplicar os arquivos de configuração

No terminal, na mesma pasta onde você salvou os arquivos YAML, execute:

kubectl apply -f nginx-deployment.yaml
kubectl apply -f nginx-service.yaml

Você verá mensagens confirmando a criação do Deployment e do Service.

Passo 2: Verificar o status dos Pods

Para ver os Pods que foram criados pelo seu Deployment:

kubectl get pods

Você deverá ver dois Pods com nomes como nginx-deployment-xxxxxxxxxx-yyyyy no status Running.

Passo 3: Acessar a aplicação

Como usamos um Service do tipo NodePort, podemos acessar a aplicação diretamente pela porta do Minikube. Para descobrir a URL exata, execute:

minikube service nginx-service --url

Este comando retornará uma URL (ex: http://192.168.49.2:30080). Copie e cole no seu navegador. Você deverá ver a página de boas-vindas do Nginx!

Alternativamente, você pode usar kubectl port-forward para mapear uma porta local para o Pod:

kubectl port-forward service/nginx-service 8080:80

Agora, acesse http://localhost:8080 no seu navegador.

Passo 4: Escalar a aplicação em tempo real

Uma das grandes vantagens do Kubernetes é a facilidade de escalonamento. Vamos aumentar o número de réplicas do Nginx para 3:

kubectl scale deployment nginx-deployment --replicas=3

Execute kubectl get pods novamente. Você verá um novo Pod sendo criado e entrando no estado Running.

Para diminuir, basta alterar o número de réplicas:

kubectl scale deployment nginx-deployment --replicas=1

O Kubernetes se encarrega de encerrar os Pods excedentes. Essa capacidade de escalonamento dinâmico é fundamental para aplicações que precisam lidar com variações de carga, e abre caminho para integrar o deploy a uma pipeline de CI/CD para automação completa.

Troubleshooting: O que fazer quando o Pod não sobe?

É comum que, ao iniciar, algo não saia como o esperado. Aqui estão alguns comandos essenciais para diagnosticar problemas:

1. Verificar o status geral dos recursos:

   kubectl get all

   Este comando mostra Pods, Deployments, Services e outros recursos.

2. Verificar o status dos Pods:

   kubectl get pods

   Procure por Pods que não estejam no estado Running (ex: Pending, CrashLoopBackOff, Error).

3. Obter logs de um Pod:

   kubectl logs <nome-do-pod>

   Substitua <nome-do-pod> pelo nome completo do Pod (ex: nginx-deployment-xxxxxxxxxx-yyyyy). Os logs podem indicar erros na aplicação ou no contêiner.

4. Descrever um Pod para detalhes:

   kubectl describe pod <nome-do-pod>

   Este comando fornece informações detalhadas sobre o Pod, incluindo eventos, volumes, condições e mensagens de erro que podem explicar por que ele não está iniciando corretamente (ex: imagem não encontrada, erro de rede, falta de recursos).

5. Descrever um Deployment ou Service:

   kubectl describe deployment nginx-deployment
   kubectl describe service nginx-service

   Isso pode ajudar a identificar problemas de configuração nos seus arquivos YAML.

Com esses comandos, você terá um bom ponto de partida para investigar e resolver a maioria dos problemas comuns ao iniciar com Kubernetes.

FAQ

Preciso saber Docker antes de aprender Kubernetes? Sim, é altamente recomendável. Como o Kubernetes orquestra contêineres, você precisa entender como empacotar sua aplicação em uma imagem Docker antes de gerenciá-la no cluster.

Por que usar o Minikube em vez de um serviço de nuvem como AWS EKS? O Minikube roda localmente e é totalmente gratuito, sendo ideal para aprendizado e testes rápidos sem a complexidade de permissões IAM ou custos de infraestrutura em nuvem.

Qual é a diferença prática entre um Pod e um Deployment? Um Pod é o contêiner (ou grupo de contêineres) rodando em si. O Deployment é o controlador declarativo que gerencia esses Pods, garantindo que o número correto de réplicas esteja sempre ativo e saudável.

Referências