Quickstarters
Comment construire un backend pour MacOS ?

46min
Introduction
Dans ce tutoriel, vous apprendrez comment construire un backend pour MacOS en utilisant Back4app et le SDK Parse Swift. 
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 effort avec votre application MacOS.
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. 
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 macOS prête pour la production, ou à intégrer facilement une logique personnalisée et des API tierces selon vos besoins.
Maîtriser cette approche vous permettra de rationaliser vos flux de travail et d'apprendre à construire un backend pour MacOS rapidement et efficacement.
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.
Un environnement de développement MacOS (Xcode)
Vous pouvez installer Xcode depuis le Mac App Store.
Swift Package Manager ou CocoaPods
Pour installer le SDK Parse Swift. Documentation de Parse Swift.﻿
Connaissances de base en Swift et développement d'applications macOS
Documentation officielle d'Apple
Une familiarité avec SwiftUI ou AppKit est utile.
Assurez-vous d'avoir tous ces prérequis en place avant de commencer. Avoir votre projet Back4app configuré et votre environnement de développement macOS local prêt vous aidera à suivre plus facilement.
Étape 1 – Configuration du projet Back4app
Créer un nouveau projet
La première étape pour construire votre backend macOS 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, “macOS-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.
Connecter le SDK Parse Swift
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 macOS à Back4app implique d'installer le SDK Parse Swift 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” de votre application pour trouver votre ID d'application et Clé client (ou clientKey). Vous trouverez également l' URL du serveur Parse (souvent au format https://parseapi.back4app.com).
﻿
Installez le SDK Parse Swift dans votre projet macOS :
Si vous utilisez Swift Package Manager:
Swift
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
﻿
Si vous utilisez CocoaPods, ajoutez ceci à votre Podfile:
Ruby
pod 'ParseSwiftOG'
pod 'ParseSwiftOG'
﻿
Initialisez Parse dans votre application macOS (par exemple, dans AppDelegate.swift si vous utilisez AppKit, ou dans une struct SwiftUI @main si vous construisez une application SwiftUI) :
Swift
import ParseSwift
import SwiftUI

@main
struct MyMacOSApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APPLICATION_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
import ParseSwift
import SwiftUI

@main
struct MyMacOSApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APPLICATION_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
﻿
En complétant cette étape, vous avez établi une connexion sécurisée entre votre interface macOS (UI) et le backend Back4app. Toutes les requêtes et transactions de données sont sécurisées via ce SDK, 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
Sauvegarde et requête de données
Avec votre projet Back4app configuré et le SDK Parse Swift intégré dans votre application macOS, vous pouvez maintenant commencer à sauvegarder et à récupérer des données. La manière la plus simple de créer un objet est de définir une structure conforme à ParseObject puis d'appeler save():
Swift
struct Todo: ParseObject {
    // ParseObject required properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}

func createTodoItem(title: String, isCompleted: Bool) async {
    var todo = Todo()
    todo.title = title
    todo.isCompleted = isCompleted
    do {
        try await todo.save()
        print("Todo saved successfully.")
    } catch {
        print("Error saving Todo: \(error)")
    }
}

func fetchTodos() async -> [Todo] {
    let query = Todo.query()
    do {
        return try await query.find()
    } catch {
        print("Error fetching Todos: \(error)")
        return []
    }
}
struct Todo: ParseObject {
    // ParseObject required properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}

func createTodoItem(title: String, isCompleted: Bool) async {
    var todo = Todo()
    todo.title = title
    todo.isCompleted = isCompleted
    do {
        try await todo.save()
        print("Todo saved successfully.")
    } catch {
        print("Error saving Todo: \(error)")
    }
}

func fetchTodos() async -> [Todo] {
    let query = Todo.query()
    do {
        return try await query.find()
    } catch {
        print("Error fetching Todos: \(error)")
        return []
    }
}
﻿
Alternativement, vous pouvez utiliser l'API REST ou GraphQL de Back4app:
Curl
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
﻿
Back4app fournit également une interface 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
    }
  }
}
﻿
Ces options diverses vous permettent d'intégrer les opérations de données de la manière qui convient le mieux à votre processus de développement, que ce soit par le SDK Parse Swift, REST ou GraphQL.
Conception de schéma et types de données
Par défaut, Parse permet la création de schéma à 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 isCompleted (Boolean).
Créer une nouvelle classe
﻿
Back4app prend en charge divers types de données : String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, et Polygon. Vous pouvez choisir le type approprié pour chaque champ, ou laisser Parse créer automatiquement ces colonnes lorsque vous enregistrez pour la première fois un objet depuis votre application macOS.
Créer une colonne
﻿
Back4app propose un Agent IA qui peut vous aider à concevoir votre modèle de données :
Ouvrez l'Agent IA depuis votre tableau de bord d'application ou dans le menu.
Décrivez votre modèle de données dans un langage simple (par exemple, “Veuillez créer une nouvelle application ToDo sur back4app avec un schéma de classe complet.”).
Laissez l'Agent IA créer le schéma pour vous.
﻿
Données relationnelles
Si vous avez des données relationnelles—disons, un Category objet qui pointe vers plusieurs Todo éléments—vous pouvez utiliser Pointers ou Relations dans Parse Swift:
Swift
struct Category: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Custom fields
    var name: String?
}

struct Todo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var title: String?
    var category: Pointer<Category>?
}

func createTaskForCategory(categoryObjectId: String, title: String) async {
    let pointer = Pointer<Category>(objectId: categoryObjectId)
    var todo = Todo()
    todo.title = title
    todo.category = pointer
    do {
        try await todo.save()
        print("Todo linked to category")
    } catch {
        print("Error creating Task with category relationship: \(error)")
    }
}

func fetchTodosWithCategory() async {
    let query = Todo.query().include("category")
    do {
        let todos = try await query.find()
        print("Fetched Todo items with Category: \(todos)")
    } catch {
        print("Error fetching Todos: \(error)")
    }
}
struct Category: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Custom fields
    var name: String?
}

struct Todo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var title: String?
    var category: Pointer<Category>?
}

func createTaskForCategory(categoryObjectId: String, title: String) async {
    let pointer = Pointer<Category>(objectId: categoryObjectId)
    var todo = Todo()
    todo.title = title
    todo.category = pointer
    do {
        try await todo.save()
        print("Todo linked to category")
    } catch {
        print("Error creating Task with category relationship: \(error)")
    }
}

func fetchTodosWithCategory() async {
    let query = Todo.query().include("category")
    do {
        let todos = try await query.find()
        print("Fetched Todo items with Category: \(todos)")
    } catch {
        print("Error fetching Todos: \(error)")
    }
}
﻿
Requêtes en direct
Pour des mises à jour en temps réel, Back4app fournit des Live Queries. En activant les requêtes en direct dans votre tableau de bord Back4app, vous pouvez vous abonner aux changements dans une classe spécifique depuis votre application macOS.
Activer les requêtes en direct dans votre tableau de bord Back4app sous les Paramètres du serveur de votre application.
Initialiser les requêtes en direct dans le code (le client de requête en direct Swift est encore en évolution, mais vous pouvez utiliser des approches communautaires ou attendre les mises à jour officielles de Parse Swift).
src/parseConfig.swift
// Example (subject to support in Parse Swift):
// Live Query’s subdomain:
// ParseSwift.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN_HERE.b4a.io")!
// Example (subject to support in Parse Swift):
// Live Query’s subdomain:
// ParseSwift.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN_HERE.b4a.io")!
﻿
Une fois abonné, vous recevrez des notifications chaque fois qu'un nouveau Todo est créé, mis à jour ou supprimé. Cela est particulièrement précieux pour les applications de bureau collaboratives ou hautement interactives où plusieurs utilisateurs ou processus doivent voir les dernières données instantanément.
Étape 3 – Appliquer 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 Access Control Lists (ACLs) et Class-Level Permissions (CLPs). 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.
﻿
Access Control Lists (ACLs)
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, si votre application macOS a un concept de “tâches privées” pour l'utilisateur actuellement connecté :
Swift
import ParseSwift

func createPrivateTodo(title: String) async {
    guard let currentUser = User.current else { return }

    var todo = Todo()
    todo.title = title

    // Create an ACL granting read/write access only to the owner
    var acl = ParseACL()
    acl.setReadAccess(currentUser, value: true)
    acl.setWriteAccess(currentUser, value: true)

    todo.ACL = acl

    do {
        try await todo.save()
        print("Private Todo saved")
    } catch {
        print("Error saving private Todo: \(error)")
    }
}
import ParseSwift

func createPrivateTodo(title: String) async {
    guard let currentUser = User.current else { return }

    var todo = Todo()
    todo.title = title

    // Create an ACL granting read/write access only to the owner
    var acl = ParseACL()
    acl.setReadAccess(currentUser, value: true)
    acl.setWriteAccess(currentUser, value: true)

    todo.ACL = acl

    do {
        try await todo.save()
        print("Private Todo saved")
    } catch {
        print("Error saving private Todo: \(error)")
    }
}
﻿
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.
Modifier l'ACL
﻿
Class-Level Permissions (CLPs)
Les CLPs 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 à 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” pour lire ou écrire, ou “Aucun accès” pour le public.
﻿
Étape 4 – Écriture et déploiement des fonctions cloud
Le code cloud 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 propres serveurs ou infrastructure. En écrivant du code cloud, 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 serveur Parse.
Comment ça fonctionne
Lorsque vous écrivez du code cloud, vous placez généralement vos fonctions JavaScript, déclencheurs et tous les modules NPM requis dans un main.js fichier. Vous déployez ensuite ce fichier dans votre projet Back4app, et il s'exécute dans l'environnement Parse Server. Cela vous permet de garder la logique sensible côté serveur.
Cas d'utilisation typiques:
Logique métier: Calculs ou transformations avant d'enregistrer des données
Validations de données: Assurez-vous que certains champs répondent à des critères
Déclencheurs: Effectuer des actions lorsque les données changent
Intégrations: Connectez-vous à des API externes (par exemple, paiements, notifications)
Exemple de fonction
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 CLI Back4app
Installer le CLI:
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
﻿
Configurer votre clé de compte:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
Déployer votre code cloud:
Bash
b4a deploy
b4a deploy
﻿
Appeler votre fonction
Depuis macOS en utilisant Swift:
Swift
import ParseSwift

func getTextLength(text: String) async {
    do {
        let result = try await ParseCloud.callFunction("calculateTextLength", with: ["text": text])
        if let resultDict = result as? [String: Any],
           let length = resultDict["length"] as? Int {
            print("Text length: \(length)")
        }
    } catch {
        print("Error calling cloud function: \(error)")
    }
}
import ParseSwift

func getTextLength(text: String) async {
    do {
        let result = try await ParseCloud.callFunction("calculateTextLength", with: ["text": text])
        if let resultDict = result as? [String: Any],
           let length = resultDict["length"] as? Int {
            print("Text length: \(length)")
        }
    } catch {
        print("Error calling cloud function: \(error)")
    }
}
﻿
Vous pouvez également l'appeler via REST ou GraphQL, de la même manière que dans d'autres frameworks.
Étape 5 – Configuration de l'authentification des utilisateurs
Authentification des utilisateurs dans Back4app
Back4app utilise la ParseUser classe 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é, donc vous n'avez pas à configurer manuellement des flux de sécurité complexes.
Configuration de l'authentification des utilisateurs
Dans une application macOS, vous pouvez créer un nouvel utilisateur avec:
Swift
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Default properties
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpUser(username: String, password: String, email: String) async {
    var newUser = User()
    newUser.username = username
    newUser.password = password
    newUser.email = email
    do {
        newUser = try await newUser.signUp()
        print("User signed up successfully!")
    } catch {
        print("Error signing up user: \(error)")
    }
}

func logInUser(username: String, password: String) async {
    do {
        let user = try await User.login(username: username, password: password)
        print("User logged in: \(user)")
    } catch {
        print("Error logging in user: \(error)")
    }
}
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Default properties
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpUser(username: String, password: String, email: String) async {
    var newUser = User()
    newUser.username = username
    newUser.password = password
    newUser.email = email
    do {
        newUser = try await newUser.signUp()
        print("User signed up successfully!")
    } catch {
        print("Error signing up user: \(error)")
    }
}

func logInUser(username: String, password: String) async {
    do {
        let user = try await User.login(username: username, password: password)
        print("User logged in: \(user)")
    } catch {
        print("Error logging in user: \(error)")
    }
}
﻿
Via REST, une connexion pourrait ressembler à:
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
﻿
Gestion de session
Après une connexion réussie, Parse crée un jeton de session. Vous pouvez accéder à l'utilisateur actuellement connecté :
Swift
if let currentUser = User.current {
    print("Currently logged-in user: \(currentUser.username ?? "No username")")
} else {
    print("No user is logged in")
}
if let currentUser = User.current {
    print("Currently logged-in user: \(currentUser.username ?? "No username")")
} else {
    print("No user is logged in")
}
﻿
Déconnexion :
Swift
do {
    try await User.logout()
} catch {
    print("Error logging out: \(error)")
}
do {
    try await User.logout()
} catch {
    print("Error logging out: \(error)")
}
﻿
Intégration de la connexion sociale
Vous pouvez intégrer des fournisseurs populaires comme Google, Apple ou Facebook en configurant authData. Les instructions détaillées varient, alors référez-vous à Documentation sur la connexion sociale.﻿
Vérification de l'email 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 de messagerie dans votre tableau de bord Back4app.
Activer la vérification par e-mail.
Configurer l'adresse d'expédition, les modèles d'e-mail et votre domaine personnalisé si désiré.
Cela améliore la sécurité du compte en validant les e-mails des utilisateurs et en fournissant une méthode de récupération de mot de passe.
É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é :
Swift
func uploadFile(data: Data) async -> ParseFile? {
    let file = ParseFile(name: "doc.txt", data: data)
    do {
        let savedFile = try await file.save()
        print("File saved:", savedFile.url ?? "No URL")
        return savedFile
    } catch {
        print("Error uploading file:", error)
        return nil
    }
}
func uploadFile(data: Data) async -> ParseFile? {
    let file = ParseFile(name: "doc.txt", data: data)
    do {
        let savedFile = try await file.save()
        print("File saved:", savedFile.url ?? "No URL")
        return savedFile
    } catch {
        print("Error uploading file:", error)
        return nil
    }
}
﻿
Attachez-le à un objet :
Swift
struct Photo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var imageFile: ParseFile?
}

func createPhotoObject(file: ParseFile) async {
    var photo = Photo()
    photo.imageFile = file
    do {
        try await photo.save()
        print("Photo object saved!")
    } catch {
        print("Error saving photo:", error)
    }
}
struct Photo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var imageFile: ParseFile?
}

func createPhotoObject(file: ParseFile) async {
    var photo = Photo()
    photo.imageFile = file
    do {
        try await photo.save()
        print("Photo object saved!")
    } catch {
        print("Error saving photo:", error)
    }
}
﻿
Sécurité des fichiers
Vous pouvez configurer la sécurité de téléchargement de fichiers dans les paramètres de votre serveur Parse. Par exemple, contrôler quels utilisateurs peuvent télécharger ou supprimer des fichiers. Gardez à l'esprit que si vous partagez l'URL du fichier, toute personne ayant cette URL peut y accéder à moins que vous n'ayez défini des règles plus strictes côté serveur.
É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 essentielles pour une gestion sécurisée des utilisateurs. Nous en avons déjà parlé dans Étape 5, mais pour rappel :
Activez ces fonctionnalités dans le tableau de bord Back4app (Paramètres de l'e-mail).
Configurez les modèles d'e-mail « Activer la vérification par e-mail » et « Réinitialisation du mot de passe ».
Testez le flux depuis votre application macOS.
Étape 8 – Planification des tâches avec les Cloud Jobs
Cloud Jobs
Cloud Jobs vous permet de planifier et d'exécuter des tâches de routine sur votre backend, comme l'envoi d'e-mails périodiques ou le nettoyage des données. Par exemple :
JS
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);
  query.lessThan('createdAt', cutoff);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
// main.js
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);
  query.lessThan('createdAt', cutoff);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
﻿
Déployez votre Cloud Code avec le nouveau travail.
Allez au tableau de bord Back4app > Paramètres de l'application > Paramètres du serveur > Travaux en arrière-plan.
Planifiez le travail (par exemple, quotidiennement).
Planification d'un travail Cloud
﻿
Étape 9 – 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.
Naviguez vers la configuration des Webhooks dans votre tableau de bord Back4app > Plus > WebHooks.
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.
Ajout d'un Webhook
﻿
Par exemple, si vous souhaitez notifier 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.”
Étape 10 – Explorer le 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. Elle fournit une centrée sur le modèle, conviviale interface 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'Admin App
Activez en allant à App Dashboard > More > Admin App et en cliquant sur “Activer l'Admin App.”
Activer l'Admin App
﻿
Créer un premier utilisateur administrateur, ce qui génère automatiquement un nouveau rôle (B4aAdminUser) et des classes pertinentes dans le schéma de votre application.
﻿
Choisissez un sous-domaine pour accéder à l'interface administrateur et complétez la configuration.
﻿
Connectez-vous avec les identifiants administratifs que vous avez créés pour accéder à votre nouveau tableau de bord Admin App.
﻿
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 du code backend.
Conclusion
En suivant ce tutoriel complet, vous avez :
Créé un backend sécurisé pour une application macOS 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 (Requêtes en direct) 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 une authentification utilisateur 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 front-end macOS solide et un backend Back4app robuste, vous êtes maintenant bien équipé pour développer des applications de bureau 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.
Prochaines étapes
Construire une application macOS 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).
Consultez 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.
Explorez d'autres tutoriels sur la communication 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?
Comment construire un backend pour tvOS ?
Comment créer un backend pour iOS ?