Docker su Ubuntu 22.04


Non ci crederete, ma installare Docker su Ubuntu 22.04 è piuttosto semplice. L’interazione con Kubernetes solitamente richiede dei passaggi più ostici ma in questo tutorial ci concentreremo soltanto ad installare Docker su Ubuntu 22.04.

La prima cosa è aggiornare i pacchetti della nostra distribuzione all’ultima versione tramite il classico comando:

sudo apt update && sudo apt upgrade

Installare alcuni tool aggiuntivi

sudo apt install apt-transport-https ca-certificates software-properties-common

Occorre aggiungere la chiave del repository pubblico di docker (qualora non l’abbiate mai fatto):

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg –dearmor -o /usr/share/keyrings/docker.gpg

Aggiungere il repository di Docker al nostro sistema:

echo “deb [arch=$(dpkg –print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable” | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Fare un refresh dei pacchetti del sistema:

sudo apt update

Installare la versione comunity di Docker ossia il pacchetto docker-ce (e le sue dipendenze):

sudo apt install docker-ce

Ora per poter usare il nostro utente per con docker dobbiamo aggiungerlo al gruppo “docker”

sudo usermod -aG docker ${USER}

Possiamo aggiungere altri utenti al gruppo docker semplicemente con il comando sopra sostituendo ${USER} con il nome degli altri utenti presenti su Ubuntu.

Ora l’ambiente è funzionante. Se per esempio vogliamo scaricare un’immagine di Alpine Linux sul nostro sistema possiamo usare il comando:

sudo docker pull alpine

Installare Kubernetes su Ubuntu 22.04

Dopo qualche mese d’utilizzo, è ora di installare Kubernetes su Ubuntu 22.04.

L’installazione di Kubernetes (K8s) su Ubuntu 22.04 differisce da quella fatta per Ubuntu 20.04 in quanto non andremmo più ad installare Docker.

Esatto! La mancanza di Docker non è un problema anzi un’opportunità in quanto uno dei componenti di Kubernetes, chiamato dockershim, che permetteva a Kubernetes di interloquire con Docker è stato rimosso dalla versione 1.24 di K8s. Ora l’installazione di Kubernetes con Docker non è più così immediata come prima, per cui passare a containerd come runtime risulta più agevole e non limita le funzionalità.

Se avete l’esigenza di creare un disco (o un filesystem) separato dove ospitare i container farlo usando come mount point /var/lib/containerd.

Installazione di Kubernetes su Ubuntu 22.04

Dopo aver installato la versione server di Ubuntu 22.04 (l’installazione minimal con server SSH è sufficiente), il primo passaggio è quello di assegnare un IP statico (che non cambia) ai nodi Kubernetes.
Questo in quanto cambiare l’indirizzo IP successivamente all’installazione è un po’ problematico e comporta dei tempi di indisponibilità del cluster.
Altro suggerimento è quello di non cambiare l’hostname del server successivamente all’installazione e configurazione di K8s, per lo stesso motivo.

Ora procediamo! E’ necessario disabilitare la swap e attivare e modificare alcune impostazioni al kernel.

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

Aggiugere questa configurazione per il kernel:

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

Attivare questi 2 moduli del kernel (il comando è persistente al riavvio):

sudo modprobe overlay
sudo modprobe br_netfilter

Poi aggiungere ancora queste impostazioni dedicate a Kubernetes

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

Per renderle attive è necessario ricaricare sysctl con il seguente comando:

sudo sysctl --system

Si può installare il runtime containerd. Containerd oppure un altro runtime come CRI-O potevano essere “ignorati” fino alla versione 1.23 di Kuberentes in quanto si potevano usare dei componenti creati ad-hoc per docker, ma ora questi sono stati rimossi da Kuberentes (> 1.24) per cui è più semplice usare queste parti e quindi in questa guida è stato scelto di installare il runtime di containerd anzichè docker.

Questi tool sono necessari per l’installazione dei pacchetti successivi:

sudo apt install -y curl gnupg2 software-properties-common apt-transport-https ca-certificates

Abilitare repository Docker

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmour -o /etc/apt/trusted.gpg.d/docker.gpg
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Procedere all’ installazione di containerd (che proviene dai repository di docker):

sudo apt update
sudo apt install -y containerd.io

Configurare containerd in modo che usi systemd come cgroup.

containerd config default | sudo tee /etc/containerd/config.toml >/dev/null 2>&1
sudo sed -i 's/SystemdCgroup \= false/SystemdCgroup \= true/g' /etc/containerd/config.toml

Riavvia e abilita il servizio containerd

sudo systemctl restart containerd
sudo systemctl enable containerd

Xenial è ancora l’ultimo repository Kubernetes disponibile per Ubuntu 22.04 (Jammy Jellyfish).
Aggiungere ora il repository per Kubernetes

sudo curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmour -o /etc/apt/trusted.gpg.d/cloud.google.gpg
sudo apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"

Installare i componenti Kubernetes Kubectl, kubeadm e kubelet e impostare il fatto che futuri aggiornamenti sono bloccati per questi pacchetti.

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

Ricordiamoci che al termine dell’installazione e configurazione di Kubernetes è opportuno attivare un componente aggiuntivo di rete Pod basato su Container Network Interface (CNI) in modo che i tuoi Pod possano comunicare tra loro. Ora scegliamo una rete dalla quale saranno scelti gli IP che saranno assegnati ai vari container e servizi.
Solitamente questa rete deve essere diversa da quella del nostro ambiente in quanto altrimenti si potranno avere degli IP duplicati che comportano l’irraggiunbilità dei servizi e altri malfunzionamenti.

Ora è possibile inizializzare Kubernetes ma prima va fatta una considerazione sulla rete e su pod-network-cidr.

Siccome ad ogni nodo generalmente viene assegnato un pool di 256 indirizzi che verranno assegnati ai servizi e container bisogna calcolare una rete amplia anche per usi futuri. Con una rete come 192.168.240.0/21 è possibile avere fino ad 8 nodi in quanto ci sono 2046 indirizzi utilizzabili. Per questo motivo se pensate di aggiungere più di 8 nodi al vostro cluster, sarebbe opportuno fin da subito ampliare il pod network cidr con una rete più amplia es. 192.168.240.0/20, così da poter avere ben 16 nodi e un intervallo di indirizzi utilizzabili da 192.168.240.1 a 192.168.255.254.
Quindi nel successivo comando cambiare la rete 192.168.240.0/21 con una che soddisfa i vostri requisti. Sostituire 192.168.1.1 con l’indirizzo del server K8s che disporrà del componente Control Plane (quello che una volta era chiamato Master).

sudo kubeadm init --control-plane-endpoint 192.168.1.1 --pod-network-cidr 192.168.240.0/21

E’ importante annotarsi il comando da usare per aggiungere nuovi nodi, come worker, al nostro cluster K8s. Il comando viene dato come output alla fine dell’inizializzazione di Kubernetes.

sudo kubeadm join 192.168.1.1:6443 --token s1o2xh.sqcjbkc7f1iocf15 \
        --discovery-token-ca-cert-hash sha256:bbb0aded78f6138b3bf185dabce1f9441e6c224aa270a98b0f782dc52062af5c \
        --control-plane

192.168.1.1 dovrebbe corrispondere all’indirizzo del vostro control plane e poi vi viene fornito un token generato a caso e l’hash del token.

E’ possibile comunque rigenerare un token sostituivo per il join di un worker lanciando il seguente comando sul nodo control plane

kubeadm token create --print-join-command

Al termine dell’installazione è possibile configurare l’ambiente dei comandi in maniera comoda, lanciando quanto sotto:

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

Ora è necessario configurare la parte di rete.
Come gestore utilizzeremo Calico come nel precedente tutorial su Ubuntu 20.04.

curl https://docs.projectcalico.org/manifests/calico-typha.yaml -o calico.yaml
kubectl apply -f calico.yaml

Attendere una decina di minuti (dipende dalla vostra connessione) oppure verificare che tutti i pod necessari a Calico siano in esecuzione:

watch kubectl get pods --all-namespaces

E’ possibile aggiungere altri nodi, come worker, seguendo la procedura sopra ma saltando la parte di kubectl init e la configurazione del gestore di rete, per riferimento potete leggere la guida di installazione di Kubernetes su Ubuntu 20.04.

Passaggio facoltativo:

E’ possibile consentire l’esecuzione di pod anche sul nodo control plane (master); chiaramente non è un’operazione consigliata in un ambiente produttivo, ma così è possibile usare il nodo col control plane per far girare i container come se fosse un po’ un worker.

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

Risoluzione dei problemi di Kubernetes (troubleshooting)

Cosa fare quando un nodo Kubernetes risulta NotReady?

Uno dei possibile stati di un nodo, che sia Control Plane o Worker, è NotReady. Se un nodo K8s è NotReady significa che non può essere utilizzato completamente e ha qualche anomalia. Per indagare su questa eventualità si può usare il comando:
kubectl describe node

L’output di questo comando è alquanto prolisso ma possiamo trovare questa riga che ho sottolineato in giallo:

Questo significa che il gestore di rete non sta funzionando correttamente. Solitamente si consiglia di verificare che i pod del gestore siano attivi sul cluster.

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
NodePort espone il servizio sull’IP di ogni nodo su una porta stabilita (la NodePort), nel caso dell’immagine sopra è la 31115, questo numero può cambiare, usate quello che vi è stato indicato.

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.

Installare Kubernetes in Debian 9

Kubernetes è uno strumento di gestione (orchestrazione) di container che consente l’amministrazione di gruppi di container dislocati anche su più server.
Esistono tecnologie simili a Kubernetes, ma esso è diventato un riferimento di mercato e uno dei prodotti meglio documentati e semplici da utilizzare.
Kubernetes si avvale di Docker, e per questo motivo, prima di installare Kubernetes è conveniente installare Docker CE (Community Edition).

Continua a leggere

Installare Rancher su Ubuntu 16.04 Xenial Xerus


Dopo una serie di guide su Rancher in Debian, vediamo assieme come installare Rancher su Ubuntu 16.04 Xenial Xerus. Ubuntu Xenial Xerus non ha bisogno di presentazioni: si tratta della prossima LTS di Canonical. Rancher propone un’interfaccia web che consente la gestione di immagini e gruppi di immagini (detti stack e/o servizi) per rendere il deploy di applicazioni con Docker più semplice.

Continua a leggere

Installare Docker su Ubuntu 16.04 Xenial Xerus


In questo tutorial vedremo come installare la versione ufficiale di Docker su Ubuntu 16.04 Xenial Xerus in maniera semplice e veloce.

Incluso in Ubuntu 16.04 Xenial Xerus è già disponibile la versione 1.6.1 di Docker pacchettizzata per la distribuzione, tuttavia in questo articolo scopriremo come installare la versione disponibile sul sito di docker.com che è più aggiornata.

Continua a leggere

Attivare WordPress su Docker con Rancher


Negli articoli precedenti abbiamo scoperto uno dei modi più semplici per installare l’ultima versione di Docker in aggiunta a Rancher. In questo tutorial vedremo come fare il deploy di due container, uno che ospita un web server sul quale è attivo WordPress e l’altro container con il database MariaDB che andrà a supportare WordPress.

Utilizzando Rancher, il deploy è abbastanza facile: in breve basta scegliere l’applicazione WordPress dal catalogo di Rancher e in pochi secondo verranno installati i servizi e lo stack necessari.

 

Continua a leggere

Installare Rancher server su Debian Jessie


Rancher è una suite di applicazioni che consente la gestione tramite interfaccia grafica di Docker che viene distribuito come un insieme di contenitori Docker. Avviare Rancher è piuttosto semplice così come il lancio di due container: un contenitore rappresenta il server di gestione e l’altro un nodo agente.

Si può installare Rancher su Debian Jessie, a patto che la versione installata di Docker sia superiore o ugiale alla 1.9 e sia disponibile almeno 1 GB di RAM.
Se avete seguito l’articolo precedente, dovreste avere al meno la versione 1.10 di Docker che soddisfa i requisiti.

Continua a leggere

Esporre servizi Docker all’esterno


Nel precedente articolo abbiamo visto come è semplice installare Docker su Debian Jessie. Abbiamo altresì installato e avviato il nostro primo container.

Ora vogliamo usare Docker in modo più “intelligente” e utile. Supponiamo di aver installato un web server o di aver attivato un servizio da esporre all’esterno tramite connessione tcp o Internet. Qui le cose si complicano perché Docker non permette di esporre servizi esterni di default (out-of-box).

Docker essenzialmente crea un’interfaccia virtuale chiamata docker0 che affianca la più nota eth0.

Continua a leggere