Qu'est-ce que Kubernetes ? Introduction et exemples

Sivous êtes au courant de l'essor du cloud computing, vous avez forcément entendu parler de Kubernetes. Dans le cadre du développement d'applications modernes, il s'agit d'un outil essentiel à apprendre pour gérer diverses configurations d'infrastructure.

Dans cet article d'introduction, nous vous proposons une vue d'ensemble de Kubernetes et de ses composants, ainsi qu'un tutoriel complet sur sa mise en œuvre locale. Si vous recherchez une expérience d'apprentissage pratique pour compléter ce tutoriel, consultez notre cours d'introduction à Kubernetes. 

Qu'est-ce que Kubernetes ?

Kubernetes est une plateforme d'orchestration de conteneurs open-source qui automatise le déploiement, la mise à l'échelle et la gestion des applications conteneurisées. Développé à l'origine par Google, il est devenu la norme de facto pour l'exécution de conteneurs à grande échelle.

Il fait abstraction de la complexité de la gestion des conteneurs individuels et permet aux développeurs de se concentrer sur la création et le déploiement de leurs applications.

Pourquoi utiliser Kubernetes ?

Voici quelques avantages clés de l'utilisation de Kubernetes :

• Orchestration de conteneurs: Automatise la distribution et l'ordonnancement des conteneurs dans un cluster.
• Évolutivité et autoréparation: Simplifie la mise à l'échelle horizontale (réplication des conteneurs) et la mise à l'échelle verticale (ajustement de l'allocation des ressources), le tout avec des capacités d'autoréparation.
• Haute disponibilité: Garantit que les conteneurs (et donc vos services) restent opérationnels même si certains nœuds tombent en panne.
• Portabilité: Abstraite l'infrastructure sous-jacente, ce qui permet de l'exécuter aussi bien sur site que sur différents fournisseurs de cloud.
• Utilisation efficace des ressources: Redimensionne les conteneurs en fonction de l'utilisation des ressources, ce qui permet d'optimiser l'allocation des ressources et de réduire les coûts.

Kubernetes est utile dans des applications variées telles que :

• DevOps: Automatise le déploiement, la mise à l'échelle et la gestion des applications conteneurisées.
• Microservices: Décompose les grandes applications monolithiques en services plus petits et plus faciles à gérer afin d'améliorer l'agilité et l'évolutivité.
• Big data: Simplifie le déploiement et la gestion de systèmes complexes de big data à l'aide de conteneurs.
• Informatique de pointe: Permet d'exécuter Kubernetes sur des appareils périphériques afin de traiter et d'analyser les données au plus près de l'endroit où elles sont générées, réduisant ainsi la latence et améliorant les performances.
• Livraison continue: S'intègre à des outils tels que Jenkins et GitLab pour des pipelines de livraison continue automatisés.
• L'apprentissage automatique: Fournit une plateforme évolutive pour l'entraînement et le déploiement de modèles d'apprentissage automatique, la gestion de grands ensembles de données et de calculs complexes.

Concepts clés de Kubernetes

Pour comprendre le fonctionnement de Kubernetes, vous devrez avoir une bonne compréhension de ses concepts clés. 

Ceux-ci comprennent 4 concepts principaux :

1. Groupes d'entreprises
2. Cosse
3. Espaces de noms
4. Opérateurs

Nous reviendrons plus en détail sur ce point ci-dessous.

Groupes d'entreprises

Les clusters Kubernetes sont des groupes de nœuds, qui sont des machines individuelles qui exécutent le logiciel Kubernetes. Le cluster joue le rôle de plan de contrôle pour la gestion des applications et des services.

Dans une configuration classique, une grappe comprend un nœud maître et plusieurs nœuds de travail. Le nœud maître est responsable de la coordination de toutes les activités au sein de la grappe, tandis que les nœuds de travail s'occupent de l'exécution et de la gestion des conteneurs.

Cosse

Les pods constituent la plus petite unité de déploiement dans Kubernetes. Ils peuvent contenir un ou plusieurs conteneurs, ainsi que des ressources de stockage et des paramètres de réseau partagés.

Chaque module dispose d'une adresse IP unique et peut communiquer avec les autres modules du même cluster par l'intermédiaire de cette adresse. Cela permet une communication efficace entre les différents composants d'une application.

Les pods peuvent se présenter sous la forme d'un seul ou de plusieurs conteneurs et chacun d'entre eux a son propre cas d'utilisation.

• Dosettes à contenant unique: Il s'agit du type de pod le plus courant, dans lequel un seul conteneur fonctionne. Cela est utile pour les applications simples ou les microservices qui ne nécessitent qu'un seul conteneur.
• Dosettes multi-conteneurs: Plusieurs conteneurs sont installés au même endroit et fonctionnent ensemble. Cela peut s'avérer utile pour les applications complexes dans lesquelles différents conteneurs doivent communiquer entre eux et partager des ressources.

Espaces de noms

Les espaces de noms permettent de partitionner logiquement les ressources au sein d'un même cluster. Cela permet une meilleure organisation et une meilleure gestion des ressources, ainsi que des contrôles de sécurité plus stricts.

Les espaces de noms peuvent également être utilisés pour gérer différents environnements, tels que le développement, la mise en scène et la production. Cela garantit que les ressources sont isolées et ne sont pas affectées par les changements apportés dans d'autres environnements.

Pour afficher les espaces de noms de votre cluster, vous pouvez utiliser cette commande :

kubectl get namespaces

Pour passer d'un espace de noms à l'autre, procédez comme suit

kubectl config set-context --current --namespace <namespace name>

Opérateurs

Les opérateurs sont des extensions logicielles qui permettent d'automatiser la gestion des ressources Kubernetes. Ils utilisent des contrôleurs personnalisés et des extensions d'API pour gérer des tâches complexes de manière plus efficace et plus automatique.

Parmi les opérateurs les plus populaires, citons

• Prometheus pour le suivi
• etcd operator pour gérer les clusters etcd

L'utilisation d'opérateurs peut grandement simplifier la gestion des applications et des ressources au sein de votre cluster. Grâce à leur capacité à automatiser des tâches et à fournir des fonctionnalités avancées, ils sont de plus en plus populaires parmi les utilisateurs de Kubernetes.

Composants principaux de Kubernetes

Dans la plupart des environnements Kubernetes, il existe un ensemble de composants de base.

Source : Kubernetes

Voici une liste des composants et de leur fonction :

1. Serveur API: Ce composant fait office de point de gestion central pour toutes les ressources Kubernetes. Il reçoit des demandes des utilisateurs et d'autres composants, puis applique des politiques pour gérer le cluster.
2. Responsable du contrôle: Le gestionnaire de contrôleur est chargé de maintenir l'état souhaité de la grappe en surveillant et en rapprochant en permanence les modifications apportées aux objets de la grappe.
3. etcd: Il s'agit d'un magasin de valeurs clés distribué qui sert de magasin de données principal pour Kubernetes. Il stocke toutes les données du cluster et assure la cohérence et la disponibilité des données.
4. kubelet: Cet agent s'exécute sur chaque nœud du cluster et est chargé de gérer les conteneurs, en veillant à ce qu'ils fonctionnent conformément aux configurations spécifiées.
5. Proxy Kube: Ce composant fonctionne sur chaque nœud et est responsable de l'acheminement du trafic réseau vers le bon conteneur.

Fonctionnement de Kubernetes

Comme nous l'avons établi, Kubernetes automatise le déploiement, la mise à l'échelle et la gestion des applications conteneurisées sur des clusters. Il garantit une haute disponibilité, une utilisation efficace des ressources et une auto-réparation sans intervention manuelle.

Au lieu de gérer des conteneurs individuels, Kubernetes les regroupe en Pods et les distribue sur des nœuds de travail, qui communiquent avec le plan de contrôle pour maintenir l'état souhaité du système.

Voici en quelques mots comment fonctionne Kubernetes :

1. Définir le déploiement de l'application: Vous spécifiez l'état souhaité dans un fichier YAML, y compris les répliques, les limites de ressources et les règles de mise en réseau.
2. Planifier les charges de travail: L'ordonnanceur affecte les pods aux nœuds de travail en fonction de la disponibilité des ressources.
3. Gérer l'état de la grappe: Le gestionnaire du contrôleur veille à ce que le système maintienne le nombre correct de pods, en remplaçant ceux qui tombent en panne.
4. Gérer la mise en réseau: Kubernetes gère la communication entre les services et l'accès externe via les services et les contrôleurs Ingress.
5. Échelle et autoguérison: Kubernetes ajuste le nombre de pods en cours d'exécution en fonction de la demande et redémarre automatiquement les conteneurs défaillants.

En gérant la complexité de l'infrastructure, Kubernetes permet aux équipes de se concentrer sur la création d'applications plutôt que sur la gestion des déploiements, ce qui le rend essentiel pour les charges de travail évolutives et résilientes dans tous les secteurs.

Terminologie et concepts communs

Examinons quelques-uns des termes clés que vous devez connaître et leur définition :

• Manifestes YAML: Il s'agit de fichiers de configuration qui définissent l'état souhaité de votre application ou de votre infrastructure. Ils peuvent être utilisés pour créer, mettre à jour et supprimer des ressources dans Kubernetes.
• StatefulSets vs. Déploiements: Il s'agit de deux types de contrôleurs dans Kubernetes qui gèrent le cycle de vie des pods. Les Deployments sont généralement utilisés pour les applications sans état, tandis que les StatefulSets sont utilisés pour les applications avec état.
• Services: Ils fournissent une adresse IP et un nom DNS stables pour accéder à votre application au sein du cluster. Ils permettent également la communication entre les différents pods.
• ConfigMaps: Ils sont utilisés pour stocker les données de configuration dans des paires clé-valeur auxquelles votre application peut accéder.
• Secrets: Similaires aux ConfigMaps, ils sont utilisés pour stocker des informations sensibles telles que des mots de passe ou des clés d'API.

Démarrer avec Kubernetes

Travailler avec Kubernetes peut sembler décourageant, surtout lorsqu'il s'agit de comprendre les différents termes et concepts. Cependant, une fois que vous aurez acquis une solide compréhension de ces termes essentiels, il vous sera beaucoup plus facile de naviguer sur la plateforme.

Commençons par examiner certains outils utilisés avec Kubernetes.

Outils pour débutants

En tant que débutant sur Kubernetes, devoir déployer des applications sur le cloud peut être trop difficile à gérer. À ce titre, vous pouvez vous tourner vers certains outils courants pour effectuer un déploiement local. 

Voici les deux outils les plus couramment utilisés :

1. Minikube

Minikube est une implémentation légère de Kubernetes qui peut fonctionner sur une seule machine hôte. Il exécute généralement un cluster à un seul nœud dans une machine virtuelle (VM) sur votre ordinateur portable ou votre station de travail.

Pourquoi l'utiliser ?

• Facile à monter et à démonter.
• Idéal pour le développement local et les preuves de concept.
• Utilisation minimale des ressources par rapport à une grappe complète.

Comment installer Minikube (exemple sous Windows) :

# Install via Windows Package Manager
winget install Kubernetes.minikube

Vous devriez voir le message d'installation suivant. Acceptez les termes et conditions si vous êtes invité à le faire en cliquant sur "Y".

Ensuite, pour démarrer un simple cluster sur minikube, utilisez la commande suivante start:

# Start a single-node cluster
minikube start

Pour vérifier que le nœud de cluster a bien démarré, exécutez la commande get:

# Verify the cluster is running
kubectl get nodes

Note: Le serveur kubectl API doit être installé sur votre machine locale (dans de nombreux cas, il est installé automatiquement avec Minikube).

2. Kind (Kubernetes dans Docker)

Kind signifie Kubernetes dans Docker. Il utilise des conteneurs Docker comme "nœuds" dans un cluster Kubernetes, fournissant un environnement de cluster local simple, basé sur des conteneurs.

Pourquoi l'utiliser ?

• Démarrage plus rapide que Minikube dans de nombreux scénarios.
• Facile à mettre en place simultanément plusieurs clusters de test, idéal pour les pipelines CI/CD.
• Souvent utilisé dans les environnements de test automatisés en raison de sa faible charge de travail.

Comment installer Kind (exemple sous Windows) :

# Install Kind with Windows Package Manager
winget install Kubernetes.kind

Une fois installé, vous pouvez créer un simple cluster à l'aide de la commande create cluster et lui donner un nom.

# Create a basic cluster
kind create cluster --name example-cluster

Pour vérifier si votre cluster Kubernetes kind a démarré, utilisez la commande suivante get.

# Check running clusters
kind get clusters

Vous pouvez également interagir avec le cluster via l'interface kubectl:

# Interact with your Kind cluster using kubectl
kubectl get nodes

Note: Assurez-vous que Docker est installé et fonctionne.

Fournisseurs de cloud (EKS, GKE, AKS)

Lorsque vous exécutez Kubernetes sur le cloud, voici quelques fournisseurs de cloud à choisir :

1. Amazon EKS (Elastic Kubernetes Service)

Amazon EKS est un service géré qui facilite l'exécution de Kubernetes sur AWS sans avoir à gérer votre propre plan de contrôle ou vos nœuds de travail. Il s'intègre à d'autres services AWS pour offrir des fonctionnalités supplémentaires telles que l'équilibrage de la charge, le stockage, la mise à l'échelle automatique et la surveillance.

Voici quelques caractéristiques supplémentaires :

• Offre des intégrations avec d'autres services AWS (par exemple, IAM, CloudWatch, ECR).
• L'évolutivité et la haute disponibilité sont intégrées dans la plateforme.

2. Google GKE (Google Kubernetes Engine)

Google GKE est un service entièrement géré pour l'exécution de Kubernetes sur Google Cloud Platform. Il offre une mise à l'échelle automatique, des capacités d'autoréparation et une intégration avec d'autres services Google Cloud.

Voici quelques caractéristiques supplémentaires :

• Intégration approfondie avec les services GCP tels que la journalisation du cloud, la surveillance du cloud et le registre des conteneurs.
• Offre un mode autopilote, qui gère automatiquement l'infrastructure du cluster.

3. Azure AKS (Azure Kubernetes Service)

Azure AKS fournit des clusters Kubernetes sans serveur qui sont entièrement intégrés à d'autres services Azure tels que le stockage, la mise en réseau et l'équilibrage de charge. Il dispose également d'une prise en charge intégrée des outils DevOps tels que Helm et Prometheus.

Voici quelques caractéristiques supplémentaires :

• Intégration avec Azure Active Directory, Azure Monitor, Container Registry, etc.
• Offre Kubernetes sans serveur (nœuds virtuels) à l'aide d'Azure Container Instances.

Ressources pour apprendre Kubernetes

Apprendre Kubernetes pour la première fois peut sembler insurmontable, mais il existe de nombreuses ressources disponibles pour vous aider à démarrer. 

Voici quelques ressources recommandées :

• Cours et ressources DataCamp : Notre cours Introduction à Kubernetes et notre tutoriel sur la conteneurisation peuvent être d'excellents points de départ.
• Nos tutoriels de démarrage dédiés à Kubernetes: Créé pour vous fournir les bases.

Exemple de déploiement de Kubernetes

Pour exécuter des applications dans Kubernetes, vous suivez un flux de travail structuré qui implique la mise en place d'un cluster, le déploiement d'une application conteneurisée, son exposition en tant que service et sa mise à l'échelle en fonction des besoins. 

Nous avons couvert ce processus en détail dans notre tutoriel Kubernetes, mais voici une ventilation de haut niveau :

Mettre en place un cluster Kubernetes

Utilisez Minikube pour créer un cluster local à des fins de test et de développement. Installez Minikube et démarrez votre cluster en utilisant :

minikube start --driver=docker

kubectl get nodes

Déployer une application

Définissez l'état souhaité de votre application dans un fichier YAML de déploiement. Par exemple, le déploiement d'un serveur web Nginx se présente comme suit :

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

Appliquer le déploiement avec :

kubectl apply -f hello-deployment.yaml

Exposer l'application en tant que service

Pour rendre l'application accessible, créez un Service en utilisant :

kubectl expose deployment hello-deployment --type=NodePort --port=80 --name=hello-service

Récupérez l'URL externe et ouvrez l'application dans votre navigateur :

minikube service hello-service

Dimensionner et surveiller l'application

Kubernetes vous permet de faire évoluer les applications sans effort. Pour augmenter le nombre de répliques :

kubectl scale deployment hello-deployment --replicas=3

Vérifier le fonctionnement des pods :

kubectl get pods

Affichez les journaux pour le débogage :

kubectl logs -f <pod-name>

Voici quelques exemples à explorer pour des projets plus avancés :

• Exécutez des tâches de streaming dans des conteneurs (par exemple, Spark sur Kubernetes, Kafka sur Kubernetes).
• Utiliser Volumes persistants pour monter des solutions de stockage externes telles que AWS EBS, Azure Disks ou NFS.
• Déployez des applications plus complexes (par exemple, des microservices à plusieurs niveaux avec des bases de données).
• Explorez les fonctionnalités avancées telles que les contrôleurs Ingress, les maillages de services (par exemple, Istio), les tableaux Helm pour la gestion des paquets.

Conclusion

Kubernetes est une plateforme puissante pour déployer et gérer des applications conteneurisées à l'échelle, ce qui en fait un outil essentiel pour les ingénieurs de données qui ont besoin d'environnements élastiques et fiables pour le traitement des données. 

Si vous souhaitez en savoir plus sur Kubernetes, notre cours Introduction à Kubernetes est l'endroit idéal pour commencer.