Files

2025-07-19 15:35:27 +00:00

8.8 KiB

Raw Blame History

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

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

Si quieres probar Multus con bridges y VLANs, puedes usar una configuración de Netplan como la siguiente. Aquí se configura:

Bonding LACP sobre dos interfaces
VLANs para separar redes
Bridges para administración y servicios

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

Ubuntu 24.04 actualizado
Acceso root o sudo

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)

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

3. Instala containerd (runtime recomendado)

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

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

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

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

Si usas Flannel, usa este parámetro:

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

a) Configura kubectl para tu usuario

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)

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

8. Instala Multus (opcional, para 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

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

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 en cloud. Ideal para exponer ingress-nginx, rancher, etc. directamente en 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

En este repositorio, la carpeta metallb/ contiene los recursos listos para aplicar:

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)

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

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)

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

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

16. Despliega kubevirt-manager

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

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

kubectl apply -k storage/