Quickstarters
Comment construire un backend pour Python ?

41min
Introduction
Dans ce tutoriel étape par étape, vous apprendrez à construire un backend complet pour des applications Python en utilisant Back4App.
Nous allons passer en revue l'intégration des fonctionnalités essentielles de Back4App—telles que la gestion de base de données, les fonctions Cloud Code, les API REST et GraphQL, l'authentification des utilisateurs et les requêtes en temps réel—pour créer un backend sécurisé, évolutif et robuste qui communique sans effort avec votre code Python.
Python est un choix populaire parmi les langages de programmation pour le développement backend car il offre simplicité et la capacité de maintenir le côté serveur avec aisance.
Des frameworks et bibliothèques comme Django, Flask, et d'autres ont longtemps fait de Python un choix privilégié pour les processus de développement web.
En tirant parti de Back4App, un développeur Python peut rapidement configurer le schéma de base de données, garantir l'intégrité des données et même incorporer des tâches d'apprentissage automatique sans avoir à gérer une infrastructure complexe.
En cours de route, vous acquerrez une expérience pratique avec des fonctionnalités clés, telles que des fonctionnalités de sécurité avancées, la planification de tâches avec Cloud Jobs, et la configuration de webhooks pour des intégrations externes.
À la fin de ce tutoriel, vous serez bien préparé à améliorer cette structure fondamentale en une application backend Python prête pour la production ou à vous intégrer facilement avec d'autres outils comme Docker et Kubernetes à mesure que votre projet évolue.
Cela lancera votre parcours de développement backend Python en utilisant une plateforme fiable et des bibliothèques Python robustes.
Conditions préalables
Pour compléter ce tutoriel, vous aurez besoin de :
Un compte Back4App et un nouveau projet Back4App
Commencer avec Back4App.
Inscrivez-vous gratuitement si ce n'est pas déjà fait et créez un nouveau projet.
Python 3.x installé
Assurez-vous d'avoir Python 3.x configuré sur votre machine. Télécharger Python.﻿
Le SDK Python Parse
Installez via pip avec pip install parse-rest. Nous utiliserons ce SDK pour les interactions de données.
Familiarité avec les concepts de base de Python
Si vous êtes nouveau en Python, consultez la Documentation officielle de Python. ou un tutoriel pour débutants.
Avoir ces conditions préalables en place vous garantira que vous pouvez suivre alors que nous explorons comment construire un backend pour Python sur Back4App.
Étape 1 – Configuration du projet Back4App
Créer un nouveau projet
La première étape pour construire votre backend Python sur Back4App consiste à créer un nouveau projet. Si vous ne l'avez pas encore fait, suivez ces étapes :
Connectez-vous à votre compte Back4App.
Cliquez sur le bouton “Nouvelle application” dans votre tableau de bord Back4App.
Donnez un nom à votre application (par exemple, “Python-Backend-Tutorial”).
﻿
Une fois le projet créé, vous le verrez listé dans votre tableau de bord Back4App. Ce projet sera la base de toutes les configurations backend discutées dans ce tutoriel.
Connectez le SDK Parse
Back4App s'appuie sur la plateforme Parse pour gérer vos données, fournir des fonctionnalités en temps réel, gérer l'authentification des utilisateurs, et plus encore.
Pour connecter votre code Python à Back4App, vous devez installer le SDK Parse pertinent et l'initialiser avec les identifiants de votre tableau de bord Back4App.
Récupérez vos clés Parse:
Dans votre tableau de bord Back4App, accédez aux Paramètres de l'application ou à la section Sécurité et clés pour trouver votre ID d'application et votre clé API REST. Vous trouverez également l' URL du serveur Parse (souvent https://parseapi.back4app.com).
﻿
Installez le SDK REST Python de Parse:
Bash
pip install parse-rest
pip install parse-rest
﻿
Initialisez Parse dans votre script Python:
Typiquement, vous créeriez un fichier (par exemple, parse_config.py) dans votre projet :
parse_config.py
# parse_config.py
from parse_rest.connection import register

# Replace the placeholders with your Back4App credentials
APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
PARSE_SERVER_URL = "https://parseapi.back4app.com"

# The register function initializes the connection
register(APPLICATION_ID, REST_API_KEY, master_key=None)
# parse_config.py
from parse_rest.connection import register

# Replace the placeholders with your Back4App credentials
APPLICATION_ID = "YOUR_APPLICATION_ID"
REST_API_KEY = "YOUR_REST_API_KEY"
PARSE_SERVER_URL = "https://parseapi.back4app.com"

# The register function initializes the connection
register(APPLICATION_ID, REST_API_KEY, master_key=None)
﻿
Ce code garantit que chaque fois que vous importez votre parse_config module ailleurs dans votre application Python, il est préconfiguré pour se connecter à votre instance Back4App spécifique. Vous avez maintenant établi une connexion sécurisée entre votre code Python et le backend Back4App.
Étape 2 – Configuration de la base de données
Un schéma de base de données robuste est essentiel pour le développement backend Python. Les fonctionnalités de gestion des données de Back4App vous permettent de définir des tables (classes), des champs et des relations, garantissant que vous pouvez facilement stocker et récupérer des données dans votre framework web Python ou toute autre bibliothèque Python de votre choix.
Création d'un modèle de données
Back4App crée automatiquement des schémas de classe lorsque vous enregistrez pour la première fois un objet depuis le code, ou vous pouvez définir un schéma dans le tableau de bord :
Accédez à la section “Base de données” dans votre tableau de bord Back4App.
Créez une nouvelle classe (par exemple, “Todo”) et ajoutez des colonnes pertinentes, telles que titre (String) et isCompleted (Boolean).
Créer une nouvelle classe
﻿
Créer un modèle de données en utilisant l'agent IA
L'agent IA de Back4App peut vous aider à créer rapidement un schéma de base de données :
Ouvrez l'agent IA depuis votre tableau de bord d'application.
Décrivez votre modèle de données en langage naturel (par exemple, “Créez une application ToDo avec un schéma de classe complet.”).
Laissez l'agent IA générer votre schéma automatiquement.
﻿
Lire et écrire des données en utilisant le SDK Python Parse
Une fois votre schéma prêt, enregistrer et interroger des données est simple. Par exemple :
models.py
from parse_rest.datatypes import Object
import parse_config  # ensure parse_config is imported

class Todo(Object):
    pass

def create_todo_item(title, is_completed=False):
    new_todo = Todo(title=title, isCompleted=is_completed)
    new_todo.save()
    print("Todo saved successfully:", new_todo.objectId)

def fetch_todos():
    return Todo.Query.all()

# Usage
# create_todo_item("Buy groceries", False)
# results = fetch_todos()
# for todo in results:
#     print(todo.title, todo.isCompleted)
from parse_rest.datatypes import Object
import parse_config  # ensure parse_config is imported

class Todo(Object):
    pass

def create_todo_item(title, is_completed=False):
    new_todo = Todo(title=title, isCompleted=is_completed)
    new_todo.save()
    print("Todo saved successfully:", new_todo.objectId)

def fetch_todos():
    return Todo.Query.all()

# Usage
# create_todo_item("Buy groceries", False)
# results = fetch_todos()
# for todo in results:
#     print(todo.title, todo.isCompleted)
﻿
Lecture et écriture de données en utilisant l'API REST
Si vous préférez interagir via REST, vous pouvez envoyer des requêtes directement :
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
﻿
Lecture et écriture de données en utilisant l'API GraphQL
Back4App fournit également un point de terminaison GraphQL pour interroger et modifier des données :
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
    }
  }
}
﻿
Travailler avec des requêtes en direct (optionnel)
Les requêtes en direct vous permettent de recevoir des mises à jour en temps réel chaque fois que les données changent. Pour les activer :
Activer les requêtes en direct dans vos Paramètres du serveur.
Utiliser une approche WebSocket en Python pour s'abonner aux changements. Bien que le SDK Python pour les requêtes en direct soit géré par la communauté, vous pouvez intégrer une bibliothèque WebSocket si votre application nécessite des mises à jour en temps réel.
Étape 3 – Application de la sécurité avec les ACL et les CLP
Aperçu rapide
Back4App fournit Des listes de contrôle d'accès (ACL) et Des autorisations au niveau de la classe (CLP) pour vous aider à garantir l'intégrité des données. Ces fonctionnalités définissent comment les utilisateurs publics ou authentifiés peuvent accéder ou modifier les données.
﻿
Configuration des autorisations au niveau de la classe
Allez sur votre tableau de bord Back4App, sélectionnez votre application et ouvrez la base de données.
Sélectionnez une classe (par exemple, “Todo”).
Allez aux autorisations au niveau de la classe et configurez les règles pour les utilisateurs publics ou authentifiés.
Configuration des ACL dans le code
Les ACL sont des permissions fines définies sur des objets individuels. Par exemple :
Python
from parse_rest.datatypes import Object, ACL
from parse_rest.user import User
import parse_config

class TodoACL(Object):
    pass

def create_private_todo(title, owner):
    todo = TodoACL(title=title)
    # Create ACL that allows only the owner read/write
    acl = ACL()
    acl.set_read_access(owner.objectId, True)
    acl.set_write_access(owner.objectId, True)
    todo.ACL = acl
    todo.save()
    return todo
from parse_rest.datatypes import Object, ACL
from parse_rest.user import User
import parse_config

class TodoACL(Object):
    pass

def create_private_todo(title, owner):
    todo = TodoACL(title=title)
    # Create ACL that allows only the owner read/write
    acl = ACL()
    acl.set_read_access(owner.objectId, True)
    acl.set_write_access(owner.objectId, True)
    todo.ACL = acl
    todo.save()
    return todo
﻿
Avec les ACL et les CLP, vous pouvez trouver un équilibre entre sécurité et commodité lors de la création de vos applications Python.
Étape 4 – Écriture des Fonctions Cloud Code
Pourquoi Cloud Code
Le Cloud Code vous permet de décharger une logique métier importante sur le côté serveur. Cela peut impliquer des validations, des déclencheurs ou des tâches sophistiquées comme l'intégration d'outils d'apprentissage automatique ou d'APIs externes avec votre développement backend Python.
Fonction Exemple
Vous pourriez écrire vos fonctions dans main.js (Cloud Code basé sur JavaScript) sur Back4App. Notez que bien que vous développiez votre application en Python, l'environnement Cloud Code sur Back4App utilise Node.js/JavaScript. Vous pouvez appeler ces fonctions depuis votre code Python ou tout autre client.
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 };
});
﻿
Vous pouvez appeler cette fonction en utilisant les capacités REST ou GraphQL de Python :
Python
import requests

def get_text_length(text):
    url = "https://parseapi.back4app.com/functions/calculateTextLength"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "application/json"
    }
    response = requests.post(url, headers=headers, json={"text": text})
    data = response.json()
    return data.get("result", {})

# usage
length_info = get_text_length("Hello Back4App")
print(length_info.get("length"))
import requests

def get_text_length(text):
    url = "https://parseapi.back4app.com/functions/calculateTextLength"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "application/json"
    }
    response = requests.post(url, headers=headers, json={"text": text})
    data = response.json()
    return data.get("result", {})

# usage
length_info = get_text_length("Hello Back4App")
print(length_info.get("length"))
﻿
Déploiement et NPM
Le Cloud Code de Back4App est déployé en utilisant le Back4App CLI ou via le tableau de bord. Vous pouvez installer des packages NPM (par exemple, pour la manipulation de données, les appels d'API externes) et les référencer dans votre main.js. Cette approche garde votre code efficace et sécurisé côté serveur.
Étape 5 – Configuration de l'authentification
Activer ou configurer l'authentification des utilisateurs
Back4App utilise la classe Parse User pour l'authentification. Cela gère automatiquement le hachage des mots de passe, les jetons de session, et plus encore. Vous pouvez gérer les inscriptions, les connexions ou les réinitialisations de mot de passe avec un minimum de surcharge.
S'inscrire et se connecter depuis Python
Python
from parse_rest.user import User
import parse_config

def sign_up_user(username, password, email):
    new_user = User.signup(username, password, email=email)
    print("User signed up successfully:", new_user.objectId)
    return new_user

def log_in_user(username, password):
    logged_user = User.login(username, password)
    print("User logged in:", logged_user.username)
    return logged_user
from parse_rest.user import User
import parse_config

def sign_up_user(username, password, email):
    new_user = User.signup(username, password, email=email)
    print("User signed up successfully:", new_user.objectId)
    return new_user

def log_in_user(username, password):
    logged_user = User.login(username, password)
    print("User logged in:", logged_user.username)
    return logged_user
﻿
Les sessions sont automatiquement gérées par Parse. Vous pouvez suivre l'utilisateur connecté et appeler .logout() lorsque nécessaire. Pour plus de détails, consultez la Documentation de la classe Utilisateur.
Connexion Sociale
Vous pouvez intégrer des fournisseurs populaires (comme Facebook ou Google) en configurant des flux OAuth ou en utilisant des adaptateurs spécialisés. Référez-vous à Documentation de la connexion sociale pour plus de détails sur la configuration de ces fonctionnalités avec votre projet Python.
Étape 6 – Gestion du stockage de fichiers
Configuration du stockage de fichiers
La plateforme Parse inclut un stockage de fichiers natif:
Python
import requests
import parse_config

def upload_file(file_path):
    file_name = file_path.split('/')[-1]
    url = f"https://parseapi.back4app.com/files/{file_name}"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "image/jpeg" # or other mime type
    }
    with open(file_path, 'rb') as f:
        response = requests.post(url, headers=headers, data=f)
    return response.json().get('url')
import requests
import parse_config

def upload_file(file_path):
    file_name = file_path.split('/')[-1]
    url = f"https://parseapi.back4app.com/files/{file_name}"
    headers = {
        "X-Parse-Application-Id": "YOUR_APP_ID",
        "X-Parse-REST-API-Key": "YOUR_REST_API_KEY",
        "Content-Type": "image/jpeg" # or other mime type
    }
    with open(file_path, 'rb') as f:
        response = requests.post(url, headers=headers, data=f)
    return response.json().get('url')
﻿
Exemple
Vous pouvez attacher ce fichier à un objet Parse en stockant son URL. Cela maintient vos données cohérentes pendant que vos médias sont hébergés en toute sécurité par Back4App.
Considérations de sécurité
Vous pouvez contrôler qui peut télécharger ou accéder aux fichiers en configurant les paramètres de votre serveur Parse pour n'autoriser que les utilisateurs authentifiés, par exemple. Cette approche garantit que vos applications Python de production restent sécurisées.
Étape 7 – Vérification par e-mail et réinitialisation du mot de passe
Aperçu
La vérification par e-mail et les réinitialisations de mot de passe sont cruciales pour la gestion des utilisateurs. Elles aident à confirmer les identités des utilisateurs et à maintenir la sécurité des comptes.
Configuration du tableau de bord Back4App
Activer la vérification par e-mail dans Paramètres de l'application > Paramètres de l'e-mail.
Configurer les modèles d'e-mail, tels que l'adresse “De”, et les instructions de réinitialisation du mot de passe.
Mise en œuvre du code
Depuis Python, vous pouvez déclencher des e-mails de réinitialisation de mot de passe via le point de terminaison REST ou les bibliothèques parse. Par exemple :
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
Cela garantit un flux sans faille pour les réinitialisations de mot de passe directement depuis votre backend Python ou toute autre interface.
Étape 8 – Planification des tâches avec des Cloud Jobs
Ce que font les Cloud Jobs
Les Cloud Jobs vous permettent d'automatiser des tâches, comme nettoyer les anciens enregistrements ou générer des rapports périodiques. Ceux-ci s'exécutent sur l'infrastructure de Back4App à des intervalles spécifiés.
Exemple
Dans votre main.js:
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);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
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);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
﻿
Vous pouvez ensuite programmer ce travail pour qu'il s'exécute quotidiennement ou hebdomadairement en utilisant la Section des travaux en arrière-plan.
Planification d'un travail Cloud
﻿
Étape 9 – Intégration des Webhooks
Définition
Les webhooks permettent à votre application Back4App de notifier des services externes lorsque certains événements se produisent. Cela est utile pour s'intégrer avec des passerelles de paiement ou des plateformes d'analyse, élargissant vos processus de développement.
Configuration
Naviguer vers Webhooks dans votre tableau de bord Back4App.
Ajouter un nouveau webhook point de terminaison (par exemple, https://your-service.com/webhook-endpoint).
Sélectionner les événements qui déclenchent le webhook (par exemple, la création ou les mises à jour d'objets).
Ajout d'un Webhook
﻿
Vous pouvez également définir des webhooks dans les déclencheurs de Cloud Code comme beforeSave ou afterSave pour envoyer des données à des API externes.
Webhook BeforeSave
﻿
Étape 10 – Explorer le panneau d'administration Back4App
Où le trouver
L' Application Admin Back4App est une interface de gestion basée sur le web. Elle permet à votre équipe d'effectuer des opérations CRUD, de gérer des données et de gérer les tâches quotidiennes sans écrire de code supplémentaire. Cela peut rationaliser votre processus de développement backend Python.
Fonctionnalités
Activer l'application Admin depuis App Dashboard > Plus > Application Admin et suivez les étapes :
Activer l'application Admin
﻿
Créez le premier utilisateur Admin. Un nouveau rôle (B4aAdminUser) et des classes sont automatiquement ajoutés à votre schéma.
﻿
Choisissez un sous-domaine pour votre interface admin et finalisez. Ensuite, connectez-vous pour accéder à votre nouvelle application Admin.
﻿
﻿
L'application Admin facilite la mise à jour ou la suppression d'enregistrements et la gestion de vos données. Avec des contrôles d'accès appropriés, il est sûr de la partager avec des chefs de projet ou des parties prenantes.
Conclusion
En suivant ce guide sur comment construire un backend pour Python, vous avez :
Créé un backend sécurisé pour les applications Python sur Back4App.
Configuré une base de données avec des schémas et des relations flexibles.
Implémenté des requêtes en temps réel pour des mises à jour instantanées des données (optionnel avec les requêtes en direct).
Appliqué des mesures de sécurité avec des ACL et des CLP pour protéger les données.
Écrit du Cloud Code en JavaScript pour gérer la logique côté serveur, facilement appelable depuis Python.
Mis en place l'authentification des utilisateurs avec vérification par e-mail et flux de réinitialisation de mot de passe.
Géré les téléchargements de fichiers dans votre code Python avec une sécurité de fichier optionnelle.
Planifié des tâches récurrentes pour des tâches automatisées.
Intégré des services externes en utilisant des webhooks.
Exploré le panneau d'administration pour la gestion des données et la collaboration.
Avec une base de code Python solide et un backend Back4App robuste, vous êtes maintenant équipé pour aborder des structures de données avancées, incorporer des frameworks comme Django et Flask, et même intégrer l'apprentissage automatique.
Python offre d'innombrables possibilités, et le combiner avec Back4App signifie que vous pouvez itérer rapidement tout en vous concentrant sur la logique métier principale plutôt que sur la maintenance du serveur.
Prochaines étapes
Construire une application Python prête pour la production en affinant votre schéma de base de données, en ajoutant du caching et en gérant les optimisations de performance.
Explorer des fonctionnalités avancées comme le contrôle d'accès basé sur les rôles, la journalisation avancée ou la connexion d'APIs tierces pour l'analyse.
Consulter la documentation officielle de Back4App pour des informations plus approfondies sur la sécurité, l'optimisation des performances et l'analyse des journaux.
Expérimenter avec des outils comme Docker et Kubernetes pour containeriser et faire évoluer votre application selon vos besoins.
En tirant parti des bibliothèques puissantes de Python et de l'infrastructure évolutive de Back4App, vous pouvez accélérer votre parcours de développement backend en toute confiance.
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour Flask ?
Comment construire un backend pour Astro ?