Implementando um Cluster Kubernetes do Zero com Rocky Linux

A implementação de um cluster Kubernetes representa um marco fundamental para profissionais de infraestrutura que buscam modernizar seus ambientes de TI. Neste guia completo do PortalDoLinux.com.br, você aprenderá a construir um cluster Kubernetes do zero utilizando Rocky Linux, uma distribuição enterprise robusta e confiável que se tornou referência após as mudanças no ecossistema CentOS.

O Kubernetes consolidou-se como a plataforma de orquestração de contêineres mais utilizada no mercado, oferecendo automação, escalabilidade e gerenciamento eficiente de aplicações containerizadas. Quando combinado com Rocky Linux, uma distribuição enterprise mantida pela comunidade e 100% compatível com Red Hat Enterprise Linux, obtemos uma base sólida e confiável para ambientes de produção.

A escolha do Rocky Linux para implementar um cluster Kubernetes traz vantagens significativas: estabilidade comprovada, ciclo de vida estendido, suporte comunitário ativo e compatibilidade com ferramentas corporativas. Este tutorial aborda desde a preparação inicial dos servidores até a configuração completa de um cluster funcional, pronto para receber cargas de trabalho em produção.

Pré-requisitos e Planejamento da Infraestrutura

Antes de iniciar a implementação do cluster Kubernetes, é essencial realizar um planejamento adequado da infraestrutura. Para este guia, consideraremos uma arquitetura mínima composta por três nós: um control plane (master) e dois worker nodes.

Requisitos de Hardware

Cada nó do cluster deve atender aos seguintes requisitos mínimos:

Control Plane:

2 CPUs ou mais
4 GB de RAM (recomendado 8 GB)
50 GB de armazenamento
Conexão de rede estável

Worker Nodes:

2 CPUs ou mais
4 GB de RAM (recomendado 8 GB ou mais)
50 GB de armazenamento
Conexão de rede estável

Requisitos de Software

Rocky Linux 9.x instalado em todos os nós
Acesso root ou privilégios sudo
Conectividade de rede entre todos os nós
Portas específicas liberadas no firewall

Arquitetura de Rede

Para este tutorial, utilizaremos a seguinte configuração de rede:

Control Plane: 192.168.1.10 (k8s-master)
Worker Node 1: 192.168.1.11 (k8s-worker1)
Worker Node 2: 192.168.1.12 (k8s-worker2)

Preparação do Ambiente Rocky Linux

A preparação adequada do sistema operacional é crucial para garantir o funcionamento correto do cluster Kubernetes. Execute os seguintes passos em todos os nós do cluster.

Atualização do Sistema

Primeiro, atualize todos os pacotes do sistema para as versões mais recentes:

sudo dnf update -y
sudo dnf upgrade -y

Configuração de Hostname e Hosts

Configure o hostname de cada nó de forma apropriada:

# No Control Plane
sudo hostnamectl set-hostname k8s-master

# No Worker Node 1
sudo hostnamectl set-hostname k8s-worker1

# No Worker Node 2
sudo hostnamectl set-hostname k8s-worker2

Adicione as entradas no arquivo /etc/hosts em todos os nós:

sudo tee -a /etc/hosts <<EOF
192.168.1.10 k8s-master
192.168.1.11 k8s-worker1
192.168.1.12 k8s-worker2
EOF

Desabilitação do SELinux

Embora o SELinux seja uma camada importante de segurança, para simplificar a configuração inicial, vamos configurá-lo para modo permissivo:

sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

Desabilitação do Swap

O Kubernetes requer que o swap esteja desabilitado para funcionar corretamente:

sudo swapoff -a
sudo sed -i '/ swap / s/^|$.*$|$/#\1/g' /etc/fstab

Configuração de Módulos do Kernel

Carregue os módulos necessários para o funcionamento do Kubernetes:

sudo tee /etc/modules-load.d/kubernetes.conf <<EOF
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

Configuração de Parâmetros do Sistema

Configure os parâmetros sysctl necessários:

sudo tee /etc/sysctl.d/kubernetes.conf <<EOF
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

sudo sysctl --system

Configuração do Firewall

Configure as regras de firewall necessárias. No Control Plane:

sudo firewall-cmd --permanent --add-port=6443/tcp
sudo firewall-cmd --permanent --add-port=2379-2380/tcp
sudo firewall-cmd --permanent --add-port=10250/tcp
sudo firewall-cmd --permanent --add-port=10251/tcp
sudo firewall-cmd --permanent --add-port=10252/tcp
sudo firewall-cmd --permanent --add-port=10255/tcp
sudo firewall-cmd --reload

Nos Worker Nodes:

sudo firewall-cmd --permanent --add-port=10250/tcp
sudo firewall-cmd --permanent --add-port=30000-32767/tcp
sudo firewall-cmd --reload

Instalação e Configuração do Container Runtime

O Kubernetes necessita de um container runtime para executar os contêineres. Utilizaremos o containerd, que é amplamente adotado e recomendado pela comunidade.

Instalação do Containerd

Instale o containerd e suas dependências:

sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo dnf install -y containerd.io

Configuração do Containerd

Gere a configuração padrão do containerd:

sudo mkdir -p /etc/containerd
sudo containerd config default | sudo tee /etc/containerd/config.toml

Configure o containerd para usar systemd como cgroup driver:

sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml

Inicie e habilite o serviço containerd:

sudo systemctl enable --now containerd
sudo systemctl status containerd

Instalação dos Componentes Kubernetes

Com o ambiente preparado e o container runtime configurado, podemos proceder com a instalação dos componentes do Kubernetes.

Adição do Repositório Kubernetes

Adicione o repositório oficial do Kubernetes:

sudo tee /etc/yum.repos.d/kubernetes.repo <<EOF
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.29/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.29/rpm/repodata/repomd.xml.key
exclude=kubelet kubeadm kubectl cri-tools kubernetes-cni
EOF

Instalação dos Pacotes Kubernetes

Instale kubelet, kubeadm e kubectl em todos os nós:

sudo dnf install -y kubelet kubeadm kubectl --disableexcludes=kubernetes

Habilite o serviço kubelet:

sudo systemctl enable --now kubelet

Inicialização do Cluster Control Plane

Agora vamos inicializar o control plane do cluster Kubernetes. Execute os comandos a seguir apenas no nó master.

Inicialização com Kubeadm

Execute o comando de inicialização do cluster:

sudo kubeadm init \
  --pod-network-cidr=10.244.0.0/16 \
  --apiserver-advertise-address=192.168.1.10 \
  --control-plane-endpoint=k8s-master

Este comando pode levar alguns minutos para ser concluído. Ao final, você receberá instruções importantes, incluindo o comando para adicionar worker nodes ao cluster. Salve essas informações em local seguro.

Configuração do Kubectl

Configure o kubectl para o usuário atual:

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

Verifique o status do cluster:

kubectl cluster-info
kubectl get nodes

Neste momento, o nó master aparecerá com status “NotReady” porque ainda não configuramos a rede pod.

Configuração da Rede Pod com CNI

O Kubernetes requer um plugin CNI (Container Network Interface) para gerenciar a comunicação entre pods. Utilizaremos o Flannel, uma solução simples e eficiente.

Instalação do Flannel

Aplique o manifesto do Flannel:

kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

Aguarde alguns minutos e verifique se os pods do sistema estão executando:

kubectl get pods -n kube-system

Verifique novamente o status do nó:

kubectl get nodes

O nó master agora deve aparecer com status “Ready”.

Verificação da Rede

Confirme que a rede está funcionando corretamente:

kubectl get pods -n kube-system -o wide

Todos os pods do sistema devem estar no estado “Running”.

Adição de Nós Worker ao Cluster

Com o control plane configurado e funcionando, podemos adicionar os worker nodes ao cluster.

Obtenção do Token de Join

Se você não salvou o comando de join fornecido durante a inicialização, pode gerar um novo:

kubeadm token create --print-join-command

Adição dos Worker Nodes

Execute o comando de join em cada worker node. O comando terá um formato similar a este:

sudo kubeadm join k8s-master:6443 --token <token> \
  --discovery-token-ca-cert-hash sha256:<hash>

Verificação dos Nós

No control plane, verifique se os worker nodes foram adicionados com sucesso:

kubectl get nodes

Todos os nós devem aparecer com status “Ready” após alguns minutos.

Verificação e Testes do Cluster

Com o cluster completamente configurado, vamos realizar testes para garantir que tudo está funcionando corretamente.

Deploy de Aplicação de Teste

Crie um deployment de teste com nginx:

kubectl create deployment nginx-test --image=nginx:latest --replicas=3

Verifique o status do deployment:

kubectl get deployments
kubectl get pods -o wide

Exposição do Serviço

Exponha o deployment como um serviço:

kubectl expose deployment nginx-test --type=NodePort --port=80

Obtenha informações sobre o serviço:

kubectl get services

Teste de Conectividade

Teste o acesso ao serviço usando o NodePort:

curl http://192.168.1.11:<NodePort>

Verificação de Logs

Verifique os logs de um pod específico:

kubectl logs <nome-do-pod>

Teste de Escalabilidade

Teste a escalabilidade do deployment:

kubectl scale deployment nginx-test --replicas=5
kubectl get pods -o wide

Configurações Avançadas e Otimizações

Após a configuração básica do cluster Kubernetes, existem diversas otimizações e configurações avançadas que podem melhorar o desempenho e a segurança.

Configuração de Resource Limits

Defina limites de recursos para evitar que pods consumam todos os recursos do nó:

apiVersion: v1
kind: LimitRange
metadata:
  name: resource-limits
  namespace: default
spec:
  limits:
  - max:
      cpu: "2"
      memory: 2Gi
    min:
      cpu: 100m
      memory: 128Mi
    type: Container

Aplique a configuração:

kubectl apply -f resource-limits.yaml

Configuração de Network Policies

Implemente políticas de rede para controlar o tráfego entre pods:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Ingress

Configuração de Storage Classes

Configure classes de armazenamento para provisionamento dinâmico de volumes:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: local-storage
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer

Habilitação de Métricas

Instale o Metrics Server para monitoramento de recursos:

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

Edite o deployment do metrics-server para adicionar a flag –kubelet-insecure-tls:

kubectl edit deployment metrics-server -n kube-system

Verifique as métricas:

kubectl top nodes
kubectl top pods

Configuração de Autoscaling

Configure o Horizontal Pod Autoscaler:

kubectl autoscale deployment nginx-test --cpu-percent=50 --min=3 --max=10

Verifique o status do HPA:

kubectl get hpa

Troubleshooting e Resolução de Problemas

Durante a implementação e operação do cluster Kubernetes, você pode encontrar diversos desafios. Aqui estão soluções para problemas comuns.

Nós com Status NotReady

Se um nó aparecer como “NotReady”, verifique os logs do kubelet:

sudo journalctl -u kubelet -f

Verifique também o status do containerd:

sudo systemctl status containerd

Pods em Estado Pending

Se pods permanecerem em estado “Pending”, verifique os eventos:

kubectl describe pod <nome-do-pod>

Verifique se há recursos suficientes:

kubectl describe nodes

Problemas de Rede

Para diagnosticar problemas de rede, verifique os pods do CNI:

kubectl get pods -n kube-system | grep flannel
kubectl logs -n kube-system <flannel-pod>

Teste a conectividade entre pods:

kubectl run test-pod --image=busybox --rm -it -- /bin/sh
# Dentro do pod
ping <ip-de-outro-pod>

Problemas com DNS

Verifique o status do CoreDNS:

kubectl get pods -n kube-system | grep coredns
kubectl logs -n kube-system <coredns-pod>

Teste a resolução de nomes:

kubectl run test-dns --image=busybox --rm -it -- nslookup kubernetes.default

Comandos Úteis de Diagnóstico

Colete informações detalhadas sobre o cluster:

kubectl get all --all-namespaces
kubectl get events --all-namespaces --sort-by='.lastTimestamp'
kubectl cluster-info dump

Verifique certificados:

sudo kubeadm certs check-expiration

Considerações de Segurança

A segurança é fundamental em qualquer implementação de cluster Kubernetes. Aqui estão práticas recomendadas para fortalecer seu ambiente.

RBAC (Role-Based Access Control)

Configure permissões granulares usando RBAC:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: developer
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Pod Security Standards

Implemente políticas de segurança para pods:

apiVersion: v1
kind: Namespace
metadata:
  name: restricted-namespace
  labels:
    pod-security.kubernetes.io/enforce: restricted
    pod-security.kubernetes.io/audit: restricted
    pod-security.kubernetes.io/warn: restricted

Secrets Management

Utilize Secrets para armazenar informações sensíveis:

kubectl create secret generic db-credentials \
  --from-literal=username=admin \
  --from-literal=password=senhasegura

Auditoria

Habilite logs de auditoria editando o manifesto do API server:

sudo vi /etc/kubernetes/manifests/kube-apiserver.yaml

Adicione as flags de auditoria:

- --audit-log-path=/var/log/kubernetes/audit.log
- --audit-log-maxage=30
- --audit-log-maxbackup=10
- --audit-log-maxsize=100

Atualizações de Segurança

Mantenha o cluster atualizado regularmente:

sudo dnf update -y
sudo kubeadm upgrade plan
sudo kubeadm upgrade apply v1.29.x

Backup e Recuperação

Configure backups regulares do etcd:

ETCDCTL_API=3 etcdctl snapshot save /backup/etcd-snapshot.db \
  --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key

A implementação de um cluster Kubernetes do zero com Rocky Linux representa uma conquista significativa para qualquer profissional de infraestrutura. Ao longo deste guia completo do PortalDoLinux.com.br, você aprendeu desde a preparação inicial do ambiente até configurações avançadas de segurança e otimização.

O cluster Kubernetes que você construiu oferece uma base sólida para orquestração de contêineres em ambientes de produção. A combinação de Kubernetes com Rocky Linux proporciona estabilidade, confiabilidade e compatibilidade com padrões enterprise, tornando-se uma escolha excelente para organizações que buscam modernizar sua infraestrutura.

Lembre-se de que a jornada não termina aqui. O ecossistema Kubernetes está em constante evolução, com novas funcionalidades e melhorias sendo lançadas regularmente. Continue aprimorando seus conhecimentos, explorando ferramentas complementares como Helm, Prometheus, Grafana e outras soluções que podem enriquecer ainda mais seu ambiente.

Mantenha seu cluster atualizado, monitore constantemente seu desempenho, implemente práticas robustas de segurança e realize backups regulares. Com dedicação e prática contínua, você estará preparado para enfrentar os desafios mais complexos da orquestração de contêineres em ambientes corporativos.

O portaldoLinux.com.br continuará trazendo conteúdos técnicos aprofundados para apoiar sua evolução profissional no universo Linux e DevOps. Compartilhe suas experiências, dúvidas e sugestões nos comentários, contribuindo para o crescimento da comunidade técnica brasileira.

Rogerio Lima

Sou um profissional na área de Tecnologia da informação, especializado em monitoramento de ambientes, Sysadmin e na cultura DevOps. Possuo certificações de Segurança, AWS e Zabbix.