Introdução
Kubernetes é uma ferramenta de código aberto crucial na orquestração de contêineres. O Kubernetes funciona orquestrando e gerenciando clusters em escala em vários ambientes de nuvem ou até mesmo em servidores locais. Um cluster é um conjunto de hosts destinados a executar aplicativos e serviços em contêineres. Um cluster precisa de no mínimo dois nós para funcionar – um master nó e um worker nó. Tendo em mente a escalabilidade, você tem a opção de expandir o cluster com quantos nós worker forem necessários.
Um nó no Kubernetes refere-se a um servidor. Um nó master é um servidor que gerencia o estado do cluster. Os nós worker são servidores que executam as cargas de trabalho – estas são normalmente aplicativos e serviços em contêineres.
Este guia irá orientá-lo pelas etapas de instalação e implantação de um cluster Kubernetes composto por dois nós no Ubuntu 20.04. Como mencionado, ter dois nós é a configuração mais básica ao trabalhar com o Kubernetes. Você também tem a opção de adicionar mais nós worker assim que entender os fundamentos. Mostraremos ainda como interligar os dois servidores para permitir que o nó master controle o nó worker.
Para testar nossa configuração, iremos implantar um Docker container executando o servidor web Nginx no cluster. Esta é uma aplicação típica do Kubernetes na vida real. Você aprenderá mais sobre alguns componentes definidores do Kubernetes, tais como kubectl e kubeadm à medida que avançamos. Também é aconselhável familiarizar-se primeiro com o nosso tutorial sobre conhecer os conceitos básicos do conjunto de ferramentas do Kubernetes para se familiarizar com os conceitos básicos da plataforma Kubernetes.
Agora, vamos começar!
Pré-requisitos
Você precisará provisionar dois servidores, executando no Ubuntu 20.04. Para obter o melhor desempenho, os requisitos mínimos de sistema para o Kubernetes são 2 GB de RAM e 2 CPUs. Você pode seguir as etapas de 1 a 4 deste tutorial passo a passo para ajudá-lo a configurar seu servidor Ubuntu na CloudSigma. Um servidor será o nó master, o outro será o nó worker. Nomeamos apropriadamente nossos dois servidores como kubernetes-master e kubernetes-worker. Isso torna mais fácil acompanhar o tutorial. No entanto, você está livre para escolher os hostnames que preferir.
-
Certifique-se de adicionar um usuário com privilégios sudo em ambos os nós que usaremos para executar os comandos conforme descrito no tutorial acima. Siga este tutorial sobre como configurar o arquivo sudoers do Linux para obter instruções.
-
Conectividade de rede – os servidores no cluster devem ser capazes de se comunicar. Quando você implanta suas VMs a partir da CloudSigma, elas estarão conectadas à internet com um IP público por padrão. Se você estiver trabalhando a partir de uma rede local, poderá ter que editar seu arquivo /etc/hosts em cada servidor e interligá-los adequadamente.
-
Você precisará instalar e habilitar o Docker em cada um dos nós. O Kubernetes depende de um tempo de execução de contêiner para executar contêineres em pods. Embora existam outras plataformas de contêiner para escolher, usaremos o Docker neste tutorial. O Docker fornecerá o ambiente de tempo de execução necessário para o Ubuntu. Você pode seguir as etapas 1, 2 e 3 do nosso tutorial sobre instalação e operação do Docker.
Etapa 1: Instalar o Kubernetes
Nesta etapa, instalaremos o Kubernetes. Assim como você fez com o Docker nos pré-requisitos, você deve executar os comandos em ambos os nós para instalar o Kubernetes. Use ssh para fazer login em ambos os nós e prosseguir. Você começará instalando o pacote apt-transport-https que permite trabalhar com http e https nos repositórios do Ubuntu. Além disso, instale o curl pois ele será necessário para as próximas etapas. Execute o seguinte comando:
|
1 |
sudo apt install apt-transport-https curl |
Em seguida, adicione a chave de assinatura do Kubernetes a ambos os nós executando o comando:
|
1 |
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add |
Em seguida, adicionamos o repositório do Kubernetes como uma fonte de pacotes em ambos os nós usando o seguinte comando:
|
1 2 |
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" >> ~/kubernetes.list sudo mv ~/kubernetes.list /etc/apt/sources.list.d |
Depois disso, atualize os nós:
|
1 |
sudo apt update |
- Instalar ferramentas do Kubernetes
Assim que a atualização for concluída, instalaremos o Kubernetes. Isso envolve a instalação das várias ferramentas que compõem o Kubernetes: kubeadm, kubelet, kubectl, e kubernetes-cni. Essas ferramentas são instaladas em ambos os nós. Definimos cada ferramenta abaixo:
-
kubelet – um agente que roda em cada nó e lida com a comunicação com o nó mestre para iniciar cargas de trabalho no runtime do contêiner. Insira o seguinte comando para instalar o kubelet:
|
1 |
sudo apt install kubelet |
-
kubeadm – parte do projeto Kubernetes e ajuda a inicializar um cluster Kubernetes. Insira o seguinte comando para instalar o kubeadm:
|
1 |
sudo apt install kubeadm |
-
kubectl – a ferramenta de linha de comando do Kubernetes que permite executar comandos dentro dos clusters Kubernetes. Execute o seguinte comando para instalar o kubectl:
|
1 |
sudo apt install kubectl |
-
kubernetes-cni – permite a rede dentro dos contêineres, garantindo que os contêineres possam se comunicar e trocar dados. Execute o seguinte comando para instalar:
|
1 |
sudo apt-get install -y kubernetes-cni |
Opcionalmente, você pode instalar todos os quatro em um único comando:
|
1 |
sudo apt-get install -y kubelet kubeadm kubectl kubernetes-cni |
Passo 2: Desativando a Memória Swap
O Kubernetes não funciona em um sistema que está usando swap memória. Portanto, ela deve ser desativada no nó mestre e em todos os nós de trabalho. Execute o seguinte comando para desativar a memória swap:
|
1 |
sudo swapoff -a |
Este comando desativa a memória swap até que o sistema seja reiniciado. Devemos garantir que ela permaneça desativada mesmo após as reinicializações. Isso deve ser feito no nó mestre e em todos os nós de trabalho. Podemos fazer isso editando o arquivo fstab file e comentando a linha /swapfile com um #. Abra o arquivo com o editor de texto nano inserindo o seguinte comando:
|
1 |
sudo nano /etc/fstab |
Dentro do arquivo, comente a linha swapfile como mostrado na captura de tela abaixo:
Se você não vir a linha swapfile, apenas ignore-a. Salve e feche o arquivo quando terminar de editar. Siga o mesmo processo para ambos os nós. Agora, as configurações de memória swap permanecerão desativadas, mesmo após a reinicialização do servidor.
Passo 3: Definindo Hostnames Únicos
Seus nós devem ter hostnames únicos para facilitar a identificação. Se você estiver implantando um cluster com muitos nós, poderá defini-los para identificar nomes para seus nós de trabalho, como node-1, node-2, etc. Como mencionamos anteriormente, nomeamos nossos nós como kubernetes-master e kubernetes-worker. Nós os definimos no momento da criação do servidor. No entanto, você pode ajustar ou definir os seus, caso ainda não o tenha feito a partir da linha de comando. Para ajustar o hostname no nó mestre, execute o seguinte comando:
|
1 |
sudo hostnamectl set-hostname kubernetes-master |
No nó de trabalho, execute o seguinte comando:
|
1 |
sudo hostnamectl set-hostname kubernetes-worker |
Você pode fechar a sessão atual do terminal e fazer ssh de volta ao servidor para ver as alterações.
Passo 4: Permitindo que o Iptables Veja o Tráfego em Ponte
Para que os nós mestre e de trabalho vejam corretamente o tráfego em ponte, você deve garantir que net.bridge.bridge-nf-call-iptables esteja definido como 1 na sua configuração. Primeiro, garanta que o módulo br_netfilter esteja carregado. Você pode confirmar isso emitindo o comando:
|
1 |
lsmod | grep br_netfilter |
Opcionalmente, você pode carregá-lo explicitamente com o comando:
|
1 |
sudo modprobe br_netfilter |
Agora, você pode executar este comando para definir o valor como 1:
|
1 |
sudo sysctl net.bridge.bridge-nf-call-iptables=1 |
Passo 5: Alterando o Driver Cgroup do Docker
Por padrão, o Docker é instalado com “cgroupfs” como o driver cgroup. O Kubernetes recomenda que o Docker deve executar com “systemd” como o driver. Se você pular esta etapa e tentar inicializar o kubeadm na próxima etapa, receberá o seguinte aviso no seu terminal:
|
1 2 |
[preflight] Executando pré-flight verificações [AVISO IsDockerSystemdCheck]: detectado "cgroupfs" como o Docker cgroup driver. O recomendado driver é "systemd". Por favor siga o guia em https://kubernetes.io/docs/setup/cri/ |
Tanto nos nós master quanto nos nós worker, atualize o cgroupdriver com os seguintes comandos:
|
1 2 3 4 5 6 7 8 9 |
sudo mkdir /etc/docker cat <<EOF | sudo tee /etc/docker/daemon.json { "exec-opts": ["native.cgroupdriver=systemd"], "log-driver": "json-file", "log-opts": { "max-size": "100m" }, "storage-driver": "overlay2" } EOF |
Em seguida, execute os seguintes comandos para reiniciar e habilitar o Docker na inicialização do sistema:
|
1 2 3 |
sudo systemctl enable docker sudo systemctl daemon-reload sudo systemctl restart docker |
Uma vez configurado, podemos prosseguir para a parte divertida, implantar o cluster Kubernetes!
Passo 6: Inicializando o Nó Master do Kubernetes
O primeiro passo na implantação de um cluster Kubernetes é iniciar o nó master. No terminal do seu nó master, execute o seguinte comando para inicializar o kubernetes-master:
|
1 |
sudo kubeadm init --pod-network-cidr=10.244.0.0/16 |
Se você executar o comando acima e seu sistema não atender aos requisitos esperados, como RAM ou CPU mínima, conforme explicado na seção de Pré-requisitos, você receberá um aviso e o cluster não será iniciado:
A captura de tela abaixo mostra que a inicialização foi bem-sucedida. Também adicionamos uma flag para especificar a rede de pods com o IP 10.244.0.0. É o IP padrão que o kube-flannel usa. Discutiremos mais sobre a rede de pods na próxima etapa.
Na saída, você pode ver o comando kubeadm join (ocultamos nosso endereço IP) e um token exclusivo que você executará no nó worker e em todos os outros nós worker que deseja associar a este cluster. Em seguida, copie e cole este comando, pois você o usará mais tarde no nó worker.
Na saída, o Kubernetes também exibe alguns comandos adicionais que você deve executar como um usuário comum no nó master antes de começar a usar o cluster. Vamos executar esses comandos:
|
1 2 3 |
mkdir -p $HOME/.kube sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config sudo chown $(id -u):$(id -g) $HOME/.kube/config |
Agora inicializamos o nó master. No entanto, também temos que configurar a rede de pods no nó master antes de juntar os nós worker.
Passo 7: Implantando uma Rede de Pods
Uma rede de pods facilita a comunicação entre servidores e é necessária para o funcionamento adequado do cluster Kubernetes. Você pode ler mais sobre Rede de Cluster do Kubernetes nos documentos oficiais. Estaremos usando a rede de pods Flannel para este tutorial. O Flannel é uma rede overlay simples que atende aos requisitos do Kubernetes.
Antes de implantarmos a rede de pods, precisamos verificar o status do firewall. Se você ativou o firewall após seguir a etapa 5 do tutorial sobre como configurar seu servidor Ubuntu, você deve primeiro adicionar uma regra de firewall para criar exceções para a porta 6443 (a porta padrão para o Kubernetes). Execute os seguintes ufw comandos nos nós master e worker:
|
1 2 |
sudo ufw allow 6443 sudo ufw allow 6443/tcp |
Depois disso, você pode executar os dois comandos a seguir para implantar a rede de pods no nó master:
|
1 2 |
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/k8s-manifests/kube-flannel-rbac.yml |
Isso pode levar de alguns segundos a um minuto, dependendo do seu ambiente, para carregar a rede flannel. Execute o seguinte comando para confirmar que tudo está funcionando:
|
1 |
kubectl get pods --all-namespaces |
A saída do comando deve mostrar o status de todos os serviços como em execução se tudo tiver sido bem-sucedido:
Você também pode visualizar o estado de saúde dos componentes usando o comando get component status:
|
1 |
kubectl get componentstatus |
Este comando tem uma forma curta cs:
|
1 |
kubectl get cs |
Se você vir o status unhealthy, modifique os seguintes arquivos e exclua a linha em (spec->containers->command) contendo esta frase - --port=0 :
|
1 |
sudo nano /etc/kubernetes/manifests/kube-scheduler.yaml |
Faça o mesmo para este arquivo:
|
1 |
sudo nano /etc/kubernetes/manifests/kube-controller-manager.yaml |
Por fim, reinicie o serviço do Kubernetes:
|
1 |
sudo systemctl restart kubelet.service |
Etapa 8: Unindo os Nós Worker ao Cluster Kubernetes
Com o nó kubernetes-master ativo e a rede de pods pronta, podemos unir nossos nós worker ao cluster. Neste tutorial, temos apenas um nó worker, então trabalharemos com ele. Se você tiver mais nós worker, poderá sempre seguir as mesmas etapas explicadas abaixo para se unir ao cluster.
Primeiro, faça login no seu nó worker em uma sessão de terminal separada. Você usará o seu comando kubeadm join que foi exibido no seu terminal quando inicializamos o nó master na Etapa 6. Execute o comando:
|
1 |
sudo kubeadm join 127.0.0.188:6443 --token u81y02.91gqwkxx6rnhnnly --discovery-token-ca-cert-hash sha256:4482ab1c66bf17992ea02c1ba580f4af9f3ad4cc37b24f189db34d6e3fe95c2d |
Você deve ver uma saída semelhante à captura de tela abaixo quando a união ao cluster for concluída:
Assim que o processo de união for concluído, mude para o terminal do nó master e execute o seguinte comando para confirmar que o seu nó worker se uniu ao cluster:
|
1 |
kubectl get nodes |
Na captura de tela da saída do comando acima, podemos ver que o nó worker se uniu ao cluster:
Etapa 9: Implantando uma Aplicação no Cluster Kubernetes
Neste ponto, você configurou com sucesso um cluster Kubernetes. Vamos tornar o cluster utilizável implantando um serviço nele. O Nginx é um servidor web popular que ostenta velocidades incríveis mesmo com milhares de conexões. Implantaremos o servidor web Nginx no cluster para provar que você pode usar essa configuração em uma aplicação real.
Execute o seguinte comando no nó master para criar um deployment do Kubernetes para o Nginx:
|
1 |
kubectl create deployment nginx --image=nginx |
Você pode visualizar o deployment criado usando o comando describe deployment:
|
1 |
kubectl describe deployment nginx |
To make the nginx service accessible via the internet, run the following command:
|
1 |
kubectl create service nodeport nginx --tcp=80:80 |
The command above will create a public-facing service for the Nginx deployment. This being a nodeport, o Kubernetes atribui ao serviço uma porta no intervalo de 32000+.
Você pode obter os serviços atuais emitindo o comando:
|
1 |
kubectl get svc |
Você pode ver que a nossa porta atribuída é 32264. Anote a porta exibida no seu terminal para usar na próxima etapa.
Para verificar se a implantação do serviço Nginx foi bem-sucedida, emita uma curl chamada para o nó worker a partir do master. Substitua o IP do seu nó worker e a porta que você obteve do comando acima:
|
1 |
curl seu-kubernetes-worker-ip:32264 |
Você deve ver a saída do Nginx padrão index.html:
Opcionalmente, você pode visitar a combinação de endereço IP e porta do nó worker no seu navegador e visualizar a página index padrão do Nginx:
Você pode excluir uma implantação especificando o nome da implantação. Por exemplo, este comando excluirá nossa implantação:
|
1 |
kubectl delete deployment nginx |
Agora testamos com sucesso o nosso cluster!
Conclusão
Neste tutorial, você aprendeu como instalar um cluster Kubernetes no Ubuntu 20.04. Você configurou um cluster composto por um nó master e um nó worker. Você conseguiu instalar o conjunto de ferramentas do Kubernetes, criou uma rede de pods e juntou o nó worker ao nó master. Também testamos nosso conceito fazendo uma implantação básica de um servidor web Nginx no cluster. Isso deve funcionar como base para trabalhar com clusters Kubernetes no Ubuntu.
Embora tenhamos usado apenas um nó worker, você pode estender seu cluster com quantos nós desejar. Se você quiser se aprofundar em DevOps com ferramentas de automação como o Ansible, temos um tutorial que se aprofunda no provisionamento de implantações de cluster Kubernetes com Ansible e Kubeadm, confira. Se você quiser aprender como implantar uma aplicação PHP em um cluster Kubernetes, confira este tutorial.
Boa computação!
Comentários
Nenhum comentário ainda. Seja o primeiro.