Kubeadm Multi Master

Se você está planejando implantar um cluster Kubernetes utilizando o kubeadm e a configuração de multi-master, juntamente com um HAProxy servindo como balanceador de carga, você está no caminho certo para garantir alta disponibilidade e escalabilidade para a sua infraestrutura.

O processo de instalação e configuração de um cluster Kubernetes dessa natureza requer atenção aos detalhes, mas os benefícios são inegáveis. Com a configuração multi-master, você terá uma maior tolerância a falhas, permitindo que o cluster mantenha a operação normal mesmo se um dos mestres apresentar algum problema.

Além disso, a inclusão do HAProxy como balanceador de carga garante a distribuição uniforme das requisições entre os nós mestres, otimizando o desempenho e a resiliência do cluster. Essa abordagem inteligente permite que o tráfego seja gerenciado de forma eficaz, evitando gargalos e garantindo uma experiência confiável para seus usuários.

Portanto, siga em frente com a instalação desse cluster Kubernetes robusto e confiável. Com a configuração multi-master e o HAProxy como balanceador de carga, você estará implementando as melhores práticas e garantindo uma base sólida para suas aplicações, permitindo que você desfrute dos benefícios da alta disponibilidade e escalabilidade em seu ambiente Kubernetes.

Instancias EC2

Para subir as instancias é necessário criar o par de chave rsa com ssh-keygen conforme demonstrando abaixo. O nome utilizado neste exemplo é ck-prod para a chave privada e ck-prod.pub para chave publica. Caso deseje alterar será necessário editar o arquivo das variáveis do Terraform em ec2/curso/main.tf. Procures por chave e altere o valor.

Repositório do projeto

Volte a raiz do repositório copiado do git no passo anterior, caso não tenha o repositório local faça o clone novametne e crie a branch do curso.

 git clone https://github.com/marconesns/modulo_k8s_I.git

 cd modulo_k8s_I/
 git checkout -b curso

Criando a chave

 cd terraform_k8s_multimaster
 ssh-keygen -f ec2/curso/ck-prod -t rsa -N ""

Criando as instancias

Antes de criar suas instâncias usando o Terraform, é essencial que você carregue os módulos necessários. Felizmente, esse processo é simples e direto. Tudo o que você precisa fazer é executar o comando init dentro do diretório ec2/curso. Essa etapa é fundamental para garantir que todas as dependências e recursos necessários sejam carregados corretamente.

Ao executar o comando init, o Terraform realizará a inicialização do ambiente, identificando e configurando todas as configurações e módulos necessários para a criação das suas instâncias. É uma etapa crucial para garantir que seu ambiente Terraform esteja pronto e funcionando adequadamente, além de garantir que todas as dependências sejam atendidas.

Ao seguir esse procedimento, você estará configurando seu ambiente com eficiência e preparando-o para a criação das instâncias desejadas. Certifique-se de executar o comando init no diretório correto, ec2/curso, para garantir que você esteja carregando e configurando os módulos relevantes para a sua aplicação.

Portanto, prepare-se para criar suas instâncias com confiança. Executar o comando init é o primeiro passo para garantir que você tenha tudo pronto e no lugar certo antes de dar continuidade à criação do seu ambiente no Terraform.

 terraform init

Apos este procedimento, você deverá executar um plan e identificar se existe alguma pendência.

 terraform plan

Pronto agora é possível criar as instancia executando um apply e respondendo yes para prosseguir. Ou caso esteja ciente de que vai aprovar, poderá adicionar a opção –auto-approve.

 terraform apply

Este procedimento criará varias instancias ec2 sendo haproxy, master e workers de acordo como valor definido no campo count do arquivo infra/main.tf. Ao final tem uma instrução output que mostrará os IPs públicos dados a cada instancia. Esses endereços serão usados para acesso remoto as instancias via ssh.

Para visualizar o output novamente, basta digitar o comando a seguir.

 terraform output

Configuração do Haproxy

Configuração do balanceamento de carga com HAProxy:

Uma etapa crucial para configurar um ambiente altamente disponível é instalar o HAProxy em um nó dedicado, que desempenhará o papel de balanceador de carga. Essa configuração permitirá que o HAProxy encaminhe o tráfego de entrada de forma eficiente para os nós do cluster, garantindo uma distribuição equitativa das solicitações.

Para começar, você precisará instalar o pacote do HAProxy e, em seguida, fazer os ajustes necessários no arquivo de configuração. Isso permitirá que você defina os parâmetros desejados, como as regras de roteamento, monitoramento de estado dos nós e equilíbrio de carga, para garantir um fluxo suave de tráfego entre os nós do cluster.

Ao concluir essas etapas, você estará configurando seu ambiente de forma inteligente e eficiente, garantindo que o HAProxy esteja pronto para lidar com o tráfego intenso e garantir alta disponibilidade para suas aplicações.

Portanto, certifique-se de seguir esses passos importantes ao instalar o HAProxy em um nó separado e configurá-lo corretamente como seu balanceador de carga. Sua infraestrutura se beneficiará significativamente com essa implementação, garantindo uma distribuição equilibrada da carga e alta disponibilidade para as cargas de trabalho do cluster.

Acessando como root

sudo -i

Install LoadBalancer

 apt -y install haproxy

cat >> /etc/haproxy/haproxy.cfg <<EOF
frontend kubernetes-frontend
  bind *:6443
  mode tcp
  option tcplog
  default_backend kubernetes-backend
backend kubernetes-backend
  option httpchk GET /healthz
  http-check expect status 200
  mode tcp
  option ssl-hello-chk
  balance roundrobin
    server k8smaster1 <IP_privado do Master1>:6443 check fall 3 rise 2
    server k8smaster2 <IP_privado do Master2>:6443 check fall 3 rise 2

listen stats
  bind :32600
  stats enable
  stats uri /
  stats hide-version
  stats auth admin:123456
EOF

vim /etc/haproxy/haproxy.cfg

Inicie o serviço do HAproxy e ative para o Inicio junto com o sistema operacional.

systemctl enable haproxy
systemctl start haproxy

Configuração dos Pré-requisitos

Configuração dos nós do cluster

Prepare os nós do cluster, garantindo que eles atendam aos requisitos mínimos de hardware e software. Os procedimentos devem ser executado em todas as instancias que terão função no cluster, ou seja as Masters e Works.

Acessando como root

sudo -i

Desativando a Swap

sed -i '/swap/d' /etc/fstab
swapoff -a

Habilitando módulos do kernel no boot

cat <<EOF | sudo tee /etc/modules-load.d/crio.conf
overlay
br_netfilter
EOF

Habilitando módulos do kernel em tempo de execução.

modprobe overlay
modprobe br_netfilter

Módulos de trafego agregado.

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

sysctl --system

Instalação dos pacotes do Kubernetes

Criação dos arquivos de repos de acordo com a versão.

OS=xUbuntu_22.04
CRIO_VERSION=1.27

echo "deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/ /"|sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list

echo "deb http://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$CRIO_VERSION/$OS/ /"|sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable:cri-o:$CRIO_VERSION.list

curl -L https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable:cri-o:$CRIO_VERSION/$OS/Release.key | sudo apt-key add -

curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/Release.key | sudo apt-key add -

Atualizando lista de pacotes disponíveis.

apt update

Instalação do Container Runtime

Instale o cri-o em todos os nós do cluster. Em seguida, instale as dependências do Kubernetes, como o kubelet e o kubeadm, também em todos os nós.

Instalação do cri-o e do Kubernetes:

apt install -y cri-o cri-o-runc

Habilitando o serviço para subir junto com sistema operacional.

systemctl enable crio.service
systemctl start crio.service

apt-get install -y apt-transport-https ca-certificates curl

Instalação do Kubeadm, kubelet e kubectl

curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-archive-keyring.gpg

echo "deb [signed-by=/etc/apt/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

 apt-get update

apt-get install -y kubelet kubeadm kubectl
apt-mark hold kubelet kubeadm kubectl

systemctl enable kubelet
systemctl start kubelet

Inicialização do master:

Escolha um dos nós para ser o master e execute o comando “kubeadm init” nele. Siga as instruções fornecidas pelo comando para configurar corretamente o master e obter o comando de junção necessário para adicionar os nodes workers.

kubeadm config images pull

kubeadm init --control-plane-endpoint="<IP publico do HAproxy>:6443" --upload-certs --apiserver-advertise-address=<ip privado do master>

Ao termino desse comando será gerado uma saída semelhante a essa apresentado abaixo. São os procedimento para configuração de acesso pelo kubeconfig, juntando demais nodes Master e juntando nodes Works ao cluster. Basta copiar a linha e colar nos seus nodes conforme função no cluster.

Instalando o complemento de rede dos Pods CNI

O Kubernetes requer uma solução especial de rede entre os nós master e os container chamada rede dos PODs.

Uma Interface de rede do contêiner é um complemento de rede dos pods baseado em CNI para que seus pods possam se comunicar uns com os outros. O Cluster DNS (CoreDNS) não será inicializado antes da instalação de uma rede.

E assim que a Rede dos POD for criada, estamos prontos para continuar fazendo com que os works se juntem ao nó master.

kubectl apply -f https://github.com/weaveworks/weave/releases/download/v2.8.1/weave-daemonset-k8s.yaml

Adicição do node Master 2

Acesso o outro node Master e cole a linha gerada na saída do comando kubeadm init do Master 1.

kubeadm join 34.218.246.132:6443 --token td73wn.... \
	--discovery-token-ca-cert-hash sha256:01b5b4c.... \
	--control-plane --certificate-key c26f62ff....

Adição dos nodes workers:

Acesse cada um dos nodes workers e execute o comando de junção fornecido pelo comando “kubeadm init” no master. Isso fará com que os nodes workers se juntem ao cluster.

kubeadm join 34.218.246.132:6443 --token td73wn.8.... \
	--discovery-token-ca-cert-hash sha256:01b5b4c42...

O token tem validade de 24 horas, caso seja necessário adicionar outro node no futuro, é um novo token deverá ser gerado.

Verificação e teste do cluster

Verifique se os nós do cluster estão ativos e prontos para receber cargas de trabalho. Execute comandos como “kubectl get nodes” para listar os nós e “kubectl get pods –all-namespaces” para verificar se os pods estão em execução corretamente.

Implantação de aplicativos

Agora que o cluster está configurado e funcionando corretamente, você pode implantar seus aplicativos e serviços no cluster Kubernetes.

Adicionando Node no futuro

kubeadm token create

kubeadm token create

Criando linha de junção de nodes Works ao cluster.

kubeadm token create --print-join-command

Criando a linha de junção de node Master.

echo $(kubeadm token create --print-join-command) --control-plane --certificate-key $(kubeadm init phase upload-certs --upload-certs | grep -vw -e certificate -e Namespace)

Outros

O Minikube, o Kind e o Docker Desktop são ferramentas que permitem executar um cluster Kubernetes localmente em um único nó. Eles são projetados para facilitar o desenvolvimento, testes e experimentação de aplicativos que são implantados em um ambiente Kubernetes. No Apêndice A, ao final deste guia, estão os passos para instalar esses ambientes.

Ansible

O Ansible é uma ferramenta de automação de TI que tem como finalidade principal simplificar e automatizar tarefas repetitivas de gerenciamento de infraestrutura, implantação de aplicativos e orquestração de processos.

Seguindo os passos de instalação de instancias ec2 visto no incio deste capitulo, o procedimento de criação do cluster utilizando o Ansible está descrito no Apêndice B, ao final deste guia.