Guía de instalación K8s + KubeVirt en Ubuntu 24.04

0. Ejemplo de configuración de red (Netplan)

Aquí defines cómo se conectará tu servidor físicamente a la red: enlaces redundantes (bonding), VLANs para separar tráfico y bridges para que las máquinas virtuales y pods se conecten a varias redes internas. Es la base para un clúster flexible y segmentado.

Archivo: /etc/netplan/50-cloud-init.yaml

network:
  version: 2
  ethernets:
    enp2s0f0np0: {}
    enp2s0f1np1: {}
  bonds:
    bond0:
      interfaces:
        - enp2s0f0np0
        - enp2s0f1np1
      parameters:
        mode: "802.3ad"
        lacp-rate: "fast"
        transmit-hash-policy: "layer3+4"
  vlans:
    bond0.20:
      id: 20
      link: bond0
      dhcp4: no
    bond0.30:
      id: 30
      link: bond0
      addresses:
        - "192.168.3.4/24"
    bond0.40:
      id: 40
      link: bond0
      addresses:
        - "192.168.4.4/24"
  bridges:
    br0:
      interfaces:
        - bond0
      addresses:
        - "192.168.1.14/24"
      nameservers:
        addresses:
          - 192.168.1.1
          - 1.1.1.1
          - 8.8.8.8
      routes:
        - to: "default"
          via: "192.168.1.1"
      parameters:
        stp: false
        forward-delay: 0
    br-servicios:
      interfaces:
        - bond0.20
      addresses:
        - 192.168.200.4/22
      parameters:
        stp: false
        forward-delay: 0

No olvides aplicar cambios con: sudo netplan apply

---

1. Prerrequisitos del sistema

Hay que partir de un Ubuntu 24.04 actualizado y con permisos de administrador. En este paso instalamos utilidades básicas y configuramos el repositorio oficial de Kubernetes, necesario para instalar sus componentes más adelante.

a) Actualiza el sistema y paquetes básicos

sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gnupg

b) Añade el repositorio oficial de 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
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
sudo chmod 644 /etc/apt/keyrings/kubernetes-apt-keyring.gpg
sudo chmod 644 /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update

---

2. Desactiva SWAP (requisito Kubernetes)

Kubernetes requiere que el intercambio de memoria (swap) esté desactivado para gestionar los recursos de forma predecible y evitar problemas de rendimiento y estabilidad.

sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

---

3. Instala containerd (runtime recomendado)

containerd es el motor que gestiona los contenedores en el clúster. Kubernetes necesita un “runtime” para crear y controlar los pods, y containerd es la opción oficial y más estable.

sudo apt-get install -y containerd
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd
sudo systemctl enable containerd

---

4. Prepara el kernel y sysctl

En este paso se habilitan módulos y parámetros de red necesarios para que Kubernetes gestione correctamente el tráfico entre pods y nodos.

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

---

5. Instala kubeadm, kubelet, kubectl

Aquí se instalan los tres componentes esenciales de Kubernetes:

• kubelet: agente que corre en cada nodo y gestiona los pods
• kubeadm: herramienta para iniciar y gestionar el clúster
• kubectl: cliente de línea de comandos para operar el clúster

sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

---

6. Inicializa el clúster (mononodo/laboratorio)

Este paso crea el clúster de Kubernetes en el nodo principal (control-plane). Aquí defines la red interna para los pods.

Si usas Flannel, usa este parámetro:

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

---

a) Configura kubectl para tu usuario

Permite usar el comando kubectl como usuario normal copiando la configuración de administración del clúster a tu carpeta personal.

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

---

7. Instala la red de pods (Flannel)

Kubernetes solo define la infraestructura; necesitas un complemento de red (CNI) para que los pods puedan comunicarse entre sí. Flannel es la opción más sencilla y compatible.

kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

---

8. Instala Multus (opcional, para múltiples redes)

Multus permite que un pod tenga más de una interfaz de red, útil para aplicaciones avanzadas (firewalls, balanceadores, appliances virtuales). Instálalo solo si necesitas múltiples redes.

kubectl apply -f https://raw.githubusercontent.com/k8snetworkplumbingwg/multus-cni/master/deployments/multus-daemonset.yml

• Verifica:

  kubectl get pods -n kube-system | grep multus
  

---

9. (Opcional) Quita el taint del nodo master para poder programar pods en él

Por defecto, Kubernetes no programa pods de usuario en el nodo principal (control-plane). Si tienes solo un nodo (laboratorio), elimina este bloqueo para poder desplegar aplicaciones ahí.

kubectl taint nodes --all node-role.kubernetes.io/control-plane-
kubectl taint nodes --all node-role.kubernetes.io/master-

---

10. Test rápido de Multus

Aquí puedes comprobar que Multus funciona: se crea una red secundaria y un pod de prueba que recibe dos interfaces (una para la red de pods y otra para la red adicional configurada).

La carpeta multus/ del repositorio contiene el NAD y el pod de prueba:

• multus/nad-br-servicios.yaml (NetworkAttachmentDefinition)
• multus/test-multus-pod.yaml (pod alpine)

Despliega la NAD:

kubectl apply -f multus/nad-br-servicios.yaml

Despliega el pod de test:

kubectl apply -f multus/test-multus-pod.yaml

Comprueba las interfaces:

kubectl exec -it multus-test -- sh
ip a

El pod debería tener una interfaz extra de la red br-servicios además de la de Flannel.

Para limpiar:

kubectl delete pod multus-test

---

11. Instalación y configuración de MetalLB (LoadBalancer local)

MetalLB permite a tu clúster on-premise asignar IPs flotantes de tu red LAN a servicios tipo LoadBalancer, igual que hacen los clústeres en la nube. Es necesario si quieres exponer servicios (ingress, dashboards, etc.) con una IP accesible desde tu red.

a) Instala MetalLB

kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.14.5/config/manifests/metallb-native.yaml

Esto crea el namespace metallb-system y despliega los pods necesarios.

---

b) Crea la configuración del pool de IPs

Aquí defines qué rango de IPs puede repartir MetalLB dentro de tu red local. Estos archivos suelen estar versionados en la carpeta metallb/ del repositorio.

metallb/
├── ipaddresspool.yaml
├── l2advertisement.yaml
└── kustomization.yaml

Para aplicar:

kubectl apply -k metallb/

---

c) Uso de MetalLB

A partir de aquí, cualquier Service tipo LoadBalancer obtiene una IP flotante LAN automáticamente.

Ejemplo mínimo de Service:

apiVersion: v1
kind: Service
metadata:
  name: ejemplo
spec:
  selector:
    app: ejemplo
  ports:
    - port: 80
      targetPort: 80
  type: LoadBalancer

Verás la IP asignada en la columna EXTERNAL-IP al ejecutar:

kubectl get svc

Puedes acceder desde tu red local a esa IP.

---

12. Instalación de Traefik y cert-manager (Ingress + TLS)

Traefik actúa como el "router" de aplicaciones dentro de tu clúster, permitiendo exponer servicios a Internet o la red local de forma sencilla. cert-manager se encarga de gestionar certificados TLS automáticamente para que tus aplicaciones estén siempre seguras.

a) Instala Traefik como Ingress Controller

• Aplica todos los recursos con Kustomize:

kubectl apply -k traefik/

• Comprueba que MetalLB asigna una IP al Service principal:

kubectl get pods -n traefik
kubectl get svc -n traefik

b) Instala cert-manager

• Crea el namespace:

kubectl apply -f cert-manager/namespace.yaml

• Aplica el manifiesto oficial de cert-manager:

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/latest/download/cert-manager.yaml

• Crea los ClusterIssuer para staging y producción:

kubectl apply -f cert-manager/clusterissuer-staging.yaml
kubectl apply -f cert-manager/clusterissuer-prod.yaml

• Comprueba los pods:

kubectl get pods -n cert-manager

---

13. Instala KubeVirt y CDI

KubeVirt permite crear y gestionar máquinas virtuales dentro de Kubernetes, integrando cargas virtualizadas junto a contenedores. CDI (Containerized Data Importer) facilita la gestión y carga de discos e ISOs para esas VMs.

Nota: Puedes usar manifiestos oficiales, o crear tu carpeta kubevirt/ si deseas versionar los YAML personalizados.

# Instala KubeVirt (recomendado hacerlo tras tener la red y almacenamiento)
export KUBEVIRT_VERSION=$(curl -s https://api.github.com/repos/kubevirt/kubevirt/releases/latest | grep tag_name | cut -d '"' -f 4)
kubectl create namespace kubevirt
kubectl apply -f https://github.com/kubevirt/kubevirt/releases/download/${KUBEVIRT_VERSION}/kubevirt-operator.yaml
kubectl apply -f https://github.com/kubevirt/kubevirt/releases/download/${KUBEVIRT_VERSION}/kubevirt-cr.yaml

# Instala CDI (para gestión de discos/ISOs)
export CDI_VERSION=$(curl -s https://api.github.com/repos/kubevirt/containerized-data-importer/releases/latest | grep tag_name | cut -d '"' -f 4)
kubectl create -f https://github.com/kubevirt/containerized-data-importer/releases/download/${CDI_VERSION}/cdi-operator.yaml
kubectl create -f https://github.com/kubevirt/containerized-data-importer/releases/download/${CDI_VERSION}/cdi-cr.yaml

---

14. Instala virtctl (CLI de KubeVirt)

virtctl es una herramienta de línea de comandos para interactuar fácilmente con las máquinas virtuales de KubeVirt: arranque, apagado, consola, etc.

curl -L -o virtctl https://github.com/kubevirt/kubevirt/releases/download/${KUBEVIRT_VERSION}/virtctl-${KUBEVIRT_VERSION}-linux-amd64
chmod +x virtctl
sudo mv virtctl /usr/local/bin/

---

15. Habilita KVM para tu usuario

Para poder crear y gestionar máquinas virtuales, tu usuario debe pertenecer al grupo kvm (acceso al hardware de virtualización).

sudo usermod -aG kvm $(whoami)
# Reinicia sesión o ejecuta 'newgrp kvm' para aplicar

---

16. Despliega kubevirt-manager

kubevirt-manager es una interfaz web sencilla para gestionar tus máquinas virtuales desde el navegador. Esta sección aplica sus manifiestos en Kubernetes.

La carpeta kubevirt-manager/ contiene todos los manifiestos organizados por tipo:

kubectl apply -k kubevirt-manager/

Puedes comprobar el estado:

kubectl get pods -n kubevirt-manager

---

17. Despliega el stack de almacenamiento NFS

Esta sección despliega tanto el servidor NFS (almacenamiento en red) como el "provisioner" para que Kubernetes pueda crear volúmenes dinámicos de manera automática. Es la forma más sencilla de tener almacenamiento persistente en el clúster.

La carpeta storage/ tiene todos los manifiestos del servidor y provisioner NFS, organizados en subcarpetas:

kubectl apply -k storage/

Puedes comprobar el estado:

kubectl get pods -n nfs-provisioner

• Instala el cliente NFS en el nodo:

  sudo apt install nfs-common
  

---