Qu’est-ce qu’une fonction sans serveur ?

Dans cet article, nous parlerons de l’informatique sans serveur, des différentes architectures logicielles, des fonctions sans serveur, de leurs avantages et des cas d’utilisation. Dans la deuxième partie de l’article, nous allons apprendre à construire un backend serverless sur Back4app en utilisant les fonctions Cloud Code.

Qu’est-ce qu’une fonction sans serveur ?

Une fonction serverless est un morceau de code piloté par les événements qui sert un objectif unique. Elle peut être déclenchée par des événements spécifiques tels que des requêtes HTTP, des modifications de base de données ou d’autres messages. Ces fonctions sont écrites par un développeur de logiciels, puis déployées dans le cloud. Le fournisseur de cloud gère alors l’infrastructure et la sécurité, s’occupe de l’exécution du code et adapte automatiquement les ressources en fonction de la demande.

Les fonctions sans serveur sont souvent confondues avec l’informatique sans serveur. Bien que ces termes soient liés l’un à l’autre, ils ne peuvent pas être utilisés de manière interchangeable. L’informatique sans serveur est un modèle de cloud computing dans lequel les fournisseurs de cloud gèrent l’infrastructure nécessaire à l’exécution des applications, tandis que les fonctions sans serveur sont un type d’informatique sans serveur qui permet aux développeurs d’exécuter et de déployer facilement de petits morceaux de code dans le cloud.

Comment fonctionnent les fonctions sans serveur ?

La plupart des applications modernes sont divisées en deux parties : le frontend et le backend. Le frontend est ce que l’utilisateur voit et avec lequel il peut interagir, tandis que le backend est tout ce que l’utilisateur ne peut pas voir. Il s’agit de la logique commerciale, du stockage des données, des bases de données, des API, etc.

Les fonctions sans serveur simplifient le composant backend des applications logicielles, en divisant le backend en plusieurs fonctions réutilisables à usage unique. Ces fonctions peuvent ensuite être connectées pour exécuter des tâches complexes.

La façon la plus simple de comprendre les fonctions sans serveur est de regarder un exemple du monde réel. Supposons que nous ayons une boutique de commerce électronique où un utilisateur peut voir des produits, ajouter des produits au panier, retirer des produits du panier et passer à la caisse.

Notre backend sans serveur inclurait très probablement les fonctions suivantes :

getProductList()                       -> retrieves the products from the database
getProduct(productId)                  -> retrieves a specific product from the database
getCart(user)                          -> returns the products in the user's cart
addToCart(user, productId)             -> adds a product to the user's cart
removeFromCart(user, productId)        -> removes the product from the user's cart
clearCart(user)                        -> clears user's cart

Et puis nous aurions aussi des fonctions plus complexes qui utilisent d’autres fonctions sans serveur :

checkout()
    cart = getCart(user)
    finalizeCheckout(user, cart)       -> deducts money from user's account
    clearCart(user)
    sendConfirmationEmail(user, cart)  -> sends a confirmation email to the user

D’accord, mais comment les fonctions sans serveur fonctionnent-elles sous le capot ?

Sous le capot, les fonctions sans serveur fonctionnent en tirant parti de la technologie de conteneurisation, qui consiste à conditionner le code dans des conteneurs légers et isolés qui peuvent être facilement déployés et mis à l’échelle à la demande. Lorsqu’une fonction sans serveur est déclenchée, le fournisseur de cloud crée une nouvelle instance du conteneur, y exécute le code, puis ferme le conteneur lorsque le code a fini de s’exécuter.

Le fournisseur d’informatique en nuage prend généralement en charge tous les aspects de la gestion de l’infrastructure sous-jacente, y compris la mise à l’échelle, l’équilibrage de la charge et l’allocation des ressources, de sorte que les développeurs n’ont pas à se préoccuper de la configuration ou de la gestion des serveurs. Les développeurs n’ont donc pas à se préoccuper de la configuration ou de la gestion des serveurs. Il leur suffit d’écrire du code, de le télécharger vers le fournisseur d’informatique en nuage et de définir les conditions de déclenchement de l’exécution du code.

Quelles sont les différentes architectures logicielles ?

Outre les fonctions sans serveur, nous avons également l’architecture monolithique et l’architecture microservices. Examinons-les.

Architecture monolithique

Dans une architecture monolithique, l’application est construite comme une unité unique dont tous les composants sont étroitement intégrés. Toutes les fonctionnalités sont regroupées dans une seule base de code et l’application est déployée sous la forme d’un paquet unique. L’architecture monolithique est simple à construire et à maintenir, mais elle peut devenir complexe et difficile à faire évoluer au fur et à mesure que l’application grandit.

Architecture des microservices

L’architecture microservices est une approche qui consiste à créer des applications logicielles sous la forme d’une collection de petits services indépendants qui communiquent entre eux par l’intermédiaire d’API. Chaque microservice est responsable d’une fonction spécifique de l’application et peut être développé, déployé et mis à l’échelle de manière indépendante. Cette approche permet une plus grande flexibilité, évolutivité et résilience, mais elle peut également introduire de la complexité en termes de communication et de gestion des services.

En conclusion, les apps monolithiques conviennent mieux aux projets plus simples qui n’ont pas besoin d’évoluer beaucoup. En revanche, les microservices et l’architecture sans serveur sont généralement plus appropriés pour les projets plus complexes qui doivent être hautement évolutifs et flexibles. En plus de tous les avantages des microservices, l’architecture sans serveur fait abstraction de la gestion de l’infrastructure. Vous économisez donc beaucoup de temps et d’argent.

Quels sont les avantages des fonctions sans serveur ?

Les fonctions en tant que service (FaaS) présentent de nombreux avantages.

Un développement plus rapide

Les fonctions sans serveur permettent un développement et un déploiement plus rapides puisqu’il n’est pas nécessaire de gérer l’infrastructure, de configurer les serveurs, de mettre en place une mise à l’échelle ou de gérer les serveurs. Comme les fonctions sans serveur sont de petits morceaux de code qui servent un seul objectif, elles peuvent être facilement testées et déboguées. Mieux encore, les fonctions sans serveur peuvent être facilement intégrées à d’autres services cloud ou à des API tierces, ce qui permet de se décharger d’un grand nombre de problèmes courants.

Extensibilité et disponibilité élevées

Les fonctions sans serveur peuvent gérer un grand nombre de demandes et évoluer automatiquement en fonction de la demande. Cela garantit que l’application peut s’adapter à n’importe quel niveau de trafic. De plus, si personne n’utilise votre service, l’environnement peut être réduit à zéro, ce qui vous permet d’économiser beaucoup d’argent.

Il est également possible de déployer vos fonctions en tant que service (FaaS) dans plusieurs zones. Cela peut vous aider à améliorer la disponibilité de votre application en distribuant vos fonctions à travers le monde.

Une plus grande flexibilité

Les fonctions sans serveur permettent aux développeurs de choisir le langage de programmation et les outils qui répondent le mieux à leurs besoins. La plupart des fournisseurs de fonctions sans serveur prennent en charge plusieurs langages tels que JavaScript, Java, Python, Go et .NET. Cela offre une plus grande flexibilité dans le développement et le déploiement des applications.

Rapport coût-efficacité

L’architecture sans serveur est la plus rentable, car vous ne payez que ce que vous consommez. Il s’agit du temps d’exécution de vos fonctions et des autres services gérés que vos fonctions utilisent. En outre, vous n’avez pas besoin de payer pour les ressources inactives.

Quels sont certains des cas d’utilisation des fonctions sans serveur ?

Les fonctions sans serveur peuvent être utilisées dans pratiquement n’importe quel projet. Vous pouvez utiliser les fonctions serverless pour construire le projet à partir de la base ou simplement pour des tâches spécifiques. Les principaux cas d’utilisation sont les suivants :

• Applications web
• Construire des API RESTful
• Tâches basées sur des déclencheurs
• Automatisation des tâches programmées
• Traitement asynchrone
• Internet des objets (IoT)
• CI/CD

La plupart des équipes de développeurs migrent vers le serverless par étapes. Elles migrent tâche par tâche jusqu’à ce qu’il n’y ait plus besoin de serveurs traditionnels.

Quels sont les exemples d’environnements sans serveur ?

Plate-forme en tant que service (PaaS)

La plateforme en tant que service (PaaS) est une solution avantageuse d’informatique dématérialisée qui offre aux utilisateurs la possibilité de créer, de gérer et de déployer des applications dans un environnement dématérialisé.

Il fournit des outils préconfigurés pour le développement, la personnalisation et le test des applications, éliminant ainsi une grande partie du temps consacré à la gestion de l’infrastructure.

Le développement d’une application qui sera déployée sur PaaS n’est pas très différent de celui d’une application traditionnelle. Les fournisseurs de PaaS ne prennent pas en charge les fonctions sans serveur dès le départ.

Les services PaaS comprennent : Heroku, AWS Elastic Beanstalk, DigitalOcean App Platform et Fly.io.

Backend en tant que service (BaaS)

Le BaaS rationalise et simplifie le développement du backend en fournissant une plateforme pour gérer l’infrastructure en nuage.

Il prend en charge toutes les tâches fastidieuses associées à la construction d’un backend, permettant aux développeurs de se concentrer sur la création d’applications. En automatisant un grand nombre de ces processus, BaaS aide les développeurs à créer des applications robustes rapidement et efficacement.

La plateforme offre un large éventail de fonctionnalités, notamment la gestion des utilisateurs, les notifications, l’intégration des médias sociaux et le stockage. Elle constitue donc un choix idéal pour les entreprises qui cherchent à renforcer leur présence numérique. En outre, elle est pratique et facile à utiliser, ce qui la rend accessible à tous les utilisateurs.

Les développeurs n’ont plus à se préoccuper de l’infrastructure dorsale et peuvent concentrer leurs efforts sur la création de la partie frontale de leurs projets. Ils peuvent ainsi se concentrer sur leur cœur de métier sans avoir à consacrer du temps et de l’énergie à d’autres tâches.

Certains fournisseurs de BaaS nous permettent également de déployer des fonctions sans serveur :

• Back4app a des fonctions de Cloud Code
• Firebase dispose de Google Cloud Functions
• AWS Amplify a AWS Lambda

Parmi les autres fournisseurs de BaaS figurent Supabase, Kinvey et Parse.

Fonction en tant que service (FaaS)

La fonction en tant que service (FaaS) est un modèle de cloud computing spécialisé dans les fonctions sans serveur. FaaS permet aux développeurs de se concentrer sur l’écriture et le déploiement de fonctions individuelles plutôt que sur la construction et la gestion d’une pile d’applications complète. Les fonctions sans serveur s’intègrent généralement à des API tierces et à d’autres services cloud. Ce modèle informatique peut évoluer automatiquement et rapidement pour s’adapter à n’importe quel trafic.

Les principales différences entre BaaS et FaaS résident dans :

• Construction de l’application
• Évolutivité
• Modèle de tarification

Les fonctions sans serveur sont exécutées dans des conteneurs, sont plus évolutives et plus rentables puisque vous ne payez que pour le temps d’exécution de vos fonctions. Le BaaS, quant à lui, dispose de nombreuses fonctionnalités intégrées telles que la gestion des utilisateurs, les notifications push, les intégrations aux médias sociaux et d’autres outils prêts à l’emploi qui vous permettent de créer rapidement des backends. De plus, BaaS est extrêmement facile à utiliser.

Parmi les exemples de FaaS, on peut citer : AWS Lambda, Google Cloud Functions et Azure Functions.

Construire un backend sans serveur sur Back4app

Dans cette section du tutoriel, nous allons démontrer comment coder et déployer des fonctions Cloud Code sur Back4app. De plus, nous apprendrons à connecter un frontend à un backend sans serveur.

Objectifs:

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

• Expliquer ce que sont les fonctions du code cloud et comment elles fonctionnent
• Codez votre Cloud Codez les fonctions qui peuvent manipuler la base de données
• Utiliser les fonctions de Cloud Code pour récupérer des données à partir d’API tierces
• Créez vos propres “Cloud Jobs” et planifiez-les
• Connecter un projet frontend avec un backend sans serveur

Qu’est-ce que Back4app ?

Back4app est une plateforme BaaS (Backend as a Service) de premier plan qui fournit aux développeurs les outils et les fonctionnalités dont ils ont besoin pour créer facilement des applications web et mobiles.

Grâce à ses nombreux avantages, il permet aux développeurs de se concentrer sur les principaux aspects de leur activité sans se soucier des complexités du backend ou des problèmes d’infrastructure. C’est l’une des solutions BaaS open-source les plus appréciées aujourd’hui.

Cette solution complète s’accompagne d’un tableau de bord interactif et d’une interface de ligne de commande (CLI) flexible pour une commodité maximale. En outre, elle fournit des SDK compatibles avec React Native, Flutter, Node.js, Angular, iOS, Android, et plus encore – ce qui rend l’intégration dans les systèmes existants sans effort !

Les caractéristiques principales de Back4app comprennent une base de données de type tableur, des API GraphQL et REST, des requêtes en direct, l’authentification avec des options de connexion sociale, l’évolutivité pour l’hébergement et les notifications, toutes disponibles dans cette puissante plateforme.

Pour plus d’informations, veuillez lire les caractéristiques de Back4app.

Back4app propose un modèle rentable pour tous les types d’applications, des plus petites aux plus grandes. Ils fournissent un plan gratuit qui est parfait pour le développement et l’expérimentation de la plateforme.

Introduction du projet

Nous allons créer une application simple de gestion de stations météorologiques. Nous commencerons par créer des stations météorologiques virtuelles, puis nous utiliserons WeatherAPI pour obtenir les informations météorologiques réelles à l’emplacement des stations météorologiques. Pour définir la logique de notre application, nous utiliserons les fonctions Cloud Code et Cloud Jobs. Enfin, nous montrerons comment connecter facilement un projet frontal à un backend sans serveur.

Créer une application

Si vous n’avez pas encore de compte Back4app, inscrivez-vous maintenant pour bénéficier de leurs services gratuits. Sinon, connectez-vous à votre compte existant et suivez les étapes suivantes.

Pour commencer à utiliser Back4app, vous devez créer une application. Connectez-vous à votre tableau de bord pour voir la liste des applications et cliquez sur “Créer une nouvelle application” pour commencer à créer votre application.

Puisque nous allons utiliser le framework Parse pour construire notre application, sélectionnez “Backend as a Service”.

Ensuite, entrez un nom d’application personnalisé, sélectionnez “NoSQL Database” comme base de données, et enfin cliquez sur “Create”.

Back4app va mettre en place tous les composants nécessaires à votre application, y compris la base de données, la couche applicative, la mise à l’échelle, les sauvegardes et la sécurité. Cela ne prend que peu de temps.

Une fois votre demande complétée, vous serez redirigé vers le tableau de bord de votre application.

Base de données

Définissons nos modèles de base de données. Nous allons créer deux modèles :

1. WeatherStation représente une station météorologique virtuelle située à un certain endroit.
2. WeatherRecord représente une mesure du temps à une station météo spécifique.

Accédez à votre “Base de données” et cliquez sur “Créer une classe”. Nommez-la WeatherStation, assurez-vous d’activer “Public Read and Write” et ajoutez-y les champs suivants :

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

Ensuite, suivez les mêmes étapes pour créer une autre classe nommée WeatherRecord avec les champs suivants :

+---------------------------+-----------------+---------------+----------+
| Data type                 | Name            | Default value | Required |
+---------------------------+-----------------+---------------+----------+
| Pointer -> WeatherStation | weatherStation  | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | weatherText     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | weatherIcon     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| Number                    | weatherCode     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+

Enfin, naviguez vers le modèle WeatherStation et créez deux stations météorologiques. Exemple :

+---------------------------+---------------+
| name                      | location      |
+---------------------------+---------------+
| Sunnyvale Station         | sunnyvale     |
+---------------------------+---------------+
| Mountain View Station     | mountain view |
+---------------------------+---------------+

Voilà, c’est tout pour la base de données.

WeatherAPI

Pour obtenir les informations météorologiques actuelles, nous utiliserons une API gratuite appelée WeatherAPI.

Les étapes suivantes nécessitent que vous ayez un compte WeatherAPI. Si vous n’en avez pas encore, inscrivez-vous, sinon connectez-vous à votre tableau de bord.

Une fois que vous êtes connecté, notez votre clé API :

Ensuite, ouvrez votre terminal et essayez de récupérer les informations météorologiques actuelles pour “Sunnyvale” en utilisant votre clé API :

curl "https://api.weatherapi.com/v1/current.json?key=<your_api_key>&q=<location>&aqi=no"

# Example:
# curl "https://api.weatherapi.com/v1/current.json?key=354fc376a4c&q=Sunnyvale&aqi=no"

Vous devriez obtenir une réponse similaire à celle-ci :

{
    "location": {
        "name": "Sunnyvale",
        "region": "California",
        "country": "United States of America",
        "lat": 37.37,
        "lon": -122.04,
    },
    "current": {
        "temp_c": 7.0,
        "temp_f": 44.6,
        "is_day": 1,
        "condition": {
            "text": "Light rain",
            "icon": "//cdn.weatherapi.com/weather/64x64/day/296.png",
            "code": 1183
        },
        ...
    }
}

Dans la prochaine section de l’article, nous utiliserons les fonctions de Cloud Code pour récupérer les informations météorologiques de la WeatherAPI et les stocker dans la base de données.

Code du nuage

Les fonctions Cloud Code sont une fonctionnalité puissante de Parse Server qui permet aux développeurs d’exécuter du code JavaScript personnalisé côté serveur. Les développeurs peuvent utiliser ces fonctions pour mettre en œuvre une logique métier, valider des données, traiter des données complexes et construire des backends sans serveur en général.

Naviguez vers votre tableau de bord Back4app et sélectionnez “Fonctions & Hébergement Web” sous “Code Cloud” sur la barre latérale.

L’interface utilisateur de Back4app Cloud Code est facile à utiliser. Sur le côté gauche de l’écran, vous pouvez voir la structure des répertoires. Par défaut, il y a deux répertoires :

1. cloud est un répertoire pour tout le code cloud
2. public est un répertoire pour les fichiers publics tels que les images, les feuilles de style, etc.

Sur le côté droit de l’écran, vous disposez d’un éditeur de code intégré.

Définir les fonctions du code cloud

Nous définirons les fonctions suivantes :

1. weatherLocations renvoie la liste des emplacements des stations météorologiques.
2. weatherInfo renvoie le bulletin météorologique pour un lieu spécifique.

Mais avant cela, installons un paquetage tiers appelé axios. Axios est un client HTTP basé sur des promesses pour JavaScript qui simplifie grandement les requêtes HTTP.

Créez un nouveau fichier appelé package.json dans le dossier cloud et mettez-y ce qui suit :

{
  "dependencies": {
    "axios": "*"
  }
}

Ensuite, définissez les fonctions du Code Cloud dans cloud/main.js comme suit :

// cloud/main.js

const axios = require("axios");

// make sure to replace `<api_key>` with your actual WeatherAPI key
const WEATHER_API_BASE = "https://api.weatherapi.com/v1/current.json?key=<api_key>";

Parse.Cloud.define("weatherLocations", async (request) => {
  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  const weatherStationResults = await weatherStationQuery.find();

  return weatherStationResults.map(result => result.get("location"))
});

Parse.Cloud.define("weatherInfo", async (request) => {
  let location = request.params.location;

  if (!location) {
    throw new Parse.Error(400, "Location not provided.");
  }

  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  weatherStationQuery.equalTo("location", location);
  const weatherStationResults = await weatherStationQuery.find();

  if (weatherStationResults.length == 0) {
    throw new Parse.Error(400, "Invalid location.");
  }

  const WeatherRecord = Parse.Object.extend("WeatherRecord");
  const weatherRecordQuery = new Parse.Query(WeatherRecord);
  weatherRecordQuery.equalTo("weatherStation", weatherStationResults[0]);
  weatherRecordQuery.descending("createdAt");
  weatherRecordQuery.limit(5);
  const weatherRecordResults = await weatherRecordQuery.find();

  return weatherRecordResults;
});

Enfin, cliquez sur “Déployer” en bas à droite de l’écran pour déployer vos fonctions sur Back4app.

Emploi dans le nuage

Les Cloud Jobs permettent aux développeurs d’exécuter des tâches en arrière-plan, telles que l’envoi de notifications push ou le traitement de données. Ces tâches sont écrites de la même manière que les fonctions de Cloud Code et peuvent être programmées pour être exécutées de manière ponctuelle ou récurrente.

Créons un “Cloud Job” qui mesure le temps qu’il fait dans toutes nos stations météorologiques toutes les 30 minutes.

Définir l’emploi dans le nuage

Sélectionnez “Cloud Code” dans la barre latérale et collez le code suivant au bas de cloud/main.js:

// cloud/main.js

// ...

Parse.Cloud.job("weatherCapture", async (request) => {
  const {params, headers, log, message} = request;
  message("weatherCapture just started...");

  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  const weatherStationResults = await weatherStationQuery.find();

  for (let i = 0; i < weatherStationResults.length; i++) {
    let weatherStation = weatherStationResults[i];

    try {
      const response = await axios.get(
        WEATHER_API_BASE + "&q=" + weatherStation.get("location") + "&aqi=no"
      );
      const currentWeather = response.data.current.condition;
      let icon = currentWeather.icon
        .replace("//", "https://")
        .replace("64x64", "128x128");

      const WeatherRecord = Parse.Object.extend("WeatherRecord");
      const weatherRecord = new WeatherRecord();
      weatherRecord.set("weatherStation", weatherStation);
      weatherRecord.set("weatherText", currentWeather.text);
      weatherRecord.set("weatherIcon", icon);
      weatherRecord.set("weatherCode", currentWeather.code);
      weatherRecord.save();
    } catch (error) {
      throw new Parse.Error(400, error);
    }
  }

  message("weatherCapture just finished!");
});

Ce code définit une nouvelle tâche dans le nuage nommée weatherCapture. Cette tâche passe en boucle par toutes les stations météo, récupère les informations météorologiques de WeatherAPI et les stocke dans la base de données.

Pour tester si cela fonctionne, naviguez vers “Jobs > All Jobs” sur la barre latérale et essayez d’exécuter le job. Si tout se passe bien, il devrait y avoir deux nouveaux WeatherRecord dans la base de données.

Planifier l’emploi dans le nuage

Planifions l’exécution du travail toutes les 30 minutes.

Sélectionnez “App Settings > Server Settings” dans la barre latérale et cherchez “Background Jobs”. Cliquez ensuite sur le bouton “Paramètres” :

Ensuite, planifiez un nouveau travail avec les détails suivants :

1. Description : Mesure le temps dans toutes les stations
2. Travail dans le nuage : weatherCapture
3. Paramètres : Laisser en blanc
4. Durée du programme : Commencer immédiatement
5. Doit-il se répéter ? Oui
6. Fréquence : Intervalle
7. Quel est l’intervalle de temps entre les répétitions ? 30 minutes

Voilà, c’est fait. La tâche weatherCapture va maintenant s’exécuter toutes les 30 minutes.

Notre backend sans serveur est maintenant terminé. Dans la prochaine section, nous verrons comment connecter un frontend au backend sans serveur.

Frontend

Construire un frontend personnalisé à partir de la base est hors de la portée de ce tutoriel. Néanmoins, je vais décrire les étapes de base de la connexion d’un frontend JavaScript à un backend sans serveur.

• Installez Parse via npm ou yarn et importez-le.
• Initialisez Parse dans votre App.js ou _app.js comme suit :

import Parse from "parse/dist/parse.min.js";
    
// to get the keys navigate to your Back4app app > App Settings > Security & Keys
Parse.initialize(
  "<your_app_id>",              // replace me
  "<your_javascript_key>",      // replace me
);
Parse.serverURL = "https://parseapi.back4app.com/";

• Vous pouvez ensuite appeler les fonctions de Cloud Code comme suit :

const fetchWeatherLocations = async () => {
    return await Parse.Cloud.run("weatherLocations");
};

Pour plus d’informations, consultez la documentation officielle.

J’ai également préparé un exemple de projet pour le backend de notre station météo. Le projet est accessible sur GitHub. Le README.md contient toutes les informations dont vous avez besoin pour mettre en place le projet et le faire fonctionner localement. N’hésitez pas à le forker et à jouer avec.

Conclusion

L’informatique sans serveur est devenue une solution de plus en plus populaire pour les développeurs qui cherchent à créer et à déployer des applications sans se soucier de la gestion des serveurs.

Dans cet article, nous avons exploré diverses architectures logicielles, examiné les fonctions sans serveur et mis en évidence leurs avantages et leurs cas d’utilisation. Enfin, nous avons démontré comment construire un backend serverless simple sur Back4app en utilisant les fonctions Cloud Code.

Le code source final peut être trouvé dans le repo back4app-serverless sur GitHub.

Prochaines étapes

1. Consultez Parse Server Security pour rendre votre backend plus sûr.
2. Jetez un coup d’œil à The Ultimate Guide to Deploy Docker App s pour apprendre comment construire et déployer un frontend personnalisé sur Back4app Containers.
3. En savoir plus sur les déclencheurs d’Parse.

FAQ