Cómo iniciar un clúster de Kubernetes desde cero con Kubeadm y Kubectl

Kubernetes tiene fama de ser complejo, pero las versiones modernas son relativamente sencillas de configurar. La herramienta oficial de administración de clústeres Kubeadm proporciona una experiencia automatizada para iniciar su plano de control y registrar nodos de trabajo.

Este artículo lo guiará a través de la configuración de un clúster de Kubernetes simple usando la configuración predeterminada. Esta es una guía "desde cero" que debería funcionar en un host recién aprovisionado. Se asume un sistema basado en Debian, pero puede ajustar la mayoría de los comandos para que coincidan con el administrador de paquetes de su sistema operativo. Estos pasos se probaron con Ubuntu 22.04 y Kubernetes v1.25.

→ Índice de contenidos

Instalación de un tiempo de ejecución de contenedor
Instalación de Kubeadm, Kubectl y Kubelet
Deshabilitar el intercambio
Cargando el módulo br_netfilter
Creación de su clúster
Preparando su archivo Kubeconfig
Instalación de un complemento de red de pod
Interactuando con su clúster
Agregar otro nodo
Resumen

Instalación de un tiempo de ejecución de contenedor

Kubernetes necesita un tiempo de ejecución de contenedor compatible con CRI para iniciar y ejecutar sus contenedores. La distribución estándar de Kubernetes no incluye un tiempo de ejecución, por lo que debe instalar uno antes de continuar. containerd es la opción más popular. Es el tiempo de ejecución incluido con las versiones modernas de Docker.

Puede instalar containerd utilizando el repositorio Apt de Docker. Primero agregue algunas dependencias que se utilizarán durante el procedimiento de instalación:

$ sudo apt update
$ sudo apt install -y 
   ca-certificates 
   curl 
   gnupg 
   lsb-release

A continuación, agregue la clave GPG del repositorio a la de Apt. keyrings directorio:

$ sudo mkdir -p /etc/apt/keyrings
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Ahora puede agregar el repositorio correcto para su sistema ejecutando este comando:

$ 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

Actualice su lista de paquetes para incluir el contenido del repositorio de Docker:

$ sudo apt update

Finalmente instale containerd:

$ sudo apt install -y containerd.io

Verifique que el servicio containerd se haya iniciado:

$ sudo service containerd status
 containerd.service - containerd container runtime
     Loaded: loaded (/lib/systemd/system/containerd.service; enabled; vendor preset: enabled)
     Active: active (running) since Tue 2022-09-13 16:50:12 BST; 6s ago

Se requieren algunos ajustes en el archivo de configuración del contenedor para que funcione correctamente con Kubernetes. Primero reemplace el contenido del archivo con la configuración predeterminada de containerd:

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

Esto completa todos los campos de configuración disponibles y soluciona algunos problemas, como la desactivación de la compatibilidad con CRI en instalaciones nuevas.

Siguiente abierto /etc/containerd/config.toml y busca la siguiente línea:

SystemdCgroup = false

Cambia el valor a true:

SystemdCgroup = true

Esta modificación es necesaria para habilitar el soporte completo para systemd cgestión de grupos. Sin esta opción, los contenedores del sistema de Kubernetes se reiniciarán periódicamente.

Reinicie containerd para aplicar sus cambios:

$ sudo service containerd restart

Instalación de Kubeadm, Kubectl y Kubelet

La segunda fase del proceso es instalar las herramientas de Kubernetes. Estas tres utilidades proporcionan las siguientes capacidades:

Kubeadm - Una herramienta de administración que opera a nivel de clúster. Lo usará para crear su clúster y agregar nodos adicionales.
Kubectl - Kubectl es la CLI que usa para interactuar con su clúster de Kubernetes una vez que se está ejecutando.
Kubelet - Este es el proceso de Kubernetes que se ejecuta en los nodos trabajadores de su clúster. Es responsable de mantener contacto con el avión de control y de iniciar nuevos contenedores cuando se le solicite.

Los tres binarios están disponibles en un repositorio de Apt alojado en Google Cloud. Primero registre el llavero GPG del repositorio:

$ sudo curl -fsSLo /etc/apt/keyrings/kubernetes.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg

A continuación, agregue el repositorio a sus fuentes...

$ echo "deb [signed-by=/etc/apt/keyrings/kubernetes.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

… Y actualice su lista de paquetes:

$ sudo apt update

Ahora instale los paquetes:

$ sudo apt install -y kubeadm kubectl kubelet

Es una buena práctica "retener" estos paquetes para que Apt no los actualice automáticamente cuando ejecute apt upgrade. Las actualizaciones del clúster de Kubernetes deben iniciarse manualmente para evitar el tiempo de inactividad y evitar cambios importantes no deseados.

$ sudo apt-mark hold kubeadm kubectl kubelet

Deshabilitar el intercambio

Kubernetes no funciona cuando el intercambio está habilitado. Debe desactivar el intercambio antes de crear su clúster. De lo contrario, encontrará que el proceso de aprovisionamiento se bloquea mientras espera que se inicie Kubelet.

Ejecute este comando para deshabilitar el intercambio:

$ sudo swapoff -a

A continuación, edite su /etc/fstab archivo y deshabilite cualquier montaje de intercambio:

UUID=ec6efe91-5d34-4c80-b59c-cafe89cc6cb2 /               ext4    errors=remount-ro 0       1
/swapfile                                 none            swap    sw              0       0

Este archivo muestra un montaje con el swap escriba como la última línea. Debe eliminarse o comentarse para que el intercambio permanezca deshabilitado después de reiniciar el sistema.

Cargando el módulo br_netfilter

los br_netfilter Se requiere el módulo kernel para permitir que iptables vea el tráfico puenteado. Kubeadm no le permitirá crear su clúster cuando falte este módulo.

Puede habilitarlo con el siguiente comando:

$ sudo modprobe br_netfilter

Haga que persista después de un reinicio incluyéndolo en la lista de módulos de su sistema:

$ echo br_netfilter | sudo tee /etc/modules-load.d/kubernetes.conf

Creación de su clúster

Está listo para crear su clúster de Kubernetes. Correr kubeadm init en la máquina que desea alojar su plano de control:

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

los --pod-network-cidr se incluye una marca para que haya una asignación de CIDR correcta disponible para el complemento de red Pod que se instalará más adelante. El valor predeterminado de 10.244.0.0/16 funciona en la mayoría de los casos, pero es posible que deba cambiar el rango si está utilizando un entorno de red muy personalizado.

La creación del clúster puede tardar varios minutos en completarse. La información de progreso se mostrará en su terminal. Debería ver este mensaje en caso de éxito:

Your Kubernetes control-plane has initialized successfully!

El resultado también incluye información sobre cómo comenzar a usar su clúster.

Preparando su archivo Kubeconfig

Comience copiando el archivo Kubeconfig generado automáticamente en el suyo propio. .kube/config directorio. Ajuste la propiedad del archivo a usted mismo para que Kubectl pueda leer su contenido correctamente.

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

Instalación de un complemento de red de pod

Kubernetes requiere que exista un complemento de redes Pod en su clúster antes de que los nodos de trabajo comiencen a funcionar normalmente. Debe instalar manualmente un complemento compatible para completar su instalación.

Calico y Flannel son las dos opciones más populares. Esta guía utiliza Flannel debido a su sencilla experiencia de instalación.

Use Kubectl para agregar Flannel a su clúster:

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

Espere unos momentos y luego ejecute kubectl get nodes en tu terminal. Debería ver su Nodo muestra como Ready y puede comenzar a interactuar con su clúster.

$ kubectl get nodes
NAME       STATUS   ROLES           AGE     VERSION
ubuntu22   Ready    control-plane   7m19s   v1.25.0

Si tu corres kubectl get pods --all-namespacesdebería ver que los componentes del plano de control, CoreDNS y Flannel están todos en funcionamiento:

$ kubectl get pods --all-namespaces
NAMESPACE      NAME                               READY   STATUS    RESTARTS        AGE
kube-flannel   kube-flannel-ds-xlrk6              1/1     Running   5 (16s ago)     11m
kube-system    coredns-565d847f94-bzzkf           1/1     Running   5 (2m9s ago)    14m
kube-system    coredns-565d847f94-njrdc           1/1     Running   4 (30s ago)     14m
kube-system    etcd-ubuntu22                      1/1     Running   6 (113s ago)    13m
kube-system    kube-apiserver-ubuntu22            1/1     Running   5 (30s ago)     16m
kube-system    kube-controller-manager-ubuntu22   1/1     Running   7 (3m59s ago)   13m
kube-system    kube-proxy-r9g9k                   1/1     Running   8 (21s ago)     14m
kube-system    kube-scheduler-ubuntu22            1/1     Running   7 (30s ago)     15m

Interactuando con su clúster

Ahora puede comenzar a usar Kubectl para interactuar con su clúster. Antes de continuar, elimine la mancha predeterminada en su nodo del plano de control para permitir que los pods se programen en él. Kubernetes evita que los pods se ejecuten en el nodo del plano de control para evitar la contención de recursos, pero esta restricción no es necesaria para el uso local.

$ kubectl taint node ubuntu22 node-role.kubernetes.io/control-plane:NoSchedule-
node/ubuntu22 untainted

Reemplazar ubuntu22 en el comando anterior con el nombre asignado a su propio nodo.

Ahora intente iniciar un NGINX Pod simple:

$ kubectl run nginx --image nginx:latest
pod/nginx created

Expóngalo con un servicio NodePort:

$ kubectl expose pod/nginx --port 80 --type NodePort
service/nginx exposed

Encuentre el puerto de host que se asignó al servicio:

$ kubectl get services
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        18m
nginx        NodePort    10.106.44.155   <none>        80:30647/TCP   27s

el puerto es 30647. Las solicitudes HTTP a este punto final ahora deberían emitir la página de destino NGINX predeterminada en respuesta:

$ curl http://localhost:30647
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>

¡Su clúster de Kubernetes está funcionando!

Agregar otro nodo

Para configurar nodos trabajadores adicionales, primero repita todos los pasos en las secciones hasta "Creación de su clúster" en cada máquina que desee usar. Cada nodo necesitará la instalación de containerd, Kubeadm y Kubelet. También debe verificar que su nodo tenga conectividad de red completa con la máquina que ejecuta su plano de control.

A continuación, ejecute el siguiente comando en su nuevo nodo trabajador:

kubeadm join 192.168.122.229:6443 
    --node-name node-b 
    --token <token> 
    --discovery-token-ca-cert-hash sha256:<token-ca-cert-hash>

Reemplace la dirección IP con la de su nodo del plano de control. los valores de <token> y <token-ca-cert-hash> se habrá mostrado cuando ejecutó kubeadm init para crear su plano de control. Puede recuperarlos siguiendo los siguientes pasos.

Simbólico

Correr kubeadm token list en el nodo del plano de control. El valor del token se mostrará en el TOKEN columna.

$ kubeadm token list
TOKEN                     TTL         EXPIRES                USAGES                   DESCRIPTION                                                EXTRA GROUPS
lkoz6v.cw1e01ckz2yqvw4u   23h         2022-09-14T19:35:03Z   authentication,signing

Token de hash de certificado de CA

Ejecute este comando y use su salida como el valor:

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

Unirse al Clúster

los kubeadm join el comando debe producir esta salida si tiene éxito:

$ kubeadm join 192.168.122.229:6443 
    --node-name node-b 
    --token <token> 
    --discovery-token-ca-cert-hash sha256:<token-ca-cert-hash>
[kubelet-start] Starting the kubelet[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

Verifique que el nodo se haya unido al clúster y esté listo para recibir Pods ejecutando el kubectl get nodes dominio:

$ kubectl get nodes
NAME       STATUS   ROLES           AGE    VERSION
node-b     Ready    <none>          91s    v1.25.0
ubuntu22   Ready    control-plane   100m   v1.25.0

El nodo aparece en la lista y tiene Ready como su estado. Esto significa que está operativo y Kubernetes puede programar Pods para él.

Resumen

Configurar Kubernetes puede parecer desalentador, pero Kubeadm automatiza la mayoría de las partes difíciles por usted. Aunque todavía hay varios pasos por recorrer, no debería tener problemas si se asegura de que se cumplan los requisitos previos antes de comenzar.

La mayoría de los problemas ocurren porque no hay tiempo de ejecución del contenedor disponible, el br_netfilter falta el módulo del kernel, el intercambio está habilitado o se ha pasado por alto la necesidad de proporcionar un complemento de red Pod. La solución de problemas debe comenzar comprobando estos errores comunes.

Kubeadm le ofrece la última versión de Kubernetes directamente desde el propio proyecto. Hay distribuciones alternativas disponibles que le permiten iniciar un clúster de un solo nodo con un solo comando. Minikube, MicroK8s y K3s son tres opciones populares. Aunque estos suelen ser más fáciles de configurar y actualizar, todos tienen ligeras diferencias en comparación con Kubernetes ascendente. El uso de Kubeadm lo acerca al funcionamiento interno de Kubernetes y es aplicable a muchos entornos diferentes.