# Crea tu clúster de Kubernetes en Proxmox Crear un clúster de Kubernetes en Proxmox te permite operar una plataforma de orquestación de contenedores de alto rendimiento en un entorno virtualizado y gestionado por ti. Es ideal para entornos de prueba, flujos de trabajo de desarrollo y CI, así como para escenarios de producción de menor escala. En esta guía aprenderás paso a paso cómo configurar máquinas virtuales en Proxmox y, a partir de ellas, desplegar un clúster de Kubernetes estable. ## Paso 1: comprobar los requisitos previos Antes de empezar con la configuración del clúster de Kubernetes, asegúrate de que tu entorno cumple todos los requisitos técnicos necesarios. Contar con una base inicial limpia te ahorrará tiempo más adelante y evitará errores de configuración innecesarios. En primer lugar, necesitas una instalación funcional de [Proxmox](https://www.ionos.com/es-us/digitalguide/servidores/know-how/proxmox/) VE. Por motivos de rendimiento, se recomienda una [instalación bare metal de Proxmox](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/instalar-proxmox-en-bare-metal/). Tanto el **acceso web** a través de la interfaz de Proxmox como el **acceso SSH** a la línea de comandos deben estar disponibles. Mediante [SSH](https://www.ionos.com/es-us/digitalguide/servidores/herramientas/protocolo-ssh/) podrás ejecutar comandos, subir imágenes y automatizar configuraciones. Para operar un [clúster de Kubernetes](https://www.ionos.com/es-us/digitalguide/servidores/know-how/cluster-kubernetes/) estable, también necesitarás varias [máquinas virtuales](https://www.ionos.com/es-us/digitalguide/servidores/know-how/maquina-virtual/). Se recomienda la siguiente distribución de [nodos de Kubernetes](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/kubernetes-node/): - un nodo maestro (para la denominada control plane) y - al menos dos nodos worker. Esta configuración aporta un cierto grado de redundancia y permite operar [Kubernetes](https://www.ionos.com/es-us/digitalguide/servidores/know-how/que-es-kubernetes/) de forma similar a entornos reales de producción. No obstante, para fines de prueba o desarrollo también puede ser suficiente una configuración más reducida con un nodo maestro y un nodo worker. Además, el host de Proxmox debe disponer de una **interfaz de red tipo bridge** correctamente configurada. Esto permite que las máquinas virtuales accedan a la red local y, si es necesario, a Internet, algo imprescindible para descargar actualizaciones e instalar posteriormente los componentes de Kubernetes. Consejo Para entornos de producción, también es recomendable configurar copias de seguridad periódicas de las máquinas virtuales mediante un [Proxmox Backup Server](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/proxmox-backup-server/). De este modo, podrás restaurar rápidamente los nodos de Kubernetes en caso de fallo y minimizar los tiempos de inactividad. ## Paso 2: descargar la imagen cloud y prepararla como plantilla La instalación de Kubernetes resulta mucho más sencilla con las denominadas **cloud images**. Se trata de imágenes de sistemas operativos preconfiguradas, normalmente Ubuntu o Debian, que están optimizadas para el arranque automático mediante `cloud-init`. En este ejemplo utilizamos una imagen cloud de Ubuntu 22.04 LTS, ya que es estable, está bien documentada y resulta especialmente adecuada para su uso con Kubernetes. En primer lugar, descarga la imagen cloud actual de Ubuntu directamente en tu host de Proxmox. Para ello, inicia sesión por SSH en el servidor Proxmox y cambia al directorio en el que Proxmox almacena los archivos ISO e imágenes: ```bash cd /var/lib/vz/template/iso ``` A continuación, descarga la imagen de Ubuntu con el siguiente comando: ```bash wget -O ubuntu-22.04-server-cloudimg-amd64.img https://cloud-images.ubuntu.com/releases/22.04/release/ubuntu-22.04-server-cloudimg-amd64.img ``` Nota Como alternativa, también puedes descargar la imagen primero en tu equipo local y transferirla después al host de Proxmox mediante `scp` (Secure Copy): ```bash scp ubuntu-22.04-server-cloudimg-amd64.img root@:/var/lib/vz/template/iso/ ``` Una vez que la imagen esté disponible en el host de Proxmox, puedes crear a partir de ella una nueva máquina virtual que más adelante servirá como plantilla. Para ello, crea primero una **VM vacía con un ID único**, por ejemplo 9000, y asígnale recursos de hardware básicos: ```bash qm create 9000 --name ubuntu-template --memory 2048 --net0 virtio,bridge=vmbr0 ``` Ahora importa la imagen cloud descargada previamente **como disco duro virtual en el almacenamiento deseado** (en este ejemplo, `local-lvm`): ```bash qm importdisk 9000 /var/lib/vz/template/iso/ubuntu-22.04-server-cloudimg-amd64.img local-lvm ``` Consejo Si tu clúster de Proxmox utiliza un almacenamiento distribuido, también puedes guardar el disco en Ceph. La integración de [Ceph en Proxmox](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/ceph-en-proxmox/) ofrece una solución de almacenamiento escalable y de alta disponibilidad para las máquinas virtuales de Kubernetes. A continuación, conecta el disco importado a la VM y configura el controlador adecuado. De este modo, la imagen queda vinculada al controlador SCSI virtual de la máquina: ```bash qm set 9000 --scsihw virtio-scsi-pci --scsi0 local-lvm:vm-9000-disk-0 ``` Para poder configurar automáticamente direcciones IP, nombres de host y claves SSH al clonar las VM más adelante, necesitas añadir una unidad Cloud-Init. Esta unidad virtual contiene los datos de configuración que se aplican automáticamente durante el primer arranque de la máquina virtual. Añade la unidad Cloud-Init y define el orden de arranque con los siguientes comandos: ```bash qm set 9000 --ide2 local-lvm:cloudinit qm set 9000 --boot c --bootdisk scsi0 ``` Activa también el [QEMU](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/qemu/) Guest Agent, para que Proxmox pueda **leer información de estado de la VM**, y configura una consola serie que permita acceder directamente a la consola en caso de emergencia: ```bash qm set 9000 --agent 1 qm set 9000 --serial0 socket --vga serial0 ``` Si todo está configurado correctamente, puedes convertir la máquina virtual en una plantilla. En Proxmox, las plantillas sirven como base a partir de la cual puedes crear tantos clones como necesites, lo que las hace ideales para los nodos maestro y worker de Kubernetes: ```bash qm template 9000 ``` Tras completar este paso, dispondrás de una plantilla de Ubuntu lista para crear los nodos de tu clúster de Kubernetes. ## Paso 3: clonar máquinas virtuales para maestro y worker mediante la CLI En este paso crearás, a partir de la plantilla generada anteriormente, las máquinas virtuales que **actuarán como nodos maestro y worker de tu clúster de Kubernetes**. Cada VM recibe su propia dirección IP, un nombre de host único y una clave SSH para un acceso seguro. Proxmox aplica automáticamente la configuración básica mediante `cloud-init`, por lo que no es necesario realizar ajustes manuales dentro de las máquinas virtuales. En primer lugar, clona la plantilla (en este ejemplo, con el ID 9000) y crea **tres máquinas virtuales**: una para el nodo maestro y dos para los nodos worker. Durante el proceso puedes ajustar de forma individual los recursos de [CPU](https://www.ionos.com/es-us/digitalguide/servidores/know-how/cpu/) y [memoria RAM](https://www.ionos.com/es-us/digitalguide/servidores/know-how/que-es-la-memoria-ram/): ```bash qm clone 9000 101 --name k8s-master-1 --full true qm set 101 --cores 2 --memory 4096 qm clone 9000 102 --name k8s-worker-1 --full true qm set 102 --cores 2 --memory 4096 qm clone 9000 103 --name k8s-worker-2 --full true qm set 103 --cores 2 --memory 4096 ``` A continuación, define mediante `cloud-init` la configuración básica de red, el nombre de usuario y la clave SSH. Puedes asignar direcciones IP estáticas o utilizar [DHCP](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/que-es-el-dhcp-y-como-funciona/). En este ejemplo se emplean **direcciones IP estáticas**. ```bash # Configurar el nodo maestro qm set 101 --ipconfig0 ip=192.168.1.10/24,gw=192.168.1.1 qm set 101 --sshkey "$(cat ~/.ssh/id_rsa.pub)" qm set 101 --ciuser ubuntu qm set 101 --nameserver 192.168.1.1 qm set 101 --description "K8s Master 1" # Configurar los nodos worker qm set 102 --ipconfig0 ip=192.168.1.11/24,gw=192.168.1.1 qm set 102 --sshkey "$(cat ~/.ssh/id_rsa.pub)" qm set 102 --ciuser ubuntu qm set 103 --ipconfig0 ip=192.168.1.12/24,gw=192.168.1.1 qm set 103 --sshkey "$(cat ~/.ssh/id_rsa.pub)" qm set 103 --ciuser ubuntu ``` Nota Adapta las direcciones IP de ejemplo a tu propia red. Utiliza direcciones dentro del rango de tu router y asegúrate de que cada VM tenga una IP única que no esté asignada a otro dispositivo. Por último, inicia las tres máquinas virtuales: ```bash qm start 101 qm start 102 qm start 103 ``` Espera unos instantes a que los sistemas arranquen por completo y **comprueba la conexión por SSH**. Por ejemplo, puedes iniciar sesión en el nodo maestro con el siguiente comando: ```none ssh ubuntu@192.168.1.10 ``` ## Paso 4: añadir la configuración básica en todas las máquinas virtuales Antes de instalar Kubernetes en las VM, es necesario aplicar algunos ajustes a nivel de sistema para garantizar un funcionamiento estable. Entre ellos se incluyen la desactivación del swap, la configuración de parámetros del [kernel](https://www.ionos.com/es-us/digitalguide/servidores/know-how/que-es-el-kernel/) relacionados con la red y el reenvío de IP, así como la sincronización de la hora del sistema. Estas medidas son imprescindibles para el correcto funcionamiento de Kubernetes y para garantizar una comunicación de red fiable entre nodos y contenedores. En primer lugar, desactiva el swap en todos los nodos, ya que Kubernetes lo exige para el correcto funcionamiento del scheduler. Además, elimina la entrada correspondiente en `/etc/fstab` para evitar que el swap se reactive tras reiniciar el sistema: ```bash sudo swapoff -a sudo sed -i '/ swap / s/^/#/' /etc/fstab ``` A continuación, configura los parámetros del kernel necesarios para que el tráfico de red pueda procesarse correctamente entre contenedores y nodos. Para ello, crea un archivo de configuración específico y aplica los cambios: ```bash cat <<'EOF' | sudo tee /etc/sysctl.d/k8s.conf net.bridge.bridge-nf-call-iptables = 1 net.ipv4.ip_forward = 1 net.bridge.bridge-nf-call-ip6tables = 1 EOF # Aplicar cambios sudo sysctl --system ``` Otro paso importante es sincronizar la hora del sistema, ya que diferencias de tiempo pueden provocar errores en certificados y en distintos componentes del clúster. Para ello, instala y activa `chrony`: ```bash sudo apt update && sudo apt install -y chrony sudo systemctl enable --now chrony ``` Por último, se recomienda instalar algunas **herramientas auxiliares básicas** que serán necesarias en los pasos posteriores de la configuración: ```bash sudo apt install -y curl apt-transport-https ca-certificates gnupg lsb-release ``` Tras completar estos pasos, todos los nodos quedan preparados de forma uniforme: el swap está desactivado, los ajustes de red están correctamente configurados y la hora del sistema está sincronizada. Las máquinas virtuales ya están listas para instalar Kubernetes y continuar con la creación del clúster. ## Paso 5: elección de la distribución de Kubernetes Antes de comenzar con la instalación de Kubernetes, conviene elegir una **distribución adecuada** en función de tus requisitos y del entorno de uso previsto. En este contexto, hay dos opciones especialmente recomendables: - **RKE2 (Rancher Kubernetes Engine 2)**: RKE2 es una distribución de Kubernetes estable y preparada para producción, desarrollada por Rancher. Resulta especialmente adecuada si más adelante quieres utilizar una gestión gráfica mediante Rancher o si planeas operar un clúster con varios nodos de control plane. - **k3s**: [k3s](https://www.ionos.com/es-us/digitalguide/servidores/know-how/que-es-k3s/) es una distribución de Kubernetes ligera, ideal para entornos de prueba, laboratorios domésticos o sistemas con recursos limitados. Destaca por su instalación sencilla y por requerir menos memoria y CPU que otras distribuciones completas. Para crear un **clúster de Kubernetes robusto en Proxmox**, que también pueda utilizarse en escenarios cercanos a producción, **se recomienda RKE2**. En cambio, si tu objetivo es configurar rápidamente un clúster pequeño para pruebas o desarrollo, k3s suele ser la alternativa más práctica. En el resto de esta guía se utilizará RKE2. ## Paso 6: instalar RKE2 en el nodo maestro Una vez completada la configuración básica de las máquinas virtuales, puedes comenzar con la **instalación de RKE2 en el nodo maestro**. Para ello, inicia sesión por SSH en el nodo maestro: ```bash ssh ubuntu@192.168.1.10 ``` A continuación, descarga y ejecuta el script oficial de instalación de RKE2. De forma opcional, puedes especificar el canal de versión que deseas utilizar: ```bash curl -sfL https://get.rke2.io | sudo INSTALL_RKE2_CHANNEL=v1.28 bash - ``` Una vez finalizada la instalación, habilita el servicio del servidor RKE2 y arráncalo de inmediato: ```bash sudo systemctl enable --now rke2-server.service ``` Comprueba que el servicio se esté ejecutando correctamente con el siguiente comando: ```bash sudo systemctl status rke2-server ``` Para poder administrar el clúster de Kubernetes desde tu equipo local, copia el archivo `kubeconfig` generado por RKE2. Primero, ajusta los permisos del archivo en el nodo maestro y, a continuación, transfiérelo a tu equipo local: ```bash sudo chmod 644 /etc/rancher/rke2/rke2.yaml scp ubuntu@192.168.1.10:/etc/rancher/rke2/rke2.yaml ~/rke2-kubeconfig ``` Después, adapta la dirección IP del nodo maestro en el archivo `kubeconfig` para que `kubectl` pueda conectarse correctamente al servidor de la API de Kubernetes: ```bash sed -i 's/127.0.0.1:6443/192.168.1.10:6443/' ~/rke2-kubeconfig export KUBECONFIG=~/rke2-kubeconfig ``` Si ya tienes `kubectl` instalado en tu equipo local, puedes comprobar si el nodo maestro está accesible y registrado correctamente en el clúster: ```bash kubectl get nodes ``` Si el nodo maestro aparece en la salida, la instalación de RKE2 se ha completado correctamente. En el siguiente paso podrás añadir los nodos worker al clúster. ## Paso 7: instalar el agente de RKE2 en los nodos worker Una vez que el nodo maestro esté configurado correctamente, puedes integrar los nodos worker en el clúster. Para ello, debes instalar **el agente de RKE2 en cada nodo worker** y conectarlo al nodo maestro. En el nodo maestro, obtén primero el **token del clúster**, que se utiliza para autenticar los nodos worker al unirse al clúster: ```bash sudo cat /var/lib/rancher/rke2/server/node-token ``` **Guarda el valor del token**, ya que lo necesitarás en los nodos worker. A continuación, inicia sesión por SSH en uno de los nodos worker (repite el proceso para cada nodo): ```bash ssh ubuntu@192.168.1.11 ``` Descarga el script de instalación de RKE2 e instala el agente con el siguiente comando: ```bash curl -sfL https://get.rke2.io | sudo INSTALL_RKE2_CHANNEL=v1.28 sh - ``` Después, crea el archivo de configuración del agente e introduce la dirección del nodo maestro y el token obtenido previamente: ```bash sudo mkdir -p /etc/rancher/rke2 cat < EOF ``` Por último, habilita e inicia el servicio del agente de RKE2: ```bash sudo systemctl enable --now rke2-agent.service ``` **Repite estos pasos en todos los nodos worker** del clúster. Tras unos minutos, puedes comprobar desde el nodo maestro si los nodos se han unido correctamente: ```bash kubectl get nodes ``` Si todo ha funcionado correctamente, verás el nodo maestro y los nodos worker en el estado `Ready`. Con esto, el clúster de Kubernetes ya está completo y preparado para instalar plugins de red, balanceadores de carga y otros componentes esenciales. ## Paso 8: instalar la CNI de red y el LoadBalancer Una vez que los nodos maestro y worker estén configurados correctamente, necesitas una **Container Network Interface (CNI)** para que los pods del clúster puedan comunicarse entre sí, así como un **LoadBalancer** para exponer los Services en la red. En esta guía utilizamos Calico como CNI y MetalLB para la funcionalidad de [balanceo de carga](https://www.ionos.com/es-us/digitalguide/servidores/know-how/balanceo-de-carga-conoce-a-fondo-sus-ventajas/) de capa 2. Calico se encarga de establecer la conectividad de red entre los pods, asignar direcciones IP y, de forma opcional, aplicar políticas de red. Puedes instalarlo con el siguiente comando: ```bash kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml ``` A continuación, comprueba que los pods de Calico se hayan iniciado correctamente: ```bash kubectl get pods -n kube-system ``` Todos los pods deberían aparecer con el estado `Running` o `Completed`. Si alguno permanece en `Pending`, espera unos minutos, ya que Calico necesita tiempo para desplegar la configuración de red en todos los nodos. Kubernetes admite de forma nativa Services del tipo LoadBalancer, pero en clústeres autoalojados, como los que se ejecutan en Proxmox, es necesario un componente adicional para asignar direcciones IP externas. Para ello se utiliza MetalLB. Instálalo con el siguiente comando: ```bash kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.13.10/config/manifests/metallb-native.yaml ``` Después, crea un **pool de direcciones IP** desde el que MetalLB pueda asignar IP a los Services de tipo LoadBalancer. Ajusta el rango de direcciones a tu red local: ```bash cat <