Como instalar um cluster Kubernetes Multi-master on premises

Se você chegou nesta página provavelmente está familiarizado com o minikube, kind ou com o Kubernetes que vem com o Docker Desktop porém assim como eu, gostaria de ver como é cluster “real” do Kubernetes. Saber um pouco mais sobre toda aquela “magia” que acontece quando vamos na GKE (Google Kubernetes Engine) e pedimos para criar um novo cluster. Se você se identificou com isso bom, você está no lugar certo. O meu objetivo aqui hoje é desmistificar um pouco essa tecnologia para que você se torne ainda mais confiante no seu uso do dia e ainda ter um ambiente robusto para testar e aprender.

Nesse tutorial iremos fazer a instalação e configuração inicial de um cluster Kubernetes com três worker nodes, tendo a api do Kubernetes exposta por um balanceador com o HA Proxy e o Keepalived fazendo a comutação de um IP Flutuante entre os servidores master e slave.

Topologia do Cluster

Na documentação temos basicamente duas opções uma em que o ETCD é instalado junto com as máquinas do control plane e a outra seria a de ter-se mais três máquinas formando um cluster dedicado para o ETCD.

Peguei emprestado a figura oficial da documentação do Kubernetes para servir como referência de qual tipo de instalação faremos e de como cluster estará configurado no final.

Diagrama da arquitetura

Agora que sabemos que tipo de instalação iremos fazer vamos montar uma arquitetura. Esta parte é muito importante pois é aqui que descobrimos quais componentes e produtos vamos utilizar levando em consideração a compatibilidade entre eles.

Como plataforma de virtualização estou usando o VMware Workstation Pro 16, mas você pode utilizar um outro da sua preferência como por exemplo o Virtual Box da Oracle ou mesmo o Hyper-V da Microsoft se você estiver usando uma versão Pro do Windows.

Antes de você criar a primeira máquina virtual crie uma rede como NAT com o range 10.20.30.0/24. Será essa rede que você deverá associar as novas máquinas virtuais. Com relação as características das máquinas coloquei uma tabela para ajudar na criação.

Para a criação das máquinas virtuais em um ambiente corporativo obviamente utilizaríamos uma automação com Ansible por exemplo mas, como estamos montando esse cluster para efeitos de estudo, você pode fazer a instalação de uma delas e depois utilizar alguma opção de clonagem dor próprio software de virtualização. Ainda tem a opção de baixar para o seu virtualizador uma máquina virtual pronta para uso do site OSBoxes.org.

Para o sistema operacional vamos utilizar o Debian Buster 64 bits que pode se baixado diretamente do site.

Descritivo das máquinas virtuais
Arquitetura e componentes

Para o funcionamento do nosso cluster teremos as máquinas ha-proxy-001 e ha-proxy-002 configuradas com um balanceador de carga com o HA Proxy e o Keeplived fazendo o gerenciamento do IP Flutuante entre elas. Será essa estrutura que irá expor a API do Kubernetes para o Control Plane e para os Worker Nodes.

Nosso control plane será composto de 3 nós e haverão mais 3 worker nodes formando um total de 6 máquinas no nosso cluster e para rede CNI utilizaremos o Calico

Instalação do Cluster

Para realizar a instalação do cluster iremos precisar de 8 (oito) máquinas virtuais no total. Abaixo coloquei uma tabela com os nomes e as principais características para facilitar a nossa configuração.

HostnameIPCPUMemóriaFunção
ha-proxy-00110.20.30.401512MbHA Proxy
ha-proxy-001 10.20.30.411512MbHA Proxy
k8s-master-00110.20.30.4222048MbControl Plane
k8s-master-00210.20.30.4322048MbControl Plane
k8s-master-00310.20.30.4422048MbControl Plane
k8s-worker-00110.20.30.4724096MbWorker
k8s-worker-00210.20.30.4624096MbWorker
k8s-worker-00310.20.30.4824096MbWorker
Relação das VMs

Configuração do HAProxy e Keepalived

Configurando o HA Proxy

Para começarmos vamos a instalação do pacote HA Proxy nos dois servidores: ha-proxy-001 e ha-proxy-002. Para isso vamos realizar os comandos abaixo em ambas as máquinas.

sudo apt update
sudo apt install -y haproxy

Após a conclusão da instalação vamos fazer a configuração do HA Proxy. Para isso precisamos editar o arquivo /etc/haproxy/haproxy.cfg e adicionar as linhas destacadas abaixo no final do arquivo.

global
        log /dev/log    local0
        log /dev/log    local1 notice
        chroot /var/lib/haproxy
        stats socket /run/haproxy/admin.sock mode 660 level admin expose-fd listeners
        stats timeout 30s
        user haproxy
        group haproxy
        daemon

        ca-base /etc/ssl/certs
        crt-base /etc/ssl/private

defaults
        log     global
        mode    http
        option  httplog
        option  dontlognull
        timeout connect 5000
        timeout client  50000
        timeout server  50000
        errorfile 400 /etc/haproxy/errors/400.http
        errorfile 403 /etc/haproxy/errors/403.http
        errorfile 408 /etc/haproxy/errors/408.http
        errorfile 500 /etc/haproxy/errors/500.http
        errorfile 502 /etc/haproxy/errors/502.http
        errorfile 503 /etc/haproxy/errors/503.http
        errorfile 504 /etc/haproxy/errors/504.http

frontend kubernetes
        mode tcp
        bind 10.20.30.45:6443
        option tcplog
        default_backend k8s-control-plane

backend k8s-control-plane
        mode tcp
        balance roundrobin
        option tcp-check
        server k8s-master-001.lan.int 10.20.30.42:6443 check fall 3 rise 2
        server k8s-master-002.lan.int 10.20.30.43:6443 check fall 3 rise 2
        server k8s-master-003.lan.int 10.20.30.44:6443 check fall 3 rise 2

Reinicie o serviço para que ele carregue as novas configurações

sudo systemctl restart haproxy
Configurando o Keepalived

Agora vamos realizar a instalação do Keepalived também nos dois servidores: ha-proxy-001 e ha-proxy-002

sudo apt update
sudo apt install -y keepalived

Para que Keepalived possa funcionar corretamente é necessário que seja configurado no sistema operacional a habilidade de se realizar o bind de endereços IP não locais. Para isso vamos executar esses comandos:

sudo echo "net.ipv4.ip_nonlocal_bind=1" >> /etc/sysctl.conf

# Para confirmar que a atualização foi aplicada corretamente execute

sudo sysctl -p
net.ipv4.ip_nonlocal_bind = 1 # O comando deve retornar esse valor

Para implementarmos uma camada a mais de proteção na nossa configuração do Keepalived vamos adicionar um novo grupo e usuário que executarão os scripts.

sudo groupadd -r keepalived_script
sudo useradd -r -s /sbin/nologin -g keepalived_script -M keepalived_script

Agora podemos fazer a configuração do Keepalived, para isso edite o arquivo: /etc/keepalived/keepalived.conf

global_defs {
        # Don't run scripts configured to be run as root if any part of the path
        # is writable by a non-root user.
        enable_script_security
}

vrrp_script chk_haproxy {      
       script "/usr/bin/pgrep haproxy"  
       interval 2 # check every 2 seconds
       weight 2 # add 2 points of priority if OK
}

vrrp_instance VI_1 {
	interface eth0 # troque para corresponder ao nome da sua interface de rede.
	state MASTER # troque para BACKUP no servidor de Backup.
	virtual_router_id 51
	priority 101 # 101 master, 100 backup  troque de acordo com o servidor

	virtual_ipaddress {
		10.20.30.45
	}

	track_script {
		chk_haproxy
	}
}

Agora vamos reiniciar o serviço do Keepalived para que a configuração seja efetivada.

sudo systemctl restart keepalived

Agora que temos configurado nosso Load Balance para a API do Kubernetes, podemos seguir adiante na configuração.

Preparação das maquinas do Cluster

Os próximos passos devem ser realizados em todas as máquinas virtuais que farão parte do cluster Kubernetes: k8s-master-001, k8s-master-002, k8s-master-003, k8s-worker-001, k8s-worker-002 e k8s-worker-003.

DNS Manual

Neste tutorial não faremos o setup de um servidor de DNS para fazer a resolução de nomes interna do nosso laboratório. Porém, para facilitar a configuração vamos adicionar as linhas abaixo no arquivo /etc/hosts em nossas máquinas virtuais. Isso permitirá que os nomes das máquinas sejam resolvidos sem a necessidade de decoramos os endereços IP.

10.20.30.40     ha-proxy-001.lan.int    ha-proxy-001
10.20.30.41     ha-proxy-002.lan.int    ha-proxy-002
10.20.30.42     k8s-master-001.lan.int  k8s-master-001
10.20.30.43     k8s-master-002.lan.int  k8s-master-002
10.20.30.44     k8s-master-003.lan.int  k8s-master-003
10.20.30.45     kube.lan.int  kube
10.20.30.46     k8s-worker-001.lan.int  k8s-worker-001
10.20.30.47     k8s-worker-002.lan.int  k8s-worker-002
10.20.30.48     k8s-worker-003.lan.int  k8s-worker-003

Note que na linha 6 está definido o IP Flutuante que configuramos no KeepAlived.

Desabilitar SWAP

Para a configurarmos um cluster do Kubernetes a primeira coisa que faremos será desabilitar o SWAP das máquinas virtuais, para isso vamos fazer o seguinte:

sudo swapoff -a

O comando anterior desabilita o SWAP somente momentaneamente para desabilitá-lo definitivamente edite o arquivo /etc/fstab , localize a linha que monta a partição de SWAP e a comente com ‘#

sudo vi /etc/fstab
# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
# <file system> <mount point>   <type>  <options>       <dump>  <pass>
# / was on /dev/sda1 during installation
UUID=5c1913aa-19be-4e5e-8d9f-c3c0ea8656d0 /               ext4    errors=remount-ro 0       1
# swap was on /dev/sda5 during installation
# UUID=4aeba94a-be90-4fd9-8419-3f66d84789d1 none            swap    sw              0       0
/dev/sr0        /media/cdrom0   udf,iso9660 user,noauto     0       0
Configuração de Rede

Para que o cluster possa funcionar corretamente precisamos agora ajustar a configuração de rede para que a rede de pods tenha capacidade de operar em cenários de networking bridge. Como nesse tutorial não trataremos do funcionamento em si do Kubernetes não me alongarei neste assunto. Porém, caso se interesse em saber mais detalhes sobre esse ponto é só consultar a documentação do Kubernetes aqui.

Primeiro vamos verificar se o driver br_netfilter está carregado, para isso execute esse comando:

lsmod | grep br_netfilter
br_netfilter           24576  0

Caso ele não esteja carregado execute o comando abaixo e verifique novamente se ele foi carregado:

sudo modprobe br_netfilter

Agora rode os comandos abaixo:

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
br_netfilter
EOF

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sudo sysctl --system

Pronto agora que configuramos a rede podemos seguir adiante e configurar o Container Runtime.

Container Runtime

O Kubernetes hoje quando escrevo ester artigo suporta o Docker e o CRI-O como Container Runtime. Para o nosso cluster utilizaremos desta vez o Docker. Para instalarmos seguiremos o procedimento oficial do Docker de instalação:

Primeiro, caso exista alguma instalação do docker é necessário realizar a sua remoção:

sudo apt-get remove docker docker-engine docker.io containerd runc

Agora vamos atualizar o índice do gerenciado de pacotes

sudo apt-get update

Instalamos as dependências do Docker

	 sudo apt-get install \
		apt-transport-https \
		ca-certificates \
		curl \
		gnupg \
		lsb-release

Adicionamos a chave GPG oficial do Docker

curl -fsSL https://download.docker.com/linux/debian/gpg | \
sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Adicionamos o repositório estável do Docker

echo \
  "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
	https://download.docker.com/linux/debian \
	$(lsb_release -cs) stable" | \
	sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Atualizamos novamente o banco de dados do gerenciador de pacotes com as informações do novo pacote do docker que foi adicionado nos passos anteriores:

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

Para testarmos se a instalação foi realizada corretamente vamos executar o comando abaixo:

sudo docker run hello-world
Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Instalação do kubeadm, kubelet e kubectl

Agora vamos realizar a etapa final de instalação dos pré requisitos que é a instalação do kubeadm, kubelet e kubectl:

Instalamos os pacotes de dependências

sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl

Baixamos e configuramos a chave do Google Cloud Public

sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg \
https://packages.cloud.google.com/apt/doc/apt-key.gpg

Adicionamos o repositório do Kubernetes

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

Atualizamos o índice do gerenciador de pacote e depois faz a instalação dos pacotes.

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

Finaliza a instalação marcando os pacotes que acabamos de instalar para que não sejam atualizados.

sudo apt-mark hold kubelet kubeadm kubectl

Pronto finalizamos toda a configuração que era necessária para a criação do nosso Cluster. Agora vamos fazer a criação do Cluster.

Criando o Control Plane do Kubernetes

Para fazer a criação do Control Plane precisamos primeiramente acessar a máquina virtual k8s-master-001 e executar o seguinte comando:

sudo kubeadm init --control-plane-endpoint "kube:6443" --upload-certs

A execução deste comando pode demorar um pouco dependendo da velocidade da sua conexão com a Internet pois serão baixadas as imagens necessárias do Kubernetes. Caso o comando tenha terminado com sucesso será exibida uma mensagem parecida com essa:

Your Kubernetes control-plane 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

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

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 the control-plane node running the following command on each as root:

  kubeadm join kube:6443 --token qrc7x1.or1q9d9qsan7z0yw \
        --discovery-token-ca-cert-hash sha256:caf1817ce92f4048b4071bb365cfea02c3e79c9717bce01ef6cc796f0b2d7458 \
        --control-plane --certificate-key d643abac4b63b4c390070d3a582fe958b8187cfa2359d00746ada98a2981d8c9

Please note that the certificate-key gives access to cluster sensitive data, keep it secret!
As a safeguard, uploaded-certs will be deleted in two hours; If necessary, you can use
"kubeadm init phase upload-certs --upload-certs" to reload certs afterward.

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join kube:6443 --token qrc7x1.or1q9d9qsan7z0yw \
        --discovery-token-ca-cert-hash sha256:caf1817ce92f4048b4071bb365cfea02c3e79c9717bce01ef6cc796f0b2d7458

Por um momento gostaria destacar 4 pontos grifados acima:

  • [ 5 – 7 ] – Depois que o primeiro do Control Plane é criado precisamos configurar o kubectl para utilizarmos no nosso cluster.
  • [ 14 – 15 ] – Para que possamos adicionar mais Nós ao Control Plane ou mesmo Nós de Workers precisamos instalar um Plugin de Rede dentre uma das opções existentes.
  • [ 19 – 21 ] – Depois de configurado o plugin de rede podemos adicionar os novos Nós ao Control Plane.
  • [ 29 – 30 ] – Adicionarmos novos Nós Workers ao nosso cluster.
Configurando o Kubectl para o Control Plane

Basicamente somente precisamos copiar e colar a linhas no terminal do k8s-master-001

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config
Não faremos a configuração do kubectl nos outros nós do Control Plane neste tutorial, contudo vale a pena ressaltar que em ambientes de produção ela é recomendada.
Configurando o Calico com plugin de rede CNI

Como nosso plugin de rede utilizaremos o Calico. Para realizar a instalação deste plugin devemos acessar o k8s-master-001 e partir dela baixamos o arquivo do manifesto de instalação no formato YAML. Depois de baixado basta aplicar o manifesto com o kubectl . Lembre-se que você precisa ter realizado a configuração do kubectl no passo anterior.

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

Adicionando Worker Nodes ao Control Plane

Para realizar a configuração dos outras Nós ao Control Plane precisamos acessar as máquinas virtuais k8smaster-002 e k8s-master-003 e executar os comandos que foram listados quando criamos o primeiro Nó do Control Plane:

kubeadm join kube:6443 --token qrc7x1.or1q9d9qsan7z0yw \
        --discovery-token-ca-cert-hash sha256:caf1817ce92f4048b4071bb365cfea02c3e79c9717bce01ef6cc796f0b2d7458 \
        --control-plane --certificate-key d643abac4b63b4c390070d3a582fe958b8187cfa2359d00746ada98a2981d8c9

Para verificar se as novas Nós foram associadas corretamente ao Control Plane retorne ao k8s-master-001 e execute:

kubectl get nodes
NAME             STATUS   ROLES                  AGE     VERSION
k8s-master-001   Ready    control-plane,master   3m15s   v1.21.2
k8s-master-002   Ready    control-plane,master   3m14s   v1.21.2
k8s-master-003   Ready    control-plane,master   3m14s   v1.21.2

Depois que todos os Nós do Control Plane tenham sido adicionados vamos finalizar a configuração adicionando os Nós de Workers.

Adicionando Workers ao Cluster

Para adicionar os workers ao nosso cluster acesse as máquinas: k8s-worker-001, k8s-worker-002 e k8s-worker-003 e execute em cada uma delas o comando abaixo:

kubeadm join kube:6443 --token qrc7x1.or1q9d9qsan7z0yw \
        --discovery-token-ca-cert-hash sha256:caf1817ce92f4048b4071bb365cfea02c3e79c9717bce01ef6cc796f0b2d7458

Depois de executado o comando em todos os workers podemos acompanhar o andamento da configuração executando o comando a partir do k8s-master-001

kubectl get nodes
NAME             STATUS   ROLES                  AGE     VERSION
k8s-master-001   Ready    control-plane,master   3m15s   v1.21.2
k8s-master-002   Ready    control-plane,master   3m14s   v1.21.2
k8s-master-003   Ready    control-plane,master   3m14s   v1.21.2
k8s-worker-001   Ready    <none>                 5m36s   v1.21.2
k8s-worker-002   Ready    <none>                 5m36s   v1.21.2
k8s-worker-003   Ready    <none>                 5m36s   v1.21.2
Verificando se todos os Nós foram adicionados ao Cluster

Depois que todos os Nós foram adicionados tanto ao Control Plane quanto Worker Nodes é possível verificar se tudo ficou configurado corretamente:

$ kubectl get all -A
NAMESPACE      NAME                                           READY   STATUS      RESTARTS   AGE
kube-system    pod/calico-kube-controllers-78d6f96c7b-45gl9   0/1     Running     10         3d13h
kube-system    pod/calico-node-86xzp                          0/1     Running     4          3d13h
kube-system    pod/calico-node-kj82h                          0/1     Running     16         3d13h
kube-system    pod/calico-node-m6qtf                          0/1     Completed   6          3d13h
kube-system    pod/calico-node-mgsk9                          0/1     Completed   6          3d13h
kube-system    pod/calico-node-r48sz                          0/1     Running     4          3d13h
kube-system    pod/calico-node-sj8sq                          0/1     Running     4          3d13h
kube-system    pod/coredns-558bd4d5db-24x4x                   0/1     Completed   3          3d14h
kube-system    pod/coredns-558bd4d5db-rwlrs                   0/1     Completed   3          3d14h
kube-system    pod/etcd-k8s-master-001                        1/1     Running     4          3d14h
kube-system    pod/etcd-k8s-master-002                        1/1     Running     3          3d13h
kube-system    pod/etcd-k8s-master-003                        1/1     Running     3          3d13h
kube-system    pod/kube-apiserver-k8s-master-001              0/1     Running     6          3d14h
kube-system    pod/kube-apiserver-k8s-master-002              0/1     Running     5          3d13h
kube-system    pod/kube-apiserver-k8s-master-003              0/1     Running     7          3d13h
kube-system    pod/kube-controller-manager-k8s-master-001     1/1     Running     9          3d14h
kube-system    pod/kube-controller-manager-k8s-master-002     1/1     Running     4          3d13h
kube-system    pod/kube-controller-manager-k8s-master-003     1/1     Running     3          3d13h
kube-system    pod/kube-proxy-9x86m                           0/1     Running     2          3d13h
kube-system    pod/kube-proxy-clvdj                           1/1     Running     3          3d13h
kube-system    pod/kube-proxy-gg24t                           1/1     Running     3          3d13h
kube-system    pod/kube-proxy-mff89                           0/1     Running     2          3d13h
kube-system    pod/kube-proxy-nvr8z                           1/1     Running     3          3d13h
kube-system    pod/kube-proxy-rkkpm                           1/1     Running     4          3d14h
kube-system    pod/kube-scheduler-k8s-master-001              1/1     Running     7          3d14h
kube-system    pod/kube-scheduler-k8s-master-002              1/1     Running     4          3d13h
kube-system    pod/kube-scheduler-k8s-master-003              0/1     Running     2          3d13h

NAMESPACE   NAME                TYPE       CLUSTER-IP EXTERNAL-IP PORT(S)                  AGE
default     service/kubernetes  ClusterIP  10.96.0.1  <none>      443/TCP                  3d14h
kube-system service/kube-dns    ClusterIP  10.96.0.10 <none>      53/UDP,53/TCP,9153/TCP   3d14h

Teste Básico do Cluster Kubernetes

Para fazer um teste básico de funcionamento vamos subir um NGinx com 3 réplicas inicialmente. Depois iremos reduzir para apenas 1 e por fim aumentar para 5.

# Cria um pod do NGinx com 3 réplicas
kubectl create deployment nginx --image=nginx --replicas 3 
deployment.apps/nginx created

# Verifica se as réplicas foram criadas corretamente
kubectl get pods
NAME                     READY   STATUS    RESTARTS   AGE
nginx-6799fc88d8-9kzk6   1/1     Running   0          3m
nginx-6799fc88d8-hrwvk   1/1     Running   0          3m
nginx-6799fc88d8-stp5l   1/1     Running   0          3m

# Faz o scale down para 1 réplica
kubectl scale deployment nginx --replicas 1
deployment.apps/nginx scaled

# Verifica se as réplicas foram reduzidas para 1
kubectl get pods
NAME                     READY   STATUS        RESTARTS   AGE
nginx-6799fc88d8-9kzk6   1/1     Terminating   0          3m27s
nginx-6799fc88d8-hrwvk   1/1     Terminating   0          3m27s
nginx-6799fc88d8-stp5l   1/1     Terminating   0          3m27s
nginx-6799fc88d8-xjjcl   1/1     Running       0          3m27s

kubectl get pods
NAME                     READY   STATUS    RESTARTS   AGE
nginx-6799fc88d8-xjjcl   1/1     Running   0          4m21s

# Faz o scale up para 5 réplicas.
kubectl scale deployment nginx --replicas 5
deployment.apps/nginx scaled

# Verifica se as réplicas foram aumentadas para 5 
kubectl get pods
NAME                     READY   STATUS    RESTARTS   AGE
nginx-6799fc88d8-dxqbg   1/1     Running   0          17s
nginx-6799fc88d8-f5jgh   1/1     Running   0          17s
nginx-6799fc88d8-kvvvn   1/1     Running   0          17s
nginx-6799fc88d8-xjjcl   1/1     Running   0          5m14s
nginx-6799fc88d8-zmkrn   1/1     Running   0          17s

Conclusão

Como vocês puderam ver montar um cluster do Kubernetes on premises não é difícil. Podemos dizer que é trabalhoso se realizarmos as tarefas manualmente como fizemos aqui. Na vida real, você teria um script para realizar todas essas tarefas em alguma ferramenta de automação como o Ansible por exemplo.

Lembre-se que você não precisa montar um cluster com todas as máquinas da forma como fizemos. Você pode simplificar e deixar por exemplo dois servidores para o Control Plane e apenas um outro para ser o Worker Node.

Nos próximos artigos vamos melhorar o nosso cluster adicionando novas funcionalidades como volumes, ingress e etc. Fique atento para as novas publicações.

E ai gostou deste tutorial? Com certeza temos muitas oportunidades para melhorar, então por favor fique a vontade para comentar, deixar a sua opinião e compartilhar se você achar relevante.

Muito obrigado e até a próxima!


Este post foi publicado em inglês no site Medium caso queira vê-lo acesse o link

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s