Éléments à surveiller lors de la configuration d’un serveur Express

Dans cet article, nous passerons en revue quelques éléments à prendre en compte lors du développement d’un serveur Express.

Dans cet article, nous montrerons comment créer un serveur Express de base et effectuer des requêtes HTTP simples pour les ressources présentes sur notre serveur, et nous passerons en revue certaines des choses à garder à l’esprit lors de cette opération.

Configuration du projet

Tout d’abord, nous devons installer Node.js sur notre appareil car Express est un framework JavaScript permettant de créer des serveurs avec Node.js. Vous pouvez obtenir la dernière version de Node.js ici. Maintenant, allons-y et configurons notre application Node.js.

npm init --yes

Cette commande initialisera notre application Node.js et créera un package.json fichier dans notre répertoire de projet.

{
  "name": "node",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Mettez à jour le contenu des scripts dans votre fichier package.json pour qu’il ressemble à ceci :

"scripts": {
  "start": "node index.js"
},

Créez un fichier dans le répertoire racine de votre projet et nommez-le index.js. Cela servira de dossier d’entrée pour notre application. Ensuite, installons Express. Exécutez la commande suivante dans votre terminal :

npm install express

Ajoutez ce qui suit à votre index.js dossier:

const express = require('express');
const app = express();

app.get("https://www.telerik.com/", (req, res) => {
  res.send('Hello World');
});
const port = process.env.PORT || 5000;
app.listen(port, () => console.log(`Listening on port ${port}...`));

Tapez la commande ci-dessous dans votre terminal pour démarrer votre serveur :

node index.js

Maintenant, si nous naviguons vers localhost:5000, nous obtenons la réponse "Hello World".

Nous avons configuré notre application pour recevoir des demandes, mais pour que la communication soit possible entre notre application et toute autre qui souhaite s’y connecter, nous devons intégrer des fonctionnalités supplémentaires.

SCRO

CORS, qui signifie Cross-Origin Resource Sharing, est un mécanisme de sécurité mis en œuvre par les serveurs. Il permet à un serveur de spécifier une liste de domaines ou de ports qui ont accès aux ressources de son domaine. Avec CORS spécifié, les demandes externes de ressources adressées à notre serveur ne seront pas autorisées à accéder à ces ressources. CORS est généralement envoyé avec les en-têtes HTTP.

Les navigateurs demandant des ressources envoient d’abord une demande de « contrôle en amont » au serveur sur lequel la ressource d’origine croisée est présente pour vérifier si le serveur approuvera la demande de ressource. D’autres informations liées à la demande, telles que la méthode HTTP et les en-têtes, sont envoyées pendant le contrôle en amont.

Maintenant, implémentons CORS dans notre application. Exécutez cette commande dans votre terminal pour installer le package CORS :

npm install cors

Mettons à jour notre index.js fichier avec le code suivant avec CORS installé et activé.

const express = require('express');
var cors = require('cors');
const app = express();
var corsOptions = {
  origin: 'http://example.com',
  optionsSuccessStatus: 200, 
};
app.get("https://www.telerik.com/", (req, res) => {
  res.send('Hello World');
});
app.get('/cors-enabled', cors(corsOptions), (req, res, next) => {
  res.send('This link is cors enabled');
});
const port = process.env.PORT || 5000;
app.listen(port, () => console.log(`Listening on port ${port}...`));

Dans le code ci-dessus, nous avons besoin corspuis nous définissons certaines configurations d’options avec lesquelles nous voulons que notre cors fonctionne, ce qui spécifie que notre code ne doit autoriser que les requêtes pour une ressource à partir de http//:example.com. Celui-ci est alors affecté en tant que middleware pour n’être fonctionnel que pour une seule route, c’est-à-dire un get demande à la route activée par cors.

Intergiciel

Dans le code ci-dessus, nous avons vu un exemple de middleware (cors). Une fonction middleware est une fonction qui se situe entre une requête à une ressource et la réponse à renvoyer. Il a accès à l’objet requête, à l’objet réponses et au next() fonction dans le cycle requête-réponse de l’application. Il peut traiter la demande avant que le serveur n’envoie une réponse.

Une fonction middleware peut être jointe à d’autres fonctions middleware résultant en une chaîne exécutée dans l’ordre. Une fonction middleware peut invoquer la fonction middleware suivante en appelant next() ou terminez la demande en envoyant une réponse au client.

De l’exemple cors ci-dessus, nous avons :

app.get('/cors-enabled', cors(corsOptions), (req, res, next) => {
   res.send('This link is cors enabled');
})

La position de cors(corsOptions) est l’endroit où le middleware est spécifié. Les fonctions du middleware jouent un rôle essentiel dans le traitement des requêtes reçues des requêtes HTTP et dans l’exécution des contrôles, des fonctions de sécurité, des fonctions d’autorisation, etc.

Il existe deux manières d’implémenter des fonctions middleware dans Express. Vous pouvez spécifier un middleware pour prendre forme et capturer la requête HTTP pour traiter une route spécifique ou la spécifier pour toutes les routes.

Paramètres pour un seul itinéraire

Le middleware est ajouté à la route qui gère cette demande particulière, et il se situe entre le chemin d’URL que la route a l’intention de capturer et la fonction de contrôleur finale que nous écrivons pour récupérer les ressources et renvoyer les réponses.

app.get('/cors-enabled', cors(corsOptions), (req, res, next) => {
   res.send('This link is cors enabled');
})

Paramètres pour tous les itinéraires

Le middleware est ajouté à l’application Express et implémenté par l’appel à app.use() avec la fonction middleware spécifiée, et ceci avant que toute route ne soit gérée.

app.use(express.json());

Analyseur de corps

Body-parser est un middleware d’analyse de corps Node.js qui valide le corps de la requête envoyée par le client avant qu’il ne soit envoyé au serveur. L’analyseur de corps analyse les données brutes, le JSON, le texte et le corps de la requête codée en URL à l’aide de quatre types de middleware. Les quatre principales méthodes HTTP utilisées lors des demandes de ressources sont Get, Post, Put et Delete. Post et Put les requêtes sont principalement analysées car elles doivent envoyer des données au serveur.

Avant la sortie d’Express 4.16, vous devez installer le package body-parser pour l’utiliser ; cependant, à partir d’Express 4.16+, il a été inclus dans le package Express par défaut et ne doit plus être installé séparément.

const express = require('express');
const app = express();
app.get("https://www.telerik.com/", (req, res) => {
  res.send('Data fetching request');
});

app.use(express.json());
app.post('/books', (req, res) => {
  res.send(req.body);
});

const ymlParser = express.raw({ type: 'application/yml' });
app.post('/author-name', ymlParser, (req, res) => {
  console.log(req.body);
  res.send(req.body);
});
const port = process.env.PORT || 5000;
app.listen(port, () => console.log(`Listening on port ${port}...`));

Conclusion

Dans cet article, nous avons passé en revue quelques éléments à prendre en compte lors du développement d’un serveur Express. C’est tout pour le moment; S’il vous plaît laissez-moi savoir si vous avez des questions ou des suggestions.