O Kubernetes (também conhecido como K8s) é uma plataforma open-source de orquestração de contêineres que automatiza a implantação, o dimensionamento e a operação de aplicações em contêineres. Criado pelo Google e agora mantido pela Cloud Native Computing Foundation (CNCF), o Kubernetes se tornou o padrão de fato para gerenciar cargas de trabalho em contêineres em produção. Nesta aula, vamos explorar os fundamentos do Kubernetes, desde sua definição até sua arquitetura e conceitos essenciais, preparando você para os próximos passos no mundo DevOps.

Se você já trabalha com Docker, sabe que gerenciar alguns contêineres manualmente é viável. Mas em um ambiente de produção com dezenas ou centenas de contêineres, surgem desafios como escalabilidade, disponibilidade, balanceamento de carga e atualizações contínuas. O Kubernetes resolve esses problemas oferecendo uma camada de abstração que gerencia o ciclo de vida dos contêineres de forma declarativa e automatizada.

O que é

O Kubernetes é um sistema de orquestração de contêineres que permite implantar, escalar e gerenciar aplicações em contêineres em um cluster de máquinas. Ele oferece uma API para definir o estado desejado da aplicação (por exemplo, quantas réplicas devem estar rodando) e trabalha continuamente para garantir que o estado real corresponda ao desejado. Isso é feito por meio de um conjunto de componentes que se comunicam entre si para manter o sistema funcionando.

Diferente de ferramentas como Docker Compose, que são voltadas para ambientes locais ou de desenvolvimento, o Kubernetes é projetado para ambientes de produção, com recursos como auto-scaling, auto-recuperação, atualizações sem downtime e balanceamento de carga interno. Ele é agnóstico de nuvem, podendo rodar em qualquer infraestrutura (on-premises, nuvens públicas ou híbridas).

Um exemplo simples de uso: você define um arquivo YAML que descreve que deseja 3 réplicas de um serviço web, com uma imagem específica. O Kubernetes lê esse arquivo e garante que 3 pods estejam sempre rodando, substituindo qualquer pod que falhe e escalando manual ou automaticamente conforme a demanda.

Para começar, podemos usar um comando como kubectl para interagir com o cluster. Por exemplo, para ver os nós do cluster:

kubectl get nodes

Arquitetura (control plane, nodes)

Um cluster Kubernetes é composto por dois tipos de componentes: o control plane (plano de controle) e os nodes (nós). O control plane é o cérebro do cluster, responsável por tomar decisões globais (como agendar novos pods) e responder a eventos. Ele consiste em vários componentes que podem rodar em uma única máquina ou em múltiplas máquinas para alta disponibilidade.

Os principais componentes do control plane são:

  • kube-apiserver: é a porta de entrada para todas as operações via API REST. Ele valida e processa os comandos recebidos.
  • etcd: armazenamento chave-valor distribuído que guarda todo o estado do cluster (configurações, dados de contêineres, etc.).
  • kube-scheduler: responsável por decidir em qual nó cada pod deve ser executado, com base em recursos, afinidade e outras políticas.
  • kube-controller-manager: executa os controladores (controllers) que monitoram o estado do cluster e fazem as correções necessárias (ex.: garantir que o número de réplicas esteja correto).
  • cloud-controller-manager: opcional, integra o cluster com provedores de nuvem (ex.: balanceadores de carga, volumes).

Já os nodes (nós) são as máquinas (físicas ou virtuais) onde os contêineres realmente são executados. Cada nó contém:

  • kubelet: agente que se comunica com o control plane e garante que os contêineres estejam rodando no nó.
  • kube-proxy: mantém as regras de rede que permitem a comunicação com os serviços.
  • container runtime: o software que executa os contêineres (ex.: Docker, containerd, CRI-O).

Para visualizar a arquitetura, podemos usar o comando:

kubectl get pods -n kube-system

Isso lista os pods que rodam os componentes do próprio Kubernetes no namespace kube-system.

Quando (não) usar

O Kubernetes é extremamente poderoso, mas não é a solução para todos os casos. É importante entender quando faz sentido adotá-lo e quando ele pode ser um exagero.

Quando usar Kubernetes:

  • Se você tem uma aplicação que precisa escalar horizontalmente (mais réplicas conforme a demanda).
  • Se você precisa de alta disponibilidade e auto-recuperação (substituição automática de contêineres com falha).
  • Se você trabalha com microservices, onde cada serviço pode ter seu próprio ciclo de vida e escalonamento.
  • Se você precisa fazer deploy contínuo (CI/CD) com zero downtime (rolling updates).
  • Se você quer gerenciar múltiplos ambientes (dev, staging, prod) de forma consistente.
  • Se você está em uma organização que já adota contêineres em larga escala.

Quando NÃO usar Kubernetes:

  • Para aplicações simples ou monolíticas que rodam em um único servidor.
  • Para projetos pequenos ou em estágio inicial, onde a complexidade de operar um cluster não compensa.
  • Quando a equipe não tem experiência em operar infraestrutura distribuída.
  • Se a aplicação tem requisitos de baixa latência e o overhead de rede do Kubernetes é inaceitável.
  • Se você precisa de gerenciamento de estado (stateful) muito específico que o Kubernetes ainda não suporta bem (embora ele tenha melhorado muito nesse aspecto).

Uma regra prática: se você consegue resolver seu problema com Docker Compose ou uma VM, talvez não precise de Kubernetes. Ele adiciona complexidade operacional considerável, então avalie os benefícios reais para seu caso.

Conceitos centrais

O Kubernetes introduz vários conceitos que são essenciais para trabalhar com ele. Vamos explorar os principais:

Pods

O pod é a menor unidade de execução no Kubernetes. Ele representa um ou mais contêineres que compartilham o mesmo namespace de rede e podem compartilhar volumes. Geralmente, um pod contém um único contêiner, mas em casos de sidecar (por exemplo, um contêiner de log) pode haver mais. Os pods são efêmeros: quando um pod é destruído, ele não é recriado da mesma forma; em vez disso, um Deployment ou ReplicaSet garante a criação de um novo pod.

Deployments

Um Deployment é um recurso que define o estado desejado para seus pods (imagem, réplicas, atualizações). Ele gerencia ReplicaSets (que controlam o número de réplicas) e permite fazer rolling updates e rollbacks. Por exemplo, para criar um deployment com 3 réplicas de um nginx:

kubectl create deployment nginx --image=nginx --replicas=3

Services

Um Service é uma abstração que define um conjunto de pods e uma política de acesso. Ele fornece um endereço IP e um DNS estáveis para que outros componentes possam acessar o serviço, independentemente de quais pods estão ativos. Existem tipos como ClusterIP (acesso interno), NodePort (expor porta em cada nó) e LoadBalancer (balanceador de carga externo). Exemplo de criação de um Service:

kubectl expose deployment nginx --type=LoadBalancer --port=80

Namespaces

Namespaces são usados para dividir o cluster em ambientes virtuais separados. Isso permite organizar recursos, aplicar quotas de recursos e políticas de acesso. Por exemplo, você pode ter namespaces dev, prod. Para listar namespaces:

kubectl get namespaces

ConfigMaps e Secrets

ConfigMaps são usados para armazenar configurações não confidenciais (como variáveis de ambiente), e Secrets para dados sensíveis (como senhas e chaves). Eles permitem separar a configuração do código do contêiner. Exemplo de criação de um ConfigMap:

kubectl create configmap app-config --from-literal=APP_COLOR=blue

Ingress

O Ingress é um recurso que gerencia o acesso externo aos serviços dentro do cluster, tipicamente HTTP. Ele fornece roteamento baseado em host ou caminho e pode fazer terminação de TLS. Exemplo de um objeto Ingress:

kubectl apply -f ingress.yaml

Esses são apenas alguns dos conceitos fundamentais. Conforme você avança, encontrará outros como StatefulSets, DaemonSets, PersistentVolumes e muito mais.

Boas práticas e observações finais

Ao trabalhar com Kubernetes, é importante seguir boas práticas para garantir estabilidade e segurança. Algumas recomendações:

  • Use arquivos de manifesto versionados (GitOps) para gerenciar seus recursos.
  • Defina limites de recursos (requests/limits) para cada pod, evitando que um contêiner consuma todos os recursos do nó.
  • Utilize namespaces para isolar ambientes e aplicar quotas.
  • Prefira Deployments em vez de criar pods diretamente, para ter auto-recuperação e updates.
  • Mantenha o cluster atualizado e faça backups do etcd regularmente.
  • Use RBAC para controlar permissões de acesso à API.
  • Monitore seu cluster com ferramentas como Prometheus e Grafana.

O Kubernetes é uma ferramenta poderosa, mas exige estudo contínuo. Esta introdução é o primeiro passo; nas próximas aulas você aprenderá a criar clusters, implantar aplicações e gerenciar o ciclo de vida completo.

Exercícios

  1. Explique com suas palavras o que é o Kubernetes e qual problema ele resolve.

    2. ✓ Resposta: O Kubernetes é uma plataforma de orquestração de contêineres que automatiza a implantação, o dimensionamento e a operação de aplicações em contêineres. Ele resolve problemas como escalabilidade, alta disponibilidade, balanceamento de carga e gerenciamento de ciclo de vida em ambientes com muitos contêineres.
  2. Descreva os principais componentes do control plane e suas funções.

    3. ✓ Resposta: Os componentes do control plane são: kube-apiserver (API de entrada), etcd (armazenamento de estado), kube-scheduler (agendamento de pods), kube-controller-manager (controladores que mantêm o estado desejado) e cloud-controller-manager (integração com nuvem).
  3. Cite dois cenários em que NÃO é recomendado usar Kubernetes e justifique.

    4. ✓ Resposta: 1) Para aplicações simples que rodam em um único servidor, pois a complexidade do Kubernetes não compensa. 2) Para projetos pequenos com equipe sem experiência em infraestrutura distribuída, pois a curva de aprendizado é alta e o risco de erros operacionais aumenta.
  4. Qual a diferença entre um Pod e um Deployment?

    5. ✓ Resposta: O Pod é a menor unidade de execução, contendo um ou mais contêineres. O Deployment é um recurso que gerencia pods, garantindo o número de réplicas desejado e permitindo atualizações e rollbacks. Um Deployment cria e gerencia ReplicaSets, que por sua vez criam pods.
  5. Qual o papel de um Service no Kubernetes?

    6. ✓ Resposta: O Service é uma abstração que define um conjunto de pods e fornece um endereço IP e DNS estáveis para acessá-los. Ele permite que outros componentes descubram e se comuniquem com os pods, mesmo que eles sejam recriados com novos IPs.

Referências