Declaração do problema
Precisa de implementar um cluster Kubernetes de nível de produção que consiga sobreviver a falhas de nós, suportar rolling updates sem downtime e escalar para responder às exigências de tráfego.
Pré-requisitos
- Mínimo de 3 nós de control plane (2GB de RAM cada)
- Mínimo de 3 nós worker (1GB+ de RAM cada)
- 1 nó de load balancer/endpoint
- CentOS 7/8 ou distribuição Linux compatível
- Conectividade de rede entre todos os nós
Arquitetura
┌─────────────────────┐
│ External Traffic │
└──────────┬──────────┘
│
┌──────────▼──────────┐
│ HAProxy + VIP │
│ (Load Balancer) │
└──────────┬──────────┘
│
┌───────────────────────┼───────────────────────┐
│ │ │
┌───────▼───────┐ ┌───────▼───────┐ ┌───────▼───────┐
│ Control Plane │ │ Control Plane │ │ Control Plane │
│ Node 1 │ │ Node 2 │ │ Node 3 │
│ + etcd │ │ + etcd │ │ + etcd │
└───────┬───────┘ └───────┬───────┘ └───────┬───────┘
│ │ │
└───────────────────────┼───────────────────────┘
│
┌───────────────────────┼───────────────────────┐
│ │ │
┌───────▼───────┐ ┌───────▼───────┐ ┌───────▼───────┐
│ Worker Node │ │ Worker Node │ │ Worker Node │
│ 1 │ │ 2 │ │ 3 │
└───────────────┘ └───────────────┘ └───────────────┘
Passo 1: Preparar todos os nós
Definir hostnames
Em cada nó, defina um hostname único:
sudo hostnamectl set-hostname control-plane-1 # ou um nome apropriado
Configurar /etc/hosts
Adicione todos os nós do cluster a /etc/hosts em cada máquina:
cat <<EOF >> /etc/hosts
# Cluster Kubernetes
10.0.0.10 endpoint
10.0.0.11 control-plane-1
10.0.0.12 control-plane-2
10.0.0.13 control-plane-3
10.0.0.21 worker-1
10.0.0.22 worker-2
10.0.0.23 worker-3
EOF
Desativar swap
O Kubernetes requer que o swap esteja desativado:
swapoff -a
sed -i '/swap/d' /etc/fstab
Configurar parâmetros do kernel
cat <<EOF > /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
sysctl --system
Desativar SELinux (ou configurar corretamente)
setenforce 0
sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
Passo 2: Instalar o container runtime
Instalar Docker
dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo
dnf install -y docker-ce docker-ce-cli containerd.io
# Configurar o Docker para Kubernetes
mkdir -p /etc/docker
cat <<EOF > /etc/docker/daemon.json
{
"exec-opts": ["native.cgroupdriver=systemd"],
"log-driver": "json-file",
"log-opts": {
"max-size": "100m"
},
"storage-driver": "overlay2"
}
EOF
systemctl daemon-reload
systemctl enable docker --now
Passo 3: Instalar componentes do Kubernetes
Adicionar o repositório do Kubernetes
cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.32/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.32/rpm/repodata/repomd.xml.key
EOF
Instalar kubeadm, kubelet, kubectl
dnf install -y kubelet kubeadm kubectl iproute-tc
systemctl enable kubelet
Passo 4: Configurar o load balancer (nó endpoint)
Instalar HAProxy
dnf install -y haproxy
Configurar HAProxy
cat <<EOF > /etc/haproxy/haproxy.cfg
global
log /dev/log local0
log /dev/log local1 notice
daemon
defaults
mode tcp
log global
timeout connect 5s
timeout client 1m
timeout server 1m
frontend kubernetes-apiserver
bind *:6443
mode tcp
option tcplog
default_backend kubernetes-apiserver
backend kubernetes-apiserver
mode tcp
option tcp-check
balance roundrobin
server control-plane-1 10.0.0.11:6443 check fall 3 rise 2
server control-plane-2 10.0.0.12:6443 check fall 3 rise 2
server control-plane-3 10.0.0.13:6443 check fall 3 rise 2
EOF
systemctl enable haproxy --now
Passo 5: Configurar a firewall
Em todos os nós
# Confiar nos nós do cluster
firewall-cmd --zone=trusted --add-source=10.0.0.10
firewall-cmd --zone=trusted --add-source=10.0.0.11
firewall-cmd --zone=trusted --add-source=10.0.0.12
firewall-cmd --zone=trusted --add-source=10.0.0.13
firewall-cmd --zone=trusted --add-source=10.0.0.21
firewall-cmd --zone=trusted --add-source=10.0.0.22
firewall-cmd --zone=trusted --add-source=10.0.0.23
# Rede de pods (Calico ou Flannel)
firewall-cmd --zone=trusted --add-source=10.244.0.0/16
firewall-cmd --zone=trusted --add-masquerade
# Guardar regras
firewall-cmd --runtime-to-permanent
systemctl restart firewalld
Passo 6: Inicializar o primeiro nó de control plane
kubeadm init \
--pod-network-cidr=10.244.0.0/16 \
--control-plane-endpoint "endpoint:6443" \
--upload-certs
Guarde o output!
O comando devolve dois comandos de join: 1. Para nós adicionais de control plane (com --control-plane) 2. Para nós worker
Configurar kubectl
mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config
Passo 7: Instalar CNI (Container Network Interface)
Opção A: Calico
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml
Opção B: Flannel
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
Passo 8: Adicionar nós adicionais de control plane
Em cada nó adicional de control plane:
kubeadm join endpoint:6443 \
--token <token> \
--discovery-token-ca-cert-hash sha256:<hash> \
--control-plane \
--certificate-key <certificate-key>
Depois, configure o kubectl:
mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config
Regenerar certificados se estiverem expirados
kubeadm init phase upload-certs --upload-certs
Passo 9: Adicionar nós worker
Em cada nó worker:
kubeadm join endpoint:6443 \
--token <token> \
--discovery-token-ca-cert-hash sha256:<hash>
Gerar um novo token de join se estiver expirado
kubeadm token create --print-join-command
Passo 10: Verificar a saúde do cluster
# Verificar se todos os nós estão Ready
kubectl get nodes
# Verificar se todos os pods do sistema estão Running
kubectl get pods -n kube-system
# Verificar o estado dos componentes
kubectl get componentstatuses
Output esperado:
NAME STATUS MESSAGE ERROR
scheduler Healthy ok
controller-manager Healthy ok
etcd-0 Healthy {"health":"true"}
Passo 11: Configurar o agendamento de pods (opcional)
Ativar o agendamento em nós de control plane
Por predefinição, os pods não são agendados em nós de control plane. Para o permitir:
kubectl taint nodes --all node-role.kubernetes.io/control-plane-
Etiquetar nós para distribuição de workloads
kubectl label nodes worker-1 node-type=compute
kubectl label nodes worker-2 node-type=compute
kubectl label nodes worker-3 node-type=storage
Tarefas de manutenção
Atualizar a versão do cluster
# Primeiro, nos nós de control plane
dnf upgrade -y kubeadm
kubeadm upgrade plan
kubeadm upgrade apply v1.32.x
# Depois, atualizar o kubelet e o kubectl
dnf upgrade -y kubelet kubectl
systemctl daemon-reload
systemctl restart kubelet
Renovação de certificados
# Verificar a expiração do certificado
kubeadm certs check-expiration
# Renovar certificados
kubeadm certs renew all
Backup 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
Resolução de problemas
Nó não Ready
# Verificar os logs do kubelet
journalctl -u kubelet -f
# Verificar as condições do nó
kubectl describe node <node-name>
Problemas de rede de pods
# Verificar os pods do CNI
kubectl get pods -n kube-system | grep -E 'calico|flannel'
# Verificar o CoreDNS
kubectl get pods -n kube-system | grep coredns
API Server inacessível
# Verificar o estado do HAProxy
systemctl status haproxy
# Verificar a saúde do backend
curl -k https://endpoint:6443/healthz
Checklist de alta disponibilidade
- [ ] 3+ nós de control plane com etcd
- [ ] Load balancer à frente dos API servers
- [ ] Rede de pods (CNI) instalada e saudável
- [ ] Todos os nós no estado Ready
- [ ] Estratégia de backup do etcd implementada
- [ ] Rotação de certificados planeada
- [ ] Monitorização e alertas configurados
- [ ] Auto-scaling de nós configurado (se em cloud)
- [ ] PodDisruptionBudgets definidos para workloads críticas
Artigos relacionados na wiki
