domingo, 3 de setembro de 2023

Criação de um Cluster Kubernet com vagrant , virtualbox e kubeadm no Ubuntu 22.04

Criação de um cluster Kubernetes no Ubuntu 22.04

CRIAÇÃO DE UM CLUSTER KUBERNET NO UBUNTU 22.04 USANDO KUBEADM, VAGRANT E VIRTUALBOX

Última atualização: 03 de Setembro de 2023 por Paulo Evaristo F. Da Silva

Você está procurando um guia fácil sobre como instalar um cluster Kubernetes no Ubuntu 22.04 (Jammy Jellyfish)?

O guia passo a passo nesta página mostrará como instalar um cluster Kubernetes no Ubuntu 22.04 usando o comando Kubeadm, Vagrant e VirtualBox, passo a passo.

O Kubernetes tornou-se a plataforma de orquestração de contêiner de facto, capacitando desenvolvedores e administradores de sistemas a gerenciar e dimensionar aplicativos em contêiner sem esforço. Se você é um usuário do Ubuntu 22.04 ansioso para aproveitar o poder do Kubernetes, você veio ao lugar certo.

Um cluster Kubernetes consiste em nós de trabalho nos quais a carga de trabalho do aplicativo é implantada e um conjunto de nós mestres que são usados para gerenciar os nós de trabalho e os pods no cluster.

Pré-requisitos

  • Instalação mínima do Ubuntu 22.04
  • Mínimo de 2GB de RAM ou mais
  • Mínimo de 2 núcleos de CPU / ou 2 vCPU
  • Espaço em disco livre de 20 GB em /var ou mais
  • Usuário Sudo com direitos de administrador
  • Conectividade com a Internet em cada nó

Configuração do Laboratório

Nó Endereço IP Nome do host
Mestre 192.168.56.110 master.marmotanet.local
Node1 192.168.56.115 node1.marmotanet.local
Node2 192.168.56.120 node2.marmotanet.local

Instalação do Vagrant, plugins e o VirtualBox

Acesse o link: https://developer.hashicorp.com/vagrant/downloads?product_intent=vagrant

Baixe o executável de acordo com o seu Windows, siga as instruções de instalação.

Abra cmd (Prompt de Comando) e digite:

vagrant --version
vagrant plugin install vagrant-vbguest

Acesse o link: https://www.virtualbox.org/wiki/Downloads

Clique em "Windows hosts" e baixe o VirtualBox de acordo com a versão do seu Windows.

Mais abaixo, clique em "All supported platforms" no item: "VirtualBox 7.0.10 Oracle VM VirtualBox Extension Pack", e baixe a extensão pack, depois, dê dois cliques e instale-o no VirtualBox.

Criando o arquivo Vagrantfile

Crie uma pasta para os arquivos, por exemplo, "cluster".

Crie um arquivo com o nome Vagrantfile (sem extensão).


# Criando a VM master
Vagrant.configure("2") do |config|
  config.vm.define "master" do |master|
    master.vm.box = "ubuntu/jammy64"
    master.vm.network "private_network", type: "static", ip: "192.168.56.110"
    master.vm.network "forwarded_port", guest: 6443, host: 6443
    master.vm.synced_folder ".", "/vagrant", type: "rsync"
    master.vm.hostname = "master"
    master.vm.provider "virtualbox" do |vb|
      vb.memory = 2048
      vb.cpus = 2
    end
    master.vm.provision "shell", path: "master-provision.sh"
  end
  config.vm.define "node1" do |node1|
    node1.vm.box = "ubuntu/jammy64"
    node1.vm.network "private_network", type: "static", ip: "192.168.56.115"
    node1.vm.synced_folder ".", "/vagrant", type: "rsync"
    node1.vm.hostname = "node1"
    node1.vm.provider "virtualbox" do |vb|
      vb.memory = 2048
      vb.cpus = 2
    end
    node1.vm.provision "shell", path: "node1-provision.sh"
  end

  config.vm.define "node2" do |node2|
    node2.vm.box = "ubuntu/jammy64"
    node2.vm.network "private_network", type: "static", ip: "192.168.56.120"
    node2.vm.synced_folder ".", "/vagrant", type: "rsync"
    node2.vm.hostname = "node2"
    node2.vm.provider "virtualbox" do |vb|
      vb.memory = 2048
      vb.cpus = 2
    end
    node2.vm.provision "shell", path: "node2-provision.sh"
  end
end
# ...

Criando os scripts provision

Crie um arquivo chamado master-provision.sh e adicione o seguinte conteúdo:


#!/bin/bash

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

#Configurar os módulos persistentes
sudo tee /etc/modules-load.d/containerd.conf < /etc/containerd/config.toml

sudo  systemctl daemon-reload
sudo systemctl restart containerd
sudo systemctl enable containerd
# Instale as dependências do Kubernetes
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys B53DC80D13EDEF05

# Adicione a chave GPG do Kubernetes
curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

# Adicione o repositório do Kubernetes
sudo add-apt-repository "deb https://apt.kubernetes.io/ kubernetes-xenial main"

# Instale os pacotes do Kubernetes
sudo apt-get update -y
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

# Marque os pacotes instalados para evitar atualizações automáticas
sudo apt-mark hold kubelet kubeadm kubectl

# Configure as entradas no arquivo /etc/hosts
 echo "192.168.56.110 master.marmotanet.local master" | sudo tee -a /etc/hosts
 echo "192.168.56.115 node1.marmotanet.local node1" | sudo tee -a /etc/hosts
 echo "192.168.56.120 node2.marmotanet.local node2" | sudo tee -a /etc/hosts
 
 
# Inicialize o cluster Kubernetes no nó mestre
sudo kubeadm init  --control-plane-endpoint="192.168.56.110:6443"



# Instale um plugin de rede (por exemplo, Weave) para permitir a comunicação entre pods
kubectl apply -f https://github.com/weaveworks/weave/releases/download/v2.8.1/weave-daemonset-k8s.yaml

kubeadm token create --print-join-command > /vagrant/join.sh

Crie o arquivo node1-provision.sh com o seguinte conteúdo:


#!/bin/bash

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


#Configurar os módulos persistentes
sudo tee /etc/modules-load.d/containerd.conf < /etc/containerd/config.toml

sudo  systemctl daemon-reload
sudo systemctl restart containerd
sudo systemctl enable containerd
# Instale as dependências do Kubernetes
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys B53DC80D13EDEF05

# Adicione a chave GPG do Kubernetes
curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

# Adicione o repositório do Kubernetes
sudo add-apt-repository "deb https://apt.kubernetes.io/ kubernetes-xenial main"

# Instale os pacotes do Kubernetes
sudo apt-get update -y
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

# Marque os pacotes instalados para evitar atualizações automáticas
sudo apt-mark hold kubelet kubeadm kubectl

# Configure as entradas no arquivo /etc/hosts
 echo "192.168.56.115 node1.marmotanet.local node1" | sudo tee -a /etc/hosts
 echo "192.168.56.110 master.marmotanet.local master" | sudo tee -a /etc/hosts
 echo "192.168.56.120 node2.marmotanet.local node2" | sudo tee -a /etc/hosts

Crie o arquivo node2-provision.sh com o seguinte conteúdo:


#!/bin/bash

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

#Configurar os módulos persistentes
sudo tee /etc/modules-load.d/containerd.conf < /etc/containerd/config.toml

sudo  systemctl daemon-reload
sudo systemctl restart containerd
sudo systemctl enable containerd
# Instale as dependências do Kubernetes
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys B53DC80D13EDEF05

# Adicione a chave GPG do Kubernetes
curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

# Adicione o repositório do Kubernetes
sudo add-apt-repository "deb https://apt.kubernetes.io/ kubernetes-xenial main"

# Instale os pacotes do Kubernetes
sudo apt-get update -y
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

# Marque os pacotes instalados para evitar atualizações automáticas
sudo apt-mark hold kubelet kubeadm kubectl

# Configure as entradas no arquivo /etc/hosts
 echo "192.168.56.115 node1.marmotanet.local node1" | sudo tee -a /etc/hosts
 echo "192.168.56.110 master.marmotanet.local master" | sudo tee -a /etc/hosts
 echo "192.168.56.120 node2.marmotanet.local node2" | sudo tee -a /etc/hosts

Criando as máquinas

Após criar os arquivos, execute o comando no cmd (Prompt de Comando) dentro da pasta onde estão os arquivos:


vagrant up

Isso criará as 3 VMs, instalará os pacotes necessários e iniciará o cluster.

Configurações necessárias

Após o término das configurações veja o log do vagrant no cmd(dos) e procure por uma linha parecida com essa abaixo


kubeadm join master.marmotanet.local:6443 --token vt4ua6.wcma2y8pl4menxh2 \
   --discovery-token-ca-cert-hash sha256:0494aa7fc6ced8f8e7b20137ec0c5d2699dc5f8e616656932ff9173c94962a36

Copie e guarde

Acesse a máquina master com o comando:


vagrant ssh master

execute os seguintes comandos:


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

Isso vai dará permissões ao usuário vagrant de executar comandos no cluster com o kubectl

Digite no terminal do master:


Kubectl cluster-info #( ele  te dará informações sobre o cluster)

Adicionando os nodes.

Como comando kubeadm Join copiado faça o seguinte:

Acesse os nodes um de cada ver


vagrant ssh node1
vagrant ssh node2

e copie o comando kubeadm Join com o sudo na frente

Exemplo:


sudo kubeadm join master.marmotanet.local:6443 --token vt4ua6.wcma2y8pl4menxh2 \
   --discovery-token-ca-cert-hash sha256:0494aa7fc6ced8f8e7b20137ec0c5d2699dc5f8e616656932ff9173c94962a36

Instalando o plugin Calico Network Plugin

Volte para o servidor master, e execute o comando


kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.0/manifests/calico.yaml

Depois de instalar o plugin execute o comando:


  vagrant@master:~$ kubectl get nodes
NAME				    STATUS      ROLES		AGE	    VERSION
master.marmotanet.local	Ready	 control-plane	20m 	v1.28.1
node1.marmotanet.local	Ready	 none	        20m 	v1.28.1
node2.marmotanet.local	Ready	 none 	        20m 	v1.28.1

Se o resultado for esse , então está tudo ok!

Teste o seu cluster kubernet


$ kubectl create deployment nginx-app --image=nginx --replicas=2



$ kubectl get deployment nginx-app
NAME        READY   UP-TO-DATE   AVAILABLE   AGE
nginx-app   2/2     2            2           68s

Exponha seu pod

  
  $ kubectl expose deployment nginx-app --type=NodePort --port=80
service/nginx-app exposed

Rode o comando seguinte para ver o status dos serviços:

 
  kubectl get svc nginx-app


   
sysops@k8smaster:~$ kubectl describe svc nginx-app 
Name: 			 nginx-app
Port:            unused 80/TCP 
TargetPort:		 80/TCP
NodePort:        unused 31246/TCP

Teste o acesso ao nginx


curl http://master.marmotanet.local:31246
Postado por às

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)
 

bobox

Blogger news