Kubernetes para Iniciantes: Seu Primeiro Deploy de Aplicação Containerizada

O Kubernetes frequentemente carrega a fama de ser uma ferramenta extremamente complexa, reservada apenas para especialistas em infraestrutura de grandes corporações. No entanto, para desenvolvedores, profissionais de QA e pequenos times de tecnologia, compreender os fundamentos da orquestração de containers é um divisor de águas. Esse conhecimento não apenas amadurece a arquitetura do software, mas também aproxima o ambiente de desenvolvimento local do comportamento real de produção.

Neste guia prático, vamos desmistificar o Kubernetes (K8s). Você entenderá a diferença real entre ele e o Docker, compreenderá seus conceitos fundamentais e aprenderá a realizar o seu primeiro deploy local utilizando o Minikube, sem custos de nuvem e sem jargões comerciais.

O que é Kubernetes (K8s) e por que ele é necessário?

O Kubernetes é uma plataforma de orquestração de containers de código aberto projetada para automatizar a implantação, o dimensionamento e o gerenciamento de aplicações containerizadas. Desenvolvido originalmente pelo Google e lançado como open-source em 2014, o projeto hoje é mantido pela Cloud Native Computing Foundation (CNCF).

Para entender por que ele é necessário, precisamos dar um passo atrás. Quando trabalhamos com poucos containers, gerenciá-los manualmente é simples. Porém, à medida que a aplicação cresce, surgem desafios complexos:

• Como garantir que, se um container falhar, outro suba instantaneamente no lugar?
• Como distribuir o tráfego de rede de forma inteligente entre múltiplos containers?
• Como escalar a aplicação horizontalmente durante picos de acesso?

O Kubernetes resolve exatamente esses problemas. Ele atua como o “cérebro” que coordena a infraestrutura, garantindo que o estado real do seu sistema seja sempre igual ao estado desejado que você declarou. Se você ainda tem dúvidas sobre o ecossistema básico, vale a pena ler sobre o que são containers e orquestração.

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

Uma confusão muito comum entre quem está começando é achar que o Kubernetes substitui o Docker, ou vice-versa. Na realidade, eles são tecnologias complementares que resolvem problemas diferentes em etapas distintas do ciclo de vida do software.

• Docker: Focado em empacotar, distribuir e rodar containers isolados. Ele cria a imagem da sua aplicação (com todas as dependências inclusas) e garante que ela rode da mesma forma em qualquer máquina. Para entender como ele simplifica o dia a dia, veja nosso artigo sobre Docker para facilitar o desenvolvimento.
• Kubernetes: Focado em coordenar e gerenciar esses containers em escala, distribuídos em um cluster de várias máquinas (nós). O Kubernetes não cria os containers; ele utiliza um agente de execução (runtime) para rodar e gerenciar as imagens que você gerou (frequentemente criadas com Docker).

Em resumo: o Docker cria e roda o container individual; o Kubernetes gerencia o ecossistema de múltiplos containers trabalhando juntos.

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

Antes de colocar as mãos no terminal, você precisa compreender três conceitos fundamentais que estruturam quase qualquer aplicação no Kubernetes:

1. Pods

O Pod é a menor unidade de implantação no Kubernetes. Ele representa um único processo em execução no cluster e pode conter um ou mais containers que compartilham o mesmo espaço de rede, armazenamento e especificações de como rodar. Na imensa maioria dos casos, adota-se a prática de “um container por Pod”.

2. Deployments

Você raramente criará Pods diretamente. Em vez disso, utilizará um Deployment. O Deployment é um objeto declarativo que define o ciclo de vida dos seus Pods. Nele, você especifica qual imagem de container usar, quantas réplicas (cópias idênticas do Pod) deseja manter ativas e como o Kubernetes deve realizar atualizações de versão (rolling updates) sem derrubar o sistema.

3. Services

Pods são efêmeros: eles podem morrer, ser destruídos ou recriados a qualquer momento, e cada vez que isso acontece, eles ganham um novo endereço IP interno. Para evitar que outras partes do sistema percam a comunicação com eles, usamos o Service. O Service funciona como uma ponte de rede estável (com IP e DNS fixos) que expõe os Pods e distribui o tráfego de entrada entre as réplicas disponíveis.

Preparando o Ambiente Local com Minikube e Kubectl

Para praticar sem gastar com provedores de nuvem (como AWS, GCP ou Azure), utilizaremos o Minikube. Ele é uma ferramenta fantástica que cria um cluster Kubernetes de nó único dentro de uma máquina virtual ou container na sua máquina local.

Para interagir com esse cluster, utilizaremos a CLI oficial do Kubernetes, o kubectl.

Pré-requisitos

Antes de começar, certifique-se de ter instalado em sua máquina:

1. Um driver de virtualização (como o Docker Desktop, VirtualBox ou Hyper-V).
2. O Minikube.
3. O kubectl.

Com as ferramentas instaladas, abra o terminal e inicie o seu cluster local com o comando:

minikube start

Esse comando fará o download da imagem do cluster e configurará o kubectl para apontar automaticamente para o seu ambiente local. Para verificar se o cluster está ativo e respondendo, execute:

kubectl get nodes

Você deverá ver um nó chamado minikube com o status Ready. Esse processo de setup local é o primeiro passo para entender a automatização na infraestrutura.

Mão na Massa: Criando seu Primeiro Manifesto YAML

No Kubernetes, tudo é definido de forma declarativa através de arquivos YAML. Vamos criar um único arquivo chamado aplicacao.yaml que conterá a definição do nosso Deployment (rodando uma aplicação web simples de exemplo) e do nosso Service (para expor essa aplicação).

Crie o arquivo aplicacao.yaml e insira o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app-deployment
  labels:
    app: web-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: hello-app
        image: gcr.io/google-samples/hello-app:1.0
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: web-app-service
spec:
  type: ClusterIP
  selector:
    app: web-app
  ports:
  - port: 80
    targetPort: 8080

Entendendo o arquivo:

• Deployment: Definimos que queremos replicas: 2 (dois Pods rodando simultaneamente). A imagem utilizada é a hello-app:1.0, que escuta na porta 8080.
• Service: Criamos um serviço do tipo ClusterIP (acessível apenas internamente no cluster) que mapeia a porta 80 do serviço para a porta 8080 dos Pods marcados com a label app: web-app.

Executando o Deploy e Acessando a Aplicação

Com o arquivo salvo, vamos aplicar as configurações ao nosso cluster local utilizando o comando kubectl apply:

kubectl apply -f aplicacao.yaml

Você verá mensagens confirmando que o deployment e o service foram criados. Para verificar se os Pods já estão rodando, execute:

kubectl get pods

A saída deve mostrar dois Pods com o status Running:

NAME                                  READY   STATUS    RESTARTS   AGE
web-app-deployment-78d4cf998f-xxxxx   1/1     Running   0          15s
web-app-deployment-78d4cf998f-yyyyy   1/1     Running   0          15s

Acessando a aplicação localmente

Como configuramos o Service como ClusterIP, ele não está exposto diretamente para a sua máquina física. Para testarmos o acesso de forma rápida e segura sem alterar configurações de rede complexas, podemos usar o recurso de port-forward:

kubectl port-forward service/web-app-service 8080:80

Agora, abra o seu navegador e acesse http://localhost:8080. Você verá uma página simples exibindo a mensagem “Hello, world!” junto com o nome do Pod específico que respondeu à requisição. Pressione Ctrl + C no terminal para encerrar o redirecionamento quando terminar.

Troubleshooting Básico e Como Escalar a Aplicação

No dia a dia de quem trabalha com Kubernetes, saber diagnosticar problemas e ajustar recursos é fundamental. Aqui estão os comandos essenciais que você deve dominar:

1. Inspecionando detalhes (describe)

Se um Pod não estiver subindo ou apresentar erro, use o describe para ver o histórico de eventos detalhado daquele recurso:

kubectl describe pod <nome-do-pod>

2. Verificando logs

Para ler a saída padrão (stdout) gerada pela sua aplicação dentro do container:

kubectl logs <nome-do-pod>

3. Escalonamento rápido (Scale)

Uma das maiores vantagens do Kubernetes é a facilidade de escala. Se a sua aplicação web começar a receber muito tráfego e você precisar de mais poder de processamento, você pode escalar o número de réplicas instantaneamente com um único comando:

kubectl scale deployment web-app-deployment --replicas=5

Execute kubectl get pods novamente e observe o Kubernetes criando mais três Pods em tempo real para atingir o novo estado desejado.

Se preferir manter a infraestrutura documentada (o que é uma excelente prática de GitOps), basta alterar o campo replicas: 2 para replicas: 5 diretamente no seu arquivo aplicacao.yaml e rodar novamente o comando kubectl apply -f aplicacao.yaml.

Conclusão

Parabéns! Você acabou de instalar o Minikube, entender a diferença estrutural entre Docker e Kubernetes, criar manifestos declarativos e realizar o deploy de uma aplicação escalável localmente.

O Kubernetes pode parecer intimidador no início devido à quantidade de conceitos, mas ao focar na prática local e entender o papel de cada componente (Pods, Deployments e Services), a curva de aprendizado se torna muito mais suave. O próximo passo lógico é explorar como integrar esses deploys em pipelines de CI/CD automatizados e estudar estratégias de monitoramento.

FAQ: Dúvidas Comuns de Iniciantes

Preciso saber Docker antes de aprender Kubernetes?

Sim. Como o Kubernetes é um orquestrador de containers, você precisa entender como criar, rodar e estruturar imagens de containers (geralmente com Docker) antes de aprender a coordená-los em um cluster.

Qual a diferença entre o Minikube e ferramentas como Kind ou K3s?

O Minikube roda o Kubernetes dentro de uma máquina virtual local, sendo muito amigável para iniciantes. O Kind roda nós do Kubernetes como containers Docker (sendo mais rápido), e o K3s é uma versão altamente leve e otimizada para IoT e ambientes de produção com poucos recursos.

Como faço para atualizar a imagem da minha aplicação no Kubernetes?

Você pode atualizar o campo image dentro do seu arquivo YAML do Deployment com a nova tag da imagem e aplicar novamente com o comando kubectl apply -f aplicacao.yaml, ou usar o comando kubectl set image diretamente no terminal para disparar um rolling update.

Referências

• Documentação Oficial do Kubernetes
• Repositório Oficial do Minikube
• Cloud Native Computing Foundation (CNCF)