Quickstarters
Comment créer un backend pour Swift ?

45min
Introduction
Dans ce tutoriel, vous apprendrez à construire un backend complet pour une application Swift 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, les requêtes en temps réel (Live Queries), et plus encore—pour créer un backend sécurisé, évolutif et robuste qui communique sans problème avec votre application cliente basée sur Swift.
En tirant parti de la configuration rapide et de l'environnement intuitif de Back4App, vous réduirez considérablement le temps et les efforts nécessaires 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 cruciales, 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 ce service backend fondamental en une application prête pour la production ou à intégrer facilement une logique personnalisée et des API tierces selon vos besoins.
Vous verrez comment travailler avec une plateforme BaaS peut transformer le développement backend en une expérience plus fluide, surtout lors de la création d'un backend rapide ou de toute autre application backend. 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.
Un environnement de développement Swift
Vous pouvez utiliser Xcode comme votre IDE pour créer des applications iOS ou macOS en utilisant Swift. Assurez-vous d'avoir une version stable récente de Xcode installée sur votre machine.
Familiarité avec le langage de programmation Swift
Si vous êtes nouveau dans Swift, consultez la Documentation Swift officielle ou un tutoriel pour débutants avant de commencer.
Parse Swift SDK
Si vous utilisez CocoaPods, ajoutez pod 'ParseSwiftOG' à votre Podfile. Ou si vous utilisez Swift Package Manager, ajoutez .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0") à vos dépendances. Lisez-en plus dans les Docs Parse Swift.
Assurez-vous d'avoir tous ces prérequis en place avant de commencer. Avoir votre projet Back4App configuré et votre environnement Swift local prêt vous aidera à suivre plus facilement.
Étape 1 – Créer un nouveau projet sur Back4App et se connecter
La première étape pour construire votre backend Swift sur Back4App consiste à créer un nouveau projet. Ce projet est la base de toutes les configurations backend discutées dans ce tutoriel. Swift peut se connecter sans problème à votre nouveau backend en utilisant le SDK Parse Swift. Voyons comment.
Créer un nouveau projet
Connectez-vous à votre compte Back4App.
Cliquez sur le bouton “Nouvelle application” dans votre tableau de bord Back4App.
Nommez votre application (par exemple, “Swift-Backend-Tutorial”).
﻿
Après la création, vous verrez la nouvelle application listée dans votre tableau de bord. C'est ici que vous configurerez votre base de données, vos fonctions cloud et d'autres paramètres cruciaux pour votre application backend.
Connectez le SDK Parse Swift
Back4App est alimenté par la plateforme Parse, qui fournit la base de votre base de données, des mises à jour en temps réel, l'authentification, et plus encore. Votre application Swift peut se connecter à Back4App en installant et en initialisant le SDK Parse Swift.
Récupérez vos clés Parse:
Dans votre tableau de bord Back4App, allez dans les “Paramètres de l'application” ou “Sécurité & Clés” de votre application pour trouver votre ID d'application et Clé client. Vous verrez également votre URL du serveur Parse (souvent https://parseapi.back4app.com).
﻿
Installez le SDK Parse Swift:
Gestionnaire de paquets Swift (Recommandé):
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")
]
﻿
CocoaPods:
Ruby
pod 'ParseSwiftOG'
pod 'ParseSwiftOG'
﻿
Initialisez Parse dans votre application:
Vous pouvez faire cela dans le point d'entrée principal de votre projet Swift (par exemple, AppDelegate.swift ou la structure SwiftUI @main . Par exemple :
Swift
import SwiftUI
import ParseSwift

@main
struct MyApp: App {
    init() {
        // Replace placeholders with your Back4App credentials
        ParseSwift.initialize(
            applicationId: "YOUR_APPLICATION_ID",
            clientKey: "YOUR_CLIENT_KEY",
            serverURL: URL(string: "https://parseapi.back4app.com")!
        )
    }

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

@main
struct MyApp: App {
    init() {
        // Replace placeholders with your Back4App credentials
        ParseSwift.initialize(
            applicationId: "YOUR_APPLICATION_ID",
            clientKey: "YOUR_CLIENT_KEY",
            serverURL: URL(string: "https://parseapi.back4app.com")!
        )
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
﻿
Avec cette configuration, votre client Swift peut maintenant envoyer des requêtes sécurisées à Back4App. Vous avez établi une connexion robuste qui simplifie les opérations de données sans nécessiter d'appels REST ou GraphQL manuels (bien que vous puissiez toujours les utiliser si vous le souhaitez).
Étape 2 – Configuration de la base de données
Dans cette étape, vous allez configurer votre base de données backend sur Back4App et voir comment gérer les données depuis votre code Swift. Back4App utilise le modèle de données Parse, vous permettant de stocker des objets dans des structures semblables à des classes. Swift peut interagir facilement avec ces classes via le SDK Parse Swift.
Création d'un modèle de données
Accédez à la section “Base de données” dans votre tableau de bord Back4App.
Créez une nouvelle classe (par exemple, “Todo”).
Ajoutez des colonnes pour les données dont vous avez besoin, telles que “title” (String) et “isCompleted” (Boolean).
Créer une nouvelle classe
﻿
Vous pouvez également laisser le SDK Parse Swift créer ces colonnes automatiquement la première fois que vous enregistrez un objet. Dans tous les cas, votre schéma doit correspondre aux données que vous stockez afin que votre application puisse les gérer sans problème.
Créer un modèle de données en utilisant l'agent IA
Back4App fournit un agent IA qui peut vous aider à concevoir votre modèle de données :
Ouvrez l'agent IA depuis le tableau de bord ou le menu de votre application.
Décrivez votre modèle de données en langage naturel. Par exemple : “Veuillez créer un nouveau projet Swift avec un schéma de classe ToDo.”
Laissez l'agent IA créer le schéma pour vous automatiquement.
﻿
Lire et écrire des données : SDK Parse Swift
En utilisant le SDK Parse Swift, vous pouvez créer une structure conforme à ParseObject pour représenter vos données. Par exemple, si vous avez une classe Todo :
Swift
import ParseSwift

struct Todo: ParseObject {
    // ParseObject protocol properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

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

struct Todo: ParseObject {
    // ParseObject protocol properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}
﻿
Créez un objet Todo et enregistrez-le:
Swift
var newTodo = Todo()
newTodo.title = "Buy groceries"
newTodo.isCompleted = false

Task {
    do {
        let saved = try await newTodo.save()
        print("Saved:", saved)
    } catch {
        print("Error saving Todo:", error)
    }
}
var newTodo = Todo()
newTodo.title = "Buy groceries"
newTodo.isCompleted = false

Task {
    do {
        let saved = try await newTodo.save()
        print("Saved:", saved)
    } catch {
        print("Error saving Todo:", error)
    }
}
﻿
Interroger tous les éléments Todo:
Swift
Task {
    do {
        let todos = try await Todo.query().find()
        print("Todos:", todos)
    } catch {
        print("Error fetching:", error)
    }
}
Task {
    do {
        let todos = try await Todo.query().find()
        print("Todos:", todos)
    } catch {
        print("Error fetching:", error)
    }
}
﻿
Lecture et écriture de données : API REST
Si vous préférez les requêtes HTTP standard, vous pouvez utiliser l'API REST. Par exemple, pour créer un nouveau Todo :
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": "Walk the dog", "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": "Walk the dog", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Lecture et écriture de données : API GraphQL
GraphQL est également pris en charge. Voici un exemple de mutation pour créer un Todo :
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Finish homework"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Finish homework"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Travailler avec des requêtes en direct
Si votre application Swift a besoin de mises à jour en temps réel, Back4App prend en charge les requêtes en direct. Pour iOS:
Activer les requêtes en direct dans les Paramètres du serveur de votre application.
Connectez-vous en spécifiant Parse.liveQueryServerURL dans votre application:
Swift
Parse.configuration.serverURL = URL(string: "https://parseapi.back4app.com")!
Parse.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN.b4a.io")!
Parse.configuration.serverURL = URL(string: "https://parseapi.back4app.com")!
Parse.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN.b4a.io")!
﻿
Abonnez-vous aux mises à jour en direct:
Swift
let subscription = Todo.query()
.subscribeCallback { subscriptionState in
    switch subscriptionState {
    case .subscribed(let querySubscription):
        print("Subscribed to Todo changes!")
    default:
        break
    }
}
let subscription = Todo.query()
.subscribeCallback { subscriptionState in
    switch subscriptionState {
    case .subscribed(let querySubscription):
        print("Subscribed to Todo changes!")
    default:
        break
    }
}
﻿
Maintenant, chaque fois qu'un Todo est créé, mis à jour ou supprimé, vous recevrez des mises à jour en temps réel. Cela est particulièrement utile pour les fonctionnalités collaboratives ou sensibles au temps dans le développement de votre backend Swift.
Étape 3 – Application de la sécurité avec les ACL et les CLP
Qu'est-ce que les ACL et les CLP ?
Back4App utilise les Listes de Contrôle d'Accès (ACL) et les Permissions au Niveau de la Classe (CLP) pour sécuriser vos données. Les ACL vous permettent de définir des permissions par objet, tandis que les CLP définissent des règles d'accès par défaut pour toute une classe.
﻿
Permissions au Niveau de la Classe
Dans le tableau de bord Back4App :
Allez à Base de données et sélectionnez une classe (par exemple, “Todo”).
Ouvrez les Permissions au Niveau de la Classe.
Configurez les restrictions sur la lecture, l'écriture ou l'accès public.
Listes de Contrôle d'Accès (ACL)
Lors de la création ou de la mise à jour d'un ParseObject en Swift, vous pouvez définir un ACL. Par exemple :
Swift
var acl = ParseACL()
// Only let the current user read and write
acl.setReadAccess(userId: "CURRENT_USER_ID", value: true)
acl.setWriteAccess(userId: "CURRENT_USER_ID", value: true)

var todo = Todo()
todo.ACL = acl
var acl = ParseACL()
// Only let the current user read and write
acl.setReadAccess(userId: "CURRENT_USER_ID", value: true)
acl.setWriteAccess(userId: "CURRENT_USER_ID", value: true)

var todo = Todo()
todo.ACL = acl
﻿
Cela garantit que seul l'utilisateur spécifié peut lire ou modifier cet objet. La combinaison des ACL et des CLP forme un modèle de sécurité robuste et stratifié pour les données de votre application.
Étape 4 – Écriture de fonctions Cloud Code
Pourquoi Cloud Code ?
Le Cloud Code vous permet d'exécuter une logique Swift côté serveur (ou JavaScript si vous utilisez le style original de Cloud Code de Parse) sans exposer de secrets au client. C'est parfait pour les validations, les déclencheurs, les tâches planifiées, et plus encore.
Exemple de fonction
Voici un exemple basé sur JavaScript, mais vous pouvez également travailler en TypeScript ou appeler depuis Swift. Dans votre dossier Cloud Code de Back4App, créez main.js:
JS
Parse.Cloud.define("getTasksCount", async (request) => {
  const query = new Parse.Query("Todo")
  const count = await query.count({ useMasterKey: true })
  return count
})

Parse.Cloud.beforeSave("Todo", async (request) => {
  const todo = request.object
  if (!todo.get("title")) {
    throw "Cannot save a Todo without a title."
  }
})
Parse.Cloud.define("getTasksCount", async (request) => {
  const query = new Parse.Query("Todo")
  const count = await query.count({ useMasterKey: true })
  return count
})

Parse.Cloud.beforeSave("Todo", async (request) => {
  const todo = request.object
  if (!todo.get("title")) {
    throw "Cannot save a Todo without a title."
  }
})
﻿
Vous voudrez peut-être installer des modules NPM en les incluant dans votre package.json fichier, puis en les appelant dans main.js. Une fois déployé, vous pouvez invoquer ces fonctions depuis votre code Swift en utilisant callFunction.
Déploiement
Déployez votre Cloud Code via :
Bash
b4a deploy
b4a deploy
﻿
Vous pouvez également déployer via le tableau de bord Back4App en allant à Cloud Code > Functions. Collez votre code dans l'éditeur en ligne et cliquez sur Déployer.
Appel depuis Swift
Swift
Task {
    do {
        let result = try await ParseCloud.callFunction("getTasksCount", with: [String: Any]())
        print("Count:", result)
    } catch {
        print("Error calling cloud function:", error)
    }
}
Task {
    do {
        let result = try await ParseCloud.callFunction("getTasksCount", with: [String: Any]())
        print("Count:", result)
    } catch {
        print("Error calling cloud function:", error)
    }
}
﻿
Étape 5 – Configuration de l'authentification
Activation de l'authentification des utilisateurs
Dans le Tableau de bord, vous verrez une classe par défaut _User pour les comptes utilisateurs. Activez tout fournisseur d'authentification supplémentaire (Apple, Facebook, Google, etc.) dans les Paramètres d'authentification de votre application si nécessaire.
Inscription et connexion (Swift)
Swift
struct User: ParseUser {
    var objectId: String?
    var username: String?
    var email: String?
    var password: String?
    var emailVerified: Bool?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
}

// Sign up
Task {
    do {
        var newUser = User()
        newUser.username = "alice"
        newUser.password = "p@ssword"
        let signedUp = try await newUser.signup()
        print("User signed up:", signedUp)
    } catch {
        print("Error signing up:", error)
    }
}

// Log in
Task {
    do {
        let user = try await User.login(username: "alice", password: "p@ssword")
        print("Logged in user:", user)
    } catch {
        print("Error logging in:", error)
    }
}
struct User: ParseUser {
    var objectId: String?
    var username: String?
    var email: String?
    var password: String?
    var emailVerified: Bool?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
}

// Sign up
Task {
    do {
        var newUser = User()
        newUser.username = "alice"
        newUser.password = "p@ssword"
        let signedUp = try await newUser.signup()
        print("User signed up:", signedUp)
    } catch {
        print("Error signing up:", error)
    }
}

// Log in
Task {
    do {
        let user = try await User.login(username: "alice", password: "p@ssword")
        print("Logged in user:", user)
    } catch {
        print("Error logging in:", error)
    }
}
﻿
Connexion sociale
Back4App prend en charge la connexion OAuth avec Google, Apple et Facebook. Configurez ces fournisseurs sur votre page de paramètres d'authentification, et utilisez le code d'intégration Parse Swift pertinent dans votre application Swift (par exemple, ParseFacebookUtils ou ParseAppleUtils) pour gérer les flux d'authentification. Pour plus de détails, consultez la Documentation sur la connexion sociale.
Étape 6 – Gestion du stockage de fichiers
Configuration du stockage de fichiers
Vous pouvez stocker des images, des vidéos ou tout fichier dans Back4App. En Swift, vous avez ParseFile:
Swift
let imageData = Data(/* your image bytes */)
let parseFile = ParseFile(name: "photo.jpg", data: imageData)

Task {
    do {
        let savedFile = try await parseFile.save()
        print("File saved:", savedFile.url ?? "No URL")
    } catch {
        print("Error uploading file:", error)
    }
}
let imageData = Data(/* your image bytes */)
let parseFile = ParseFile(name: "photo.jpg", data: imageData)

Task {
    do {
        let savedFile = try await parseFile.save()
        print("File saved:", savedFile.url ?? "No URL")
    } catch {
        print("Error uploading file:", error)
    }
}
﻿
Ensuite, vous pouvez attacher ce fichier à un ParseObject et l'enregistrer. Récupérez l'URL du fichier pour l'afficher ou le télécharger ailleurs.
Considérations de sécurité
Pour restreindre l'accès aux fichiers, vous pouvez utiliser la configuration des fichiers de Parse Server. Par exemple, vous pourriez autoriser uniquement les utilisateurs authentifiés à télécharger des fichiers ou spécifier des autorisations de lecture/écriture dans votre code Swift.
Étape 7 – Vérification par e-mail et réinitialisation du mot de passe
Pourquoi des e-mails de vérification et de réinitialisation?
Valider l'e-mail d'un utilisateur garantit une boîte aux lettres réelle et active. La réinitialisation du mot de passe aide vos utilisateurs à retrouver en toute sécurité l'accès à leur compte s'ils oublient leurs identifiants.
Configuration dans Back4App
Allez à Paramètres de l'email et activez Vérification de l'email. Modifiez vos modèles d'email pour les flux de vérification et de réinitialisation.
Déclencher une réinitialisation de mot de passe depuis Swift
Swift
Task {
    do {
        try await User.passwordReset(email: "[email protected]")
        print("Password reset email sent!")
    } catch {
        print("Error requesting password reset:", error)
    }
}
Task {
    do {
        try await User.passwordReset(email: "alice@example.com")
        print("Password reset email sent!")
    } catch {
        print("Error requesting password reset:", error)
    }
}
﻿
Étape 8 – Planification des tâches avec les travaux Cloud
Travaux Cloud
Vous pouvez planifier des tâches côté serveur sur Back4App. Par exemple, nettoyer les anciennes données ou envoyer des rapports hebdomadaires. Définissez un travail dans votre code Cloud et planifiez-le via le tableau de bord Back4App.
JS
Parse.Cloud.job("cleanupOldTodos", async (request) => {
  const now = new Date()
  // Example logic: remove todos older than 30 days
  // Use Master Key for privileged operations
})
Parse.Cloud.job("cleanupOldTodos", async (request) => {
  const now = new Date()
  // Example logic: remove todos older than 30 days
  // Use Master Key for privileged operations
})
﻿
Ensuite, dans les Paramètres du serveur de Back4App > Travaux en arrière-plan, vous pouvez le planifier pour qu'il s'exécute quotidiennement ou à tout intervalle.
Planification d'un travail dans le cloud
﻿
Étape 9 – Intégration des Webhooks
Qu'est-ce que les Webhooks ?
Les webhooks permettent à votre application de POST automatiquement des données vers des services externes chaque fois que certains événements se produisent. C'est parfait pour s'intégrer avec Slack, Stripe ou d'autres API tierces.
Configuration
Dans votre tableau de bord Back4App, allez à Plus > Webhooks.
Ajoutez un point de terminaison webhook (par exemple, https://example.com/webhook).
Choisissez des déclencheurs (par exemple, création d'objet dans “Todo”).
Ajout d'un Webhook
﻿
Pour une logique personnalisée, vous pouvez également émettre des requêtes vers des URL externes dans les déclencheurs de Cloud Code :
Avant de sauvegarder le WebHook
﻿
Étape 10 – Explorer le panneau d'administration Back4App
Qu'est-ce que le panneau d'administration ?
L' Application d'administration Back4App est une interface point-and-click pour le personnel non technique ou de support. Elle fournit une interface graphique simple pour effectuer des opérations CRUD sur vos données—idéale pour gérer des données en dehors de votre environnement de développement.
Activation de l'application d'administration
Allez au tableau de bord de l'application > Plus > Application d'administration.
Activez l'application d'administration et choisissez un sous-domaine.
Créez un utilisateur administrateur.
Activer l'application d'administration
﻿
Une fois activée, toute personne disposant des identifiants appropriés peut visualiser et modifier vos données à partir d'une interface web conviviale—aucun code requis.
Conclusion
En suivant ce tutoriel complet, vous avez appris comment construire un backend pour Swift en utilisant Back4App. Plus précisément, vous avez :
Créé un backend sécurisé pour votre application Swift.
Configuré une base de données avec des schémas de classe et des relations de données.
Travaillé avec des requêtes en temps réel (Live Queries) pour des mises à jour immédiates.
Mis en place une sécurité robuste avec des ACL et des CLP.
Utilisé Cloud Code pour exécuter une logique personnalisée côté serveur.
Implémenté l'authentification des utilisateurs avec vérification et réinitialisation de mot de passe.
Géré les téléchargements de fichiers de manière sécurisée.
Planifié des tâches automatisées avec Cloud Jobs.
Appris sur les Webhooks pour intégrer des API externes.
Exploré le panneau d'administration pour la gestion directe des données.
Vous avez maintenant un service backend fonctionnel et évolutif pour votre application Swift—un service qui peut être facilement étendu pour gérer des fonctionnalités plus complexes, se connecter à des services tiers ou s'adapter à un trafic utilisateur plus important. Vous avez également vu de première main comment la combinaison des fonctionnalités BaaS de Back4App et de la syntaxe moderne de Swift peut accélérer le développement backend.
Prochaines étapes
Construire une application Swift prête pour la production en développant votre UI/UX.
Intégrer des fonctionnalités avancées comme une authentification spécialisée (basée sur les rôles, SSO), ou une logique Cloud Code supplémentaire pour des règles spécifiques au domaine.
Consulter la documentation officielle de Back4App pour des plongées plus profondes dans les journaux, l'analyse ou la sécurité avancée.
Explorer d'autres tutoriels sur le chat en temps réel, les tableaux de bord IoT ou les applications basées sur la localisation. Combinez-les avec des API externes pour résoudre des défis du monde réel.
C'est ainsi que l'on construit un backend pour Swift en utilisant Back4App ! Bon codage !
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment construire un backend pour SwiftUI ?
Comment construire un backend pour Kotlin ?