Cluster Kubernetes com Terraform

 Instalando o Terraform

Para instalar o terraform clique neste link terraform.io.

O projeto está disponibilizado no github. Faça o clone do repositório e siga os proximos passos.

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

 cd modulo_k8s_I/
 git checkout -b curso

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.

Criando a chave

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

Criando as instancias

Para criar as instancias é necessário carregar os módulos do Terraform executando o comando com init conforme demonstrado abaixo. Este procedimento deverá ser executado dentro do diretório ec2/curso

 cd ec2/curso
 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á tres instancias ec2 sendo uma master e duas workers. Ao final tem uma instrução output que mostrará os IPs públicos dados a cada instancia. Esses endereços serão usados para alterar o inventário do Ansible.

Pàra visualizar o output novamente, basta digitar o comando a seguir.

 terraform output

Cluster Kubernetes com Kubeadm

Nesta aula, veremos a ferramenta kubeadm que pode ser usada para dar o pontapé inicial a um cluster Kubernetes.

A ferramenta kubeadm nos ajuda a montar um cluster de vários nós usando as melhores práticas da documetnação do Kubernetes. Como discutimos, o cluster Kubernetes consiste em vários componentes, incluindo o kube-apiserver, etcd, e os controladores, etc.

Instalar todos esses vários componentes individualmente em diferentes nós e modificar todos os arquivos de configuração necessários para garantir que todos os componentes apontem uns para os outros e que funcione é uma tarefa entediante.

A ferramenta kubeadm nos ajuda, cuidando de todas estas tarefas. Vamos percorrer os passos para montar um cluster Kubernetes usando a ferramenta Kubeadm a um nível elevado.

Primeiro, vamos precisar ter três ou mais maquinas. Estas podem ser, máquinas físicas ou virtuais. Uma vez que todos os nós estejam provisionados, teremos que designar um como o master e o resto como works.

Há, nesta instalação utilizaremos três instancias na AWS definindo uma como master e duas como work node. O sistema operacional será o Ubuntu 20.04 LTS.

Instalação de pacotes pré-requisitos.

sudo apt install -y \
   apt-transport-https \
   ca-certificates \
   curl  \
   software-properties-common

O próximo passo depois disso é a instalação de um contêiner runtime nos nós. Portanto, estaremos usando cri-o e, vamos instalar cri-o em todos os nós.

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 dos pacotes do Kubernetes

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

modprobe overlay

modprobe br_netfilter

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

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

Execute o comando abaixo apenas no node master

kubeadm config images pull

kubeadm init --pod-network-cidr=10.8.0.0/16

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

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

Juntando nós ao cluster

A linha de comando para juntar os works ao master foi apresentando no final da execução do comando kubeadm init…​ algo como:kubeadm join <control-plane-host>:<control-plane-port> –token <token> –discovery-token-ca-cert-hash sha256:<hash>

Por padrão, os tokens expiram após 24 horas. Se você estiver ingressando em um nó no cluster após a expiração do token atual, poderá criar um novo token executando o seguinte comando no nó do plano de controle:

kubeadm token create --print-join-command

Acompanhe o ingresso dos nodes ao cluster com o comando abaixo até que o status do nós estejam com Ready.

kubectl get nodes

Uma vez que eles tenham se unido ao nó master, podemos então passar a implantar nossa aplicação no ambiente Kubernetes.

Fim do procedimento de instalação do Cluster com Kubeadm.