Installare Kubernetes su Ubuntu 20.04

In questo articolo potrai trovare i passaggi per installare Kubernetes su Ubuntu 20.04.

Kubernetes (K8s) è un insieme di strumenti per gestire l’automazione della creazione e la scalabilità di applicativi nei container. Esso può utilizzare diverse tecnologie di container come Docker, Cri-o o Containerd. In questo tutorial scoprirai come installare Docker, Kubernetes su Focal Fossa.

Installazione di K8s

La prima cosa da fare, che tu stia usando la versione server oppure quella desktop di Ubuntu Focal Fossa 20.04 (LTS), è un aggiornamento dei pacchetti in generale tramite il comando:

sudo apt update && sudo apt upgrade

Il sistema su cui installerai Kubernetes dovrebbe essere dedicato a questo scopo perchè, poi verrà attivato l’inoltro dei pacchetti di rete ed è necessario disattivare la swap (la swap generalmente è utile in altri casi). Disattivare la swap con i comandi:

sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
sudo swapoff -a

Poi, siccome gli strumenti di Kubernetes non sono presente nei repository standard di Ubuntu, è opportuno attivare un repository esterno in questo modo:

sudo apt -y install curl apt-transport-https
wget -qO- https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Ora aggiornare nuovamente i metadati dei pacchetti con il classico apt update e poi procedere all’installazione dei pacchetti di Kubernetes.

sudo apt update
sudo apt install -y vim git kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

In seguito bisogna attivare alcuni moduli del kernel, abilitare il forward dei pacchetti di rete e configurare sysctl.

sudo tee /etc/modules-load.d/containerd.conf<<EOF
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

sudo tee /etc/sysctl.d/kubernetes.conf<<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

sudo sysctl --system

Verifichiamo che i moduli del kernel aggiunti siano effettivamente attivi:

lsmod | grep br_netfilter

Ora possiamo decidere quale tecnologia di container vogliamo usare sul nostro server Kubernetes. Possiamo scegliere fra Docker, Cri-o oppure Containerd.

In questo tutorial installeremo Docker.

Installazione di Docker

Attivare i repository e installare i pacchetti necessari per Docker:

sudo apt install gnupg2 software-properties-common ca-certificates
wget -qO- https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt update
sudo apt install containerd.io docker-ce docker-ce-cli

Successivamente è necessario configurare alcune componenti di Docker al fine di sfruttare al meglio Kubernetes (per utilizzare systemd per la gestione dei cgroup del contenitore):

sudo mkdir /etc/docker
sudo tee /etc/docker/daemon.json <<EOF
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF
sudo systemctl enable docker
sudo systemctl daemon-reload
sudo systemctl restart docker

Ora per avere un riscontro riguardo il corretto funzionamento di Docker è sufficiente digitare il classico comando:

sudo systemctl status docker

Kubernetes ci richiede di creare un nodo principale, chiamato Master Node. Per creare tale nodo, abilita il servizio kubelet.

sudo systemctl enable kubelet

Poi aggiungere i componenti del control plane che include etcd (il database del cluster) e il server API.

sudo kubeadm config images pull

Quest’operazione va svolta solo nel nodo master: kubeadm consente di creare un nodo col ruolo control-plane utilizzando il comando kubeadm init. Per utilizzare il bootstrap di un cluster senza utilizzare l’endpoint DNS:

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

Conviene salvare l’output del comando precedente, in particolare la parte finale gialla con l’hash code perchè ci servirà più tardi.

Completare la configurazione per avviare il cluster:

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

Per verificare il funzionamento di Kubernetes, lanciare il comando:

kubectl cluster-info

L’ultima cosa da fare è installare il plugin di rete sul nodo Master. Anche qui ci sono svariati plug-in che si possono utilizzare, per semplicità e comodità attiveremo Calico.

kubectl create -f https://docs.projectcalico.org/manifests/tigera-operator.yaml 
kubectl create -f https://docs.projectcalico.org/manifests/custom-resources.yaml

Attendere 7-8 minuti oppure verificare che tutti i pod necessari a Calico siano in esecuzione:

watch kubectl get pods --all-namespaces

Poi controllare che Kubernetes sia ok:

kubectl get nodes -o wide

Ora la configurazione base di Kubernetes è finita. Abbiamo un nodo master che può essere usato per attivare nuove applicazioni. Per aggiungere un nodo come worker ripetere il tutorial saltando il passaggio indicato solo per nodi master (ossia kubeadm init) e aggiungere al suo posto quella di kubeadm join.

Se lo desiderate potete installare una web gui (dashboard) per la gestione di Kubernetes, comoda se siete principianti. Le istruzioni sono le successive.

Installare Kubernetes Dashboard con NodePort (facoltativo)

Puoi attivare la dashboard di Kubernetes con il comando seguente:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/master/aio/deploy/recommended.yaml
kubectl --namespace kubernetes-dashboard patch svc kubernetes-dashboard -p '{"spec": {"type": "NodePort"}}'

Per verificare che si sia attivata usare il comando:

kubectl get svc -n kubernetes-dashboard

Creiamo un file chiamato patch.yaml e incolliamo quanto sotto, ricordandoci di cambiare 31115 con la porta che vi è stata assegnata.

spec:
  ports:
  - nodePort: 31115
    port: 443
    protocol: TCP
    targetPort: 8443

Applicare la patch:

kubectl -n kubernetes-dashboard patch svc kubernetes-dashboard --patch "$(cat patch.yaml)"

Per accedere alla dashboard di Kubernetes, usare l’IP della scheda di rete di Ubuntu che si può ottenere col comando (evidenziato in giallo):

ip a | grep ens

L’url da usare quindi è https://192.168.159.135:31115 dove 192.168.159.135 è l’ip del sistema, 31115 la porta assegnata alla dashboard.

Per poter accedere alla pagina web tuttavia occorre creare un token. Per farlo creiamo un file chiamato admin.yaml con il seguente testo:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: kubedash-admin
  namespace: kube-system

Creiamo un oggetto Kubernetes attraverso una sintassi dichiarativa usando il file appena salvato:

kubectl apply -f admin.yml

Creare un file di nome admin-ClusterRoleBinding.yaml e scrivere dentro quanto sotto:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: kubedash-admin
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
  - kind: ServiceAccount
    name: kubedash-admin
    namespace: kube-system

Applicare il file così:

kubectl apply -f admin-ClusterRoleBinding.yaml

Impostiamo questa variabile nella shell:

SA_NAME="kubedash-admin"

Ora lanciamo il seguente comando per avere finalmente il token:

kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | grep ${SA_NAME} | awk '{print $1}')

Con il token si può fare login.

Ed ecco la nostra dashboard.