Premiers pas avec Node.js

Serveur HTTP Hello World

Tout d’abord, installez Node.js pour votre plate-forme.

Dans cet exemple, nous allons créer un serveur HTTP écoutant sur le port 1337, qui envoie “Hello, World!” au navigateur. Notez qu’au lieu d’utiliser le port 1337, vous pouvez utiliser n’importe quel numéro de port de votre choix qui n’est actuellement utilisé par aucun autre service.

Le module http est un Node.js [core module](https://www.wikiod.com/fr/node-js/premiers-pas-avec-nodejs#Modules de base ) (un module inclus dans la source de Node.js, qui ne nécessite pas l’installation de ressources supplémentaires). Le module http fournit la fonctionnalité pour créer un serveur HTTP en utilisant la méthode http.createServer(). To create the application, create a file containing the suivant le code JavaScript.

const http = require('http'); // Loads the http module

http.createServer((request, response) => {

    // 1. Tell the browser everything is OK (Status code 200), and the data is in plain text
    response.writeHead(200, {
        'Content-Type': 'text/plain'
    });

    // 2. Write the announced text to the body of the page
    response.write('Hello, World!\n');

    // 3. Tell the server that all of the response headers and body have been sent
    response.end();

}).listen(1337); // 4. Tells the server what port to be on

Enregistrez le fichier avec n’importe quel nom de fichier. Dans ce cas, si nous le nommons hello.js, nous pouvons exécuter l’application en accédant au répertoire dans lequel se trouve le fichier et en utilisant la commande suivante :

node hello.js

Le serveur créé est alors accessible avec l’URL http://localhost:1337 ou http://127.0.0.1:1337 dans le navigateur.

Une page Web simple apparaîtra avec un “Hello, World!” texte en haut, comme indiqué dans la capture d’écran ci-dessous.

[![Capture d’écran][1]][1]

[Exemple modifiable en ligne.][2]

[1] : http://i.stack.imgur.com/Oq3Y4.png [2] : https://glitch.com/edit/#!/node-hello-world

Ligne de commande Hello World

Node.js peut également être utilisé pour créer des utilitaires de ligne de commande. L’exemple ci-dessous lit le premier argument de la ligne de commande et imprime un message Hello.

Pour exécuter ce code sur un système Unix :

  1. Créez un nouveau fichier et collez le code ci-dessous. Le nom du fichier est sans importance.
  2. Rendez ce fichier exécutable avec chmod 700 FILE_NAME
  3. Exécutez l’application avec ./APP_NAME David

Sous Windows, vous faites l’étape 1 et l’exécutez avec node APP_NAME David

#!/usr/bin/env node

'use strict';

/*
    The command line arguments are stored in the `process.argv` array, 
    which has the following structure:
    [0] The path of the executable that started the Node.js process
    [1] The path to this application
    [2-n] the command line arguments

    Example: [ '/bin/node', '/path/to/yourscript', 'arg1', 'arg2', ... ]
    src: https://nodejs.org/api/process.html#process_process_argv
 */

// Store the first argument as username.
var username = process.argv[2];

// Check if the username hasn't been provided.
if (!username) {

    // Extract the filename
    var appName = process.argv[1].split(require('path').sep).pop();

    //  Give the user an example on how to use the app.
    console.error('Missing argument! Example: %s YOUR_NAME', appName);

    // Exit the app (success: 0, error: 1). 
    // An error will stop the execution chain. For example:
    //   ./app.js && ls       -> won't execute ls
    //   ./app.js David && ls -> will execute ls
    process.exit(1);
}

// Print the message to the console.
console.log('Hello %s!', username);

Bonjour le monde avec Express

L’exemple suivant utilise Express pour créer un serveur HTTP écoutant sur le port 3000, qui répond par “Hello, World!”. Express est un framework Web couramment utilisé qui est utile pour créer des API HTTP.

Commencez par créer un nouveau dossier, par ex. monApp. Allez dans myApp et créez un nouveau fichier JavaScript contenant le code suivant (nommons-le hello.js par exemple). Ensuite, installez le module express en utilisant npm install --save express à partir de la ligne de commande. Reportez-vous à [cette documentation][1] pour plus d’informations sur l’installation des packages.

// Import the top-level function of express
const express = require('express');

// Creates an Express application using the top-level function
const app = express();

// Define port number as 3000
const port = 3000;

// Routes HTTP GET requests to the specified path "/" with the specified callback function
app.get('/', function(request, response) {
  response.send('Hello, World!');
});

// Make the app listen on port 3000
app.listen(port, function() {
  console.log('Server listening on http://localhost:' + port);
});

Depuis la ligne de commande, exécutez la commande suivante :

node hello.js

Ouvrez votre navigateur et accédez à http://localhost:3000 ou http://127.0.0.1:3000 pour voir la réponse.

Pour plus d’informations sur le framework Express, vous pouvez consulter la section [Web Apps With Express][2]

[1] : https://www.wikiod.com/fr/node-js/npm#Installation de packages [2] : https://www.wikiod.com/fr/node-js/applications-web-avec-express

Installation et exécution de Node.js

Pour commencer, installez Node.js sur votre ordinateur de développement.

Windows : Accédez à la [page de téléchargement][1] et téléchargez/exécutez le programme d’installation.

Mac : Accédez à la [page de téléchargement][1] et téléchargez/exécutez le programme d’installation. Alternativement, vous pouvez installer Node via Homebrew en utilisant brew install node. Homebrew est un gestionnaire de paquets en ligne de commande pour Macintosh, et plus d’informations à ce sujet peuvent être trouvées sur le [site Web Homebrew][2].

Linux : Suivez les instructions de votre distribution sur la [page d’installation de la ligne de commande][3].

Exécution d’un programme de nœud

Pour exécuter un programme Node.js, exécutez simplement node app.js ou nodejs app.js, où app.js est le nom de fichier du code source de votre application de nœud. Vous n’avez pas besoin d’inclure le suffixe .js pour que Node trouve le script que vous souhaitez exécuter.

Alternativement, sous les systèmes d’exploitation basés sur UNIX, un programme Node peut être exécuté en tant que script de terminal. Pour ce faire, il doit commencer par un shebang pointant vers l’interpréteur Node, tel que #!/usr/bin/env node. Le fichier doit également être défini comme exécutable, ce qui peut être fait en utilisant chmod. Maintenant, le script peut être exécuté directement à partir de la ligne de commande.

[1] : https://nodejs.org/en/download/ [2] : http://brew.sh/ [3] : https://nodejs.org/en/download/package-manager/

Débogage de votre application NodeJS

Vous pouvez utiliser l’inspecteur de nœud. Exécutez cette commande pour l’installer via npm :

npm install -g node-inspector

Ensuite, vous pouvez déboguer votre application en utilisant

node-debug app.js

Le référentiel Github peut être trouvé ici : https://github.com/node-inspector/node-inspector

Débogage en natif

Vous pouvez également déboguer nativement node.js en le démarrant comme ceci :

node debug your-script.js

Pour arrêter votre débogueur exactement dans une ligne de code que vous voulez, utilisez ceci :

debugger;

Pour plus d’informations, voir ici.

Dans node.js 8, utilisez la commande suivante :

node --inspect-brk your-script.js

Ensuite, ouvrez about://inspect dans une version récente de Google Chrome et sélectionnez votre script Node pour obtenir l’expérience de débogage des DevTools de Chrome.

Routage de base Hello World

Une fois que vous avez compris comment créer un [serveur HTTP] [1] avec nœud, il est important de comprendre comment lui faire “faire” des choses en fonction du chemin vers lequel un utilisateur a navigué. Ce phénomène est appelé “routage”.

L’exemple le plus basique serait de vérifier if (request.url === 'some/path/here'), puis d’appeler une fonction qui répond avec un nouveau fichier.

Un exemple de ceci peut être vu ici:

const http = require('http');

function index (request, response) {
    response.writeHead(200);
    response.end('Hello, World!');
}

http.createServer(function (request, response) {
    
    if (request.url === '/') {
        return index(request, response);
    }

    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);

}).listen(1337);

Si vous continuez à définir vos “routes” comme ceci, cependant, vous vous retrouverez avec une fonction de rappel massive, et nous ne voulons pas d’un gâchis géant comme celui-là, alors voyons si nous pouvons nettoyer cela.

Tout d’abord, stockons toutes nos routes dans un objet :

var routes = {
    '/': function index (request, response) {
        response.writeHead(200);
        response.end('Hello, World!');
    },
    '/foo': function foo (request, response) {
        response.writeHead(200);
        response.end('You are now viewing "foo"');
    }
}

Maintenant que nous avons stocké 2 routes dans un objet, nous pouvons maintenant les vérifier dans notre callback principal :

http.createServer(function (request, response) {
    
    if (request.url in routes) {
        return routes[request.url](request, response);
    }

    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);

}).listen(1337);

Désormais, chaque fois que vous essayez de naviguer sur votre site Web, il vérifie l’existence de ce chemin dans vos itinéraires et appelle la fonction correspondante. Si aucune route n’est trouvée, le serveur répondra par un 404 (Not Found).

Et voilà, le routage avec l’API HTTP Server est très simple.

[1] : https://www.wikiod.com/fr/node-js/premiers-pas-avec-nodejs#Serveur HTTP Hello World

Hello World dans le REPL

Lorsqu’il est appelé sans arguments, Node.js démarre un REPL (Read-Eval-Print-Loop) également appelé « Node shell ».

À une invite de commande, tapez “nœud”.

$ node
>

À l’invite du shell Node >, tapez “Hello World!”

$ node
> "Hello World!"
'Hello World!'

Déployer votre application en ligne

Lorsque vous déployez votre application dans un environnement hébergé (spécifique à Node.js), cet environnement propose généralement une variable d’environnement PORT que vous pouvez utiliser pour exécuter votre serveur. Changer le numéro de port en process.env.PORT vous permet d’accéder à l’application.

Par exemple,

http.createServer(function(request, response) {
   // your server code
}).listen(process.env.PORT);

De plus, si vous souhaitez y accéder hors ligne pendant le débogage, vous pouvez utiliser ceci :

http.createServer(function(request, response) {
  // your server code
}).listen(process.env.PORT || 3000);

où “3000” est le numéro de port hors ligne.

Modules de base

Node.js est un moteur Javascript (le moteur V8 de Google pour Chrome, écrit en C++) qui permet d’exécuter Javascript en dehors du navigateur. Alors que de nombreuses bibliothèques sont disponibles pour étendre les fonctionnalités de Node, le moteur est livré avec un ensemble de modules de base implémentant des fonctionnalités de base.

Il y a actuellement 34 modules principaux inclus dans Node :

[ 'assert',
  'buffer',
  'c/c++_addons',
  'child_process',
  'cluster',
  'console',
  'crypto',
  'deprecated_apis',
  'dns',
  'domain',
  'Events',
  'fs',
  'http',
  'https',
  'module',
  'net',
  'os',
  'path',
  'punycode',
  'querystring',
  'readline',
  'repl',
  'stream',
  'string_decoder',
  'timers',
  'tls_(ssl)',
  'tracing',
  'tty',
  'dgram',
  'url',
  'util',
  'v8',
  'vm',
  'zlib' ]

Cette liste a été obtenue à partir de l’API de documentation Node https://nodejs.org/api/all.html (fichier JSON : https://nodejs.org/api/all.json).

Tous les modules de base en un coup d’œil

assert

Le module assert fournit un ensemble simple de tests d’assertion qui peuvent être utilisés pour tester les invariants.

buffer

Avant l’introduction de TypedArray dans ECMAScript 2015 (ES6), le Le langage JavaScript n’avait aucun mécanisme pour lire ou manipuler les flux de données binaires. La classe Buffer a été introduite dans le cadre de Node.js API pour permettre d’interagir avec les flux d’octets dans le contexte des choses comme les flux TCP et les opérations du système de fichiers.

Maintenant que TypedArray a été ajouté dans ES6, la classe Buffer implémente la Uin t8Array API d'une manière plus optimisée et adaptée à Node.js' cas d'utilisation.

c/c++_addons

Node.js Addons sont des objets partagés liés dynamiquement, écrits en C ou C++, qui peut être chargé dans Node.js à l’aide de la fonction require() , et utilisé comme s’il s’agissait d’un module Node.js ordinaire. Ils servent principalement à fournir une interface entre JavaScript exécuté dans Node.js et les bibliothèques C/C++.

child_process

Le module child_process permet de générer des processus enfants dans d’une manière similaire, mais pas identique, à popen(3).

[cluster][1]

Une seule instance de Node.js s’exécute dans un seul thread. Pour profiter des systèmes multicœurs, l’utilisateur voudra parfois lancer un cluster de Node.js processus pour gérer la charge. Le module cluster vous permet de créer facilement des processus enfants qui tous les ports du serveur de partage.

console

Le module console fournit une console de débogage simple similaire à la Mécanisme de console JavaScript fourni par les navigateurs Web.

crypto

Le module crypto fournit des fonctionnalités cryptographiques qui incluent un ensemble de wrappers pour les fonctions de hachage, HMAC, de chiffrement, de déchiffrement, de signature et de vérification d’OpenSSL.

deprecated_apis

Node.js peut rendre obsolètes les API lorsque : (a) l’utilisation de l’API est considérée comme dangereux, (b) une API alternative améliorée a été mise à disposition, ou (c) des modifications majeures de l’API sont attendues dans une future version majeure.

dns

Le module dns contient des fonctions appartenant à deux catégories différentes :

  1. Fonctions qui utilisent les installations sous-jacentes du système d’exploitation pour effectuer résolution de noms, et qui n’effectuent pas nécessairement de communication réseau. Cette catégorie ne contient qu’une seule fonction : dns.lookup().
  2. Fonctions qui se connectent à un serveur DNS réel pour effectuer la résolution de noms, et qui utilisent toujours le réseau pour effectuer des requêtes DNS. Cette catégorie contient toutes les fonctions du module dns sauf dns.lookup() .

domaine

Ce module est en attente d’obsolescence. Une fois qu’une API de remplacement a été finalisé, ce module sera totalement obsolète. La plupart des utilisateurs finaux devraient ne pas avoir de raison d’utiliser ce module. Les utilisateurs qui doivent absolument avoir la fonctionnalité fournie par les domaines peut en dépendre pour le moment mais doit s’attendre à devoir migrer vers une autre solution dans le futur.

[Événements][2]

Une grande partie de l’API principale de Node.js est construite autour d’un asynchrone idiomatique architecture événementielle dans laquelle certains types d’objets (appelés “émetteurs”) émettre périodiquement des événements nommés qui provoquent l’activation d’objets Function (“auditeurs”) appelé.

fs

Les E/S de fichiers sont fournies par de simples wrappers autour des fonctions POSIX standard. Pour utiliser ce module, faites require('fs'). Toutes les méthodes ont des formes asynchrones et synchrones.

[http][3]

Les interfaces HTTP de Node.js sont conçues pour prendre en charge de nombreuses fonctionnalités du protocole qui ont été traditionnellement difficiles à utiliser. En particulier, les messages volumineux, éventuellement codés en blocs. L'interface est veillez à ne jamais mettre en mémoire tampon des requêtes ou des réponses entières - le l'utilisateur peut diffuser des données.

https

HTTPS est le protocole HTTP sur TLS/SSL. Dans Node.js, cela est implémenté comme un module séparé.

module

Node.js a un système de chargement de module simple. Dans Node.js, fichiers et modules sont en correspondance un à un (chaque fichier est traité comme un module séparé).

net

Le module net vous fournit un wrapper réseau asynchrone. Il contient des fonctions pour créer à la fois des serveurs et des clients (appelés flux). Vous pouvez inclure ce module avec require('net');.

os

Le module os fournit un certain nombre de méthodes utilitaires liées au système d’exploitation.

path

Le module path fournit des utilitaires pour travailler avec les chemins de fichiers et de répertoires.

punycode

La version du module punycode fourni dans Node.js est obsolète.

querystring

Le module querystring fournit des utilitaires pour analyser et formater les chaînes de requête d’URL.

[readline][4]

Le module readline fournit une interface pour lire les données d’un Lisible stream (comme process.stdin) une ligne à la fois.

repl

Le module repl fournit une implémentation REPL (Read-Eval-Print-Loop) qui est disponible en tant que programme autonome ou inclus dans d’autres applications.

[stream][5]

Un flux est une interface abstraite pour travailler avec des données de streaming dans Node.js. Le module stream fournit une API de base qui facilite la création d’objets qui implémentent l’interface de flux.

Il existe de nombreux objets de flux fournis par Node.js. Par exemple, un requête à un serveur HTTP et process.stdout sont les deux instances de flux.

string_decoder

Le module string_decoder fournit une API pour décoder les objets Buffer en chaînes de manière à préserver les codes UTF-8 et UTF-16 multi-octets personnages.

timers

Le module timer expose une API globale pour les fonctions de planification être appelé à une certaine période de temps future. Étant donné que les fonctions de minuterie sont globals, il n’est pas nécessaire d’appeler require('timers') pour utiliser l’API.

Les fonctions de minuterie dans Node.js implémentent une API similaire à l'API des minuteurs fournis par les navigateurs Web mais utilisent une implémentation interne différente qui est construit autour de la boucle d'événements Node.js.

tls_(ssl)

Le module tls fournit une implémentation du Transport Layer Security (TLS) et Secure Socket Layer (SSL) basés sur OpenSSL.

traçage

Trace Event fournit un mécanisme pour centraliser les informations de traçage générées par V8, Node core et code de l’espace utilisateur.

Le traçage peut être activé en passant le drapeau --trace-events-enabled lors du démarrage d'un Application Node.js.

tty

Le module tty fournit les classes tty.ReadStream et tty.WriteStream. Dans la plupart des cas, il ne sera pas nécessaire ou possible d’utiliser directement ce module.

dgram

Le module dgram fournit une implémentation des sockets UDP Datagram.

url

Le module url fournit des utilitaires pour la résolution et l’analyse d’URL.

util

Le module util est principalement conçu pour répondre aux besoins de Node.js' propres API internes. Cependant, de nombreux utilitaires sont également utiles aux développeurs d’applications et de modules.

v8

Le module v8 expose des API spécifiques à la version de V8 intégré au binaire Node.js.

Remarque : Les API et la mise en œuvre sont susceptibles d'être modifiées à tout moment.

vm

Le module vm fournit des API pour compiler et exécuter du code dans des contextes de machine virtuelle V8. Le code JavaScript peut être compilé et exécuté immédiatement ou compilé, enregistré et exécuté plus tard.

Remarque : Le module vm n'est pas un mécanisme de sécurité. Ne l'utilisez pas pour exécuter du code non approuvé.

zlib

Le module zlib fournit une fonctionnalité de compression implémentée à l’aide de Gzip et Dégonfler/gonfler.

[1] : https://www.wikiod.com/fr/node-js/module-de-grappe [2] : https://www.wikiod.com/fr/node-js/emetteurs-devenements [3] : https://www.wikiod.com/fr/node-js/http [4] : https://www.wikiod.com/fr/node-js/ligne-de-lecture [5] : https://www.wikiod.com/fr/node-js/utilisation-de-flux

Socket TLS : serveur et client

Les seules différences majeures entre cela et une connexion TCP régulière sont la clé privée et le certificat public que vous devrez définir dans un objet d’option.

Comment créer une clé et un certificat

La première étape de ce processus de sécurité est la création d’une clé privée. Et quelle est cette clé privée ? Fondamentalement, il s’agit d’un ensemble de bruits aléatoires utilisés pour chiffrer les informations. En théorie, vous pouvez créer une clé et l’utiliser pour chiffrer tout ce que vous voulez. Mais il est préférable d’avoir des clés différentes pour des choses spécifiques. Parce que si quelqu’un vole votre clé privée, c’est comme si quelqu’un volait les clés de votre maison. Imaginez si vous utilisiez la même clé pour verrouiller votre voiture, votre garage, votre bureau, etc.

openssl genrsa -out clé-privée.pem 1024

Une fois que nous avons notre clé privée, nous pouvons créer une CSR (demande de signature de certificat), qui est notre demande de faire signer la clé privée par une autorité fantaisiste. C’est pourquoi vous devez saisir des informations relatives à votre entreprise. Cette information sera vue par l’autorité de signature et utilisée pour vous vérifier. Dans notre cas, peu importe ce que vous tapez, car à l’étape suivante, nous allons signer nous-mêmes notre certificat.

openssl req -new -key clé-privée.pem -out csr.pem

Maintenant que nous avons rempli nos papiers, il est temps de prétendre que nous sommes une autorité de signature cool.

openssl x509 -req -in csr.pem -signkey clé-privée.pem -out public-cert.pem

Maintenant que vous avez la clé privée et le certificat public, vous pouvez établir une connexion sécurisée entre deux applications NodeJS. Et, comme vous pouvez le voir dans l’exemple de code, c’est un processus très simple.

Important!

Puisque nous avons créé nous-mêmes le certificat public, en toute honnêteté, notre certificat ne vaut rien, car nous ne sommes rien. Le serveur NodeJS ne fera pas confiance à un tel certificat par défaut, et c’est pourquoi nous devons lui dire de faire confiance à notre certificat avec l’option suivante reflectUnauthorized: false. Très important : ne définissez jamais cette variable sur true dans un environnement de production.

Serveur de sockets TLS 

'use strict';

var tls = require('tls');
var fs = require('fs');

const PORT = 1337;
const HOST = '127.0.0.1'

var options = {
    key: fs.readFileSync('private-key.pem'),
    cert: fs.readFileSync('public-cert.pem')
};

var server = tls.createServer(options, function(socket) {

    // Send a friendly message
    socket.write("I am the server sending you a message.");

    // Print the data that we received
    socket.on('data', function(data) {

        console.log('Received: %s [it is %d bytes long]',
            data.toString().replace(/(\n)/gm,""),
            data.length);

    });

    // Let us know when the transmission is over
    socket.on('end', function() {

        console.log('EOT (End Of Transmission)');

    });

});

// Start listening on a specific port and address
server.listen(PORT, HOST, function() {

    console.log("I'm listening at %s, on port %s", HOST, PORT);

});

// When an error occurs, show it.
server.on('error', function(error) {

    console.error(error);

    // Close the connection after the error occurred.
    server.destroy();

});

Client de socket TLS 

'use strict';

var tls = require('tls');
var fs = require('fs');

const PORT = 1337;
const HOST = '127.0.0.1'

// Pass the certs to the server and let it know to process even unauthorized certs.
var options = {
    key: fs.readFileSync('private-key.pem'),
    cert: fs.readFileSync('public-cert.pem'),
    rejectUnauthorized: false
};

var client = tls.connect(PORT, HOST, options, function() {

    // Check if the authorization worked
    if (client.authorized) {
        console.log("Connection authorized by a Certificate Authority.");
    } else {
        console.log("Connection not authorized: " + client.authorizationError)
    }

    // Send a friendly message
    client.write("I am the client sending you a message.");

});

client.on("data", function(data) {

    console.log('Received: %s [it is %d bytes long]',
        data.toString().replace(/(\n)/gm,""),
        data.length);

    // Close the connection after receiving the message
    client.end();

});

client.on('close', function() {

    console.log("Connection closed");

});

// When an error ocoures, show it.
client.on('error', function(error) {

    console.error(error);

    // Close the connection after the error occurred.
    client.destroy();

});

Comment faire fonctionner un serveur Web HTTPS de base !

Une fois que vous avez installé node.js sur votre système, vous pouvez simplement suivre la procédure ci-dessous pour obtenir un serveur Web de base fonctionnant avec la prise en charge de HTTP et HTTPS !

Étape 1 : Créer une autorité de certification

  1. créez le dossier où vous souhaitez stocker votre clé & certificat :

    mkdir conf

  1. allez dans ce répertoire :

    cd conf

  1. récupérez ce fichier ca.cnf à utiliser comme raccourci de configuration :

    wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf

  1. créez une nouvelle autorité de certification en utilisant cette configuration :

    openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem

  1. maintenant que nous avons notre autorité de certification dans ca-key.pem et ca-cert.pem, générons une clé privée pour le serveur :

    openssl genrsa -out key.pem 4096

  1. récupérez ce fichier server.cnf à utiliser comme raccourci de configuration :

    wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/server.cnf

  1. générer la demande de signature de certificat en utilisant cette configuration :

    openssl req -new -config server.cnf -key key.pem -out csr.pem

  1. signer la demande :

    openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in csr.pem -CA ca-cert.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem

Etape 2 : Installez votre certificat en tant que certificat racine

  1. copiez votre certificat dans le dossier de vos certificats racine :

    sudo cp ca-crt.pem /usr/local/share/ca-certificates/ca-crt.pem

  1. mettre à jour le magasin CA :

    sudo update-ca-certificates

Etape 3 : Démarrage de votre serveur de nœud

Tout d’abord, vous souhaitez créer un fichier server.js contenant votre code de serveur réel.

La configuration minimale d’un serveur HTTPS dans Node.js ressemblerait à ceci :

var https = require('https');
var fs = require('fs');

var httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

var app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

https.createServer(httpsOptions, app).listen(4433);

Si vous souhaitez également prendre en charge les requêtes http, il vous suffit de faire cette petite modification :

var http = require('http');
var https = require('https');
var fs = require('fs');

var httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

var app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

http.createServer(app).listen(8888);
https.createServer(httpsOptions, app).listen(4433);

  1. allez dans le répertoire où se trouve votre server.js :

    cd /path/to

  1. exécutez server.js :

    node server.js

Installation de Node.js →