Quickstarters
Comment construire un backend pour Kotlin ?

39min
Introduction
Dans ce tutoriel, vous apprendrez à construire un backend complet pour une application Android (écrite en Kotlin) en utilisant Back4App.
Nous allons passer en revue l'intégration des fonctionnalités essentielles de Back4App—y compris 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 Android.
Vous verrez également comment la configuration rapide et l'environnement intuitif de Back4App 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 prête pour la production, ou à incorporer facilement une logique personnalisée et des API tierces selon vos besoins.
Prérequis
Pour compléter ce tutoriel, vous aurez besoin de :
Un compte Back4app et un nouveau projet Back4app
 Commencer avec Back4app.
Si vous n'avez pas de compte, vous pouvez en créer un gratuitement. Suivez le guide ci-dessus pour préparer votre projet.
Environnement de développement Android/Kotlin de base
 Assurez-vous d'avoir Android Studio installé sur votre machine. Vous pouvez suivre la documentation officielle de configuration d'Android Studio si vous ne l'avez pas encore configuré.
Un minimum d'Android 4.0 ou supérieur dans la configuration Gradle de votre application
Typiquement, vous définirez cela dans votre minSdkVersion dans le build.gradle de votre module.
Familiarité avec Kotlin et les concepts de base d'Android
 Documentation pour développeurs Android.
Si vous êtes nouveau dans Android ou Kotlin, consultez la documentation officielle ou un tutoriel pour débutants avant de commencer.
Assurez-vous d'avoir tous ces prérequis en place avant de commencer. Avoir votre projet Back4app configuré et votre environnement Android 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 Android sur Back4app consiste à 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, “Android-Kotlin-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
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. L'intégration de votre application Android avec Back4App implique d'ajouter les dépendances du SDK Android Parse à vos fichiers Gradle et de les 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. Vous trouverez également l' URL du serveur Parse (souvent au format https://parseapi.back4app.com).
﻿
Ajoutez le SDK Parse à vos build.gradle fichiers:
Dans votre build.gradle racine (niveau projet):
Text
allprojects {
    repositories {
        maven { url "https://jitpack.io" }
    }
}
allprojects {
    repositories {
        maven { url "https://jitpack.io" }
    }
}
﻿
Dans votre build.gradle au niveau du module (généralement app/build.gradle):
Text
dependencies {
    implementation "com.github.parse-community.Parse-SDK-Android:parse:latest.version.here"
}
dependencies {
    implementation "com.github.parse-community.Parse-SDK-Android:parse:latest.version.here"
}
﻿
Initialiser Parse dans votre application Android:
Créer une Application personnalisée (par exemple, App.kt) si vous n'en avez pas déjà une :
Kotlin
package com.example.app

import android.app.Application
import com.parse.Parse
import com.parse.ParseInstallation

class App : Application() {
    override fun onCreate() {
        super.onCreate()

        // Initialize Parse
        Parse.initialize(
            Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")  // from Back4App Dashboard
                .clientKey("YOUR_CLIENT_KEY")  // from Back4App Dashboard
                .server("https://parseapi.back4app.com/")
                .build()
        )

        // (Optional) Track statistics around app opens
        ParseInstallation.getCurrentInstallation().saveInBackground()
    }
}
package com.example.app

import android.app.Application
import com.parse.Parse
import com.parse.ParseInstallation

class App : Application() {
    override fun onCreate() {
        super.onCreate()

        // Initialize Parse
        Parse.initialize(
            Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")  // from Back4App Dashboard
                .clientKey("YOUR_CLIENT_KEY")  // from Back4App Dashboard
                .server("https://parseapi.back4app.com/")
                .build()
        )

        // (Optional) Track statistics around app opens
        ParseInstallation.getCurrentInstallation().saveInBackground()
    }
}
﻿
Ensuite, ouvrez votre AndroidManifest.xml et enregistrez la Application personnalisée :
XML
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.app">

    <application
        android:name=".App"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:usesCleartextTraffic="true"
        ... >
        ...
    </application>

</manifest>
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.app">

    <application
        android:name=".App"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:usesCleartextTraffic="true"
        ... >
        ...
    </application>

</manifest>
﻿
En complétant cette étape, vous avez établi une connexion sécurisée entre votre interface Android (Kotlin) et le backend Back4App. Toutes les demandes et transactions de données sont acheminées de manière sécurisée 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 intégré dans votre application Android, vous pouvez maintenant commencer à enregistrer et à récupérer des données. Ci-dessous un exemple utilisant Kotlin pour créer et récupérer des données.
Kotlin
import com.parse.ParseObject
import com.parse.ParseQuery
import com.parse.SaveCallback
import com.parse.ParseException

// Example: Create a Todo item
fun createTodoItem(title: String, isCompleted: Boolean) {
    val todo = ParseObject("Todo")
    todo.put("title", title)
    todo.put("isCompleted", isCompleted)

    todo.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("Todo saved successfully")
        } else {
            println("Error saving Todo: ${e.localizedMessage}")
        }
    }
}

// Example: Query all Todo items
fun fetchTodos() {
    val query = ParseQuery<ParseObject>("Todo")
    query.findInBackground { results, e ->
        if (e == null) {
            println("Fetched Todo items: ${results.size}")
        } else {
            println("Error fetching Todos: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseObject
import com.parse.ParseQuery
import com.parse.SaveCallback
import com.parse.ParseException

// Example: Create a Todo item
fun createTodoItem(title: String, isCompleted: Boolean) {
    val todo = ParseObject("Todo")
    todo.put("title", title)
    todo.put("isCompleted", isCompleted)

    todo.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("Todo saved successfully")
        } else {
            println("Error saving Todo: ${e.localizedMessage}")
        }
    }
}

// Example: Query all Todo items
fun fetchTodos() {
    val query = ParseQuery<ParseObject>("Todo")
    query.findInBackground { results, e ->
        if (e == null) {
            println("Fetched Todo items: ${results.size}")
        } else {
            println("Error fetching Todos: ${e.localizedMessage}")
        }
    }
}
﻿
Alternativement, vous pouvez utiliser les points de terminaison de 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
﻿
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 via le SDK Parse, REST ou GraphQL.
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 isCompleted (Boolean).
Créer une nouvelle classe
﻿
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.
﻿
Utiliser l'agent IA peut vous faire gagner du temps lors de la configuration de votre architecture de données et garantir la cohérence de votre application.
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. Par exemple, ajouter un pointeur à un Category:
Kotlin
// Linking a Todo to a Category with a pointer
fun createTaskForCategory(categoryObjectId: String, title: String) {
    val todo = ParseObject("Todo")
    val categoryPointer = ParseObject("Category")
    categoryPointer.objectId = categoryObjectId

    todo.put("title", title)
    todo.put("category", categoryPointer)

    todo.saveInBackground { e ->
        if (e == null) {
            println("Created Task with category relationship")
        } else {
            println("Error creating Task: ${e.localizedMessage}")
        }
    }
}
// Linking a Todo to a Category with a pointer
fun createTaskForCategory(categoryObjectId: String, title: String) {
    val todo = ParseObject("Todo")
    val categoryPointer = ParseObject("Category")
    categoryPointer.objectId = categoryObjectId

    todo.put("title", title)
    todo.put("category", categoryPointer)

    todo.saveInBackground { e ->
        if (e == null) {
            println("Created Task with category relationship")
        } else {
            println("Error creating Task: ${e.localizedMessage}")
        }
    }
}
﻿
Lorsque vous interrogez, vous pouvez également inclure des données de pointeur :
Kotlin
val query = ParseQuery.getQuery<ParseObject>("Todo")
query.include("category")
query.findInBackground { todos, e ->
    if (e == null) {
        println("Fetched ${todos.size} todos with category data")
    }
}
val query = ParseQuery.getQuery<ParseObject>("Todo")
query.include("category")
query.findInBackground { todos, e ->
    if (e == null) {
        println("Fetched ${todos.size} todos with category data")
    }
}
﻿
Cet include("category") appel récupère les détails de la catégorie avec chaque Todo, rendant vos données relationnelles facilement accessibles.
Requêtes en direct
Pour des mises à jour en temps réel, Back4app fournit des Live Queries. Vous pouvez vous abonner aux changements dans une classe spécifique depuis votre application Android :
Activer les Requêtes en direct dans votre tableau de bord Back4App sous les Paramètres du serveur de votre application.
Initialiser une souscription de Requête en direct dans votre code :
Kotlin
import com.parse.ParseLiveQueryClient
import com.parse.ParseQuery
import com.parse.SubscriptionHandling
...

val parseLiveQueryClient = ParseLiveQueryClient.Factory.getClient()
val parseQuery = ParseQuery<ParseObject>("Todo")

val subscriptionHandling: SubscriptionHandling<ParseObject> =
    parseLiveQueryClient.subscribe(parseQuery)

subscriptionHandling.handleEvent(SubscriptionHandling.Event.CREATE) { queryTodo, todo ->
    println("New Todo created: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.UPDATE) { queryTodo, todo ->
    println("Todo updated: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.DELETE) { queryTodo, todo ->
    println("Todo deleted: ${todo.getString("title")}")
}
import com.parse.ParseLiveQueryClient
import com.parse.ParseQuery
import com.parse.SubscriptionHandling
...

val parseLiveQueryClient = ParseLiveQueryClient.Factory.getClient()
val parseQuery = ParseQuery<ParseObject>("Todo")

val subscriptionHandling: SubscriptionHandling<ParseObject> =
    parseLiveQueryClient.subscribe(parseQuery)

subscriptionHandling.handleEvent(SubscriptionHandling.Event.CREATE) { queryTodo, todo ->
    println("New Todo created: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.UPDATE) { queryTodo, todo ->
    println("Todo updated: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.DELETE) { queryTodo, todo ->
    println("Todo deleted: ${todo.getString("title")}")
}
﻿
Chaque fois qu'un nouveau Todo est créé, mis à jour ou supprimé, le client reçoit un rappel en temps réel—parfait pour les applications collaboratives ou dynamiques.
É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 autorisations 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)
Une ACL est appliquée à des objets individuels pour déterminer quels utilisateurs, rôles ou le public peuvent effectuer des opérations de lecture/écriture. Par exemple:
Kotlin
fun createPrivateTodo(title: String, ownerUser: ParseObject) {
    val todo = ParseObject("Todo")
    todo.put("title", title)

    // Create an ACL granting read/write access only to the owner
    val acl = com.parse.ParseACL(ownerUser)
    acl.publicReadAccess = false
    acl.publicWriteAccess = false

    todo.acl = acl

    todo.saveInBackground { e ->
        if (e == null) {
            println("Saved private todo")
        } else {
            println("Error: ${e.localizedMessage}")
        }
    }
}
fun createPrivateTodo(title: String, ownerUser: ParseObject) {
    val todo = ParseObject("Todo")
    todo.put("title", title)

    // Create an ACL granting read/write access only to the owner
    val acl = com.parse.ParseACL(ownerUser)
    acl.publicReadAccess = false
    acl.publicWriteAccess = false

    todo.acl = acl

    todo.saveInBackground { e ->
        if (e == null) {
            println("Saved private todo")
        } else {
            println("Error: ${e.localizedMessage}")
        }
    }
}
﻿
Permissions au niveau de la classe (CLPs)
Les CLPs régissent les permissions par défaut d'une classe entière, telles que si la classe est lisible ou écrivable publiquement.
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.
﻿
Étape 4 – Écriture de fonctions Cloud Code
Le Cloud Code vous permet d'exécuter du code JavaScript personnalisé similaire à Kotlin sur Parse Server (téléchargé en tant que .js fichiers), sans avoir besoin de gérer l'infrastructure du serveur. Cela est idéal pour la logique métier, les validations, les déclencheurs et les appels d'API externes.
Comment ça fonctionne
Vous placez généralement les fonctions JavaScript, les déclencheurs et tous les modules npm requis dans un main.js fichier. Ce fichier est déployé dans votre projet Back4App et s'exécute dans l'environnement Parse Server.
Cas d'utilisation typiques
Logique métier
Validations de données
Déclencheurs (comme beforeSave, afterSave)
Application de la sécurité
Intégrations avec des API tierces
Déployez votre fonction
Voici une fonction Cloud Code simple :
main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Déploiement via le Back4App CLI:
Bash
# For Linux/Mac
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

# For Windows, download the .exe from the releases page
# For Linux/Mac
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

# For Windows, download the .exe from the releases page
﻿
Configurez et déployez:
Bash
b4a configure accountkey
b4a deploy
b4a configure accountkey
b4a deploy
﻿
Appeler votre fonction
Depuis votre code Android (Kotlin) via le SDK Parse :
Kotlin
import com.parse.ParseCloud
import com.parse.FunctionCallback
import com.parse.ParseException

fun callTextLengthFunction(someText: String) {
    val params = hashMapOf("text" to someText)
    ParseCloud.callFunctionInBackground<Map<String, Any>>("calculateTextLength", params) { result, e ->
        if (e == null) {
            val length = result["length"] as Int
            println("Text length: $length")
        } else {
            println("Error calling Cloud Code: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseCloud
import com.parse.FunctionCallback
import com.parse.ParseException

fun callTextLengthFunction(someText: String) {
    val params = hashMapOf("text" to someText)
    ParseCloud.callFunctionInBackground<Map<String, Any>>("calculateTextLength", params) { result, e ->
        if (e == null) {
            val length = result["length"] as Int
            println("Text length: $length")
        } else {
            println("Error calling Cloud Code: ${e.localizedMessage}")
        }
    }
}
﻿
Vous pouvez également l'appeler via REST ou GraphQL de manière similaire.
Étape 5 – Configuration de l'authentification
Authentification des utilisateurs dans Back4App
Back4App utilise la classe Parse User pour l'authentification. Parse gère le hachage sécurisé des mots de passe, les jetons de session, et plus encore par défaut.
Configuration de l'authentification des utilisateurs
En Kotlin, vous pouvez créer un nouvel utilisateur :
Kotlin
import com.parse.ParseUser
...
fun signUpUser(username: String, password: String, email: String) {
    val user = ParseUser()
    user.username = username
    user.setPassword(password)
    user.email = email

    user.signUpInBackground { e ->
        if (e == null) {
            println("User signed up successfully!")
        } else {
            println("Error signing up user: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseUser
...
fun signUpUser(username: String, password: String, email: String) {
    val user = ParseUser()
    user.username = username
    user.setPassword(password)
    user.email = email

    user.signUpInBackground { e ->
        if (e == null) {
            println("User signed up successfully!")
        } else {
            println("Error signing up user: ${e.localizedMessage}")
        }
    }
}
﻿
Connectez un utilisateur existant :
Kotlin
fun logInUser(username: String, password: String) {
    ParseUser.logInInBackground(username, password) { user, e ->
        if (user != null && e == null) {
            println("User logged in: ${user.username}")
        } else {
            println("Error logging in: ${e?.localizedMessage}")
        }
    }
}
fun logInUser(username: String, password: String) {
    ParseUser.logInInBackground(username, password) { user, e ->
        if (user != null && e == null) {
            println("User logged in: ${user.username}")
        } else {
            println("Error logging in: ${e?.localizedMessage}")
        }
    }
}
﻿
Les connexions sociales telles que Google, Facebook et Apple peuvent également être intégrées. Consultez les Docs de connexion sociale pour plus de détails.
Gestion des sessions
Parse gère automatiquement les jetons de session. Vous pouvez accéder à l'utilisateur actuel :
Kotlin
val currentUser = ParseUser.getCurrentUser()
if (currentUser != null) {
    println("Currently logged-in user: ${currentUser.username}")
} else {
    println("No user is logged in")
}
val currentUser = ParseUser.getCurrentUser()
if (currentUser != null) {
    println("Currently logged-in user: ${currentUser.username}")
} else {
    println("No user is logged in")
}
﻿
Et se déconnecter :
Kotlin
ParseUser.logOut()
ParseUser.logOut()
﻿
É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 :
Kotlin
import com.parse.ParseFile
import com.parse.ParseException

fun uploadImage(file: java.io.File) {
    val bytes = file.readBytes()
    val parseFile = ParseFile(file.name, bytes)

    parseFile.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("File saved: ${parseFile.url}")
        } else {
            println("Error uploading file: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseFile
import com.parse.ParseException

fun uploadImage(file: java.io.File) {
    val bytes = file.readBytes()
    val parseFile = ParseFile(file.name, bytes)

    parseFile.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("File saved: ${parseFile.url}")
        } else {
            println("Error uploading file: ${e.localizedMessage}")
        }
    }
}
﻿
Sécurité des fichiers
Vous pouvez contrôler qui peut télécharger ou télécharger des fichiers en ajustant les ACL et les CLP ou en utilisant des paramètres spécifiques aux fichiers dans la configuration du serveur parse.
Étape 7 – Vérification par e-mail et réinitialisation du mot de passe
Activer la vérification par e-mail dans les paramètres de votre tableau de bord Back4App.
Configurer votre adresse d'expéditeur, vos modèles d'e-mail ou votre domaine personnalisé si vous le souhaitez.
Utiliser ParseUser.requestPasswordResetInBackground(email, callback) pour déclencher un flux de réinitialisation de mot de passe dans votre application.
Étape 8 – Planification des tâches avec des travaux Cloud
Les travaux Cloud vous permettent d'automatiser des tâches routinières comme le nettoyage des données ou l'envoi de notifications périodiques.
JS
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo')
  const query = new Parse.Query(Todo)
  // e.g., remove todos older than 30 days
  const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
  query.lessThan('createdAt', cutoff)

  const oldTodos = await query.find({ useMasterKey: true })
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true })
  return `Deleted ${oldTodos.length} old Todos.`
})
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo')
  const query = new Parse.Query(Todo)
  // e.g., remove todos older than 30 days
  const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
  query.lessThan('createdAt', cutoff)

  const oldTodos = await query.find({ useMasterKey: true })
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true })
  return `Deleted ${oldTodos.length} old Todos.`
})
﻿
Planifiez le travail dans votre tableau de bord Back4App sous Paramètres du serveur > Travaux en arrière-plan.
É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.
Ajouter un Webhook dans votre tableau de bord Back4App sous Plus > Webhooks.
Configurer les déclencheurs (par exemple, après avoir enregistré un nouvel objet).
Ajouter un point de terminaison URL (comme un webhook Slack ou Stripe).
Ajout d'un Webhook
﻿
Étape 10 – Explorer le panneau d'administration Back4App
L' Application d'administration Back4App est une interface web conviviale pour les utilisateurs non techniques afin de gérer les données.
Activez-le sous Tableau de bord de l'application > Plus > Application d'administration.
Créez votre premier utilisateur administrateur.
Choisissez un sous-domaine pour accéder au panneau d'administration.
Connectez-vous pour visualiser, modifier ou supprimer facilement des enregistrements de votre base de données.
Activer l'application d'administration
﻿
Conclusion
En suivant ce tutoriel complet, vous avez :
Créé un backend sécurisé pour une application Android sur Back4App.
Configuré une base de données avec des schémas de classe, des types de données et des relations.
Intégré des requêtes en temps réel (Live Queries) pour des mises à jour de données immédiates.
Appliqué des mesures de sécurité en utilisant des ACL et des CLP pour protéger et gérer l'accès aux données.
Implémenté des fonctions Cloud Code pour exécuter une logique métier personnalisée côté serveur.
Mis en place une authentification utilisateur avec support pour la vérification par e-mail et la réinitialisation de mot de passe.
Géré les téléchargements de fichiers et la récupération, avec des contrôles de sécurité de fichiers optionnels.
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 Android (Kotlin) solide et un backend Back4App robuste, vous êtes maintenant bien équipé pour développer des applications 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
Construire une application Android prête pour la production en étendant ce backend pour gérer des modèles de données plus complexes, des stratégies de mise en cache et des optimisations de performance.
Intégrer des fonctionnalités avancées telles que des flux d'authentification spécialisés, un contrôle d'accès basé sur les rôles ou des API externes (comme des passerelles de paiement).
Consulter la documentation officielle de Back4app pour des plongées plus profondes dans la sécurité avancée, le réglage des performances et l'analyse des journaux.
Explorer d'autres tutoriels sur les applications de chat en temps réel, les tableaux de bord IoT ou les services basés sur la localisation. Vous pouvez combiner les techniques apprises ici avec des API tierces pour créer des applications complexes et réelles.
﻿
Mis à jour 23 Jan 2025
Cette page vous a-t-elle aidée?
Comment créer un backend pour Swift ?
Comment construire un backend pour Android ?