Os Fundamentos do Kubernetes: Guia Completo para Orquestrar seus Contêineres

O Kubernetes (K8s) tornou-se a plataforma padrão para a orquestração de contêineres em grande escala. Este guia apresenta os conceitos fundamentais do Kubernetes e como utilizá-lo de forma eficaz para gerenciar suas aplicações em contêineres.

O que é o Kubernetes?

O Kubernetes é uma plataforma open-source criada pelo Google para automatizar a implantação, o escalonamento e o gerenciamento de aplicações em contêineres. Ele fornece uma estrutura para executar sistemas distribuídos de forma resiliente.

Por que usar o Kubernetes?

• Implantação automatizada: Implantação e atualizações sem tempo de inatividade
• Autorrecuperação (self-healing): Reinício automático de contêineres com falha
• Escalonamento horizontal: Adaptação automática da capacidade
• Balanceamento de carga: Distribuição do tráfego entre as instâncias
• Orquestração de armazenamento: Gerenciamento de armazenamento persistente
• Gerenciamento de configuração: Separação entre código e configuração
• Suporte multicloud: Funciona em todos os principais provedores de nuvem

Arquitetura do Kubernetes

A arquitetura do Kubernetes é composta por vários componentes principais:

Plano de Controle (Control Plane)

• API Server: Ponto de entrada para todos os comandos REST
• etcd: Banco de dados chave-valor para armazenar o estado do cluster
• Scheduler: Atribui os pods aos nós
• Controller Manager: Mantém o estado desejado do cluster
• Cloud Controller Manager: Interface com as APIs dos provedores de nuvem

Nós (Nodes)

• Kubelet: Agente executado em cada nó, garante que os contêineres estejam funcionando
• Kube-proxy: Mantém as regras de rede nos nós
• Container Runtime: Software responsável pela execução dos contêineres (Docker, containerd, etc.)

Instalação do Kubernetes

Minikube (para desenvolvimento local)

# Instalação no Linux
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# Iniciar um cluster Kubernetes local
minikube start

# Verificar o estado
minikube status

kubeadm (para clusters de produção)

# Instalação dos pré-requisitos
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl

# Adicionar a chave GPG e o repositório do Kubernetes
sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

# Instalar kubeadm, kubelet e kubectl
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

# Inicializar o cluster (no nó mestre)
sudo kubeadm init --pod-network-cidr=192.168.0.0/16

# Configurar o kubectl
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

kubectl (ferramenta de linha de comando)

# Instalação no Linux
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

# Verificar a instalação
kubectl version --client

Conceitos Fundamentais do Kubernetes

Pods

O pod é a unidade básica do Kubernetes, representando um ou mais contêineres que compartilham armazenamento e rede.

# pod.yaml - Exemplo de pod simples
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.19
    ports:
    - containerPort: 80

# Criar um pod
kubectl apply -f pod.yaml

# Listar os pods
kubectl get pods

# Descrever um pod
kubectl describe pod nginx-pod

# Excluir um pod
kubectl delete pod nginx-pod

Deployments

Os deployments permitem gerenciar o ciclo de vida dos pods e dos ReplicaSets, facilitando as atualizações e os rollbacks.

# deployment.yaml - Exemplo de deployment
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.19
        ports:
        - containerPort: 80

# Criar um deployment
kubectl apply -f deployment.yaml

# Listar os deployments
kubectl get deployments

# Atualizar a imagem de um deployment
kubectl set image deployment/nginx-deployment nginx=nginx:1.20

# Efetuar um rollback
kubectl rollout undo deployment/nginx-deployment

Services

Os services permitem expor as aplicações executadas em um conjunto de pods.

# service.yaml - Exemplo de service
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP  # Outros tipos: NodePort, LoadBalancer, ExternalName

# Criar um service
kubectl apply -f service.yaml

# Listar os services
kubectl get services

# Descrever um service
kubectl describe service nginx-service

Namespaces

Os namespaces fornecem um mecanismo para isolar grupos de recursos dentro de um cluster.

# namespace.yaml - Exemplo de namespace
apiVersion: v1
kind: Namespace
metadata:
  name: development

# Criar um namespace
kubectl apply -f namespace.yaml

# Listar os namespaces
kubectl get namespaces

# Criar um recurso em um namespace específico
kubectl apply -f pod.yaml -n development

ConfigMaps e Secrets

Permitem separar a configuração dos contêineres.

# configmap.yaml - Exemplo de ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database.host: "db.example.com"
  database.port: "5432"

# secret.yaml - Exemplo de Secret
apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  # Os valores devem ser codificados em base64
  database.password: cGFzc3dvcmQxMjM=  # "password123" codificado em base64

# Criar um ConfigMap
kubectl apply -f configmap.yaml

# Criar um Secret
kubectl apply -f secret.yaml

# Usar um ConfigMap em um pod
spec:
  containers:
  - name: app
    image: app:1.0
    envFrom:
    - configMapRef:
        name: app-config

Uso de Volumes

Os volumes permitem armazenar dados além da vida útil de um pod.

# pvc.yaml - Exemplo de PersistentVolumeClaim
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

# pod-with-volume.yaml - Pod que utiliza um volume
apiVersion: v1
kind: Pod
metadata:
  name: data-pod
spec:
  containers:
  - name: data-container
    image: nginx
    volumeMounts:
    - mountPath: "/data"
      name: data-volume
  volumes:
  - name: data-volume
    persistentVolumeClaim:
      claimName: data-pvc

Gerenciamento do Ingress

O Ingress expõe serviços HTTP e HTTPS para fora do cluster.

# ingress.yaml - Exemplo de Ingress
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /app
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 80

# Instalar um controlador Ingress (exemplo com NGINX)
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.0.0/deploy/static/provider/cloud/deploy.yaml

# Criar um Ingress
kubectl apply -f ingress.yaml

Depuração de Aplicações

Logs e shell interativo

# Exibir os logs de um pod
kubectl logs nginx-pod

# Executar um comando em um pod
kubectl exec -it nginx-pod -- /bin/bash

# Acompanhar os logs em tempo real
kubectl logs -f nginx-pod

Diagnóstico de problemas

# Verificar o estado de um pod
kubectl get pod nginx-pod -o wide

# Descrever um pod para ver os eventos
kubectl describe pod nginx-pod

# Verificar os nós
kubectl get nodes
kubectl describe node <node-name>

Gerenciamento de Recursos

Limites de recursos

# resource-limits.yaml - Exemplo de limites de recursos
apiVersion: v1
kind: Pod
metadata:
  name: resource-pod
spec:
  containers:
  - name: app
    image: app:1.0
    resources:
      requests:
        memory: "64Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"

Horizontal Pod Autoscaler (HPA)

# hpa.yaml - Exemplo de autoscaling
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: app-deployment
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

# Criar um HPA
kubectl apply -f hpa.yaml

# Listar os HPAs
kubectl get hpa

Segurança no Kubernetes

RBAC (Controle de Acesso Baseado em Funções)

# role.yaml - Exemplo de role
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]

# rolebinding.yaml - Exemplo de vinculação de role
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: jane
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Network Policies

# network-policy.yaml - Exemplo de política de rede
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: db-network-policy
spec:
  podSelector:
    matchLabels:
      role: db
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: app
    ports:
    - protocol: TCP
      port: 5432

Boas Práticas para o Kubernetes

1. Usar deployments em vez de pods individuais
2. Definir limites de recursos para todos os contêineres
3. Configurar probes de disponibilidade (liveness e readiness probes)
4. Implementar o escalonamento horizontal para cargas variáveis
5. Separar os ambientes com namespaces
6. Usar labels e annotations para organizar os recursos
7. Implementar políticas de rede para proteger as comunicações
8. Configurar o RBAC para limitar os acessos
9. Usar Secrets para dados sensíveis
10. Implementar uma estratégia de backup para o etcd

Ferramentas Complementares para o Kubernetes

Helm (gerenciador de pacotes)

# Instalação do Helm
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

# Adicionar um repositório
helm repo add bitnami https://charts.bitnami.com/bitnami

# Instalar uma aplicação
helm install my-release bitnami/wordpress

Kustomize (gerenciamento de configuração)

# kustomization.yaml - Exemplo de configuração do Kustomize
resources:
- deployment.yaml
- service.yaml

namespace: my-namespace

commonLabels:
  app: my-app
  environment: production

# Aplicar uma configuração do Kustomize
kubectl apply -k ./

Prometheus e Grafana (monitoramento)

# Instalação via Helm
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install prometheus prometheus-community/kube-prometheus-stack

Conclusão

O Kubernetes tornou-se a ferramenta padrão para a orquestração de contêineres graças à sua flexibilidade, robustez e ao seu rico ecossistema. Compreender seus conceitos fundamentais é essencial para gerenciar com eficiência aplicações modernas em grande escala.

Ao dominar o Kubernetes, você poderá:

• Implantar aplicações em escala
• Garantir alta disponibilidade
• Otimizar o uso de recursos
• Simplificar as operações
• Dispor de um modelo declarativo para o gerenciamento de infraestrutura

A curva de aprendizado do Kubernetes pode ser íngreme, mas o investimento vale a pena para qualquer equipe que trabalhe com arquiteturas baseadas em contêineres.