Pourquoi Deployer Django sur GCP ?
Le déploiement de Django sur Google Cloud Platform (GCP) est une excellente option pour des développeurs qui cherchent à créer des applications web robustes, scalables et sécurisées. Avec les capacités de calcul cloud de GCP, vous pouvez facilement déployer et gérer votre application Django sans préoccuper du matériel physique. Cela permet d'investir davantage dans le développement plutôt que dans la gestion des infrastructures.
Un cas concret serait une application de gestion de contenu (CMS) qui doit être accessible à un grand nombre d'utilisateurs en temps réel. En déployant sur GCP, vous pouvez tirer parti des fonctionnalités comme les instances Gunicorn pour le scaling horizontal, les charges équilibrées et les volumes de stockage durables.
Prerequis
Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :
- Un compte Google Cloud Platform (GCP)
- Un environnement local avec Python 3.8+ et pip installés
- Un environnement de développement pour créer votre application Django
Voici les outils à installer :
Google Cloud SDK : Pour interagir avec GCP depuis la ligne de commande.
- Téléchargez et installez le SDK sur le site officiel.
Django : Pour créer votre application web. Installez-le via pip :
pip install django==3.2.5
Concepts fondamentaux
1. Google Cloud Platform (GCP)
GCP est le plus grand fournisseur de services cloud, offrant une variété d'options pour héberger, stocker et gérer votre application.
Schéma mental :
+-------------------+
| |
| Google Cloud |
| |
+----------+--------+
|
v
+-----------------+
| |
| Compute Engine |
| |
+-----------------+
2. Compute Engine
Compute Engine vous permet de créer et de gérer des instances virtuelles dans le cloud.
Schéma mental :
+-------------------+
| |
| Google Cloud |
| |
+----------+--------+
|
v
+-----------------+
| |
| Compute Engine |
| |
+-----------------+
|
v
+-----------------+
| |
| Instance |
| |
+-----------------+
3. Django Project
Un projet Django est une collection de configuration et de code source pour une application web.
Schéma mental :
+-------------------+
| |
| Django |
| |
+----------+--------+
|
v
+-----------------+
| |
| settings.py |
| |
+-----------------+
| |
| urls.py |
| |
+-----------------+
| |
| views.py |
| |
+-----------------+
4. Gunicorn
Gunicorn est un serveur WSGI HTTP pour Python, utilisé pour déployer des applications Django.
Schéma mental :
+-------------------+
| |
| Gunicorn |
| |
+----------+--------+
|
v
+-----------------+
| |
| Application |
| |
+-----------------+
Mise en pratique : projet fil rouge
Dans cette section, nous allons créer un simple gestionnaire de tâches en utilisant Django. Le projet sera déployé sur GCP.
Étape 1 : Créer le projet Django
Créez un nouveau projet Django :
django-admin startproject taskmanager
cd taskmanager
Étape 2 : Créer une application Django
Ajoutez une nouvelle application pour gérer les tâches :
python manage.py startapp tasks
Étape 3 : Configurer le projet Django
Ajoutez l'application tasks au fichier settings.py :
INSTALLED_APPS = [
...
'tasks',
]
Étape 4 : Créer un modèle pour les tâches
Créez un modèle pour les tâches dans le fichier models.py de l'application tasks :
from django.db import models
class Task(models.Model):
title = models.CharField(max_length=255)
description = models.TextField()
completed = models.BooleanField(default=False)
def __str__(self):
return self.title
Étape 5 : Créer des migrations
Créez et appliquez les migrations pour créer la table de base de données :
python manage.py makemigrations tasks
python manage.py migrate
Étape 6 : Créer une vue pour afficher les tâches
Créez une vue pour afficher les tâches dans le fichier views.py de l'application tasks :
from django.shortcuts import render
from .models import Task
def task_list(request):
tasks = Task.objects.all()
return render(request, 'tasks/task_list.html', {'tasks': tasks})
Étape 7 : Créer un template pour afficher les tâches
Créez un template pour afficher les tâches dans le fichier task_list.html de l'application tasks :
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Gestionnaire de Tâches</title>
</head>
<body>
<h1>Liste des Tâches</h1>
<ul>
{% for task in tasks %}
<li>task.title - task.description</li>
{% empty %}
<li>Aucune tâche enregistrée.</li>
{% endfor %}
</ul>
</body>
</html>
Étape 8 : Ajouter une URL pour la vue
Ajoutez une URL pour la vue dans le fichier urls.py de l'application tasks :
from django.urls import path
from .views import task_list
urlpatterns = [
path('', task_list, name='task_list'),
]
Étape 9 : Inclure les URLs de l'application dans le projet
Incluez les URLs de l'application tasks dans le fichier urls.py du projet :
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('tasks.urls')),
]
Étape 10 : Lancer la application locallement
Lancez l'application pour vérifier qu'elle fonctionne :
python manage.py runserver
Accédez à http://127.0.0.1:8000/ dans votre navigateur pour voir le gestionnaire de tâches.
Erreurs frequentes et debugging
1. Erreur : "No module named 'django'"
Si vous rencontrez cette erreur, assurez-vous que Django est installé correctement :
pip install django==3.2.5
2. Erreur : "ModuleNotFoundError: No module named 'gunicorn'"
Si vous ne pouvez pas démarrer l'application avec Gunicorn, installez-le via pip :
pip install gunicorn==20.1.0
3. Erreur : "Could not find a version that satisfies the requirement django"
Assurez-vous d'avoir la bonne version de Python installée et que pip est à jour :
python -m venv venv
source venv/bin/activate
pip install --upgrade pip
Pour aller plus loin
1. Utiliser Kubernetes pour le scaling
Kubernetes permet un déploiement et une gestion automatisés des applications.
2. Configurer des logs distribués avec Stackdriver Logging
Stackdriver Logging vous permet de collecter, stocker et analyser les journaux de vos applications.
3. Utiliser Firestore pour la base de données NoSQL
Firestore est une base de données NoSQL intégrée à GCP.
Défi pratique
Créez une application Django qui permet de gérer des utilisateurs et leurs profils. Ajoutez des fonctionnalités comme la création, la mise à jour et la suppression d'utilisateurs.
Ce tutoriel vous a montré comment déployer un projet Django sur Google Cloud Platform. En suivant ces étapes, vous avez appris les concepts fondamentaux et pratiques nécessaires pour créer et déployer une application web avec Django sur GCP.