Quickstarters
Comment construire un backend pour Flask ?

42min
Introduction
Dans ce tutoriel, vous apprendrez comment construire un backend pour Flask en utilisant Back4App. 
Flask est un framework backend léger qui gère les requêtes HTTP avec aisance, et il fonctionne efficacement en mode débogage pendant le développement. 
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 (Live Queries)—pour créer un backend sécurisé, évolutif et robuste pour votre application Flask.
Vous verrez également comment la configuration rapide de Back4App et son environnement intuitif peuvent réduire considérablement le temps et les efforts par rapport à la configuration manuelle des serveurs et des bases de données. 
Nous utiliserons du code Python pour connecter Flask au serveur Parse de Back4App. En cours de route, vous acquerrez une expérience pratique avec des fonctionnalités clés, y compris 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 configuration de base en une application prête pour la production ou à intégrer facilement une logique personnalisée et des API tierces selon vos besoins. 
Prérequis
Pour compléter ce tutoriel, vous aurez besoin de :
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.
Environnement de développement Flask de base
Vous pouvez installer Flask via pip install flask. Assurez-vous d'avoir Python 3.7+ installé sur votre machine.
pip install parse
Ce package Python permet à votre application Flask d'interagir avec le serveur Parse de Back4App.
Familiarité avec les concepts de Python et Flask
Documentation officielle de Flask.
Si vous êtes nouveau sur Flask, consultez la documentation officielle ou un tutoriel pour débutants avant de commencer.
Assurez-vous d'avoir tous ces prérequis en place avant de commencer. Avoir votre projet Back4app configuré et votre environnement Flask local prêt vous aidera à suivre plus facilement.
Étape 1 – Créer un nouveau projet sur Back4App et se connecter
Créer un nouveau projet
La première étape pour construire votre backend Flask sur Back4App consiste à créer un nouveau projet. Si vous ne l'avez pas encore créé, 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, “Flask-Backend-Tutorial”).
﻿
Une fois le projet créé, vous le verrez listé dans votre tableau de bord Back4app. Ce projet est la base de toutes les configurations backend.
Connectez le SDK Parse à Flask
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. 
Connecter votre application Flask à Back4App implique d'installer le parse paquet Python et de 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 à la section “Paramètres de l'application” ou “Sécurité & Clés” pour trouver votre ID d'application et Clé client (ou Clé API REST si nécessaire). Vous trouverez également l' URL du serveur Parse (souvent au format https://parseapi.back4app.com).
﻿
Installez le SDK Python Parse dans votre environnement Flask en exécutant :
Bash
pip install parse
pip install parse
﻿
Initialisez Parse dans votre application Flask:
Créez un fichier (par exemple, parse_config.py) dans un répertoire appelé app ou où que vous stockiez vos modules backend :
parse_config.py
import parse

# Replace the placeholders with your Back4app credentials
parse.application_id = "YOUR_APPLICATION_ID"
parse.client_key = "YOUR_CLIENT_KEY"
parse.server_url = "https://parseapi.back4app.com"
import parse

# Replace the placeholders with your Back4app credentials
parse.application_id = "YOUR_APPLICATION_ID"
parse.client_key = "YOUR_CLIENT_KEY"
parse.server_url = "https://parseapi.back4app.com"
﻿
Ensuite, dans votre fichier principal de l'application Flask (par exemple, app.py ), vous pouvez importer les modules de l'application flask ainsi que votre configuration Parse :
Python
from flask import Flask, request, jsonify
import parse_config  # This ensures Parse is already set up

app = Flask(__name__)

@app.route('/')
def index():
    return "Hello, Flask + Back4App!"

if __name__ == '__main__':
    app.run(debug=True)  # The debug mode helps in local development server
from flask import Flask, request, jsonify
import parse_config  # This ensures Parse is already set up

app = Flask(__name__)

@app.route('/')
def index():
    return "Hello, Flask + Back4App!"

if __name__ == '__main__':
    app.run(debug=True)  # The debug mode helps in local development server
﻿
En complétant cette étape, vous avez établi une connexion sécurisée entre vos routes front-end Flask et le backend Back4App. Toutes les requêtes et transactions de données sont acheminées de manière sécurisée via le code Python Parse, réduisant la complexité des appels REST ou GraphQL manuels (bien que vous puissiez toujours les utiliser si nécessaire).
Étape 2 – Configuration de la base de données
Création d'un modèle de données
Avant de commencer, parlons de la configuration de la base de données. Vous pouvez concevoir votre schéma de données dans le tableau de bord Back4App ou laisser Parse le créer à la volée. Par exemple, vous pourriez créer une classe nommée “Todo” avec des champs comme title et isCompleted.
Naviguez vers 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 title (String) et isCompleted (Boolean).
Créer une nouvelle classe
﻿
Back4app prend en charge divers types de données, comme String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, et Polygon. Vous pouvez choisir le type approprié pour chaque champ.
Créer un modèle de données en utilisant l'Agent IA
Si vous préférez une approche automatisée, vous pouvez également utiliser l'Agent IA de Back4app :
Ouvrez l'Agent IA depuis votre tableau de bord d'application.
Décrivez votre modèle de données dans un langage simple (par exemple, “Créer une classe ToDo avec des champs titre et isCompleted sur Back4app.”).
Laissez l'Agent IA créer le schéma pour vous.
﻿
Lire et écrire des données en utilisant le SDK
Dans Flask, vous pouvez créer et récupérer des données en important parse depuis votre parse_config.py initialisation :
Python
from flask import Flask, request, jsonify
import parse
import parse_config

app = Flask(__name__)

@app.route('/create_todo', methods=['POST'])
def create_todo():
    data = request.get_json()  # import json to parse the payload
    title = data.get('title')
    is_completed = data.get('isCompleted', False)

    Todo = parse.Object.factory('Todo')
    todo_item = Todo()
    todo_item.title = title
    todo_item.isCompleted = is_completed

    try:
        saved_todo = todo_item.save()
        return jsonify({"success": True, "objectId": saved_todo.objectId}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400

@app.route('/fetch_todos', methods=['GET'])
def fetch_todos():
    Todo = parse.Object.factory('Todo')
    query = Todo.query

    try:
        todos = query.find()
        # Convert to JSON-compatible response
        results = [{"objectId": t.objectId, "title": t.title, "isCompleted": t.isCompleted} for t in todos]
        return jsonify(results), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400

if __name__ == '__main__':
    app.run(debug=True)
from flask import Flask, request, jsonify
import parse
import parse_config

app = Flask(__name__)

@app.route('/create_todo', methods=['POST'])
def create_todo():
    data = request.get_json()  # import json to parse the payload
    title = data.get('title')
    is_completed = data.get('isCompleted', False)

    Todo = parse.Object.factory('Todo')
    todo_item = Todo()
    todo_item.title = title
    todo_item.isCompleted = is_completed

    try:
        saved_todo = todo_item.save()
        return jsonify({"success": True, "objectId": saved_todo.objectId}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400

@app.route('/fetch_todos', methods=['GET'])
def fetch_todos():
    Todo = parse.Object.factory('Todo')
    query = Todo.query

    try:
        todos = query.find()
        # Convert to JSON-compatible response
        results = [{"objectId": t.objectId, "title": t.title, "isCompleted": t.isCompleted} for t in todos]
        return jsonify(results), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400

if __name__ == '__main__':
    app.run(debug=True)
﻿
Ce fichier d'application Flask gère les requêtes http pour créer et lire des éléments Todo dans votre base de données Back4App.
Lecture et écriture de données en utilisant l'API REST
Si vous préférez des appels REST directs, vous pouvez tester avec curl depuis la ligne de commande:
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
De même, Back4app fournit un point de terminaison 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
    }
  }
}
﻿
Python
from flask import Flask, request, jsonify
import parse
import parse_config

app = Flask(__name__)

@app.route('/create_todo', methods=['POST'])
def create_todo():
    data = request.get_json()  # import json to parse the payload
    title = data.get('title')
    is_completed = data.get('isCompleted', False)

    Todo = parse.Object.factory('Todo')
    todo_item = Todo()
    todo_item.title = title
    todo_item.isCompleted = is_completed

    try:
        saved_todo = todo_item.save()
        return jsonify({"success": True, "objectId": saved_todo.objectId}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400

@app.route('/fetch_todos', methods=['GET'])
def fetch_todos():
    Todo = parse.Object.factory('Todo')
    query = Todo.query

    try:
        todos = query.find()
        # Convert to JSON-compatible response
        results = [{"objectId": t.objectId, "title": t.title, "isCompleted": t.isCompleted} for t in todos]
        return jsonify(results), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400

if __name__ == '__main__':
    app.run(debug=True)
from flask import Flask, request, jsonify
import parse
import parse_config

app = Flask(__name__)

@app.route('/create_todo', methods=['POST'])
def create_todo():
    data = request.get_json()  # import json to parse the payload
    title = data.get('title')
    is_completed = data.get('isCompleted', False)

    Todo = parse.Object.factory('Todo')
    todo_item = Todo()
    todo_item.title = title
    todo_item.isCompleted = is_completed

    try:
        saved_todo = todo_item.save()
        return jsonify({"success": True, "objectId": saved_todo.objectId}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400

@app.route('/fetch_todos', methods=['GET'])
def fetch_todos():
    Todo = parse.Object.factory('Todo')
    query = Todo.query

    try:
        todos = query.find()
        # Convert to JSON-compatible response
        results = [{"objectId": t.objectId, "title": t.title, "isCompleted": t.isCompleted} for t in todos]
        return jsonify(results), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400

if __name__ == '__main__':
    app.run(debug=True)
﻿
Travailler avec des requêtes en direct (optionnel)
Si vous avez besoin de mises à jour en temps réel, Back4app fournit des requêtes en direct. Dans un scénario Flask, vous utiliseriez généralement une bibliothèque d'abonnement côté client ou côté serveur distincte qui peut maintenir une connexion websocket au serveur de requêtes en direct de Back4App.
Activer les requêtes en direct dans votre tableau de bord Back4app sous les Paramètres du serveur.
Utiliser un client Parse LiveQuery qui se connecte à wss://YOUR_SUBDOMAIN_HERE.b4a.io et écoute les événements de création/mise à jour/suppression.
Étape 3 – Appliquer 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 sécuriser les données. Les ACL s'appliquent à des objets individuels, tandis que les CLP s'appliquent à l'ensemble de la classe. Cela vous aide à restreindre ou à autoriser les opérations de lecture/écriture par utilisateur, rôle ou le public.
﻿
Configuration des autorisations au niveau de la classe
Allez à votre tableau de bord Back4app, sélectionnez votre application et ouvrez la base de données section.
Sélectionnez une classe (par exemple, “Todo”).
Ouvrez les autorisations au niveau de la classe onglet.
Configurez vos paramètres par défaut, tels que “Nécessite une authentification” ou “Aucun accès.”
Configuration des ACL dans le code
Vous pouvez appliquer des ACL dans le code Python :
Python
@app.route('/create_private_todo', methods=['POST'])
def create_private_todo():
    data = request.get_json()
    user_id = data.get('userId')
    title = data.get('title')

    # Assume you have a pointer to the user or a way to get user from ID
    ParseUser = parse.User
    user_query = ParseUser.query
    user_obj = user_query.get(user_id)

    Todo = parse.Object.factory('Todo')
    todo_item = Todo()
    todo_item.title = title

    acl = parse.ACL()
    acl.setReadAccess(user_obj, True)
    acl.setWriteAccess(user_obj, True)
    acl.setPublicReadAccess(False)
    acl.setPublicWriteAccess(False)

    todo_item.ACL = acl

    saved_todo = todo_item.save()
    return jsonify({"success": True, "objectId": saved_todo.objectId}), 200
@app.route('/create_private_todo', methods=['POST'])
def create_private_todo():
    data = request.get_json()
    user_id = data.get('userId')
    title = data.get('title')

    # Assume you have a pointer to the user or a way to get user from ID
    ParseUser = parse.User
    user_query = ParseUser.query
    user_obj = user_query.get(user_id)

    Todo = parse.Object.factory('Todo')
    todo_item = Todo()
    todo_item.title = title

    acl = parse.ACL()
    acl.setReadAccess(user_obj, True)
    acl.setWriteAccess(user_obj, True)
    acl.setPublicReadAccess(False)
    acl.setPublicWriteAccess(False)

    todo_item.ACL = acl

    saved_todo = todo_item.save()
    return jsonify({"success": True, "objectId": saved_todo.objectId}), 200
﻿
Étape 4 – Écriture des fonctions Cloud Code
Pourquoi Cloud Code
Le Cloud Code est parfait pour exécuter du code python (ou JavaScript dans d'autres scénarios) côté serveur, afin que vous n'ayez pas à héberger votre propre infrastructure. Vous pouvez exécuter des tâches telles que la validation des données, l'exécution de calculs complexes ou l'intégration avec des services externes directement depuis le serveur Parse.
Fonction d'exemple
Parce que l'environnement Cloud Code par défaut pour Back4App utilise Node.js, vous écririez votre Cloud Code en JavaScript. Cependant, vous pouvez toujours déclencher ces scripts côté serveur depuis votre application Flask. Par exemple, une fonction Cloud Node.js pourrait ressembler à :
main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Déploiement
Utilisez le Back4app CLI pour déployer votre Cloud Code :
Bash
# Step 1 - Install the CLI
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

# Step 2 - Configure your account key
b4a configure accountkey

# Step 3 - Deploy your code
b4a deploy
# Step 1 - Install the CLI
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

# Step 2 - Configure your account key
b4a configure accountkey

# Step 3 - Deploy your code
b4a deploy
﻿
Alternativement, vous pouvez déployer via le tableau de bord Back4app en collant votre code JS dans Cloud Code > Fonctions et en cliquant sur “Déployer.”
﻿
Appeler votre fonction
Dans Flask, vous pouvez appeler cette fonction cloud en utilisant REST :
Python
import requests

@app.route('/text_length', methods=['POST'])
def get_text_length():
    data = request.get_json()
    text = data.get('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"
    }
    payload = {"text": text}

    response = requests.post(url, json=payload, headers=headers)
    return jsonify(response.json()), response.status_code
import requests

@app.route('/text_length', methods=['POST'])
def get_text_length():
    data = request.get_json()
    text = data.get('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"
    }
    payload = {"text": text}

    response = requests.post(url, json=payload, headers=headers)
    return jsonify(response.json()), response.status_code
﻿
Étape 5 – Configuration de l'authentification
Activer ou configurer l'authentification des utilisateurs dans le tableau de bord Back4App
Back4App utilise la classe Utilisateur par défaut. Parse gère le hachage des mots de passe, les jetons de session et le stockage sécurisé. Vous pouvez gérer ces fonctionnalités dans vos Paramètres de l'application.
Exemples de code
Python
@app.route('/signup', methods=['POST'])
def sign_up_user():
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')
    email = data.get('email')

    user = parse.User()
    user.username = username
    user.password = password
    user.email = email

    try:
        user.sign_up()
        return jsonify({"success": True}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400

@app.route('/login', methods=['POST'])
def log_in_user():
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')

    try:
        parse.User.login(username, password)
        return jsonify({"success": True}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400
@app.route('/signup', methods=['POST'])
def sign_up_user():
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')
    email = data.get('email')

    user = parse.User()
    user.username = username
    user.password = password
    user.email = email

    try:
        user.sign_up()
        return jsonify({"success": True}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400

@app.route('/login', methods=['POST'])
def log_in_user():
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')

    try:
        parse.User.login(username, password)
        return jsonify({"success": True}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 400
﻿
Connexion sociale
Back4App et Parse peuvent s'intégrer avec des fournisseurs sociaux comme Google, Apple ou Facebook. Les détails de configuration varient, alors référez-vous aux Docs de connexion sociale Parse.
Étape 6 – Gestion du stockage de fichiers
Configuration du stockage de fichiers
Vous pouvez télécharger des fichiers dans votre base de données Parse depuis Flask en créant un parse.File() objet dans l'environnement basé sur Node, ou vous pouvez utiliser des appels REST directs depuis Python. Si vous stockez des références à ces fichiers dans vos classes, ils deviennent facilement récupérables.
Python
@app.route('/upload_file', methods=['POST'])
def upload_file():
    file = request.files['file']  # from an HTML form or an API call
    file_name = file.filename
    url = "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": file.content_type
    }

    response = requests.post(url, data=file.read(), headers=headers)
    return jsonify(response.json()), response.status_code
@app.route('/upload_file', methods=['POST'])
def upload_file():
    file = request.files['file']  # from an HTML form or an API call
    file_name = file.filename
    url = "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": file.content_type
    }

    response = requests.post(url, data=file.read(), headers=headers)
    return jsonify(response.json()), response.status_code
﻿
Exemple
Après avoir téléchargé un fichier, vous recevrez une URL de fichier que vous pouvez stocker dans votre base de données. Vous pouvez ensuite rendre ou référencer ce fichier dans votre modèle html selon vos besoins.
Étape 7 – Vérification par e-mail et réinitialisation du mot de passe
Aperçu
La vérification par e-mail garantit des adresses e-mail valides, et la réinitialisation du mot de passe aide les utilisateurs à retrouver l'accès à leur compte de manière sécurisée.
Configuration du tableau de bord Back4App
Allez dans vos paramètres de messagerie dans le tableau de bord Back4App.
Activer la vérification par e-mail et configurer les modèles d'e-mail.
Activer la réinitialisation du mot de passe pour envoyer des liens de récupération de mot de passe à l'e-mail de l'utilisateur.
Code/Implémentation
Une fois activé, tout nouvel utilisateur s'inscrivant avec un e-mail reçoit un lien de vérification. Pour la réinitialisation du mot de passe, vous pouvez appeler les méthodes intégrées de Parse via REST ou depuis vos routes Flask.
Étape 8 – Planification des tâches avec des travaux cloud
Ce que font les travaux cloud
Les Cloud Jobs vous permettent de planifier des tâches en arrière-plan comme le nettoyage des données ou l'envoi d'e-mails périodiques. Par exemple, vous pouvez supprimer des enregistrements anciens chaque jour sans intervention de l'utilisateur.
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);

  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);
  }
});
// 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);

  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);
  }
});
﻿
Ensuite, depuis votre tableau de bord Back4App :
Allez dans les paramètres de l'application > Paramètres du serveur > Tâches en arrière-plan.
Planifiez cette tâche pour qu'elle s'exécute quotidiennement ou à l'intervalle de votre choix.
Planification d'un Cloud Job
﻿
Étape 9 – Intégration des Webhooks
Définition
Webhooks permettent à votre application Back4app d'envoyer des données à des services externes chaque fois que certains déclencheurs se produisent. Cela est utile pour les intégrations avec des passerelles de paiement, Slack, des analyses ou tout service tiers.
Configuration
Naviguez vers la configuration des Webhooks dans votre tableau de bord Back4App > Plus > WebHooks.
Ajoutez un nouveau Webhook.
Définissez le point de terminaison (par exemple, https://your-external-service.com/webhook-endpoint).
Sélectionnez les déclencheurs pour lesquels le webhook sera déclenché.
Ajout d'un Webhook
﻿
Exemple
Si vous souhaitez notifier un canal Slack chaque fois qu'un nouvel enregistrement est créé dans “Todo,” définissez l'URL du webhook Slack. Ensuite, chaque fois qu'un nouveau Todo est enregistré, Slack recevra une requête POST contenant ses détails.
Étape 10 – Exploration du panneau d'administration Back4App
L' Application d'administration Back4App fournit une interface conviviale pour les membres non techniques de votre équipe. C'est une interface centrée sur le modèle pour les opérations CRUD et les tâches de niveau entreprise.
Où le trouver
Allez sur votre tableau de bord d'application.
Sélectionnez Plus > Application Admin et activez-la.
Créez un utilisateur admin et choisissez un sous-domaine pour héberger le panneau.
Activer l'application Admin
﻿
﻿
﻿
Une fois activé, vous pouvez vous connecter avec vos identifiants admin pour gérer les données plus facilement—sans écrire d'endpoints ou de requêtes personnalisées dans votre code Python.
﻿
Conclusion
En suivant ce tutoriel complet, vous avez :
Créé un backend sécurisé pour une application Flask sur Back4App.
Configuré une base de données avec des schémas de classe, des types de données et des relations.
Intégré des requêtes en temps réel (Live Queries) pour des mises à jour de données immédiates.
Appliqué des mesures de sécurité en utilisant des ACL et des CLP pour protéger et gérer l'accès aux données.
Implémenté des fonctions Cloud Code pour exécuter une logique métier personnalisée côté serveur.
Mis en place l'authentification des utilisateurs avec prise en charge de la vérification par e-mail et des réinitialisations de mot de passe.
Géré les téléchargements de fichiers et la récupération, avec des contrôles de sécurité des fichiers en option.
Planifié des tâches Cloud pour des tâches d'arrière-plan automatisées.
Utilisé des Webhooks pour s'intégrer à des services externes.
Exploré le panneau d'administration Back4App pour la gestion des données.
Avec un solide framework backend Flask qui peut retourner des fichiers de modèle de rendu (si désiré) et une configuration robuste de Back4App, vous êtes maintenant équipé pour développer des applications riches en fonctionnalités, évolutives et sécurisées. 
La ligne de commande les tâches deviennent simples avec méthodes post def des routes qui acceptent des charges utiles JSON.
Prochaines étapes
Construire une application Flask prête pour la production en étendant ce backend pour gérer des modèles de données plus complexes, des stratégies de mise en cache et des optimisations de performance.
Intégrer des fonctionnalités avancées telles que des flux d'authentification spécialisés, un contrôle d'accès basé sur les rôles ou des API externes (comme des passerelles de paiement).
Consulter la documentation officielle de Back4app pour des plongées plus profondes dans la sécurité avancée, le réglage des performances et l'analyse des journaux.
Explorer d'autres tutoriels sur les applications de chat en temps réel, les tableaux de bord IoT ou les services basés sur la localisation. Vous pouvez combiner les techniques apprises ici avec des API tierces pour créer des applications complexes et réelles.
﻿
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment créer un backend pour Django ?
Comment construire un backend pour Python ?