Cómo configurar un clúster de Kubernetes con Kubeadm en Debian 11
Kubernetes o k8s es una plataforma de código abierto para la orquestación de contenedores que automatiza el despliegue, la gestión y el escalado de las aplicaciones en contenedores. Kubernetes es una orquestación de contenedores creada por Google, y ahora se ha convertido en un proyecto de código abierto y se ha convertido en un estándar para el despliegue de aplicaciones modernas y plataformas informáticas.
Kubernetes es la solución para la era moderna de despliegue de contenedores. Proporciona descubrimiento de servicios y equilibrio de carga, orquestación de almacenamiento, despliegue y retroceso automatizados, servicio de autorreparación, secreto y gestión de la configuración. Kubernetes permite un desarrollo nativo en la nube rentable.
En este tutorial, configurarás el clúster de Kubernetes mediante:
- Configurar los sistemas, lo que incluye: configurar el archivo /etc/hosts, habilitar los módulos del núcleo y deshabilitar el SWAP.
- Configurar el cortafuegos UFW añadiendo algunos puertos necesarios para Kubernetes y el plugin CNI (Calico).
- Instalar CRI-O como tiempo de ejecución de contenedores para Kubernetes.
- Instalar paquetes de Kubernetes como kubelet, kubeadm y kubectl.
- Inicializar un nodo del plano de control y añadir dos nodos trabajadores.
Requisitos previos
Para completar este tutorial, necesitarás los siguientes requisitos:
- Tres o más servidores Debian 11.
- Un usuario no root con privilegios de root/administrador.
Configuración de los sistemas
Antes de empezar a instalar cualquier paquete para el despliegue de Kubernetes, tendrás que configurar todos tus sistemas como se requiere para el despliegue de Kubernetes. Esto incluye las siguientes configuraciones:
- Configurarun archivo /etc/hosts correcto: Cada nombre de host del servidor debe ser resuelto a la dirección IP correcta. Esto puede hacerse de varias maneras, pero la más fácil y sencilla es utilizar el archivo /etc/hosts en todos los servidores.
- Configura el cortafuegos UFW: Para el entorno de producción, siempre se recomienda habilitar el cortafuegos tanto en el plano de control como en los nodos trabajadores. Configurarás un cortafuegos UFW para el plano de control de Kubernetes, el nodo trabajador y el plugin CNI Calico.
- Habilita los Módulos del kernel: Kubernetes requiere que se habiliten algunos módulos del kernel en el sistema Linux. El módulo del kernel «overlay» y «br_netfilter» son necesarios para que iptables pueda ver el tráfico en puente.
- Desactivar SWAP: Esto es obligatorio, debes desactivar SWAP en todos los nodos de Kubernetes, tanto en el plano de control como en los nodos trabajadores. De lo contrario, el servicio kubelet funcionará con problemas.
Configurar el archivo /etc/hosts
En este primer paso, configurarás el nombre de host del sistema y el archivo /etc/hosts en todos tus servidores. Para esta demostración, utilizaremos los siguientes servidores.
Hostname IP Address Used as
--------------------------------------------
k8s-master 192.168.5.10 control-plane
k8s-worker1 192.168.5.115 worker node
k8s-worker2 192.168.5.116 worker node
Ejecuta el siguiente comando hostnamectl para configurar el nombre de host del sistema en cada servidor.
Para el nodo del plano de control, ejecuta el siguiente comando para configurar el nombre de host del sistema como«k8s-master«.
sudo hostnamectl set-hostname k8s-master
Para los nodos trabajadores de Kubernetes, ejecuta el siguiente comando hostnamectl.
# setup hostname k8s-worker1
sudo hostnamectl set-hostname k8s-worker1
# setup hostname k8s-worker2
sudo hostnamectl set-hostname k8s-worker2
A continuación, edita el archivo /etc/hosts en todos los servidores con el siguiente comando.
sudo nano /etc/hosts
Añade la siguiente configuración al archivo. Asegúrate de que cada nombre de host apunta a la dirección IP correcta.
192.168.5.10 k8s-master
192.168.5.115 k8s-worker1
192.168.5.116 k8s-worker2
Guarda y cierra el archivo cuando hayas terminado.
Por último, si ejecutas el comando ping contra cada nombre de host, se apuntará a la dirección IP correcta definida en el archivo /etc/hosts.
ping k8s-master -c3
ping k8s-worker1
ping k8s-worker2 -c3
Configurar el cortafuegos UFW
Kubernetes requiere que algunos puertos estén abiertos en todos tus sistemas. En el sistema Ubuntu por defecto, se utiliza el cortafuegos UFW como firewall por defecto. Instalarás el cortafuegos UFW en todos tus sistemas Debian y añadirás algunas reglas UFW para el despliegue de Kubernetes.
Para el plano de control de Kubernetes, tienes que abrir los siguientes puertos:
Protocol Direction Port Range Purpose Used By
-----------------------------------------------
TCP Inbound 6443 Kubernetes API server All
TCP Inbound 2379-2380 etcd server client API kube-apiserver, etcd
TCP Inbound 10250 Kubelet API Self, Control plane
TCP Inbound 10259 kube-scheduler Self
TCP Inbound 10257 kube-controller-manager Self
Para los nodos trabajadores de Kubernetes, necesitas abrir los siguientes puertos:
Protocol Direction Port Range Purpose Used By
--------------------------------------------------
TCP Inbound 10250 Kubelet API Self, Control plane
TCP Inbound 30000-32767 NodePort Services† All
En este ejemplo, utilizaremos Calico como plugin CNI (Container Network Interface). Por tanto, abrirás algunos puertos adicionales a continuación:
Protocol Direction Port Range Purpose Used By
-------------------------------------------------------
TCP Bidirectional 179 Calico networking (BGP)
UDP Bidirectional 4789 Calico networking with VXLAN enabled
TCP Incoming 2379 etcd datastore
UDP Bidirectional 4789 flannel networking (VXLAN)
Instala el paquete UFW en tus servidores Debian con el siguiente comando apt. Introduce Y para confirmar la instalación y pulsa ENTER, y la instalación comenzará.
sudo apt install ufw
A continuación, añade la aplicación OpenSSH a tu cortafuegos utilizando el siguiente comando. A continuación, activa el cortafuegos UFW. Cuando se te pida la confirmación, introduce «y» para habilitar y ejecutar el cortafuegos UFW.
sudo ufw allow "OpenSSH"
sudo ufw enable
En el nodo del plano de control«k8s-master«, ejecuta el siguiente comando ufw para abrir los puertos. A continuación, comprueba y verifica las reglas UFW.
Reglas del cortafuegos para el plano de control de Kubernetes.
sudo ufw allow 6443/tcp
sudo ufw allow 2379:2380/tcp
sudo ufw allow 10250/tcp
sudo ufw allow 10259/tcp
sudo ufw allow 10257/tcp
Reglas del cortafuegos para el plugin Calico CNI.
sudo ufw allow 179/tcp
sudo ufw allow 4789/udp
sudo ufw allow 4789/tcp
sudo ufw allow 2379/tcp
sudo ufw status
En los nodos trabajadores«k8s-worker1» y«k8s-worker2«, ejecuta el siguiente comando ufw para abrir algunos puertos. A continuación, comprueba las reglas del cortafuegos UFW.
Reglas del cortafuegos para los nodos trabajadores de Kubernetes.
sudo ufw allow 10250/tcp
sudo ufw allow 30000:32767/tcp
Reglas del cortafuegos para Calico en los nodos trabajadores de Kubernetes.
sudo ufw allow 179/tcp
sudo ufw allow 4789/udp
sudo ufw allow 4789/tcp
sudo ufw allow 2379/tcp
sudo ufw status
Habilita los módulos del kernel y desactiva el SWAP
Kubernetes requiere que los módulos del kernel «overlay» y «br_netfilter» estén habilitados en todos los servidores. Esto permitirá a los iptbales ver los tráficos en puente. Además, tendrás que habilitar el reenvío de puertos y desactivar el SWAP.
Ejecuta el siguiente comando para habilitar los módulos del kernel«overlay» y«br_netfilter«.
sudo modprobe overlay
sudo modprobe br_netfilter
Para hacerlo permanente, crea el archivo de configuración en«/etc/modules-load.d/k8s.conf» utilizando el siguiente comando. Esto permitirá a los sistemas Linux habilitar los módulos del núcleo durante el arranque del sistema.
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF
A continuación, crea los parámetros de systemctl necesarios utilizando el siguiente comando.
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward = 1
EOF
Para aplicar la nueva configuración de sysctl sin reiniciar el sistema, utiliza el siguiente comando sysctl. Deberías obtener la lista de parámetros sysctl por defecto en tu sistema y asegurarte de que obtienes los parámetros sysctl que acabas de añadir en el archivo«k8s.conf«.
sudo sysctl --system
Para desactivar el SWAP, tendrás que comentar la configuración del SWAP en el archivo«/etc/fstab«. Esto puede hacerse utilizando el comando único mediante sed (editor de flujos) o editando manualmente el archivo /etc/fstab.
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
o
sudo nano /etc/fstab
A continuación, desactiva el SWAP en la sesión actual utilizando el siguiente comando. A continuación, comprueba que el SWAP está apagado utilizando el comando«free -m«. Deberías ver que el SWAP tiene valores«0», lo que significa que ahora está desactivado.
sudo swapoff -a
free -m
Instalar el tiempo de ejecución del contenedor: CRI-O
Para configurar el Cluster Kubernetes, debes instalar el tiempo de ejecución de contenedores en todos los servidores para que los Pods puedan ejecutarse. Se pueden utilizar varios tiempos de ejecución de contenedores para los despliegues de Kubernetes, como containerd, CRI-O, Mirantis Container Runtime y Docker Engine (mediante cri-dockerd).
En esta demostración, utilizaremos el «CRI-O» como contenedor para nuestro despliegue de Kubernetes. Por tanto, instalarás CRI-O en todos los servidores, en el plano de control y en los nodos trabajadores.
Antes de instalar CRI-O, ejecuta el siguiente comando apt para instalar el paquete básico«gnupg2» y«apt-transport-https«. Introduce Y para confirmar la instalación y pulsa ENTER.
sudo apt install gnupg2 apt-transport-https
Ahora crea una nueva variable de entorno para la instalación de CRI-O. La variable «$OS» con el valor «Debian_11» y la variable «$VERSION» con el valor «1.24». En este ejemplo, instalaremos el contenedor CRI-O v1.24 (versión actual) para los sistemas «Debian_11».
export OS=Debian_11
export VERSION=1.24
Ejecuta el siguiente comando para añadir el repositorio de CRI-O para el sistema Debian 11.
echo "deb [signed-by=/usr/share/keyrings/libcontainers-archive-keyring.gpg] https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/ /" > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
echo "deb [signed-by=/usr/share/keyrings/libcontainers-crio-archive-keyring.gpg] https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/ /" > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.list
Ejecuta el siguiente comando para añadir la clave GPG para el repositorio CRI-O.
mkdir -p /usr/share/keyrings
curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/Release.key | gpg --dearmor -o /usr/share/keyrings/libcontainers-archive-keyring.gpg
curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$VERSION/$OS/Release.key | gpg --dearmor -o /usr/share/keyrings/libcontainers-crio-archive-keyring.gpg
Ahora actualiza los repositorios del sistema y refresca el índice de paquetes con el siguiente comando. Deberías ver que el repositorio CRI-O se ha añadido a los servidores de Debian 11.
sudo apt update
Para instalar el tiempo de ejecución del contenedor CRI-O, ejecuta el siguiente comando apt. Introduce Y para confirmar la instalación y pulsa ENTER, y comenzará la instalación de CRI-O.
sudo apt install cri-o cri-o-runc cri-tools
Una vez finalizada la instalación, edita la configuración de CRI-O «/etc/crio/crio.conf » utilizando el siguiente comando.
sudo nano /etc/crio/crio.conf
En la sección «[crio.network]«, descomenta la opción«network_dir» y la«plugin_dir«.
# The crio.network table containers settings pertaining to the management of
# CNI plugins.
[crio.network]
# The default CNI network name to be selected. If not set or "", then
# CRI-O will pick-up the first one found in network_dir.
# cni_default_network = ""
# Path to the directory where CNI configuration files are located.
network_dir = "/etc/cni/net.d/"
# Paths to directories where CNI plugin binaries are located.
plugin_dirs = [
"/opt/cni/bin/",
]
Cuando hayas terminado, guarda y cierra el archivo.
A continuación, edita la configuración del puente CRI-O«/etc/cni/net.d/100-crio-bridge.conf» utilizando el siguiente comando.
sudo nano /etc/cni/net.d/100-crio-bridge.conf
Cambia la subred por defecto de la dirección IP utilizando tu subred personalizada. Esta dirección IP de subred se utilizará para tus Pods en el clúster de Kubernetes. Además, tendrás que asegurarte de que la dirección IP de la subred coincide con la configuración de la dirección IP en el plugin CNI.
En este ejemplo, utilizaremos la dirección IP de subred«10.42.0.0/24» para los Pods en el clúster de Kubernetes.
...
"ranges": [
[{ "subnet": "10.42.0.0/24" }],
[{ "subnet": "1100:200::/24" }]
]
...
Guarda y cierra el archivo cuando hayas terminado.
A continuación, ejecuta el siguiente comando systemctl para reiniciar el servicio CRI-O y aplicar los nuevos cambios.
sudo systemctl restart crio
Por último, habilita el servicio CRI-O para que se ejecute en el arranque del sistema. A continuación, comprueba y verifica el estado del servicio CRI-O. Deberías ver que el servicio CRI-O está habilitado y el estado actual es de ejecución.
sudo systemctl enable crio
sudo systemctl status crio
Instalación de los paquetes de Kubernetes
Has instalado el tiempo de ejecución del contenedor CRI-O. Ahora vas a instalar los paquetes de Kubernetes en todos tus sistemas Debian. Esto incluye el kubeadm para arrancar el clúster de Kubernetes, el kubelet el componente principal del clúster de Kubernetes, y el kubectl la utilidad de línea de comandos para gestionar el clúster de Kubernetes.
En este ejemplo, instalaremos los paquetes de Kubernetes utilizando el repositorio proporcionado por Kubernetes. Por tanto, añadirás el repositorio de Kubernetes a todos tus sistemas Debian.
Ejecuta el siguiente comando para añadir el repositorio de Kubernetes y la clave GPG.
sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
Actualiza y refresca tu repositorio de Ubuntu y el índice de paquetes.
sudo apt update
Cuando termine la actualización, instala los paquetes de Kubernetes con el siguiente comando apt. Introduce Y para confirmar la instalación y pulsa ENTER para continuar, y la instalación comenzará.
sudo apt install kubelet kubeadm kubectl
Una vez finalizada la instalación, ejecuta el siguiente comando para fijar la versión actual de los paquetes de Kubernetes. Esto evitará que los paquetes de Kubernetes se actualicen automáticamente y evitará el desajuste de versiones entre los paquetes de Kubernetes.
sudo apt-mark hold kubelet kubeadm kubectl
Inicializar el plano de control de Kubernetes
Has finalizado todas las dependencias y requisitos para desplegar el Cluster de Kubernetes. Ahora vas a iniciar el Cluster de Kubernetes inicializando el nodo del Plano de Control por primera vez. En este ejemplo, el Plano de Control de Kubernetes se instalará en el servidor «k8s-master» con la dirección IP «192.168.5.10».
Antes de inicializar el nodo del Plano de Control, ejecuta el siguiente comando para comprobar que los módulos del kernel «br_netfilter» están habilitados. Si obtienes una salida del comando, significa que el módulo «br_netfilter» está habilitado.
lsmod | grep br_netfilter
A continuación, ejecuta el siguiente comando para descargar las imágenes necesarias para el clúster de Kubernetes. Este comando descargará todas las imágenes de contenedor necesarias para crear el Clúster Kubernetes, como coredns, kube-api server, etcd, kube-controller, kube-proxy y la imagen de contenedor de pausa.
sudo kubeadm config images pull
Una vez finalizada la descarga, ejecuta el comando«crictl» que aparece a continuación para comprobar la lista de imágenes disponibles en el servidor «k8s-master». Deberías ver la lista de imágenes que se utilizarán para crear el clúster de Kubernetes.
sudo crictl images
A continuación, ejecuta el siguiente comando «kubeadm init» para inicializar el clúster de Kubernetes en el servidor «k8s-master». Este nodo «k8s-master» se seleccionará automáticamente como Plano de Control de Kubernetes porque es la primera vez que se inicializa el clúster.
Además, en este ejemplo, especificamos la red para los Pods a«10.42.0.0/24«, que es la misma subred que la configuración del puente CRI-O «/etc/cni/net.d/100-crio-bridge.conf».
La opción«–apiserver-advertise-address» determina en qué dirección IP se ejecutará el servidor de la API de Kubernetes, en este ejemplo se utiliza la dirección IP interna«192.168.5.10«.
Para la opción «–cri-socket» aquí especificamos el socket CRI al socket de tiempo de ejecución del contenedor CRI-O que está disponible en«/var/run/crio/crio.sock«. Si utilizas un tiempo de ejecución del contenedor diferente, debes cambiar la ruta del archivo del socket, o simplemente puedes eliminar esta opción «–cri-socket» porque el kubeadm detectará el socket del tiempo de ejecución del contenedor automáticamente.
sudo kubeadm init --pod-network-cidr=10.42.0.0/24 \
--apiserver-advertise-address=192.168.5.10 \
--cri-socket=unix:///var/run/crio/crio.sock
A continuación se muestra la salida cuando se inicializa el Cluster Kubernetes en el servidor«k8s-master «.
Cuando la inicialización haya terminado, podrás ver el mensaje «¡Tu plano de control de Kubernetes se ha inicializado con éxito!» con algunos mensajes de salida importantes para configurar las credenciales de Kubernetes y desplegar el complemento de red Pod, la forma de añadir el nodo trabajador a tu Cluster Kubernetes.
Antes de empezar a gestionar el clúster de Kubernetes con la herramienta «kubectl», tendrás que configurar las credenciales de Kubernetes. Ejecuta el siguiente comando para configurar las credenciales de Kubernetes.
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
Ahora puedes utilizar el comando «kubectl» para interactuar con tu clúster de Kubernetes. Ejecuta el siguiente comando «kubectl» para comprobar la información del clúster de Kubernetes. Y deberías ver el plano de control de Kubernetes y los coredns en funcionamiento.
kubectl cluster-info
Para obtener toda la información sobre tu Kubernetes, puedes utilizar la opción dump – así«kubectl cluster-info dump«.
Una vez que el Kubernetes esté en marcha, configurarás el plugin CNI de Calico para tu clúster de Kubernetes. Ejecuta el siguiente comando para descargar el archivo de manifiesto de Calico«calico.yaml«. A continuación, edita el archivo «calico.yaml» con el editor nano.
curl https://docs.projectcalico.org/manifests/calico.yaml -O
nano calico.yaml
Descomenta la configuración«CALICO_IPV4POOL_CIDR» y cambia la subred de red a«10.42.0.0/24«. Esta configuración de subred debe ser la misma subred que en la configuración del puente CRI-O y la configuración «–pod-network-cidr» durante la inicialización de Kubernetes mediante el comando «kubeadm init».
...
- name: CALICO_IPV4POOL_CIDR
value: "10.42.0.0/24"
...
Cuando hayas terminado, guarda y cierra el archivo.
A continuación, ejecuta el comando «kubectl» que aparece a continuación para desplegar el plugin CNI de Calico con el archivo de manifiesto personalizado «calico.yaml». Este comando creará varios recursos Kubernetes para el plugin Calico CNI. Además, esto descargará las imágenes de Calico y creará nuevos Pods para Calico.
sudo kubectl apply -f calico.yml
Ahora ejecuta el siguiente comando kubectl para comprobar los Pods disponibles en tu clúster de Kubernetes. Deberías ver dos Pods adicionales el «calico-node-xxx» y el «calico-kube-controller-xxx».
kubectl get pods --all-namespaces
Añadir nodos trabajadores a Kubernetes
Tras inicializar el Plano de Control de Kubernetes en el servidor «k8s-master», añadirás los nodos trabajadores«k8s-worker1» y«k8s-worker2» al Cluster de Kubernetes.
Ve al servidor «k8s-worker1» y ejecuta el siguiente comando«kubeadm join» para añadir el«k8s-worker1» al Cluster de Kubernetes. Es posible que tengas un token y un ca-cert-hash diferentes, puedes ver los detalles de esta información en el mensaje de salida al inicializar el nodo del Plano de Control.
kubeadm join 192.168.5.10:6443 --token dbgk8h.nwzqqp1v5aqif5fy \
--discovery-token-ca-cert-hash sha256:7a543a545585358b143ce3e8633a8d673b6f628c5abc995939a58606c6dd219c
En la siguiente salida, puedes ver que el servidor«k8s-worker1» se ha unido al Clúster Kubernetes.
A continuación, pasa al servidor «k8s-worker2» y ejecuta el comando«kubeadm join» para añadir el«k8s-worker2» al Cluster de Kubernetes.
kubeadm join 192.168.5.10:6443 --token dbgk8h.nwzqqp1v5aqif5fy \
--discovery-token-ca-cert-hash sha256:7a543a545585358b143ce3e8633a8d673b6f628c5abc995939a58606c6dd219c
Verás el mismo mensaje de salida cuando termine el proceso.
Ahora vuelve al servidor del Plano de Control «k8s-master» y ejecuta el siguiente comando para comprobar todos los pods en ejecución en el Cluster de Kubernetes. Deberías ver que hay pods adicionales para cada componente de Kubernetes.
kubectl get pods --all-namespaces
o
kubectl get pods -o wide --all-namespaces
Por último, comprueba y verifica todos los nodos disponibles en el Cluster de Kubernetes utilizando el comando ‘kubectl» que aparece a continuación. Deberías ver que el servidor «cplane1» se está ejecutando como Plano de Control de Kubernetes, y que los servidores «k8s-worker1» y «k8s-worker2» se están ejecutando como nodo trabajador.
kubectl get nodes -o wide
Despliegue de Nginx Pod en el clúster de Kubernetes
Ejecuta el siguiente comando para crear un nuevo despliegue para el servidor web Nginx. En este ejemplo, crearemos nuevos Nginx Pods basados en la imagen«nginx:alpine» con dos réplicas.
kubectl create deployment nginx --image=nginx:alpine --replicas=2
Ahora crea un nuevo servicio de tipo«NodePort» que expondrá el despliegue de Nginx utilizando el siguiente comando kubectl. Este comando creará un nuevo servicio de Kubernetes llamado «nginx» con el tipo «NodePort» y expondrá el puerto«80» para el Pod.
kubectl create service nodeport nginx --tcp=80:80
A continuación, ejecuta el siguiente comando kubectl para comprobar la lista de pods en ejecución en tu clúster de Kubernetes. Y deberías ver dos pods de Nginx en ejecución.
kubectl get pods
Ahora comprueba la lista de servicios disponibles en Kubernetes con el siguiente comando. Deberías ver el servicio«nginx» de tipo NodePort expuesto al puerto«80» y al puerto «31277» en los hosts de Kubernetes. El servicio NodePort siempre expondrá el puerto entre el rango 30000-32767.
kubectl get svc
Ejecuta el siguiente comando curl para acceder a tu implementación de Nginx.
curl k8s-worker1:31277
curl k8s-worker2:31277
A continuación se muestra la salida del código fuente index.html del nodo«k8s-worker1«.
Y a continuación el código index.html del nodo «k8s-worker2«.
Conclusión
A lo largo de este tutorial, has finalizado el despliegue del Cluster Kubernetes con tres nodos y servidores Debian 11. El Cluster de Kubernetes se está ejecutando con un plano de control y dos nodos trabajadores. Se está ejecutando con el CRI-O como Container Runtime para tu Cluster de Kubernetes, y el plugin Calico CNI para la conexión en red de los Pods en tu cluster. Además, has desplegado con éxito el servidor web Nginx dentro del Clúster Kubernetes.
Has configurado completamente el Cluster de Kubernetes, puedes empezar a desplegar tus aplicaciones en el Cluster de Kubernetes o intentar instalar el Dashboard de Kubernetes para saber más sobre tu entorno de Kubernetes.