Quickstarters
Comment créer un backend pour Django ?

41min
Introduction
Dans ce tutoriel, vous apprendrez comment construire un backend pour Django en utilisant la plateforme robuste et alimentée par l'IA de Back4App. 
Django est un framework web de haut niveau qui encourage le développement rapide de backend et un design propre et pragmatique. 
Nous allons créer un backend évolutif et sécurisé qui s'intègre parfaitement à votre projet Django. 
En utilisant Back4App, vous pouvez tirer parti de la gestion automatisée des bases de données, des API puissantes, du stockage de fichiers, de l'authentification des utilisateurs, de la validation des données, des capacités en temps réel et des fonctionnalités de sécurité avancées.
Vous verrez comment l'environnement de Back4App génère automatiquement l'infrastructure serveur, vous permettant de vous concentrer sur la logique métier de votre application Django. 
Cette approche réduit le temps de développement en éliminant le besoin de configurer manuellement des serveurs et des bases de données. 
À la fin de ce tutoriel, vous disposerez d'une structure robuste pour vos applications web qui peut être étendue avec des fonctionnalités plus complexes, des intégrations et une logique personnalisée.
Conditions préalables
Un compte Back4App et un nouveau projet Back4App
Commencer avec Back4App.
Si vous n'avez pas de compte, vous pouvez en créer un gratuitement. Suivez le guide ci-dessus pour préparer votre projet.
Un projet Django configuré localement
Assurez-vous d'avoir un environnement Django. Si vous partez de zéro, suivez la documentation officielle de Django. Confirmez que les INSTALLED_APPS de votre projet et la structure de base des vues et modèles sont prêtes.
Python 3.7+ installé
Vous aurez besoin d'un environnement Python moderne pour votre application Django.
Familiarité avec l’architecture de modèle vue de Django et les opérations CRUD de base
Si vous êtes nouveau sur Django ou si vous devez vous rafraîchir la mémoire, consultez la documentation de Django.﻿
Avoir ces conditions préalables en place garantira une expérience plus fluide lors de ce tutoriel.
Étape 1 – Créer un nouveau projet sur Back4App et se connecter
Pourquoi vous avez besoin d'un projet Back4App
Un nouveau projet sur Back4App est la colonne vertébrale de votre développement backend. Il vous fournit des capacités de serveur Parse, des outils de base de données et une interface d'administration puissante. 
Cette structure centrale vous permet de déléguer la gestion du serveur et de vous concentrer sur la logique métier de votre application Django.
Créer un nouveau projet
Connectez-vous à votre compte Back4App.
Cliquez sur le bouton “Nouvelle application” dans votre tableau de bord Back4App.
Nommez votre application (par exemple, “Django-Backend-Tutorial”).
﻿
Une fois créée, votre application apparaîtra dans votre tableau de bord Back4App. Ce nouveau projet est l'endroit où nous stockerons des données, gérerons les règles de sécurité et exécuterons le code côté serveur pour votre application Django.
Installation du SDK Python Parse
Pour connecter votre projet Django à Back4App, nous utiliserons le SDK Python Parse. Il vous permet de gérer les opérations de données, l'authentification des utilisateurs, les fonctionnalités en temps réel, et plus encore depuis votre code Python.
Récupérez vos clés d'application:
Dans le tableau de bord Back4App, allez dans Paramètres de l'application ou Sécurité et clés pour trouver votre ID d'application et votre clé client (ou clé REST) et l' URL du serveur Parse (par exemple, https://parseapi.back4app.com).
﻿
Installez le SDK:
Bash
pip install parse_rest
pip install parse_rest
﻿
Initialiser Parse dans votre projet Django. Par exemple, créez un nouveau fichier appelé parse_config.py dans le répertoire principal de votre application Django (le même dossier qui contient views.py ou models.py):
Python
# parse_config.py
from parse_rest.connection import register

APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
PARSE_SERVER_URL = "https://parseapi.back4app.com"

# Register your app with Parse
register(APPLICATION_ID, REST_API_KEY, master_key=None, endpoint=PARSE_SERVER_URL)
# parse_config.py
from parse_rest.connection import register

APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
PARSE_SERVER_URL = "https://parseapi.back4app.com"

# Register your app with Parse
register(APPLICATION_ID, REST_API_KEY, master_key=None, endpoint=PARSE_SERVER_URL)
﻿
Avec cette configuration, n'importe quel fichier de votre projet Django peut importer parse_config pour assurer une connexion à votre backend Back4App. Vous pouvez maintenant interroger et enregistrer des données depuis votre code Django en utilisant le SDK Python de Parse.
Étape 2 – Configuration de la base de données
1. Création d'un modèle de données
Tout comme Django utilise des modèles pour stocker des données dans une base de données relationnelle, Parse utilise des classes pour stocker des objets. Vous pouvez créer des classes dans le tableau de bord Back4App ou les définir à la volée.
Dans le tableau de bord Back4App
Naviguez vers Base de données
Cliquez sur Créer une classe
Nommez-la (par exemple, “Todo”), puis ajoutez des champs comme title (String) et isCompleted (Boolean).
Créer une nouvelle classe
﻿
2. Utiliser l'agent IA pour générer automatiquement un modèle de données
L'agent IA de Back4App peut vous aider à générer automatiquement un schéma :
Ouvrez l'agent IA dans votre tableau de bord d'application.
Décrivez votre modèle de données (par exemple, “Un schéma d'application Todo avec title, isCompleted et un pointeur utilisateur.”).
Laissez l'agent IA le construire pour vous.
﻿
Cela peut faire gagner du temps, surtout si votre application Django nécessite des relations complexes ou une validation de données avancée.
3. Lire et écrire des données en utilisant le SDK Parse
Voici un exemple de création et interrogation d'un Todo objet depuis votre projet Django :
Python
# views.py
from parse_config import *
from parse_rest.datatypes import Object

class Todo(Object):
    pass

def create_todo_item(title, is_completed=False):
    todo = Todo(title=title, isCompleted=is_completed)
    todo.save()  # This performs the CRUD operation to save data in Back4App

def get_all_todos():
    return Todo.Query.all()  # Retrieves all Todo objects from Back4App
# views.py
from parse_config import *
from parse_rest.datatypes import Object

class Todo(Object):
    pass

def create_todo_item(title, is_completed=False):
    todo = Todo(title=title, isCompleted=is_completed)
    todo.save()  # This performs the CRUD operation to save data in Back4App

def get_all_todos():
    return Todo.Query.all()  # Retrieves all Todo objects from Back4App
﻿
Vous pouvez appeler ces fonctions depuis vos vues Django ou votre shell. Cette configuration fonctionne en tandem avec la logique de votre application Django, de sorte que votre framework web reste entièrement intégré au backend Parse.
4. Lecture et écriture de données en utilisant l'API REST
Si vous préférez REST, voici comment créer un Todo objet :
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
5. Lecture et écriture de données en utilisant l'API GraphQL
Back4App fournit également une interface GraphQL. Par exemple:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Ceci est utile si vous souhaitez intégrer des requêtes GraphQL dans vos vues Django ou microservices dans le cadre d'une architecture de données moderne.
6. Travailler avec des requêtes en direct (optionnel)
Pour des mises à jour en temps réel, vous pouvez activer les requêtes en direct dans le tableau de bord Back4App. Pour le moment, le SDK Python Parse officiel peut avoir un support limité des requêtes en direct. Cependant, vous pouvez toujours vous abonner aux changements via WebSockets ou d'autres approches si nécessaire. Consultez les Docs Back4App pour les dernières mises à jour sur les requêtes en direct Python.
Étape 3 – Appliquer la sécurité avec les ACL et les CLP
1. Aperçu rapide
Utilisez les listes de contrôle d'accès (ACL) et les permissions au niveau de la classe (CLP) pour protéger vos données. Les ACL contrôlent les permissions de lecture/écriture par objet, tandis que les CLP s'appliquent à une classe entière.
﻿
2. Étape par étape
Configuration des autorisations au niveau de la classe:
Allez dans la base de données section dans Back4App.
Choisissez la classe (par exemple, Todo).
Ajustez l'accès Lecture/Écriture ou exigez une connexion.
Configuration des ACL dans le code:
Cela garantit que votre projet Django respecte les mêmes règles de sécurité granulaires définies dans Back4App.
Étape 4 – Écriture des fonctions Cloud Code
1. Pourquoi Cloud Code
Avec Cloud Code, vous exécutez la logique métier côté serveur. Par exemple, vous pouvez effectuer une validation des données, intégrer des API externes ou déclencher des événements avant d'enregistrer des données. C'est un complément puissant à vos vues et modèles Django, vous permettant de centraliser la logique avancée en un seul endroit.
2. Exemple de Fonction
Cloud Code est généralement écrit en JavaScript. Vous le déployez sur Back4App, puis vous l'appelez depuis votre application Django via le SDK Python Parse ou des requêtes REST. Une fonction simple :
JS
// main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
3. Déploiement
Utilisez le CLI Back4App ou Dashboard.
Déployez votre main.js avec des fonctions cloud.
Une fois déployées, elles deviennent accessibles à votre code Django via :
Python
from parse_config import *
import requests

def call_calculate_text_length(text):
    url = "https://parseapi.back4app.com/functions/calculateTextLength"
    headers = {
        "X-Parse-Application-Id": APPLICATION_ID,
        "X-Parse-REST-API-Key": REST_API_KEY,
        "Content-Type": "application/json"
    }
    payload = {"text": text}
    response = requests.post(url, json=payload, headers=headers)
    return response.json()
from parse_config import *
import requests

def call_calculate_text_length(text):
    url = "https://parseapi.back4app.com/functions/calculateTextLength"
    headers = {
        "X-Parse-Application-Id": APPLICATION_ID,
        "X-Parse-REST-API-Key": REST_API_KEY,
        "Content-Type": "application/json"
    }
    payload = {"text": text}
    response = requests.post(url, json=payload, headers=headers)
    return response.json()
﻿
4. NPM
Si vous avez besoin de modules Node externes dans votre Cloud Code, déclarez-les dans le package.json. Back4App les installe automatiquement lors du déploiement.
Étape 5 – Configuration de l'authentification
1. Activer ou configurer l'authentification des utilisateurs
Par défaut, Parse inclut la classe Utilisateur pour les inscriptions et les connexions. Configurez la vérification par e-mail, les réinitialisations de mot de passe, et plus encore dans le tableau de bord Back4App.
2. Exemples de code Django
Python
# models.py or a separate file
from parse_config import *
from parse_rest.user import User

def register_user(username, password, email):
    new_user = User.signup(username, password, email=email)
    return new_user

def login_user(username, password):
    return User.login(username, password)
# models.py or a separate file
from parse_config import *
from parse_rest.user import User

def register_user(username, password, email):
    new_user = User.signup(username, password, email=email)
    return new_user

def login_user(username, password):
    return User.login(username, password)
﻿
3. Connexion sociale
Si vous avez besoin de connexions Google, Apple ou Facebook, configurez-les dans Paramètres d'authentification de Back4App et suivez les guides respectifs. Votre application Django peut alors lier ou connecter des utilisateurs en appelant les méthodes Parse pertinentes.
Étape 6 – Gestion du stockage de fichiers
1. Configuration du stockage de fichiers
Back4App stocke en toute sécurité les fichiers téléchargés via le SDK Parse. Vous pouvez télécharger depuis Django en envoyant un fichier à un champ de fichier Parse :
Python
from parse_rest.datatypes import Object, File

class Photo(Object):
    pass

def upload_image(file_path):
    with open(file_path, 'rb') as f:
        parse_file = File(file_path, f.read())

    photo = Photo(imageFile=parse_file)
    photo.save()
    return photo
from parse_rest.datatypes import Object, File

class Photo(Object):
    pass

def upload_image(file_path):
    with open(file_path, 'rb') as f:
        parse_file = File(file_path, f.read())

    photo = Photo(imageFile=parse_file)
    photo.save()
    return photo
﻿
2. Exemple
Si vous souhaitez ajouter des images téléchargées par les utilisateurs, intégrez un <input type="file"> dans vos modèles Django, puis gérez le fichier dans une fonction de vue qui appelle upload_image().
3. Considérations de sécurité
Parse fournit une configuration qui contrôle qui peut télécharger des fichiers :
JSON
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
﻿
Ajustez ces paramètres pour correspondre à vos besoins en matière de sécurité, en veillant à ce que seuls les utilisateurs de confiance puissent stocker et accéder à des fichiers sensibles.
Étape 7 – Vérification par e-mail et réinitialisation du mot de passe
1. Vue d'ensemble
L' interface d'administration de Django gère de nombreuses choses, mais pour votre backend alimenté par Parse, vous pouvez également activer la vérification par e-mail et les réinitialisations de mot de passe. C'est essentiel pour vérifier les vrais utilisateurs et fournir un chemin de récupération de compte fluide.
2. Configuration du tableau de bord
Ouvrez votre application Back4App
Activez la vérification par e-mail dans Paramètres de l'application > Paramètres de messagerie
Personnalisez les modèles d'e-mail pour correspondre à votre image de marque
3. Code/Implémentation
Dans votre application Django, vous pourriez proposer un formulaire de réinitialisation de mot de passe. Lorsqu'un utilisateur demande une réinitialisation, appelez le point de terminaison de réinitialisation de mot de passe de Parse ou la méthode Python appropriée si elle est prise en charge dans le SDK.
Étape 8 – Planification des tâches avec les travaux Cloud
1. Ce que font les travaux Cloud
Les travaux Cloud vous permettent d'exécuter des tâches automatisées, telles que le nettoyage des anciennes données ou la génération de rapports. Cela complète les crontab ou les celery de Django en centralisant les tâches dans l'environnement de Back4App.
2. Exemple
JS
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
﻿
Après le déploiement, planifiez-le dans le Tableau de bord Back4App sous Paramètres du serveur > Travaux en arrière-plan pour qu'il s'exécute quotidiennement ou hebdomadairement.
Étape 9 – Intégration des Webhooks
1. Définition
Les Webhooks vous permettent d'envoyer des requêtes HTTP à des services externes lorsque certains événements se produisent dans vos classes Back4App. Par exemple, notifiez un canal Slack ou un service de paiement chaque fois qu'un nouvel enregistrement est créé.
2. Configuration
Allez à Plus > WebHooks dans le tableau de bord.
Configurez votre point de terminaison externe (par exemple, une URL dans votre projet Django).
Définissez des déclencheurs (comme “Objet créé” dans Todo).
Ajout d'un Webhook
﻿
3. Exemple
Chaque fois qu'un nouveau Todo est créé, une requête POST est envoyée à l'endpoint de votre application Django. Dans Django, vous analyseriez les données JSON et les traiteriez (par exemple, en les enregistrant ou en les traitant davantage).
Étape 10 – Exploration du panneau d'administration Back4App
1. Où le trouver
L' Application d'administration Back4App se trouve dans votre console sous Plus > Application d'administration. C'est une interface centrée sur le modèle pour gérer vos données sans écrire de code.
Activer l'application d'administration
﻿
2. Fonctionnalités
Base de données: Affichez, modifiez ou supprimez des enregistrements rapidement.
Journaux: Surveillez les erreurs ou les journaux de traitement.
Tâches en arrière-plan: Gérez vos horaires de tâches Cloud.
Analytique & Notifications push: Si pertinent pour votre application, accédez aux notifications push et aux données analytiques.
C'est similaire à l' interface d'administration de Django, mais se concentre sur le backend Parse.
Conclusion
En suivant ce guide, vous avez appris à construire un backend pour Django en utilisant Back4App. Vous avez :
Créé une structure de backend sécurisée et évolutive pour votre application Django.
Mis en place un modèle de données, effectué des opérations CRUD et tiré parti des fonctionnalités en temps réel.
Implémenté des ACL, des CLP et une authentification des utilisateurs pour une sécurité de haut niveau.
Utilisé Cloud Code pour la logique métier, la validation des données et les intégrations externes.
Stocké des fichiers, planifié des Cloud Jobs et configuré des Webhooks pour des workflows avancés.
Exploré l'application Admin de Back4App pour gérer vos données efficacement.
Avec cette base, vous pouvez étendre votre projet Django en toute confiance. Intégrez des fonctionnalités avancées, optimisez les performances et ajoutez une logique personnalisée pour répondre aux exigences de niveau entreprise.
Continuez à expérimenter avec le SDK Parse Python pour livrer des applications web puissantes. Bon codage !
Prochaines étapes
Construire une application Django prête pour la production avec un cache avancé, des rôles d'utilisateur et des optimisations de performance.
Tirer parti de fonctionnalités Back4App plus avancées telles que des analyses avancées ou un contrôle d'accès basé sur les rôles.
Apprendre à partir de la documentation officielle de Back4App pour une connaissance approfondie des journaux, des requêtes en temps réel et de l'optimisation des données.
Explorer d'autres tutoriels pour voir comment vous pouvez combiner les puissantes “vues et modèles” de Django avec des API externes et m
﻿
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour Java ?
Comment construire un backend pour Flask ?