Se você trabalha no mundo do desenvolvimento de software, certamente já ouviu falar de Kubernetes. Mas o que exatamente é, e por que se tornou o padrão de fato para gerenciar aplicações em contêineres? Este guia levará você dos conceitos básicos aos fundamentais, com exemplos práticos e diagramas para ajudá-lo a entender.
Antes do Kubernetes: Um Pouco de História
Para entender por que o Kubernetes é tão revolucionário, vamos dar um passo atrás.
- Implantação Tradicional: Inicialmente, as aplicações eram executadas em servidores físicos. Essa abordagem era cara, difícil de escalar e propensa a conflitos de recursos.
- Implantação Virtualizada: Então surgiram as Máquinas Virtuais (VMs). As VMs permitiam executar múltiplas aplicações isoladas no mesmo hardware, melhorando a utilização de recursos e a segurança. No entanto, cada VM executa um sistema operacional inteiro, consumindo muitos recursos.
- Implantação em Contêineres: Os contêineres (como Docker) são a próxima evolução. Eles compartilham o mesmo sistema operacional do host, mas executam processos isolados. São leves, rápidos para iniciar e portáteis.
Os contêineres resolveram o problema de portabilidade, mas criaram outro: como gerenciar centenas (ou milhares) de contêineres em um ambiente de produção? Como garantir que estejam sempre em execução, possam se comunicar entre si e escalar com base na carga?
É aqui que o Kubernetes entra.
O que é Kubernetes?
Kubernetes (frequentemente abreviado como K8s) é uma plataforma open-source para orquestração de contêineres. Em termos simples, ele automatiza a implantação, o escalonamento e o gerenciamento de aplicações em contêineres. Criado pelo Google e agora mantido pela Cloud Native Computing Foundation (CNCF), o Kubernetes se tornou a ferramenta essencial para quem trabalha com microsserviços em escala.
A Arquitetura de um Cluster Kubernetes
Um ambiente Kubernetes é chamado de cluster. Um cluster é composto por um conjunto de máquinas, chamadas nodes, que executam nossas aplicações. A arquitetura é dividida em duas partes principais: o Control Plane e os Worker Nodes.
Control Plane
O Control Plane é o "cérebro" do cluster. Ele toma decisões globais (como agendamento) e detecta e responde a eventos do cluster. Seus principais componentes são:
- API Server (
kube-apiserver): É o gateway do cluster. Ele expõe a API do Kubernetes, que é usada por usuários (viakubectl), componentes do cluster e ferramentas externas para se comunicar. - etcd: Um banco de dados chave-valor consistente e altamente disponível. Ele armazena todos os dados do cluster, representando o estado desejado e atual do sistema.
- Scheduler (
kube-scheduler): Atribui Pods recém-criados a um Worker Node disponível, levando em conta requisitos de recursos, políticas e outras restrições. - Controller Manager (
kube-controller-manager): Executa controladores, que são loops de controle que observam o estado do cluster e trabalham para trazê-lo ao estado desejado. Por exemplo, oNode Controllergerencia os nodes, enquanto oReplication Controllergarante que o número correto de Pods esteja em execução.
Worker Node
Os Worker Nodes são as máquinas (físicas ou virtuais) onde as aplicações são realmente executadas. Cada node é gerenciado pelo Control Plane e contém os seguintes componentes:
- Kubelet: Um agente que roda em cada node. Ele garante que os contêineres descritos nos Pods estejam em execução e saudáveis.
- Kube-proxy: Um proxy de rede que gerencia as regras de rede nos nodes. Ele permite a comunicação de rede com os Pods a partir de sessões de rede internas ou externas ao cluster.
- Container Runtime: O software responsável por executar os contêineres. O Docker é o mais famoso, mas o Kubernetes também suporta outros runtimes como
containerdeCRI-O.
Objetos Fundamentais do Kubernetes
No Kubernetes, tudo é representado por objetos. Esses objetos são "registros de intenção": uma vez que você cria um objeto, o Kubernetes trabalha constantemente para garantir que ele exista e corresponda ao estado desejado.
Aqui estão os mais importantes:
Pod
O Pod é a menor unidade de execução no Kubernetes. Ele representa um ou mais contêineres que são executados juntos no mesmo node, compartilhando recursos como rede e armazenamento.
Geralmente, você executa apenas um contêiner por Pod, mas em cenários avançados (como "sidecar containers" para logging ou monitoramento), você pode ter mais.
Você quase nunca cria Pods diretamente. Você usa abstrações de nível superior como Deployments.
Deployment
Um Deployment é o objeto que você usará com mais frequência. Ele descreve o estado desejado para um grupo de Pods idênticos. O controlador de Deployment é responsável por:
- Criar e gerenciar um ReplicaSet (outro objeto que garante que um número específico de réplicas de um Pod estejam sempre em execução).
- Escalar o número de Pods para cima ou para baixo.
- Gerenciar atualizações da aplicação de maneira controlada (por exemplo, Rolling Update), sem tempo de inatividade.
Aqui está um exemplo de arquivo YAML para um Deployment que executa 3 réplicas de um servidor NGINX:
# nginx-deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: nginx-deployment spec: replicas: 3 selector: matchLabels: app: nginx template: metadata: labels: app: nginx spec: containers: - name: nginx image: nginx:1.14.2 ports: - containerPort: 80
Service
Os Pods no Kubernetes são efêmeros: podem ser criados e destruídos a qualquer momento. Cada Pod tem seu próprio endereço IP, mas esse IP não é estável. Então, como expor nossa aplicação de forma confiável?
Com um Service. Um Service é uma abstração que define um conjunto lógico de Pods e uma política para acessá-los. Ele fornece um ponto de acesso estável (um endereço IP virtual e um nome DNS) para um grupo de Pods.
O Service usa um selector baseado em labels para encontrar os Pods para os quais deve encaminhar o tráfego.
Veja como criar um Service para nosso Deployment NGINX:
# nginx-service.yaml apiVersion: v1 kind: Service metadata: name: nginx-service spec: selector: app: nginx ports: - protocol: TCP port: 80 targetPort: 80 type: ClusterIP # Default - exposes the service only within the cluster
Existem diferentes tipos de Services:
ClusterIP: Expõe o service em um IP interno do cluster (padrão).NodePort: Expõe o service em uma porta estática em cada Worker Node.LoadBalancer: Cria um load balancer externo no provedor de nuvem (ex.: AWS, GCP) e atribui um IP público ao service.
Ingress
Um Service LoadBalancer é ótimo, mas criar um para cada service pode ser caro. Para expor múltiplos services HTTP/HTTPS ao mundo externo, você usa um Ingress.
Um Ingress atua como um "roteador inteligente" para tráfego externo. Ele permite definir regras de roteamento baseadas no host (ex.: api.mysite.com) ou caminho (ex.: mysite.com/api).
Aqui está um exemplo de Ingress:
# example-ingress.yaml apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: example-ingress spec: rules: - host: mysite.com http: paths: - path: /api pathType: Prefix backend: service: name: api-service port: number: 8080 - path: /ui pathType: Prefix backend: service: name: ui-service port: number: 3000
Outros Objetos Úteis
- Namespace: Permite criar "clusters virtuais" dentro de um cluster físico. Útil para isolar ambientes (ex.:
development,staging,production) ou equipes. - ConfigMap e Secret: Para gerenciar dados de configuração e segredos (como senhas ou chaves de API) desacoplados da imagem do contêiner.
- StatefulSet: Similar a um Deployment, mas específico para aplicações com estado (como bancos de dados) que requerem identidades de rede estáveis e armazenamento persistente.
- PersistentVolume (PV) e PersistentVolumeClaim (PVC): Para gerenciar armazenamento persistente no cluster.
Conclusão
O Kubernetes é uma ferramenta incrivelmente poderosa, mas sua curva de aprendizado pode ser íngreme. Este guia apenas arranhou a superfície, mas esperamos que tenha lhe dado uma compreensão sólida dos conceitos básicos.
O que fazer agora?
- Experimente localmente: Instale o Minikube ou o Kind para criar um cluster Kubernetes no seu computador.
- Use o
kubectl: Familiarize-se com o comandokubectl, sua principal ferramenta para interagir com o cluster. Tente criar o Deployment e o Service NGINX deste artigo. - Explore os tutoriais oficiais: A documentação do Kubernetes é um recurso fantástico repleto de exemplos.
A orquestração de contêineres é uma habilidade fundamental no mundo cloud-native, e dominar o Kubernetes abrirá um mundo de possibilidades. Divirta-se!