Visão Geral

• Distribuição: Ubuntu Server 22.04 LTS (pode ser Debian 12 também)
• Componentes principais: kubeadm, kubelet, kubectl, containerd
• Kuebrnetes v1.30
• Topologia mínima:
  • master1, master2, master3
  • worker1, worker2
• Load Balancer externo: via HAProxy + Keepalived com IP virtual
• Rede dos pods: Calico
• CIDR para pods: 192.168.0.0/16

2.1 – Preparação de Todos os Nós (master e worker)

Executar em todos os nós (masters e workers):

# Atualize o sistema
sudo apt update && sudo apt upgrade -y

# Desative o swap (obrigatório)
sudo swapoff -a
sudo sed -i '/\/swap.img/ s/^/#/' /etc/fstab

# Ative módulos de kernel
sudo modprobe overlay
sudo modprobe br_netfilter

# Carregue os módulos no boot
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

# Parâmetros de rede
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.ipv4.ip_forward                 = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF

sudo sysctl --system

2.2 – Instalação do container runtime (containerd)

sudo apt install -y containerd

# Cria o arquivo de configuração padrão
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml

# Altere para usar systemd como cgroup
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml

# Reinicie o serviço
sudo systemctl restart containerd
sudo systemctl enable containerd

2.3 – Instalação dos binários Kubernetes

# Pré-requisitos
sudo apt-get update
# apt-transport-https pode ser um pacote fictício; se for, você pode pular esse pacote
sudo apt-get install -y apt-transport-https ca-certificates curl gpg

# Se o diretório `/etc/apt/keyrings` não existir, ele deve ser criado antes do comando curl, leia a nota abaixo.
sudo mkdir -p -m 755 /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

# Isso sobrescreve qualquer configuração existente em /etc/apt/sources.list.d/kubernetes.list
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

# Atualize o índice de pacotes apt, instale o kubelet, o kubeadm e o kubectl, e fixe suas versões:
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

2.4 – Configuração do Load Balancer Externo (Alta Disponibilidade)

Você precisa de um IP virtual (VIP) para acessar o cluster:

• IP VIP: 192.168.100.100
• Usando HAProxy + Keepalived em 2 máquinas (ou no master1 e master2) conforme fizemoz nesta neste tópico Etapa 1 – Instalando HAProxy como Load Balancer
  

2.5 – Inicializar o Cluster no master1

No master1:

sudo kubeadm init \
  --control-plane-endpoint "192.168.100.100:6443" \
  --upload-certs \
  --pod-network-cidr=192.168.0.0/16

• 192.168.100.100 é o IP VIP do Load Balancer

Após a conclusão, salve os comandos gerados, como:

• kubeadm join para os nós workers
• –control-plane + –certificate-key para outros masters

2.6 – Configurar o kubectl no master1

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

2.7 – Instalar a CNI (rede do cluster)

Use a CNI Calico:

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.27.0/manifests/calico.yaml

2.8 – Adicionar os outros Masters

Nos nós master2 e master3, execute o comando kubeadm join com as flags:

kubeadm join 192.168.100.100:6443 \
  --token <TOKEN> \
  --discovery-token-ca-cert-hash sha256:<HASH> \
  --control-plane \
  --certificate-key <CERT_KEY>

2.9 – Adicionar os nós Worker

Nos nós worker1 e worker2:

kubeadm join 192.168.100.100:6443 \
  --token <TOKEN> \
  --discovery-token-ca-cert-hash sha256:<HASH>

2.10 – Verificar o cluster

No master1:

kubectl get nodes -o wide

Resultado esperado:

NAME       STATUS   ROLES           AGE     VERSION
master1    Ready    control-plane   10m     v1.28.x
master2    Ready    control-plane   9m      v1.28.x
master3    Ready    control-plane   8m      v1.28.x
worker1    Ready    <none>          5m      v1.28.x
worker2    Ready    <none>          5m      v1.28.x

2.11 – (Opcional) Instalar o Kubernetes Dashboard

kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.7.0/aio/deploy/recommended.yaml

Crie um ServiceAccount e role de acesso para autenticação.

Conclusão da Etapa 2

Seu cluster Kubernetes está:

• Com 3 masters (alta disponibilidade)
• Load Balancer (HAProxy) com IP virtual exposto
• Rede funcional com Calico
• Pronto para instalar serviços essenciais: Ingress, Cert-Manager, Monitoramento, GitOps

ansible-k8s-ha/
├── hosts
├── site.yml
└── roles/
    ├── common/                    # Instala pacotes base e ajustes do sistema
    ├── haproxy_keepalived/       # Configura LB com HAProxy + Keepalived
    └── kube_master/              # Instala Kubeadm, kubelet, inicia cluster etc.

[loadbalancers]
lb1 ansible_host=192.168.1.190 priority=101 state=MASTER
lb2 ansible_host=192.168.1.191 priority=100 state=BACKUP

- name: Configuração comum de todos os servidores
  hosts: all
  become: yes
  roles:
    - common

- name: Configurar Load Balancers (lb1/lb2)
  hosts: loadbalancers
  become: yes
  roles:
    - haproxy_keepalived

- name: Configurar Control Plane Kubernetes
  hosts: masters
  become: yes
  roles:
    - kube_master

# roles/common/tasks/main.yml
- name: Desativar swap
  command: swapoff -a
  become: true

- name: Remover entrada do swap do /etc/fstab
  replace:
    path: /etc/fstab
    regexp: '^.*swap.*$'
    replace: '# desativado pelo Ansible'

- name: Instalar pacotes base
  apt:
    name:
      - curl
      - gnupg
      - lsb-release
      - apt-transport-https
      - ca-certificates
    update_cache: yes

- name: Ativar módulos necessários
  shell: |
    modprobe overlay
    modprobe br_netfilter
  args:
    warn: false

# roles/kube_master/tasks/main.yml

- name: Adicionar repositório do Kubernetes
  shell: |
    curl -fsSL https://pkgs.k8s.io/core:/stable:/v{{ kube_version }}/deb/Release.key | gpg --dearmor -o /etc/apt/trusted.gpg.d/kubernetes-apt-keyring.gpg
    echo "deb https://pkgs.k8s.io/core:/stable:/v{{ kube_version }}/deb/ /" | tee /etc/apt/sources.list.d/kubernetes.list
  args:
    warn: false

- name: Instalar kubeadm, kubelet e kubectl
  apt:
    name:
      - kubelet
      - kubeadm
      - kubectl
    update_cache: yes
    state: present

- name: Marcar kubelet como hold
  apt:
    name: "{{ item }}"
    state: hold
  loop:
    - kubelet
    - kubeadm
    - kubectl

- name: Inicializar cluster no master1
  shell: |
    kubeadm init \
      --control-plane-endpoint "{{ vip }}:6443" \
      --upload-certs \
      --pod-network-cidr=192.168.0.0/16
  when: inventory_hostname == 'master1'
  register: init_output
  ignore_errors: true

- name: Salvar tokens e comandos de join
  copy:
    content: "{{ init_output.stdout }}"
    dest: /root/kubeadm-init.log
  when: inventory_hostname == 'master1'

- name: Criar kubeconfig para root
  shell: |
    mkdir -p $HOME/.kube
    cp /etc/kubernetes/admin.conf $HOME/.kube/config
    chown $(id -u):$(id -g) $HOME/.kube/config
  when: inventory_hostname == 'master1'

ansible-playbook -i hosts site.yml