Deployer Django sur Heroku

Pourquoi Deployer Django sur Heroku ?

Deployer un projet Django sur Heroku offre plusieurs avantages réels au quotidien. Il permet de :

1. Faciliter la mise en production : Heroku gère tout ce qui est nécessaire pour exécuter une application web, ce qui permet aux développeurs de se concentrer sur le développement et l'amélioration du code.
2. Accroître la scalabilité : Avec Heroku, vous pouvez facilement ajuster les ressources allouées à votre application en fonction du trafic.

Un cas d'utilisation concret serait de développer une application web pour un service de gestion de projet ou un simple blog. Deployer cette application sur Heroku permettrait aux utilisateurs finaux de l'utiliser en ligne, sans avoir besoin d'installer le logiciel localement.

Prerequis

Pour déployer un Django project sur Heroku, vous aurez besoin des éléments suivants :

• Connaissance intermédiaire en Python et Django
• Un compte Heroku (gratuit pour les petits projets)
• L’installation de Git et de la CLI Heroku
• La version du langage Python spécifiée dans le runtime.txt de votre projet

Concepts fondamentaux

1. Concept : Heroku CLI (Command Line Interface)

La ligne de commande Heroku est un outil puissant qui vous permet d'interagir avec l'environnement Heroku.

Schéma mental :

+-------------------+
| Heroku CLI        |
|                   |
|   +-------------+  |
|   | Commandes   |  |
|   +-------------+  |
|                   |
+-------------------+

Code fonctionnel :

## Installation de la CLI Heroku
$ brew install heroku/brew/heroku

## Connexion à votre compte Heroku
$ heroku login

## Création d'une nouvelle application sur Heroku
$ heroku create mon-nom-d-app

2. Concept : Procfile

Le Procfile est un fichier qui décrit comment l'application doit être lancée.

Schéma mental :

+-------------------+
| Procfile          |
|                   |
|   +-------------+  |
|   | Commandes   |  |
|   +-------------+  |
|                   |
+-------------------+

Code fonctionnel :

## Création du fichier Procfile
$ echo "web: gunicorn monprojet.wsgi" > Procfile

## Lancer l'application localement avec Gunicorn
$ gunicorn monprojet.wsgi

3. Concept : Requirements.txt

Le requirements.txt liste toutes les dépendances Python nécessaires à votre application.

Schéma mental :

+-------------------+
| requirements.txt  |
|                   |
|   +-------------+  |
|   | Dépendances |  |
|   +-------------+  |
|                   |
+-------------------+

Code fonctionnel :

## Création du fichier requirements.txt
$ pip freeze > requirements.txt

## Installer les dépendances depuis requirements.txt
$ pip install -r requirements.txt

4. Concept : Runtime.txt

Le runtime.txt spécifie la version de Python utilisée par Heroku.

Schéma mental :

+-------------------+
| runtime.txt       |
|                   |
|   +-------------+  |
|   | Version     |  |
|   +-------------+  |
|                   |
+-------------------+

Code fonctionnel :

## Création du fichier runtime.txt
$ echo "python-3.9" > runtime.txt

5. Concept : Heroku Dynos

Les dynos sont des conteneurs exécutant votre application.

Schéma mental :

+-------------------+
| Dynos             |
|                   |
|   +-------------+  |
|   | Conteneur   |  |
|   +-------------+  |
|                   |
+-------------------+

Code fonctionnel :

## Voir les dynos en cours d'exécution
$ heroku ps

## Lancer un nouveau dyno
$ heroku ps:scale web=1

Mise en pratique : projet fil rouge

Nous allons créer un simple blog avec Django. Ce projet comprendra :

• Une page d'accueil montrant les articles les plus récents.
• Des détails sur chaque article.

Étape 1 : Initialiser le Projet Django

## Créer un nouveau projet Django
$ django-admin startproject monprojet
$ cd monprojet

Structure du projet :

monprojet/
├── manage.py
└── monprojet/
    ├── __init__.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py

Étape 2 : Créer un Modèle

Créons un modèle pour les articles.

## monprojet/monprojet/models.py
from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

Migrer le modèle :

$ python manage.py makemigrations
$ python manage.py migrate

Étape 3 : Créer des Vues

Créons des vues pour afficher les articles.

## monprojet/monprojet/views.py
from django.shortcuts import render
from .models import Article

def home(request):
    latest_articles = Article.objects.order_by('-created_at')[:5]
    return render(request, 'home.html', {'articles': latest_articles})

Étape 4 : Créer des Templates

Créons un template pour la page d'accueil.

<!-- monprojet/monprojet/templates/home.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Blog</title>
</head>
<body>
    <h1>Les derniers articles</h1>
    {% for article in articles %}
        <div>
            <h2>article.title</h2>
            <p>article.content|truncatewords:50</p>
        </div>
    {% endfor %}
</body>
</html>

Étape 5 : Configurer les URLs

Configurez les URL pour accéder à la page d'accueil.

## monprojet/monprojet/urls.py
from django.contrib import admin
from django.urls import path
from .views import home

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', home, name='home'),
]

Étape 6 : Créer un Superutilisateur

Créez un superutilisateur pour administrer l'application.

$ python manage.py createsuperuser

Étape 7 : Lancer la Application Localement

Lancez l'application localement et accédez à http://127.0.0.1:8000/.

$ python manage.py runserver

Étape 8 : Initialiser le Repository Git

Initialisez le repository Git pour Heroku.

## Création d'un répertoire git
$ git init

## Ajout des fichiers au dépôt
$ git add .

## Commit initial
$ git commit -m "Initial commit"

Étape 9 : Déployer sur Heroku

Connectez-vous à votre compte Heroku et déployez l'application.

## Connexion à Heroku
$ heroku login

## Création de l'application
$ heroku create mon-nom-d-app

## Push vers Heroku
$ git push heroku master

## Accès à l'application
$ heroku open

Erreurs frequentes et debugging

1. Erreur : Command not found: gunicorn

Cause : Gunicorn n'est pas installé.

Correction :

## Installer Gunicorn
$ pip install gunicorn

2. Erreur : ModuleNotFoundError: No module named 'gunicorn'

Cause : Le package Gunicorn n'est pas inclus dans le requirements.txt.

Correction :

## Ajouter Gunicorn au requirements.txt
$ echo "gunicorn" >> requirements.txt

## Relancer l'application
$ heroku restart

3. Erreur : ValueError: invalid literal for int() with base 10: 'None'

Cause : Une erreur dans la configuration de Heroku.

Correction :

## Vérifier les logs Heroku
$ heroku logs --tail

## Corriger la configuration si nécessaire

Pour aller plus loin

1. Amélioration des performances avec Gunicorn et Nginx

Utilisez Gunicorn comme serveur WSGI et Nginx pour servir des fichiers statiques.

2. Utilisation d'un environnement virtuel Python

Créez un environnement virtuel Python pour isoler les dépendances du projet.

3. Déploiement continue avec GitHub Actions

Automatisez le déploiement continu sur Heroku à chaque push vers la branche main.

Défi pratique

Développez une application web simple qui permet aux utilisateurs de soumettre des commentaires sur un article. Utilisez Django pour le backend et les modèles, et créez un formulaire pour ajouter des commentaires.