Instalar um Cluster Kubernetes no Ubuntu usando o kubeadm

Neste guia, levá-lo-ei através dos passos para instalar e configurar um Cluster Kubernetes funcional de 3 nós no Ubuntu Linux. Kubernetes é um sistema open-source de orquestração de containers usado para automatizar a implementação, gestão e escalabilidade de aplicações conteinerizadas.

Neste artigo partilhamos em detalhe o processo de:

A preparar nós Kubernetes
Configurar repositórios
Instalar motor de execução de contentores
Instalação dos componentes do Kubernetes
Inicializando o seu cluster
instalando plugin de rede para Kubernetes
Adicionar novos nós de trabalho ao cluster

Vamos começar!

O Manual Definitivo do Ambiente de Trabalho Ubuntu

Domina o Ubuntu como um profissional - desde a personalização bela do ambiente de trabalho até à automação poderosa do terminal. Perfeito para desenvolvedores, administradores de sistemas e utilizadores avançados que querem controlo total do seu espaço de trabalho.

Passo 1: Diagrama de Sistemas

Esta configuração baseia-se no seguinte diagrama:

Vamos configurar os nomes dos hosts do sistema antes de podermos avançar para os próximos passos:

No Nó Mestre:

Defina o nome do host como abaixo:

sudo hostnamectl set-hostname k8s-master.example.com

No Nó de Trabalho 01:

Defina o nome do host utilizando a ferramenta de linha de comandos hostnamectl.

sudo hostnamectl set-hostname k8s-node-01.example.com

No Nó de Trabalho 02:

Defina também o nome do host para o nó de trabalho 02 do Kubernetes.

sudo hostnamectl set-hostname k8s-node-02.example.com

Uma vez que o nome de anfitrião correto tenha sido configurado em cada host, preencha em cada nó com os valores configurados.

$ sudo vim /etc/hosts
192.168.2.2 k8s-master.example.com    k8s-master
192.168.2.3 k8s-node-01.example.com  k8s-node-01
192.168.2.4 k8s-node-02.example.com  k8s-node-02

Termine a sessão e volte a iniciar para utilizar o novo nome de anfitrião configurado.

exit||logout

Passo 2: Criar utilizador administrador

Antes de fazer qualquer configuração específica do Kubernetes, vamos garantir que todas as dependências estão satisfeitas. Aqui, faremos uma atualização do sistema e criaremos o utilizador do Kubernetes.

Atualizar os pacotes do sistema para a versão mais recente em todos os nós:

sudo apt update && sudo apt upgrade -y
[ -e /var/run/reboot-required ] && sudo reboot

Adicionar utilizador para gerir o cluster Kubernetes:

sudo useradd -s /bin/bash -m k8s-admin
sudo passwd k8s-admin
sudo usermod -aG sudo k8s-admin
echo "k8s-admin ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/k8s-admin

Se preferir inserir a senha do sudo ao executar comandos sudo como utilizador k8s-admin, pode ignorar a última linha. Pode testar se não há pedido de senha para sudo:

$ su - k8s-admin
k8s-admin@k8s-master:~$ sudo su -
root@k8s-master:~# exit

Está tudo pronto, vamos prosseguir com a instalação do Docker Engine.

Passo 3: Instalar o Containerd

O Kubernetes requer um motor de execução de contêineres para executar contêineres. Neste artigo, utilizaremos o Containerd como motor de contêineres.

Certifique-se de que o Docker não está instalado. Se estiver, desinstale-o.

sudo apt remove docker docker-engine docker.io

Instale as dependências:

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

Importar chave GPG do repositório Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/docker-archive-keyring.gpg
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Instalar o motor Docker.

sudo apt update && sudo apt install containerd.io

O serviço é iniciado automaticamente.

$ systemctl status containerd.service
● containerd.service - containerd container runtime
   Loaded: loaded (/lib/systemd/system/containerd.service; enabled; vendor preset: enabled)
   Active: active (running) since  Sun 2024-07-14 21:22:30 UTC; 34min ago
     Docs: https://containerd.io
  Process: 4265 ExecStartPre=/sbin/modprobe overlay (code=exited, status=0/SUCCESS)
 Main PID: 4270 (containerd)
    Tasks: 8
   CGroup: /system.slice/containerd.service
           └─4270 /usr/bin/containerd

Também pode verificar a versão instalada:

containerd --version

Passo 4: Instalar Componentes do Kubernetes

Instalar ferramentas dependentes.

sudo apt install apt-transport-https ca-certificates curl gpg -y

Defina a versão do Kubernetes que deseja instalar.

k8s_ver=1.30

Descarregue a chave pública de assinatura para os repositórios de pacotes do Kubernetes

curl -fsSL https://pkgs.k8s.io/core:/stable:/v${k8s_ver}/deb/Release.key | \
 sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/k8s.gpg

Adicionar o repositório APT oficial do Kubernetes.

echo "deb https://pkgs.k8s.io/core:/stable:/v${k8s_ver}/deb/ /" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Atualizar índice de pacotes apt:

sudo apt update

Instalar Componentes do Kubernetes

Instale os componentes principais do Kubernetes: kubectl, kubelet, kubernetes-cni e kubeadm:

sudo apt install kubectl kubelet kubeadm kubernetes-cni

Confirme que todos os binários do pacote estão presentes no sistema de ficheiros.

$ which kubelet
/usr/bin/kubelet

$ which kubeadm
/usr/bin/kubeadm

Se a memória de troca estiver ativada, desligue-a.

sudo swapoff -a
sudo sed -i.bak -r 's/(.+ swap .+)/#\1/' /etc/fstab

Carregar módulos necessários.

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

Para carregar em tempo de execução, execute:

sudo modprobe overlay
sudo modprobe br_netfilter

Também configure as definições de sysctl.

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

Carregar as configurações.

sudo sysctl --system

Configure o containerd e reinicie o serviço

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

Ativar o serviço kubelet

sudo systemctl enable kubelet

Passo 5: Inicializar o Plano de Controlo do k8s

Todos os comandos que serão executados nesta secção destinam-se a ser executados no nó master. Não execute nenhum dos comandos nos nós trabalhadores do Kubernetes. Os componentes Master do Kubernetes fornecem o plano de controlo do cluster – API Server, Scheduler, Controller Manager. Eles tomam decisões globais sobre o cluster, como agendar e detetar e responder a eventos do cluster.

Confirme que o containerd está a funcionar puxando imagens base do Kubernetes.

$ sudo kubeadm config images pull
[config/images] Pulled registry.k8s.io/kube-apiserver:v1.30.2
[config/images] Pulled registry.k8s.io/kube-controller-manager:v1.30.2
[config/images] Pulled registry.k8s.io/kube-scheduler:v1.30.2
[config/images] Pulled registry.k8s.io/kube-proxy:v1.30.2
[config/images] Pulled registry.k8s.io/coredns/coredns:v1.11.1
[config/images] Pulled registry.k8s.io/pause:3.9
[config/images] Pulled registry.k8s.io/etcd:3.5.12-0

Se tiver vários sockets CRI, por favor use --cri-socket para selecionar um:

# Containerd
sudo kubeadm config images pull --cri-socket unix:///run/containerd/containerd.sock

# For CRI-O
sudo kubeadm config images pull --cri-socket unix:///var/run/crio/crio.sock

Bootstrap (nodo de plano de controlo único) – sem endpoint partilhado

Para iniciar um cluster sem utilizar um endpoint DNS, execute:

sudo sysctl -p
sudo kubeadm init \
  --pod-network-cidr=172.24.0.0/16 \
  --cri-socket unix:///run/containerd/containerd.sock

Bootstrap com endpoint partilhado (nome DNS para a API do plano de controlo)

Isto é ideal para múltiplos nós do plano de controlo.

Defina o nome DNS do endpoint do cluster ou adicione um registo ao ficheiro /etc/hosts.

$ sudo vim /etc/hosts
172.29.20.5 k8s-cluster.computingforgeeks.com

Criar cluster:

sudo sysctl -p
sudo kubeadm init \
  --pod-network-cidr=172.24.0.0/16 \
  --upload-certs \
  --control-plane-endpoint=k8s-cluster.computingforgeeks.com

Onde :

k8s-cluster.computingforgeeks.com aponta para um IP de LB para os seus nós do plano de controlo k8s.

Se tudo correr bem, deverá receber uma mensagem de sucesso com as instruções sobre o que fazer a seguir:

---
Your Kubernetes master has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

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

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of machines by running the following on each node
as root:

  kubeadm join 192.168.2.2:6443 --token 9y4vc8.h7jdjle1xdovrd0z --discovery-token-ca-cert-hash sha256:cff9d1444a56b24b4a8839ff3330ab7177065c90753ef3e4e614566695db273c

Configurar o acesso para o utilizador `k8s-admin` no servidor Master

Mude para k8s-admin e copie o ficheiro de configuração do Kubernetes com as informações do cluster.

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

Valide a implementação verificando as informações do cluster.

$ kubectl cluster-info
Kubernetes control plane is running at https://192.168.2.2:6443
CoreDNS is running at https://192.168.2.2:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

Passo 6: Instalar o Plugin CNI

Neste guia, vamos usar o Calico. Pode escolher qualquer outro plugin de rede suportado.

Descarregue os ficheiros do operador e dos recursos personalizados. Consulte a página de lançamentos para a versão mais recente.

Obtenha a última versão:

VERSION=$(curl --silent "https://api.github.com/repos/projectcalico/calico/releases/latest" | grep '"tag_name"' | sed -E 's/.*"([^"]+)".*/\1/')

Transferir recursos de instalação.

curl -O https://raw.githubusercontent.com/projectcalico/calico/${VERSION}/manifests/tigera-operator.yaml
curl -O https://raw.githubusercontent.com/projectcalico/calico/${VERSION}/manifests/custom-resources.yaml

Primeiro, instale o operador no seu cluster.

k8s-admin@k8s-master:~$ kubectl create -f tigera-operator.yaml
namespace/tigera-operator created
customresourcedefinition.apiextensions.k8s.io/bgpconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgpfilters.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgppeers.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/blockaffinities.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/caliconodestatuses.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/clusterinformations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/felixconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/hostendpoints.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamblocks.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamconfigs.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamhandles.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ippools.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipreservations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/kubecontrollersconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/apiservers.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/imagesets.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/installations.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/tigerastatuses.operator.tigera.io created
serviceaccount/tigera-operator created
clusterrole.rbac.authorization.k8s.io/tigera-operator created
clusterrolebinding.rbac.authorization.k8s.io/tigera-operator created
deployment.apps/tigera-operator created

Vamos também atualizar a pool de IP do Calico.

sed -ie 's/192.168.0.0/172.24.0.0/g' custom-resources.yaml

Em seguida, aplique as configurações do manifesto.

k8s-admin@k8s-master:~$  kubectl create -f custom-resources.yaml
installation.operator.tigera.io/default created
apiserver.operator.tigera.io/default created

Aguarde que o Pod Calico esteja em execução.

k8s-admin@k8s-master:~$ kubectl get pods --all-namespaces
NAMESPACE          NAME                                             READY   STATUS    RESTARTS   AGE
calico-apiserver   calico-apiserver-5476c484c4-rmmts                1/1     Running   0          37s
calico-apiserver   calico-apiserver-5476c484c4-z9phf                1/1     Running   0          37s
calico-system      calico-kube-controllers-6945f87bd4-2xwx4         1/1     Running   0          80s
calico-system      calico-node-tkwtv                                1/1     Running   0          80s
calico-system      calico-typha-65f575c9fc-xx8m8                    1/1     Running   0          81s
calico-system      csi-node-driver-kngdn                            2/2     Running   0          80s
kube-system        coredns-5dd5756b68-77x77                         1/1     Running   0          11m
kube-system        coredns-5dd5756b68-plpd6                         1/1     Running   0          11m
kube-system        etcd-k8s-master.example.com                      1/1     Running   0          11m
kube-system        kube-apiserver-k8s-master.example.com            1/1     Running   0          11m
kube-system        kube-controller-manager-k8s-master.example.com   1/1     Running   0          11m
kube-system        kube-proxy-bxq4x                                 1/1     Running   0          11m
kube-system        kube-scheduler-k8s-master.example.com            1/1     Running   0          11m
tigera-operator    tigera-operator-94d7f7696-xls25                  1/1     Running   0          3m20s

O nó deverá estar agora pronto.

k8s-admin@k8s-master:~$ kubectl get nodes
NAME                     STATUS   ROLES           AGE   VERSION
k8s-master.example.com   Ready    control-plane   20m   v1.30.2

Passo 7: Configurar os Nós de Trabalho

Quando o cluster Kubernetes tiver sido iniciado e o nó mestre estiver online, inicie a configuração dos Nós de Trabalho. Um nó é uma máquina de trabalho no Kubernetes, podendo ser uma VM ou uma máquina física. Cada nó é gerido pelo mestre e possui os serviços necessários para executar pods – docker, kubelet, kube-proxy

1) Certifique-se de que o runtime Containerd está instalado (coberto)

Use os passos fornecidos neste artigo para instalar o containerd

2) Adicionar o repositório Kubernetes (coberto)

Certifique-se de que o repositório para pacotes do Kubernetes está adicionado ao sistema.

3) Instalar os componentes do Kubernetes (Passo 4)

Depois de adicionar o repositório Kubernetes, instale os componentes usando:

sudo apt install kubelet kubeadm kubectl kubernetes-cni

4) Junte o Nó ao Cluster:

Use o comando join fornecido após inicializar o cluster Kubernetes. Pode imprimir os comandos usando:

kubeadm token create --print-join-command

Quando terminar, verifique o estado dos nós no mestre:

k8s-admin@k8s-master:~$ kubectl get nodes
NAME          STATUS    ROLES     AGE       VERSION
k8s-master    Ready     master    35m       v1.30.2
k8s-node-01   Ready     <none>    2m        v1.30.2
k8s-node-02   Ready     <none>    1m        v1.30.2

Passo 8: Validar a Configuração do Kubernetes

Crie um namespace de teste:

$ kubectl create namespace test
namespace/test created

Implementar aplicação de teste

kubectl create deployment hello-node --image=registry.k8s.io/e2e-test-images/agnhost:2.39 -- /agnhost netexec --http-port=8080

Ver implementações existentes:

$ kubectl get deployments
NAME         READY   UP-TO-DATE   AVAILABLE   AGE
hello-node   1/1     1            1           1m

Ver pods em execução

$ kubectl get pods
NAME                          READY     STATUS    RESTARTS   AGE
hello-node-5f76cf6ccf-br9b5   1/1       Running   0          1m

Para limpar os recursos, execute:

kubectl delete deployment hello-node

Passo 9: Configurar a conclusão do kubectl

Ative a autocompletação de comandos do kubectl no shell. O kubectl inclui suporte para autocompletação, o que pode poupar muito tempo a digitar!. Para ativar a conclusão no shell na sua sessão atual, execute:

source <(kubectl completion bash)

Para adicionar a conclusão automática do kubectl ao seu perfil, de forma a que seja carregada automaticamente em shells futuros, execute:

echo "source <(kubectl completion bash)" >> ~/.bashrc

Se estiver a usar zsh, edite o ficheiro ~/.zshrc e adicione o seguinte código para ativar a autocompletação do kubectl:

if [ $commands[kubectl] ]; then
source <(kubectl completion zsh)
fi

Ou, ao usar o Oh-My-Zsh, edite o ficheiro ~/.zshrc e atualize a linha plugins= para incluir o plugin kubectl.

source <(kubectl completion zsh)

Também é relevante o comando Top para métricas de container

Materiais de formação para domínio de Kubernetes:

Melhores livros de estudo de Kubernetes

Conclusão

Implementámos com sucesso um cluster Kubernetes de 3 nós em servidores Ubuntu LTS. Os nossos próximos tutoriais irão abordar Kubernetes HA, Monitorização do Kubernetes, Como configurar armazenamento externo e outras coisas interessantes. Fiquem atentos!