PyCharm

The only Python IDE you need.

Download

Web Development

Déploiement d’applications Django dans Kubernetes

Delphine Massenhove

Read this post in other languages:

En tant que plateforme d’orchestration de conteneurs open source automatisant le déploiement, la mise à l’échelle et l’équilibrage de charge, Kubernetes offre une résilience et une flexibilité inégalées pour la gestion de vos applications Django.

Qu’il s’agisse de lancer un projet à petite échelle ou de gérer une application complexe, Kubernetes fournit un environnement robuste pour améliorer votre application Django en garantissant qu’elle réponde aux exigences du développement web moderne.

En automatisant le déploiement, la mise à l’échelle et la gestion des applications conteneurisées, Kubernetes (ou K8s) présente de nombreux avantages pour les organisations du secteur fortement évolutif de la tech.

Que vous soyez un développeur Django cherchant à améliorer ses compétences de déploiement ou un fan de Kubernetes qui souhaite explorer l’intégration de Django, ce guide est fait pour vous.

L’introduction de ce tutoriel traite de la relation symbiotique entre Django et Kubernetes, qui vous permet de créer de conteneuriser de manière fluide transparente votre application web, de répartir les charges de travail sur les clusters et de garantir une haute disponibilité.

Django

Le framework Django, un framework web Python de haut niveau, se distingue par son efficacité et sa simplicité dans le domaine du développement web. Conçu pour créer des applications web rapides, robustes et faciles à maintenir, Django est devenu une référence pour les développeurs et les organisations.

Fondamentalement, Django a une approche « batteries-included », qui offre un ensemble étendu d’outils intégrés, de bibliothèques et de conventions qui facilitent le processus de développement. Il simplifie les tâches complexes comme le routage d’URL, l’intégration des bases de données et l’authentification des utilisateurs, ce qui permet aux développeurs de se concentrer sur la création de leurs applications.

L’un des principaux avantages de Django réside dans son principe « Ne vous répétez pas » (Don’t repeat yourself, DRY), qui réduit les redondances et facilite la maintenance du code. Il applique également l’architecture modèle-vue-contrôleur (model-view-controller, MVC), ce qui permet d’obtenir des applications structurées et faciles à gérer.

Django donne également la priorité à la sécurité, en réduisant l’exposition aux vulnérabilités web les plus courantes. Il inclut dès le départ des fonctionnalités telles que la protection contre les scripts intersites (XSS) et la falsification de requêtes intersites (CSRF). Offrant une combinaison puissante de vitesse, de simplicité et de sécurité, Django est un choix idéal pour les développeurs souhaitant créer facilement des applications web robustes et riches en fonctionnalités.

Orchestrateurs de conteneurs

Les orchestrateurs de conteneurs sont des outils essentiels pour gérer et automatiser le déploiement, la mise à l’échelle et la gestion des applications conteneurisées. Plusieurs orchestrateurs de conteneurs sont disponibles sur le marché, les plus populaires étant :

1. Kubernetes, cette plateforme d’orchestration de conteneurs open source très appréciée offre un environnement robuste et adaptable pour gérer les applications conteneurisées. Elle automatise des tâches telles que la mise à l’échelle, l’équilibrage de charge et la vérification de l’état des conteneurs grâce à un vaste écosystème d’extensions.

2. Docker Swarm est une solution d’orchestration de conteneurs proposée par Docker. Conçue pour être simple à configurer et à utiliser, c’est un bon choix pour les applications les plus simples ou les organisations utilisant déjà Docker, car elle utilise la même interface de ligne de commande et la même API que Docker.

3. OpenShift est une plateforme Kubernetes d’entreprise développée par Red Hat. Elle ajoute des outils de développement et d’opérations à Kubernetes, ce qui simplifie le déploiement et la gestion des applications conteneurisées.

4. Nomad, développé par HashiCorp, est un orchestrateur léger et convivial permettant de gérer à la fois les applications conteneurisées et non conteneurisées.

5. Apache Mesos est un noyau de système distribué open source et DC/OS (Data Center Operating System) est une plateforme d’entreprise construite sur Mesos. DC/OS étend les fonctionnalités de Mesos pour la gestion et la mise à l’échelle des applications conteneurisées.

Les équipes de développement logiciel travaillent principalement avec les plateformes gérées proposées par des fournisseurs cloud reconnus tels que AWS, Google Cloud Platform et Azure. Ces fournisseurs cloud offrent des services comme Amazon EKS, Google GKE et Azure AKS, qui sont toutes des solutions Kubernetes gérées. Ces services simplifient la configuration, l’expansion et l’administration des clusters Kubernetes et permettent de les intégrer facilement avec les environnements cloud respectifs afin d’assurer une orchestration efficace des conteneurs et du déploiement des applications.

Créer une application Django dans PyCharm

Dans ce tutoriel, nous allons commencer par générer une application Django minimaliste. Nous allons ensuite conteneuriser cette application, et pour finir, nous la déployer sur un cluster Kubernetes local en utilisant Docker Desktop.

Si vous découvrez le framework Django et souhaitez savoir comment créer une application Django à partir de 0, lisez cet article de blog.

Vous pouvez accéder au code source utilisé dans ce tutoriel ici.

Commençons en créant une nouvelle application Django dans PyCharm.

Essayer PyCharm Pro gratuitement

Pour créer votre projet, lancez PyCharm et cliquez sur New Project. Si PyCharm est déjà lancé, sélectionnez File | New Project dans le menu principal.

Fournissez les informations essentielles, telles que le nom du projet, l’emplacement et le type d’interpréteur, en utilisant venv ou un environnement personnalisé.

Cliquez ensuite sur Create.

PyCharm se chargera de la plus grande partie de la configuration du projet et de la création de l’environnement virtuel.

Gunicorn

Une fois le projet créé, installez Gunicorn ; il s’agit d’un serveur web HTTP WSGI populaire écrit en Python. Gunicorn est un serveur web basé sur le modèle des workers pré-fork qui est très sollicité pour servir des applications web en Python. Il est souvent utilisé en conjonction avec des frameworks web tels que Django, Flask et autres pour déployer des applications web et les rendre accessibles sur Internet.

La fenêtre d’outils Python Packages fournit le moyen le plus rapide et simple pour obtenir un aperçu des packages et les installer pour l’interpréteur Python actuellement sélectionné.

Vous pouvez ouvrir la fenêtre d’outils via View | Tool Windows | Python Packages.

Psycopg 2

Psycopg 2 est une bibliothèque Python servant à se connecter aux bases de données PostgreSQL et à interagir avec elles. Il fournit une interface Python pour travailler avec PostgreSQL, l’un des SGBDR open source les plus populaires. Psycopg 2 permet aux développeurs Python d’exécuter différentes opérations avec les bases de données, telles que l’insertion, la mise à jour et l’extraction de données, ainsi que l’exécution de requêtes SQL et la gestion de connexions de bases de données à partir de programmes en Python.

Avant d’installer psycopg2, assurez-vous d’installer les dépendances système : brew install libpq pour macOS et apt-get install libpq-dev pour Linux.

Référence : postgresql.org/docs/16/libpq.html

libpq est la bibliothèque client pour PostgreSQL. Il s’agit d’une bibliothèque C qui réunit toutes les fonctionnalités nécessaires pour que les applications client se connectent aux serveurs de bases de données PostgreSQL, afin d’interagir avec eux ou de les gérer.

Une fois les modifications terminées, mettez à jour la section de settings.py qui se rapporte à DATABASES.

Veillez à transférer les informations d’authentification secrètes au moyen des variables d’environnement.

STATIC_ROOT

Dans Django, STATIC_ROOT est un paramètre de configuration permettant de spécifier le chemin absolu des fichiers système où les fichiers statiques collectés seront stockés lorsque vous exécutez la commande de gestion collectstatic. Les fichiers statiques incluent généralement CSS, JavaScript, les images et autres ressources de votre application web. Le paramètre STATIC_ROOT est un élément essentiel des serveurs de fichiers statiques dans un environnement de production.

Définissez une variable d’environnement pour STATIC_ROOT à la ligne 127. Cette variable pointe vers un chemin de fichier qui mène à un PersistentVolume Kubernetes. J’expliquerai plus tard comment créer cette configuration.

Pour collecter les fichiers statiques, exécutez la commande suivante :

python manage.py collectstatic

Cette commande regroupera les fichiers statiques et les placera dans le répertoire STATIC_ROOT. Vous pouvez ensuite servir ces ressources directement avec un serveur web NGINX ou Apache, car cela constitue une approche plus efficace pour les environnements de production.

Dockerfile

Un Dockerfile est un simple document texte contenant des directives de construction des images Docker.

1. FROM python:3.11 : cette ligne spécifie l’image de base pour l’image Docker utilisant l’image Python 3.11 officielle de Docker Hub. L’application sera construite et exécutée sur la base de cette image, dans laquelle Python est pré-installé.

2. ENV PYTHONUNBUFFERED 1 : cette ligne définit la variable d’environnement PYTHONUNBUFFERED sur 1. Il est souvent recommandé de définir cette variable d’environnement lors de l’exécution de Python dans des conteneurs Docker pour s’assurer que Python ne place pas la sortie en mémoire tampon. Cela facilite l’obtention de fichiers journaux en temps réel et le débogage des informations à partir de l’application.

3. WORKDIR /app : cette ligne définit le répertoire de travail du conteneur Docker sur /app. Toutes les commandes suivantes seront exécutées dans ce répertoire.

4. COPY . /app : cette ligne copie le contenu du répertoire actif (celui où se trouve le Dockerfile) dans le répertoire /app du conteneur. Cela inclut le code de votre application et tous les fichiers nécessaires pour l’image Docker.

5. RUN pip install -r requirements.txt : cette ligne exécute la commande pip install pour installer les dépendances Python figurant dans le fichier requirements.txt situé dans le répertoire /app. Il s’agit d’une pratique courante pour les applications Python, car elle permet de gérer les dépendances de l’application.

6. EXPOSE 8000 : cette ligne informe Docker que le conteneur écoute sur le port 8000. Elle ne publie pas le port. Il s’agit d’une déclaration de métadonnées qui indique les ports que le conteneur peut utiliser.

7. CMD ["gunicorn", "django_kubernetes_tutorial.wsgi:application", "--bind", "0.0.0.0:8000"] : cette ligne spécifie la commande par défaut à exécuter lors du démarrage du conteneur. Elle utilise Gunicorn pour servir l’application Django et force Gunicorn à écouter toutes les interfaces réseau (0.0.0.0) sur le port 8000 en utilisant l’application WSGI définie dans django_kubernetes_tutorial.wsgi:application.

DockerHub

Ouvrez la page hub.docker.com et connectez ou inscrivez-vous sur la plateforme.

Cliquez sur Create repository.

Ensuite, fournissez le nom du référentiel et définissez la visibilité sur publique. Si vous manipulez des informations sensibles ou confidentielles, définissez la visibilité sur privée.

Une fois le référentiel créé, vous devez créer l’image docker et pousser cette image vers le registre.

Avant d’exécuter la commande, assurez-vous que votre fichier requirements.txt est à jour en exécutant la commande suivante :

pip freeze > requirements.txt

Pour construire une image, exécutez la commande suivante :

docker build -t mukulmantosh/django-kubernetes:1.0 .

docker build -t /django-kubernetes:1.0 .

Cette commande peut varier en fonction de vos circonstances et vous devez utiliser votre propre nom d’utilisateur.

Vous devez ensuite vous identifier sur Docker Hub pour faire un push de l’image dans le registre.

Tapez la commande suivante dans le terminal :

docker login

Entrez votre nom d’utilisateur et votre mot de passe. Une fois le processus d’authentification terminé, vous pouvez faire un push de l’image en exécutant :

docker push mukulmantosh/django-kubernetes:1.0

docker push /django-kubernetes:1.0

Une fois l’image poussée, vous pouvez observer des modifications dans Docker Hub.

Si vous ne prévoyez pas de faire d’autres push d’images dans le registre, vous pouvez vous déconnecter en exécutant la commande :

docker logout

Si vous souhaitez extraire cette image localement, allez sur la page hub.docker.com/r/mukulmantosh/django-kubernetes.

Configuration de Kubernetes : écrire des fichiers YAML

Cette section du tutoriel décrit le déploiement d’applications sur des clusters Kubernetes locaux.

Pour ce tutoriel, nous allons utiliser Docker Desktop, mais vous pouvez aussi utiliser minikube ou kind.

Namespaces

Dans Kubernetes, namespaces est une partition virtuelle dans un cluster qui est utilisée pour grouper et isoler des ressources et des objets. C’est une façon de créer plusieurs clusters virtuels dans un même cluster physique.

Vous pouvez créer et gérer les namespaces en utilisant kubectl, l’outil de ligne de commande de Kubernetes ou en les définissant dans les manifestes YAML lors du déploiement des ressources.

Si vous avez choisi Docker Desktop comme plateforme principale d’exécution de Kubernetes, veillez à activer Kubernetes dans les paramètres en cliquant sur la case à cocher Enable Kubernetes.

Exécutez la commande suivante dans le terminal pour créer un namespace :

kubectl create ns django-app

Déploiement de bases de données avec K8s

Pour commencer, nous allons créer une instance PostgreSQL dans notre cluster Kubernetes sur l’environnement local.

PersistentVolume

Dans Kubernetes, un PersistentVolume (PV) est un élément de stockage du cluster qui a été provisionné par un administrateur. En stockant les données d’une façon indépendante du cycle de vie d’un pod, les volumes persistants permettent une gestion et une abstraction des ressources de stockage plus découplées et flexibles. Cela signifie que les données peuvent persister même si le pod qui les utilise est supprimé ou replanifié sur un autre nœud du cluster.

Nous allons créer un PV et l’appeler pv.yml.

Cette configuration YAML définit une ressource PersistentVolume appelée postgres-pv dotée d’une capacité de 1 Go, qui est montée avec le mode d’accès ReadWriteOnce et qui est fournie par un chemin local sur le système de fichiers du nœud situé dans /data/db. Ce PV peut être utilisé pour assurer le stockage persistant des pods qui doivent accéder à un répertoire sur le système de fichiers du nœud et convient pour des applications telles que PostgreSQL, ou d’autres services avec état nécessitant un stockage persistant.

Pour la production, nous recommandons d’utiliser des solutions cloud telles que AWS RDS ou Google CloudSQL, ou encore Kubernetes StatefulSets.

PersistentVolumeClaim

Dans Kubernetes, un PersistentVolumeClaim (PVC) est un objet de ressource utilisé par un pod pour demander une certaine quantité de stockage avec certaines propriétés d’un volume persistant. Les PVC permettent aux applications de demander des ressources de stockage sans avoir à connaître les détails de l’infrastructure de stockage sous-jacente.

En créant et utilisant des PVC, Kubernetes permet d’allouer et de gérer de façon dynamique les ressources de stockage des applications tout en dématérialisant l’infrastructure de stockage, ce qui facilite leur manipulation et permet de gérer les applications avec état dans des environnements conteneurisés.

Nous allons créer un PVC et l’appeler pvc.yml.

Un PVC nécessite des ressources de stockage et est lié à un volume persistant qui assure ce stockage.

Cette configuration YAML définit un PersistentVolumeClaim appelé postgres-pvc dans le namespace django-app. Elle consomme un gigaoctet de stockage en mode d’accès ReadWriteOnce et définit explicitement StorageClass sur manual. Ce PVC doit être lié à un PV existant appelé postgres-pv, ce qui revient à réserver ce volume pour les pods dans le namespace django-app qui référence ce PVC.

ConfigMap

Dans Kubernetes, un ConfigMap est un objet d’API servant à stocker les données de configuration dans des paires clé-valeur. Il offre un moyen de découpler les données de configuration du code de l’application, ce qui facilite leur gestion et leur mise à jour sans avoir à modifier et redéployer les conteneurs. Cela s’avère particulièrement utile pour configurer les applications, les microservices et autres composants d’un cluster Kubernetes.

Nous allons créer un ConfigMap et l’appeler cm.yml.

Ce tutoriel utilise des ConfigMap, mais pour des raisons de sécurité, il est recommandé de stocker les informations d’authentification sensibles dans des Secrets Kubernetes ou d’explorer d’autres solutions, telles que Bitnami Sealed Secrets, AWS Parameter Store ou HashiCorp Vault.

Deployment

Dans Kubernetes, Deployment est un objet de ressource permettant de gérer le déploiement et l’évolution des applications. Il fait partie du groupe d’API Kubernetes et apporte une solution déclarative pour définir et gérer l’état voulu de votre application.

Un Deployment est une ressource Kubernetes de plus haut niveau pour gérer et mettre à l’échelle les pods d’applications.

Cette configuration YAML définit un Deployment appelé postgres dans le namespace django-app. Il déploie une réplique unique d’une base de données PostgreSQL (version 16.0) à stockage persistant. Le pod de base de données est appelé app: postgresdb et le stockage est assuré par un PVC appelé postgres-pvc. La configuration et les informations d’authentification du conteneur PostgreSQL sont fournies par un ConfigMap appelé db-secret-credentials.

Service

Dans Kubernetes, un Service est un objet de ressource permettant d’exposer un ensemble de pods en tant que service réseau. Le rôle d’un Service est d’assurer la communication réseau entre différentes parties de votre application s’exécutant dans un cluster Kubernetes et de fournir un point de terminaison stable permettant aux clients d’y accéder. Cela permet d’abstraire l’infrastructure réseau sous-jacente pour faciliter la connexion et la découverte des composants de votre application.

Cette configuration YAML définit un Service NodePort sous le nom postgres-service dans le namespace django-app. Elle expose le service PostgreSQL s’exécutant dans les pods portant le libellé « app: postgresdb » sur le port 5432 du cluster. Les clients externes peuvent accéder au Service à l’adresse IP du nœud voulu en utilisant le port 30004. Ce Service rend la base de données PostgreSQL accessible depuis l’extérieur du cluster Kubernetes.