Rancher com Kubernetes

Instalação Kubernetes com Rancher no Opensuse

O que é Rancher e o que é Kubernentes?

Uma breve descrição:

O Rancher é uma plataforma de gerenciamento de contêineres que facilita a implantação e a operação de clusters Kubernetes em ambientes de nuvem e locais. Ele oferece uma interface gráfica de usuário (GUI) e ferramentas de linha de comandos para gerenciar clusters, simplificar a orquestração de contêineres e proporcionar segurança, monitoramento e escalabilidade de aplicações baseadas em contêineres.

O Kubernetes é uma plataforma de código aberto para orquestração de containers, usada para gerenciar e automatizar o deployment, a escalabilidade e as operações de aplicações containerizadas. Ele foi desenvolvido inicialmente pelo Google e agora é mantido pela Cloud Native Computing Foundation (CNCF).

Kubernetes com seus componentes principais:

Control Plane: Coordena o cluster, gerenciando o estado e o ciclo de vida das aplicações. Inclui o API Server (interface principal), o Scheduler (alocação de pods nos nós), e o Controller Manager (gestão de controladores).

Etcd: Um banco de dados chave-valor distribuído que armazena de forma confiável todos os dados do cluster, como configurações e estados.

Worker Nodes: Os servidores que executam os containers e incluem o Kubelet (comunicação com o Control Plane), Kube Proxy (gestão de rede) e o runtime de containers (como Docker ou containerd).

Resumo: O rancher é englobado pelo cluster Kubernetes que contém os componentes Control Plane, Etcd e worker. 

Obs: Essa configuração é enxuta e direcionada para o aprendizado e execução deste tutorial.

Principais Termos: 

Container: Uma instância independente que executa um ou mais aplicativos ou processos.

Pod: A menor unidade no Kubernetes, que contém um ou mais contêineres funcionando juntos e compartilhando recursos como rede e armazenamento.

Deployment: Gerencia pods, suportando atualizações automáticas e reversões.

Service: Exposição de pods como um ponto de acesso interno/externo na rede.

Apartir segue o tutorial de instalação e configuração:

O Opensuse utilizado foi o 15.6 Leaf.

Ajustes da timezone de São Paulo:

timedatectl set-timezone America/Sao_Paulo

Após cada servidor do Opensuse instalado:

Ex: Ips:

192.168.15.95 --> kubernentes-control-plane

192.168.15.135 --> kubernentes-etcd

192.168.15.145 --> kubernentes-worker

hostnamectl set-hostname kubernentes-control-plane

hostnamectl set-hostname kubernentes-etcd

hostnamectl set-hostname kubernentes-worker

Criar 3 servidores básicos: (Control Plane, Etcd e Worker), a memória alocada em cada servidor fico como comentário no arquivo /etc/hosts

Adicione as informações no /etc/hosts:

192.168.15.95    kubernentes-control-plane # 8GB alocado

192.168.15.135    kubernentes-etcd                 # 4GB alocado

192.168.15.145    kubernentes-worker            # 8GB alocado

Em todos servidores executar:

zypper update

zypper in vim wget iputils

Não é recomendável, mas p/ facilitar a ditática, será desabilitado o firewall local. Desabilitar o firewalld:

systemctl disable --now firewalld

Instalar o docker (dependência para o cluster kubernentes)

zypper addrepo https://download.docker.com/linux/opensuse/leap/15.6/x86_64/stable/ docker-ce

zypper refresh

zypper install docker-24.0.7_ce-150000.198.2

systemctl enable docker --now

docker ps

Criar usuário:

useradd -m k8s

passwd k8s (Senha:m@st3r-!@#)

groupadd k8s

usermod -g k8s k8s

usermod -aG docker k8s

Servidor Control plane (bastion)

su - k8s

ssh-keygen -t rsa -b 4096 -f /home/k8s/.ssh/id_rsa

ssh-copy-id k8s@kubernentes-control-plane

ssh-copy-id k8s@kubernentes-etcd

ssh-copy-id k8s@kubernentes-worker

exit

Instalar o kubernetes (kubectl e rke)

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

install -o root -g root -m 0755 kubectl /usr/bin/kubectl

chmod 755 /usr/bin/kubectl

kubectl version --client

wget https://github.com/rancher/rke/releases/download/v1.4.17/rke_linux-amd64

mv rke_linux-amd64 /usr/bin/rke

chmod 755 /usr/bin/rke

rke --version

Configurar o cluster kubernentes:

su - k8s

rke config

Observa os Detalhes a serem preenchidos:

[+] Cluster Level SSH Private Key Path [~/.ssh/id_rsa]: <enter>

[+] Number of Hosts [1]: 3

[+] SSH Address of host (1) [none]: kubernentes-control-plane

[+] SSH Port of host (1) [22]: <enter>

[+] SSH Private Key Path of host (kubernentes-control-plane) [none]:

~/.ssh/id_rsa

[+] SSH User of host (kubernentes-control-plane) [ubuntu]: k8s

[+] Is host (kubernentes-control-plane) a Control Plane host (y/n)? [y]: y

[+] Is host (kubernentes-control-plane) a Worker host (y/n)? [n]: n

[+] Is host (kubernentes-control-plane) an etcd host (y/n)? [n]: n

[+] Override Hostname of host (kubernentes-control-plane) [none]:

kubernentes-control-plane

[+] Internal IP of host (kubernentes-control-plane) [none]: 192.168.15.95

[+] Docker socket path on host (kubernentes-control-plane)

[/var/run/docker.sock]: <enter>

[+] SSH Address of host (2) [none]: kubernentes-etcd

[+] SSH Port of host (2) [22]:  <enter>

[+] SSH Private Key Path of host (kubernentes-etcd) [none]:

~/.ssh/id_rsa

[+] SSH User of host (kubernentes-etcd) [ubuntu]: k8s

[+] Is host (kubernentes-etcd) a Control Plane host (y/n)? [y]: n

[+] Is host (kubernentes-etcd) a Worker host (y/n)? [n]: n

[+] Is host (kubernentes-etcd) an etcd host (y/n)? [n]: y

[+] Override Hostname of host (kubernentes-etcd) [none]:

kubernentes-etcd

[+] Internal IP of host (kubernentes-etcd) [none]: 192.168.15.135

[+] Docker socket path on host (kubernentes-etcd)

[/var/run/docker.sock]: <enter>

[+] SSH Address of host (3) [none]: kubernentes-worker

[+] SSH Port of host (3) [22]: <enter>

[+] SSH Private Key Path of host (kubernentes-worker) [none]:

~/.ssh/id_rsa

[+] SSH User of host (kubernentes-worker) [ubuntu]: k8s

[+] Is host (kubernentes-worker) a Control Plane host (y/n)? [y]: n

[+] Is host (kubernentes-worker) a Worker host (y/n)? [n]: y

[+] Is host (kubernentes-worker) an etcd host (y/n)? [n]: n

[+] Override Hostname of host (kubernentes-worker) [none]:

kubernentes-worker

[+] Internal IP of host (kubernentes-worker) [none]: 192.168.15.145

[+] Docker socket path on host (kubernentes-worker)

[/var/run/docker.sock]: <enter>

[+] Network Plugin Type (flannel, calico, weave, canal, aci) [canal]:

<enter>

[+] Authentication Strategy [x509]: <enter>

[+] Kubernetes Docker image [rancher/hyperkube:v1.24.6-rancher1]:

rancher/hyperkube:v1.27.14-rancher1

[+] Cluster domain [cluster.local]: <enter>

[+] Service Cluster IP Range [10.43.0.0/16]: <enter>

[+] Enable PodSecurityPolicy [n]: <enter>

[+] Cluster Network CIDR [10.42.0.0/16]: <enter>

[+] Cluster DNS Service IP [10.43.0.10]:<enter>

[+] Add addon manifest URLs or YAML files [no]: <enter>

Em cluster.yml insera o providor com o atritubo none.

vim cluster.yml

[...]

ingress:

provider: "none"

options: {}

[...]

Ajustando o cluster kubernentes para subir automaticamente:

mkdir /home/k8s/.kube

rke up

mv kube_config_cluster.yml config

cp config /home/k8s/.kube

vim /home/k8s/.bashrc

export KUBECONFIG=/home/k8s/.kube/config

Verificando o cluster Kubernetes

kubectl get nodes

kubectl cluster-info

Instalar helm (gerenciador de pacotes Kubernentes):

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3

chmod 700 get_helm.sh

bash get_helm.sh

Pré Requisito do Rancher (Ingress Controller​)

su - k8s

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

helm repo update

helm install nginx-ingress ingress-nginx/ingress-nginx --namespace ingress-nginx --create-namespace

Verificar o Ingress Controller:

kubectl get pods -n ingress-nginx

kubectl get svc -n ingress-nginx

Adicionar repositório Rancher

helm repo add rancher-stable https://releases.rancher.com/server-charts/stable

kubectl create namespace cattle-system

Crie a Autoridade Certificadora (CA)

mkdir certs && cd certs

openssl genpkey -algorithm RSA -out ca.key

openssl req -new -x509 -key ca.key -out ca.crt -days 3650 -subj "/C=BR/ST=DF/L=Brasilia/O=Rancher/OU=CA/CN=kubernentes-control-plane"

Gere a Chave e o CSR para o Servidor

openssl genpkey -algorithm RSA -out tls.key

openssl req -new -key tls.key -out tls.csr -subj "/C=BR/ST=DF/L=Brasilia/O=Rancher/OU=IT/CN=kubernentes-control-plane"

Assine o CSR com a CA

openssl x509 -req -in tls.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out tls.crt -days 3650

Criar Secret do Rancher:

kubectl -n cattle-system create secret tls tls-rancher-ingress --cert=tls.crt --key=tls.key

Criar Secret da CA

kubectl -n cattle-system create secret generic tls-ca --from-file=cacerts.pem=ca.crt

Listar secrets

kubectl -n cattle-system get secrets

Instalar Rancher com Helm

helm install rancher rancher-stable/rancher --namespace cattle-system --set bootstrapPassword=secretpasswd --set hostname=kubernentes-control-plane --set ingress.tls.source=secret --set privateCA=true

Para expor o Rancher para fora, foi necessário criar o manifest do tipo NodePort, pois é um metodo, simplificado para expor o Rancher fora do cluster Kubernetes.

k8s@rancher-cp:~> cat node-port.yml

apiVersion: v1

kind: Service

metadata:

  name: rancher

  namespace: cattle-system

spec:

  type: NodePort

  ports:

    - protocol: TCP

      port: 80

      targetPort: 80

      nodePort: 30080

    - protocol: TCP

      port: 443

      targetPort: 443

      nodePort: 30443

  selector:

    app: rancher

kubectl apply -f node-port.yml

Após acessar a primeira vez será gerada uma senha randomicamente: 

Digite esse comando no terminal para verificar a senha:

kubectl get secret --namespace cattle-system bootstrap-secret -o go-template='{{.data.bootstrapPassword | base64decode}}'

Acesse o link do Rancher para realizar o primeiro acesso:

• https://192.168.15.95:30443

Os próximos login, não iram notificar a questão de primeiro acesso do Rancher, e ficará assim:

Após o acesso será apresentado as informações do primeiro cluster:

Exemplo de criação de um deployment com o serviço Nginx com 2 replicas, no caso será criado dois pods. Clique em Workloads e selecione deployment e posteriormente clique na caixa do lado direito superior "Create"

No momento que criar o deployment, insira o nome para o deployment: primeiro-deploy, em replicas foi utilizada 2 como exemplo, insira a imagem do container: nginx, após selecione "Create".

Se tudo ocorrer sem problemas, sera criado o deployment: primeiro-deploy

Para melhor entendimento e verificar as 2 replicas de pods criadas, clique em primeiro-deploy:

Foi criados 2 pods conforme exemplificado na figura com os seguintes nomes:

• primeiro-deploy-6f55bc5d8-88bkq
• primeiro-deploy-6f55bc5d8-jlgjg

Obs: Este tutorial foi elaborado com um cluster Kubernetes utilizando apenas um nó Worker. Embora haja duas réplicas do pod configuradas, a falta de múltiplos Workers impede a alta disponibilidade. Em caso de falha no único Worker, todos os pods serão interrompidos, pois não há outro nó para redistribuí-los. Para garantir resiliência, recomenda-se ao menos dois Workers em ambientes de produção.

Para expor o nginx para acesso externo devemos configurar o service:

Antes de propagar o service, precisamos configurar o label/selector para configurar o service:

No deployment "primeiro-deploy", foi editado as configurações e inserido o seguinte label: 

• key: web
• value: nginx 

Clique em "Save", neste momento os pods anterior serão excluidos e recriados.

Clique no menu: Service Discovery, posteriormente em Service, Clique em "Create":

Será apresentada a seguinte tela, estaremos utilizado o service Node Port:

Uma breve descrição: NodePort é um tipo de Service no Kubernetes que expõe um aplicativo para acesso externo, mapeando uma porta específica em todos os nós do cluster para a porta do pod. Isso permite que o serviço seja acessado diretamente pelo IP do nó e pela porta atribuída, seu range de portas externas seria de 30000 a 32767.

Após clicar em Node Port, Preencha o nome do serviço: Name, o nome da porta: Port Name, insira a porta local do container do nginx, no caso 80 e em Node Port, escolha a porta externa a ser pública no caso foi escolhida a porta 30111.

Para completar a configuração, insera o selector criado no deployment anteriormente:

• key: web
• value: nginx 

Após clique em Create:

Para acessar o Nginx, basta acessar:

http://kubernentes-worker:30111/

ou

http://192.168.15.145:30111/

Obs 1: O acesso somente funcione via ip, pois talvez não tenha entrada dns cadastradas ou a mesma não foi inserida no /etc/hosts.

Obs 2: Caso tiver 2 ou mais workers, o acesso por equanto, seria conforme exemplo abaixo com Node Port:

• http://kubernentes-worker:30111/
• http://kubernentes-worker2:30111/
• http://kubernentes-worker3:30111/

###########################################

Espero que gostem deste tutorial, sugestões e dúvidas fico a disposição.

Ass: Luiz Guilherme Nunes Fernandes

Email: narutospinal@gmail.com

Informativo: Entusiasta e colaborador em Software Livre.