Tutoriel Django : Comprendre les fondamentaux du framework Django

Django est un framework web Python de haut niveau utilisé pour un développement rapide et une conception propre et pragmatique. Il simplifie de nombreuses tâches de développement web, vous permettant de vous concentrer sur l’écriture de votre application sans avoir à réinventer la roue.

Cela en fait l’un des frameworks web les plus populaires et les plus utilisés pour la création de sites web et d’applications dynamiques et basées sur les données.

Dans ce tutoriel, nous vous présenterons les principes fondamentaux de Django et vous fournirons une base solide pour construire votre première application web. Nous aborderons tout, de la configuration d’un VPS et de l’installation de Python au déploiement de votre projet Django.

À la fin de ce tutoriel, vous aurez une application web entièrement fonctionnelle et une solide compréhension de la façon de poursuivre le développement de vos propres projets à l’aide de Django. Que vous soyez novice en développement web ou que vous souhaitiez développer vos compétences, ce tutoriel Django vous aidera à maîtriser les bases.

Installation du framework Django

Avant de vous plonger dans la construction de votre application Django, vous devez mettre en place votre environnement de développement. Ce processus comprend la mise en place d’un VPS, l’installation de Python, la création d’un environnement virtuel et l’installation de Django.

Conditions préalables

Avant de commencer à travailler avec Django, il est important d’avoir une compréhension de base de certains concepts. Voici ce que vous devez connaître :

• Connaissance de base de Python : Une bonne maîtrise des fondamentaux de Python – types de données, structures de contrôle, fonctions, classes, modules.
• Bases de HTML, CSS et JavaScript : Connaissances de base en HTML, CSS et JavaScript.
• Compréhension des bases de données : Concepts des bases de données – tables, enregistrements, clés primaires, clés étrangères. Des connaissances en SQL sont un plus.
• Familiarité avec l’interface en ligne de commande (CLI) : Connaissance de base des commandes Linux essentielles.

Avec ces prérequis, vous serez bien préparé pour comprendre et suivre les étapes nécessaires à l’installation de Django et à la création de vos applications web.

Obtenir un VPS Django

Le choix d’un environnement d’hébergement approprié est crucial pour le bon fonctionnement de votre application Django. Un serveur privé virtuel (VPS) offre plus de contrôle, d’évolutivité et de ressources que l’hébergement mutualisé, ce qui le rend idéal pour les projets Django. L’hébergement VPS Django d’Hostinger est un excellent choix, offrant des plans abordables ainsi que des serveurs faciles à configurer et à gérer.

Lorsque vous choisissez un plan VPS chez Hostinger, tenez compte des besoins de votre projet :

• CPU et RAM : Un CPU plus rapide et une RAM plus importante permettent d’améliorer les performances, en particulier pour les applications plus complexes ou les volumes de trafic plus importants.
• Stockage : Les applications Django travaillent souvent avec des bases de données et des fichiers statiques. Assurez-vous que votre VPS dispose de suffisamment de stockage SSD pour vos besoins.
• Bande passante : En fonction du trafic attendu, choisissez un plan avec suffisamment de bande passante pour accueillir vos visiteurs sans ralentissement.

Pour un projet Django de base, un plan VPS de niveau inférieur comme KVM 1 ou KVM 2 devrait être suffisant, mais au fur et à mesure que votre projet grandit, vous pouvez facilement passer à des options de niveau supérieur pour plus de ressources.

Une fois que vous avez choisi un plan VPS et effectué l’achat, suivez les étapes suivantes pour configurer le serveur :

1. Démarrez l’installation du VPS : Connectez-vous à hPanel – sur la page d‘accueil, vous verrez une configuration VPS en attente.

Cliquez sur Configuration et Commencer maintenant dans la fenêtre suivante.

2. Choisissez un emplacement pour votre VPS : réfléchissez à la région d’où vous attendez du trafic. La région où la latence est la plus faible ne sera pas nécessairement la meilleure pour votre application si le trafic attendu provient d’Australie alors que vous êtes situé en Europe.

3. Sélectionnez le template de système d’exploitation : Pour ce guide, vous devriez sélectionner Plain OS Ubuntu ; cependant, Hostinger propose également un OS avec des options Panel et un OS avec Application stack (dépendances logicielles préinstallées).
   
4. Configurez les informations d’identification de votre VPS : Entrez le mot de passe root et ajoutez une clé SSH si vous le souhaitez. Terminez l’installation.
   
5. Connexion via SSH : Utilisez un client SSH (par exemple, PuTTY pour Windows ou le terminal pour macOS/Linux) pour vous connecter au serveur. Dans votre terminal, entrez :

ssh root@votre_ip_vps

Remplacez votre_ip_vps par l’adresse IP du VPS de Hostinger. Vous serez invité à entrer votre mot de passe root.

6. Mettez à jour le serveur : Il est important de s’assurer que votre serveur est à jour. Exécutez la commande suivante pour mettre à jour les paquets du système :

apt update && apt upgrade -y

Le VPS étant prêt, vous pouvez maintenant installer Python et les autres dépendances nécessaires au développement de Django.

Installer Python

Pour faire fonctionner Django, vous devez installer Python et pip sur votre VPS. La plupart des distributions Linux modernes, comme Ubuntu, sont livrées avec Python préinstallé. 

Si vous ne l’avez pas installé ou si vous devez le mettre à jour, vous pouvez le faire facilement. Utilisez les commandes suivantes pour vérifier la version actuelle de Python et installer la dernière version de Python 3 :

1. Vérifier si Python est installé :

python3 --version

Si votre interface de ligne de commande renvoie le numéro de version de Python, le langage de programmation est déjà installé. Dans ce cas, il suffit d’installer pip :

apt install python3-pip

2. Installer Python et pip (si nécessaire) :

apt install python3 python3-pip -y

Une fois Python installé, vous êtes prêt à mettre en place un environnement virtuel.

Mise en place d’un environnement virtuel

Un environnement virtuel est un espace isolé dans lequel vous pouvez installer des paquets Python et des dépendances pour un projet spécifique. Cette méthode n’affecte pas l’environnement Python du système ni les autres projets. 

Ceci est crucial lorsque l’on travaille avec Django, car différents projets peuvent nécessiter différentes versions de paquets. Un environnement virtuel permet de s’assurer que les dépendances de chaque projet sont bien contenues et n’entrent pas en conflit avec d’autres.

Pourquoi utiliser un environnement virtuel :

• Isolation : Les dépendances de votre projet sont séparées des autres projets Python.
• Contrôle de version : Vous pouvez installer différentes versions de paquets dans chaque espace de travail virtuel, ce qui permet d’éviter les conflits entre les projets.
• Environnement plus propre : Il vous permet d’expérimenter avec des paquets sans affecter l’environnement global de Python sur votre serveur.

Suivez les étapes suivantes pour configurer un environnement virtuel sur votre VPS :

1. Installez le paquetage venv (s’il n’est pas déjà installé) :

apt install python3-venv -y

2. Créez et naviguez jusqu’au répertoire dans lequel vous souhaitez stocker votre projet Django et créez un environnement virtuel :

mkdir myprojectcd myproject

Remplacez myproject par le nom que vous souhaitez donner à votre dossier de projet.

3. Créer un environnement virtuel à l’aide de venv :

python3 -m venv env_name

4. Activer l’environnement virtuel :

source env_name/bin/activate

Une fois activée, l’invite de l’interpréteur de commandes change pour refléter l’environnement (par exemple, (nom_env)), indiquant que vous travaillez dans votre environnement virtuel.

Cette configuration garantit que toutes les dépendances liées à Django sont isolées dans l’environnement virtuel, ce qui permet à votre serveur de rester propre et organisé.

Installer Django

Une fois votre environnement virtuel mis en place, l’étape suivante consiste à installer le framework web lui-même, ce que vous pouvez faire à l’aide du gestionnaire de paquets de Python, pip. L’installation de Django dans votre environnement virtuel permet de l’isoler des autres projets et de le gérer indépendamment.

Pour installer Django, suivez les étapes suivantes :

1. Une fois votre environnement virtuel activé, utilisez pip pour installer la dernière version de Django :

pip install django

Cela permet de télécharger et d’installer toutes les dépendances et le framework web Django dans l’environnement virtuel.

2. Utilisez la commande suivante pour confirmer que Django est installé et pour vérifier la version :

django-admin --version

Vous obtiendrez ainsi la version de Django actuellement installée dans votre environnement, ce qui confirme que l’installation s’est déroulée avec succès.

Avec votre VPS préparé pour l’hébergement Django, vous pouvez commencer à construire votre application.

Création d’un nouveau projet Django

Il est temps de créer votre première application Django. Dans cette section, vous établirez la base de code nécessaire pour commencer à développer votre site web.

Créons un nouveau projet Django :

1. Naviguez jusqu’au répertoire de votre projet : Si vous ne vous trouvez pas déjà dans le répertoire où vous souhaitez créer le projet, utilisez la commande cd pour vous y rendre.
2. Exécutez la commande startproject : Utilisez la commande startproject de Django pour créer un nouveau projet. Remplacez myproject par le nom de votre projet :

django-admin startproject myproject

Cela créera un nouveau répertoire nommé myproject contenant la structure du projet par défaut.

3. Ensuite, naviguez jusqu’au dossier interne de votre projet :

cd myproject/myproject

4. Ajoutez l’IP de votre serveur à ALLOWED_HOSTS : Utilisez l’un des éditeurs de texte par défaut d’Ubuntu (nano ou vim) et ouvrez le fichier settings.py :

vim settings.py

Localisez le paramètre ALLOWED_HOSTS et modifiez-le pour ajouter l’IP de votre VPS comme suit :

ALLOWED_HOSTS = ['votre_ip_vps']

Remplacez votre_ip_vps par l’IP réelle de votre VPS dans la console Hostinger.

5. Démarrez le serveur de développement : Pour vérifier que tout est correctement configuré, vous pouvez démarrer le serveur de développement de Django. Retournez dans la catégorie du projet parent et exécutez runserver :

python manage.py runserver 0.0.0.0:8000

Maintenant, ouvrez votre navigateur et allez sur http://votre_ip_vps:8000/ – remplacez votre_ip_vps par l’IP de votre VPS. Si tout a été fait correctement, vous devriez voir la page de bienvenue de Django :

Si vous avez suivi ces étapes, vous avez construit et exécuté avec succès un projet Django par défaut sur votre VPS. Le reste de ce tutoriel Django va plus loin dans le développement de l’application et la compréhension de Django en général.

Comprendre la structure du projet Django

L’exécution de la commande startproject crée une structure de projet Django de base qui comprend plusieurs fichiers et répertoires clés. Voici une décomposition de la structure et de l’objectif de chaque composant :

Chacun de ces fichiers et répertoires joue un rôle spécifique dans votre projet Django :

1. manage.py :

Il s’agit d’un utilitaire en ligne de commande qui vous aide à interagir avec votre projet Django. Vous l’utilisez pour des tâches telles que l’exécution du serveur de développement, la migration des bases de données et la gestion de votre application.

Voici à quoi il ressemble :

Voici ses principales fonctions :

Définit la variable d’environnement pour indiquer à Django le fichier de configuration à utiliser.

Exécute diverses commandes Django telles que runserver, migrate et autres.

2. myproject/ :

Le répertoire interne du projet qui contient les paramètres de base, les configurations et d’autres fichiers par défaut pour un projet Django.

3. __init__.py :

Ce fichier marque le répertoire comme un paquetage Python, permettant au code d’être importé comme un module dans Python. Il est vide par défaut.

4. settings.py :

Il s’agit de l’un des fichiers les plus importants de Django. Il contient tous les paramètres de configuration de votre projet, y compris les configurations de base de données, les applications installées, les intergiciels et les paramètres des fichiers statiques.

5. urls.py :

Ce fichier définit les routes URL pour votre application. Il associe les URL aux vues qui traitent les demandes et renvoient les réponses.

Au fur et à mesure que vous ajouterez des fonctionnalités à votre application, vous étendrez urlpatterns pour inclure les routes de vos propres vues.

6. asgi.py :

Ce fichier fournit un point d’entrée aux serveurs web compatibles ASGI pour servir votre projet. ASGI (Asynchronous Server Gateway Interface) est la norme pour les applications asynchrones de Django.

7. wsgi.py :

Ce fichier est le point d’entrée pour les serveurs web compatibles WSGI tels que Gunicorn ou uWSGI pour servir votre projet dans un environnement de production.

Comprendre le rôle de chaque fichier et répertoire vous permettra de modifier les paramètres, d’ajouter des URL et de gérer la structure de votre projet.

Comprendre les modèles et les bases de données de Django

Une fois votre projet Django mis en place et opérationnel, l’étape suivante consiste à se plonger dans l’un des composants centraux de toute application web : la gestion des données. Explorons comment Django gère les modèles et les bases de données afin d’alimenter des applications dynamiques et axées sur les données.

Création et migration de modèles

Dans Django, les modèles définissent la structure des tables de votre base de données. Il s’agit de classes Python qui correspondent directement aux tables de la base de données, ce qui vous permet d’interagir avec vos données de manière pratique. Chaque classe de modèle représente une table et chaque attribut de modèle représente un champ de la table. 

Django fait abstraction du code SQL, ce qui facilite la création, la mise à jour et la gestion des bases de données sans avoir à écrire des requêtes SQL brutes.

Création d’un modèle

Pour créer un modèle, vous devez définir une classe Python dans le fichier models.py de l’une de vos applications. Chaque attribut de la classe correspond à un champ de la base de données et Django gère automatiquement la structure de la base de données sous-jacente.

Voici un exemple de modèle simple dans Django :

# Dans le fichier models.py de votre application
from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    isbn = models.CharField(max_length=13, unique=True)

    def __str__(self):
        return self.title

• title et author : Il s’agit de champs de caractères (CharField) d’une longueur maximale.
• published_date : Il s’agit d’un champ de date (DateField).
• isbn : Un champ de caractères avec une contrainte d’unicité.

La  méthode __str__() garantit que lorsque vous demandez un livre, le titre du livre sera renvoyé sous la forme d’une chaîne de caractères.

Ajouter le modèle à la base de données

Une fois que vous avez créé votre modèle, Django doit le traduire en une table de base de données. Cela se fait par le biais des migrations, qui sont des fichiers que Django utilise pour garder une trace des modifications apportées à vos modèles.

1. Créer une migration : Pour créer le fichier de migration pour votre nouveau modèle, exécutez la procédure suivante :

python manage.py makemigrations

Django analysera les changements dans votre fichier models.py et générera un fichier de migration décrivant ces changements dans des instructions de type SQL.

Vous obtiendrez un résultat similaire à celui-ci :

Migrations for 'myapp':
  myapp/migrations/0001_initial.py
    - Create model Book

2. Appliquer la migration : Après avoir généré la migration, appliquez-la à la base de données à l’aide de la commande migrate :

python manage.py migrate

Cela créera les tables nécessaires dans votre base de données. Désormais, le modèle Book est représenté par une table Book correspondante dans votre base de données, et vous pouvez commencer à ajouter, interroger et gérer des données.

Mise en place de la base de données

Django prend en charge plusieurs bases de données, ce qui vous permet de choisir celle qui convient le mieux à votre projet. La base de données par défaut de Django est SQLite, qui est légère et facile à configurer, ce qui la rend idéale pour le développement et les petits projets. 

Cependant, pour les environnements de production, des bases de données plus robustes telles que PostgreSQL, MySQL ou MariaDB sont recommandées en raison de leur évolutivité et de leurs performances.

Django fournit un support intégré pour toutes ces bases de données. Commençons par configurer la base de données SQLite par défaut.

Configuration de la base de données SQLite par défaut

Par défaut, Django est configuré pour utiliser SQLite, qui est préinstallé avec Python, de sorte qu’aucune configuration supplémentaire n’est nécessaire. Voici comment vous assurer que votre projet est prêt à utiliser SQLite :

1. Accédez au fichier settings.py de votre projet, qui se trouve dans le dossier du projet (myproject→myproject→settings.py).
2. Allez dans la section DATABASES de settings.py, où Django aura déjà configuré SQLite comme base de données par défaut. Voici à quoi cela ressemble :

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

• ENGINE : Spécifie le back-end de la base de données (dans ce cas, SQLite).
• NAME : Le chemin d’accès au fichier de base de données SQLite (db.sqlite3). Django crée automatiquement ce fichier lorsque vous exécutez la migration initiale.

3. Après avoir confirmé les paramètres de la base de données, vous devez appliquer les migrations initiales pour configurer les tables par défaut (comme les utilisateurs et les sessions). Exécutez la commande suivante :

python manage.py migrate

Cette commande crée le fichier db.sqlite3 à la racine du répertoire de votre projet et met en place toutes les tables nécessaires à l’exécution de votre application.

4. Une fois les migrations terminées, vérifiez que le fichier db.sqlite3 a été créé dans le dossier de votre projet. Ce fichier stocke votre base de données localement et s’étoffera au fur et à mesure que vous ajouterez des données.

Intégration des bases de données

Une fois que vous avez configuré la base de données SQLite par défaut pour le développement, vous pouvez avoir besoin d’intégrer un système de gestion de base de données (SGBD) plus robuste au fur et à mesure que votre projet grandit. Django prend en charge plusieurs SGBD, dont PostgreSQL, MySQL, MariaDB et Oracle, chacun ayant ses propres atouts et son propre processus d’intégration.

Passons en revue chacune des options :

• SQLite : C’est la base de données par défaut de Django et elle est idéale pour le développement et les petits projets. Elle est légère, basée sur des fichiers et ne nécessite pas d’installation au-delà de ce que Django fournit dans la boîte. Cependant, elle n’est pas adaptée aux environnements de production car elle manque de fonctionnalités avancées telles que les écritures simultanées, l’extensibilité et la robustesse en cas de trafic important.
  
  Installation : SQLite ne nécessite aucune installation supplémentaire dans Django ; il est prêt à l’emploi dès sa sortie de l’emballage.
  
  Configuration : Django est préconfiguré pour utiliser SQLite avec les paramètres suivants dans settings.py :

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

Notez que SQlite ne requiert que 2 paramètres – ENGINE et NAME.

• PostgreSQL : Une base de données puissante et open-source avec des fonctionnalités avancées telles que la prise en charge de requêtes complexes, de types de données comme JSON et de la recherche en texte intégral. Elle est fortement recommandée pour les applications Django de production en raison de son évolutivité et de son ensemble de fonctionnalités. PostgreSQL est connu pour adhérer strictement aux normes SQL et être fiable pour les applications complexes et à grande échelle.
  
  Installation : PostgreSQL nécessite l’installation du paquetage psycopg2, qui agit comme un adaptateur entre Django et la base de données PostgreSQL.
  
  Configuration : Outre les paramètres ENGINE et NAME par défaut pour SQLite, PostgreSQL requiert également USER, PASSWORD, HOST et PORT. Tous ces paramètres sont configurés dans le fichier settings.py, dans la section DATABASES :

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Différences : Contrairement à SQLite, PostgreSQL est une base de données complète qui prend en charge plusieurs utilisateurs simultanés, des requêtes avancées et des transactions. Vous devrez installer PostgreSQL sur votre serveur, créer une base de données et un utilisateur, et gérer des configurations plus complexes.

• MySQL / MariaDB : Les deux sont des bases de données relationnelles rapides et fiables qui sont largement utilisées dans le développement web. MySQL est connu pour sa vitesse, tandis que MariaDB, une version dérivée de MySQL, se concentre davantage sur le développement communautaire et est entièrement compatible avec MySQL. Ces bases de données sont excellentes pour les applications web à fort trafic et sont souvent privilégiées pour leurs performances.
  
  Installation : MySQL et MariaDB utilisent tous deux le package mysqlclient pour s’interfacer avec Django.
  
  Configuration : Les deux utilisent les mêmes paramètres que PostgreSQL, configurés dans le fichier settings.py, dans la section DATABASES :

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',  # or 'django.db.backends.mariadb' for MariaDB
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

Différences : MySQL et MariaDB sont réputés pour leurs performances avec les grands ensembles de données et les applications web à fort trafic. Ils prennent en charge plusieurs moteurs de stockage, des lectures rapides et peuvent traiter rapidement des millions de requêtes.

• Oracle / Microsoft SQL Server : Ces bases de données de qualité professionnelle offrent une puissance considérable, en particulier pour les grandes applications web. Cependant, leur configuration peut être plus complexe et elles ne sont généralement utilisées que dans des environnements d’entreprise spécifiques où l’entreprise utilise déjà Oracle ou SQL Server pour d’autres logiciels.
  
  Installation : Les deux requièrent des pilotes supplémentaires pour l’intégration avec Django, tels que cx_Oracle pour Oracle ou pyodbc pour SQL Server. Ces bases de données sont généralement utilisées dans des environnements d’entreprise où d’autres logiciels reposent sur ces systèmes.
  
  Configuration : Chacun de ces systèmes nécessite des processus de configuration plus complexes, notamment l’installation du serveur, la configuration des pilotes et la configuration des informations d’identification de la base de données dans le settings.py, comme pour les options précédentes.
  
  Différences : Oracle et SQL Server offrent des fonctionnalités de niveau entreprise telles que la gestion avancée des transactions, l’optimisation des performances et l’intégration avec des systèmes à grande échelle. Leur configuration est plus complexe et est souvent confiée à des administrateurs de bases de données spécialisés.

Alors, lequel choisir ? Simplifions les choses :

• Développement et tests : Utilisez SQLite. Il est simple, ne nécessite aucune installation et est idéal pour les tests locaux.
• Production à petite échelle : Pour les petites applications web à faible trafic, vous pouvez choisir MySQL ou MariaDB, qui offrent de meilleures performances que SQLite et dont la courbe d’apprentissage est plus facile que celle de PostgreSQL.
• Production à grande échelle : PostgreSQL est le plus recommandé pour les projets Django qui nécessitent de l’évolutivité, de la sécurité et des fonctionnalités avancées.
• Environnements d’entreprise : Si vous travaillez dans une entreprise qui utilise Oracle ou SQL Server pour d’autres applications, ces bases de données peuvent être le meilleur choix en raison des exigences d’intégration.

Configuration de PostgreSQL avec Django

Dans cette section, nous verrons comment intégrer PostgreSQL à Django, car c’est l’une des bases de données les plus couramment utilisées pour les applications de production.

1. Installer PostgreSQL : Pour intégrer PostgreSQL à Django, vous devez d’abord installer PostgreSQL sur votre système :

sudo apt update

sudo apt install postgresql postgresql-contrib

2. Installer l’adaptateur PostgreSQL pour Django : Django utilise le package psycopg2 pour interagir avec PostgreSQL. Installez-le à l’aide de pip :

pip install psycopg2

3. Passez à l’utilisateur PostgreSQL :

sudo -u postgres psql

4. Créer une nouvelle base de données :

CREATE DATABASE mydatabase;

5. Créer un utilisateur avec un mot de passe :

CREATE USER mydatabaseuser WITH PASSWORD 'mypassword';

6. Accorder à mydatabaseuser tous les privilèges sur la base de données :

GRANT ALL PRIVILEGES ON DATABASE mydatabase TO mydatabaseuser;

7. Quitter le shell PostgreSQL :

\q

8. Configurez Django pour utiliser PostgreSQL : Ouvrez votre fichier settings.py et localisez la section DATABASES. Modifiez-la pour PostgreSQL comme suit :

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',  # Use '127.0.0.1' if 'localhost' doesn't work
        'PORT': '5432',       # Default PostgreSQL port
    }
}

Les valeurs PASSWORD et USER doivent correspondre à celles que vous avez définies à l’étape 5.

9. Appliquer les migrations : Maintenant que votre base de données est configurée, vous devez appliquer les migrations de votre projet pour configurer les tables nécessaires dans PostgreSQL :

python manage.py migrate

Cette commande créera les tables nécessaires dans votre base de données PostgreSQL.

10. Tester la connexion : Enfin, exécutez le serveur de développement de Django à l’aide de la commande runserver, afin de vérifier que l’intégration de PostgreSQL est réussie :

python manage.py runserver

Ouvrez http://127.0.0.1:8000/ dans votre navigateur. Si la page d’accueil de Django s’affiche sans erreur, votre connexion à la base de données fonctionne correctement.

Avec votre base de données PostgreSQL entièrement intégrée, Django est maintenant prêt à gérer des ensembles de données plus importants et plus complexes, ce qui rend votre projet évolutif et prêt pour la production.

Construire des vues et des templates

Une fois la base de données et les modèles mis en place pour gérer les données de votre application, l’étape suivante consiste à afficher ces informations aux utilisateurs et à créer des interfaces interactives. 

C’est là qu’interviennent les vues et les templates, qui vous permettent de définir la logique et la structure des pages web avec lesquelles les utilisateurs interagiront.

Comprendre les vues

Dans Django, les vues sont un composant essentiel qui définit la logique derrière ce qu’un utilisateur voit lorsqu’il interagit avec votre application. 

En termes simples, une vue prend une requête web, la traite et renvoie une réponse, généralement sous la forme d’une page HTML rendue. Les vues font le lien entre votre base de données et l’interface utilisateur grâce à l’utilisation de modèles et de gabarits.

Il existe deux types principaux de vues dans Django : Les vues basées sur les fonctions (FBV) et les vues basées sur les classes (CBV). Ces deux types de vues ont le même objectif, mais offrent différentes manières d’organiser le code.

Vues basées sur les fonctions (FBV)

Les vues basées sur des fonctions sont des fonctions Python simples qui acceptent un objet de requête et renvoient une réponse. Elles sont souvent utilisées pour des cas d’utilisation plus simples ou lorsque vous avez besoin de plus de contrôle sur le flux de la logique.

Voici un exemple d’un simple FBV qui rend un modèle HTML :

from django.shortcuts import render

# Vue basée sur des fonctions
def homepage(request):
    return render(request, 'homepage.html')

Dans cet exemple :

• request : L’objet de la requête HTTP envoyé par le navigateur de l’utilisateur.
• render : Combine le modèle homepage.html avec les données contextuelles fournies et renvoie une réponse HTTP.

Les FBV sont faciles à comprendre et à mettre en œuvre, mais lorsque les vues deviennent plus complexes, par exemple lorsqu’elles impliquent des formulaires ou l’authentification, elles peuvent devenir plus difficiles à maintenir.

Vues par classe (CBV)

Les vues basées sur les classes, quant à elles, vous permettent de structurer les vues plus efficacement en utilisant les principes de la programmation orientée objet. Les CBV sont plus flexibles et réutilisables puisqu’elles sont basées sur les classes Python. 

Django fournit des vues génériques intégrées, comme ListView et DetailView, qui gèrent les cas d’utilisation courants. Ces vues vous permettent de vous concentrer sur leur personnalisation plutôt que sur la réécriture d’une logique répétitive.

Voici un exemple d’un CBV qui remplit la même fonction que le FBV précédent :

from django.views.generic import TemplateView

# Vue basée sur une classe
class HomePageView(TemplateView):
    template_name = 'homepage.html'

Dans cet exemple :

• TemplateView : Une vue générique intégrée qui rend un modèle.
• template_name : Spécifie le fichier modèle à rendre, comme dans l’exemple FBV.

Pour utiliser cette CBV dans la configuration de l’URL, vous devez inclure la méthode .as_view() lorsque vous l’ajoutez à urls.py :

from django.urls import path
from .views import HomePageView

urlpatterns = [
    path('', HomePageView.as_view(), name='home'),
]

Quand utiliser les FBV ou les CBV ?

• Utilisez les FBV lorsque vous avez besoin de simplicité et d’un contrôle total sur la logique de votre vue. Ils sont souvent plus intuitifs pour les petites vues ou les logiques personnalisées qui ne correspondent pas aux modèles de vues prédéfinis de Django.
• Utilisez les CBV lorsque vous souhaitez suivre les principes DRY (Don’t Repeat Yourself) et réutiliser la logique existante. Les CBV sont idéales lorsque vos vues deviennent de plus en plus complexes, par exemple lorsque vous gérez des formulaires, des données paginées ou des opérations CRUD standard.

Les FBV et les CBV font tous deux partie intégrante de Django, et le choix entre les deux dépend des exigences de votre projet et de vos préférences personnelles.

Travailler avec des templates

Le système de templates de Django est conçu pour séparer la présentation des données de la logique sous-jacente. Les templates sont essentiellement des fichiers HTML qui contiennent un contenu dynamique, vous permettant d’afficher des données passées depuis vos vues. Le langage de template de Django (DTL) fournit des placeholders et de la logique, comme des boucles et des conditionnelles, pour insérer des données dynamiques dans le HTML.

Les templates jouent un rôle crucial dans la définition de l’aspect et de la convivialité de vos pages web, tout en maintenant une séparation nette entre la logique, qui est gérée par les vues, et l’interface utilisateur.

Création d’un template

Pour créer un template dans Django, vous devez créer un fichier HTML dans un répertoire templates. La structure du répertoire peut ressembler à ceci :

myproject/
│
├── myapp/
│   ├── templates/
│   │   └── myapp/
│   │       └── homepage.html
│   └── views.py
│
└── manage.py

Dans cette structure, Django recherche automatiquement les templates dans le répertoire templates de votre application. Vous pouvez également organiser les templates dans des dossiers spécifiques à l’application (comme myapp/homepage.html), en veillant à ce que chaque application ait ses propres templates.

Voici un exemple de template simple (homepage.html) :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Home</title>
</head>
<body>
    <h1>Welcome to {{ site_name }}</h1>
    <p>{{ message }}</p>
</body>
</html>

Dans ce template, {{ site_name }} et {{ message }} sont des espaces réservés qui seront remplis avec des données dynamiques transmises par la vue.

Rendu d’un template dans une vue

Pour effectuer le rendu d’un template, vous devez le passer à la vue à l’aide de la fonction render() de Django. Voici un exemple de rendu du template homepage.html avec quelques données contextuelles dans une vue basée sur une fonction (FBV) :

from django.shortcuts import render

def homepage(request):
    context = {
        'site_name': 'My Django Website',
        'message': 'This is the homepage content!'
    }
    return render(request, 'myapp/homepage.html', context)

Dans cet exemple :

• render() : Combine le template (homepage.html) avec les données contextuelles.
• context : Un dictionnaire contenant les données (site_name et message) à insérer dans le template.

Lorsqu’un utilisateur visite cette page, les espaces réservés {{ site_name }} et {{ message }} du template seront remplacés respectivement par “My Django Website” et “This is the homepage content!”.

Balises et filtres de templates

Les templates Django prennent également en charge les balises de template et les filtres, qui vous permettent d’ajouter du contenu dynamique et de la logique dans vos fichiers HTML.

• Balises de templates : Effectuer des opérations logiques à l’intérieur des templates, telles que des boucles et des conditions. Par exemple, une condition “if” :

{% if user.is_authenticated %}
    <p>Welcome back, {{ user.username }}!</p>
{% else %}
    <p>Hello, Guest!</p>
{% endif %}

• Filtres de templates : Modifier les variables à des fins d’affichage. Par exemple, formater des dates à l’aide d’un filtre :

<p>Published on {{ article.published_date|date:"F j, Y" }}</p>

Extension des templates

Django prend en charge l’héritage de templates, ce qui permet de créer des templates de base que d’autres templates peuvent étendre. Ceci est particulièrement utile pour maintenir une mise en page cohérente sur plusieurs pages, comme un en-tête et un pied de page communs.

1. Créer un template de base (base.html) :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}My Site{% endblock %}</title>
</head>
<body>
    <header>
        <h1>Site Header</h1>
    </header>

    <main>
        {% block content %}
        <!-- Page-specific content goes here -->
        {% endblock %}
    </main>

    <footer>
        <p>Footer Content</p>
    </footer>
</body>
</html>

2. Étendre le template de base dans un template enfant (homepage.html) :

{% extends 'base.html' %}

{% block title %}Home Page{% endblock %}

{% block content %}
    <h2>Welcome to the homepage!</h2>
    <p>This is the homepage content.</p>
{% endblock %}

En étendant le template de base, vous pouvez réutiliser l’en-tête et le pied de page sur différentes pages, en conservant une mise en page cohérente et en évitant les répétitions.

Utilisation de fichiers statiques dans les templates

Les templates vous permettent également de faire référence à des fichiers statiques (tels que CSS, JavaScript ou des images) à l’aide de la balise de template {% static %}. Par exemple, pour inclure un fichier CSS :

<link rel="stylesheet" type="text/css" href="{% static 'css/style.css' %}">

Assurez-vous d’avoir configuré correctement vos répertoires de fichiers statiques dans settings.py :

STATIC_URL = '/static/'

En utilisant efficacement le système de templates de Django, vous pouvez créer des pages web dynamiques, basées sur des données, et maintenir une séparation nette entre la logique et la présentation.

Travailler avec des modèles d’URL

Le distributeur d’URL de Django s’appuie sur des expressions régulières ou des convertisseurs de chemin pour faire correspondre les demandes d’URL entrantes avec des vues spécifiques. Ces motifs d’URL sont définis dans urls.py, et Django utilise cette configuration pour déterminer quelle vue doit traiter une requête particulière.

Chaque projet Django possède généralement deux niveaux de configuration d’URL :

1. URL au niveau du projet : Défini dans le fichier racine urls.py (qui se trouve dans le répertoire principal du projet), ce fichier contient la structure globale du routage des URL du projet.
2. URLs au niveau de l’application : Chaque application de votre projet peut avoir son propre fichier urls.py, ce qui permet une gestion modulaire des URL. Ces URLs au niveau de l’application sont ensuite liées aux URLs au niveau du projet.

Configuration de base de l’URL

Voyons comment un projet simple peut mettre en place des modèles d’URL :

1. URLs au niveau du projet (myproject→urls.py)

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),  # Site d'admin
    path('', include('myapp.urls')),  # Inclure les URLs au niveau de l'application pour "myapp"
]

• path() : Fonction de Django permettant de définir des modèles d’URL.
• admin.site.urls : Gère toutes les requêtes liées à l’administration.
• include() : Utilisée pour inclure les URL au niveau de l’application (à partir de myapp.urls) dans la configuration du projet principal.

2. URLs au niveau de l’application (myproject→myapp→urls.py)

from django.urls import path
from . import views

urlpatterns = [
    path('', views.homepage, name='home'),  # Associe l'URL racine à la vue homepage
    path('about/', views.about, name='about'),  # Associe "/about/" à la vue about
]

• L’URL racine (représentée par ‘ ‘) est associée à la vue homepage.
• L’URL /about/ est associée à la vue about.

Routage d’URL avec des vues basées sur des fonctions (FBV)

Voici à quoi pourraient ressembler les vues correspondantes dans views.py pour la configuration d’URL ci-dessus :

from django.shortcuts import render

def homepage(request):
    return render(request, 'homepage.html')

def about(request):
    return render(request, 'about.html')

Cette configuration lie la page d’accueil “homepage” et l’URL “about” à leurs vues respectives, ce qui garantit que lorsqu’un utilisateur visite http://example.com/ ou http://example.com/about/, le template correct est affiché.

Routage d’URL avec des vues basées sur des classes (CBV)

Vous pouvez également faire correspondre des URL à des vues basées sur des classes (CBV), qui sont gérées de manière légèrement différente. Voici un exemple de mappage d’une URL CBV :

from django.urls import path
from .views import HomePageView, AboutPageView

urlpatterns = [
    path('', HomePageView.as_view(), name='home'),
    path('about/', AboutPageView.as_view(), name='about'),
]

Et les vues basées sur les classes correspondantes dans views.py :

from django.views.generic import TemplateView

class HomePageView(TemplateView):
    template_name = 'homepage.html'

class AboutPageView(TemplateView):
    template_name = 'about.html'

Dans ce cas, la méthode .as_view() est utilisée pour lier les vues basées sur les classes aux modèles d’URL.

Paramètres d’URL et routage dynamique
Django vous permet également de capturer des paramètres d’URL et de les passer aux vues, ce qui est utile pour le mappage dynamique d’URL pour des choses comme des articles de blog ou des pages de produits.

Voici un exemple où l’URL capture un paramètre entier :

from django.urls import path
from . import views

urlpatterns = [
    path('article/<int:id>/', views.article_detail, name='article_detail'),
]

Dans ce cas, <int:id> capture un nombre entier à partir de l’URL et le transmet à la vue article_detail en tant qu’argument :

def article_detail(request, id):
    # Fetch the article using the provided ID
    article = get_object_or_404(Article, pk=id)
    return render(request, 'article_detail.html', {'article': article})

Si un utilisateur visite http://example.com/article/5/, Django transmettra 5 comme argument id à la vue article_detail, ce qui vous permettra de récupérer et d’afficher l’article en question.

Modèles d’URL nommés

Il est conseillé de nommer vos modèles d’URL. Cela vous permet de référencer les URL par leur nom dans vos templates et vos vues plutôt que de les coder en dur.

Dans l’exemple urls.py ci-dessus, chaque URL a un argument name :

path('about/', views.about, name='about')

Dans vos templates, vous pouvez alors utiliser la balise template {% url %} pour faire référence à ces URL nommées :

<a href="{% url 'about' %}">About Us</a>

Ainsi, si l’URL about change un jour, il suffit de la mettre à jour dans la configuration de l’URL plutôt que dans chaque template.

En configurant et en utilisant les modèles d’URL de Django, vous pouvez faire correspondre efficacement différentes URL à leurs vues respectives. Cette flexibilité vous permet de gérer à la fois des pages statiques simples et un contenu dynamique plus complexe, adapté à la saisie de l’utilisateur.

Gestion des fichiers statiques dans Django

Nous avons mis en place des vues, des templates et des modèles d’URL. Maintenant, pour construire une application Django pleinement fonctionnelle, nous devons commencer à manipuler des fichiers statiques, tels que CSS, JavaScript et des images. 

Heureusement, Django offre un moyen simple et efficace de gérer les fichiers statiques, en s’assurant qu’ils sont correctement servis et organisés pendant le développement et le déploiement.

Mise en place de fichiers statiques dans Django

Pour gérer les fichiers statiques dans Django, vous devez configurer votre projet pour qu’il sache où les rechercher et les servir.

Définir l’URL statique et le répertoire dans settings.py :

# settings.py
STATIC_URL = '/static/'
STATICFILES_DIRS = [
    BASE_DIR / "static",  # Optional: Add this if you want to store static files in a 'static' folder within your project
]

• STATIC_URL : Définit le préfixe de l’URL que Django utilisera pour servir les fichiers statiques.
• STATICFILES_DIRS : Spécifie des répertoires supplémentaires dans lesquels Django cherchera des fichiers statiques pendant le développement.

Par défaut, Django recherche également les fichiers statiques dans le répertoire static de chaque application. Par exemple, si vous avez une application nommée myapp, vous pouvez créer une structure de dossiers comme celle-ci :

myapp/
│
├── static/
│   └── myapp/
│       └── style.css
└── views.py

Django reconnaîtra et servira automatiquement ces fichiers pendant le développement.

Utilisation de fichiers statiques dans les templates

Pour utiliser des fichiers statiques dans vos templates, vous devez d’abord charger la balise de template {% static %} de Django. Ensuite, vous pouvez référencer vos fichiers statiques par leurs chemins relatifs :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Home Page</title>
    {% load static %}
    <link rel="stylesheet" href="{% static 'myapp/style.css' %}">
</head>
<body>
    <h1>Welcome to My Django App</h1>
    <img src="{% static 'myapp/images/logo.png' %}" alt="Logo">
</body>
</html>

Dans cet exemple :

• {% load static %} : Charge la balise de template des fichiers statiques.
• {% static ‘myapp/style.css’ %} : Résout le chemin vers le fichier style.css dans le répertoire static/myapp.
• {% static ‘myapp/images/logo.png’ %} : Résout le chemin d’accès à un fichier image.

Collecte des fichiers statiques pour le déploiement

Pendant le développement, Django sert automatiquement les fichiers statiques lorsque DEBUG = True. Cependant, en production, Django ne sert pas les fichiers statiques directement. Au lieu de cela, vous devez collecter tous les fichiers statiques à partir de différents emplacements et les stocker dans un seul répertoire.

Pour ce faire, Django fournit la commande de gestion collectstatic :

1. Assurez-vous que django.contrib.staticfiles est inclus dans le paramètre INSTALLED_APPS :

INSTALLED_APPS = [
    # Other installed apps
    'django.contrib.staticfiles',
]

2. Configurez le répertoire racine statique dans settings.py :

STATIC_ROOT = BASE_DIR / 'staticfiles'

STATIC_ROOT : Définit le répertoire dans lequel Django collectera les fichiers statiques pour le déploiement.

3. Exécutez la commande collectstatic :

python manage.py collectstatic

Cette commande collecte tous les fichiers statiques du répertoire static de chaque application et de tout autre emplacement spécifié dans STATICFILES_DIRS, puis les stocke dans le répertoire STATIC_ROOT.

Servir des fichiers statiques en production

Dans un environnement de production, vous utilisez généralement un serveur web (comme Nginx ou Apache) pour servir les fichiers statiques. Django recommande de configurer votre serveur web pour qu’il serve efficacement le contenu statique, réduisant ainsi la charge sur votre application Django.

Voici comment vous pourriez configurer le service de fichiers statiques dans une installation Nginx :

1. Configuration de Nginx pour les fichiers statiques :

server {
    listen 80;
    server_name yourdomain.com;

    location /static/ {
        alias /path/to/your/project/staticfiles/;  # The path to STATIC_ROOT
    }

    location / {
        proxy_pass http://127.0.0.1:8000;  # Pass requests to Django app
    }
}

Dans cette configuration, Nginx sert les fichiers statiques directement depuis le répertoire /static/, tout en transmettant toutes les autres requêtes à l’application Django.

En gérant correctement les fichiers statiques dans Django, vous vous assurez que votre application n’est pas seulement belle avec des styles et des images, mais qu’elle fonctionne aussi efficacement lorsqu’elle est déployée.

Mise en œuvre de l’authentification et de l’autorisation des utilisateurs

Au fur et à mesure que nous créons des applications web plus dynamiques et plus complexes, la nécessité de gérer les utilisateurs, de sécuriser le contenu et de contrôler l’accès devient critique. 

Django fournit un système d’authentification intégré qui facilite la gestion de la connexion, de la déconnexion, de l’enregistrement et des autorisations des utilisateurs. Cela permet à un développeur Django de gérer efficacement l’authentification et l’autorisation des utilisateurs.

Authentification de l’utilisateur

Le système d’authentification intégré de Django simplifie la gestion des utilisateurs avec des fonctionnalités telles que la connexion, la déconnexion, la gestion des mots de passe et l’enregistrement. Par défaut, Django offre une fonctionnalité de modèle d’utilisateur et des vues d’authentification qui gèrent la plupart de ces tâches.

Configuration de la connexion et de la déconnexion des utilisateurs

Pour mettre en œuvre les fonctionnalités de connexion et de déconnexion, vous pouvez utiliser les vues intégrées de Django qui se trouvent dans django.contrib.auth.views. Ces vues gèrent le processus d’authentification et simplifient le code nécessaire à ces opérations.

1. Configurez les URLs de connexion et de déconnexion dans votre fichier urls.py :

from django.urls import path
from django.contrib.auth import views as auth_views

urlpatterns = [
    path('login/', auth_views.LoginView.as_view(), name='login'),
    path('logout/', auth_views.LogoutView.as_view(), name='logout'),
]

• LoginView : Gère la connexion de l’utilisateur.
• LogoutView : Déconnecte l’utilisateur et le redirige vers la page spécifiée.

2. Créez un template de formulaire de connexion : Vous pouvez créer un template de connexion simple (login.html) dans le répertoire templates de votre application :

<form method="post">
    {% csrf_token %}
    <div>
        <label for="username">Username:</label>
        <input type="text" id="username" name="username" required>
    </div>
    <div>
        <label for="password">Password:</label>
        <input type="password" id="password" name="password" required>
    </div>
    <button type="submit">Login</button>
</form>

Ce template gère l’authentification de l’utilisateur lorsqu’un nom d’utilisateur et un mot de passe valides sont soumis.

3. Créer la déconnexion : Vous n’avez pas besoin d’un template séparé pour vous déconnecter, car la LogoutView de Django s’en charge. Vous pouvez simplement ajouter un lien de déconnexion dans votre template :

<a href="{% url 'logout' %}">Logout</a>

Création d’une vue d’enregistrement des utilisateurs

Django ne fournit pas de vue d’enregistrement intégrée par défaut, mais vous pouvez en créer une en utilisant UserCreationForm de Django :

1. Créer une vue d’enregistrement dans views.py :

from django.shortcuts import render, redirect
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth import login

def register(request):
    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save()
            login(request, user)  # Automatically log the user in after registration
            return redirect('home')  # Redirect to home page after successful registration
    else:
        form = UserCreationForm()
    return render(request, 'register.html', {'form': form})

2. Configurez l’URL pour l’enregistrement dans urls.py :

urlpatterns = [
    path('register/', views.register, name='register'),
]

3. Créez le template de formulaire d’inscription (register.html) :

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Register</button>
</form>

Cette vue d’enregistrement permet aux utilisateurs de créer un compte à l’aide d’un simple formulaire. Une fois l’inscription réussie, les utilisateurs sont automatiquement connectés.

Autorisation de l’utilisateur

L’autorisation de l’utilisateur permet de contrôler l’accès à certaines vues et actions en fonction des permissions ou des rôles de l’utilisateur. Le système de permissions de Django facilite la gestion des utilisateurs qui peuvent accéder à des parties spécifiques de votre application.

Restreindre l’accès à l’aide d’une connexion obligatoire

Pour restreindre l’accès à certaines vues, vous pouvez utiliser le décorateur @login_required de Django, qui garantit que seuls les utilisateurs authentifiés peuvent accéder à une vue :

1. Utilisation de @login_required dans les vues :

from django.contrib.auth.decorators import login_required

@login_required
def dashboard(request):
    return render(request, 'dashboard.html')

Cela garantit que si un utilisateur n’est pas connecté, il sera redirigé vers la page de connexion.

2. Application de @login_required dans les URL : Vous pouvez également appliquer @login_required directement dans votre fichier urls.py en utilisant le LoginRequiredMixin de Django pour les vues basées sur des classes :

from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import TemplateView

class DashboardView(LoginRequiredMixin, TemplateView):
    template_name = 'dashboard.html'

Gestion des autorisations des utilisateurs

Django vous permet d’attribuer différentes permissions aux utilisateurs et aux groupes, qui peuvent être utilisées pour contrôler l’accès à des vues ou à des actions spécifiques. Les permissions peuvent être ajoutées aux modèles d’utilisateurs et vérifiées dans vos vues.

1. Attribution de permissions : Lors de la création d’utilisateurs ou de groupes, vous pouvez attribuer des autorisations. Par exemple, un administrateur peut avoir le droit d’ajouter ou de supprimer du contenu, tandis que les utilisateurs ordinaires ne peuvent que consulter le contenu.

2. Vérification des autorisations dans les vues : Vous pouvez vérifier si un utilisateur dispose des autorisations requises avant d’autoriser l’accès à certaines vues à l’aide du décorateur @permission_required :

from django.contrib.auth.decorators import permission_required

@permission_required('app.add_article')
def add_article(request):
    # View code for adding an article

Seuls les utilisateurs disposant de l’autorisation add_article pourront accéder à cette vue.

Restreindre l’accès en fonction des rôles des utilisateurs

La fonction de groupes de Django vous permet de créer des rôles (tels que “editor ou “viewer”) et d’assigner des utilisateurs à ces groupes. Vous pouvez ensuite vérifier l’appartenance d’un utilisateur à un groupe pour en contrôler l’accès.

1. Affectation d’utilisateurs à des groupes : Les groupes peuvent être créés dans le tableau d’administration de Django ou par programme :

from django.contrib.auth.models import Group, User

group = Group.objects.get(name='editors')
user = User.objects.get(username='john')
user.groups.add(group)  # Affecte l'utilisateur au groupe 'editors'

2. Vérification de l’appartenance à un groupe dans les vues : Vous pouvez restreindre les vues en fonction de l’appartenance à un groupe :

from django.contrib.auth.decorators import user_passes_test

def is_editor(user):
    return user.groups.filter(name='editors').exists()

@user_passes_test(is_editor)
def editor_dashboard(request):
    return render(request, 'editor_dashboard.html')

Dans cet exemple, seuls les utilisateurs appartenant au groupe “editors” peuvent accéder à la vue editor_dashboard.

En tirant parti des systèmes d’authentification et d’autorisation intégrés à Django, vous pouvez gérer en toute sécurité la connexion, l’enregistrement et les autorisations des utilisateurs, en veillant à ce que les contenus sensibles soient protégés et que l’accès soit correctement contrôlé. 

Gestion des formulaires dans Django

Après la mise en œuvre de l’authentification et de l’autorisation de l’utilisateur, la prochaine fonctionnalité cruciale de toute page web est le traitement des entrées de l’utilisateur par le biais de formulaires. Django fournit un système puissant et flexible pour créer, traiter et valider les formulaires.

Le système de gestion des formulaires de Django est construit sur des classes Python qui représentent les formulaires comme des objets. Ces formulaires peuvent être rendus dans des templates, validés et traités en utilisant seulement quelques lignes de code. Les formulaires peuvent être créés manuellement à l’aide de la classe Form de Django ou générés automatiquement à partir de modèles à l’aide de ModelForm.

Création de formulaires à l’aide de la classe Form de Django

Pour créer un formulaire dans Django, vous commencez par définir une classe de formulaire dans votre fichier forms.py. Cette classe définira les champs et les règles de validation.

1. Définition d’un formulaire : Voici un exemple de formulaire de contact simple :

# forms.py
from django import forms

class ContactForm(forms.Form):
    name = forms.CharField(max_length=100, label='Votre Nom')
    email = forms.EmailField(label='Votre Email')
    message = forms.CharField(widget=forms.Textarea, label='Votre Message')

Ce formulaire comprend trois champs : le nom, l’adresse électronique et le message. Chaque champ est représenté par une classe de champ de formulaire, telle que CharField pour le texte court, EmailField pour les courriels et Textarea pour les entrées de texte plus longues.

2. Afficher le formulaire dans un template : Pour afficher le formulaire sur une page web, vous pouvez le rendre dans un template. Vous pouvez rendre le formulaire manuellement ou utiliser les aides au rendu de formulaire intégrées à Django :

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Envoyer le Message</button>
</form>

• {% csrf_token %} : Ajoute un jeton CSRF pour se protéger contre les attaques de type “cross-site request forgery”.
• {{ form.as_p }} : Rend les champs du formulaire avec chaque champ enveloppé dans une balise <p> pour faciliter la mise en forme.

3. Traitement des soumissions de formulaires : Dans la vue qui gère la soumission du formulaire, vous devrez valider les données du formulaire et les traiter si le formulaire est valide :

# views.py
from django.shortcuts import render
from .forms import ContactForm

def contact_view(request):
    if request.method == 'POST':
        form = ContactForm(request.POST)
        if form.is_valid():
            # Traiter les données, par exemple envoyer un e-mail ou les enregistrer dans la base de données
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            message = form.cleaned_data['message']
            # Rediriger vers une page de succès ou afficher un message de succès
            return render(request, 'thanks.html')
    else:
        form = ContactForm()
    return render(request, 'contact.html', {'form': form})

Dans cette vue :

• Si le formulaire est soumis via une requête POST, les données du formulaire sont validées.
• form.is_valid() : Vérifie si les données du formulaire sont validées.
• form.cleaned_data : Contient les données validées du formulaire qui peuvent maintenant être traitées (par exemple, envoi d’un courrier électronique).
• Si la requête n’est pas un POST, un formulaire vide est affiché pour que l’utilisateur puisse le remplir.

Validation des formulaires et traitement des erreurs

Les formulaires de Django sont dotés d’une validation intégrée qui garantit que les données soumises sont correctes et sécurisées. Les champs tels que EmailField valident automatiquement que l’entrée est une adresse électronique valide. Vous pouvez également créer une logique de validation personnalisée pour appliquer des règles spécifiques.

Validation intégrée

Django effectue automatiquement certains contrôles de validation pour vous :

• Champs obligatoires : Par défaut, tous les champs sont obligatoires, sauf si vous spécifiez required=False.
• Types de champs : Les champs tels que EmailField, IntegerField et URLField valident automatiquement le type de données saisies.

Validation personnalisée

Vous pouvez également définir une logique de validation personnalisée en remplaçant la méthode clean() ou en créant des validateurs de champs personnalisés.

1. Ajout d’un validateur personnalisé pour le champ name :

# forms.py
from django import forms
from django.core.exceptions import ValidationError

class ContactForm(forms.Form):
    name = forms.CharField(max_length=100, label='Your Name')
    email = forms.EmailField(label='Your Email')
    message = forms.CharField(widget=forms.Textarea, label='Your Message')

    def clean_name(self):
        name = self.cleaned_data.get('name')
        if "spam" in name.lower():
            raise ValidationError("Invalid name: 'spam' is not allowed.")
        return name

Dans cet exemple, si le nom contient le mot spam, Django lèvera une erreur de validation.

2. Gestion des erreurs de formulaire dans les templates : Vous pouvez personnaliser l’affichage des erreurs de formulaire dans les templates. Django ajoute automatiquement des messages d’erreur à chaque champ, que vous pouvez afficher comme suit :

<form method="post">
    {% csrf_token %}
    <div>
        {{ form.name.label_tag }} {{ form.name }}
        {% if form.name.errors %}
            <div class="error">{{ form.name.errors }}</div>
        {% endif %}
    </div>
    <div>
        {{ form.email.label_tag }} {{ form.email }}
        {% if form.email.errors %}
            <div class="error">{{ form.email.errors }}</div>
        {% endif %}
    </div>
    <div>
        {{ form.message.label_tag }} {{ form.message }}
        {% if form.message.errors %}
            <div class="error">{{ form.message.errors }}</div>
        {% endif %}
    </div>
    <button type="submit">Send Message</button>
</form>

Les utilisateurs peuvent ainsi voir les messages d’erreur pertinents à côté des champs qu’ils doivent corriger.

Création de formulaires à partir de modèles à l’aide de ModelForm

Dans de nombreux cas, les formulaires sont liés à des modèles. Django facilite la création de formulaires directement à partir de modèles en utilisant ModelForm. Cela permet de gagner du temps en générant automatiquement des champs de formulaire basés sur les champs du modèle.

1. Création d’un ModelForm : Supposons que vous ayez un modèle Post dans votre fichier models.py :

# models.py
from django.db import models

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

Vous pouvez créer un formulaire pour ce modèle comme suit :

# forms.py
from django import forms
from .models import Post

class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ['title', 'content']

2. Utilisation du ModelForm dans une vue :

# views.py
from django.shortcuts import render
from .forms import PostForm

def create_post(request):
    if request.method == 'POST':
        form = PostForm(request.POST)
        if form.is_valid():
            form.save()  # Enregistre les données du formulaire dans la base de données
            return redirect('post_list')  # Redirige vers une liste de posts
    else:
        form = PostForm()
    return render(request, 'create_post.html', {'form': form})

En utilisant ModelForm, Django génère automatiquement des champs de formulaire basés sur les champs du modèle Post et gère l’enregistrement du formulaire dans la base de données.

Déployer une application Django

Une fois que votre application est entièrement développée et testée sur votre machine locale, l’étape finale consiste à la déployer sur un serveur réel afin que les utilisateurs puissent y accéder. Le déploiement d’un projet Django nécessite un examen attentif des meilleures pratiques pour garantir la sécurité, l’évolutivité et les performances. Dans cette section, nous aborderons les étapes essentielles du déploiement de votre application sur un VPS que tout développeur Django devrait connaître.

Meilleures pratiques pour le déploiement d’un projet Django

Avant de plonger dans les étapes techniques, il est important de suivre quelques bonnes pratiques lors de la préparation de votre projet Django pour le déploiement :

1. Utilisez des variables d’environnement : Stockez les informations sensibles telles que les clés secrètes, les identifiants de base de données et les clés d’API dans des variables d’environnement au lieu de les coder en dur dans vos paramètres.
2. Désactiver le mode débogage : Assurez-vous de définir DEBUG = False dans votre fichier settings.py avant de déployer votre projet en production. Le mode débogage peut exposer des informations sensibles aux attaquants.
3. Définissez les hôtes autorisés : Dans votre fichier settings.py, définissez le paramètre ALLOWED_HOSTS pour inclure le(s) nom(s) de domaine où votre application sera hébergée. Par exemple :

ALLOWED_HOSTS = ['votredomaine.com', 'www.votredomaine.com']

4. Sécurisez l’application : Envisagez d’utiliser HTTPS pour sécuriser les communications entre le serveur et les utilisateurs, et utilisez les paramètres de sécurité intégrés de Django tels que SECURE_SSL_REDIRECT, CSRF_COOKIE_SECURE et SESSION_COOKIE_SECURE.
5. Traitement des fichiers statiques : Assurez-vous que les fichiers statiques tels que CSS et JavaScript sont correctement collectés et servis. Django fournit la commande collectstatic pour gérer cela.
6. Configuration de la base de données : Assurez-vous que la base de données est correctement configurée et évitez d’utiliser SQLite pour la production. Utilisez une base de données plus robuste comme PostgreSQL ou MySQL.

Déployer Django sur un VPS

Maintenant que vous avez appris les meilleures pratiques pour préparer un projet Django, il est temps de le déployer sur un serveur privé virtuel (VPS). Dans cette section, nous vous guiderons à travers les étapes pour mettre en place votre serveur, configurer les services nécessaires et rendre votre application Django vivante et accessible aux utilisateurs.

Création d’un fichier requirements.txt en Python

Un fichier requirements.txt liste toutes les dépendances Python dont votre projet Django a besoin pour fonctionner. Ce fichier vous permet d’installer tous les paquets nécessaires en une seule commande.

Assurez-vous d’être dans le répertoire principal de votre projet, où vous avez le fichier manage.py, et assurez-vous que votre environnement virtuel est actif.

Ensuite, générez le fichier requirements.txt avec la commande suivante :

pip3 freeze > requirements.txt

Cette commande créera un fichier requirements.txt dans votre répertoire actuel avec tous les paquets installés et leurs versions que vous avez dans votre environnement virtuel actuel.

Ensuite, ouvrez requirements.txt et assurez-vous que toutes les dépendances nécessaires à l’exécution de votre projet y figurent.

Téléchargement du projet vers un dépôt distant (GitHub)

Avant de déployer votre projet sur un VPS, il est conseillé de télécharger votre code sur un dépôt distant, tel que GitHub, afin de contrôler les versions et de faciliter la collaboration. De plus, cela simplifie le processus de déploiement lui-même.

1. Installez Git CLI et initialisez un dépôt local. Assurez-vous d’être dans le dossier principal de votre projet, où vous avez le fichier manage.py, et exécutez ces commandes :

sudo apt install git-all

git init

2. Créez un fichier .gitignore et ajoutez-y du contenu. Le fichier .gitignore indique à Git les fichiers à ignorer lors de l’envoi de code vers votre dépôt distant. Cela permet d’ignorer les fichiers contenant des informations sensibles ainsi que les fichiers locaux non pertinents tels que les journaux. Voici un exemple de fichier .gitignore pour un projet Django :

venv/
__pycache__/
db.sqlite3
*.pyc
*.log
media/

3. Assainissez les informations sensibles dans votre fichier settings.py. Assurez-vous d’assainir les informations sensibles dans votre fichier settings.py, telles que les mots de passe, les noms d’utilisateur, etc. Une fois le projet déployé, vous pouvez ajouter les informations d’identification à votre VPS.
4. Ajoutez et engagez vos fichiers.

git add .

git commit -m "Initial commit"

5. S’inscrire sur GitHub et créer un dépôt distant. Allez sur GitHub et inscrivez-vous ou connectez-vous à votre compte. Créez un nouveau dépôt, définissez-le comme privé et copiez son lien distant.
6. Configurez l’origine et la branche Git distante.

git remote add origin https://github.com/url-to-repository-you-created

git branch -M main

7. Vérifiez l’état de votre dépôt local et transférez des fichiers. Avant de transférer des fichiers, vous devez exécuter la commande status et vous assurer qu’aucun fichier que vous ne souhaitez pas transférer n’a été ajouté :

git status

Confirmez que seuls les fichiers que vous souhaitez télécharger sont ajoutés et transférez-les dans le référentiel distant :

git push -u origin main 

8. Accédez à votre dépôt distant sur GitHub et confirmez les fichiers téléchargés.

Préparez votre VPS et récupérez le code du projet

Ensuite, vous devez préparer votre VPS pour le déploiement et y télécharger votre code :

1. SSH dans votre VPS

ssh root@votre_ip_vps

2. Installer Nginx et Gunicorn

sudo apt install nginx

sudo pip3 install gunicorn

Nous utiliserons Nginx comme serveur web et Gunicorn comme serveur d’application.

3. Récupérer le code de GitHub

git clone https://github.com/your-repository/project-name.git

cd project-name

4. Démarrer un environnement virtuel et installer les dépendances

python3 -m venv env_namesource env_name/bin/activate

pip3 install -r requirements.txt

5. Remplir les données assainies dans votre fichier settings.py

6. Exécuter les migrations et collecter les fichiers statiques

python manage.py migrate

python manage.py collectstatic

7. Configurer Gunicorn comme serveur d’application. Créez un fichier de service :

sudo nano /etc/systemd/system/gunicorn.service

Ajoutez la configuration suivante :

[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=your-username
Group=www-data
WorkingDirectory=/your/project/directory
ExecStart=/your/project/directory/env_name/bin/gunicorn --access-logfile - --workers 3 --bind unix:/your/project/directory.sock myproject.wsgi:application

[Install]
WantedBy=multi-user.target

Veillez à saisir votre nom d’utilisateur factuel et le chemin du répertoire du projet au lieu de your-username et /your/project/directory.

8. Démarrer et activer Gunicorn

sudo systemctl start gunicorn

sudo systemctl enable gunicorn

9. Configurer Nginx comme serveur web. Créez un fichier de configuration :

sudo nano /etc/nginx/sites-available/myproject

Ajoutez la configuration suivante :

server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;

    location / {
        proxy_pass http://unix:/your/project/directory/project-name.sock;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /static/ {
        alias /your/project/directory/static/;
    }

    location /media/ {
        alias /your/project/directory/media/;
    }
}

Veillez à saisir le chemin de votre répertoire factuel au lieu de /your/project/directory.

10. Activer le site et redémarrer Nginx

sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled

sudo systemctl restart nginx

11. Sécuriser le serveur avec SSL. Nous allons utiliser Certbot pour appliquer un certificat SSL et rediriger le trafic de HTTP vers HTTPS :

sudo apt install certbot python3-certbot-nginxsudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

En suivant ces étapes, vous avez déployé avec succès votre application Django sur un VPS en utilisant les meilleures pratiques, en assurant à la fois la sécurité et la performance. 

Avec Nginx et Gunicorn qui s’occupent du web et de l’application, votre application est maintenant prête à gérer du trafic en direct. Visitez votre domaine – si vous avez tout configuré correctement, vous devriez maintenant voir votre application web en direct.

Conclusion

Dans ce tutoriel, nous avons couvert les étapes essentielles pour démarrer avec Django, de la mise en place de votre environnement de développement au déploiement de votre projet sur un serveur virtuel. Vous avez appris à créer un projet, à gérer des modèles et à stocker des données, à construire des vues et des templates, à travailler avec des URL, à gérer des fichiers statiques, à mettre en œuvre l’authentification des utilisateurs et à déployer votre application sur un serveur live.

Avec ces compétences de base, vous êtes maintenant équipé pour commencer à construire vos propres projets Django. Qu’il s’agisse d’un simple blog ou d’une application web plus complexe, Django vous fournit les outils nécessaires pour donner vie à vos idées. Plongez, expérimentez et voyez ce que vous pouvez créer avec ce puissant framework web.

Tutoriel Django – FAQ