Déployer une application Python via Docker sur Kubernetes

Dans cet article, on va déployer une application Python Flask sur Kubernetes. Un premier article montrant les premiers pas avec Kubernetes et Minikube est disponible ici Kubernetes: Simplifying Container Orchestration

Pré-requis

• Docker: pour créer l’image conteneurisée de l’application avec Docker Desktop

• Minikube: pour créer un cluster local de test

• kubectl: pour interagir avec Kubernetes

Étape 1: Créer l’application Python

1. Créer un fichier app.py

   Ce code crée une application via Flask qui écoute sur le port 5000 et affiche un message

    from flask import Flask
   
    app = Flask(__name__)
   
    @app.route('/')
    def hello_world():
        return 'Hello, K8s!'
   
    if __name__ == '__main__':
        app.run(host="0.0.0.0", port=5000)
   

2. Créer un requirements.txt pour y lister les dépendances.

    Flask==3.0.3
   

3. Installer les dépendances

    pip install -r requirements.txt
   

   Vous pouvez ensuite tester l’application avec la commande python app.py

Étape 2: Conteneuriser l’application via Docker

Pour déployer l’application sur Kubernetes, il faut la conteneuriser avec Docker. Cela signifie de créer une image Docker qui contient l’application et tout ce qu’il faut pour l’exécuter (dépendances et autres).

1. Créez un fichier Dockerfile

    # Utiliser une image de base Python
    FROM python:3.9-slim
   
    # Définir le réepertoire de travail
    WORKDIR /app
   
    # Copier les fichiers de l’application
    COPY requirements.txt .
    COPY app.py .
   
    # Installer les dépendances
    RUN pip install -r requirements.txt --no-cache-dir 
   
    # Exposer le port de l’application
    EXPOSE 5000
   
    # Démarrer l’application
    CMD ["python", "app.py"]
   

2. Construire l’image Docker

   Docker doit d’abord être installé pour que cela fonctionne. Vous pouvez télécharger et installer Docker Desktop. Après l’installation, exécutez la commande suivante:

    docker build -t flask-k8s:1.0
   

   

   L’image Docker a bien été construite et est disponible localement. Vous pouvez la vérifier avec la commande docker images.

   

3. Tester l’image en local

   Pour s’assurer que l’application fonctionne, testez le conteneur avec la commande suivante:

    docker run -p 5000:5000 flask-k8s:1.0
   

   On accède ensuite à l’application via http://localhost:5000

   

Étape 3 : Pousser l’image vers Docker Hub

La prochaine étape sera de pousser l’image sur Docker Hub afin de la rendre accessible partout, pas seulement localement. Tout autre cluster a besoin d’Accéder à l’image pour créer les conteneurs. Si l’image reste uniquement sur le Docker local, seul le PC peut la lancer. Il faut la pousser sur Docker Hub afin de la rendre disponible pour notre cluster Kubernetes ou à d’autres personnes.

1. Créer un compte Docker Hub https://hub.docker.com/ puis se connecter avec la commande docker login -u USERNAME. Vous serez invités à entrer votre mot de passe.

2. Tagger l’image Docker

   Avant de pousser l’image, il faut s’assurer qu’elle est correctement taggée. Cela ne crée pas une nouvelle image , mais ajoute un tag à l’image existante.

    docker tag flask-k8s:1.0 bildotcom/flask-k8s:1.0
   

   

3. Pousser l’image

   Assurez vous d’avoir confirmer votre adresse courriel sinon l’image ne pourra être poussée vers le hub

    docker push bildotcom/flask-k8s:1.0
   

   Après cela, votre image sera disponible sur Docker Hub et pourra être utilisée pour des déploiements sur d’autres machines.

Étape 4 : Déployer l'image sur Kubernetes

Une fois que l’Image est sur Docker Hub, on peut maintenant déployer l’application sur un cluster Kubernetes. Pour cela, il faut créer des fichiers de configurations Kubernetes qui sont des fichiers YAML pour définir les objets nécessaires, tels que Deployment et Service.

1. Créer le fichier deployment.yaml

   Deployment définit comment l’application doit être déployée, le nombre de répliques et l’image à utiliser.

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: flask-k8s
    spec:
      replicas: 2 # ici on spécifie le nombre de pods (répliques)
      selector: 
        matchLabels:
          app: flask-k8s 
      template:
        metadata:
          labels:
            app: flask-k8s
        spec:
          containers:
          - name: flask-k8s
            image: bildotcom/flask-k8s:1.0
            ports:
            - containerPort: 5000 # port exposé par le conteneur
   

2. Créer le fichier service.yaml

   Service expose l’application afin qu’elle soit accessible à d’autres services à l’extérieur du cluster.

    apiVersion: v1
    kind: Service
    metadata:
      name: flask-k8s
    spec:
      selector:
        app: flask-k8s
      ports:
      - protocol: TCP
        port: 80 # port exposé par le service
        targetPort: 5000 # port interne du conteneur
      type: NodePort
   

   Dans Kubernetes, il existe plusieurs types de services qui déterminent comment un service est exposé. On le définit via le champ type du fichier service.yaml.

   • clusterIP: type par défaut. Il expose le service uniquement à l’intérieur du cluster sur une IP interne. L’accès externe ne sera pas possible sans un tunnel.

   • NodePort: expose le service sur un port fixe de chaque noeud du cluster. Cela permet d’accéder au service depuis l’extérieur du cluster avec l’IP du noeud et le port spécifié.

   • LoadBalancer: crée un équilibreur de trafic vers les pods du service.

   • ExternalName: redirige le service vers un nom DNS externe en utilisant un CNAME.

3. Déployer sur le cluster

   Pour cette étape, il faut s’assurer que le cluster Minikube est en cours d’exécution avec la commande minikube start. Déployez ensuite le déploiement et le service avec les commandes suivantes:

    kubectl apply -f deployment.yaml
    kubectl apply -f service.yaml
   

   Vous pouvez vérifier si les pods démarrent avec la commande kubectl get pods.

   

   On voit bien les deux pods spécifiés dans le fichier deployment.yaml sont en status Running.

4. Vérifier que le service est exposé

   La commande kubectl get svc permet de lister tous les services dans le cluster. On voit que le service est bien exposé via NodePort sur le port 32101.

   

5. Accéder à l’application

   Ouvrez l’application dans votre navigateur avec la commande suivante:

    minikube service flask-k8s
   

   

Si l’adresse 192.168.49.2:32107 ne fonctionne pas directement (car le réseau Minikube n’est pas routé vers l’hôte du poste Windows), on peut utiliser la commande minikube service flask-k8s pour ouvrir l’URL automatiquement ou utiliser un LoadBalancer au lieu du NodePort

Voici comment créer une application Pyhton Flask, la conteneurisée avec Docker, la publier sur DockerHub puis la déployer sur un cluster Kubernetes avec Minikube.