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).

La implementación de un clúster de Kubernetes listo para producción en Debian 12 requiere una planificación y una ejecución cuidadosas. Esta guía le guiará en la configuración de un clúster de Kubernetes de tres nodos, que incluye un nodo maestro y dos nodos de trabajo.

Instalación

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.1.110               192.168.1.111               192.168.1.112
  +----------+-----------+   +-----------+-----------+   +-----------+-----------+
  |[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.1.110  kmaster.domain.com    kmaster
192.168.1.111  kworker1.domain.com   kworker1
192.168.1.112  kworker2.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

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.32 con la versión deseada: Releases | Kubernetes

curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.32/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.32/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

Implementar una red

En el nodo maestro, implemente Calico:

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/calico.yaml

Verifica el estado de los nodos

kubectl get nodes

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>

Instrucciones 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>

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

Puede utilizar el siguiente comando para instalarlo en su clúster en el espacio de nombres kube-system

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

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
 - --kubelet-insecure-tls

Kubernetes Dashboard UI

Deploy and Access the Kubernetes Dashboard | Kubernetes

Kubernetes Dashboard es una interfaz de usuario de Kubernetes basada en la web. Se puede usar para implementar aplicaciones en contenedores en un clúster de Kubernetes, solucionar problemas de aplicación en contenedores y administrar los recursos del clúster.

Actualmente, Kubernetes Dashboard solo admite la instalación basada en Helm, ya que es más rápido y nos brinda un mejor control sobre todas las dependencias que requiere Dashboard para ejecutarse.

Helm | Installing Helm

Helm tiene un script de instalación que automáticamente descargará la última versión de Helm y la instalará localmente.

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

Desplegando Dashboard UI

# añade el repositorio de kubernetes-dashboard 
helm repo add kubernetes-dashboard https://kubernetes.github.io/dashboard/
# Despliega una versión de Helm Release llamada "kubernetes-dashboard"
helm upgrade --install kubernetes-dashboard kubernetes-dashboard/kubernetes-dashboard --create-namespace --namespace kubernetes-dashboard
# uninstall/delete kubernetes-dashboard
helm delete kubernetes-dashboard

Acceder al panel de control de Kubernetes

Para acceder al panel de control de Kubernetes desde la red externa, deberá exponerlo mediante el método de reenvío de puertos. Ejecute el siguiente comando para exponer el panel de control de Kubernetes:

kubectl port-forward -n kubernetes-dashboard service/kubernetes-dashboard-kong-proxy 10443:443 --address 0.0.0.0 &

Ahora, abre tu navegador web y accede al panel de control de Kubernetes mediante la URL https://server-ip:10443. Se te solicitará que ingreses un token para iniciar sesión. Por lo tanto, necesitaremos crear una cuenta de servicio, un enlace de rol de clúster y un secreto, y luego obtener el token del secreto.

Creando usuario

dashboard/docs/user/access-control/creating-sample-user.md at master · kubernetes/dashboard · GitHub

vi dashboard-adminuser.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard
---
apiVersion: v1
kind: Secret
metadata:
  name: admin-user
  namespace: kubernetes-dashboard
  annotations:
    kubernetes.io/service-account.name: "admin-user"
type: kubernetes.io/service-account-token

kubectl apply -f dashboard-adminuser.yaml

Obtener el token de acceso

kubectl get secret admin-user -n kubernetes-dashboard -o jsonpath={".data.token"} | base64 -d