Comment développer la partie backend d’une application mobile ?

Cet article vous permettra de découvrir ce qu’est un Back-end pour une application mobile et tous les éléments dont vous avez besoin pour créer votre Backend.

Nous aborderons notamment les différences entre backend et frontend, les différents types de backend, les fonctionnalités du backend mobile et les coûts de développement d’un backend.

Enfin, nous apprendrons comment créer un backend pour une application mobile simple sur Back4app — l’un des meilleurs fournisseurs de MBaaS.

Différences entre frontend et backend

Les termes frontend et backend se réfèrent à la séparation des préoccupations entre la partie présentation et la partie accès aux données.

Pour bien comprendre cette différence, il suffit de se représenter un iceberg. Le frontend se trouve au-dessus du niveau de l’eau et représente tout ce qu’un utilisateur peut voir et avec lequel il peut interagir. Le backend, quant à lui, est la partie de l’iceberg qui se trouve sous l’eau. Il s’agit de la partie logique sous-jacente qui fait fonctionner le système.

Frontend

Un frontend est l’interface graphique d’un site web, d’une application mobile ou de tout autre type de client avec lequel un utilisateur peut interagir. Il regroupe tous les aspects visuels d’une application, y compris le design, les menus, les textes, les images, les vidéos, etc. Dans la plupart des projets, il représente environ 20 % de l’effort total et il n’est pas répétitif.

Les développeurs Frontend doivent s’occuper des aspects suivants :

• Un design réactif
• Des performances de l’application
• De la compatibilité entre navigateurs
• Des problèmes d’accessibilité
• De l’optimisation du référencement

Les interfaces Web sont généralement exécutées avec des outils tels que HTML, CSS, JavaScript et WebAssembly. Les applications Android natives sont écrites en Java/Kotlin, tandis que les applications iOS natives utilisent Objective-C et Swift.

Ces dernières années, de nombreux développeurs Frontend ont adapté des outils tels que React Native, Vue et Svelte Native pour faciliter le processus de développement et faire fonctionner la même base de code sur différentes plateformes.

Les frontends peuvent être “déployés” vers des services tels que Google Play, App Store, Vercel, Netlify.

Backend

Le développement de la partie backend ou côté serveur est la pratique consistant à développer la partie réservée à l’accès aux données. Le backend est le lien existant entre la base de données et le frontend. La plupart des backends fournissent une interface de couche d’application (API), qu’un frontend peut utiliser pour récupérer et stocker des données.

Les données sont généralement échangées au format JSON ou GraphQL. En général, un backend représente environ 80 % du travail et est répétitif. À titre d’exemple, pratiquement tous les projets requièrent une authentification, une autorisation, une gestion de base de données, etc.

Les développeurs backend sont responsables de :

• La gestion de la base de données
• La logique métier de l’application
• L’évolutivité, et de la haute disponibilité
• La sécurité et les sauvegardes

Les développeurs backend travaillent généralement avec des langages de programmation comme Python, JavaScript (Node.js), Ruby, C#, Java et Go. À l’heure où nous écrivons ces lignes, l’architecture de backend la plus populaire est le modèle-vue-contrôleur (MVC), qui a été adopté par de nombreux frameworks web comme Django et Laravel.

Le composant le plus important d’un backend est sa base de données. Il existe différents types de bases de données que l’on peut classer en trois catégories générales :

• Les bases de données SQL
• Les bases de données NoSQL
• Les bases de données multi-paradigmes

Elles ont chacune leurs avantages et leurs inconvénients, qui doivent être pris en compte lors du lancement d’un projet.

Un backend peut être déployé sur différentes plateformes en fonction du niveau d’abstraction souhaité. Par exemple, vous pouvez utiliser votre propre serveur, IaaS (AWS, GCE, Azure), PaaS(Heroku, Digital Ocean App Service) ou BaaS (Back4app, Firebase, AWS Amplify).

Continuez à lire pour en savoir plus sur le développement backend des applis mobiles.

Qu’est-ce qu’un backend pour une application mobile ?

Le backend d’une application mobile correspond à la partie de l’application qui s’exécute sur un serveur, plutôt que sur l’appareil lui-même. Le backend fournit les fonctionnalités dont l’application a besoin pour stocker et gérer les données, authentifier les utilisateurs, traiter et analyser les données, et communiquer avec d’autres systèmes ou services.

Un backend peut se présenter sous de nombreuses formes, notamment un serveur fonctionnant sur un service cloud, une base de données ou une API. Il fournit l’infrastructure et les outils nécessaires au bon fonctionnement de l’application et permet à cette dernière d’offrir une expérience utilisateur riche et captivante.

Quelles sont les fonctions d’un backend mobile ?

Un backend pour une application mobile fournit généralement les fonctionnalités suivantes :

• Stockage et gestion des données
• Traitement et analyse des données
• Authentification et autorisation
• Synchronisation entre plusieurs appareils
• Capacité d’intégration avec d’autres systèmes et services
• Gestion des tâches côté serveur
• Analyse et surveillance
• Notifications push

Une application mobile a-t-elle besoin d’un backend ?

Réponse courte : Si votre application fonctionne localement (sans connexion internet), vous n’avez généralement pas besoin d’un backend, mais cela ne signifie pas pour autant que votre application ne peut pas bénéficier d’un backend.

Pour mieux comprendre cette réponse, jetons un coup d’œil à certaines des applications que nous utilisons dans la vie quotidienne.

Applications qui n’ont pas besoin d’un backend :

• Calculatrice
• Calendrier et horloge
• Appareil photo et galerie
• Enregistreur vocal
• Jeux à un seul joueur

Les applications qui nécessitent un backend : 

• Applications de commerce électronique — un backend est indispensable pour assurer le suivi de l’inventaire, traiter les commandes, etc.
• Applications de transport — un backend est nécessaire pour permettre le traitement des billets, les informations sur les retards, etc.
• Applications de messagerie — un backend est utilisé pour transférer des messages d’un appareil à un autre.
• Applications météorologiques — un backend est nécessaire pour récupérer les informations météorologiques actuelles

Maintenant, voyons comment un backend pourrait améliorer les applications énumérées ci-dessus :

• Calculatrice — pourrait recourir à un backend pour décharger des calculs complexes sur un serveur distant.
• Calendrier et horloge — pourrait stocker les événements dans une base de données et les synchroniser entre les appareils.
• Appareil photo — pourrait utiliser un backend pour corriger les distorsions, l’éclairage, etc.
• Enregistreur vocal — pourrait utiliser un service backend pour supprimer le bruit.
• Jeux à un joueur — pourrait stocker les scores des utilisateurs dans une base de données et afficher un classement

Compte tenu des avantages considérables qu’offrent les backends, presque toutes les applications mobiles ont un backend. Si ce n’est pour stocker des données, le backend permet aux applications mobiles de collecter des analyses, d’envoyer des notifications push, de surveiller les applications, de collecter des rapports de panne, etc. Si vous voulez être performant, vous aurez très probablement besoin d’un backend.

Quels sont les types de backend ?

En fonction du type de votre application, vous pouvez choisir parmi plusieurs types de backend. De manière générale, nous pouvons les répartir en trois groupes en fonction de leur niveau d’abstraction :

1. Software as a Service (SaaS) ou services tiers
2. Mobile Backend as a Service (MBaaS).
3. Backend personnalisés

Regardons de plus près chacun d’entre eux.

Software as a Service (SaaS) ou services tiers

Le logiciel en tant que service (Software as a Service) (SaaS) est un modèle de fourniture de logiciels dans lequel une application logicielle est hébergée par un fournisseur tiers et mise à la disposition des clients sur Internet.

Les solutions SaaS demandent généralement à leurs clients de payer un abonnement mensuel ou annuel. Ce type de backend est le plus facile à utiliser et vous permet de mettre en place votre backend en quelques clics.

L’inconvénient de ce type de backend réside dans le fait que vous ne trouverez probablement pas de SaaS qui réponde à toutes les exigences de votre projet. Pour créer un backend réel, vous devrez probablement combiner plusieurs solutions SaaS.

Voici quelques exemples de SaaS :

• WordPress (système de gestion de contenu)
• Mailchimp (logiciel de gestion et de marketing par courriel)
• Salesforce (logiciel de gestion de la relation client)
• Shopify (Plateforme de commerce électronique)
• Dropbox (Hébergement de fichiers)

Mobile Backend as a Service (MBaaS)

Le Backend as a Service (Backend mobile en tant que service) (BaaS) est une plateforme qui automatise le côté backend du développement et prend en charge l’infrastructure cloud.

Elle fournit également des fonctionnalités telles que la gestion des utilisateurs, les notifications par e-mail, les notifications push, les fonctions de code cloud, les intégrations de médias sociaux, le stockage de fichiers et les paiements.

Les développeurs peuvent ainsi se concentrer sur leur activité principale et sur le développement du frontend sans se soucier du backend et de l’infrastructure sous-jacents. Le frontend est généralement développé via des API et des SDK spécialisés proposés par le fournisseur de BaaS. Les applications sont ainsi moins complexes et plus faciles à maintenir.

L’utilisation d’un Backend as a Service présente de nombreux avantages, notamment une vitesse de développement plus rapide, une réduction des coûts de développement et la possibilité de se concentrer sur l’activité principale.

Voici quelques exemples de BaaS :

• Back4app
• Firebase
• AWS Amplify
• Apple Cloudkit

Vous voulez en savoir plus sur BaaS et MBaas ? Jetez un coup d’œil à la section Qu’est-ce qu’un BaaS ?

Backend personnalisé

Un backend personnalisé constitue l’option la plus puissante et la plus flexible. Il vous offre un contrôle total et vous permet de déployer des fonctionnalités qui ne peuvent être réalisées avec une solution SaaS ou MBaaS.

Son principal inconvénient réside dans son coût et son temps de développement. En choisissant cette approche, vous assumez également l’entière responsabilité des performances et de la sécurité de votre backend.

La création d’un backend personnalisé prend généralement plusieurs mois et requiert un développeur backend compétent, voire toute une équipe de développeurs backend.

Les frameworks les plus populaires pour créer des backends personnalisés :

• Django
• Laravel
• Express.js
• Ruby on Rails
• Spring Boot

Pour en savoir plus sur les frameworks backend, consultez le Top 10 des frameworks backend.

Combien coûte le backend d’une application mobile ?

Il n’y a pas de recette simple pour calculer le coût d’un backend d’application mobile. Le coût varie en fonction de la complexité de l’application, du nombre de fonctionnalités, de son évolutivité, de ses performances, etc.

Coût du SaaS

Le SaaS est généralement l’option la moins chère pour laquelle vous pouvez opter. Les produits SaaS suivent généralement un modèle de tarification simple avec des frais d’abonnement mensuels ou annuels. Certains fournisseurs de SaaS proposent également différents niveaux de prix en fonction de la taille de votre entreprise.

Coût du MBaaS

Construire un backend avec MBaaS est vraiment peu coûteux par rapport à un backend personnalisé. Il vous permet de réduire considérablement les coûts de développement et vous évite d’avoir à vous soucier de l’infrastructure ou d’embaucher une équipe d’ingénieurs spécialisés en backend. Cela vous permet d’économiser beaucoup d’argent !

La plupart des fournisseurs de MBaaS proposent différents niveaux de prix en fonction de la taille de votre application. En utilisant MBaaS, vous pouvez vous attendre à payer entre 15 et 500 $ par mois.

Coût d’un backend personnalisé

Le développement d’un backend personnalisé est l’option la plus coûteuse. En choisissant cette option, vous devrez réunir une équipe de développeurs qualifiés et vous occuper de l’infrastructure de votre backend.

En fonction des exigences du projet, le prix de la création d’un backend personnalisé varie généralement de quelques milliers de dollars à plusieurs dizaines de milliers de dollars.

Étant donné que la création d’un backend personnalisé est une tâche difficile, les entreprises la confient généralement à des sociétés spécialisées dans le développement de logiciels.

Comment construire un backend pour une application mobile en utilisant MBaaS ?

Dans cette partie de ce tutoriel, nous allons voir comment développer un backend pour une application mobile en utilisant Back4app.

Qu’est-ce que Back4app ?

Back4app est l’une des meilleures solutions open-source de Backend as a Service (BaaS) sur le marché. Elle propose un large éventail de fonctionnalités et d’avantages à ses utilisateurs, ce qui permet aux développeurs de créer rapidement des applications web et mobiles.

En utilisant Back4app, vous serez en mesure de vous concentrer sur votre activité principale au lieu de vous soucier du backend ou de l’infrastructure sous-jacente.

Cette solution est dotée d’un tableau de bord riche en fonctionnalités et facile à utiliser, ainsi que d’uneinterface en ligne de commande (CLI). Elle fournit également des SDKs pour tous vos outils préférés tels que Flutter, React Native, Node.js, Angular, Android, iOS et plus encore

Voici les principales fonctionnalités de Back4app :

• Base de données de type feuille de calcul
• APIs REST et GraphQL
• Requêtes en direct
• Authentification (y compris l’authentification sociale)
• Hébergement évolutif
• Notifications par push et par e-mail

Pour plus d’informations sur leurs caractéristiques, consultez la page Caractéristiques de Back4app. 

Back4app propose un modèle de prix simple et direct qui peut convenir à une application de toute taille. Ils proposent un plan gratuit généreux (pas de carte de crédit requise) qui est idéal pour le prototypage et l’essai de la plateforme. Ce plan comprend :

• 25 000 requêtes
• 250 Mo de stockage de données
• 1 Go de transfert
• 1 Go de stockage de fichiers

Pour plus d’informations sur la tarification de Back4app, consultez la page Tarification.

Aperçu du projet

Nous souhaitons construire un backend pour une simple application de presse. Cette application permettra aux rédacteurs de créer, mettre à jour et supprimer des articles. Pour faciliter l’administration, nous allons utiliser l’application d’administration de Back4app.

Nous nous occuperons de la sécurité du backend et nous expliquerons comment utiliser l’API REST du backend. Le backend sera construit avec une quantité minimale de code.

Conditions préalables :

• Notions de base sur le Backend as a Service (BaaS)
• Notions de base sur les bases de données (et les relations entre les modèles)
• Notions de base sur les demandes et les réponses HTTP
• Avoir une compréhension de la syntaxe JSON

Objectifs:

À la fin de ce tutoriel, vous serez en mesure de :

• Construire et déployer un backend simple sur Back4app
• Structurer votre propre base de données
• Comprendre les bases de la sécurité de la plateforme Parse
• Savoir comment effectuer des opérations CRUD via l’API REST

Création de l’application

Les étapes suivantes nécessitent que vous ayez un compte Back4app. Si vous en avez déjà un, connectez-vous, sinon créez votre compte gratuit. 

Pour travailler avec Back4app, nous devons d’abord créer une application. En vous connectant à votre tableau de bord, vous verrez la liste de vos applications. Cliquez sur “Créer une nouvelle application” pour créer une nouvelle application.

Donnez-lui un nom personnalisé, puis cliquez sur “Continue”.

Back4app va prendre quelques instants pour préparer tout ce qui est nécessaire à votre application, comme la base de données, la couche d’application, la mise à l’échelle, les sauvegardes et la sécurité.

Une fois que votre application est prête, vous serez redirigé vers le tableau de bord de votre application.

Base de données

Dans cette partie du tutoriel, nous allons créer tous les modèles de base de données nécessaires.

Comme mentionné dans l’introduction du projet, nous allons construire une simple application de presse. Notre base de données sera composée des modèles suivants :

• Article représente un article d’actualité.
• ArticleCategory représente une catégorie d’article (par exemple, sports, divertissement). Un article peut appartenir à une seule catégorie.
• ArticleTag représente un hashtag d’article (ex : cosmétique, santé, beauté). Un article peut avoir plusieurs hashtags.

Cette structure de base de données nous permettra plus tard de filtrer les articles en fonction des catégories ou des tags. Dessinons un diagramme entité-relation (ERD) pour mieux comprendre les relations entre les modèles :

Maintenant, créons réellement les modèles.

Commençons par créer le modèle  ArticleCategory. En haut à gauche de l’écran, cliquez sur “Create a class”, nommez-le  ArticleCategory et ajoutez les champs suivants:

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Ensuite, créez une autre catégorie nommée  ArticleTag avec les détails suivants:

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Ensuite, créez une autre catégorie nommée  Article avec les détails suivants :

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | title       | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| String                      | content     | <leave blank> | yes      |
+-----------------------------+-------------+--------------+-----------+
| Pointer -> ArticleCategory  | category    | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Relation -> ArticleTag      | tags        | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Nous en avons terminé avec l’architecture de la base de données. Maintenant, ajoutons quelques exemples de données.

Pour simplifier un peu les choses, j’ai généré des données que vous pouvez importer. Pour importer un ensemble de données, sélectionnez la catégorie sur le côté gauche de l’écran, puis cliquez sur les trois points à droite de l’écran. Sélectionnez “Import” > “Class Data” et sélectionnez le fichier approprié.

Pour télécharger les ensembles de données JSON, accédez à back4app-mobile GitHub repo, cliquez sur “Code”, puis sur “Download ZIP”.

Importez les fichiers JSON dans l’ordre suivant :

1. User
2. ArticleCategory
3. ArticleTag
4. Article

Panneau d’administration

Pour simplifier un peu l’administration, nous allons activer l’application d’administration. Cette application est un outil basé sur un navigateur Web conçu pour gérer les données de l’application à l’aide d’une interface utilisateur non technique.

Accédez au tableau de bord de votre application, cliquez sur “More” > “Admin App”, puis cliquez sur le bouton “Enable Admin App”.

Choisissez un nom d’utilisateur et un mot de passe. Je vais choisir :

Username: admin
Password: complexpassword123

Choisissez ensuite un nom de domaine que vous souhaitez utiliser pour accéder à votre panneau d’administration. Je choisirai :

mobile-backend.admin.back4app.com

Super, vous pouvez maintenant vous connecter à votre tableau de bord d’administration sur le domaine sélectionné.

Pour en savoir plus sur Back4app Admin App, consultez la documentation officielle.

Sécurisation de l’application

Pour sécuriser notre application, nous devons effectuer les opérations suivantes :

1. Interdire aux clients de créer des classes de base de données.
2. Modifier les permissions de niveau de classe (CLP) du modèle  User
3. Modifier les CLP pour chaque modèle que nous avons créé.

Interdire aux clients de créer des classes

Pour interdire la création de classe client, allez dans “App Settings” > “Server Settings” > “Core Settings” > “Edit”, descendez jusqu’au bas de la page, et décochez “Allow Client Class Creation”.

Modifier les CLP du modèle 

Sélectionnez votre modèle User dans l’onglet “Database”, et cliquez sur les trois points à droite de l’écran > “Security” > “Class Level Permissions”. Cliquez ensuite sur l’icône en forme de rouage et changez-la en “Advanced”. Décochez tout et Get and Create lcomme suit :

Modifier les CLP pour chaque modèle que nous avons créé

Faites la même chose pour tous vos modèles personnalisés (Article, ArticleCategory, et  ArticleTag). Cette fois-ci, désactivez tout sauf Read et Find pour le groupe Public comme suit :

De cette façon, les utilisateurs non authentifiés ne pourront que trouver et lire les articles.

Pour plus d’informations sur la sécurité, consultez la section Sécurité Parse.

Test de l’API

Dans cette partie du tutoriel, nous allons tester notre API à l’aide de la console API intégrée.

Pour ouvrir la console API REST, accédez au tableau de bord de votre application. Sélectionnez “Console” dans la section “API” puis “REST”.

En raison de nos ACL/CLPs, assurez-vous de cocher “Use Master Key?” pour que les demandes aboutissent.

Récupérer

Les objets peuvent être récupérés avec le type de requête GET. Pour le point de terminaison, utilisez classes/<your_class> par exemple classes/Article et cliquez sur le bouton “Send Query” en bas de la page.

La réponse ressemblera à ceci :

{
    "results": [
                {
            "objectId": "oRwkdx7KgX",
            "title": "Voting 2022 has ended!",
            "description": "The voting for year 2022 has ended, the new major is...",
            "content": "Lorem ipsum dolor sit amet...",
            "category": {
                "__type": "Pointer",
                "className": "ArticleCategory",
                "objectId": "FYxzrBlCBC"
            },
            "author": {
                "__type": "Pointer",
                "className": "_User",
                "objectId": "UZ76K07znv"
            },
            "createdAt": "2022-12-13T09:09:04.845Z",
            "updatedAt": "2022-12-13T09:09:13.297Z",
            "tags": {
                "__type": "Relation",
                "className": "ArticleTag"
            }
        },
        ... more results ...
    ]
}

Si vous souhaitez récupérer un résultat spécifique ou filtrer l’ensemble des requêtes, consultez la documentation.

Créer

Pour créer une instance de modèle, sélectionnez la requête POST et soumettez-la à classes/<your_class>, par exemple classes/Article. Avec les requêtes POST, vous devez fournir des paramètres de requête. Par exemple :

{
   "title": "Another article",
   "content": "This is another test article added via the API",
   "category": {
      "__type": "Pointer",
      "className" :"ArticleCategory",
      "objectId": "pPGdxPAxQA"
   },
   "author": {
      "__type": "Pointer",
      "className": "_User",
      "objectId": "LFAf3yD8w0"
   }
}

Réponse:

{
    "objectId": "yAbmJ0sRZT",
    "createdAt": "2022-12-12T17:18:32.922Z"
}

Mise à jour

Pour mettre à jour un modèle, sélectionnez le type de requête PUT et soumettez-la à classes/<your_class>/<object_id>, par exemple classes/Article/oRwkdx7KgX. Vous devrez fournir des paramètres de requête contenant les données que vous souhaitez modifier :

{"description": "Back4app is cool!"}

Réponse:

{
    "updatedAt": "2022-12-12T17:31:23.459Z"
}

Supprimer

Pour supprimer une instance de modèle, sélectionnez le type de requête DELETE et soumettez-la à classes/<your_class>/<object_id>, par exemple classes/Article/oRwkdx7KgX.

Si la requête a réussi, un corps vide sera renvoyé.

Étapes suivantes

Notre backend pour une application mobile est maintenant plus ou moins complet. Pour le connecter à votre application mobile, vous devrez procéder comme suit :

1. Obtenez votre ID d’application et votre clé client à partir de “App Settings” > “Security & Keys”.
2. Installez le SDK ParseJS approprié (en fonction de votre plateforme).
3. Utilisez le SDK pour vous connecter à Back4app en utilisant vos informations d’identification.
4. Utilisez le SDK pour envoyer des requêtes.

Pour des instructions détaillées, consultez notre documentation :

Pour des instructions détaillées, consultez notre documentation :

• Guide de démarrage rapide Flutter
• Guide de démarrage rapide React Native 
• Guide de démarrage rapide Android 
• Guide de démarrage rapide iOS 

Conclusion

Les termes frontend et backend font référence à la séparation des préoccupations entre la couche de présentation et la couche d’accès aux données.

De nos jours, quasiment toutes les applications mobiles ont leur propre backend compte tenu de tous les avantages qu’un backend a à offrir. Les backends permettent aux applications mobiles de collecter des analyses, d’envoyer des notifications push, de surveiller les applications, de collecter des rapports d’erreur et bien plus encore.

Il existe plusieurs façons de construire un backend. Vous pouvez soit :

• Combiner plusieurs produits SaaS
• Utiliser un backend mobile en tant que service (MBaaS)
• Construire un backend personnalisé

Utiliser MBaaS est une excellente option car elle est vraiment peu coûteuse par rapport à un backend personnalisé tout en offrant beaucoup de flexibilité. Back4app figure parmi les meilleurs fournisseurs de MBaaS qui vous permettent de créer un backend en quelques jours, voire en quelques heures.

Section FAQ