Instalar Cluster Kubernetes no Ubuntu usando kubeadm

Neste guia, vou te guiar pelos passos para instalar e configurar um Cluster Kubernetes funcional de 3 nós no Ubuntu Linux. Kubernetes é um sistema de orquestração de contêineres de código aberto usado para automatizar o deployment, gerenciamento e escalonamento de aplicações conteinerizadas.

Neste artigo compartilhamos em detalhes o processo de:

Preparando nós do Kubernetes
Configurando repositórios
Instalando o motor de execução de contêiner
Instalando componentes do Kubernetes
Inicializando seu cluster
instalando plugin de rede para Kubernetes
Ingressando novos nós de trabalho no cluster

Vamos começar!

O Guia Definitivo do Desktop Ubuntu

Domine o Ubuntu como um profissional - desde a personalização bela da área de trabalho até a automação poderosa do terminal. Perfeito para desenvolvedores, administradores de sistemas e usuários avançados que querem controle total sobre seu ambiente de trabalho.

Passo 1: Diagrama de Sistemas

Esta configuração é baseada no seguinte diagrama:

Vamos configurar os nomes dos hosts do sistema antes de prosseguirmos 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 usando a ferramenta de linha de comando hostnamectl.

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

No Nó de Trabalho 02:

Também defina 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 do host 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

Faça logout e entre novamente para usar o novo nome de host configurado.

exit||logout

Passo 2: Criar usuário administrador

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

Atualize 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 usuário para gerenciar 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 você prefere digitar a senha do sudo ao executar comandos sudo como usuário k8s-admin, então você pode ignorar a última linha. Você pode testar se não há solicitação de senha para o sudo:

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

Tudo parece bom, vamos prosseguir com a instalação do Docker Engine.

Etapa 3: Instalar o Containerd

O Kubernetes requer um mecanismo de execução de contêineres para rodar contêineres. Neste artigo, usaremos o Containerd como motor de contêiner.

Certifique-se de que o Docker não esteja 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"

Instale o Docker Engine.

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

Você também pode verificar a versão instalada:

containerd --version

Etapa 4: Instalar Componentes do Kubernetes

Instale as ferramentas dependentes.

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

Defina a versão do Kubernetes que você deseja instalar.

k8s_ver=1.30

Baixe 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

Adicione o repositório oficial APT 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 master do Kubernetes: kubectl, kubelet, kubernetes-cni e kubeadm

sudo apt install kubectl kubelet kubeadm kubernetes-cni

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

$ which kubelet
/usr/bin/kubelet

$ which kubeadm
/usr/bin/kubeadm

Se a 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 configuraçõ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

Habilitar o serviço kubelet

sudo systemctl enable kubelet

Passo 5: Inicializar o Plano de Controle do k8s

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

Confirme se o containerd está funcionando 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 você 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 (nó único do plano de controle) – sem endpoint compartilhado

Para inicializar um cluster sem usar o 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 compartilhado (nome DNS para a API do plano de controle)

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

Defina o nome DNS do endpoint do cluster ou adicione um registro ao arquivo /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 balanceador de carga para os seus nós do plano de controle do k8s.

Se tudo correr bem, você deverá receber uma mensagem de sucesso com as instruções do 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

Configure o acesso para o usuário `k8s-admin` no servidor Master

Troque para k8s-admin e copie o arquivo 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 implantaçã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, usaremos o Calico. Você pode escolher qualquer outro plugin de rede compatível.

Baixe os arquivos do operador e dos recursos personalizados. Veja a página de lançamentos para a versão mais recente.

Baixe a versão mais recente:

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

Baixar 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 o 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 o Pod do Calico estar em estado de 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ó agora deve estar 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 for inicializado 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ó é gerenciado 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 repositório do Kubernetes (coberto)

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

3) Instale os componentes do Kubernetes (Passo 4)

Depois de adicionar o repositório do 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. Você pode imprimir os comandos usando:

kubeadm token create --print-join-command

Quando terminar, verifique o status 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

Implantar aplicação de teste

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

Visualizar implantaçõ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 à autocompletação, o que pode economizar muito digitar! Para ativar a conclusão do shell na sua sessão atual, execute:

source <(kubectl completion bash)

Para adicionar o autocompletar do kubectl ao seu perfil, de forma que ele seja carregado automaticamente em shells futuros, execute:

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

Se você estiver usando zsh, edite o arquivo ~/.zshrc e adicione o seguinte código para habilitar a conclusão automática do kubectl:

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

Ou, ao usar o Oh-My-Zsh, edite o arquivo ~/.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 treinamento para domínio de Kubernetes:

Melhores livros de estudo sobre Kubernetes

Conclusão

Implantamos com sucesso um cluster Kubernetes de 3 nós em servidores Ubuntu LTS. Nossos próximos guias abordarão Kubernetes HA, Monitoramento do Kubernetes, Como configurar armazenamento externo e outras coisas legais. Fiquem ligados!