Instalación

K8s es simplemente una abreviatura de Kubernetes, donde la "K" es la primera letra, la "s" es la última letra, y el "8" representa las 8 letras intermedias (u, b, e, r, n, e, t, e). Es una forma muy común y rápida de referirse a Kubernetes en la industria.

Kubernetes es una plataforma de orquestación de contenedores open-source desarrollada originalmente por Google y ahora mantenida por la Cloud Native Computing Foundation (CNCF).

Su función principal es automatizar el despliegue, la gestión, el escalado y la operación de aplicaciones en contenedores, normalmente basados en Docker u otros runtimes compatibles.

Características

Despliegue automático de contenedores (por ejemplo, imágenes de Docker).
Escalado automático de aplicaciones (más o menos réplicas de pods según carga).
Balanceo de carga entre pods.
Gestión de la configuración y secretos (ConfigMaps, Secrets).
Recuperación automática: reinicia pods que fallan, reemplaza nodos, etc.
Actualizaciones sin downtime mediante rolling updates.
Orquestación multi-nodo: distribuye contenedores en varios servidores (nodos) de forma eficiente.

Usos

Microservicios distribuidos.
Necesidad de alta disponibilidad.
Aplicaciones que deben escalar horizontalmente.
Infraestructura híbrida (on-premise + cloud).

Instalación

La instalación de Kubernetes (K8s) listo para producción en Debian 12 requiere una planificación y una ejecución cuidadosas. Este documento explica la configuración de un clúster de Kubernetes de tres nodos, que incluye un nodo maestro y dos nodos de trabajo.

Enlaces

Kubernetes

Installing kubeadm | Kubernetes

Debian 12 Bookworm : Kubernetes : Install Kubeadm : Server World (server-world.info)

How to Install Kubernetes Cluster on Debian 12 | 11 (linuxtechi.com)

Entorno

  -----------+---------------------------+---------------------------+------------
             |                           |                           |
       192.168.3.250               192.168.3.251               192.168.3.252
  +----------+-----------+   +-----------+-----------+   +-----------+-----------+
  |[kmaster.dominio.com] |   |[kworker1.dominio.com] |   |[kworker2.dominio.com] |
  |     Control Plane    |   |      Worker Node      |   |      Worker Node      | 
  +----------------------+   +-----------------------+   +-----------------------+

3 x servidores Debian12/ubuntu24.04

Pasos previos

Establecer el nombre del host y actualizar el archivo de hosts

Inicie sesión en cada nodo y configure su nombre de host mediante el comando hostnamectl

sudo hostnamectl set-hostname kmaster    // Run on master node
sudo hostnamectl set-hostname kworker1   // Run on 1st worker node
sudo hostnamectl set-hostname kworker2   // Run on 2nd worker node

Agregue también las siguientes entradas en el archivo '/etc/hosts' en todos los nodos con las IPs y nombre de dominio correspondiente

192.168.3.250  kmaster.k8s.domain.com    kmaster
192.168.3.251  kworker1.k8s.domain.com   kworker1
192.168.3.252  kworker2.k8s.domain.com   kworker2

Actualiza el índice del paquete apt, luego instala los paquetes necesarios para Kubernetes:

sudo apt update && sudo apt upgrade -y
sudo apt install -y apt-transport-https ca-certificates curl gnupg nfs-common

Deshabilitar "swap"

sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

Instalar y configurar Containerd

Primero, configure los parámetros del kernel necesarios para Containerd:

cat <<EOF | sudo tee /etc/modules-load.d/containerd.conf 
overlay 
br_netfilter
EOF

sudo modprobe overlay && sudo modprobe br_netfilter

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

sudo /usr/sbin/sysctl --system

Instala "containerd"

sudo apt -y install containerd

Configurar "containerd" para Kubernetes:

sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml >/dev/null 2>&1
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo sed -i 's/pause:3.6/pause:3.10/' /etc/containerd/config.toml
sudo systemctl restart containerd && sudo systemctl enable containerd

Instalar herramientas de Kubernetes

Descarga la llave pública firmada para los repositorios de Kubernetes. La misma llave firmada es usada para todos los repositorios por lo que se puede obviar la versión en la URL:

Tenga en cuenta la versión de Kubernetes. Reemplace v1.33 con la versión deseada: Releases | Kubernetes

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

Agregar el repositorio apropiado de Kubernetes.

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

Actualiza el índice de apt, luego instala kubectl:

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

Inicializar el clúster

Ejecutar solo en el nodo "maestro"

sudo kubeadm init --pod-network-cidr=10.244.0.0/16

Configurar kubeconfig para el usuario

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

Unir nodos "worker" al clúster

Ejecutar solo en los nodos "worker"

Ejecute el comando "kubeadm join" en cada nodo "worker" (reemplace el token y el hash con los valores reales de la salida de configuración del clúster)

sudo kubeadm join kmaster:6443 --token <your-token> \
    --discovery-token-ca-cert-hash sha256:<your-hash>

Verifica el estado de los nodos

kubectl get nodes

CNI (Container Network Interface)

CNI (Container Network Interface) es un conjunto de especificaciones y bibliotecas que define un estándar para la creación y gestión de redes en contenedores. En el contexto de Kubernetes, CNI se utiliza para gestionar la red de pods dentro de un clúster, proporcionando la conectividad entre los contenedores y permitiendo que se comuniquen entre sí, tanto dentro de un nodo como entre nodos diferentes.

Los plugins CNI son responsables de los siguientes aspectos clave:

Asignación de direcciones IP: Cuando se crea un contenedor (o pod en Kubernetes), el plugin CNI le asigna una dirección IP en la red del clúster. Esta IP es única y permite que los contenedores se comuniquen entre sí.
Conectividad entre contenedores: El plugin CNI asegura que los contenedores en diferentes nodos del clúster puedan comunicarse entre sí, mediante una red virtual o física.
Políticas de red: Los plugins CNI pueden gestionar políticas de red que definen el acceso y la comunicación entre diferentes pods, asegurando que solo los pods autorizados puedan comunicarse entre sí.
Enrutamiento de tráfico: Proporcionan los mecanismos necesarios para enrutar el tráfico entre los pods dentro de un nodo y entre nodos del clúster.
Integración con la infraestructura de red: CNI se integra con la infraestructura subyacente (como las redes físicas o virtuales) para garantizar que la red del clúster se comporte de la manera esperada.

Calico:Calico

Calico es un plugin CNI muy popular que ofrece una solución de red escalable y segura para Kubernetes. Además de proporcionar conectividad entre los pods, también permite aplicar políticas de red para controlar el acceso entre los pods.
Características:
- Conectividad de red de alto rendimiento.
- Políticas de red avanzadas (seguridad).
- Escalabilidad y flexibilidad.
Instalación con Helm:

Debe estar instalada la herramienta HELM. Ejecutar solo en el nodo "maestro"

# Añade el repositorio
helm repo add projectcalico https://docs.tigera.io/calico/charts
helm repo update

# Instalar
helm install calico projectcalico/tigera-operator \
  --version v3.29.3 \
  --namespace tigera-operator \
  --create-namespace

Comprobación:

watch kubectl get pods -n calico-system

Comandos comunes

# Devuelve información del cluster
kubectl cluster-info

# Devuelve el listado de nodos
kubectl get nodes

# Describe un nodo
kubectl describe node <name>

# Devuelve el consumo de recursos de un nodo
kubectl top node <name> 

# Marca un nodo como no planificable
kubectl cordon/uncordon <name>

# Drena todos los pods de un nodo
kubectl drain <name>

Solución de problemas

Resolución DNS

El fichero '/etc/resolv.conf' puede contener opciones adicionales que afecten a la resolución DNS de los Pods generados por kubernetes.

🔍 Pasos para Solucionarlo

✅ 1. Crear un archivo limpio /etc/k8s-resolv.conf

nameserver 1.1.1.1
nameserver 8.8.8.8

✅ 2. Modificar el archivo de configuración del kubelet /var/lib/kubelet/config.yaml

Kubelet usa el archivo /run/systemd/resolve/resolv.conf (generado por systemd-resolved) como plantilla para configurar el DNS en los pods, y ese archivo puede incluir configuraciones que afectan a la resolución DNS

En cada nodo, edita el archivo de configuración del kubelet (/var/lib/kubelet/config.yaml). Cambia la línea

resolvConf: /run/systemd/resolve/resolv.conf por:

 resolvConf: /etc/k8s-resolv.conf

✅ 3. Reinicia Servicios

sudo systemctl restart systemd-resolved kubelet

Metrics Server

Si desea ver el uso de memoria y CPU de sus pods o nodos, puede usar el comando "kubectl top". Sin embargo, si metrics-server no se está ejecutando, recibirá un error como el siguiente.

kubectl top nodes
error: Metrics API not available

El comando para comprobar si metrics-server se está ejecutando o no es:

kubectl get apiservices

🔍 Pasos para Solucionarlo

✅ 1. Verificar si Metrics Server está instalado

kubectl get deployment metrics-server -n kube-system

Si muestra "No resources found", significa que no está instalado.

📌 Solución: Instalar Metrics Server

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

✅ 2. Verificar si Metrics Server está en ejecución

kubectl get pods -n kube-system | grep metrics-server

Debe además, editar la implementación de metrics-server usando el siguiente comando.

kubectl edit deployment metrics-server -n kube-system

containers:
 - args:
 - --cert-dir=/tmp
 - --secure-port=4443 # cambia el puerto
 - --kubelet-insecure-tls # añade está línea

  ports:
  - containerPort: 4443 # cambia el puerto

  hostNetwork: true # añade está línea
  nodeSelector:
    kubernetes.io/os: linux