Comment configurer le cluster Kubernetes sur Ubuntu 22.04

Kubernetes est un outil gratuit d'orchestration de conteneurs qui vous aide à réaliser un déploiement, une mise à l'échelle et une gestion automatisés des applications conteneurisées. Un cluster Kubernetes se compose d'un nœud maître et d'un nœud travailleur. Le nœud maître est responsable de la gestion des nœuds et des pods du cluster. Le nœud de travail est utilisé pour déployer la charge de travail de l'application. Avec Kubernetes, vous pouvez déployer et gérer des applications cloud natives à l'aide d'une infrastructure sur site ou de plateformes de cloud public.

Ce tutoriel vous montrera comment configurer le cluster Kubernetes sur un serveur Ubuntu 22.04.

Conditions préalables

Un serveur exécutant Ubuntu 22.04.
Un mot de passe root est configuré sur le serveur.

Commencer

Tout d’abord, vous devrez mettre à jour et mettre à niveau vos packages système vers la dernière version. Vous pouvez le faire avec la commande suivante :

apt update -y
apt upgrade -y

Une fois tous les packages mis à jour, vous devrez également désactiver le Swap sur votre système. Vous pouvez le désactiver avec la commande suivante :

swapoff -a

Ensuite, vous devrez charger certains modules du noyau requis sur tous les nœuds. Pour ce faire, éditez le fichier /etc/modules-load.d/containerd.conf :

nano /etc/modules-load.d/containerd.conf

Ajoutez les lignes suivantes :

overlay
br_netfilter

Enregistrez et fermez le fichier, puis chargez les modules avec la commande suivante :

modprobe overlay
modprobe br_netfilter

Ensuite, vous devrez également créer une amende et définir certains paramètres requis du noyau :

nano /etc/sysctl.d/kubernetes.conf

Ajoutez les lignes suivantes :

net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1

Enregistrez et fermez le fichier, puis exécutez la commande suivante pour appliquer les modifications :

sysctl --system

Installer Containerd

Ensuite, vous devrez installer Containerd pour le cluster Kubernetes. Tout d'abord, installez toutes les dépendances requises à l'aide de la commande suivante :

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

Après avoir installé toutes les dépendances, ajoutez le dépôt Docker avec la commande suivante :

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

Ensuite, mettez à jour le référentiel et installez Containerd avec la commande suivante :

apt update -y
apt install containerd.io -y

Ensuite, vous devrez configurer les conteneurs pour qu'ils démarrent par systemd. Vous pouvez le faire avec la commande suivante :

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

Ensuite, redémarrez le service Containerd pour appliquer les modifications :

systemctl restart containerd

Installer les composants Kubernetes

Par défaut, les composants Kubernetes ne sont pas inclus dans le référentiel par défaut d'Ubuntu. Vous devrez donc ajouter le référentiel Kubernetes à votre système. Vous pouvez l'ajouter avec la commande suivante :

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"

Ensuite, mettez à jour le référentiel et installez tous les composants Kubernetes avec la commande suivante :

apt update -y
apt install kubelet kubeadm kubectl -y

Une fois tous les packages installés, vous pouvez passer à l'étape suivante.

Initialiser le cluster Kubernetes

À ce stade, tous les composants Kubernetes sont installés. Maintenant, exécutez la commande suivante sur le nœud maître pour initialiser le cluster :

kubeadm init --control-plane-endpoint=kubernetes-master-ip

Vous obtiendrez le résultat suivant :

To start using your cluster, you need to run the following as a regular user:

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

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of control-plane nodes by copying certificate authorities
and service account keys on each node and then running the following as root:

  kubeadm join kubernetes-master-ip:6443 --token chmz7m.fbjgdcqne1q0ff4t \
	--discovery-token-ca-cert-hash sha256:c614bf14af27472e470546539a9a2ff63e5d558dbbb3cc06d6f7a030fcb55426 \
	--control-plane 

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join kubernetes-master-ip:6443 --token chmz7m.fbjgdcqne1q0ff4t \
	--discovery-token-ca-cert-hash sha256:c614bf14af27472e470546539a9a2ff63e5d558dbbb3cc06d6f7a030fcb55426

Remarque : Copiez la commande kubeadm join à partir du résultat ci-dessus. Vous devrez exécuter cette commande sur le nœud Worker pour rejoindre le cluster. Ensuite, vous devrez exécuter les commandes suivantes pour interagir avec le cluster Kubernetes :

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

Rejoindre le nœud de travail au cluster

Ensuite, connectez-vous au nœud Worker et exécutez la commande suivante pour joindre le nœud Worker au cluster Kubernetes :

kubeadm join kubernetes-master-ip:6443 --token chmz7m.fbjgdcqne1q0ff4t --discovery-token-ca-cert-hash sha256:c614bf14af27472e470546539a9a2ff63e5d558dbbb3cc06d6f7a030fcb55426

Vous obtiendrez le résultat suivant :

[preflight] Running pre-flight checks
	[WARNING SystemVerification]: missing optional cgroups: blkio
[preflight] Reading configuration from the cluster...
[preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -o yaml'
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Starting the kubelet
[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

Installer le module complémentaire Calico Pod Network

Ensuite, vous devrez installer le réseau Calico Pod sur le nœud Kubernetes Master pour gérer le réseau.

Vous pouvez le télécharger et l'installer avec la commande suivante :

curl https://projectcalico.docs.tigera.io/manifests/calico.yaml -O calico.yaml
kubectl apply -f calico.yaml

Vous obtiendrez le résultat suivant :

poddisruptionbudget.policy/calico-kube-controllers created
serviceaccount/calico-kube-controllers created
serviceaccount/calico-node created
configmap/calico-config created
customresourcedefinition.apiextensions.k8s.io/bgpconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgppeers.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/blockaffinities.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/caliconodestatuses.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/clusterinformations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/felixconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/hostendpoints.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamblocks.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamconfigs.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamhandles.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ippools.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipreservations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/kubecontrollersconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networksets.crd.projectcalico.org created
clusterrole.rbac.authorization.k8s.io/calico-kube-controllers created
clusterrole.rbac.authorization.k8s.io/calico-node created
clusterrolebinding.rbac.authorization.k8s.io/calico-kube-controllers created
clusterrolebinding.rbac.authorization.k8s.io/calico-node created

Ensuite, vérifiez l'état des pods à l'aide de la commande suivante :

kubectl get pods -n kube-system

Vous obtiendrez le résultat suivant :

NAME                                            READY   STATUS    RESTARTS   AGE
calico-kube-controllers-58dbc876ff-nh2st        1/1     Running   0          5m58s
calico-node-7cfz7                               1/1     Running   0          5m58s
calico-node-lt5cv                               1/1     Running   0          5m58s
coredns-565d847f94-dm6qc                        1/1     Running   0          21m
coredns-565d847f94-zhng9                        1/1     Running   0          21m
etcd-k8smaster.example.net                      1/1     Running   0          22m
kube-apiserver-k8smaster.example.net            1/1     Running   0          22m
kube-controller-manager-k8smaster.example.net   1/1     Running   0          22m
kube-proxy-9w2xp                                1/1     Running   0          14m
kube-proxy-gdb97                                1/1     Running   0          21m
kube-scheduler-k8smaster.example.net            1/1     Running   0          22m

Vous pouvez maintenant vérifier l'état du cluster Kubernetes avec la commande suivante :

kubectl get nodes

Vous devriez voir que les nœuds maître et travailleur sont à l'état prêt :

NAME                    STATUS   ROLES           AGE   VERSION
k8smaster.example.net   Ready    control-plane   22m   v1.25.0
kubernetes              Ready              14m   v1.25.0

Déployer une application Nginx sur Kubernetes

Pour tester le Kubernetes, nous allons déployer une application Nginx sur le cluster.

Exécutez la commande suivante pour déployer une application Nginx :

kubectl create deployment nginx-app --image=nginx --replicas=2

Vous pouvez vérifier votre application avec la commande suivante :

kubectl get deployment nginx-app

Vous obtiendrez le résultat suivant :

NAME        READY   UP-TO-DATE   AVAILABLE   AGE
nginx-app   2/2     2            2           13s

Ensuite, exposez votre application sur le port 80 avec la commande suivante :

kubectl expose deployment nginx-app --type=NodePort --port=80

Ensuite, vérifiez l'état du service Nginx avec la commande suivante :

kubectl get svc nginx-app

Vous obtiendrez le résultat suivant :

NAME        TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
nginx-app   NodePort   10.109.89.196           80:30921/TCP   14s

Vous pouvez également voir les informations détaillées de votre application Nginx à l'aide de la commande suivante :

kubectl describe svc nginx-app

Vous devriez voir le résultat suivant :

Name:                     nginx-app
Namespace:                default
Labels:                   app=nginx-app
Annotations:              
Selector:                 app=nginx-app
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.109.89.196
IPs:                      10.109.89.196
Port:                       80/TCP
TargetPort:               80/TCP
NodePort:                   30921/TCP
Endpoints:                192.168.192.129:80,192.168.192.130:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:

Maintenant, notez l'adresse IP de l'application Nginx à partir du résultat ci-dessus et vérifiez votre application Nginx à l'aide de la commande curl :

curl http://10.109.89.196

Si tout va bien, vous obtiendrez le résultat suivant :

<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Toutes nos félicitations! vous avez déployé avec succès le cluster Kubernetes sur le serveur Ubuntu 22.04.

Comment configurer le cluster Kubernetes sur Ubuntu 22.04

Conditions préalables

Commencer

Installer Containerd

Installer les composants Kubernetes

Initialiser le cluster Kubernetes

Rejoindre le nœud de travail au cluster

Installer le module complémentaire Calico Pod Network

Déployer une application Nginx sur Kubernetes

Articles connexes: