Orchestration
des conteneurs
Driss ALLAKI
SUPINFO Official Document
© SUPINFO International University – [Link]
1 Besoin : Orchestration des conteneurs
2 Kubernetes (K8s) : vue d’ensemble
3 Architecture de Kubernetes
4 Objets Kubernetes
5 Contrôleurs Kubernetes
6 Minikube : Kubernetes en local
7 Kubectl : Commandes de base
8 Fichiers de configuration YAML
9 Technologies connexes
10 Un peu de pratique !
Orchestration des conteneurs : le besoin
Exigences à respecter pour les applications déployées en production
Les applications qui gèrent des opérations complexes à grande échelle doivent être
hautement disponibles (high availability) sans aucun temps d'arrêt (zero downtime).
Les applications doivent être résistantes aux grandes fluctuations de la charge de travail
(resiliency).
Ne pas utiliser de manière optimale les ressources cloud entraînera des coûts importants
(cost optimization).
L'exécution fiable des opérations de déploiement, pour soutenir le développement évolutif,
est cruciale (reliability).
Orchestration des conteneurs
Problèmes de disponibilité et de montée en charge (en production)
Il faut démarrer plusieurs instances en fonction de la charge
Si une instance tombe en panne, il faut la remplacer
Si le Container Engine tombe en panne, tous les conteneurs vont cracher
Solution :
Orchestration des conteneurs par des outils dédiés permettant l’automatisation des opérations comme :
Scalabilité et réplication des conteneurs / Haute disponibilité / Bilan de santé des conteneurs, etc.
Hashicorp Nomad Kubernetes Apache MESOS Docker Swarm
1 Besoin : Orchestration des conteneurs
2 Kubernetes (K8s) : vue d’ensemble
3 Architecture de Kubernetes
4 Objets Kubernetes
5 Contrôleurs Kubernetes
6 Minikube : Kubernetes en local
7 Kubectl : Commandes de base
8 Fichiers de configuration YAML
9 Technologies connexes
10 Un peu de pratique !
Kubernetes : Qu’est-ce que c’est ?
Kubernetes est une plate-forme open-source extensible et portable pour la gestion de charges
de travail (workloads) et de services conteneurisés.
Kubernetes est développé par Google (écrit en langage Go) et rendu open-source en 2014.
C’est Le fruit de 15 ans d’expérience de Google (au niveau de la gestion de la charge et de la mise à
l'échelle en production) associée aux meilleures idées et pratiques de la communauté.
Kubernetes = Mot qui tire son origine du Grec ancien, faisant référence à la personne qui gouverne
la barre du bateau (capitaine ou pilote).
Kubernetes : Plus techniquement
Kubernetes fournit un environnement de gestion focalisé sur le conteneur (container-centric)
Il orchestre les ressources machines (computing), la mise en réseau et l’infrastructure de
stockage sur les workloads des utilisateurs.
Kubernetes favorise à la fois l'écriture de configuration déclarative (declarative configuration) et
l'automatisation.
Kubernetes a un certain nombre de fonctionnalités. Il peut être considéré comme:
• une plate-forme de conteneurs
• une plate-forme de microservices
• une plate-forme cloud portable
Actions possibles avec Kubernetes
Déployer une application sous forme de conteneurs d’une manière très rapide et prévisible
Automatiser le déploiement et la réplication des conteneurs
Organiser les conteneurs en groupes et faire du Load balancing
Déclarer l’architecture désirée (nombre de pods, contenu, stratégie de MAJ) et laisser le système
atteindre et maintenir cette cible
Faire des mises à jour sans interrompre le service
Séparer l’application de l’architecture sous-jacente
Détecter les problèmes et les résoudre automatiquement
1 Besoin : Orchestration des conteneurs
2 Kubernetes (K8s) : vue d’ensemble
3 Architecture de Kubernetes
4 Objets Kubernetes
5 Contrôleurs Kubernetes
6 Minikube : Kubernetes en local
7 Kubectl : Commandes de base
8 Fichiers de configuration YAML
9 Technologies connexes
10 Un peu de pratique !
Concepts génériques de Kubernetes
Cluster : Ensemble de machines physiques ou
virtuelles (Nodes) utilisées par Kubernetes
pour faire tourner des applications.
Node : Une machine physique ou virtuelle
dans laquelle seront déployés des Pods.
Chaque Node doit contenir un Container
Runtime.
Pod(*) : Groupe de conteneurs déployés
ensembles (C’est l’entité de base la plus
élémentaire de Kubernetes).
Kubectl : Application CLI qui permet d’interagir
avec Kubernetes en exécutant des
commandes dans les clusters Kubernetes.
(*) à détailler par la suite
Architecture de Kubernetes : Composants Master
Kubernetes Master
Unité de contrôle principale qui gère la
charge de travail et dirige les
communications dans le système.
Le plan de contrôle de Kubernetes est
constitué de plusieurs composants, chacun
ayant son propre processus, qui peuvent
s’exécuter sur un seul ou plusieurs Nodes
Master permettant de créer des clusters
assurant la haute disponibilité de
l’application.
Architecture de Kubernetes : Composants Master
Les composants du plan de contrôle de K8s :
etcd : Base de données clé-valeur
consistante et hautement disponible
utilisée comme mémoire de sauvegarde
pour toutes les données du cluster.
API server : Composant qui expose l’API
Kubernetes.
Scheduler : L’ordonnanceur qui permet de
sélectionner quel Node devra faire tourner
un Pod.
Controller Manager : Processus dans
lequel s’exécute les contrôleurs principaux
de Kubernetes tels que Node Controller,
Replication Controller, Endpoints
Controller et Service Account & Token
Controllers.
Architecture de Kubernetes : Composants du Nœud
Kubernetes Node
Aussi appelé Worker, est une machine
unique (physique ou virtuelle) où des
conteneurs sont déployés.
Chaque Node du cluster doit faire tourner un
environnement de conteneurisation, ainsi
que deux autres composants pour
communiquer avec le Kubernetes Master.
Architecture de Kubernetes : Composants du Nœud
Les composants d’un Worker sont:
Kubelet : Un agent qui s'exécute sur
chaque nœud du cluster. Il s'assure que
les conteneurs fonctionnent correctement
dans un pod. Il le fait à base de PodSpecs
fournis par divers mécanismes.
Kube-proxy : Un proxy réseau qui
s'exécute sur chaque nœud du cluster. Il
est responsable du routage de trafic vers
le conteneur approprié (depuis des
sessions réseau à l'intérieur ou à
l'extérieur du cluster).
Container Runtime : Le programme
responsable de l'exécution des
conteneurs. Kubernetes supporte tout
projet respectant le standard OCI (Open
Container Initiative) tels que containerd,
cri-o, roket, et autres.
Architecture de Kubernetes : Suppléments
Addons
En plus des composants de base de K8s, les addons sont des composants supplémentaires qui
utilisent les ressources Kubernetes pour implémenter des fonctionnalités cluster.
Exemples :
• DNS cluster
• Interface utilisateur Web (Dashboard)
• La surveillance des ressources de conteneur
• Le logging au niveau cluster
• etc.
Ce qui rend K8s une plateforme extensible.
1 Besoin : Orchestration des conteneurs
2 Kubernetes (K8s) : vue d’ensemble
3 Architecture de Kubernetes
4 Objets Kubernetes
5 Contrôleurs Kubernetes
6 Minikube : Kubernetes en local
7 Kubectl : Commandes de base
8 Fichiers de configuration YAML
9 Technologies connexes
10 Un peu de pratique !
Objets Kubernetes
Kubernetes contient un certain nombre d'abstractions représentant l'état du système. Par exemple :
• Quelles applications conteneurisées sont en cours d'exécution (et sur quels nœuds)
• Les ressources (réseau et disque) disponibles pour ces applications
• Les stratégies relatives au comportement de ces applications, telles que les stratégies de
redémarrage, les mises à niveau et la tolérance aux pannes.
Ces abstractions sont représentées par des objets de l'API Kubernetes.
Un objet est exprimé via un fichier au format YAML.
Les objets de base de Kubernetes incluent :
a. Pod
b. Service
c. Ingress
d. Namespace
e. Volume
Objets Kubernetes
Exemple d’une
ressource Pod
a. Pod
Un Pod est l'unité d'exécution de base d'une application
Kubernetes. Il peut être constitué d’un unique conteneur ou d’un
petit nombre de conteneurs qui sont étroitement liés et qui
partagent des ressources.
Les conteneurs du Pod :
Sont toujours démarrés, arrêtés et répliqués en groupe.
Partagent le même réseau, namespace, adresse IP et port.
Peuvent communiquer ensemble en utilisant localhost.
Peuvent partager des données via des shared volumes.
Le Pod est l’entité de base qui va être répliquée et qui va être
mise sur différents nœuds du cluster.
Pods & Containers (Explication) Documentation officielle
Objets Kubernetes
b. Service Exemple d’une
ressource Service
Un service est une abstraction qui définit un ensemble logique de
pods et une politique permettant d'y accéder.
L'ensemble des pods ciblés par un service est généralement déterminé
par un selector.
Les cycles de vie d’un service et d’un Pod sont indépendants.
Il existe Différents types de services :
ClusterIP services NodePort services
ExternalName services LoadBalancer services
Kubernetes Services (Explication) Documentation officielle
Objets Kubernetes
c. Ingress Exemple d’une ressource Ingress
Un Ingress est un objet Kubernetes qui gère l'accès
externe aux services dans un cluster, généralement
du trafic HTTP.
Un Ingress peut fournir un équilibrage de charge, une
terminaison TLS et un hébergement virtuel basé sur
un nom.
Documentation officielle
Kubernetes Ingress (Explication)
Objets Kubernetes
d. Namespace
Kubernetes prend en charge plusieurs clusters virtuels présents sur le même cluster physique. Ces
clusters virtuels sont appelés namespaces (espaces de nommage en français).
Les namespaces sont un moyen de répartir les ressources d'un cluster entre plusieurs utilisateurs.
Les namespaces sont destinés à être utilisés dans les environnements ayant de nombreux
utilisateurs répartis en plusieurs équipes ou projets.
Kubernetes Namespaces (Explication) Documentation officielle
Objets Kubernetes
Exemple
e. Volume
Les fichiers sur disque dans un conteneur sont éphémères.
Problème 1 : Lorsqu'un conteneur plante, kubelet va le
redémarrer mais ses données seront perdus (le conteneur
démarre avec un état propre).
Problème 2 : lorsque plusieurs conteneurs s'exécutent ensemble
dans un pod, il est souvent nécessaire de partager des fichiers
entre ces conteneurs.
L'abstraction Kubernetes Volumes résout ces deux problèmes.
Un volume est configuré au niveau de la partie spec lors de la création
d’un pod.
Kubernetes supporte plusieurs types de Volumes.
Kubernetes Volumes (Explication) Documentation officielle
BONUS : Autres Objets Kubernetes
ConfigMap
Exemple
Un ConfigMap est un objet utilisé pour stocker des données non
confidentielles sous forme de paires "clé-valeur".
Les pods peuvent utiliser les ConfigMaps en tant que :
- variables d'environnement
- arguments de ligne de commande
- fichiers de configuration dans un volume.
Un ConfigMap permet de dissocier la configuration spécifique à
l'environnement des images de conteneur, afin que les applications
soient facilement portables.
Kubernetes ConfigMap (Explication) Documentation Officielle
BONUS : Autres Objets Kubernetes
Secrets
Exemple
Un Secret est un objet qui contient une petite quantité de données
sensibles telles qu'un mot de passe, un jeton (token) ou une clé.
- Ces informations pourraient autrement être placées dans une spécification de
pod ou dans une image de conteneur.
- L'utilisation d'un secret signifie qu’on n’a pas besoin d'inclure des données
confidentielles dans le code d'application.
Les Secrets sont similaires aux ConfigMaps mais sont spécifiquement
destinés à contenir des données confidentielles.
Kubernetes Secrets (Explication) Documentation Officielle
1 Besoin : Orchestration des conteneurs
2 Kubernetes (K8s) : vue d’ensemble
3 Architecture de Kubernetes
4 Objets Kubernetes
5 Contrôleurs Kubernetes
6 Minikube : Kubernetes en local
7 Kubectl : Commandes de base
8 Fichiers de configuration YAML
9 Technologies connexes
10 Un peu de pratique !
Contrôleurs Kubernetes
En plus des objets, Kubernetes contient un certain nombre d'abstractions de niveau
supérieur appelées Contrôleurs.
Les contrôleurs s'appuient sur les objets de base et fournissent des fonctionnalités
supplémentaires.
Voici quelques exemples:
a. Deployment
b. ReplicaSet
c. StatefulSet
d. DaemonSet
e. Job
Contrôleurs Kubernetes
a. Deployment
C’est le fichier dans lequel on décrit la cible à atteindre.
• Les conteneurs qu’on veut mettre dans le Pod
• Les détails de réplication
• Les stratégies à suivre pour les mises à jour
Un Deployment (déploiement en français) fournit des mises à jour déclaratives pour Pods et
ReplicaSets.
On décrit un état désiré dans un déploiement et K8s change l'état réel à l'état souhaité à un rythme
contrôlé.
Documentation officielle
Exemple
Contrôleurs Kubernetes
a. Deployment (exemple illustratif)
Dans cet exemple :
Un déploiement nommé nginx-deployment est créé, indiqué par le champ
metadata:name
Le déploiement crée trois Pods répliqués, indiqués par le champ replicas
Le modèle de Pod, ou le champ spec:template, indique que ces pods sont
libellés app:nginx
La spécification du modèle de pod, ou du champ template:spec, indique que les
pods exécutent un conteneur nommé nginx qui exécute l’image Docker Hub
nginx dans sa version 1.7.9
Le déploiement ouvre le port 80 pour une utilisation par les pods
En résumé, nous avons ces instructions à réaliser par chaque pod créé :
Chaque pod est nommé app:nginx
Créer un conteneur et le nommer nginx
Exécuter l’image nginx dans la version 1.7.9
Ouvrir le port 80 pour envoyer et recevoir du trafic
Contrôleurs Kubernetes
Exemple
b. ReplicaSet
Un ReplicaSet (ensemble de réplicas en français) est
un contrôleur K8s qui a pour but de maintenir un
ensemble stable de Pods à un moment donné.
Il est souvent utilisé pour garantir la disponibilité d'un
certain nombre identique de Pods.
Documentation officielle
Kubernetes ReplicaSet (Explication)
Contrôleurs Kubernetes
c. StatefulSet
Un StatefulSet est le contrôleur
utilisé pour gérer les
applications avec état.
Il gère le déploiement et la
mise à l'échelle d'un ensemble
de pods et fournit des garanties
sur l'ordre et l'unicité de ces
pods.
Documentation officielle
Kubernetes StatefulSet (Explication)
Contrôleurs Kubernetes
d. DaemonSet
Un DaemonSet est un contrôleur qui garantit que tous (ou certains)
nœuds exécutent une copie d'un pod.
Au fur et à mesure que des nœuds sont ajoutés au cluster, des pods
leur sont ajoutés.
Lorsque les nœuds sont supprimés du cluster, ces pods sont
récupérés.
La suppression d'un DaemonSet nettoiera les pods qu'il a créés.
Des cas d’utilisation typiques d'un DaemonSet sont:
• exécution d'un démon de stockage en cluster sur chaque nœud
• exécution d'un démon de collecte de journaux (logs) sur chaque nœud
• exécution d'un démon de supervision de nœud sur chaque nœud
Kubernetes DaemonSet (Explication) Documentation officielle
Contrôleurs Kubernetes
e. Job
Un Job crée un ou plusieurs pods et s'assure
qu'un certain nombre d'entre eux se terminent
correctement.
Lorsqu'un nombre spécifié d'exécutions
réussies est atteint, la tâche (c'est-à-dire, Job)
est terminée.
Un cas simple consiste à créer un objet Job afin d'exécuter de manière fiable un pod jusqu'à la fin.
L'objet Job démarrera un nouveau pod si le premier pod échoue ou est supprimé.
Il est aussi possible d’utiliser un Job pour exécuter plusieurs pods en parallèle.
Kubernetes Jobs (Explication) Documentation officielle
Fonctionnement de Kubernetes : Récapitulatif
Pour travailler avec Kubernetes, on utilise les objets de l'API K8s pour décrire dans un fichier YAML l'état souhaité
d’un cluster:
Quelles applications on souhaite exécuter? Quelles images de conteneur elles utilisent ? Le nombre de réplicas ?
Les ressources réseau et disque qu’on doit mettre à disposition ? etc.
Généralement, on applique ce fichier via l'interface en ligne de commande, kubectl.
Une fois qu’on a défini l'état souhaité, le plan de contrôle Kubernetes (control plane en anglais) permet de faire en
sorte que l'état actuel du cluster corresponde à l'état souhaité.
Pour ce faire, Kubernetes effectue automatiquement diverses tâches, telles que le démarrage ou le redémarrage de
conteneurs, la mise à jour du nombre de réplicas d'une application donnée, etc.
Le plan de contrôle Kubernetes comprend un ensemble de processus en cours d'exécution sur un cluster:
Le Kubernetes master qui est un ensemble de trois processus (+ une BD etcd) qui s'exécutent sur un seul nœud du cluster,
désigné comme master node. Ces processus sont: API Server, Controller Manager et Scheduler.
Chaque nœud non maître du cluster (worker node) contient un container runtime et exécute deux processus:
kubelet, qui communique avec le Kubernetes master.
kube-proxy, un proxy réseau reflétant les services réseau Kubernetes sur chaque nœud.
1 Besoin : Orchestration des conteneurs
2 Kubernetes (K8s) : vue d’ensemble
3 Architecture de Kubernetes
4 Objets Kubernetes
5 Contrôleurs Kubernetes
6 Minikube : Kubernetes en local
7 Kubectl : Commandes de base
8 Fichiers de configuration YAML
9 Technologies connexes
10 Un peu de pratique !
Kubernetes en local
Un seul Node d’un cluster Kubernetes exécuté dans une machine virtuelle.
Il comporte dans le même Node un Master Kubernetes et un Worker Kubernetes.
Il inclut Docker comme environnement d’exécution des conteneurs
Master processes
Master Master
Hyperviseur
Worker processes
Node Node Node Node Node Ordinateur
En production En local
Installer Minikube
Kubernetes en local
Après l’installation, on pourra lancer un cluster avec (par exemple) Virtualbox comme driver :
$ minikube start --vm-driver=virtualbox
Il est maintenant possible d’interagir avec le cluster via des commandes kubectl :
(par exemple: afficher le statut des nodes)
$ kubectl get nodes
Les commandes minikube peuvent aussi être utilisées :
Par exemple:
afficher le statut des composants K8s ou stopper un cluster ou afficher un tableau de bord.
$ minikube status $ minikube stop $ minikube dashboard
Kubernetes en local : autres projets
MicroK8s kind
k3d k3s
(a lightweight wrapper to run k3s in Docker)
Bonus : Outils pour installer son propre cluster Kubernetes
on-premises et fournisseurs de cloud
Bonus : Kubernetes dans le Cloud
Managed Cloud Services
Amazon Elastic Kubernetes Service Azure Kubernetes Service (AKS)
(EKS)
1 Besoin : Orchestration des conteneurs
2 Kubernetes (K8s) : vue d’ensemble
3 Architecture de Kubernetes
4 Objets Kubernetes
5 Contrôleurs Kubernetes
6 Minikube : Kubernetes en local
7 Kubectl : Commandes de base
8 Fichiers de configuration YAML
9 Technologies connexes
10 Un peu de pratique !
Kubectl : Commandes de base
Commandes CRUD
• Créer un déploiement $ kubectl create deployment [name]
• Modifier un déploiement $ kubectl edit deployment [name]
• Supprimer un déploiement $ kubectl delete deployment [name]
Statuts des différents K8s composants
$ kubectl get nodes | pod | services | replicaset | deployment
Débogage des pods
• Se connecter à la console $ kubectl logs [pod name]
• Terminal interactif $ kubectl exec -it [pod name] –bin/bash
Kubectl : Commandes de base
Utiliser le fichier de configuration YAML pour les opérations CRUD
• Création : en appliquant un fichier de configuration
$ kubectl apply -f [file name]
• Modification : On modifie le fichier et on applique la même commande
• Suppression : en appliquant un fichier de configuration
$ kubectl delete -f [file name]
1 Besoin : Orchestration des conteneurs
2 Kubernetes (K8s) : vue d’ensemble
3 Architecture de Kubernetes
4 Objets Kubernetes
5 Contrôleurs Kubernetes
6 Minikube : Kubernetes en local
7 Kubectl : Commandes de base
8 Fichiers de configuration YAML
9 Technologies connexes
10 Un peu de pratique !
Fichier de configuration YAML
Les 3 parties des fichiers de configuration de K8s
Deployment Service
Déclarations initiales
1. Metadata
2. Specification
Avec des attributs
spécifiques au type
du fichier
3. Status
Automatiquement généré
et ajouté par K8s
Fichier de configuration YAML
Les 3 parties des fichiers de configuration de K8s
3. Status
K8s s’occupe de l’ajout
automatique de cette partie
status lors de la création
d’un déploiement.
!= K8s actualise l’état des
clusters régulièrement et le
compare avec l’état désiré.
S’il y a non respect de l’état
désiré, K8s intervient pour
corriger les choses.
Desired != Actual
K8s intervient
Desired = Actual (*) : C’est le composant etcd qui contient ces différents états.
Fichier de configuration YAML
Configurations du Pod
Deployment
Les niveaux
d’abstraction Pod
Container
template
Concerne le Pod
A ses propres sections metadata et spec.
spec
le "blueprint" du Pod
(nom du conteneur, quelle image utiliser?
quel port ? etc.)
Fichier de configuration YAML
Connecter les composants avec les: Labels, Selectors, Ports
Deployment
Metadata
Contient un labels
Specification
Contient un selector
On associe à chaque composant (deployment ou pod) un nom via :
Pour faire le lien entre les deux noms (du deployment et du pod), on utilise :
Fichier de configuration YAML
Connecter le service avec le Deployment et le Pod
Deployment Service
app doit contenir la même valeur.
Fichier de configuration YAML
Connecter les ports du Service et du Pod
Deployment Service
Pod
targetPort: 8080
Pod
Nginx
service Nginx service
port: 80
Pod
DB
service DB service
Node
Fichier de configuration YAML
Rappel (commandes kubectl)
Pour créer le deployment à base du fichier [Link] :
$ kubectl apply -f [Link]
Pour créer le service à base du fichier [Link] :
$ kubectl apply -f [Link]
Résultat :
Fichier de configuration YAML
Afficher la partie "status"
$ kubectl get deployment nginx-deployment –o yaml
Résultat :
Pour générer ce résultat dans un fichier nommé [Link]
$ kubectl get deployment nginx-deployment –o yaml > [Link]
Fichier de configuration YAML
Supprimer un deployment
$ kubectl delete –f [Link]
Résultat :
Supprimer un service
$ kubectl delete –f [Link]
Résultat :
1 Besoin : Orchestration des conteneurs
2 Kubernetes (K8s) : vue d’ensemble
3 Architecture de Kubernetes
4 Objets Kubernetes
5 Contrôleurs Kubernetes
6 Minikube : Kubernetes en local
7 Kubectl : Commandes de base
8 Fichiers de configuration YAML
9 Technologies connexes
10 Un peu de pratique !
Ecosystème des outils connexes et complémentaires
Istio
Source
Package Manager
Helm est un package manager pour Kubernetes.
Il gère le cycle de vie des applications K8s :
Déployer la nouvelle version d'un service, restaurer, supprimer, etc.
Dans Helm, on trouve 3 concepts importants :
1. Chart : est un ensemble d'informations nécessaires pour créer une instance d'une application
Kubernetes.
2. Config : contient des informations de configuration qui peuvent être fusionnées dans un chart
empaqueté pour créer un objet livrable.
3. Release : est une instance en cours d'exécution d’un chart, combinée à une configuration
spécifique.
Architecture de Helm
Site Web officiel
1 Besoin : Orchestration des conteneurs
2 Kubernetes (K8s) : vue d’ensemble
3 Architecture de Kubernetes
4 Objets Kubernetes
5 Contrôleurs Kubernetes
6 Minikube : Kubernetes en local
7 Kubectl : Commandes de base
8 Fichiers de configuration YAML
9 Technologies connexes
10 Un peu de pratique !
Lab : Kubernetes
Play with Kubernetes
Or
Official tutorials
Blog articles : Kubernetes
Kubernetes — What Is It, What Problems Does It Solve and
How Does It Compare With Alternatives?
Kubernetes: A Detailed Example of Deployment of a Stateful
Application
(Il est fortement recommandé de lire ces deux articles)
Blog articles : Kubernetes
The Kubernetes Handbook
Un très bon article/cours (couvrant l’essentiel d’une manière bien résumée)
