Qu’est-ce qu’une infrastructure dorsale ?

Le choix d’une infrastructure de backend appropriée est crucial lors de la conception de votre backend. Il peut avoir un impact sur les performances, la flexibilité et la maintenabilité de votre backend, pour n’en citer que quelques-uns.

Dans cet article, nous expliquerons ce qu’est une infrastructure backend, nous explorerons les différents types d’infrastructures backend et nous discuterons des facteurs essentiels à prendre en compte lors de votre décision.

De plus, nous verrons comment créer une infrastructure backend à l’aide de Back4app.

Objectifs

À la fin de cet article, vous serez en mesure de.. :

• Expliquer ce qu’est l’infrastructure dorsale
• Discuter des différents types d’infrastructures dorsales (y compris IaaS, PaaS et BaaS).
• Choisir l’infrastructure backend adéquate pour votre projet
• Créez votre propre backend en utilisant Back4app

Qu’est-ce qu’une infrastructure dorsale ?

L’infrastructure dorsale est la combinaison des composants logiciels et matériels qui soutiennent un système dorsal. Elle comprend les serveurs, les conteneurs, les composants de réseau, le pare-feu et d’autres ressources.

L’infrastructure dorsale est responsable de la haute disponibilité, de la mise à l’échelle, de l’équilibrage des charges, de la sécurité, du routage, etc. L’infrastructure dorsale doit être conçue de manière à offrir à l’utilisateur une expérience transparente.

Quels sont les éléments à prendre en compte lors du choix d’une infrastructure dorsale ?

Examinons les facteurs essentiels à prendre en compte lors du choix d’une infrastructure dorsale.

Vitesse

La vitesse est l’une des caractéristiques essentielles de l’infrastructure dorsale. Vos utilisateurs veulent que l’application fonctionne le mieux possible. C’est pourquoi vous devez optimiser la communication entre le client et le backend.

Pour atténuer la perception des retards de communication, vous pouvez utiliser quelques astuces astucieuses. Par exemple, vous pouvez mettre en place des écrans squelettes, des barres de chargement et afficher des conseils et astuces sur l’interface utilisateur.

La vitesse est également l’un des facteurs les plus critiques en matière de référencement.

Flexibilité

La flexibilité concerne les langages de programmation, les cadres et les autres technologies (par exemple, les bases de données) pris en charge par l’infrastructure dorsale. Lorsque vous choisissez une infrastructure dorsale, veillez à opter pour un produit qui prend en charge un grand nombre de technologies.

Évolutivité

Vous devez prendre en compte l’évolutivité dès le moment où vous commencez à construire votre application. Pensez à la façon dont votre application sera utilisée. Le nombre d’utilisateurs sera-t-il constant ou connaîtra-t-il parfois des pics de fréquentation ?

Votre infrastructure dorsale doit être conçue de manière à pouvoir faire face à des charges de travail extrêmes. Pour minimiser les dépenses liées aux serveurs, les instances de votre application doivent être créées et détruites à la volée.

Maintenabilité

Le développement et la publication de votre application ne représentent que 80 % du travail. Ensuite, vous devrez consacrer beaucoup de temps à la maintenance de votre application. La mise à jour du logiciel de votre serveur et le déploiement des correctifs de sécurité doivent être aussi simples que possible.

Optez pour une infrastructure backend avec un système CI/CD intégré, ou mettez en œuvre votre propre système.

Exigences DevOps

Certains types d’infrastructures dorsales sont plus difficiles à utiliser. Choisissez l’infrastructure dorsale que vous avez le temps et les ressources nécessaires pour gérer. Si vous décidez d’utiliser une infrastructure backend de niveau inférieur, comme IaaS, vous aurez besoin d’une équipe DevOps spécialisée pour la gérer.

Sécurité

Vous êtes entièrement responsable de la sécurité des données de vos utilisateurs. Face à l’augmentation du nombre de cyberattaques, vous devez vous assurer que votre infrastructure dorsale respecte les normes de sécurité les plus récentes.

Utilisez des mots de passe solides générés automatiquement, configurez le pare-feu, n’exécutez pas de logiciels non fiables sur vos serveurs, effectuez des contrôles de sécurité réguliers, etc.

Types d’infrastructures dorsales

Vous pouvez utiliser vos serveurs (ce que l’on appelle l’infrastructure traditionnelle) ou tirer parti de l’infrastructure en nuage pour déployer votre backend.

Au cours de la dernière décennie, de nombreuses entreprises se sont tournées vers les modèles en nuage parce qu’ils leur permettent d’économiser du temps et de l’argent.

Analysons quelques-unes des plus populaires d’entre elles.

Infrastructure en tant que service ou IaaS

L’infrastructure en tant que service (IaaS) est le modèle d’informatique en nuage le moins abstrait. Dans ce modèle, le fournisseur d’informatique en nuage met à disposition des ressources informatiques dans un environnement virtualisé, telles que des serveurs, du stockage, des systèmes d’exploitation et des composants de réseau.

L’IaaS existe depuis 2010 et reste le modèle d’informatique en nuage le plus populaire. Ses avantages sont une grande évolutivité, un contrôle de haut niveau et un prix avantageux. En revanche, les inconvénients sont une gestion complexe et des coûts de maintenance plus élevés que pour les autres modèles de cloud computing.

Parmi les fournisseurs IaaS les plus connus, on peut citer

• Google Cloud Platform (GCP)
• Amazon Web Services (AWS)
• Microsoft Azure

Plate-forme en tant que service ou PaaS

La plateforme en tant que service (PaaS) est un modèle d’informatique dématérialisée qui offre un environnement convivial de développement, de gestion et de diffusion d’applications. Elle comprend divers outils de développement d’applications intégrés, ce qui facilite la mise en place et le fonctionnement de votre application.

Le PaaS rationalise la gestion de l’infrastructure et permet une entrée plus rapide sur le marché, une sécurité renforcée, des économies, une évolutivité, une haute disponibilité et une réduction du codage. D’un autre côté, il peut vous lier aux capacités du fournisseur, poser des risques de verrouillage du fournisseur et limiter la flexibilité et le contrôle.

Voici quelques exemples de solutions PaaS :

• Rendu
• Heroku
• Fly.io

Backend en tant que service ou BaaS

Le Backend as a Service (BaaS) automatise le développement côté serveur et la gestion de l’infrastructure en nuage. Il offre des bases de données en temps réel, la gestion des utilisateurs, l’authentification, les notifications, l’intégration des médias sociaux, etc.

Le BaaS libère les développeurs des préoccupations liées au backend et leur permet de se concentrer sur le frontend et le cœur de métier. Le BaaS combine les avantages de l’IaaS et du PaaS avec l’abstraction du backend, ce qui permet d’accélérer la mise sur le marché et de réduire les coûts. Les inconvénients sont le manque de contrôle, le risque de verrouillage du fournisseur et le coût relativement élevé.

Mes plateformes BaaS préférées sont les suivantes :

• Back4app
• Firebase

Conteneurs en tant que service ou CaaS

Les conteneurs en tant que service (CaaS) sont un modèle d’informatique en nuage pour le téléchargement, la construction, la mise à l’échelle et la gestion des conteneurs. CaaS inclut généralement un runtime de conteneurs, un registre de conteneurs, une fonctionnalité de mise à l’échelle automatique, un système CI/CD intégré, un équilibrage de charge et bien plus encore !

CaaS simplifie la gestion des conteneurs et élimine les préoccupations liées à l’infrastructure sous-jacente. Il encourage le développement agile, facilite l’architecture des microservices et accélère la création d’applications hautement évolutives.

Les plateformes CaaS comprennent

• Conteneurs Back4app
• Amazon Elastic Container Service
• Google Cloud Kubernetes

Comment créer une infrastructure dorsale ?

Dans cette partie de l’article, nous allons créer une infrastructure backend en utilisant Back4app.

Qu’est-ce que Back4app ?

Back4app est une plateforme exceptionnelle de Backend as a Service (BaaS). Elle vous permet de créer rapidement des backends pour des applications web et mobiles.

La plateforme est construite à partir de technologies open source et possède de nombreuses fonctionnalités. Elle comprend des bases de données de type tableur, le stockage de fichiers, la gestion des utilisateurs, l’authentification, des API générées automatiquement, des notifications, et bien d’autres choses encore !

Back4app peut vous aider à accélérer considérablement votre temps de mise sur le marché. En l’utilisant, vous pouvez vous concentrer sur le cœur de votre activité sans vous préoccuper du backend ou de l’infrastructure sous-jacente.

Vous n’aurez pas besoin d’ingénieurs DevOps spécialisés, et vos coûts de maintenance seront moins élevés.

La meilleure chose à propos de Back4app est qu’il est livré avec un niveau gratuit. Le niveau gratuit est excellent pour tester la plateforme ou héberger des petits projets. Si votre application a du succès, vous pouvez passer au niveau premium.

Pour en savoir plus sur Back4app, consultez la page Qu’est-ce que Back4app ?

Aperçu du projet

Pour montrer comment créer un backend, nous allons construire un simple service de backend de commerce électronique. Le backend nous permettra de gérer les produits, les catégories et les commandes.

Le diagramme ER de notre projet ressemblera à ceci :

Nous allons créer le backend avec un minimum de code et démontrer comment il peut être utilisé côté client (via les SDK, l’API REST et l’API GraphQL).

Créer une application

Pour suivre l’actualité, un compte Back4app est nécessaire. Vous en avez besoin ? Inscrivez-vous dès aujourd’hui !

Après vous être connecté à votre compte Back4app, vous verrez la liste de vos applications. Cliquez sur le bouton “Build app” pour lancer le processus de création d’application.

Ensuite, sélectionnez “BaaS” car nous mettons en place un backend.

Choisissez un nom d’application, sélectionnez “NoSQL” et créez l’application.

Back4app va prendre du temps pour tout mettre en place. Il s’occupera de la couche applicative, de la base de données, des sauvegardes, de la mise à l’échelle, et plus encore.

Une fois l’application créée, vous accédez à la base de données en temps réel de votre application.

Configuration de la base de données

Maintenant que nous avons créé notre application, occupons-nous de la base de données.

Nous devons d’abord créer une classe pour stocker les données dans la base de données. Les classes peuvent être considérées comme des tables (terminologie SQL) ou des modèles (terminologie ORM). Chaque classe possède par défaut les quatre champs suivants :

+-------------+-------------+------------------------------------------+
| Type        | Name        | Description                              |
+-------------+-------------+------------------------------------------+
| String      | objectId    | Object's unique identifier               |
+-------------+-------------+------------------------------------------+
| Date        | updatedAt   | Date time of the last update             |
+-------------+-------------+------------------------------------------+
| Date        | createdAt   | Date time of creation                    |
+-------------+-------------+------------------------------------------+
| ACL         | ACL         | Access Control List                      |
+-------------+-------------+------------------------------------------+

Comme indiqué dans l’aperçu du projet, notre projet comportera trois classes. Créez la première en cliquant sur le bouton “Create class” dans la barre latérale. Nommez-la ProductCategory:

Ajoutez les champs suivants :

+-----------------------------+-------------+---------------+----------+
| Type                        | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+

Procédez de la même manière pour la classe Produit:

+-----------------------------+-------------+---------------+----------+
| Type                        | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Relation -> ProductCategory | categories  | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Number                      | price       | 0             | yes      |
+-----------------------------+-------------+---------------+----------+

Nous avons utilisé le type de données Relation pour gérer la relation plusieurs à plusieurs.

Enfin, créez la classe Order:

+-----------------------------+------------+---------------+----------+
| Data type                   | Name       | Default value | Required |
+-----------------------------+------------+---------------+----------+
| Pointer -> Product          | product    | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cFirstName | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cLastName  | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cAddress   | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| Number                      | delivered  | false         | yes      |
+-----------------------------+------------+---------------+----------+

Nous avons utilisé le type de données Pointer pour gérer la relation un-à-plusieurs.

Une fois que vous avez terminé, vous devriez voir les classes dans la barre latérale.

Alimenter la base de données

Continuons à alimenter la base de données.

Commencez par créer quelques catégories de produits, produits et commandes (dans cet ordre). Si vous êtes à court d’idées, n’hésitez pas à importer cette fixation.

Pour importer un fichier JSON, utilisez l’option “Plus d’options > Importer > Données de classe > Sélectionner un fichier”. Veillez à importer les fichiers JSON dans l’ordre suivant :

1. Catégorie de produit.json
2. Produit.json
3. Joindre꞉catégories꞉Produit.json
4. Order.json

Une fois que vous avez terminé, vous devriez avoir quelques produits, catégories et commandes dans votre base de données. Cette étape est nécessaire car nous aurons besoin de certaines données pour tester le backend dans la phase suivante.

Sécuriser la base de données

Par défaut, les classes de base de données sont créées en “mode protégé”. En mode protégé, la seule façon d’interagir et de gérer les objets est d’utiliser la clé principale. Ce n’est pas optimal car nous ne pouvons pas récupérer ou gérer les objets du côté client.

Pour ce faire, nous devons assouplir certaines restrictions. Back4app/Parse propose deux mécanismes de restriction :

1. Autorisations au niveau de la classe (CLP)
2. Autorisations au niveau de l’accès (ACL)

Les CLP nous permettent d’appliquer des restrictions au niveau de la classe, tandis que les ACL nous permettent d’appliquer des restrictions au niveau de l’objet. Les deux mécanismes peuvent restreindre une classe ou un objet à un rôle ou à un utilisateur spécifique.

Sélectionnez la classe de produits dans la barre latérale et cliquez sur le texte “Protégé” en haut de l’écran. Modifiez ensuite les CLP :

Procédez de la même manière pour le modèle ProductCategory.

Mettez ensuite à jour les CLP pour la classe Order:

Faites attention à l’image. Ici, nous activons également l’autorisation de création.

Les nouveaux CLP permettront aux utilisateurs non authentifiés de rechercher, d’interroger et de compter des produitset des catégories de produits, mais pas de les modifier. Il en va de même pour la classe Order, mais ici, les utilisateurs peuvent également créer de nouvelles commandes.

Pour en savoir plus, consultez notre article sur la sécurité du serveur Parse.

App Admin

Actuellement, la seule façon de gérer les objets de votre base de données est d’utiliser la vue de la base de données. Si cette méthode fonctionne pour les développeurs, elle n’est pas intuitive pour les utilisateurs non techniciens. En outre, elle donne aux utilisateurs trop de contrôle et est sujette aux erreurs humaines.

Heureusement, Back4app vous permet d’activer facilement la fonctionnalité “Admin App”. Admin app est un panneau d’administration facile à utiliser, adapté à vos classes de base de données.

Activez-la en naviguant d’abord vers “Plus > Admin App” dans la barre latérale. Cliquez ensuite sur “Activer” :

Back4app vous demandera de choisir un nom d’utilisateur, un mot de passe et un sous-domaine. J’ai décidé d’opter pour ce qui suit :

user:        root
pass:        complexpassword123
subdomain:   https://binfra.admin.back4app.com/

C’est parfait, c’est tout ce que vous avez à faire.

Vous pouvez accéder au panneau d’administration en cliquant sur “Admin App URL”. Une nouvelle fenêtre de navigateur s’ouvrira en cliquant dessus, et il vous sera demandé d’entrer vos identifiants d’administrateur. Une fois connecté, vous pouvez créer, mettre à jour et supprimer des objets.

Essayez de jouer avec le tableau de bord pour vous y habituer.

Code du nuage

Back4app vous permet d’exécuter du code JavaScript personnalisé via ce que l’on appelle Cloud Code. Avec Cloud Code, vous pouvez définir des fonctions qui peuvent être déclenchées par Parse, des requêtes HTTP, ou exécutées périodiquement. En outre, Cloud Code peut être utilisé pour créer des applications web à l’aide d’Express.

Fonction du code cloud

Supposons que nous voulions une fonction Cloud Code qui calcule les ventes actuelles.

Tout d’abord, naviguez vers “Cloud Code > Function & Web Hosting” dans la barre latérale. Vous remarquerez que la vue de Cloud Code est divisée en deux parties. Sur le côté gauche, vous pouvez voir la structure du répertoire et le code sur la droite.

Ensuite, ouvrez cloud/main.js et collez le code suivant :

// cloud/main.js

Parse.Cloud.define("calculateSales", async (request) => {
  const orderClass = Parse.Object.extend("Order");
  const orderQuery = new Parse.Query(orderClass);
  let sales = 0;

  try {
    const orders = await orderQuery.find();

    for (var i = 0; i < orders.length; i++) {
      let order = orders[i];
      let productId = order.get("product")["id"];

      const productClass = Parse.Object.extend("Product");
      const productQuery = new Parse.Query(productClass);
      const product = await productQuery.get(productId);

      sales += product.get("price");
    }
    return { 
      sales: sales,
    };
  } catch (error) {
    console.error("Error calculating the sales: " + error.message);
    return {
      sales: 0,
    }
  }
});

Parse.Cloud.job("printSales", async (request, status) => {
  try {
    const result = await Parse.Cloud.run("calculateSales");
    console.log("Sales: " + result.sales + "$");
  } catch (error) {
    console.error("Error calculating the sales: " + error.message);
  }
});

1. Nous avons défini une fonction Cloud Code appelée calculateSales(). Cette fonction parcourt toutes les commandes, récupère les produits correspondants et calcule leur prix.
2. Nous avons défini un Cloud Code Job appelé printSales(), qui nous permet d’exécuter la fonction à partir du tableau de bord Parse et de la programmer périodiquement.

Enfin, cliquez sur “Deploy” pour déployer le code cloud.

Assurez-vous que la tâche fonctionne en naviguant vers “Cloud Code > Jobs” dans la barre latérale, puis en exécutant la tâche printSales(). Si tout fonctionne bien, vous devriez voir un message indiquant, par exemple, Sales : 1440$ lorsque vous vérifiez les journaux.

Ordonnancement du code dans le nuage

Pour planifier le travail, vous devez naviguer vers “App Settings > Server Settings” sur la barre latérale. Descendez jusqu’à “Background jobs”, cliquez sur “Schedule a job”, et remplissez le formulaire.

Pour vous assurer que cela fonctionne, vérifiez à nouveau les journaux.

Côté client

Il y a plusieurs façons d’interagir avec votre backend basé sur Back4app :

1. Parse SDK
2. API RESTful (générée automatiquement)
3. API GraphQL (générée automatiquement)

En règle générale, vous devriez toujours utiliser Parse SDK s’il est disponible pour votre plateforme. Si ce n’est pas le cas, optez pour l’API RESTful ou l’API GraphQL. Le choix entre les API dépend de vos données.

Apprenez à utiliser Parse SDK avec différents frameworks en consultant la documentation.

Néanmoins, testons notre backend à l’aide de la console REST intégrée.

Naviguez vers “API > REST” dans la barre latérale et essayez d’interroger tous les produits en remplissant le formulaire :

Vous devriez obtenir une réponse similaire :

{
    "results": [
        {
            "objectId": "4ZyHH3X0RQ",
            "name": "Fitness Tracker Watch",
            "description": "...",
            "price": 80,
            "createdAt": "2023-10-17T20:03:55.424Z",
            "updatedAt": "2023-10-17T20:24:12.322Z",
            "categories": {
                "__type": "Relation",
                "className": "ProductCategory"
            }
        },
        {
            "objectId": "cDqlGJzT5U",
            "name": "Organic Fruit Basket",
            "description": "...",
            "price": 40,
            "createdAt": "2023-10-17T20:04:10.063Z",
            "updatedAt": "2023-10-17T20:24:00.382Z",
            "categories": {
                "__type": "Relation",
                "className": "ProductCategory"
            }
        },
    // ...
}

Essayez d’effectuer les recherches suivantes :

1. Récupérer tous les produits dont le prix est supérieur à 50
2. Récupérer toutes les commandes qui n’ont pas encore été livrées
3. Créer un nouveau produit et lui ajouter une catégorie
4. Supprimer une commande

Conclusion

En conclusion, vous savez maintenant ce qu’est une infrastructure backend, vous connaissez les différents types d’infrastructures backend et vous savez comment choisir l’infrastructure appropriée pour votre projet.

De plus, vous avez appris à créer une infrastructure backend sur Back4app. Vous vous êtes occupé de la base de données, de la sécurité de la base de données, du code personnalisé, de la planification des tâches et des tests de l’API.

Pour obtenir des conseils sur la création du côté client d’un backend basé sur Back4app, consultez nos autres articles :

1. Comment héberger le frontend et le backend ?
2. Comment développer une application pour les médias sociaux ?
3. Comment construire un chatbot avec React ?

Des articles supplémentaires sont disponibles en libre accès sur GitHub.