Protocole HTTP et son implémentation dans Node.js
Published: 2022-11-01 13:13:45

 HTTP HyperText Transfer Protocol ou Protocole de Transfert Hypertexte en français est un protocole de communication permettant de récupérer et d’envoyer des ressources hypermédia, en un mot il est conçu pour permettre les communications entre les clients et les serveurs.
               Au départ, HTTP a été créé pour permettre de transfert de documents HTML uniquement puis ses usages se sont rapidement étendus pour permettre de transférer d’autres types de ressources comme des images, des vidéos ou d’autres types de fichiers.
                Un protocole est tout simplement un ensemble de règles, un ensembles des consignes, des normes  qui régissent les échanges de données.

_HTTP, un protocole de transfert client – serveur_

Le protocole HTTP est basé sur un modèle client-serveur. Dans les modèles de communication client-serveur, le client est toujours celui qui demande à accéder (demande de récupérer) une ressource tandis que le serveur est toujours celui qui va répondre à la demande (qui va « servir » la ressource).

Dans la majorité des cas, le client va être un navigateur. Par exemple, lorsqu’un visiteur cherche à accéder à l’une de nos pages web, il va taper une URL dans son navigateur. Le navigateur va alors demander au serveur sur lequel est stockée la page de la lui renvoyer. La demande du client est appelée une requête HTTP,.

_HTTP, un protocole sans état et évolutif_

HTTP est l’une des trois inventions majeures qui ont permis la création du web. HTTP est donc présent depuis la création du web et a su évoluer jusqu’à aujourd’hui pour répondre à l’évolution et à la diversification des usages du web et pour faire en sorte qu’ils soient possibles.

Au début du web, les pages n’étaient composés que de HTML et ne faisaient pas appel à des ressources externes. Le client n’avait donc qu’à effectuer une requête au serveur afin que celui-ci lui renvoie le document HTML. Aujourd’hui, les pages web sont composées de différentes ressources : une structure HTML, des ressources CSS, JavaScript, des images, vidéos, etc.

Les usages se sont également diversifiés : au départ du web, la seule opération possible en tant qu’utilisateur était la récupération et la visualisation d’une ressource. Aujourd’hui, on peut également envoyer ou modifier des informations (via des formulaires HTML notamment)

_HTTP et HTTPS_
HTTP est un protocole de transfert de la couche application . Ce protocole permet l’envoi et la récupération ressources hypermédias.

Il y a quelques années, la plupart des utilisateurs du web ne faisaient pas confiance aux sites et n’osaient pas acheter sur le web car ils devaient transmettre des informations sensibles comme des numéros de carte bleu.

Netscape a alors inventé un protocole de sécurisation des échanges de données appelées SSL pour Secure Sockets Layer.

L’IETF (groupe chargé de la standardisation de certains protocoles et notamment chargé de l’évolution de HTTP) a ensuite continué son développement en le renommant TLS (Transport Layer Security).

TLS est aujourd’hui la norme dans le chiffrement / cryptage des échanges de données sur le net. HTTPS est simplement une variante de HTTP qui implémente ce protocole de sécurisation.

Pour information, un serveur HTTP utilise le port 80 par défaut. Un serveur supportant HTTPS utilisera le port 443 par défaut. Un « port » permet de distinguer différents interlocuteurs (différents programmes ou applications).

_Les Méthodes HTTP_

- GET
- POST
- PUT
- HEAD
- DELETE
- PATCH
- OPTIONS
- CONNECT
- TRACE

Les deux méthodes HTTP les plus courantes sont : GET et POST.

_La méthode GET_
_GET_ est utilisé pour demander des données à une ressource spécifiée.

Quelques notes sur les requêtes GET :

Les requêtes GET peuvent être mises en cache
Les requêtes GET restent dans l'historique du navigateur
Les requêtes GET peuvent être mises en signet
Les requêtes GET ne doivent jamais être utilisées lorsqu'il s'agit de données sensibles
Les requêtes GET ont des restrictions de longueur
Les requêtes GET ne sont utilisées que pour demander des données (pas pour les modifier)

**_La méthode POST_**
**_POST_** est utilisé pour envoyer des données à un serveur pour créer/mettre à jour une ressource.

Les données envoyées au serveur avec POST sont stockées dans le corps de la requête HTTP ,

Quelques notes sur les requêtes POST :

Les requêtes POST ne sont jamais mises en cache
Les requêtes POST ne restent pas dans l'historique du navigateur
Les requêtes POST ne peuvent pas être mises en signet
Les requêtes POST n'ont aucune restriction sur la longueur des données

_**La méthode PUT**_
PUT est utilisé pour envoyer des données à un serveur pour créer/mettre à jour une ressource.

La différence entre POST et PUT est que les requêtes PUT sont idempotentes. Autrement dit, appeler plusieurs fois la même requête PUT produira toujours le même résultat. En revanche, l'appel répété d'une requête POST a pour effet secondaire de créer plusieurs fois la même ressource.

_**La méthode HEAD**_
HEAD est presque identique à GET, mais sans le corps de la réponse.

En d'autres termes, si GET /users renvoie une liste d'utilisateurs, alors HEAD /users fera la même requête mais ne renverra pas la liste des utilisateurs.

Les requêtes HEAD sont utiles pour vérifier ce qu'une requête GET renverra avant de faire une requête GET - comme avant de télécharger un gros fichier ou un corps de réponse.

_**La méthode DELETE**_
La méthode DELETE supprime la ressource spécifiée.

_**La méthode PATCH**_
La méthode PATCH permet d'appliquer des modifications partielles à une ressource.

_**La méthode OPTIONS**_
La méthode OPTIONS décrit les options de communication pour la ressource cible.
_**
La méthode CONNECT
**_La méthode CONNECT est utilisée pour démarrer une communication bidirectionnelle (un tunnel) avec la ressource demandée.

_**La méthode TRACE**_
La méthode TRACE est utilisée pour effectuer un test de bouclage de message qui teste le chemin de la ressource cible (utile à des fins de débogage).

_**
Le module HTTP intégré**_
Node.js possède un module intégré appelé HTTP, qui permet à Node.js de transférer des données via le protocole HTTP (Hyper Text Transfer Protocol).

Pour inclure le module HTTP, utilisez la <u>_**require()**_</u>méthode :

```
const http = require('http');
```

_**Node.js en tant que serveur Web**_
Le module HTTP peut créer un serveur HTTP qui écoute les ports du serveur et renvoie une réponse au client.

Utilisez la <u>_**createServer()**_</u>méthode pour créer un serveur HTTP :

```
const http = require('http');

http.createServer(function (req, res) {
  res.write('Hello World!'); 
  res.end(); 
}).listen(2020); 
```


La fonction passée dans la http.createServer() méthode sera exécutée lorsque quelqu'un tentera d'accéder à l'ordinateur sur le port 2020.

Enregistrez le code ci-dessus dans un fichier appelé "demo_http.js", et lancez le fichier :

```
$node demo_http.js
```

**_Ajouter un en-tête HTTP_**
Si la réponse du serveur HTTP est censée être affichée au format HTML, vous devez inclure un en-tête HTTP avec le type de contenu correct :

```
const http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.write('Hello World!');
  res.end();
}).listen(2020);
```

Le premier argument de la <u>_**res.writeHead()**_</u>méthode est le code d'état, 200 signifie que tout est OK, le deuxième argument est un objet contenant les en-têtes de réponse.

**_Lire la chaîne de requête_**
La fonction passée à <u>_**http.createServer()**_</u> a un req argument qui représente la demande du client, sous la forme d'un objet (objet http.IncomingMessage).

Cet objet a une propriété appelée "_**url"**_ qui contient la partie de l'url qui vient après le nom de domaine :


```
const http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.write(req.url);
  res.end();
}).listen(2020);
```

Enregistrez le code ci-dessus dans un fichier appelé "demo_http_url.js" et lancez le fichier :

`$node demo_http_url.`

**_Fractionner la chaîne de requête_**
Il existe des modules intégrés pour diviser facilement la chaîne de requête en parties lisibles, comme le module URL.

```
const http = require('http');
const url = require('url');

http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/html'});
  var q = url.parse(req.url, true).query;
  var txt = q.year + " " + q.month;
  res.end(txt);
}).listen(2020);
```
Enregistrez le code ci-dessus dans un fichier appelé "demo_querystring.js" et lancez le fichier :
$node demo_querystring.js