Para a instalação do cluster Kubernetes foi utilizado os seguintes materiais como base:
- Intensivo Kubernetes: O mínimo que um dev precisa saber
- Setup Kubernetes Cluster Step By Step
- How To Install Kubernetes Cluster On Ubuntu 16.04
É recomendado que o cluster envolva ao menos 3 maquinas, pois o Kubernetes em si também possui um custo computational para realizar a orquestração dos containers.
- Memoria: 2GB RAM
- Processador: 2xCPU Cores
- Memoria: 1GB RAM
- Processador: 1xCPU Core
Para o desenvolvimento do cluster foram utilizadas máquinas virtuais disponibilizadas pelo LARCC.
O cluster foi composto por 4 VMs com a mesma configuração, sendo 1 Master e 2 Nodos.
- Processador: 2xCores
- Memória: 2GB RAM
- Armazenamento: 20GB
- OS: Ubuntu Server 20.04
As seguintes etapas devem ser realizadas tanto na maquina Master quanto nos Nodos como usuário administrador.
sudo apt update
O espaço de Swap do sistema operacional deve ser desabilitado para a instalação do Kubernetes, ao contrário podem ocorrer erros durante a execução.
swapoff -a
Verificar se existem partições de swap no fstab, caso existir devem ser removidas ou comentadas.
nano /etc/fstab
O Hostname da máquina será a forma como ela será identificada dentro do cluster, este nome irá aparecer no dashboard e nas consultas por nodos.
Para construir um padrão de nomenclaturas, podemos chamar a máquina Master de "kmaster" e os nodos de "knode0", "knode1", "knode2"...
nano /etc/hostname
Para que as maquinas do cluster não percam o seu IP caso sejam desligadas ou reiniciadas, é necessário definir o IP como estático.
Atualize o arquivo /etc/network/interfaces com uma configuração de IP estático, a formatação pode mudar dependendo da versão do Ubuntu.
Para que as maquinas possam se encontrar dentro do cluster, é necessário configurar o arquivo de hosts com os IPs estáticos configurados anteriormente.
- No arquivo de hosts da maquina Master deve haver os IPs de todos os nodos.
- Já nos nodos pode haver somente o IP da maquina master.
nano /etc/hosts
sudo apt-get install openssh-server
O seguinte comando irá instalar Docker e todas as suas dependencies, podendo demorar um pouco.
sudo apt-get install -y docker.io
apt-get update && apt-get install -y apt-transport-https curl
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF
apt-get update
apt-get install -y kubelet kubeadm kubectl
sudo nano /etc/docker/daemon.json
Adicionar o seguinte conteudo:
{
"exec-opts": ["native.cgroupdriver=systemd"]
}
Reiniciar o serviço do docker
sudo systemctl restart docker
Para garantir que as configurações realizadas no namespace e variaveis de ambiente foram aplicadas, temos que reiniciar a máquina.
sudo reboot
A configuração inicial do Kubernetes foi realizada, as próximas etapas serão definir uma maquina como Master, no nosso caso o "knode", e adicionar os nodos ao cluster.
As seguintes etapas devem ser realizadas somente na maquina Master.
O seguinte comando irá iniciar o cluster, altere o <ip-address-of-kmaster-vm> pelo IP da maquina master.
kubeadm init --apiserver-advertise-address=<ip-address-of-kmaster-vm> --pod-network-cidr=192.168.0.0/16
Dois resultados deste comando devem ser anotados.
- Os comandos para copiar o arquivo .config do cluster serão exibidos como:
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
- O comando utilizado para fazer os nodos se juntarem ao cluster será algo como:
kubeadm join <ip-address-of-kmaster-vm>:port --token ...
Deve ser criado um novo usuário somente para o Kubernetes neste caso.
sudo adduser k8s
usermod -aG sudo k8s
Depois troque para o novo usuário, e execute os comandos.
su k8s
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
Para verificar se o cluster foi iniciado com sucesso, pode executar o seguinte comando e verificar se os pods estão sendo iniciados.
kubectl get pods -o wide -A
No comando anterior deve ser notado que todos os Pods ficaram com o status "Running" menos o "kube-dns", para resolve isso, será instalado a rede intra-pod chamada de CALICO.
kubectl create -f https://docs.projectcalico.org/manifests/tigera-operator.yaml
kubectl create -f https://docs.projectcalico.org/manifests/custom-resources.yaml
Após instalação, todos Pods devem ficar com o status "Running", incluindo os novos pods do CALICO.
A instalação do Dashboard deve ser realizada antes dos outros nodos se juntarem ao cluster, ao contrário pode ocorrer do Dashboard ser instalado em um nodo, e não no Master.
git clone https://github.com/Lucas-Alf/kubernetes-dashboard-config.git
cd kubernetes-dashboard-config
kubectl apply -f alternative.yaml
Para conseguir logar no Dashboard sem senha precisamos executar:
kubectl create clusterrolebinding dashboard-admin -n default --clusterrole=cluster-admin --serviceaccount=kubernetes-dashboard:kubernetes-dashboard
As seguintes etapas devem ser realizadas somente nas máquinas nodos do cluster.
Para adicionar um novo nodo ao cluster somente é necessário executar o comando sudo kubeadm join ... que foi gerado durante a instalação do cluster, na maquina nodo que deseja adicionar.
Ao executar esse comando o nodo irá automaticamente entrar na cluster, e você poderá visualiza-lo no Dashboard.
Pode demorar alguns minutos até o novo nodo ficar utilizável, pois ao entrar no cluster ele irá começar a instalar uma série de dependências no nodo, o progresso da instalação é visível no Dashboard.
Para acessar o dashboard hospedado na VM dentro do LARCC, é necessário utilizar um serviço de relay.
- Criar uma conta em: https://webhookrelay.com/
- Instalar o webhook relay na máquina master:
curl https://my.webhookrelay.com/webhookrelay/downloads/install-cli.sh | bash
- Criar um novo token em: https://my.webhookrelay.com/tokens
- Logar com token na maquina master:
relay login -k meutoken -s meusecret
- Iniciar um PortForward em um segundo terminal
kubectl port-forward -n kubernetes-dashboard service/kubernetes-dashboard 8001:80 --address 0.0.0.0
- Inicializar o Relay:
relay connect localhost:8001
- Acessar a URL gerada pelo Relay.
Habilitar o modo strict ARP.
kubectl get configmap kube-proxy -n kube-system -o yaml | \
sed -e "s/strictARP: false/strictARP: true/" | \
kubectl apply -f - -n kube-system
Instalar o MetalLB
kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.11.0/manifests/namespace.yaml
kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.11.0/manifests/metallb.yaml
Criar o arquivo de configuração do MetalLB
metallb-config.yaml
Alterar o range de IPs da configuração conforme o disponibilizado em aula.
apiVersion: v1
kind: ConfigMap
metadata:
namespace: metallb-system
name: config
data:
config: |
address-pools:
- name: default
protocol: layer2
addresses:
- 192.168.20.202-192.168.20.204
Aplicar a configuração no cluster
kubectl apply -f metallb-config.yaml
Realizar o download da imagem de demonstração
git clone https://github.com/dockersamples/example-voting-app.git
cd example-voting-app
Aplicar a imagem no cluster
kubectl create namespace vote
kubectl create -f k8s-specifications/
Expor os novos serviços no load balancer
kubectl expose deployment vote -n vote --port=5000 --target-port=80 --name=vote-loadbalancer --type=LoadBalancer
kubectl expose deployment result -n vote --port=5001 --target-port=80 --name=result-loadbalancer --type=LoadBalancer
Fazer o PortForward do serviço que deseja visualizar.
Deve-se primeiro parar o PortForward do dashboard, somente um pode estar sendo executado por vez.
kubectl port-forward -n vote service/vote-loadbalancer 8001:5000 --address 0.0.0.0
kubectl port-forward -n vote service/result-loadbalancer 8001:5001 --address 0.0.0.0