Kubernetes – Guía para crear nuestro clúster (III)

A pesar de llevar un cierto tiempo usando Kubernetes en producción, ha sido este año cuando hemos comenzado a impartir las formaciones oficiales de la Linux Foundation, haciendo un foco especial en Kubernetes. Podéis comprobar nuestra oferta disponible en el catálogo de productos o en nuestra tienda virtual.

¿Qué es la Inteligencia Artificial ?

La Inteligencia Artificial (IA) es un campo de la informática que se centra en el desarrollo de sistemas y tecnologías que pueden realizar tareas que normalmente requerirían inteligencia humana. Estas tareas pueden incluir el reconocimiento de patrones, la resolución de problemas, la toma de decisiones, el procesamiento del lenguaje natural y la percepción sensorial, entre otras habilidades cognitivas. La IA se basa en algoritmos y modelos matemáticos que permiten a las máquinas aprender de los datos, adaptarse a nuevas situaciones y realizar acciones con autonomía. Su objetivo es desarrollar sistemas capaces de imitar e incluso superar las capacidades humanas en ciertos contextos específicos. La IA tiene aplicaciones en una amplia variedad de campos, incluyendo la medicina, la industria, la robótica, los servicios financieros, entre otros, y está en constante evolución con nuevos avances tecnológicos y descubrimientos.

Una de las áreas de aplicación más interesantes de la Inteligencia Artificial es en el campo de la computación de alto rendimiento, donde la capacidad de procesamiento paralelo de las GPU (Unidades de Procesamiento Gráfico) se está utilizando para acelerar el entrenamiento y la inferencia de modelos de aprendizaje automático y redes neuronales profundas.

¿Qué son los LLMs ?

Los LLMs (Large Language Models) son modelos de lenguaje que utilizan inteligencia artificial para comprender y generar texto de manera avanzada. Estos modelos están entrenados con grandes cantidades de datos textuales y son capaces de entender el contexto, la gramática y el significado detrás de las palabras. Pueden realizar tareas como responder preguntas, generar texto coherente y traducir entre idiomas. Los LLMs han avanzado mucho en los últimos años y se utilizan en una variedad de aplicaciones, desde asistentes virtuales hasta análisis de texto y generación de contenido.

¿Qué son los RAGs ?

Los RAGs (Retriever, Aggregator, Generator) son un tipo de modelo de lenguaje que combina técnicas de recuperación de información, agregación y generación de texto para mejorar la capacidad de los modelos de respuesta de preguntas y generación de texto.

  • Retriever (Recuperador): Esta parte del modelo se encarga de buscar y recuperar información relevante de grandes bases de datos o corpus de texto para responder preguntas o generar contenido. Utiliza métodos de recuperación de información para encontrar la información más relevante para la consulta dada.
  • Aggregator (Agregador): Después de recuperar la información relevante, el agregador filtra y combina la información recuperada para generar una respuesta coherente y precisa. Puede sintetizar múltiples fuentes de información para proporcionar una respuesta completa y bien informada.
  • Generator (Generador): Finalmente, el generador utiliza la información recuperada y agregada para generar una respuesta final en forma de texto. Este componente se encarga de producir una respuesta legible y coherente utilizando técnicas de generación de lenguaje natural.

Los RAGs son una forma avanzada de mejorar la capacidad de los modelos de lenguaje para responder preguntas y generar contenido mediante la combinación de diferentes técnicas y enfoques. Este enfoque permite a los modelos abordar preguntas que requieren conocimientos más profundos o información específica más allá de lo que está presente en el entrenamiento inicial.

Añadiendo nodos workers GPU

En nuestro post anterior, vimos cómo añadir nodos a nuestro clúster de Kubernetes. Para ello instalamos en el resto de nodos los componentes necesarios para establecer estos como «workers» o los que soportan la carga de trabajo.

En este caso vamos a configurar un nodo bastante particular. Añadiremos un nodo específico con una unidad de procesamiento gráfico (GPU) para potenciar nuestras cargas de trabajo de aprendizaje profundo, modelos de lenguaje de gran tamaño (LLM’s)  y  RAG (Retrieval-Augmented Generation). Este nodo estará equipado con todas las bibliotecas y dependencias necesarias para ejecutar estas tareas de manera eficiente, incluyendo TensorFlow, PyTorch, y otras librerías esenciales para el desarrollo y despliegue de aplicaciones de inteligencia artificial.

Descripción del Laboratorio

En esta guía, continuación de este post, vamos a utilizar equipos físicos como los nodos participantes de nuestro clúster de Kubernetes. En este laboratorio, prepararemos un escenario en el que necesitaremos el siguiente material:

  • Equipos que funcionarán como nodos con GPU dedicada (NVIDIA RTX 4090)
  • Un cable ethernet por cada nodo
  • Un switch de red o router

Objetivos de la práctica

  • Instalar los componentes del nodo worker GPU
  • Instalar librerías y dependencias de NVIDIA
  • Adopción del nodo worker.
  • Verificar la configuración realizada.

Configuración paso a paso

1. Instalando componentes esenciales para nuestra GPU

Partimos de la base que tenemos el sistema operativo ya funcional, con una red para el clúster configurada y accesible por SSH. Además deberemos tener toda la instalación de nodo worker de Kubernetes que hicimos en el post anterior

Lo primero que haremos será instalar los drivers de nuestra tarjeta gráfica. En nuestro caso es una NVIDIA RTX 4090

apt-get update && apt-get upgrade -y
add-apt-repository ppa:graphics-drivers/ppa
apt-get update && apt-get install -y nvidia-driver-550
export PATH=/usr/local/cuda/bin:${PATH}

A continuación, instalamos CUDA  que son las siglas de Compute Unified Device Architecture (Arquitectura Unificada de Dispositivos de Cómputo). Hace referencia a una plataforma de computación en paralelo que incluye un compilador y un conjunto de herramientas de desarrollo creadas por Nvidia que permiten a los programadores usar una variación del lenguaje de programación C (CUDA C) para codificar algoritmos en GPU de Nvidia.

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
dpkg -i cuda-keyring_1.1-1_all.deb
apt-get update
apt-get -y install cuda-toolkit-12-4
nvidia-smi

Una vez instalado el cuda-toolkit, necesitaremos instalar el kit de herramientas de containers especializado de Nvidia. Primero agregamos el repositorio.

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Actualizamos e instalamos el paquete de herramientas nvidia-container-toolkit

apt-get update && apt-get install -y nvidia-container-toolkit

Seguidamente, necesitaremos agregar el runtime de NVIDIA. Al ejecutar el siguiente comando, procedemos a modificar la configuración de containerd para agregar el runtime de NVIDA propiamente dicho. Luego comprobamos que se haya añadido correctamente esa parte de la configuración en el fichero correspondiente.

nvidia-ctk runtime configure --runtime=containerd
nano /etc/containerd/config.toml

En el fichero se ha debido añadir algo similar a esto:

Reiniciamos el proceso containerd para aplicar los cambios en la configuración ya introducidos.

systemctl restart containerd

2. Instalando los NVIDIA GPU Operator

Kubernetes proporciona acceso a recursos de hardware especiales como GPUs NVIDIA, NICs, adaptadores Infiniband y otros dispositivos a través del framework de plugins de dispositivos. Sin embargo, la configuración y gestión de nodos con estos recursos de hardware requiere la configuración de múltiples componentes de software como controladores, tiempos de ejecución de contenedores u otras bibliotecas, lo que resulta difícil y propenso a errores. NVIDIA GPU Operator utiliza el marco del operador dentro de Kubernetes para automatizar la gestión de todos los componentes de software de NVIDIA necesarios para aprovisionar la GPU. Estos componentes incluyen los controladores NVIDIA (para habilitar CUDA), el plugin de dispositivos Kubernetes para GPUs, el NVIDIA Container Toolkit, el etiquetado automático de nodos mediante GFD, la monitorización basada en DCGM y otros.

Aprovechando la instalación de Helm que vimos en este post, usaremos un chart predefinido para descargarnos el gpu-operator de NVIDIA.

helm install --wait --generate-name \
     -n gpu-operator --create-namespace \
      nvidia/gpu-operator \
      --set driver.enabled=false \
      --set toolkit.enabled=false

Esta instalación, provocará un deployment de Kubernetes llamado gpu-operator en nuestro clúster, que se encargará de instalar, configurar y gestionar de manera apropiada los componentes necesarios para el uso de la GPU en el nodo correspondiente.

2. Verificaciones del correcto funcionamiento

Comprobamos los pods referidos al namespace gpu-operator

kubectl get -n gpu-operator pods

Podemos comprobar como el pod llamado nvidia-cuda-validator ha completado su ejecución de manera satisfactoria, lo que nos indica que el operador ha terminado de instalar todos los componentes necesarios para el uso de la GPU en nuestro clúster de Kubernetes.

Verificamos los recursos disponibles en nuestro nodo-worker con GPU

kubectl describe node nodo-worker-GPU

Visualizamos la disponibilidad del Kind RuntimeClass de NVIDIA en nuestro clúster

kubectl describe runtimeclasses.node.k8s.io

En esta parte, hemos configurado y puesto en funcionamiento nuestro nodo de Kubernetes con todo lo necesario para ejecutar cargas de trabajo en GPU dedicada a tal fin. La integración de una GPU dedicada de NVIDIA en un nodo de Kubernetes no solo representa un avance técnico significativo, sino que también abre un abanico de posibilidades para aplicaciones de Inteligencia Artificial (IA), Computación de Alto Rendimiento (HPC), etc. Al permitir una gestión eficiente de recursos y una escalabilidad dinámica, esta configuración optimizada ofrece un entorno ideal para desplegar cargas de trabajo intensivas en cómputo, mejorando tanto el rendimiento como la velocidad de procesamiento. Además, al aprovechar la potencia de las GPU, las aplicaciones de IA y HPC pueden experimentar mejoras sustanciales en términos de tiempo de entrenamiento, capacidad de análisis y capacidad predictiva. En resumen, la implementación de componentes de GPU de NVIDIA en un entorno de Kubernetes no solo facilita la infraestructura, sino que también impulsa la innovación y el progreso en campos críticos como la IA y la HPC.

En las certificaciones oficiales de Linux Foundation impartidas en loopback0, explicamos en profundidad los diferentes tipos de configuraciones para Kubernetes y sus diferentes aplicaciones.

Kubernetes – Guía para crear nuestro clúster (II)

A pesar de llevar un cierto tiempo usando Kubernetes en producción, ha sido este año cuando hemos comenzado a impartir las formaciones oficiales de la Linux Foundation, haciendo un foco especial en Kubernetes. Podéis comprobar nuestra oferta disponible en el catálogo de productos o en nuestra tienda virtual.

Añadiendo nodos workers

En nuestro primer post, vimos cómo comenzar a crear nuestro clúster de Kubernetes. Para ello instalamos en el primer nodo los componentes necesarios para establecer este nodo como «master» o el nodo que actuará como Plano de Control. Este nodo máster es el encargado de los componentes esenciales para el correcto funcionamiento del clúster. En él se ejecutan los pods de sistema. Los nodos workers son los que ejecutarán la carga de nuestras aplicaciones.

Descripción del Laboratorio

En esta guía, continuación de este post, vamos a utilizar equipos físicos como los nodos participantes de nuestro clúster de Kubernetes. En este laboratorio, prepararemos un escenario en el que necesitaremos el siguiente material:

  • Equipos que funcionarán como nodos (también podemos usar máquinas virtuales en nuestro home-lab)
  • Un cable ethernet por cada nodo
  • Un switch de red o router

Objetivos de la práctica

  • Instalar los componentes del nodo worker.
  • Adopción del nodo worker.
  • Verificar la configuración realizada.

Configuración paso a paso

1. Instalando componentes esenciales: Containerd

Partimos de la base que tenemos el sistema operativo ya funcional, con una red para el clúster configurada y accesible por SSH. Para comenzar el proceso para crear un worker que formará parte del clúster, actualizamos los repositorios e instalamos componentes de manera similar a como hicimos con el nodo máster

apt-get update && apt-get upgrade -y
apt install curl apt-transport-https vim git wget software-properties-common lsb-release ca-certificates -y
swapoff -a
modprobe overlay
modprobe br_netfilter
cat << EOF | tee /etc/sysctl.d/kubernetes.conf
  net.bridge.bridge-nf-call-ip6tables = 1
  net.bridge.bridge-nf-call-iptables = 1
  net.ipv4.ip_forward = 1
  EOF
sysctl --system
mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
apt-get update && apt-get install containerd.io -y
containerd config default | tee /etc/containerd/config.toml
sed -e 's/SystemdCgroup = false/SystemdCgroup = true/g' -i /etc/containerd/config.toml
systemctl restart containerd

2. Instalando Kubernetes

Como ya hicimos en el post anterior, añadimos los repositorios de Kubernetes –> deb http://apt.kubernetes.io/ kubernetes-xenial main y la clave GPG antes de instalar los componentes. Importante tener en cuenta que coincidan las versiones de nodo máster y nodo worker.

nano /etc/apt/sources.list.d/kubernetes.list
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
apt-get update
apt-cache madison kubeadm kubelet kubectl
apt-get install -y kubeadm=1.27.1-00 kubelet=1.27.1-00 kubectl=1.27.1-00
apt-mark hold kubelet kubeadm kubectl

3. Uniendo el worker al clúster

En este punto podríamos copiar y pegar el comando join del nodo master. Necesitamos encontrar el token en el nodo master. Ese comando sólo funciona durante 2 horas, así que construiremos nuestro propio join por si queremos añadir nodos en el futuro. Si ha pasado más tiempo, y no hay ningún token presente podemos generar uno nuevo con el comando sudo kubeadm token create, visto en el siguiente comando.

sudo kubeadm token list
sudo kubeadm token create

Creamos un Discovery Token CA Cert Hash desde el nodo master para asegurar que el nodo worker se une al cluster de forma segura. Ejecutaremos esto en el nodo master (o donde tengamos) una copia del archivo CA. Obtendremos una cadena larga como salida.

openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/ˆ.* //'

En el nodo worker añadiremos un alias DNS local para el nodo master. Editamos el archivo /etc/hosts para añadir la dirección IP del master y le asignamos el nombre k8scp. La entrada debe ser exactamente la misma que la editada en el master.

nano /etc/hosts

Utilizaremos el token y el hash, en este caso como sha256:long-hash para unir al cluster desde el nodo worker. Usaremos la dirección IP privada del nodo master y el puerto 6443. La salida del kubeadm init en el master también tiene un ejemplo para usar, si todavía está disponible.

kubeadm join --token 27eee4.6e66ff60318za928 k8scp:6443 --discovery-token-ca-cert-hash sha256:6d541678b05652e1fa5d43908e75e67376e994c3483d6683f2a18673e5d4c34

Intentamos ejecutar el comando kubectl en el nodo worker. Debería fallar puesto que en el nodo worker no tenemos las claves de cluster o de autenticación en su archivo local .kube/config.

kubectl get nodes
cd ~/
mkdir .kube
cd .kube
scp vitoko@k8scp:/home/vitoko/.kube/config
kubectl get nodes

En esta parte, hemos logrado configurar y poner en funcionamiento nuestro nodo secundario de Kubernetes y también hemos repasado como a instalar y configurar los componentes esenciales de Kubernetes, como kubelet, kubeadm y kubectl.

En la siguiente parte de este tutorial, nos enfocaremos en hacer despliegues de aplicaciones, repasando los conceptos de los diferentes elementos que componen Kubernetes, una vez ya tenemos nuestro cluster funcional

En las certificaciones oficiales de Linux Foundation impartidas en loopback0, explicamos en profundidad los diferentes tipos de configuraciones para Kubernetes y sus diferentes aplicaciones.

Kubernetes – Guía para crear nuestro clúster (I)

A pesar de llevar un cierto tiempo usando Kubernetes en producción, ha sido este año cuando hemos comenzado a impartir las formaciones oficiales de la Linux Foundation, haciendo un foco especial en Kubernetes. Podéis comprobar nuestra oferta disponible en el catálogo de productos o en nuestra tienda virtual.

¿Qué es la Linux Foundation ?

Linux Foundation juega un papel fundamental en el impulso y la promoción del software de código abierto en todo el mundo. Es una organización sin fines de lucro que se dedica a la promoción, el desarrollo y la colaboración en torno al ecosistema de código abierto, con un enfoque particular en el sistema operativo Linux y las tecnologías relacionadas. Fue fundada en 2007 y brinda apoyo a una amplia gama de proyectos de código abierto, proporcionando recursos, financiamiento, infraestructura y gobernanza neutral para fomentar la innovación y el crecimiento de la comunidad de código abierto. Linux Foundation también organiza eventos, ofrece formación y certificaciones (a través de partners como Loopback0), y promueve estándares abiertos para beneficiar a la industria de la tecnología en general.

¿Qué es la Cloud Native Computing Foundation?

CNCF es una organización sin fines de lucro que se enfoca en fomentar y promover tecnologías de computación nativas de la nube y proyectos de código abierto relacionados. Fundada en 2015 como parte de la Linux Foundation, la CNCF brinda un hogar neutral para proyectos de código abierto de gran impacto, proporcionando infraestructura, gobernanza y apoyo técnico para promover la adopción de tecnologías nativas de la nube.

La CNCF es conocida por alojar y mantener proyectos populares como Kubernetes, Prometheus, Envoy, Fluentd, Linkerd y muchos otros.

¿Qué es Kubernetes?

Kubernetes es un proyecto desarrollado por el equipo de ingeniería de Google que básicamente se trata de una plataforma de código abierto diseñada para automatizar, escalar y gestionar aplicaciones en contenedores. Proporciona herramientas para despliegue, escalamiento automático, manejo de recursos y balanceo de carga, facilitando la gestión de aplicaciones en entornos de infraestructura modernos y distribuidos.

Estructura del clúster de Kubernetes

Un clúster de Kubernetes consiste en una serie de nodos que están interconectados en una red y trabajan juntos para ejecutar y gestionar contenedores. Una descripción de los componentes físicos de un clúster de Kubernetes sería:

  1. Nodos:
    • Los nodos son las unidades básicas de cómputo en un clúster de Kubernetes.
    • Cada nodo puede ser una máquina física o virtual en tu infraestructura de hardware.
    • Los nodos ejecutan un sistema operativo compatible con Kubernetes, como Linux.
    • Cada nodo está configurado con software Kubernetes, incluyendo el Kubelet (agente de Kubernetes) y un runtime para la ejecución de contenedores.
    • Los nodos están interconectados en una red y pueden comunicarse entre sí a través de la red de clúster.
  2. Nodos Maestros:
    • Los nodos maestros son un subconjunto de nodos en el clúster que desempeñan un papel especial en la coordinación y el control del clúster.
    • Los nodos maestros alojan componentes como el API Server, el Scheduler, el Controller Manager y el etcd.
    • Estos componentes trabajan juntos para gestionar y orquestar los recursos en el clúster, como desplegar aplicaciones, escalado automático y manejo de fallos.
  3. Nodos de Trabajo:
    • Los nodos de trabajo son los nodos donde se ejecutan las aplicaciones y los contenedores en el clúster.
    • Cada nodo de trabajo ejecuta el Kubelet para comunicarse con la API Server del nodo maestro y gestionar los contenedores en el nodo.
    • Los nodos de trabajo también ejecutan componentes como el Kube Proxy para la gestión de la red entre los contenedores.
  4. Red de Clúster:
    • La red de clúster conecta todos los nodos en el clúster, permitiendo la comunicación entre los nodos y los contenedores.
    • La red de clúster también permite el tráfico de red entre los pods dentro del clúster, facilitando la comunicación entre las aplicaciones distribuidas.

 

En resumen, un clúster de Kubernetes físicamente consiste en nodos interconectados que ejecutan software Kubernetes y trabajan juntos para gestionar y ejecutar aplicaciones en contenedores de manera eficiente y escalable. Los nodos maestros proporcionan la gestión y el control centralizado del clúster, mientras que los nodos de trabajo ejecutan las aplicaciones y los contenedores. La red de clúster facilita la comunicación entre los nodos y los contenedores en el clúster.

 

Descripción del Laboratorio

En esta guía, vamos a utilizar equipos físicos como los nodos participantes de nuestro clúster de Kubernetes. En este laboratorio, prepararemos un escenario en el que necesitaremos el siguiente material:

  • Equipos que funcionarán como nodos (también podemos usar máquinas virtuales en nuestro home-lab)
  • Un cable ethernet por cada nodo
  • Un switch de red o router

Objetivos de la práctica

  • Instalar un entorno de Kubernetes por primera vez
  • Establecer una conexión entre los nodos
  • Verificar la configuración realizada.

Configuración paso a paso

1. Instalar un sistema operativo en cada nodo

Para el primer paso, tendremos que configurar el sistema operativo en todos los nodos. Sin él, los equipos no tiene ningún sistema para arrancar por defecto.

En esta guía vamos a usar la última versión de Ubuntu que la puedes encontrar aquí.

Elige tu pendrive para la instalación y flashealo con el OS correspondiente. Puedes usar la herramienta UnetBootin

2. Habilitar la conexión mediante SSH

Necesitarás configurar SSH para poder configurar remotamente cada nodo y no tener que estar con conectando el monitor, ni teclado, etc cada vez que queramos administrar un nodo. Acuérdate de configurar el fichero /etc/ssh/sshd_config según tus necesidades

sudo useradd vitoko
sudo passwd vitoko
sudo usermod -aG sudo vitoko
sudo apt install openssh-server
sudo systemctl status ssh

Actualizamos los repositorios e instalamos componentes.

apt-get update && apt-get upgrade -y
apt install curl apt-transport-https vim git wget software-properties-common lsb-release ca-certificates -y

3. Configuración de la red y configuraciones iniciales

Necesitarás que tus nodos tengan dirección IP, para hacer esto, comprueba la tabla de asignaciones del DHCP de tu router. Para esto, nosotros hemos utilizado un MikroTik y hemos generado entradas estáticas para cada uno de los nodos.

Importante: Kubernetes Scheduler nos obliga a deshabilitar swap en nuestros nodos. Existen varias maneras de realizarlo pero nosotros lo utilizaremos el siguiente comando:

sudo apt-get update && sudo apt-get install dphys-swapfile && sudo dphys-swapfile swapoff && sudo dphys-swapfile uninstall && sudo systemctl disable dphys-swapfile

Con el comando swapon –show podemos comprobarlo. También con htop vemos que no se están consumiendo recursos en esta parte

También vamos a configurar los módulos que nos aseguran que estén disponibles para los siguientes pasos.

modprobe overlay
modprobe br_netfilter

Actualizamos la parte de red del kernel para permitir el tráfico necesario.

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

Nos aseguramos que los cambios se hayan establecido con sysctl –system

Loguea por SSH en el primer nodo, este será su nodo maestro, que ejecutará el plano de control de su clúster y comenzamos a configurarlo.

3. Configuración inicial de Docker & Kubernetes

Instalamos las claves necesarias para que el software se descargue e instale correctamente

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Instalamos containerd

apt-get update && apt-get install containerd.io -y
containerd config default | tee /etc/containerd/config.toml
sed -e 's/SystemdCgroup = false/SystemdCgroup = true/g' -i /etc/containerd/config.toml
systemctl restart containerd

Añadimos las nuevas repos para kubernetes dentro de nuestras sources –> deb http://apt.kubernetes.io/ kubernetes-xenial main

nano /etc/apt/sources.list.d/kubernetes.list

También puedes descargar un archivo tar o utilizar código de GitHub. Crea el archivo y añade una entrada para el repo principal de tu distribución. Estamos usando Ubuntu 20.04 pero el repo kubernetes-xenial del software, también incluye la palabra clave main.

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg apt-key add -
apt-get update

Ahora ya sí nos apareceran los componentes de kubernetes para poder instalarlos. En este momento, podemos decidir que versión instalar, especificándola con el siguiente comando, por ejemplo: apt-get install -y kubeadm=1.27.1-00 kubelet=1.27.1-00 kubectl=1.27.1-00 Nosotros lo dejamos vacío para instalar la última versión disponible. Con el primer comando comprobamos las versiones disponibles.

apt-cache madison kubeadm kubelet kubectl
apt-get install -y kubeadm kubelet kubectl

Para evitar que los componentes se actualicen con los apt-get update, para guardar la coherencia y tenerlos en todos los nodos con la misma versión, procedemos a bloquear las actualizaciones para estos componentes.

apt-mark hold kubelet kubeadm kubectl

Para poder saber la IP primaria del equipo y asignarle un alias DNS local, utilizamos los siguientes comandos y añadimos a nuestro fichero hosts una entrada en la primera línea que vincule la IP con un nombre significativo. En nuestro caso usaremos k8scp

hostname -i
ip addr show
nano /etc/hosts

4. Despliegues. Comenzando a trabajar con .yaml

En Kubernetes, YAML se utiliza para definir y configurar recursos y objetos del clúster, como pods, servicios, despliegues, configuraciones de red, y más. Los archivos YAML de Kubernetes describen la configuración deseada del clúster, incluidos los detalles de implementación y los parámetros de configuración. Esto permite a los administradores de clústeres y desarrolladores definir y gestionar la infraestructura de Kubernetes de manera declarativa y reproducible.

nano kubeadm-config.yaml

Es muy importante respetar la identación, nuestro archivo debe tener este texto dentro -> kubeadm-config.yaml Importante definir el parámetro con la versión correspondiente.

apiVersion: kubeadm.k8s.io/v1beta3
kind: ClusterConfiguration
kubernetesVersion: 1.27.1
controlPlaneEndpoint: "k8scp:6443"
networking:
  podSubnet: 192.168.0.0/16

Ejecutamos el .yaml para comenzar el despliegue del clúster y aprovechamos para guardar esa salida inicial en un archivo y poder recuperar esa info posteriormente.

kubeadm init --config=kubeadm-config.yaml --upload-certs | tee kubeadm-init.out

Generamos nuestros archivos de configuración, que son los que nos van a permitir la gestión del clúster.

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

4. Instalando nuestra red. Comenzando a trabajar con .yaml

A estas alturas, tenemos que decidir que Container Networking Interface (CNI) vamos a utilizar. Sólo puede haber una red de pods por clúster, aunque el proyecto CNI-Genie está intentando cambiar esto. La red debe permitir comunicaciones contenedor-a-contenedor, pod-a-pod, pod-a-servicio, y externo-a-servicio. Existen varias CNI como Cilium, Calico, Flannel… En este caso, utilizaremos Calico como un plugin de red que nos permitirá utilizar Network Policies más adelante. En futuros posts, haremos una revisión de los diferentes CNI.

Para poder instalar Calico lo más sencillo es tener Helm instalado. Helm es un administrador de paquetes para Kubernetes que simplifica la gestión, instalación y actualización de aplicaciones en clústeres de Kubernetes. Permite empaquetar y compartir fácilmente aplicaciones Kubernetes como «charts», que contienen descripciones de recursos de Kubernetes y configuraciones predefinidas. Helm facilita la gestión de aplicaciones complejas en entornos de Kubernetes mediante la estandarización y automatización de los procesos de implementación y administración.

wget https://get.helm.sh/helm-v3.8.4-linux-amd64.tar.gz
tar -zxvf helm-v3.8.4-linux-amd64.tar.gz
sudo mv linux-amd64/helm /usr/local/bin/helm
helm version

Ahora ya podemos utilizar Helm para instalar Calico.

helm repo add tigera https://charts.tigera.io
helm repo update
helm install calico tigera/calico

Comprobamos que está funcionando con kubectl get pods -n calico-system

En esta parte, hemos logrado configurar y poner en funcionamiento nuestro nodo principal de Kubernetes, además hemos aprendido a instalar y configurar los componentes esenciales de Kubernetes, como kubelet, kubeadm y kubectl. Además, hemos explorado cómo inicializar un clúster de Kubernetes utilizando kubeadm y hemos establecido un nodo maestro listo para recibir conexiones de los nodos de trabajo.

En la siguiente parte de este tutorial, nos enfocaremos en hacer crecer nuestro clúster de Kubernetes agregando nodos de trabajo adicionales. Aprenderemos cómo configurar y unir nuevos nodos al clúster existente y cómo distribuir la carga de trabajo de manera equitativa entre los nodos.

En las certificaciones oficiales de Linux Foundation impartidas en loopback0, explicamos en profundidad los diferentes tipos de configuraciones para Kubernetes y sus diferentes aplicaciones.