• Cloud

Migration d’une Application Docker Compose vers Kubernetes avec KIND : Guide Étape par Étape

  • 2 min read

De nombreuses applications modernes commencent leur cycle de développement en utilisant Docker Compose pour l’orchestration des conteneurs. Cependant, à mesure que l’application se développe et nécessite plus de scalabilité, de tolérance aux pannes et de fonctionnalités avancées, la transition vers Kubernetes devient une étape naturelle. Cet article vous guidera à travers la migration d’une application web ASP.NET Core de Docker Compose vers Kubernetes en utilisant KIND (Kubernetes IN Docker). Nous définirons également le type de Deployment Kubernetes adapté à ce scénario.

En suivant ce guide, vous serez capable de déployer cette API Web ASP.NET Core à l’aide de Kubernetes avec Docker KinD. Une fois le guide terminé, vous pourrez adapter cette logique à des applications plus complexes. Cependant, il est essentiel de noter que pour réussir ce processus, vous devez avoir Docker installé sur votre machine, un registre local Docker configuré comme une image Docker, et que vous pourriez avoir à remplacer l’adresse IP de l’hôte Docker par `172.17.0.1` si vous utilisez Linux (comme dans mon cas 🙂) ou à utiliser `host.docker.internal`.

Aperçu de l’Application : De Docker Compose à Kubernetes

Nous allons commencer avec une application web construite avec ASP.NET Core. Dans sa configuration initiale, l’application est orchestrée avec Docker Compose. Nous la migrerons ensuite vers Kubernetes à l’aide de KIND, un outil permettant de déployer des clusters Kubernetes localement.

Démarrage avec Docker Compose

Voici un exemple de fichier docker-compose.yml qui configure l’application web ASP.NET Core :

 
				
					version: '3.9'
services:
  webapp:
    image: 172.17.0.1:9999/production-webapp:latest
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8080:8080" # Lie le port 8080 de l'hôte au port 8080 du conteneur
    environment:
      ASPNETCORE_ENVIRONMENT: Development
      DOTNET_HOSTBUILDER__RELOADCONFIGONCHANGE: "false"

Ce que Fait ce Fichier Compose :

  1. Définition du Service : Le service webapp exécute une application ASP.NET Core à l’aide d’une image Docker spécifiée.
  2. Ports : Le port 8080 de l’hôte est mappé au port 8080 du conteneur, permettant un accès externe.
  3. Variables d’Environnement : Elles configurent l’application en mode Development et désactivent le rechargement de la configuration.

Vous pouvez exécuter l’application localement avec :

				
					docker-compose up

Pourquoi Migrer vers Kubernetes ?

Bien que Docker Compose soit idéal pour le développement local et les petites configurations, Kubernetes offre des fonctionnalités avancées telles que :

  • Scalabilité : Adapter automatiquement ou manuellement l’application pour gérer des charges accrues.
  • Tolérance aux Pannes : Remplacer automatiquement les conteneurs (pods) défaillants.
  • Équilibrage de Charge : Distribuer le trafic entre plusieurs répliques.
  • Portabilité : Exécuter l’application de manière cohérente dans des environnements locaux, de staging ou de production.

Kubernetes offre également un contrôle précis sur l’allocation des ressources, les politiques réseau et la gestion du stockage, ce qui en fait une solution idéale pour les déploiements en production.

Configuration de KIND pour Kubernetes

Qu’est-ce que KIND ?

KIND (Kubernetes IN Docker) est un outil qui permet d’exécuter des clusters Kubernetes localement en utilisant des conteneurs Docker. Léger et simple, il est parfait pour le développement et les tests.

Fichier de Configuration KIND

Pour exécuter notre application sur Kubernetes, nous devons configurer un cluster KIND. Voici un exemple de fichier kind-config.yaml :

				
					kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
  - role: worker
    extraPortMappings:
      - containerPort: 30349 # NodePort pour l'accès externe
        hostPort: 30349
        protocol: TCP
containerdConfigPatches:
  - |
    [plugins."io.containerd.grpc.v1.cri".registry.mirrors."172.17.0.1:9999"]
      endpoint = ["http://172.17.0.1:9999"]

Ce fichier :

  • Définit les Nœuds : Un nœud pour le plan de contrôle et un nœud de travail pour exécuter les pods.
  • Configure les Ports : Expose le port 30349 pour un accès externe à l’application.
  • Configure un Registre Local : Permet au cluster de récupérer des images depuis un registre local pour le développement.

Déployer l’Application sur Kubernetes

Pour migrer depuis Docker Compose, nous définissons des fichiers de configuration Kubernetes pour un Deployment et un Service.

Fichier Deployment Kubernetes

Créez un fichier deployment.yaml :

				
					apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp-prod
spec:
  replicas: 3 # Répliques pour une haute disponibilité
  selector:
    matchLabels:
      app: webapp-prod
  template:
    metadata:
      labels:
        app: webapp-prod
    spec:
      containers:
        - name: webapp-prod
          image: 172.17.0.1:9999/production-webapp:latest
          ports:
            - containerPort: 8080
          env:
            - name: ASPNETCORE_ENVIRONMENT
              value: Development
            - name: DOTNET_HOSTBUILDER__RELOADCONFIGONCHANGE
              value: "false"

Ce Deployment :

  • Exécute 3 répliques de l’application.
  • Garantit la tolérance aux pannes : un pod défaillant est automatiquement remplacé.
  • Spécifie l’image du conteneur, les ports et les variables d’environnement.

Fichier Service Kubernetes

Créez un fichier service.yaml :

				
					apiVersion: v1
kind: Service
metadata:
  name: webapp-prod
spec:
  selector:
    app: webapp-prod
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080
      nodePort: 30349
  type: NodePort

Ce Service :

  • Expose l’application sur le port 30349.
  • Redirige le trafic vers les pods via le port 8080.
  • Équilibre la charge entre toutes les répliques.

Accéder à l’Application

Une fois déployée, l’application sera accessible via :

				
					http://localhost:30349/swagger/index.html

Type de Deployment : Rolling Update

Dans ce guide, nous utilisons le type de déploiement Rolling Update, qui met à jour les pods progressivement pour garantir la disponibilité continue de l’application pendant le déploiement.

Conclusion:

Migrer de Docker Compose à Kubernetes avec KIND améliore la robustesse, la scalabilité et la portabilité de votre application. Les répliques et les services garantissent une haute disponibilité et une gestion simplifiée du trafic.

Kegate, une entreprise spécialisée dans les solutions cloud et DevOps, dispose des compétences nécessaires et d’une équipe d’ingénieurs expérimentés pour vous accompagner dans cette transition. Que ce soit pour concevoir une architecture Kubernetes optimisée, configurer vos clusters, ou garantir une migration fluide et sécurisée, Fawz est là pour répondre à vos besoins et assurer le succès de votre projet. N’hésitez pas à nous contacter pour en savoir plus !

Articles Connexes