HomePtNotíciaComo iniciar um cluster Kubernetes do zero com Kubeadm e Kubectl

Como iniciar um cluster Kubernetes do zero com Kubeadm e Kubectl

- Advertisement -
- Advertisement -
- Advertisement -
- Advertisement -

[ad_1]

O Kubernetes tem a reputação de ser complexo, mas as versões modernas são relativamente fáceis de configurar. A ferramenta oficial de gerenciamento de cluster Kubeadm fornece uma experiência automatizada para iniciar seu plano de controle e registrar nós do trabalhador.

Este artigo orientará você na configuração de um cluster Kubernetes simples usando as configurações padrão. Este é um guia “do zero” que deve funcionar em um host recém-provisionado. Um sistema baseado em Debian é assumido, mas você pode ajustar a maioria dos comandos para combinar com o gerenciador de pacotes do seu sistema operacional. Essas etapas foram testadas com Ubuntu 22.04 e Kubernetes v1.25.

Instalando um ambiente de execução de contêiner

O Kubernetes precisa de um tempo de execução de contêiner compatível com CRI para iniciar e executar seus contêineres. A distribuição padrão do Kubernetes não inclui um tempo de execução, portanto, você deve instalar um antes de continuar. containerd é a opção mais popular. É o tempo de execução incluído nas versões modernas do Docker.

Você pode instalar o containerd usando o repositório Docker Apt. Primeiro adicione algumas dependências que serão usadas durante o procedimento de instalação:

$ sudo apt update
$ sudo apt install -y 
   ca-certificates 
   curl 
   gnupg 
   lsb-release

Em seguida, adicione a chave GPG do repositório à do Apt. keyrings diretório:

$ sudo mkdir -p /etc/apt/keyrings
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Agora você pode adicionar o repositório correto para o seu sistema executando este comando:

$ echo 
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu 
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Atualize sua lista de pacotes para incluir o conteúdo do repositório do Docker:

$ sudo apt update

Por fim, instale o containerd:

$ sudo apt install -y containerd.io

Verifique se o serviço containerd foi iniciado:

$ sudo service containerd status
 containerd.service - containerd container runtime
     Loaded: loaded (/lib/systemd/system/containerd.service; enabled; vendor preset: enabled)
     Active: active (running) since Tue 2022-09-13 16:50:12 BST; 6s ago

Alguns ajustes no arquivo de configuração do contêiner são necessários para que ele funcione corretamente com o Kubernetes. Primeiro substitua o conteúdo do arquivo pela configuração padrão do containerd:

$ sudo containerd config default > /etc/containerd/config.toml

Isso preenche todos os campos de configuração disponíveis e corrige alguns problemas, como desabilitar o suporte CRI em novas instalações.

próximo aberto /etc/containerd/config.toml e procure a seguinte linha:

SystemdCgroup = false

Altere o valor para true:

SystemdCgroup = true

Esta modificação é necessária para permitir suporte total para systemd Gerenciamento de grupo. Sem essa opção, os contêineres do sistema Kubernetes serão reiniciados periodicamente.

Reinicie o containerd para aplicar suas alterações:

$ sudo service containerd restart

Instalando Kubeadm, Kubectl e Kubelet

A segunda fase do processo é instalar as ferramentas do Kubernetes. Esses três utilitários fornecem os seguintes recursos:

  • kubeadm – Uma ferramenta de gestão que opera ao nível do cluster. Você o usará para criar seu cluster e adicionar nós adicionais.
  • kubectl – Kubectl é a CLI que você usa para interagir com seu cluster Kubernetes quando ele estiver em execução.
  • Kubelet – Este é o processo do Kubernetes em execução nos nós do trabalhador em seu cluster. É responsável por manter contato com a aeronave de controle e por iniciar novos contêineres quando solicitado.

Todos os três binários estão disponíveis em um repositório Apt hospedado no Google Cloud. Primeiro registre o chaveiro GPG do repositório:

$ sudo curl -fsSLo /etc/apt/keyrings/kubernetes.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg

Em seguida, adicione o repositório às suas fontes…

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

…e atualize sua lista de pacotes:

$ sudo apt update

Agora instale os pacotes:

$ sudo apt install -y kubeadm kubectl kubelet

É uma boa prática “segurar” esses pacotes para que o Apt não os atualize automaticamente quando você executar apt upgrade. As atualizações de cluster do Kubernetes devem ser iniciadas manualmente para evitar tempo de inatividade e evitar alterações indesejadas.

$ sudo apt-mark hold kubeadm kubectl kubelet

Desativar compartilhamento

O Kubernetes não funciona quando o compartilhamento está ativado. Você deve desabilitar o compartilhamento antes de criar seu cluster. Caso contrário, você descobrirá que o processo de provisionamento trava enquanto aguarda a inicialização do Kubelet.

Execute este comando para desabilitar o compartilhamento:

$ sudo swapoff -a

Em seguida, edite seu /etc/fstab arquivo e desabilite qualquer montagem de troca:

UUID=ec6efe91-5d34-4c80-b59c-cafe89cc6cb2 /               ext4    errors=remount-ro 0       1
/swapfile                                 none            swap    sw              0       0

Este arquivo mostra uma montagem com o swap escreva como a última linha. Ele deve ser removido ou comentado para que o compartilhamento permaneça desabilitado após a reinicialização do sistema.

Carregando o módulo br_netfilter

a br_netfilter O módulo do kernel é necessário para permitir que o iptables veja o tráfego em ponte. O Kubeadm não permitirá que você crie seu cluster quando este módulo estiver ausente.

Você pode habilitá-lo com o seguinte comando:

$ sudo modprobe br_netfilter

Faça-o persistir após uma reinicialização, incluindo-o na lista de módulos do sistema:

$ echo br_netfilter | sudo tee /etc/modules-load.d/kubernetes.conf

Crie seu cluster

Você está pronto para criar seu cluster Kubernetes. Corre kubeadm init na máquina que você deseja hospedar seu plano de controle:

$ sudo kubeadm init --pod-network-cidr=10.244.0.0/16

a --pod-network-cidr um sinalizador é incluído para que um mapeamento CIDR correto esteja disponível para que o plug-in de rede do pod seja instalado posteriormente. O valor padrão de 10.244.0.0/16 funciona na maioria dos casos, mas pode ser necessário alterar o intervalo se estiver usando um ambiente de rede altamente personalizado.

A criação do cluster pode levar vários minutos para ser concluída. As informações de progresso serão exibidas em seu terminal. Você deve ver esta mensagem em caso de sucesso:

Your Kubernetes control-plane has initialized successfully!

A saída também inclui informações sobre como começar a usar seu cluster.

Preparando seu arquivo Kubeconfig

Comece copiando o arquivo Kubeconfig gerado automaticamente em seu próprio arquivo. .kube/config diretório. Defina a propriedade do arquivo para você mesmo para que o Kubectl possa ler seu conteúdo corretamente.

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

Instalando um plug-in de rede de pod

O Kubernetes requer que um plug-in Pod Networking exista em seu cluster antes que os nós do trabalhador possam começar a funcionar normalmente. Você deve instalar manualmente um plug-in compatível para concluir sua instalação.

Calico e Flannel são as duas opções mais populares. Este guia usa Flannel devido à sua fácil experiência de instalação.

Use o Kubectl para adicionar o Flannel ao seu cluster:

$ kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml

Aguarde alguns instantes e, em seguida, execute kubectl get nodes em seu terminal. Você deve ver seus shows do Node como Ready e você pode começar a interagir com seu cluster.

$ kubectl get nodes
NAME       STATUS   ROLES           AGE     VERSION
ubuntu22   Ready    control-plane   7m19s   v1.25.0

se você correr kubectl get pods --all-namespacesvocê deve ver que os componentes do plano de controle, CoreDNS e Flannel estão todos funcionando:

$ kubectl get pods --all-namespaces
NAMESPACE      NAME                               READY   STATUS    RESTARTS        AGE
kube-flannel   kube-flannel-ds-xlrk6              1/1     Running   5 (16s ago)     11m
kube-system    coredns-565d847f94-bzzkf           1/1     Running   5 (2m9s ago)    14m
kube-system    coredns-565d847f94-njrdc           1/1     Running   4 (30s ago)     14m
kube-system    etcd-ubuntu22                      1/1     Running   6 (113s ago)    13m
kube-system    kube-apiserver-ubuntu22            1/1     Running   5 (30s ago)     16m
kube-system    kube-controller-manager-ubuntu22   1/1     Running   7 (3m59s ago)   13m
kube-system    kube-proxy-r9g9k                   1/1     Running   8 (21s ago)     14m
kube-system    kube-scheduler-ubuntu22            1/1     Running   7 (30s ago)     15m

Interagindo com seu cluster

Agora você pode começar a usar o Kubectl para interagir com seu cluster. Antes de continuar, remova o blob padrão no nó do plano de controle para permitir que os pods sejam agendados nele. O Kubernetes impede que os pods sejam executados no nó do plano de controle para evitar a contenção de recursos, mas essa restrição não é necessária para uso local.

$ kubectl taint node ubuntu22 node-role.kubernetes.io/control-plane:NoSchedule-
node/ubuntu22 untainted

Substituir ubuntu22 no comando acima com o nome atribuído ao seu próprio nó.

Agora tente iniciar um NGINX Pod simples:

$ kubectl run nginx --image nginx:latest
pod/nginx created

Exponha-o com um serviço NodePort:

$ kubectl expose pod/nginx --port 80 --type NodePort
service/nginx exposed

Encontre a porta do host que foi atribuída ao serviço:

$ kubectl get services
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        18m
nginx        NodePort    10.106.44.155   <none>        80:30647/TCP   27s

o porto é 30647. As solicitações HTTP para este endpoint agora devem emitir a página de destino NGINX padrão em resposta:

$ curl http://localhost:30647
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>

Seu cluster Kubernetes está funcionando!

Adicionar outro nó

Para configurar nós do trabalhador adicionais, primeiro repita todas as etapas nas seções até “Criando seu cluster” em cada máquina que deseja usar. Cada nó precisará de containerd, Kubeadm e Kubelet instalados. Você também deve verificar se seu nó tem conectividade de rede completa com a máquina que executa seu plano de controle.

Em seguida, execute o seguinte comando em seu novo nó do trabalhador:

kubeadm join 192.168.122.229:6443 
    --node-name node-b 
    --token <token> 
    --discovery-token-ca-cert-hash sha256:<token-ca-cert-hash>

Substitua o endereço IP pelo do nó do plano de controle. os valores de <token> S <token-ca-cert-hash> terá sido exibido quando você executou kubeadm init para criar seu plano de controle. Você pode recuperá-los seguindo as etapas abaixo.

Simbólico

Corre kubeadm token list no nó do plano de controle. O valor do token será exibido no TOKEN coluna.

$ kubeadm token list
TOKEN                     TTL         EXPIRES                USAGES                   DESCRIPTION                                                EXTRA GROUPS
lkoz6v.cw1e01ckz2yqvw4u   23h         2022-09-14T19:35:03Z   authentication,signing

Token de hash de certificado de CA

Execute este comando e use sua saída como o valor:

$ openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | 
   openssl dgst -sha256 -hex | sed 's/^.* //'

Junte-se ao cluster

a kubeadm join o comando deve produzir esta saída se for bem-sucedido:

$ kubeadm join 192.168.122.229:6443 
    --node-name node-b 
    --token <token> 
    --discovery-token-ca-cert-hash sha256:<token-ca-cert-hash>
[kubelet-start] Starting the kubelet[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

Verifique se o nó ingressou no cluster e está pronto para receber pods executando o kubectl get nodes domínio:

$ kubectl get nodes
NAME       STATUS   ROLES           AGE    VERSION
node-b     Ready    <none>          91s    v1.25.0
ubuntu22   Ready    control-plane   100m   v1.25.0

O nó aparece na lista e tem Ready como o seu estado. Isso significa que está operacional e o Kubernetes pode agendar Pods para ele.

Resumo

Configurar o Kubernetes pode parecer assustador, mas o Kubeadm automatiza a maioria das partes difíceis para você. Embora ainda haja várias etapas a serem seguidas, você não deverá ter problemas se certificar-se de que os pré-requisitos sejam atendidos antes de começar.

A maioria dos problemas ocorre porque não há tempo de execução do contêiner disponível, o br_netfilter o módulo do kernel está ausente, a troca está ativada ou a necessidade de fornecer um plug-in de rede Pod foi ignorada. A solução de problemas deve começar verificando esses erros comuns.

O Kubeadm traz para você a versão mais recente do Kubernetes diretamente do próprio projeto. Estão disponíveis distribuições alternativas que permitem iniciar um cluster de nó único com um único comando. Minikube, MicroK8s e K3s são três opções populares. Embora sejam normalmente mais fáceis de configurar e atualizar, todos têm pequenas diferenças em comparação com o Kubernetes upstream. O uso do Kubeadm aproxima você do funcionamento interno do Kubernetes e é aplicável a muitos ambientes diferentes.

[ad_2]

- Advertisement -
- Advertisement -
Stay Connected
16,985FansLike
2,458FollowersFollow
61,453SubscribersSubscribe
Must Read
- Advertisement -
Related News
- Advertisement -