Qu’est-ce que Kubernetes ? Introduction et Fonctionnement

Découvrez comment Kubernetes (K8S) transforme la gestion des conteneurs grâce à son orchestration avancée et son efficacité. Apprenez pourquoi il est devenu essentiel pour déployer, gérer et faire évoluer vos applications modernes

Dans un précedent article, nous avons vu comment Docker et la conteneurisation ont revolutionné le développement, le déploiement et la gestion des applications. Les conteneurs isolent applications et ses dépendances dans des environnements portables et reproductibles facilitant les livraisons. Ils sont donc une réponse technologique permettant l'implémentation concrète de la philosophie DevOps.

Cependant, l'adoption massive des conteneurs a introduit un besoin urgent de solutions robustes pour la production dans les règles de l'art. Comment gérer les conteneurs à grande échelle et dans un contexte à fort traffic ? C'est ici que Kubernetes rentre en scène pour apporter une solution à ces problèmatiques.

Développé initiallement par Google et maintenant soutenu par une large communauté open-source, Kubernetes est devenu aujourd'hui la référence pour l'orchestration et la gestion des conteneurs.

Cet article a pour objectif de vous faire découvrir Kubernetes et comprendre ce qu'il peut vous apporter dans votre activité quotidienne. En explorant son fonctionnement et ses concepts clés, Vous comprendrez pourquoi il est devenu crucial dans la gestion moderne des applications.

Pour tester les exemples décrits dans cet article, vous pouvez installer Docker Desktop en vous laissant guidant par ce guide :

Kubernetes c'est quoi ?

Kubernetes: Le Chef d’Orchestre des Conteneurs

Le logo de Kubernetes (source: kubernetes.io)

Kubernetes, aussi abbregé par K8S, fonctionne comme le chef d’orchestre d’un grand ensemble symphonique. Imaginez une scène où chaque conteneur est un musicien avec son propre instrument. Kubernetes coordonne harmonieusement ces musiciens pour s’assurer que chaque note est jouée au bon moment, que l’ensemble est bien accordé et que la performance se déroule sans accroc.

Il gère le déploiement des applications comme un chef d’orchestre dispose les partitions, ajuste le volume en fonction des besoins (scaling) et veille à ce que chaque musicien ait tout ce dont il a besoin pour jouer (gestion des ressources).

En libérant les développeurs des complexités liées à la gestion des infrastructures, Kubernetes leur permet de se concentrer sur l’écriture de leur “musique”, tout en assurant une performance fluide et orchestrée de leurs applications.

💡

Kubernetes orchestre vos conteneurs avec précision, garantissant une gestion fluide des applications et simplifiant l’infrastructure pour les développeurs

L’Origine de Kubernetes : De Borg à la Révolution Open-Source

Architecture de haut niveau d'un cluster Google Borg (source: sre.google)

Kubernetes trouve ses racines dans Borg, un système interne développé par Google pour orchestrer ses vastes infrastructures. Borg a permis à Google de gérer des milliers de clusters et de maximiser l’efficacité de ses ressources. Fort de cette expérience, l’équipe de Google a décidé de créer un outil open-source, accessible à tous, pour transformer la gestion des conteneurs. C'est ainsi qu'est né Kubernetes !

En s’appuyant sur les leçons tirées de Borg, Kubernetes offre une plateforme robuste et flexible, facilitant le déploiement, la gestion et la scalabilité des applications.

En quelques années, Kubernetes est devenu le standard de facto pour l’orchestration de conteneurs. L’histoire de Kubernetes ne s’arrête pas là. En 2015, la Linux Foundation crée Cloud Native Computing Foundation (CNCF) pour soutenir son développement et péreniser son adoption.

La CNCF joue un rôle crucial en soutenant et en promouvant des projets open-source dans l’écosystème cloud natif. Kubernetes est le fer de lance de cette initiative.

“L’écosystème cloud-native est un ensemble de pratiques, outils et technologies qui permettent aux organisations de concevoir, déployer et gérer des applications de manière plus efficace, en tirant parti des caractéristiques des environnements cloud, tels que l’élasticité, la scalabilité et l’automatisation.”

💡

La scalabilité se réfère à la capacité d’un système à augmenter ou diminuer ses ressources (comme le nombre de serveurs ou de machines virtuelles) en fonction de la demande.

💡

L’élasticité est la capacité d’un système à ajuster automatiquement ses ressources en réponse aux fluctuations de la demande. Contrairement à la scalabilité, qui est souvent planifiée et gérée manuellement, l’élasticité est dynamique et automatique.

Grâce à la CNCF, Kubernetes bénéficie d’un soutien communautaire continu et d’une feuille de route claire, ce qui favorise son adoption à large échelle. La fondation a également encouragé l’émergence d’un écosystème riche autour de Kubernetes, incluant des outils complémentaires et des standards ouverts :

Ce soutien a permis à Kubernetes de s’imposer comme une plateforme incontournable, intégrant les meilleures innovations du monde open-source et offrant une solution puissante pour la gestion des conteneurs.

💡

Kubernetes, né de l’expérience de Google avec Borg, a révolutionné la gestion des conteneurs. Soutenu par la CNCF, il est devenu le standard pour l’orchestration des applications, facilitant leur déploiement et scalabilité à l’échelle mondiale

Comment Kubernetes Fonctionne ?

Kubernetes a transformé la gestion des applications conteneurisées en introduisant une architecture sophistiquée qui facilite l’orchestration à grande échelle. Mais comment ce puissant système parvient-il à orchestrer et à gérer efficacement les conteneurs dans des environnements complexes ?

Dans cette section, nous allons plonger dans l’architecture fondamentale de Kubernetes et explorer ses composants clés. Vous découvrirez les mécanismes sous-jacents qui permettent à Kubernetes de déployer, gérer et scaler les applications de manière fluide et efficace.

Architecture de Kubernetes

Kubernetes repose sur une architecture maître-agent qui se compose du plan de contrôle (control plane) et des nœuds (nodes).

Components of Kubernetes — Les composants d'un cluster Kubernetes (source: kubernetes.io)

Noeud Master ou Plan de Contrôle

Le nœud maître est le cerveau de Kubernetes orchestrant et supervisant les opérations du cluster. Voici ses principales responsabilités :

Gestion de l’état global du cluster : Le nœud maître surveille continuellement l’état des nœuds et des pods pour assurer la cohérence entre l’état désiré et l’état réel des ressources. Il veille à ce que le cluster fonctionne conformément aux spécifications définies.
Coordonner les tâches : Il distribue les tâches de déploiement et de mise à jour des applications. En organisant la planification des pods sur les nœuds disponibles, le nœud maître assure une répartition efficace des ressources et une gestion fluide des opérations.
Prendre des décisions sur le déploiement des applications : Le nœud maître évalue les besoins en ressources des applications et automatise leur déploiement et leur mise à l’échelle. Il ajuste les ressources en fonction des conditions actuelles et des objectifs définis, garantissant ainsi que les applications bénéficient des ressources nécessaires pour fonctionner de manière optimale.

Pour atteindre ces objectifs, le nœud maître repose sur les composants suivants :

• API Server : Interface principale pour les interactions avec Kubernetes. Il reçoit les commandes des utilisateurs et des autres composants.

• Scheduler : Attribue les tâches aux nœuds de travail en fonction des ressources disponibles et des exigences des applications.

• Controller Manager : Supervise les différents contrôleurs qui gèrent les états des applications et des services.

• etcd : Base de données clé-valeur utilisée pour stocker la configuration et l’état du cluster.

💡

Un cluster peut avoir un ou plusieurs noeuds master pour assurer la haute-disponibilité de la plateforme Kubernetes

Nœuds (Nodes)

Les nœuds sont les machines physiques ou virtuelles qui exécutent les conteneurs. Chaque nœud fonctionne comme une unité de calcul (worker) dans le cluster Kubernetes et joue un rôle crucial dans l’exécution des applications :

• Kubelet : Agent qui s’assure que les conteneurs sont exécutés correctement sur le nœud.

• Kube-Proxy : Gère le routage du réseau et assure la communication entre les services.

• Container Runtime : Le logiciel responsable de l’exécution des conteneurs, comme Docker ou containerd.

La Puissance par l'Abstraction

Kubernetes se distingue par sa capacité à gérer les applications grace à un modèle d'abstraction efficace. Plutôt que de manipuler chaque conteneur individuellement, Kubernetes propose des composants pour faciliter la gestion des applications et l'orchestration des conteneurs. Ces composants peuvent être définis dans des fichiers YAML appelées manifestes.

Les Pods : L’Unité de Base de Kubernetes

Un Pod est le plus petit objet déployable dans Kubernetes. Il encapsule un ou plusieurs conteneurs partageant le même réseau et stockage. Les conteneurs au sein d’un Pod fonctionnent ensemble et sont souvent conçus pour fonctionner comme une seule unité cohérente.

Chaque Pod reçoit un identifiant unique dans le cluster, ce qui permet à Kubernetes de gérer efficacement les déploiements, les mises à jour et les répliques de Pods.

Les Pods ont un cycle de vie propre, contrôlé par Kubernetes. Ils peuvent être créés, supprimés et répliqués selon les besoins définis par les objets de gestion comme les Deployments et ReplicaSets que nous verrons juste après.

$ kubectl run nginx-example --image=nginx:latest --port=80 --restart=Never
pod/nginx-example created
$ kubectl get pods
NAME                  READY   STATUS    RESTARTS      AGE
nginx-example         1/1     Running   0             20s
$ kubectl port-forward pod/nginx-example 8080:80
$ curl http://localhost:8080

Par exemple, un Pod pourrait contenir un conteneur principal pour une application web et un autre conteneur pour les tâches de traitement en arrière-plan :

*Un pod multi-conteneurs contenant un extracteur de fichiers et un serveur web utilisant un volume persistant comme espace de stockage partagé entre les conteneurs.* (source: kubernetes.io)

Le diagramme ci-dessous peut être décrit sous forme de manifeste comme ceci :

apiVersion: v1
kind: Pod
metadata:
  name: file-puller-and-web-server
spec:
  containers:
  - name: file-puller
    image: your-file-puller-image:latest
    volumeMounts:
    - name: shared-storage
      mountPath: /data
    # Commande pour l'extraction des fichiers
    command: ["/bin/sh", "-c", "run-file-puller.sh"]

  - name: web-server
    image: your-web-server-image:latest
    ports:
    - containerPort: 80
    volumeMounts:
    - name: shared-storage
      mountPath: /usr/share/nginx/html
    # Configuration supplémentaire pour le serveur web, si nécessaire

  volumes:
  - name: shared-storage
    persistentVolumeClaim:
      claimName: my-pvc

exemple-pod.yaml

Explication du manifeste

apiVersion : v1 indique que le manifeste utilise la version 1 de l’API Kubernetes. La version v1 est stable et largement utilisée pour les ressources fondamentales
kind : Le champ kind indique le type de ressource que vous définissez dans le manifeste. C’est ce qui permet à Kubernetes de comprendre le type d’objet à créer ou gérer, en se basant sur la version de l’API spécifiée.
metadata :
spec: Contient la configuration des conteneurs et des volumes
- containers:
  - file-puller: Ce conteneur exécute l’image your-file-puller-image:latest (remplacez par l’image appropriée). Il monte le volume persistant à /data pour le traitement des fichiers. La commande run-file-puller.sh est utilisée pour lancer l’extraction des fichiers.
  - web-server : Ce conteneur exécute l’image your-web-server-image:latest (remplacez par l’image appropriée). Il expose le port 80 pour le serveur web et monte le même volume persistant à /usr/share/nginx/html pour servir les fichiers extraits.
- volumes : Définit un volume nommé shared-storage qui se base sur un PersistentVolumeClaim nommé my-pvc. Ce PVC doit être préalablement créé et configuré pour gérer le stockage persistant nécessaire.

Le manifeste peut être déployé à l'aide de la commande kubectl :

# Création du pod à partir de manifeste
$ kubectl create -f exemple-pod.yaml

# Suppression du pod à partir du manifeste
$ kubectl delete -f exemple-pod.yaml

Les Deployments: Simplifier la Gestion des Applications à Grande Échelle

Imaginez que vous déployez une application web avec plusieurs instances (pods) pour assurer sa disponibilité et sa résilience. Plutôt que de gérer chaque instance de Pod individuellement comme vu précedemment, vous pouvez faire plus efficace en utilisant un Deployment :

Diagramme de fonctionnement d'un Deployment Kubernetes avec un ReplicaSet et ses Pods — Diagramme de fonctionnement d'un Deployment Kubernetes (source : carnets-du-devops.fr)

Un Deployment s’appuie sur un ReplicaSet pour s’assurer que le nombre souhaité de pods est toujours maintenu, en veillant à ce que le nombre de pods en cours d’exécution corresponde au nombre désiré.

Supposons que vous souhaitiez déployer une application web utilisant l’image Docker nginx:latest. Vous pouvez définir un Deployment pour scaler le nombre de Pods.

Voici comment vous pouvez créer ce Deployment et l'augmenter à 3 réplicas en utilisant kubectl :

$ kubectl create deployment nginx-deployment --image=nginx:latest
$ kubectl get deployment nginx-deployment
NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   1/1     1            1           5s
$ kubectl scale deployment nginx-deployment --replicas=3

Création d'un Deployment dans Kubernetes et scale du nombre de replicas

Voici un équivalent de manifeste pour créer le Deployment :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

deployment.yaml

Les Services : La Découverte et l’Exposition des Applications

Dans Kubernetes, les Services jouent un rôle crucial en facilitant la découverte et l’exposition des applications. Ils offrent une abstraction réseau qui permet de regrouper un ensemble de pods et de fournir un point d’accès stable et unique, même lorsque les pods individuels sont créés ou détruits. Cela est particulièrement utile pour gérer les applications distribuées, où les adresses IP des pods peuvent changer fréquemment.

Répartition de traffic entre les Pods via un Service (source: carnets-du-devops.fr)

Les Services permettent également de distribuer le trafic entrant vers les pods appropriés, assurant ainsi la répartition de la charge et l’accès constant à l’application. Ils peuvent exposer une application à l’intérieur du cluster Kubernetes, à d’autres services, ou même au monde extérieur, selon la configuration choisie (ClusterIP, NodePort, LoadBalancer).

Les Services simplifient la gestion des connexions réseau, en garantissant que les utilisateurs et les autres applications puissent toujours accéder aux services déployés de manière fiable et transparente.

Voici un exemple d'un Service qui va exposer plusieurs instances de serveurs web d'un Deployment :

apiVersion: v1
kind: Service
metadata:
  name: web-service
spec:
  selector:
    app: web-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

service.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: web-app-container
        image: nginx:latest
        ports:
        - containerPort: 80

deployment.yaml

💡

Le lien entre le service et les pods est fait à partir des labels des pods et du selecteur du service (ici web-app)

L’Autoscaling : L’Adaptation Dynamique aux Besoins

Nous avons exploré comment augmenter ou diminuer manuellement le nombre de réplicas d’un Deployment. Mais il est aussi possible d’ajuster dynamiquement le nombre de pods selon la charge de travail et les besoins de l’application. Avec des outils comme le Horizontal Pod Autoscaler (HPA), Kubernetes surveille des métriques comme l’utilisation du CPU ou de la mémoire.

Le HPA ajuste automatiquement le nombre de réplicas pour maintenir des performances optimales. Ainsi, on garantit que les applications disposent des ressources nécessaires pour gérer les pics de trafic, tout en réduisant les coûts grâce à la minimisation des ressources inutilisées lorsque la demande est faible. L’autoscaling apporte flexibilité et réactivité, permettant aux applications de s’adapter en temps réel aux variations de la demande.

Cette capacité à scaler de manière autonome est cruciale pour les architectures modernes, surtout dans le cloud, où la gestion des coûts et des ressources est primordiale. En automatisant le scaling, Kubernetes décharge les équipes de développement des tâches manuelles et améliore la résilience des services, assurant ainsi une disponibilité constante.

Dans cet exemple, l’HPA surveille les pods du Deployment nommé nginx-deployment :

apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: nginx-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx-deployment
  minReplicas: 2
  maxReplicas: 10
  targetCPUUtilizationPercentage: 80

Il essaiera de maintenir l’utilisation moyenne du CPU autour de 80%.
Si l’utilisation moyenne dépasse ce seuil, l’HPA augmentera le nombre de réplicas jusqu’à un maximum de 10.
Si l’utilisation est inférieure à 80%, le nombre de réplicas peut être réduit, mais pas en dessous de 2.

Essayer Kubernetes c'est l'Adopter !

Découvrir Kubernetes, c’est bien souvent l’adopter. Ce système d’orchestration de conteneurs n’est pas seulement une solution technique. C’est une véritable transformation dans la manière dont vous gérez et déployez vos applications.

Améliorer l’Expérience Développeur (DX)

Kubernetes transforme l’expérience développeur (DX) en simplifiant considérablement la gestion des applications. Grâce à son approche déclarative et ses outils d’automatisation, Kubernetes élimine les tâches répétitives et réduit les erreurs humaines lors des déploiements. La mise à l’échelle dynamique et la gestion centralisée des configurations permettent aux développeurs de se concentrer sur l’innovation plutôt que sur l’administration des systèmes.

Avec des outils intégrés pour le monitoring et le debugging, ainsi qu’une documentation exhaustive et une communauté active, Kubernetes offre une expérience fluide et efficace, facilitant ainsi le développement, le déploiement et la gestion des applications à grande échelle.

Simplification des Déploiements

L’un des aspects les plus appréciés de Kubernetes est la facilité avec laquelle il gère les déploiements. Grâce à des outils comme les Deployments et les ReplicaSets, mettre à jour une application devient un processus fluide et sans heurts. L’intégration des fonctionnalités de mise à jour continue et de rollback automatique vous permet de déployer vos applications avec une confiance accrue, tout en minimisant les risques d’interruption de service.

Scalabilité et Résilience Automatiques

Kubernetes excelle dans l’adaptation automatique aux variations de la charge de travail. Avec le Horizontal Pod Autoscaler et le Vertical Pod Autoscaler, Kubernetes ajuste le nombre de réplicas et les ressources allouées en temps réel pour répondre à la demande, garantissant ainsi des performances optimales. Cette capacité à évoluer en fonction des besoins renforce non seulement la résilience mais optimise également les coûts.

Un Gestion Simplifiée

Au fur et à mesure que vous explorez Kubernetes, vous apprécierez la simplicité de sa gestion. L’interface utilisateur intuitive de Kubernetes et ses puissantes APIs permettent de gérer les clusters et les applications avec une grande facilité. L’expérience pratique démontre comment Kubernetes libère les équipes de développement des tâches manuelles, en automatisant les processus complexes et en améliorant la résilience des services.

Un Ecosystème Riche

Kubernetes ne se limite pas à son noyau de gestion des conteneurs ; il est au cœur d’un écosystème vaste et dynamique qui enrichit considérablement ses fonctionnalités. Cette richesse offre aux utilisateurs une flexibilité accrue et des capacités étendues pour répondre à divers besoins opérationnels.

Outils Complémentaires

Kubernetes s’intègre avec une gamme étendue d’outils complémentaires qui optimisent et enrichissent l’expérience utilisateur. Par exemple, Helm simplifie la gestion des applications en fournissant un système de gestion des paquets pour Kubernetes, tandis que Prometheus et Grafana offrent des solutions robustes pour le monitoring et la visualisation des performances.

Ces outils permettent de personnaliser et d’adapter Kubernetes à vos besoins spécifiques, facilitant ainsi la gestion des clusters et des applications.

Extensions et Plugins

Le modèle de Kubernetes encourage les extensions et les plugins pour ajouter des fonctionnalités spécifiques. Les Opérateurs Kubernetes permettent de gérer des applications complexes et des services avec des automatisations personnalisées. Les Custom Resource Definitions (CRD) permettent d’étendre l’API Kubernetes pour gérer des ressources spécifiques à votre domaine, tout en intégrant des solutions tierces.

Support de la Communauté

La communauté Kubernetes joue un rôle crucial dans la croissance et l’enrichissement de l’écosystème. Grâce à la Cloud Native Computing Foundation (CNCF) et à une vaste communauté de développeurs, Kubernetes bénéficie d’un flux constant d’innovations et d’améliorations. Les forums, les groupes de discussion, et les conférences permettent aux utilisateurs de partager des connaissances, d’échanger des idées et de collaborer sur de nouveaux projets.

Intégrations avec le Cloud et les Outils DevOps

Kubernetes est conçu pour s’intégrer facilement avec les principaux fournisseurs de cloud computing comme AWS, Google Cloud, et Azure. Ces plateformes proposes des clusters Kubernetes managés. Le fournisseur assure la maintenance du plan de contrôle du cluster et de l'infrastructure de Kubernetes. Vous êtes responsable de la charge de travail que vous déployez dans le cluster.

Kubernetes s’intègre parfaitement avec les systèmes d’intégration et de déploiement continu (CI/CD) tels que Jenkins, GitLab CI, et GitHub Actions. Grâce à l’efficacité des conteneurs, qui sont plus rapides à déployer que les environnements traditionnels, Kubernetes permet une automatisation fluide des processus de développement. Cette intégration réduit les délais de mise en production, améliore la réactivité aux changements et optimise la gestion des applications, apportant ainsi un gain de temps considérable et une meilleure flexibilité dans vos workflows CI/CD

Conclusion

Au cours de cet article, nous avons exploré les fondamentaux de Kubernetes, en nous concentrant sur ses composants clés tels que les Pods, ReplicaSets, Deployments et Services. Nous avons également abordé pourquoi Kubernetes est devenu un pilier essentiel dans la gestion des applications modernes. Avec une compréhension solide de ces bases, vous êtes désormais prêt à mettre en pratique ces concepts et à explorer des fonctionnalités plus avancées.

Avec ces bases établies, vous pouvez commencer à approfondir vos connaissances et découvrir les aspects plus sophistiqués de Kubernetes. Dans nos prochains articles, nous explorerons des sujets plus avancés sur Kubernetes tel que l’auto-scaling, la gestion des configurations, et l’intégration avec divers outils et services.

Restez connecté pour continuer à enrichir vos compétences et maximiser les avantages offerts par Kubernetes