Quickstarters
Comment construire un backend pour Flutter ?

41min
Introduction
Dans ce tutoriel, vous apprendrez comment construire un backend pour Flutter en utilisant Back4app, un backend open source et fiable en tant que service (BaaS). 
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, les API RESTful, les API GraphQL et l'authentification des utilisateurs—dans votre projet Flutter. 
Vous découvrirez également comment gérer les mises à jour en temps réel en utilisant les requêtes en direct. En utilisant les puissants serveurs backend de Back4app, vous pouvez éviter une grande partie de la configuration manuelle et vous concentrer sur la création d'une application Flutter dynamique.
Ce guide montrera aux développeurs Flutter comment configurer une structure backend sécurisée, évolutive et robuste qui communique sans effort avec votre côté client. 
Nous mettrons également en avant les avantages de laisser Back4app gérer les tâches lourdes—comme l'hébergement, l'authentification des utilisateurs et la logique serveur—afin que vous puissiez bénéficier de fonctionnalités telles que l'évolutivité automatique, la sécurité avancée et la maintenance simplifiée. 
Si vous avez un projet Flutter et que vous souhaitez économiser d'innombrables heures de configuration backend, c'est le bon endroit pour commencer.
À la fin de ce tutoriel, vous comprendrez le type de backend que vous pouvez créer avec Back4app et serez prêt à étendre vos services backend pour une application prête pour la production ou à intégrer des fonctionnalités plus complexes, telles que des API externes et une authentification avancée des utilisateurs. 
Commençons!
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 Flutter de base
 Assurez-vous d'avoir le SDK Flutter installé et configuré. Confirmez également que vous avez un IDE (comme Android Studio ou VS Code) configuré pour Flutter.
Environnement de langage de programmation Dart
Généralement, cela est installé avec Flutter. Assurez-vous de pouvoir importer des paquets dart sans erreur.
Familiarité avec les fondamentaux de Flutter
 Documentation officielle de Flutter.
Si vous êtes nouveau dans Flutter, consultez la documentation officielle ou un tutoriel pour débutants avant de commencer.
Assurez-vous d'avoir tous ces prérequis en place. Avoir votre projet Back4app configuré et votre environnement Flutter local configuré 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 Flutter sur Back4app est de 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, “Flutter-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 que nous allons discuter.
Installer et initialiser le SDK Parse dans votre application Flutter
Back4app s'appuie sur la plateforme Parse pour gérer vos données, les mises à jour en temps réel, l'authentification des utilisateurs, et plus encore. Pour connecter votre projet Flutter à Back4app, suivez ces étapes :
Ajoutez le SDK Flutter Parse à votre application :
YAML
dependencies:
  parse_server_sdk_flutter: ^4.0.0
dependencies:
  parse_server_sdk_flutter: ^4.0.0
﻿
Importez le package Parse dans votre main.dart (ou où que vous initialisiez votre application) :
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:flutter/material.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  const keyApplicationId = 'YOUR_APPLICATION_ID';
  const keyParseServerUrl = 'https://parseapi.back4app.com';
  const keyClientKey = 'YOUR_CLIENT_KEY';

  // Initialize Parse with debug set to true
  await Parse().initialize(
    keyApplicationId,
    keyParseServerUrl,
    clientKey: keyClientKey,
    autoSendSessionId: true,
    debug: true, 
  );

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter + Back4App Example',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: const Scaffold(
        body: Center(
          child: Text('Hello from Flutter + Back4App!'),
        ),
      ),
    );
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:flutter/material.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  const keyApplicationId = 'YOUR_APPLICATION_ID';
  const keyParseServerUrl = 'https://parseapi.back4app.com';
  const keyClientKey = 'YOUR_CLIENT_KEY';

  // Initialize Parse with debug set to true
  await Parse().initialize(
    keyApplicationId,
    keyParseServerUrl,
    clientKey: keyClientKey,
    autoSendSessionId: true,
    debug: true, 
  );

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter + Back4App Example',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: const Scaffold(
        body: Center(
          child: Text('Hello from Flutter + Back4App!'),
        ),
      ),
    );
  }
}
﻿
Dans votre tableau de bord Back4app, allez dans la section Sécurité et Clés pour trouver votre ID d'application, Clé client, et URL du serveur Parse. Remplacez les espaces réservés ci-dessus par vos propres identifiants. Avec cette initialisation, chaque demande de votre application Flutter est acheminée en toute sécurité vers votre instance Back4app.
N'oubliez pas que la clé maître ne doit jamais être utilisée du côté client de votre application Flutter. Si vous avez besoin de la clé maître, gardez-la sur le serveur ou dans un environnement sécurisé.
Étape 2 – Configuration de la base de données
Création d'un modèle de données
Une fois que votre application Flutter est connectée à Back4app, vous pouvez commencer à concevoir le schéma de votre base de données. Vous pouvez le faire manuellement depuis le tableau de bord Back4app :
Accédez à la section “Base de données” dans votre tableau de bord.
Créez une nouvelle classe (par exemple, “Todo”), et ajoutez des colonnes pertinentes (par exemple, titre, estComplété).
Créer une nouvelle classe
﻿
Back4app propose également un Agent IA pour aider à la création automatique de schémas :
Ouvrez l'Agent IA depuis votre tableau de bord d'application ou le menu.
Décrivez votre modèle de données en langage simple (par exemple, “Créez une nouvelle application ToDo avec un schéma de classe complet.”).
Laissez l'Agent IA créer le schéma pour vous.
﻿
Cela rationalise la configuration de l'architecture des données. Si vous souhaitez que des champs soient créés automatiquement, vous pouvez simplement commencer à enregistrer des objets depuis votre application—Parse prend en charge la création de schémas à la volée.
Création d'un modèle de données en utilisant l'Agent IA
Si vous choisissez d'utiliser l'Agent IA de Back4app, il vous suffit de fournir une courte description, et il construira ou suggérera un schéma pour vous. C'est un excellent moyen d'accélérer la phase initiale de modélisation des données de votre projet Flutter.
Lecture et écriture de données en utilisant le SDK Flutter Parse
Voici un exemple simple démontrant comment créer et récupérer des objets en utilisant le SDK Flutter Parse.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createTodoItem(String title, bool isCompleted) async {
  final todo = ParseObject('Todo')
    ..set('title', title)
    ..set('isCompleted', isCompleted);

  final response = await todo.save();
  if (response.success && response.result != null) {
    print('Todo saved successfully: ${response.result}');
  } else {
    print('Error saving Todo: ${response.error?.message}');
  }
}

Future<List<ParseObject>?> fetchTodos() async {
  final QueryBuilder<ParseObject> queryTodo =
      QueryBuilder<ParseObject>(ParseObject('Todo'));

  final response = await queryTodo.query();
  if (response.success && response.results != null) {
    print('Fetched Todo items: ${response.results}');
    return response.results as List<ParseObject>;
  } else {
    print('Error fetching Todos: ${response.error?.message}');
    return null;
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createTodoItem(String title, bool isCompleted) async {
  final todo = ParseObject('Todo')
    ..set('title', title)
    ..set('isCompleted', isCompleted);

  final response = await todo.save();
  if (response.success && response.result != null) {
    print('Todo saved successfully: ${response.result}');
  } else {
    print('Error saving Todo: ${response.error?.message}');
  }
}

Future<List<ParseObject>?> fetchTodos() async {
  final QueryBuilder<ParseObject> queryTodo =
      QueryBuilder<ParseObject>(ParseObject('Todo'));

  final response = await queryTodo.query();
  if (response.success && response.results != null) {
    print('Fetched Todo items: ${response.results}');
    return response.results as List<ParseObject>;
  } else {
    print('Error fetching Todos: ${response.error?.message}');
    return null;
  }
}
﻿
Avec cela, vous pouvez interagir directement avec votre base de données Back4app depuis votre application Flutter. Il vous suffit d'appeler createTodoItem('Feed the cat', false) ou fetchTodos() pour écrire et lire des données.
Lecture et écriture de données en utilisant l'API REST
Si vous devez vous intégrer à d'autres services ou si vous préférez une approche plus traditionnelle, vous pouvez toujours utiliser l'API REST de Back4app :
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 propose également un point de terminaison GraphQL :
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
    }
  }
}
﻿
Cela vous donne la flexibilité de construire l'approche qui fonctionne le mieux pour votre application Flutter.
Travailler avec des requêtes en direct
Back4app fournit des requêtes en direct afin que vous puissiez recevoir des mises à jour en temps réel de vos données. Activez les requêtes en direct dans le tableau de bord Back4app (Paramètres du serveur) puis utilisez le client Flutter Parse LiveQuery.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:parse_server_sdk_flutter/live_query.dart';

Future<void> subscribeToTodos() async {
  final liveQuery = LiveQuery();
  final query = QueryBuilder<ParseObject>(ParseObject('Todo'));

  Subscription subscription = await liveQuery.client.subscribe(query);

  subscription.on(LiveQueryEvent.create, (value) {
    print('New Todo created: $value');
  });

  subscription.on(LiveQueryEvent.update, (value) {
    print('Todo updated: $value');
  });

  subscription.on(LiveQueryEvent.delete, (value) {
    print('Todo deleted: $value');
  });
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:parse_server_sdk_flutter/live_query.dart';

Future<void> subscribeToTodos() async {
  final liveQuery = LiveQuery();
  final query = QueryBuilder<ParseObject>(ParseObject('Todo'));

  Subscription subscription = await liveQuery.client.subscribe(query);

  subscription.on(LiveQueryEvent.create, (value) {
    print('New Todo created: $value');
  });

  subscription.on(LiveQueryEvent.update, (value) {
    print('Todo updated: $value');
  });

  subscription.on(LiveQueryEvent.delete, (value) {
    print('Todo deleted: $value');
  });
}
﻿
Avec cet abonnement, vous pouvez écouter les changements de données au fur et à mesure qu'ils se produisent. C'est fantastique pour construire des applications collaboratives où plusieurs utilisateurs voient des mises à jour de données en direct. Une fois le rechargement à chaud déclenché, votre abonnement restera actif à moins que l'application ne redémarre.
Étape 3 – Appliquer la sécurité avec les ACL et les CLP
Qu'est-ce que les ACL et les CLP ?
Back4app utilise des ACL (Listes de Contrôle d'Accès) et des CLP (Permissions au Niveau de la Classe) pour restreindre qui peut lire ou écrire des données à la fois au niveau des objets et des classes. Cette couche garantit que vos données sont protégées contre les accès non autorisés.
Configuration des permissions au niveau de la classe
Dans votre tableau de bord Back4app, allez à Database et sélectionnez une classe (par exemple, “Todo”).
Naviguez vers Class-Level Permissions.
Définissez des valeurs par défaut (par exemple, seuls les utilisateurs authentifiés peuvent créer de nouveaux objets).
﻿
Configuration des ACL dans le code
Vous pouvez également appliquer des ACL au niveau des objets depuis le code Flutter :
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createPrivateTodo(ParseUser ownerUser, String title) async {
  final todo = ParseObject('Todo')..set('title', title);

  final acl = ParseACL(owner: ownerUser);
  acl.setPublicReadAccess(allowed: false);
  acl.setPublicWriteAccess(allowed: false);

  todo.setACL(acl);

  final response = await todo.save();
  if (response.success) {
    print('Private Todo saved.');
  } else {
    print('Error: ${response.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createPrivateTodo(ParseUser ownerUser, String title) async {
  final todo = ParseObject('Todo')..set('title', title);

  final acl = ParseACL(owner: ownerUser);
  acl.setPublicReadAccess(allowed: false);
  acl.setPublicWriteAccess(allowed: false);

  todo.setACL(acl);

  final response = await todo.save();
  if (response.success) {
    print('Private Todo saved.');
  } else {
    print('Error: ${response.error?.message}');
  }
}
﻿
En combinant les CLP et les ACL, vous pouvez vous assurer que seules les bonnes personnes ou rôles peuvent accéder ou modifier des données spécifiques.
Étape 4 – Écriture des fonctions Cloud Code
Pourquoi le Cloud Code ?
Le Cloud Code vous permet d'exécuter une logique côté serveur sans configurer manuellement de serveurs backend. C'est parfait pour valider des données, s'intégrer à des services externes ou appliquer certaines règles dans votre backend en tant que service (BaaS).
Exemple de Fonction
Voici un exemple de Cloud Function qui calcule la longueur d'un texte :
JS
// main.js in your Cloud Code
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js in your Cloud Code
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Vous pouvez déployer ce code via le Back4app CLI ou dans le tableau de bord de votre application sous Cloud Code.
Déploiement
Utilisation de Back4app CLI:
Bash
b4a configure accountkey
b4a deploy
b4a configure accountkey
b4a deploy
﻿
Utilisation du Tableau de bord:
Dans le tableau de bord de votre application, allez à Cloud Code > Functions.
Collez le code JavaScript.
Cliquez sur Déployer.
﻿
Appeler le Cloud Code depuis Flutter
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> getTextLength(String text) async {
  final function = ParseCloudFunction('calculateTextLength');
  final params = <String, dynamic>{'text': text};

  final ParseResponse result = await function.execute(parameters: params);
  if (result.success && result.result != null) {
    print('Text length: ${result.result['length']}');
  } else {
    print('Error calling Cloud Code: ${result.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> getTextLength(String text) async {
  final function = ParseCloudFunction('calculateTextLength');
  final params = <String, dynamic>{'text': text};

  final ParseResponse result = await function.execute(parameters: params);
  if (result.success && result.result != null) {
    print('Text length: ${result.result['length']}');
  } else {
    print('Error calling Cloud Code: ${result.error?.message}');
  }
}
﻿
Cette approche sécurisée garantit que la logique sensible reste sur le serveur, tandis que votre application Flutter effectue simplement des requêtes.
Étape 5 – Configuration de l'authentification
Activer l'authentification des utilisateurs
Back4app utilise la Parse.User classe pour gérer l'inscription et la connexion des utilisateurs. Par défaut, Parse s'occupe du hachage des mots de passe, des jetons de session et du stockage sécurisé.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> signUpUser(String username, String password, String email) async {
  final user = ParseUser(username, password, email);
  final response = await user.signUp();
  if (response.success) {
    print('User signed up successfully!');
  } else {
    print('Sign up error: ${response.error?.message}');
  }
}

Future<void> logInUser(String username, String password) async {
  final user = ParseUser(username, password, null);
  final response = await user.login();
  if (response.success) {
    print('User logged in: ${response.result}');
  } else {
    print('Login error: ${response.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> signUpUser(String username, String password, String email) async {
  final user = ParseUser(username, password, email);
  final response = await user.signUp();
  if (response.success) {
    print('User signed up successfully!');
  } else {
    print('Sign up error: ${response.error?.message}');
  }
}

Future<void> logInUser(String username, String password) async {
  final user = ParseUser(username, password, null);
  final response = await user.login();
  if (response.success) {
    print('User logged in: ${response.result}');
  } else {
    print('Login error: ${response.error?.message}');
  }
}
﻿
Connexion Sociale
Back4app prend en charge les intégrations avec Google, Apple, Facebook, et plus encore. Chaque fournisseur a une approche spécifique et peut nécessiter des bibliothèques supplémentaires (par exemple, pour la connexion Facebook ou Google). Vous pouvez ensuite appeler :
Dart
await ParseUser.loginWith('facebook', <String, dynamic>{
  'id': 'USER_FACEBOOK_ID',
  'access_token': 'FACEBOOK_ACCESS_TOKEN',
  'expiration_date': 'DATE'
});
await ParseUser.loginWith('facebook', <String, dynamic>{
  'id': 'USER_FACEBOOK_ID',
  'access_token': 'FACEBOOK_ACCESS_TOKEN',
  'expiration_date': 'DATE'
});
﻿
Ajustez les paramètres selon la documentation du fournisseur.
Étape 6 – Gestion du stockage de fichiers
Configuration du stockage de fichiers
Vous pouvez stocker des images, des documents ou d'autres fichiers multimédias en utilisant ParseFile. Back4app sécurise ces fichiers et fournit une URL pour les récupérer.
Dart
import 'dart:io';
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:image_picker/image_picker.dart';

Future<void> uploadImage() async {
  final picker = ImagePicker();
  final XFile? pickedFile = await picker.pickImage(source: ImageSource.gallery);
  if (pickedFile == null) {
    print('No file selected.');
    return;
  }

  final parseFile = ParseFile(File(pickedFile.path));
  final response = await parseFile.save();
  if (response.success) {
    print('File saved: ${parseFile.url}');
  } else {
    print('Error uploading file: ${response.error?.message}');
  }
}
import 'dart:io';
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:image_picker/image_picker.dart';

Future<void> uploadImage() async {
  final picker = ImagePicker();
  final XFile? pickedFile = await picker.pickImage(source: ImageSource.gallery);
  if (pickedFile == null) {
    print('No file selected.');
    return;
  }

  final parseFile = ParseFile(File(pickedFile.path));
  final response = await parseFile.save();
  if (response.success) {
    print('File saved: ${parseFile.url}');
  } else {
    print('Error uploading file: ${response.error?.message}');
  }
}
﻿
Considérations de sécurité
Vous pouvez définir qui a accès aux fichiers (public, utilisateurs authentifiés ou restreints) en combinant la sécurité au niveau des fichiers avec des ACL. Cela garantit que vos données de fichiers restent en sécurité.
Étape 7 – Vérification de l'email et réinitialisation du mot de passe
Pourquoi ils sont importants
La vérification de l'email confirme qu'un utilisateur possède l'adresse email fournie, tandis que les flux de réinitialisation de mot de passe améliorent l'expérience utilisateur et la sécurité.
Configuration du tableau de bord
Allez dans les Paramètres de l'email de votre application dans le tableau de bord Back4app.
Activez la vérification par email et la réinitialisation du mot de passe.
Configurez les modèles d'email ou votre domaine personnalisé si nécessaire.
Ces paramètres permettent à votre application Flutter de gérer automatiquement les vérifications de propriété des utilisateurs et la récupération de mot de passe.
Mise en œuvre dans Flutter
Dart
final user = ParseUser('testuser', 'password123', '[email protected]');
final signUpResponse = await user.signUp();
if (signUpResponse.success) {
  // The user will receive a verification email
}

// For password reset
final resetResponse = await ParseUser.requestPasswordReset('[email protected]');
if (resetResponse.success) {
  print('Reset email sent successfully!');
}
final user = ParseUser('testuser', 'password123', 'test@example.com');
final signUpResponse = await user.signUp();
if (signUpResponse.success) {
  // The user will receive a verification email
}

// For password reset
final resetResponse = await ParseUser.requestPasswordReset('test@example.com');
if (resetResponse.success) {
  print('Reset email sent successfully!');
}
﻿
Étape 8 – Planification des tâches avec les Cloud Jobs
Cloud Jobs
Vous voudrez peut-être planifier des tâches récurrentes (comme nettoyer les anciennes données ou envoyer des emails périodiques). Les Cloud Jobs vous permettent de faire cela :
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.`;
});
﻿
Déployez ce code, puis allez à Paramètres de l'application > Paramètres du serveur > Tâches d'arrière-plan dans votre tableau de bord Back4app pour le programmer.
Planification d'un travail dans le cloud
﻿
Étape 9 – Intégration des Webhooks
Qu'est-ce que les Webhooks ?
Les Webhooks permettent à votre application Back4app d'envoyer des requêtes HTTP à un service externe lorsque certains événements se produisent (comme l'enregistrement d'un nouvel objet). C'est idéal pour s'intégrer à des outils tiers.
Allez à Plus > WebHooks dans votre tableau de bord Back4app et Ajouter un Webhook.
Définissez votre point de terminaison et vos déclencheurs (par exemple, “Nouvel enregistrement dans Todo”).
Ajout d'un Webhook
﻿
Vous pouvez également configurer manuellement des webhooks dans le code cloud en effectuant des requêtes HTTP dans les déclencheurs beforeSave ou afterSave.
Avant de sauvegarder le WebHook
﻿
Étape 10 – Explorer le panneau d'administration Back4App
Où le trouver
L' Application d'administration Back4app est une interface conviviale qui permet aux membres de l'équipe non techniques de gérer les données (opérations CRUD, tâches de données, etc.) sans avoir besoin d'ouvrir le tableau de bord Parse.
Allez à Tableau de bord de l'application > Plus > Application d'administration.
Cliquez sur Activer l'application d'administration.
Activer l'application d'administration
﻿
Vous allez créer un utilisateur administrateur, choisir un sous-domaine et vous connecter avec les nouvelles informations d'identification créées. L'application d'administration aide à des examens et modifications rapides des données.
Conclusion
Dans ce tutoriel, vous avez appris comment construire un backend pour Flutter en utilisant Back4app et le SDK Parse Flutter. 
Vous avez créé des classes, stocké des données, configuré des requêtes en temps réel, appliqué la sécurité avec des ACL et des CLP, écrit des fonctions Cloud, programmé des tâches, intégré des webhooks et exploré le panneau d'administration de Back4app. 
Cette approche accélère le développement en vous permettant de vous concentrer sur le côté client de Flutter plutôt que sur la configuration complexe du serveur.
La chaîne finale que vous avez maintenant est un backend fonctionnel et sécurisé qui exploite des API RESTful, l'authentification des utilisateurs et une manipulation facile des données. 
Vous pouvez intégrer des fonctionnalités plus avancées à tout moment—comme des fonctions Cloud supplémentaires, des appels d'API externes ou des rôles personnalisés. 
Prochaines étapes
Rendre prêt pour la production: Implémentez un cache avancé, des analyses ou des contrôles d'accès basés sur les rôles.
Étendre votre application: Intégrez des services tiers ou construisez plus de fonctions Cloud pour une logique métier spécialisée.
Consulter la documentation de Back4app: Explorez la sécurité avancée, l'optimisation des performances, l'analyse des journaux, et plus encore.
En savoir plus: Consultez des tutoriels pour des applications de chat en direct, des services basés sur la localisation, ou des structures de données plus complexes. Combinez-les avec votre projet Flutter pour des cas d'utilisation réels.
En continuant à affiner cette configuration, vous transformerez votre application Flutter en une solution puissante et évolutive construite sur un service backend robuste. Bon codage!
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour Objective-C ?
Comment construire un backend pour Gatsby ?