Introducció a Kubernetes

En aquest article presentarem una breu introducció a l'orquestrador de contenidors Kubernetes (K8s). Et recomanem tenir coneixements bàsics de Docker per tenir una visió global del que són els contenidors i perquè en aquest article es farà servir Docker com a sistema de contenidors.

• Què és Kubernetes?
• Conceptes bàsics
• Clúster
• Pod
• Servei

Instal·lació

• Comú
• Inicialització del clúster
• Afegir treballadors
• Fent proves
• Eliminar recursos

Què és Kubernetes?

Segons la documentació de Kubernetes:

Kubernetes és una plataforma de codi obert per automatitzar la implementació, l'escalat i l'administració d'aplicacions en contenidors.

Per aprofundir en la definició, Kubernetes és un sistema de control del cicle de vida de contenidors que fa servir diferents mètodes que permeten tenir un alt nivell de disponibilitat i escalabilitat, entre altres característiques.

Conceptes bàsics

Clúster

Un clúster és un conjunt d'ordinadors. En el nostre cas serà un clúster de Kubernetes i cada ordinador tindrà un rol, que pot ser un d'aquests dos:

• Mestre: només n'hi ha un en el conjunt i és el que s'encarrega de repartir la càrrega de treball entre els altres nodes, mantenir l'estat de treball desitjat, escalar les aplicacions o actualitzar-les.
• Treballador: els altres nodes que no són mestres. Són els que executen les aplicacions per mitjà de contenidors. El nombre mínim desitjable de treballadors és 3.

La comunicació entre el mestre i els treballadors es fa per mitjà de l'API de Kubernetes, a través del mestre (tot i que els usuaris finals també poden interactuar amb l'API). Els treballadors es connecten al mestre per mitjà del procés kubelet.

Un clúster de Kubernetes es pot implementar en una màquina física o en una màquina virtual. També és possible fer servir Minikube, una implementació lleugera de Kubernetes que crea una màquina virtual localment amb un sol treballador.

Pod

És la unitat mínima d'execució de Kubernetes. Representa processos en execució al clúster. Un Pod conté un o diversos contenidors (de Docker, per exemple) i administra els recursos de l'aplicació, l'adreça IP i diferents opcions que determinen com funcionen els contenidors.

Servei

És una abstracció que defineix un conjunt de pods que executen un microservei com ara el frontal.

Els pods són finits, és a dir, “neixen” i “moren” però no poden “ressuscitar”. Es creen i s'eliminen al llarg de l'execució del Deployment. Cada pod té la seva pròpia adreça IP, de manera que les adreces IP dels pods que s'executen en un moment determinat seran diferents de les dels que s'executin en un altre instant. Això suposa un problema, atès que voldrem tenir una adreça IP fixa a l'hora d'accedir als pods. Per això existeix el concepte de servei, per solucionar aquest problema.

Instal·lació

Com s'ha dit anteriorment, necessitem tenir un servidor que actuï com a mestre i un com a treballador, de manera que necessitarem almenys 2 servidors VPS. La imatge que cal seleccionar a l'hora d'inicialitzar-los serà la de Docker, que en aquest cas es farà servir sobre Ubuntu 18.04. Per no tenir problemes, els servidors han de tenir almenys dos processadors, tot i que es pot forçar amb menys, però pot ser que el rendiment no sigui el desitjat.

Comú
Cal instal·lar les dependències següents i el mateix Kubernetes en totes les màquines que formen el clúster, independentment del seu rol.

• Desactivar la swap:

# swapon -s && swapoff -a

Per desactivar la partició swap de manera permanent, obrim el fitxer /etc/fstab (amb vim, per exemple) i comentem la línia corresponent a la partició swap, com a la imatge següent:

• Inicialitzar el servei de Docker i programar-lo perquè s'executi a l'inici:

# systemctl enable docker.service && systemctl start docker.service

• Actualitzar el sistema:

# apt update && apt upgrade -y && apt dist-upgrade -y

• Dependències (per si encara no estiguessin instal·lades):

# apt install -y apt-transport-https

• Importar la clau del repositori de Kubernetes:

# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add

• Afegir el repositori:

# curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.32/deb/Release.key | \  gpg --dearmor -o /etc/apt/sources.list.d/kubernetes.apt.keyring.gpg
# echo "deb [signed-by=/etc/apt/sources.list.d/kubernetes.apt.keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.32/deb/ /" > /etc/apt/sources.list.d/kubernetes.list

• Instal·lar Kubernetes:

# apt update && apt install -y kubeadm kubelet kubectl

Inicialització del clúster

Ara inicialitzarem el clúster al node que actua com a mestre. Per fer-ho, hem d'executar les ordres següents només al mestre:

# kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address DIRECCION_IP_MASTER

On DIRECCION_IP_MASTER és la IP pública del nostre VPS mestre.

Si ens dona l'error següent a causa del nombre de processadors:

([ERROR NumCPU]: the number of available CPUs 1 is less than the required 2)

podem executar-lo igualment, tot i que lògicament el rendiment serà menor, afegint l'opció següent a l'ordre anterior:

--ignore-preflighterrors=NumCPU.

Si tot ha anat bé, hauríem d'obtenir un missatge com aquest (pot trigar diversos minuts a executar totes les ordres):

Haurem de copiar l'ordre que comença per “kubeadm join …” (al final del missatge), ja que és la que ens permetrà afegir nodes al nostre clúster.

• Configurar el clúster: hem de crear una configuració nova per al clúster al directori $HOME/.kube. Per fer-ho, podem copiar la que té Kubernetes per defecte amb les ordres següents:

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

Desplegar el flannel per administrar les adreces IP dels contenidors, ja que Kubernetes assumeix que cada pod té una IP única:

# kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/main/Documentation/kube-flannel.yml

Per comprovar els nodes actius i els pods i el seu estat, executem les dues ordres següents, respectivament:

# kubectl get nodes
# kubectl get pods --all-namespaces

Abans d'afegir nodes, hem d'afegir les regles al tallafoc. En el meu cas, he decidit permetre tot el trànsit TCP entre el treballador i el mestre amb la configuració següent, on la IP que apareix és la del treballador:

Afegir treballadors

Per afegir un node nou al clúster, cal disposar de l'ordre “kubectl join …” esmentada anteriorment, ja que conté la clau per afegir un node:

# kubeadm join 85.208.20.82:6443 --token *** --discovery-token-ca-cert-hash sha256: ***

On els asteriscs són les claus concretes.

Després de diversos minuts, haurem de tenir el missatge següent, que confirmarà que tot ha anat com s'esperava:

Podem comprovar que el node s'ha afegit al clúster des del mestre, executant de nou

# kubectl get nodes

Fent proves

Ara que tenim almenys un node, podem comprovar si funciona correctament. Per fer-ho, desplegarem una pàgina web senzilla de nginx.

• Creem la carpeta al treballador on s'allotjarà el nostre servidor web:

# mkdir -p nginx/
# cd nginx/

• Hem de crear un fitxer YAML amb la configuració que volem, per exemple el següent:

apiVersion: apps/v1 # Fes servir apps/v1beta2 per a versions anteriors a 1.9.0 
kind: Deployment 
metadata: 
name: nginx-deployment 
spec: 
selector: 
    matchLabels: 
    app: nginx 
replicas: 2 # indica al controlador que executi 2 pods 
template: 
  metadata: 
  labels: 
     app: nginx 
  spec: 
  containers: 
  - name: nginx 
    image: nginx:1.7.9 # imatge i versió que cal fer servir 
    ports: 
    - containerPort: 80 # port en què s'executa, per defecte per a un servidor HTTP és el 80

I el desem en un fitxer amb extensió .yaml, per exemple a nginx.yaml.

• Creem un recurs nou a partir del YAML:

# kubectl create -f nginx.yaml

I rebrem el missatge següent:

deployment.apps/nginx-deployment created

Podem veure els desplegaments i el seu estat amb l'ordre següent:

# kubectl get deployments

que ens retornarà:

També podem obtenir més informació sobre un recurs concret executant:

 # kubectl describe deployment DESPLIEGUE

on DESPLIEGUE en el nostre cas és nginxdeployment:

• Després del desplegament s'han creat dos pods més (ja que hem posat replicas: 2), cosa que podem comprovar fàcilment amb l'ordre que hem vist anteriorment:

 # kubectl get pods

I, com és lògic, obtenir més informació de cada pod amb:

# kubectl describe pod POD

on POD és el nom obtingut amb l'ordre anterior.
Per acabar, cal crear un servei, ja que, si no, no veurem el resultat del nostre servidor HTTP.

• Creem un fitxer YAML amb el següent

contingut a nginx-svc.yaml:

apiVersion: v1
kind: Service
metadata:
name: nginx-svc
labels:
run: nginx-svc
spec:
type: NodePort
ports:
- port: 80
protocol: TCP
selector:
app: nginx

•   Creem el servei igual que abans amb:

 # kubectl create -f nginx-svc.yaml

Veiem la llista de serveis amb:

# kubectl get service

Com es veu a la llista, el port a través del qual hem d'accedir al servidor web no és el 80, sinó el 31890 (en el meu cas), de manera que, a l'hora d'escriure'l a la barra d'adreces d'un navegador web, haurem de posar http://IP:PUERTO i obtindrem el resultat següent:

Eliminar recursos

A l'hora d'eliminar diferents tipus de recursos, pods o serveis, és possible fer-ho si en sabem l'identificador amb l'ordre “kubectl delete”:

• Serveis:

 # kubectl delete svc/SERVICIO

• Pods:

 # kubectl delete pod/POD

• Desplegaments:

 # kubectl delete deployment/DEPLOYMENT

Autor: David Población.