Création de modèles Django : un tutoriel

Hark Labs2022-03-08 · 13 min read

Création de modèles Django : un tutoriel

Django est un framework web bien connu pour le développement rapide de sites et d'applications web sécurisés et faciles à maintenir. Construit avec Python, Django simplifie le développement web, permettant de consacrer plus de temps et d'attention à l'écriture d'applications sans réinventer la roue à chaque fois. Django est un projet gratuit et open-source doté d'une documentation officielle solide, d'un excellent soutien de la communauté et de nombreuses options d'assistance gratuites et payantes.

Dans ce guide, nous allons nous plonger dans la création de modèles Django. Dans Django, un modèle est la source d'informations clé concernant vos données. Les modèles décrivent les champs et le comportement des données à stocker. Django utilise le modèle pour générer les tables de la base de données à l'aide de l'ORM (Object Relational Mapping), également appelés modèles.

Prérequis

Nous travaillons sur un système d'exploitation basé sur Unix, de préférence un serveur cloud Ubuntu 20.04 comme système sur lequel nous avons testé. Si vous souhaitez configurer Django sur un environnement similaire, veuillez vous référer à notre tutoriel, « Comment installer Django et configurer un environnement de développement sur Ubuntu 20.04.”

Étape 1. Environnement de développement Python

Django est construit sur Python. Nous avons donc besoin d'un environnement de développement Python robuste avec tous les outils nécessaires pour travailler avec des applications Python. Nous en avons déjà discuté dans un guide dédié. Ici, nous ferons une courte démonstration.

Tout d'abord, lancez un terminal et exécutez les commandes suivantes :

$ sudo apt update && sudo apt upgrade -y
$ sudo apt install python3 python-is-python3

1 2	$ sudo apt update && sudo apt upgrade -y $ sudo apt install python3 python-is-python3

Ensuite, installez pip – le gestionnaire de paquets Python :

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Ensuite, installez des paquets de développement supplémentaires :

$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

1	$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

Pour établir un environnement virtuel, nous avons également besoin du module Python venv :

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

Étape 2. Installation du serveur MySQL

MySQL est un système de gestion de base de données relationnelle populaire. Il est open-source, stable et riche en fonctionnalités. Nous utiliserons MySQL comme serveur de base de données pour notre application Django. Installez MySQL à l'aide d'APT :

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

Ensuite, vérifiez l'installation :

$ systemctl status mysql

1	$ systemctl status mysql

Il s'agit d'une configuration minimale de MySQL avec les options par défaut. Consultez le guide plus détaillé sur l'installation et la configuration de MySQL.

Étape 3. Configuration de l'application Django

Nous sommes maintenant prêts à créer notre application Django. Si vous êtes intéressé par une démonstration plus approfondie de Django, veuillez vous référer à notre tutoriel, « Installer le framework web Django sur Ubuntu 20.04.”

Ensuite, créez un répertoire dédié pour l'application. Le nom du répertoire doit refléter le nom du projet :

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

Dans le répertoire du projet, créez un environnement virtuel Python à l'aide du module venv :

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Activez l'environnement virtuel :

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Installez Django à l'aide de pip:

$ pip install django

1	$ pip install django

Ensuite, créez un nouveau projet Django à l'aide de la commande django-admin :

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

Étape 4. Configuration de l'application Django

L'application Django contient toutes les configurations par défaut. Pour notre objectif, nous devons effectuer quelques ajustements.

Commencez par éditer le fichier de configuration settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

1	$ nano sample_app/sample_app/sample_app/settings.py

Ensuite, modifiez le fuseau horaire :

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Ajoutez les machines autorisées à accéder au serveur de l'application Django :

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Après cela, appliquez les modifications :

$ python manage.py migrate

1	$ python manage.py migrate

Enfin, créez un superutilisateur pour notre application web Django :

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

Étape 5. Connexion de l'application Django à MySQL

Pour se connecter à MySQL, nous avons besoin d'une bibliothèque de connecteurs Python supplémentaire compatible avec Django. Nous utiliserons mysqlclient.

Tout d'abord, assurez-vous que les paquets nécessaires sont installés :

$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

1	$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

Ensuite, installez mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Création d'une base de données dédiée

Pour notre application, nous devons créer une base de données dédiée et un utilisateur de base de données. Lancez le shell MySQL en tant que root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Créez une base de données dédiée pour notre application Django :

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

Ensuite, créez un utilisateur de base de données dédié pour l'application Django :

$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

1	$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

Enfin, accordez à l'utilisateur dédié toutes les autorisations sur la base de données dédiée :

$ GRANT ALL ON <database>.* TO '<username'@'%';

1	$ GRANT ALL ON <database>.* TO '<username'@'%';

Modification de la configuration de Django pour utiliser MySQL

Maintenant, nous devons ajuster certaines configurations de Django afin qu'il puisse utiliser MySQL comme serveur de base de données. Ouvrez settings.py dans un éditeur de texte :

$ nano settings.py

1	$ nano settings.py

Faites défiler vers le bas jusqu'à la section DATABASES et collez le code suivant :

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'OPTIONS': {
'read_default_file': '/etc/mysql/my.cnf',
},
}
}

DATABASES = {

'default': {

'ENGINE': 'django.db.backends.mysql',

'OPTIONS': {

'read_default_file': '/etc/mysql/my.cnf',

}

Ensuite, modifiez le fichier de configuration MySQL afin qu'il contienne les identifiants de base de données nécessaires :

$ sudo nano /etc/mysql/my.cnf

1	$ sudo nano /etc/mysql/my.cnf

Ajoutez le bloc suivant à la fin du fichier :

[client]
database = <dedicated_database>
user = <dedicated_user>
password = <user_password>
default-character-set = utf8

[client]

database = <dedicated_database>

user = <dedicated_user>

password = <user_password>

default-character-set = utf8

Redémarrez MySQL pour que les modifications prennent effet :

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

1 2	$ sudo systemctl daemon-reload $ sudo systemctl restart mysql

Étape 6. Création d'un modèle Django

Nous sommes maintenant prêts à créer un nouveau modèle au sein de notre projet Django. Activez l'environnement virtuel :

$ cd sample_app/
$ . sample_app_env/bin/activate
$ cd sample_app/

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

À cet emplacement, demandez à Django de créer une nouvelle application :

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

Après la création, l'arborescence des fichiers devrait ressembler à ceci. Ici, le fichier models.py contiendra les codes de notre modèle Django personnalisé :

Vérifiez le contenu actuel du fichier :

$ cat models.py

1	$ cat models.py

À titre de démonstration, nous allons créer un modèle pour les articles de blog nommé Post. Il contiendra les champs suivants :

title : Titre de l'article de blog.
slug : Stocke et génère des URL valides pour les pages web.
content : Le texte de l'article de blog.
created_on : Date de création de l'article.
author : L'utilisateur qui a créé l'article.

Ouvrez le fichier models.py dans un éditeur de texte :

$ nano models.py

1	$ nano models.py

Importons quelques API nécessaires pour notre modèle. Par défaut, il importe l'API des modèles. Nous aurons également besoin de l'API slugify pour générer des slugs, de User pour l'authentification, et de reverse pour une création d'URL meilleure et plus flexible :

from django.db import models
from django.template.defaultfilters import slugify
from django.contrib.auth.models import User
from django.urls import reverse

from django.db import models

from django.template.defaultfilters import slugify

from django.contrib.auth.models import User

from django.urls import reverse

Ensuite, ajoutez la méthode de classe appelée Post. Elle contiendra les champs de base de données nécessaires comme title, slug, content, created_on, et author:

class Post(models.Model):
   title = models.CharField(max_length=255)
   slug = models.SlugField(unique=True, max_length=255)
   content = models.TextField()
   created_on = models.DateTimeField(auto_now_add=True)
   author = models.TextField()

class Post(models.Model):

title = models.CharField(max_length=255)

slug = models.SlugField(unique=True, max_length=255)

content = models.TextField()

created_on = models.DateTimeField(auto_now_add=True)

author = models.TextField()

Nous avons besoin de la fonctionnalité de génération d'URL et de sauvegarde de l'article. C'est important car cela génère des liens uniques correspondant à des articles uniques :

def get_absolute_url(self):
   return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):
   if not self.slug:
      self.slug = slugify(self.title)
      super(Post, self).save(*args, **kwargs)

def get_absolute_url(self):

return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):

if not self.slug:

self.slug = slugify(self.title)

super(Post, self).save(*args, **kwargs)

La section suivante indiquera au modèle comment trier l'article et l'afficher sur la page web. Nous allons encoder la logique à l'aide d'une classe interne, Meta. Elle contiendra une logique de modèle supplémentaire qui ne concerne pas la définition des champs de la base de données :

class Meta:
   ordering = ['created_on']

def __unicode__(self):
   return self.title

class Meta:

ordering = ['created_on']

def __unicode__(self):

return self.title

Enfin, nous aurons la fonctionnalité du modèle Comment dans ce fichier. Cela nécessite d'ajouter une autre classe Comment en utilisant models.Model comme signature. Elle contiendra les champs de base de données suivants :

name : Nom de l'auteur du commentaire.
email : Adresse e-mail de l'auteur du commentaire.
text : Contenu du commentaire lui-même.
post : L'article sur lequel le commentaire a été publié.
created_on : Date et heure de création du commentaire.

Le code ressemblera à quelque chose comme ceci :

class Comment(models.Model): 
   name = models.CharField(max_length=42) 
   email = models.EmailField(max_length=75) 
   website = models.URLField(max_length=200, null=True, blank=True) 
   content = models.TextField() 
   post = models.ForeignKey(Post, on_delete=models.CASCADE) 
   created_on = models.DateTimeField(auto_now_add=True)

class Comment(models.Model):

name = models.CharField(max_length=42)

email = models.EmailField(max_length=75)

website = models.URLField(max_length=200, null=True, blank=True)

content = models.TextField()

post = models.ForeignKey(Post, on_delete=models.CASCADE)

created_on = models.DateTimeField(auto_now_add=True)

À ce stade, notre fichier models.py ressemblera à ceci :

Enfin, enregistrez le fichier et fermez l'éditeur.

Étape 7. Mise à jour des paramètres Django

Le modèle est créé. Cependant, nous devons ajuster certains fichiers de configuration pour mettre le modèle en action. Dans settings.py, nous devons ajouter notre modèle sous INSTALLED_APPS.

Ouvrez settings.py dans un éditeur de texte :

$ nano settings.py

1	$ nano settings.py

Enregistrez le nouveau module sous la section INSTALLED_APPS:

Enregistrez le fichier et fermez l'éditeur.

Étape 8. Migration des modifications

Maintenant que nous avons ajouté tous les modèles souhaités, l'étape suivante consiste à appliquer ces modifications. Django appliquera ces schémas à notre base de données MySQL.

La commande suivante générera tous les fichiers de migration nécessaires. La sortie affichera les emplacements de tous ces fichiers dans le répertoire du projet :

$ python manage.py makemigrations

1	$ python manage.py makemigrations

La commande suivante listera toutes les migrations existantes :

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Notez que toutes les migrations sont marquées à l'exception de 0001_initial qui a été créée dans le cadre des modèles Post et Comment.

La commande suivante montrera quelle requête SQL Django exécutera pour effectuer les migrations :

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Tout ce qu'il nous reste à faire maintenant est d'appliquer les migrations. Ces migrations écriront les modifications dans la base de données :

$ python manage.py migrate

1	$ python manage.py migrate

Étape 9. Vérification des modifications

Pour vérifier les modifications, jetons un coup d'œil à notre base de données MySQL. Démarrez le shell MySQL en tant qu'utilisateur Django :

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

Ensuite, remplacez la base de données active actuelle par la base de données de l'application Django :

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

Affichez la liste de toutes les tables de la base de données :

$ SHOW TABLES;

1	$ SHOW TABLES;

Enfin, pour voir le contenu de l'une des tables, utilisez la DESCRIBE requête :

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

Limites de Django avec MySQL

Lorsque vous utilisez MySQL comme serveur de base de données pour votre application Django, il y a quelques points à garder à l'esprit :

Il y a peu de prise en charge des transactions pour les processus de modification de schéma. Cela signifie que si une migration échoue, il est nécessaire d'annuler manuellement toutes les modifications avant de tenter une autre migration. Il n'y a aucun moyen de revenir à un point antérieur où la migration ayant échoué n'avait pas eu lieu.
Pour la plupart des processus de modification de schéma, MySQL réécrit complètement les tables. Dans certaines situations, cela peut prendre beaucoup de temps. Au pire, la complexité temporelle sera proportionnelle au nombre de lignes à ajouter ou de colonnes à supprimer. Selon la documentation officielle de Django, cela pourrait prendre une minute par million de lignes.
MySQL impose une limite de caractères pour la longueur des noms de colonnes, de tables et d'index. Il existe également une limite sur la taille totale de toutes les colonnes et couvertures d'index. Django peut dépasser cette limite. Certains backends autres que MySQL peuvent gérer la limite plus élevée de Django.

C'est pourquoi il est fortement recommandé de peser vos options et de choisir celle qui convient le mieux.

Réflexions finales

Ce guide démontre avec succès comment ajouter des modules à une application Django existante. Nous avons utilisé MySQL comme backend pour l'application. Il présente également certains concepts clés de Django tels que les modèles, le fonctionnement des migrations et la manière dont Django traduit les modèles en tables de base de données MySQL.

Bon développement !

Hark Labs

Auteur · CloudSigma

Preslav Dobrev est un designer créatif chez CloudSigma, axé sur une identité commerciale cohérente à travers des canaux marketing traditionnels et innovants. Il excelle à fusionner la vision artistique avec le marketing stratégique pour créer des récits de marque percutants.