Como instalar o Kubernetes no Ubuntu 22.04 com Kubeadm

Neste guia, instalaremos o Kubernetes no Ubuntu 22.04 do zero usando o comando kubeadm.

1. Atualize seus hosts Ubuntu 22.04

Tenho (3) hosts Ubuntu 22.04 instalados como hosts Kubernetes no cluster rodando como máquinas virtuais em execução em minha infraestrutura de virtualização VMware. Eles são configurados com 4 CPUs e 8 GB de RAM e 40 GB de espaço em disco para o laboratório. Cada host possui uma conexão com a Internet para baixar pacotes. Além disso, criei um administrador do linux usuário e adicionado ao arquivo sudoers para acesso no ambiente de exemplo.

Para atualizar seus hosts Ubuntu 22.04 Kubernetes como parte dos requisitos:

sudo apt-get update && sudo apt-get upgrade -y

2. Configure seus nomes de host e resolução

Os nomes de host precisam ser configurados. Eu tenho o seguinte configurado em meus hosts Ubuntu, configuração do nome do host do arquivo host:

10.1.149.123 kube-1.cloud.local
10.1.149.124 kube-2.cloud.local
10.1.149.125 kube-3.cloud.local

Abaixo, adicionei as entradas aos arquivos hosts para cada nó do cluster Kubernetes. Você também pode usar a configuração DNS adequada para resolução de nomes.

3. Configurações do sistema para Kubernetes

Kubernetes requer parâmetros de kernel e configurações de sistema específicos no Ubuntu 22.04. Esta seção irá guiá-lo na otimização dessas configurações, como desabilitar a troca e ajustar os parâmetros do kernel usando sudosysctl.

Desativar arquivo de troca

Existem alguns comandos que podemos executar para garantir que o arquivo de troca esteja desabilitado.

sudo swapoff -a
sudo sed -i '/ swap / s/^(.*)$/#1/g' /etc/fstab

Parâmetros do kernel

Precisamos adicionar os dois conjuntos de parâmetros de kernel a seguir como pré-requisitos em nossos hosts de cluster Kubernetes. Por que? Se não fizermos o seguinte, veremos algo como o erro:

(ERROR FileContent--proc-sys-net-bridge-bridge-nf-call-iptables): /proc/sys/net/bridge/bridge-nf-call-iptables does not exist
    (ERROR FileContent--proc-sys-net-ipv4-ip_forward): /proc/sys/net/ipv4/ip_forward contents are not set to 1

Portanto, precisamos executar o primeiro conjunto de parâmetros do sistema abaixo.

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

##Run after the above command
sudo modprobe overlay
sudo modprobe br_netfilter

Executando os comandos acima

Em seguida, precisamos executar os seguintes comandos:

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

Agora precisamos executar o seguinte comando para aplicar as alterações ao sistema:

sudo sysctl --system

4. Instalando o tempo de execução do contêiner Containerd

Para versões modernas do Kubernetes, precisamos instalar o contêiner tempo de execução, e não Docker. Vamos instalar o containerd.

Primeiro, precisamos configurar o repositório apt do Docker:

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add the repository to Apt sources:
echo 
"deb (arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg) https://download.docker.com/linux/ubuntu 
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | 
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Em seguida, precisamos instalar o tempo de execução do containerd:

sudo apt install containerd.io -y

A seguir, precisamos configurar o sistema para que ele comece a usar o systemd como cgroup.

containerd config default | sudo tee /etc/containerd/config.toml >/dev/null 2>&1
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/g' /etc/containerd/config.toml

Finalmente, precisamos configurar o serviço para iniciar automaticamente e verificar se ele está funcionando:

sudo systemctl restart containerd
sudo systemctl enable containerd
sudo systemctl status containerd

5. Configurando repositórios Kubernetes

O Kubernetes requer que certos repositórios apt sejam adicionados ao seu sistema Ubuntu 22.04. Para configurar os repositórios Kubernetes necessários, executaremos os seguintes comandos:

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

##Add the key to your sources.list
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

##Update the apt package index
sudo apt-get update

6. Instalando componentes do Kubernetes

Depois que seu sistema Ubuntu 22.04 estiver preparado e o repositório apt configurado, é hora de instalar os pacotes Kubernetes, como kubectl, kubeadm e configuração de kubelet.

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

Ao final da execução do comando, podemos ver que os pacotes estão em espera.

7. Inicialize o cluster Kubernetes

A inicialização de um cluster Kubernetes no Ubuntu 22.04 envolve a execução do comando abaixo para inicializar o cluster Kubernetes em nosso nó do plano de controle. Isso instala coisas como kube-controller-manager, API, armazenamento etcd e outros serviços.sudo kubeadm init

Depois de alguns momentos, você verá que o cluster Kubernetes foi inicializado com sucesso. Conforme observado na saída, você também pode executar o comando para extrair imagens antecipadamente: sudo kubeadm config images

A saída do comando fornecerá a diretiva sobre como copiar o arquivo kubeconfig para o diretório $HOME. Esse comando é o seguinte:

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

Na saída, também vemos o comando join que podemos usar em nossos nós de trabalho.

Abaixo, estamos copiando o arquivo kubeconfig.

O STATUS está mostrando como Não está pronto. Ainda precisamos instalar a rede do contêiner.

Vários nós do plano de controle

Você também pode ter vários nós do plano de controle em seu cluster. Isso garante que você tenha vários nós principais para alta disponibilidade.

Dê uma olhada na documentação oficial aqui para clusters de alta disponibilidade: Criando clusters altamente disponíveis com kubeadm | Kubernetes. Tenha em mente que esta será uma implantação mais complexa, exigindo balanceamento de carga, etc.

8. Unindo nós de trabalho ao mestre

Depois de inicializar o plano de controle no nó mestre, você precisará unir os nós de trabalho ao cluster Kubernetes. Como temos vários nós de trabalho, usaremos o juntar-se ao kubeadm comando em cada nó de trabalho abaixo (observe que este comando de junção será diferente para todos, incluindo seu IP e hash de certificado CA do token de cluster. Unimos os nós de trabalho com o comando:

kubeadm join 10.1.149.123:6443 --token g9m3o9.529e95dem1j2f8qu 
--discovery-token-ca-cert-hash sha256:d2bf43cd2e4b4e0f929fa5a9ae654876f58efb6873bb460fc67f92bc642a1c34

Agora, depois de adicionarmos nós de trabalho, vamos verificar o status do cluster:

kubectl get nodes

9. Configurando a rede Pod

Para que os nós do Kubernetes se comuniquem, precisamos configurar uma sobreposição de rede de pod (rede de pod). Como mencionado acima, esta é a razão pela qual Não está pronto status para os nós. Calico é uma sobreposição de rede preferida para Kubernetes. Para instalar o Calico para comunicação de rede, podemos executar o seguinte comando em nosso nó mestre:

kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

Depois de instalarmos o Calico, podemos verificar o status do cluster novamente e vemos que os nós agora têm o Preparar status. Agora estamos prontos para nossos aplicativos em contêineres.

10. Verificando a instalação do Kubernetes

Depois de concluir a configuração, vejamos mais algumas coisas para verificar a instalação do Kubernetes no Ubuntu 22.04. Podemos verificar todos os recursos do cluster usando o comando:

kubectl get all -A

Abaixo, vemos cada namespace e os pods para:

• chita
• coredns
• servidor api
• ser um procurador

Crie uma implantação de teste

Por fim, vamos criar uma implantação de teste com o aplicativo Nginx.

kubectl create deploy nginx --image nginx

Podemos obter a implantação usando:

kubectl get deployment

Perguntas frequentes sobre a instalação do Kubernetes no Ubuntu 22.04

Empacotando

Vimos um tutorial para criar um cluster Kubernetes no Ubuntu 22.04 usando kubeadm. Executar o Kubernetes é a maneira de executar com eficiência cargas de trabalho em contêineres de produção. Você também pode ativar aplicativos facilmente usando o helm assim que tiver seu cluster Kubernetes em execução. Lembre-se de que você desejará dar atenção ao monitoramento de seu cluster e pods de aplicativos para garantir que eles estejam funcionando conforme o esperado.