Saltar al contenido principal

Instalación de Kubernetes

La instalación de Kubernetes en un cluster de nodos puede ser un proceso complejo la primera vez, pero no te procupes. En esta guía agruparé distintos tutoriales de instalación con distintos motores de contenedores y distintos sistemas operativos. Esta muy mascado y probado el proceso, pero si tienes algún problema, no dudes en abrir un issue en el repositorio de Github.

Para todas las instalaciones estos son los requisitos mínimos y los recomendados para un cluster de Kubernetes:

Requisitos mínimos y recomendados para un cluster de Kubernetes

Si prefieres ver la instalación en vídeo, aquí lo tienes: Instalación de Kubernetes

Ubuntu Server 24.04 con Containerd​

Nodo maestro​

NOTA: Hasta el paso 11 todos los comandos se han ejecutado con el usuario root. A partir de este paso, se ejecutarán con el usuario normal que se haya creado en el sistema, en mi caso pabpereza.

  1. Actualizar paquetería e instalar requisitos previos:
apt update && apt upgrade -y

apt install curl apt-transport-https git wget software-properties-common lsb-release ca-certificates socat -y
  1. Desactivar swap:
swapoff -a
sed -i '/swap/s/^\(.*\)$/#\1/g' /etc/fstab # Auto comenta la línea de swap en fstab
  1. Cargar módulos necesarios del kernel y cargar configuración en sysctl:
modprobe overlay
modprobe br_netfilter

cat << EOF | tee /etc/sysctl.d/kubernetes.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
  1. Aplicar configuración de sysctl y comprobar que se ha aplicado correctamente:
sysctl --system
  1. Instalar las claves gpg de Docker para instalar containerd:
mkdir -p /etc/apt/keyrings

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

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
  1. Instalar containerd y configurar el daemon para que use cgroups de systemd:
apt-get update && apt-get install containerd.io -y

containerd config default | tee /etc/containerd/config.toml

sed -e's/SystemdCgroup = false/SystemdCgroup = true/g' -i /etc/containerd/config.toml

systemctl restart containerd
  1. Instalar claves gpg de Kubernetes y añadir el repositorio:
mkdir -p -m 755 /etc/apt/keyrings

curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/deb/Release.key \
| sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
  1. Añadir el repositorio de Kubernetes 1.30 (puedes cambiar la versión modificando las URLs):
echo "deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] \
https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /" \
| sudo tee /etc/apt/sources.list.d/kubernetes.list

apt-get update
  1. Instalar kubeadm, kubelet y kubectl:
apt-get install -y kubeadm=1.30.1-1.1 kubelet=1.30.1-1.1 kubectl=1.30.1-1.1

apt-mark hold kubelet kubeadm kubectl # Bloquear actualizaciones automáticas
  1. Buscamos nuestra IP y la añadimos al fichero /etc/hosts con el nombre del nodo maestro (en mi caso k8scp como control plane pero le puedes dar el nombre que prefieras):
echo "<IP> k8scp" >> /etc/hosts

Puedes obtener tu ip con el comando ip a, ip addr show o hostname -i.

  1. Iniciar el cluster con kubeadm (importante cambiar el rango de IPs para pods por uno que no esté en uso en tu red, evitar también el rango 10.XXX.XXX.XXX ya que es un rango reservado para redes privadas). Por último, añadimos el nombre del nodo maestro (recuerda usar el de antes) y el puerto 6443:
kubeadm init --pod-network-cidr=<rango de IPs para pods> --control-plane-endpoint=<Nombre añañadido en el /etc/hosts>:6443

# Por ejemplo:
# kubeadm init --pod-network-cidr=192.168.0.0/16 --control-plane-endpoint=k8scp:6443
  1. Configurar kubectl e instalar autocompletado:
mkdir -p $HOME/.kube

sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

sudo chown $(id -u):$(id -g) $HOME/.kube/config

sudo apt-get install bash-completion -y

source <(kubectl completion bash)

echo 'source <(kubectl completion bash)' >> ~/.bashrc # persistir autocompletado

Esto nos permitirá usar autocompletado en la terminal de bash y si tabulamos después de escribir kubectl nos mostrará las opciones disponibles.

  1. Instalar Helm, necesario para instalar algunas aplicaciones en Kubernetes, incluido cilium (la CNI que vamos a instalar):
curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg > /dev/null

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/helm.gpg] https://baltocdn.com/helm/stable/debian/ all main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list

sudo apt-get update

sudo apt-get install helm -y
  1. Instalar cilium, una CNI que nos permitirá conectar los pods entre sí:
helm repo add cilium https://helm.cilium.io/

helm repo update

helm template cilium cilium/cilium --version 1.16.1 \
--namespace kube-system > cilium.yaml

kubectl apply -f cilium.yaml
  1. (Opcional y no recomendado) Si quieres que tu nodo maestro también sea un nodo worker (es decir, que ejecute pods), puedes hacerlo con el siguiente comando:
kubectl taint nodes --all node-role.kubernetes.io/master-
kubectl taint nodes --all  node-role.kubernetes.io/control-plane-

Podríamos reactivar la restricción (taint) de que el nodo maestro no ejecute pods con el comando:

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

Nodo worker​

Esta parte de la instalació la haremos sobre el servidor que queramos añadir al cluster. En este caso, el nodo worker.

  1. Repetir los pasos 1 a 10 del nodo maestro. IMPORTANTE Recuerda añadir la IP y el nombre del nodo maestro en el fichero /etc/hosts. Osea, exactamente igual que en el nodo maestro no lo adaptes a este nodo.

  2. Unir el nodo worker al cluster con el comando que nos proporcionó kubeadm init en el nodo maestro:

kubeadm join <Nombre del nodo maestro>:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>

El token se puede obtener con el comando kubeadm token list lanzado en el nodo maestro. Si hubiera expirado, se puede generar uno nuevo con kubeadm token create.

El hash se puede obtener con el siguiente comando de openssl. Lo lanzamos en el nodo maestro:

openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'
  1. Comprobar que el nodo worker se ha unido correctamente al cluster. Lanza el siguiente comando en el nodo maestro. Es posible que tarde un poco en estar listo:
kubectl get nodes

Ubuntu Server 20.04 y 22.04 con Containerd​

Nodo maestro​

  1. Instalar requisitos previos:
apt install curl apt-transport-https vim git wget gnupg2 \
software-properties-common apt-transport-https ca-certificates uidmap -y
  1. Desactivar swap:
swapoff -a
sed -i '/swap/s/^\(.*\)$/#\1/g' /etc/fstab # Auto comenta la línea de swap en fstab
  1. Cargar módulos necesarios:
modprobe overlay
modprobe br_netfilter

sudo tee /etc/modules-load.d/k8s.conf <<EOF
overlay
br_netfilter
EOF
  1. Configurar módulos:
cat << EOF | tee /etc/sysctl.d/kubernetes.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

sysctl --system # Aplica la configuración
  1. Añadir al fichero `/etc/hosts' la IP y el nombre de la máquina (ATENCIÓN: Pon la IP del nodo master si esta configurando un worker). Con esto podremos configurar el cluster con el nombre de la máquina en vez de la IP.
echo "<IP> <NOMBRE>" >> /etc/hosts
  1. Instalar containerd:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

apt update && apt install containerd.io -y
  1. Configurar containerd:
mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml

Dentro del fichero /etc/containerd/config.toml hay que cambiar la línea SystemdCgroup = false por SystemdCgroup = true.

  1. Iniciar containerd:
systemctl enable containerd
systemctl restart containerd
  1. Instalar kubeadm, kubelet y kubectl:
# Agrergar repositorio de Kubernetes
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | tee -a /etc/apt/sources.list.d/kubernetes.list

# Instalar clave pública de Kubernetes
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add 

# Instalar paquetes
apt update && apt install -y kubelet kubeadm kubectl
# Especificar versión de Kubernetes, por ejemplo:
#apt install -y kubelet=1.24.1-00 kubeadm=1.24.1-00 kubectl=1.24.1-00

# Bloquear actualizaciones automáticas
apt-mark hold kubelet kubeadm kubectl

# Iniciar kubelet
systemctl enable kubelet
  1. Iniciar cluster master:
kubeadm init --pod-network-cidr=<rango de IPs para pods> --control-plane-endpoint=<Nombre añañadido en /etc/hosts>:6443
  1. Configurar kubectl:
mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config
  1. Instalar red de pods: Esta paso es importante, tendremos que editar el archivo de configuración de la red de pods para que funcione correctamente. En este caso usaremos Calico, pero puedes usar cualquier otra red de pods que quieras. Debemos especificar en la instrucción CALICO_IPV4POOL_CIDR el rango de IPs que hemos especificado en el paso 9.
wget https://docs.projectcalico.org/manifests/calico.yaml

# Editar el archivo de configuración de Calico descomentando las líneas. Quedando así:
- name: CALICO_IPV4POOL_CIDR
  value: "rango de IPs para pods"

Por ejemplo:

            # The default IPv4 pool to create on startup if none exists. Pod IPs will be
            # chosen from this range. Changing this value after installation will have
            # no effect. This should fall within `--cluster-cidr`.
            - name: CALICO_IPV4POOL_CIDR
              value: "192.168.0.0/16"
           # The default IPv4 pool to create on startup if none exists. Pod IPs will be
            # chosen from this range. Changing this value after installation will have
            # no effect. This should fall within `--cluster-cidr`.
  1. Aplicar red de pods:
kubectl apply -f calico.yaml

Nodo worker​

Repeticiones de los pasos 1 a 9 del nodo maestro. Esta vez en el fichero /etc/hosts tenemos que añadir la IP y el nombre del nodo maestro.

  1. Iniciar cluster worker:
kubeadm join <Nombre del nodo maestro>:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>

El token se puede obtener con el comando kubeadm token list lanzado en el nodo maestro. Si hubiera expirado, se puede generar uno nuevo con kubeadm token create.

El hash se puede obtener con el siguiente comando de openssl. Lo lanzamos en el nodo maestro:

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

Volver al índice

X

Graph View