Quickstarters
Comment construire un backend pour Blazor ?

39min
Introduction
Dans ce tutoriel, vous apprendrez à construire un backend complet pour une application Blazor 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 (Live Queries) - pour créer un backend sécurisé, évolutif et robuste qui communique sans problème avec votre frontend Blazor.
Tirer parti des services backend robustes de Back4app avec Blazor, un framework ASP.NET Core pour construire des interfaces web interactives en utilisant C#, permet aux développeurs d'accélérer le développement backend.
Que vous construisiez une application Blazor Server ou une application Blazor WebAssembly, l'intégration transparente avec Back4app peut réduire considérablement le temps de développement tout en garantissant une logique métier côté serveur de haute qualité.
À la fin de ce tutoriel, vous aurez construit une structure backend sécurisée adaptée à une application web full stack utilisant Blazor.
Vous obtiendrez des informations sur la façon de gérer les opérations de données, d'appliquer des contrôles de sécurité et de mettre en œuvre des fonctions cloud, rendant votre application web Blazor robuste et évolutive.
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 Blazor de base
Vous pouvez le configurer en installant le dernier SDK .NET depuis Microsoft et en créant un nouveau projet Blazor en utilisant des modèles comme dotnet new blazorserver ou dotnet new blazorwasm.
.NET SDK (version 6 ou supérieure) installé
Assurez-vous d'avoir le SDK .NET pour construire et exécuter des applications Blazor.
Familiarité avec C# et les concepts Blazor
Documentation officielle de Blazor.
Si vous êtes nouveau dans Blazor, consultez la documentation officielle ou un tutoriel pour débutants avant de commencer.
Assurez-vous d'avoir ces prérequis avant de commencer pour garantir une expérience de tutoriel fluide.
Étape 1 – Configuration du projet Back4app
Créer un nouveau projet
La première étape pour construire votre backend Blazor sur Back4app consiste à créer un nouveau projet. Si vous n'en avez pas encore créé un, 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, “Blazor-Backend-Tutorial”).
﻿
Cette configuration garantit que chaque fois que vous utilisez Parse dans votre application Blazor, il est préconfiguré pour se connecter à votre instance Back4app spécifique.
En complétant cette étape, vous avez établi une connexion sécurisée entre votre frontend Blazor et le backend Back4app, ouvrant la voie à l'exécution d'opérations sur la base de données, la gestion des utilisateurs, et plus encore.
Étape 2 – Configuration de la base de données
Sauvegarde et requête de données
Avec votre projet Back4app configuré et le SDK Parse intégré dans votre application Blazor, vous pouvez maintenant commencer à sauvegarder et à récupérer des données. La manière la plus simple de créer un enregistrement est d'utiliser le ParseObject classe :
SomeDataService.cs
using Parse;
using System.Threading.Tasks;

public class SomeDataService {
    public async Task<ParseObject> CreateTodoItemAsync(string title, bool isCompleted) {
        var todo = new ParseObject("Todo");
        todo["title"] = title;
        todo["isCompleted"] = isCompleted;

        try {
            await todo.SaveAsync();
            Console.WriteLine("Todo saved successfully: " + todo.ObjectId);
            return todo;
        } catch (Exception ex) {
            Console.WriteLine("Error saving Todo: " + ex.Message);
            return null;
        }
    }

    public async Task<IList<ParseObject>> FetchTodosAsync() {
        var query = new ParseQuery<ParseObject>("Todo");
        try {
            var results = await query.FindAsync();
            Console.WriteLine("Fetched Todo items: " + results.Count);
            return results;
        } catch (Exception ex) {
            Console.WriteLine("Error fetching Todos: " + ex.Message);
            return null;
        }
    }
}
using Parse;
using System.Threading.Tasks;

public class SomeDataService {
    public async Task<ParseObject> CreateTodoItemAsync(string title, bool isCompleted) {
        var todo = new ParseObject("Todo");
        todo["title"] = title;
        todo["isCompleted"] = isCompleted;

        try {
            await todo.SaveAsync();
            Console.WriteLine("Todo saved successfully: " + todo.ObjectId);
            return todo;
        } catch (Exception ex) {
            Console.WriteLine("Error saving Todo: " + ex.Message);
            return null;
        }
    }

    public async Task<IList<ParseObject>> FetchTodosAsync() {
        var query = new ParseQuery<ParseObject>("Todo");
        try {
            var results = await query.FindAsync();
            Console.WriteLine("Fetched Todo items: " + results.Count);
            return results;
        } catch (Exception ex) {
            Console.WriteLine("Error fetching Todos: " + ex.Message);
            return null;
        }
    }
}
﻿
Alternativement, vous pouvez utiliser les points de terminaison de l'API REST de Back4app pour les opérations.
Conception de schéma et types de données
Par défaut, Parse permet la création de schémas à la volée, mais vous pouvez également définir vos classes et types de données dans le tableau de bord Back4app pour plus de contrôle.
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 estComplété (Boolean).
Créer une nouvelle classe
﻿
Lors de la requête, incluez les données du pointeur :
SomeDataService.cs (continuation)
public async Task<IList<ParseObject>> FetchTodosWithCategoryAsync() {
    var query = new ParseQuery<ParseObject>("Todo").Include("category");
    try {
        var todosWithCategory = await query.FindAsync();
        return todosWithCategory;
    } catch (Exception ex) {
        Console.WriteLine("Error fetching todos with category: " + ex.Message);
        return null;
    }
}
public async Task<IList<ParseObject>> FetchTodosWithCategoryAsync() {
    var query = new ParseQuery<ParseObject>("Todo").Include("category");
    try {
        var todosWithCategory = await query.FindAsync();
        return todosWithCategory;
    } catch (Exception ex) {
        Console.WriteLine("Error fetching todos with category: " + ex.Message);
        return null;
    }
}
﻿
Requêtes en direct
Pour des mises à jour en temps réel dans une application Blazor Server, envisagez d'utiliser la connexion SignalR pour les Requêtes en direct. Bien que le SDK .NET de Parse prenne en charge les Requêtes en direct, les intégrer directement dans une application Blazor peut nécessiter une configuration supplémentaire avec SignalR pour la communication en temps réel.
Activer les Requêtes en direct dans votre tableau de bord Back4app sous les Paramètres du serveur. Assurez-vous que « Requêtes en direct » est activé.
Configurer le client de Requête en direct dans .NET si nécessaire. Cependant, pour les applications Blazor, tirer parti de SignalR pourrait être plus idiomatique pour les connexions côté serveur.
En raison de la complexité de la configuration des Requêtes en direct dans Blazor et des limitations potentielles du SDK .NET de Parse dans Blazor WebAssembly, vous devrez peut-être mettre en œuvre un service côté serveur qui relie les Requêtes en direct de Parse avec les clients SignalR.
Étape 3 – Application de la sécurité avec les ACL et les CLP
Mécanisme de sécurité Back4app
Back4app prend la sécurité au sérieux en fournissant des Listes de contrôle d'accès (ACL) et des Permissions au niveau de la classe (CLP). Ces fonctionnalités vous permettent de restreindre qui peut lire ou écrire des données sur une base par objet ou par classe, garantissant que seuls les utilisateurs autorisés peuvent modifier vos données.
﻿
Listes de Contrôle d'Accès (ACL)
Un ACL est appliqué à des objets individuels pour déterminer quels utilisateurs, rôles ou le public peuvent effectuer des opérations de lecture/écriture. Par exemple :
SomeDataService.cs (ACL example)
public async Task<ParseObject> CreatePrivateTodoAsync(string title, ParseUser ownerUser) {
    var todo = new ParseObject("Todo");
    todo["title"] = title;

    // Create an ACL granting read/write access only to the owner
    var acl = new ParseACL(ownerUser);
    acl.PublicReadAccess = false;
    acl.PublicWriteAccess = false;
    todo.ACL = acl;

    try {
        await todo.SaveAsync();
        return todo;
    } catch (Exception ex) {
        Console.WriteLine("Error saving private todo: " + ex.Message);
        return null;
    }
}
public async Task<ParseObject> CreatePrivateTodoAsync(string title, ParseUser ownerUser) {
    var todo = new ParseObject("Todo");
    todo["title"] = title;

    // Create an ACL granting read/write access only to the owner
    var acl = new ParseACL(ownerUser);
    acl.PublicReadAccess = false;
    acl.PublicWriteAccess = false;
    todo.ACL = acl;

    try {
        await todo.SaveAsync();
        return todo;
    } catch (Exception ex) {
        Console.WriteLine("Error saving private todo: " + ex.Message);
        return null;
    }
}
﻿
Lorsque vous enregistrez l'objet, il a un ACL qui empêche quiconque, sauf l'utilisateur spécifié, de le lire ou de le modifier.
Permissions au Niveau de la Classe (CLP)
Les CLP régissent les permissions par défaut d'une classe entière, telles que si la classe est lisible ou modifiable publiquement, ou si seuls certains rôles peuvent y accéder.
Allez sur 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 l'onglet des Permissions au Niveau de la Classe.
Configurez vos paramètres par défaut, tels que “Nécessite une authentification” pour la lecture ou l'écriture, ou “Aucun accès” pour le public.
Ces permissions établissent la base, tandis que les ACL affinent les permissions pour des objets individuels. Un modèle de sécurité robuste combine généralement à la fois les CLP (restrictions larges) et les ACL (restrictions fines par objet). Pour plus d'informations, allez à Directives de Sécurité de l'Application.﻿
Étape 4 – Écriture et Déploiement des Fonctions Cloud
Le Cloud Code est une fonctionnalité de l'environnement Parse Server qui vous permet d'exécuter du code JavaScript personnalisé côté serveur - sans avoir besoin de gérer vos serveurs ou votre infrastructure. 
En écrivant du Cloud Code, vous pouvez étendre votre backend Back4app avec une logique métier supplémentaire, des validations, des déclencheurs et des intégrations qui s'exécutent de manière sécurisée et efficace sur le Parse Server.
Comment ça fonctionne
Lorsque vous écrivez du Cloud Code, vous placez généralement vos fonctions JavaScript, déclencheurs et tous les modules NPM requis dans un main.js (ou app.js) fichier. 
Ce fichier est ensuite déployé sur votre projet Back4app, qui s'exécute dans l'environnement Parse Server. 
Puisque ces fonctions et déclencheurs s'exécutent sur le serveur, vous pouvez leur faire confiance pour gérer une logique confidentielle, traiter des données sensibles ou effectuer des appels API réservés au backend - des processus que vous ne voudriez peut-être pas exposer directement au client.
Tout le Cloud Code pour votre application Back4app s'exécute à l'intérieur du Parse Server géré par Back4app, donc vous n'avez pas à vous soucier de la maintenance des serveurs, de la mise à l'échelle ou de l'approvisionnement. 
Chaque fois que vous mettez à jour et déployez votre fichier main.js, le serveur Parse en cours d'exécution est mis à jour avec votre dernier code.
Structure du fichier main.js
Un main.js typique pourrait contenir :
Instructions Require pour tous les modules nécessaires (packages NPM, modules Node intégrés ou autres fichiers de code cloud).
Définitions de fonctions Cloud utilisant Parse.Cloud.define().
Déclencheurs tels que Parse.Cloud.beforeSave(), Parse.Cloud.afterSave(), etc.
Modules NPM que vous avez installés (si nécessaire).
main.js
// main.js

// 1. Import necessary modules and other cloud code files
const axios = require('axios');
const report = require('./reports');

// 2. Define a custom Cloud Function
Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

// 3. Example of a beforeSave trigger
Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
// main.js

// 1. Import necessary modules and other cloud code files
const axios = require('axios');
const report = require('./reports');

// 2. Define a custom Cloud Function
Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

// 3. Example of a beforeSave trigger
Parse.Cloud.beforeSave('Todo', (request) => {
  const todo = request.object;
  if (!todo.get('title')) {
    throw new Error('Todo must have a title');
  }
});
﻿
Avec la possibilité d'installer et d'utiliser des modules NPM, le code Cloud devient incroyablement flexible, vous permettant de vous intégrer à des API externes, d'effectuer des transformations de données ou d'exécuter une logique complexe côté serveur.
Cas d'utilisation typiques
Logique métier: Par exemple, agréger des données pour l'analyse ou effectuer des calculs avant de les enregistrer dans la base de données.
Validations de données: Assurez-vous que certains champs sont présents ou qu'un utilisateur a les bonnes autorisations avant d'enregistrer ou de supprimer un enregistrement.
Déclencheurs: Effectuer des actions lorsque les données changent (par exemple, envoyer une notification lorsqu'un utilisateur met à jour son profil).
Intégrations: Se connecter à des API ou services tiers.
Application de la sécurité: Valider et assainir les entrées pour appliquer la sécurité avant d'effectuer des opérations sensibles.
Déployez votre fonction
Voici une simple fonction Cloud Code qui calcule la longueur d'une chaîne de texte envoyée par le client :
main.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 };
});
﻿
Déploiement via le Back4app CLI:
1 - Installer le CLI :
Pour Linux/MacOS :
Bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
﻿
Pour Windows :
Téléchargez le b4a.exe fichier depuis la page des versions.
2 - Configurez votre clé de compte:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
3 - Déployez votre code cloud :
Bash
b4a deploy
b4a deploy
﻿
Déploiement via le tableau de bord:
Dans le tableau de bord de votre application, allez à Cloud Code > Functions.
Copiez/collez la fonction dans l'éditeur main.js.
Cliquez sur Déployer.
Appeler votre fonction
Depuis Blazor en utilisant le SDK .NET de Parse :
SomeDataService.cs (calling function)
public async Task<int?> GetTextLengthAsync(string text) {
    try {
        var result = await ParseCloud.CallFunctionAsync<Dictionary<string, object>>("calculateTextLength", 
            new Dictionary<string, object> { { "text", text } });
        if(result != null && result.ContainsKey("length"))
            return Convert.ToInt32(result["length"]);
        return null;
    } catch(Exception ex) {
        Console.WriteLine("Error calling cloud function: " + ex.Message);
        return null;
    }
}
public async Task<int?> GetTextLengthAsync(string text) {
    try {
        var result = await ParseCloud.CallFunctionAsync<Dictionary<string, object>>("calculateTextLength", 
            new Dictionary<string, object> { { "text", text } });
        if(result != null && result.ContainsKey("length"))
            return Convert.ToInt32(result["length"]);
        return null;
    } catch(Exception ex) {
        Console.WriteLine("Error calling cloud function: " + ex.Message);
        return null;
    }
}
﻿
Vous pouvez également l'appeler via REST ou GraphQL comme indiqué dans le tutoriel ReactJS.
Étape 5 – Configuration de l'authentification des utilisateurs
Authentification des utilisateurs dans Back4app
Back4app utilise la classe Parse User comme base pour l'authentification. Par défaut, Parse gère le hachage des mots de passe, les jetons de session et le stockage sécurisé. Cela signifie que vous n'avez pas à configurer manuellement des flux de sécurité complexes.
Configuration de l'authentification des utilisateurs
Dans une application Blazor, vous pouvez créer un nouvel utilisateur avec :
AuthService.cs
using Parse;
using System.Threading.Tasks;

public class AuthService {
    public async Task SignUpUserAsync(string username, string password, string email) {
        var user = new ParseUser() {
            Username = username,
            Password = password,
            Email = email
        };

        try {
            await user.SignUpAsync();
            Console.WriteLine("User signed up successfully!");
        } catch (Exception ex) {
            Console.WriteLine("Error signing up user: " + ex.Message);
        }
    }

    public async Task LogInUserAsync(string username, string password) {
        try {
            var user = await ParseUser.LogInAsync(username, password);
            Console.WriteLine("User logged in: " + user.Username);
        } catch (Exception ex) {
            Console.WriteLine("Error logging in user: " + ex.Message);
        }
    }
}
using Parse;
using System.Threading.Tasks;

public class AuthService {
    public async Task SignUpUserAsync(string username, string password, string email) {
        var user = new ParseUser() {
            Username = username,
            Password = password,
            Email = email
        };

        try {
            await user.SignUpAsync();
            Console.WriteLine("User signed up successfully!");
        } catch (Exception ex) {
            Console.WriteLine("Error signing up user: " + ex.Message);
        }
    }

    public async Task LogInUserAsync(string username, string password) {
        try {
            var user = await ParseUser.LogInAsync(username, password);
            Console.WriteLine("User logged in: " + user.Username);
        } catch (Exception ex) {
            Console.WriteLine("Error logging in user: " + ex.Message);
        }
    }
}
﻿
Gestion des sessions
Après une connexion réussie, Parse crée un jeton de session qui est stocké dans l'objet utilisateur. Dans votre application Blazor, vous pouvez accéder à l'utilisateur actuellement connecté :
SomeComponent.razor.cs
var currentUser = ParseUser.CurrentUser;
if (currentUser != null) {
    Console.WriteLine("Currently logged-in user: " + currentUser.Username);
} else {
    Console.WriteLine("No user is logged in");
}
var currentUser = ParseUser.CurrentUser;
if (currentUser != null) {
    Console.WriteLine("Currently logged-in user: " + currentUser.Username);
} else {
    Console.WriteLine("No user is logged in");
}
﻿
Parse gère automatiquement les sessions basées sur des jetons en arrière-plan, mais vous pouvez également les gérer ou les révoquer manuellement. Pour se déconnecter :
AuthService.cs (logout)
public async Task LogOutAsync() {
    await ParseUser.LogOutAsync();
    Console.WriteLine("User logged out");
}
public async Task LogOutAsync() {
    await ParseUser.LogOutAsync();
    Console.WriteLine("User logged out");
}
﻿
Intégration de la connexion sociale
Back4app et Parse peuvent s'intégrer avec des fournisseurs OAuth populaires, tels que Google ou Facebook. 
La configuration peut varier et implique souvent une configuration côté serveur ou des packages supplémentaires. Consultez la Documentation de connexion sociale pour des instructions détaillées.
Étant donné que les applications Blazor Server fonctionnent sur ASP.NET Core, vous pourriez intégrer la connexion sociale en utilisant les fournisseurs d'identité ASP.NET Core aux côtés de Parse pour une authentification fluide.
Vérification par e-mail et réinitialisation du mot de passe
Pour activer la vérification par e-mail et la réinitialisation du mot de passe :
Accédez aux paramètres d'e-mail dans votre tableau de bord Back4app.
Activez la vérification par e-mail pour garantir que les nouveaux utilisateurs vérifient la propriété de leurs adresses e-mail.
Configurez l'adresse d'expédition, les modèles d'e-mail et votre domaine personnalisé si désiré.
Ces fonctionnalités améliorent la sécurité des comptes et l'expérience utilisateur en validant la propriété des e-mails par les utilisateurs et en fournissant une méthode de récupération de mot de passe sécurisée.
Étape 6 – Gestion du stockage de fichiers
Téléchargement et récupération de fichiers
Parse inclut la ParseFile classe pour gérer les téléchargements de fichiers, que Back4app stocke en toute sécurité :
FileService.cs
using Parse;
using System;
using System.Threading.Tasks;

public class FileService {
    public async Task<string> UploadImageAsync(byte[] fileData, string fileName) {
        var parseFile = new ParseFile(fileName, fileData);
        try {
            await parseFile.SaveAsync();
            Console.WriteLine("File saved: " + parseFile.Url);
            return parseFile.Url;
        } catch (Exception ex) {
            Console.WriteLine("Error uploading file: " + ex.Message);
            return null;
        }
    }
}
using Parse;
using System;
using System.Threading.Tasks;

public class FileService {
    public async Task<string> UploadImageAsync(byte[] fileData, string fileName) {
        var parseFile = new ParseFile(fileName, fileData);
        try {
            await parseFile.SaveAsync();
            Console.WriteLine("File saved: " + parseFile.Url);
            return parseFile.Url;
        } catch (Exception ex) {
            Console.WriteLine("Error uploading file: " + ex.Message);
            return null;
        }
    }
}
﻿
Pour attacher le fichier à un objet :
FileService.cs (continued)
public async Task<ParseObject> CreatePhotoObjectAsync(byte[] fileData, string fileName) {
    var photo = new ParseObject("Photo");
    var parseFile = new ParseFile(fileName, fileData);
    photo["imageFile"] = parseFile;

    try {
        await photo.SaveAsync();
        return photo;
    } catch (Exception ex) {
        Console.WriteLine("Error creating photo object: " + ex.Message);
        return null;
    }
}
public async Task<ParseObject> CreatePhotoObjectAsync(byte[] fileData, string fileName) {
    var photo = new ParseObject("Photo");
    var parseFile = new ParseFile(fileName, fileData);
    photo["imageFile"] = parseFile;

    try {
        await photo.SaveAsync();
        return photo;
    } catch (Exception ex) {
        Console.WriteLine("Error creating photo object: " + ex.Message);
        return null;
    }
}
﻿
Récupération de l'URL du fichier :
SomeComponent.razor.cs
var imageFile = photo.Get<ParseFile>("imageFile");
var imageUrl = imageFile.Url;
var imageFile = photo.Get<ParseFile>("imageFile");
var imageUrl = imageFile.Url;
﻿
Vous pouvez afficher cette imageUrl dans vos composants Blazor en le définissant comme source d'un <img> tag.
Sécurité des fichiers
Parse Server fournit des configurations flexibles pour gérer la sécurité des téléchargements de fichiers. Utilisez des ACL sur les ParseFiles ou définissez des configurations au niveau du serveur selon vos besoins.
Étape 7 – Planification des tâches avec les Cloud Jobs
Cloud Jobs
Cloud Jobs dans Back4app vous permet de planifier et d'exécuter des tâches de routine sur votre backend - comme nettoyer les anciennes données ou envoyer un e-mail récapitulatif quotidien. Un Cloud Job typique pourrait ressembler à ceci :
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);
  }
});
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);
  }
});
﻿
Déployez votre Cloud Code avec le nouveau job (via CLI ou le tableau de bord).
Allez sur le tableau de bord Back4app > Paramètres de l'application > Paramètres du serveur > Tâches d'arrière-plan.
Planifiez le job pour qu'il s'exécute quotidiennement ou à tout intervalle qui convient à vos besoins.
﻿
Les Cloud Jobs vous permettent d'automatiser la maintenance en arrière-plan ou d'autres processus périodiques sans nécessiter d'intervention manuelle.
Étape 8 – Intégration des Webhooks
Les Webhooks permettent à votre application Back4app d'envoyer des requêtes HTTP à un service externe chaque fois que certains événements se produisent. 
C'est puissant pour s'intégrer à des systèmes tiers comme des passerelles de paiement, des outils de marketing par e-mail ou des plateformes d'analyse.
Accédez à la configuration des Webhooks dans votre tableau de bord Back4app > Plus > WebHooks, puis cliquez sur Ajouter un Webhook.
Configurez un point de terminaison (par exemple, https://your-external-service.com/webhook-endpoint).
Configurez des déclencheurs pour spécifier quels événements dans vos classes Back4app ou fonctions Cloud Code déclencheront le webhook.
Par exemple, si vous souhaitez notifier un canal Slack chaque fois qu'un nouveau Todo est créé :
Créez une application Slack qui accepte les webhooks entrants.
Copiez l'URL du webhook Slack.
Dans votre tableau de bord Back4app, définissez le point de terminaison sur cette URL Slack pour l'événement “Nouvel enregistrement dans la classe Todo.”
Vous pouvez également ajouter des en-têtes HTTP ou des charges utiles personnalisées si nécessaire.
Vous pouvez également définir des Webhooks dans le Cloud Code en effectuant des requêtes HTTP personnalisées dans des déclencheurs comme beforeSave, afterSave.
Étape 9 – Exploration du panneau d'administration Back4app
Le Back4app Admin App est une interface de gestion basée sur le web conçue pour les utilisateurs non techniques afin d'effectuer des opérations CRUD et de gérer des tâches de données courantes sans écrire de code. 
Il fournit une interface centrée sur le modèle, interface conviviale qui rationalise l'administration de la base de données, la gestion des données personnalisées et les opérations de niveau entreprise.
Activation de l'application Admin
Activez en allant dans App Dashboard > Plus > Admin App et en cliquant sur le bouton “Activer l'application Admin”.
Créez un premier utilisateur Admin (nom d'utilisateur/mot de passe), ce qui génère automatiquement un nouveau rôle (B4aAdminUser) et des classes (B4aSetting, B4aMenuItem et B4aCustomField) dans le schéma de votre application.
Choisissez un sous-domaine pour accéder à l'interface d'administration et complétez la configuration.
Connectez-vous en utilisant les identifiants administratifs que vous avez créés pour accéder à votre nouveau tableau de bord de l'application Admin.
Une fois activée, l'application Admin Back4app facilite la visualisation, l'édition ou la suppression d'enregistrements de votre base de données sans nécessiter l'utilisation directe du tableau de bord Parse ou de code backend.
Conclusion
En suivant ce tutoriel complet, vous avez :
Créé un backend sécurisé pour une application Blazor 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 lorsque cela est applicable 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 frontend Blazor solide et un backend Back4app robuste, vous êtes maintenant bien équipé pour développer des applications web riches en fonctionnalités, évolutives et sécurisées.
Continuez à explorer des fonctionnalités plus avancées, intégrez votre logique métier et exploitez la puissance de Back4app pour vous faire gagner d'innombrables heures dans l'administration des serveurs et des bases de données. Bon codage !
Prochaines étapes
Construisez une application Blazor 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égrez 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.
Consultez la documentation officielle de Back4app pour des plongées plus profondes dans la sécurité avancée, l'optimisation des performances et l'analyse des journaux.
Explorez 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. Combinez 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?
Tutoriels Back4app
Comment construire un backend pour htmx ?