Django avec MySQL : guide pratique

Pourquoi Django avec MySQL : guide pratique ?

Au quotidien, les développeurs ont besoin d'une combinaison puissante de technologies pour construire des applications robustes et scalables. Le framework Django est une solution idéale pour la création de sites Web et d'applications backend grâce à sa structure MVC (Model-View-Controller), ses outils de gestion de contenu, et sa sécurité intégrée. Cependant, pour une grande base de données ou un grand nombre d'utilisateurs en même temps, il est souvent nécessaire de passer à MySQL comme backend. C'est pourquoi ce tutoriel vous guide à travers le processus d'intégration de Django avec MySQL.

Un cas d'usage concret : Imaginez que vous travaillez pour une petite entreprise qui souhaite développer une application web pour gérer les projets et leurs tâches. Cette application devra être en mesure de stocker des milliers de projets, de millions de tâches, et de traiter plusieurs centaines d'utilisateurs simultanément. Utiliser Django avec MySQL permettra à cette application de répondre efficacement aux besoins de l'entreprise tout en restant performante et sécurisée.

Prerequis

• Connaissances en Python et Django (version 3.x recommandée)
• Connaissance de base en SQL
• Installation d'un environnement de développement Python (Python 3.8 ou ultérieur)
• Installation de MySQL serveur et client
• Un IDE ou éditeur de code comme Visual Studio Code, PyCharm, ou Sublime Text

Concepts fondamentaux

1. Base de données avec Django

Django utilise des modèles (Models) pour définir la structure de votre base de données. Ces modèles sont ensuite mappés directement en tables SQL.

## models.py
from django.db import models

class Tache(models.Model):
    nom = models.CharField(max_length=200)
    description = models.TextField()
    date_deadline = models.DateField()

    def __str__(self):
        return self.nom

2. Configuration de la base de données dans Django

Pour connecter Django à MySQL, vous devez configurer les paramètres de connexion dans le fichier settings.py.

## settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'votre_base_de_donnees',
        'USER': 'votre_utilisateur',
        'PASSWORD': 'votre_mot_de_passe',
        'HOST': 'localhost',  # Ou l'adresse de votre serveur MySQL
        'PORT': '3306',       # Le port par défaut pour MySQL
    }
}

3. Migration des modèles en base de données

Après avoir défini vos modèles, vous devez les migrer pour créer les tables SQL correspondantes.

## Terminal
python manage.py makemigrations
python manage.py migrate

Mise en pratique : projet fil rouge - Gestionnaire de tâches

Pour illustrer l'intégration Django avec MySQL, nous allons construire un gestionnaire de tâches simple. Ce projet comprendra des fonctionnalités pour ajouter, afficher, modifier et supprimer des tâches.

Étape 1 : Création du projet Django

## Terminal
django-admin startproject gestion_taches
cd gestion_taches

Étape 2 : Création de l'application

## Terminal
python manage.py startapp tache

Étape 3 : Définition des modèles

Ajoutez le modèle Tache dans le fichier tache/models.py.

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

class Tache(models.Model):
    nom = models.CharField(max_length=200)
    description = models.TextField()
    date_deadline = models.DateField()

    def __str__(self):
        return self.nom

Étape 4 : Configuration des modèles dans settings.py

Ajoutez l'application tache à la liste des applications dans gestion_taches/settings.py.

## settings.py
INSTALLED_APPS = [
    ...
    'tache',
]

Étape 5 : Création des vues

Créez un fichier views.py dans le répertoire tache.

## tache/views.py
from django.shortcuts import render, redirect
from .models import Tache

def tache_list(request):
    taches = Tache.objects.all()
    return render(request, 'tache/tache_list.html', {'taches': taches})

def tache_add(request):
    if request.method == 'POST':
        nom = request.POST.get('nom')
        description = request.POST.get('description')
        date_deadline = request.POST.get('date_deadline')
        Tache.objects.create(nom=nom, description=description, date_deadline=date_deadline)
        return redirect('tache_list')
    return render(request, 'tache/tache_add.html')

def tache_edit(request, id):
    tache = Tache.objects.get(id=id)
    if request.method == 'POST':
        tache.nom = request.POST.get('nom')
        tache.description = request.POST.get('description')
        tache.date_deadline = request.POST.get('date_deadline')
        tache.save()
        return redirect('tache_list')
    return render(request, 'tache/tache_edit.html', {'tache': tache})

def tache_delete(request, id):
    tache = Tache.objects.get(id=id)
    tache.delete()
    return redirect('tache_list')

Étape 6 : Configuration des URL

Ajoutez les URL dans tache/urls.py et incluez les URLs de l'application dans gestion_taches/urls.py.

## tache/urls.py
from django.urls import path
from .views import tache_list, tache_add, tache_edit, tache_delete

urlpatterns = [
    path('', tache_list, name='tache_list'),
    path('add/', tache_add, name='tache_add'),
    path('edit/<int:id>/', tache_edit, name='tache_edit'),
    path('delete/<int:id>/', tache_delete, name='tache_delete'),
]
python
## gestion_taches/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('tache.urls')),
]

Étape 7 : Création des templates

Créez un répertoire templates/tache et ajoutez les fichiers suivants :

• tache_list.html
• tache_add.html
• tache_edit.html

<!-- tache/templates/tache/tache_list.html -->
<!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 tache in taches %}
            <li>tache.nom - tache.description - tache.date_deadline</li>
        {% endfor %}
    </ul>
    <a href="{% url 'tache_add' %}">Ajouter une Tâche</a>
</body>
</html>
html
<!-- tache/templates/tache/tache_add.html -->
<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Ajouter une Tâche</title>
</head>
<body>
    <h1>Ajouter une Tâche</h1>
    <form method="post">
        {% csrf_token %}
        <label for="nom">Nom:</label>
        <input type="text" id="nom" name="nom"><br><br>
        <label for="description">Description:</label>
        <textarea id="description" name="description"></textarea><br><br>
        <label for="date_deadline">Date limite:</label>
        <input type="date" id="date_deadline" name="date_deadline"><br><br>
        <button type="submit">Ajouter</button>
    </form>
    <a href="{% url 'tache_list' %}">Retourner à la liste des tâches</a>
</body>
</html>
html
<!-- tache/templates/tache/tache_edit.html -->
<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Modifier une Tâche</title>
</head>
<body>
    <h1>Modifier une Tâche</h1>
    <form method="post">
        {% csrf_token %}
        <label for="nom">Nom:</label>
        <input type="text" id="nom" name="nom" value="tache.nom"><br><br>
        <label for="description">Description:</label>
        <textarea id="description" name="description">tache.description</textarea><br><br>
        <label for="date_deadline">Date limite:</label>
        <input type="date" id="date_deadline" name="date_deadline" value="tache.date_deadline"><br><br>
        <button type="submit">Modifier</button>
    </form>
    <a href="{% url 'tache_list' %}">Retourner à la liste des tâches</a>
</body>
</html>

Étape 8 : Migrer les modèles

Exécutez les commandes pour migrer les modèles en base de données.

## Terminal
python manage.py makemigrations
python manage.py migrate

Étape 9 : Créer un superuser

Créez un utilisateur admin pour accéder à l'interface d'administration Django.

## Terminal
python manage.py createsuperuser

Étape 10 : Lancer le serveur de développement

Démarrage du serveur Django pour voir votre application en action.

## Terminal
python manage.py runserver

Allez sur http://127.0.0.1:8000/ et vous verrez votre gestionnaire de tâches fonctionnel avec MySQL en backend.

Erreurs frequentes et debugging

1. Erreur : django.db.utils.OperationalError: (2003, "Can't connect to MySQL server on 'localhost' (10061)

Code incorrect :

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'votre_base_de_donnees',
        'USER': 'votre_utilisateur',
        'PASSWORD': 'votre_mot_de_passe',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

Code correct :

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'votre_base_de_donnees',
        'USER': 'votre_utilisateur',
        'PASSWORD': 'votre_mot_de_passe',
        'HOST': 'localhost',  # Assurez-vous que MySQL est bien installé et en cours d'exécution
        'PORT': '3306',
    }
}

2. Erreur : django.db.utils.ProgrammingError: (1064, "You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'LIMIT 21' at line 1")

Code incorrect :

taches = Tache.objects.all()[:20]

Code correct :

from django.db.models import Count

taches = Tache.objects.annotate(comments_count=Count('comments')).all()[:20]

3. Erreur : django.db.utils.IntegrityError: (1062, "Duplicate entry '1' for key 'PRIMARY'")

Code incorrect :

Tache.objects.create(id=1, nom='Tâche 1', description='Description de la tâche')

Code correct :

tache = Tache(nom='Tâche 1', description='Description de la tâche')
tache.save()

Pour aller plus loin

1. Utilisation des QuerySets avancés

Enseigner les fonctions d'aggrégation et les jointures complexes pour traiter les données.

Documentation Django ORM

2. Sécurité et authentification

Expliquer comment sécuriser une application avec des utilisateurs et des groupes.

Documentation Django Auth

3. Optimisation des requêtes SQL

Pratiques pour optimiser les performances des requêtes en base de données.

Documentation Django Optimization

Défi pratique :

• Ajoutez une fonctionnalité d'importation de tâches à partir d'un fichier CSV. Utilisez la bibliothèque csv pour lire le fichier et Django ORM pour enregistrer les données dans la base de données.

## tache/views.py
import csv

def import_taches_from_csv(request):
    if request.method == 'POST':
        file = request.FILES['file']
        reader = csv.reader(file)
        for row in reader:
            Tache.objects.create(nom=row[0], description=row[1], date_deadline=row[2])
        return redirect('tache_list')
    return render(request, 'tache/import_taches.html')
html
<!-- tache/templates/tache/import_taches.html -->
<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Importer des Tâches à partir de CSV</title>
</head>
<body>
    <h1>Importer des Tâches à partir de CSV</h1>
    <form method="post" enctype="multipart/form-data">
        {% csrf_token %}
        <input type="file" name="file"><br><br>
        <button type="submit">Importer</button>
    </form>
    <a href="{% url 'tache_list' %}">Retourner à la liste des tâches</a>
</body>
</html>

Ajoutez cette URL dans tache/urls.py :

## tache/urls.py
path('import/', import_taches_from_csv, name='import_taches'),

Maintenant, vous pouvez importer des tâches à partir d'un fichier CSV en visitant la page /import/.

Ce tutoriel devrait vous fournir une bonne compréhension de l'intégration de Django avec MySQL. Vous pouvez maintenant commencer à développer vos propres applications utilisant cette combinaison puissante de technologies.