DESCRIPCIÓN.

Preparación de clúster de Kubernetes para Certificación CKA.
Direcciones IP:
master -> 192.168.0.54
worker1 -> 192.168.0.56
worker2 -> 192.168.0.59

REQUISITOS.

Contiene las siguientes especificaciones:

SISTEMA OPERATIVO -> Ubuntu Server (Minimal)
HARDWARE (Minimun) -> 2 Core CPU & 4 GB RAM
SOFTWARE -> ContainerD – Kubernetes (k8s)

La estructura del cluster será la siguiente

esquema

Procedimiento

Partiremos de una instalación mínima (Sin Interfaz Gráfica) en Ubuntu Server LTS 24.X. Como motor de ejecución de contenedores usaremos ContainerD. Es un entorno más ligero ya que no utiliza Docker al completo, solo la parte que virtualizará. Iremos paso a paso realizando la instalación y posteriormente iniciando el Clúster. También uniremos dos nodos trabajadores que se podrán comunicar.

Instalación Containerd

Actualizamos repositorios

sudo apt update && sudo apt upgrade -y

Desinstalamos posibles conflictos

sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc | cut -f1)

Instalamos paquetes

sudo apt update 
sudo apt install ca-certificates curl runc apt-transport-https ca-certificates curl gnupg2 software-properties-common git vim golang golang-go sudo gpg -y

Quitamos la memoria swap y activamos modulos de red

sudo swapoff -a
sudo modprobe overlay
sudo modprobe br\_netfilter

Comprobaremos en el fichero /etc/fstab el estado de la memoria swap:

swapoff

Configuracion de red para kubernetes

sudo tee /etc/sysctl.d/kubernetes.conf
<<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

sudo sysctl --system

Instalacion de DOCKER

Add Docker’s official GPG key:

sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

Añadimos Repositorios Necesarios:

sudo tee /etc/apt/sources.list.d/docker.sources 
<<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU\_CODENAME:-$VERSION\_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Configuracion de containerd para kubernetes

containerd config default > /etc/containerd/config.toml

Accederemos a la configuración y ajustaremos el systemgroup

vim /etc/containerd/config.toml

Modificamos SystemdCgroup y cambiamos false a true

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]
  ...
  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
    SystemdCgroup = true

systemctl restart containerd

Instalación de Kubeadm

Instalación de paquetes kubeadm por defecto

sudo apt-get update
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.34/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

NOTA!! Cambiar la versión de kubernetes según la instalación necesaria. En esta instalación utilizaremos la 1.34.

Añadimos el repositorio con la versión seleccionada

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.34/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

Actualizamos repositorios e instalamos

sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
sudo systemctl enable --now kubelet

Iniciamos el Cluster kubeadm

Creacion de cluster con Kubeadm

kubeadm init --apiserver-advertise-address 192.168.0.54 --pod-network-cidr 10.10.10.0/24

Una vez haya finalizado nos quedará un token que debemos guardar y unos comandos a lanzar desde el usuario del que vamos a usar kubernetes para instalar los certificados.

esquema

Nos dejara el siguiente mensaje. Es importante que guardemos los tokens proporcionados y ejecutemos los comandos según sea conveniente para poder comunicarnos con la API.

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/

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

kubeadm join 192.168.0.54:6443 \
    --token kl5i5b.ziwjtglhh958y2pc --discovery-token-ca-cert-hash sha256:9e632f0e0ff18d271d1ee43e8b135ede-xxxxxxxxxxxxxxxxxxxxxxx

Container Network Interface (CNI)

Kubernetes necesitará una serie de pluggins básicos para preparar la interfaz de red entre los contenedores.

git clone https://github.com/containernetworking/plugins
cd plugins
git checkout v1.1.1
./build_linux.sh
sudo mkdir -p /opt/cni/bin
sudo cp bin/* /opt/cni/bin/

CNI - CALICO

Calico es una solución de red y seguridad Open-Source para Kubernetes es capaz de comunicar la red entre los contenedores basándose en los pluggins por defecto.

kubectl apply -f https://docs.tigera.io/calico/latest/manifests/calico.yaml

kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.31.2/manifests/tigera-operator.yaml

kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.31.2/manifests/custom-resources.yaml

Comprobaremos que esta funcionando con el siguiente comando:

watch kubectl get tigerastatus

esquema

Untaint Nodes

Una vez el cluster se haya iniciado los nodos que tengamos “repelerán” la asignación de pods por defecto, esto ayuda a la gestión de recursos y a que en el nodo que actue como Control Plane (CP) no tenga carga de trabajo extra. En nuestro caso utilizaremos tres nodos incluyendo el CP por lo que eliminaremos este ‘Taint’.

kubectl taint nodes --all node-role.kubernetes.io/control-plane-

Tendremos el cluster de la siguiente manera. Se podrán observar los pods de Calico, almacenamiento (etcd), DNS, Api-server, proxy y scheduler. Estos pods son la estructura base de nuestro cluster y han de estar siempre en estado “Running”. esquema

Procedemos a unir un nodo trabajador mediante el comando que nos ha mostrado el nodo master. Veremos como aparecen nuevos pods relacionados con Calico y con Proxy. Se pondrán en estado “Running” y eso significará que el nodo se ha unido correctamente al cluster. esquema

De la misma manera uniremos el segundo y LISTO!

Conclusion

Estos son los primeros pasos de un cluster Kubeadm en local. Podremos observar como el entorno se realiza con el runtime de ContainerD (El entorno de virtualización de Docker). Partiendo de estas bases podremos crear Despliegues, contenedores con nuestras aplicaciones, bases de datos etc. Todo este entorno se controlará a traves de archivos YAML y comandos con la herramienta kubectl desde la consola. Es importante controlar bien los certificados y permisos (RBAC) para una gestion segura y eficiente del entorno. Una vez tengamos el entorno preparado podremos empezar a aprender a cerca de la gestión de sus recuros. Kubernetes(k8s) es una herramienta muy potente en los entornos de produccion de desarrollo, capaz de automatizar, implementar y escalar servicios gestionados en contenedores.