Node.js Tutoriel
Démarrer avec Node.js

Remarques

Versions

Bonjour HTTP server HTTP

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 que, 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 module de base Node.js (un module inclus dans la source de Node.js, qui n'exige pas l'installation de ressources supplémentaires). Le module http fournit la fonctionnalité permettant de créer un serveur HTTP à l'aide de la méthode http.createServer() . Pour créer l'application, créez un fichier contenant le code JavaScript suivant.

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 l' hello.js nous pouvons exécuter l'application en allant dans le répertoire où 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 simple page Web apparaîtra avec un texte «Hello, World!» En haut, comme le montre la capture d'écran ci-dessous.

Exemple en ligne modifiable

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 de fichier n'est pas pertinent.
2. Rendre ce fichier exécutable avec chmod 700 FILE_NAME
3. Exécutez l'application avec ./APP_NAME David

Sous Windows, faites l’étape 1 et exécutez-le avec le 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);

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 et téléchargez / exécutez le programme d'installation.

Mac: Accédez à la page de téléchargement et téléchargez / exécutez le programme d'installation. Alternativement, vous pouvez installer Node via Homebrew en utilisant le brew install node . Homebrew est un gestionnaire de paquets en ligne de commande pour Macintosh. Vous trouverez plus d'informations à ce sujet sur le site Web Homebrew .

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

Exécution d'un programme de noeud

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 noeud. Vous n'avez pas besoin d'inclure le suffixe .js pour que Node trouve le script que vous souhaitez exécuter.

Sous un système d'exploitation UNIX, un programme Node peut également être exécuté en tant que script de terminal. Pour ce faire, il doit commencer par un pointage vers l'interpréteur de nœud, tel que le nœud #!/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 directement exécuté à partir de la ligne de commande.

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 accéder à ce mode hors connexion 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.

Déboguer votre application NodeJS

Vous pouvez utiliser l'inspecteur de noeud. 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 dépôt Github peut être trouvé ici: https://github.com/node-inspector/node-inspector

Déboguer en mode natif

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

node debug your-script.js

Pour cerner votre débogueur exactement dans une ligne de code souhaitée, utilisez ceci:

debugger;

Pour plus d'informations, voir ici .

Dans node.js 8, utilisez la commande suivante:

node --inspect-brk your-script.js

Ouvrez ensuite à about://inspect une version récente de Google Chrome et sélectionnez votre script Node pour obtenir l'expérience de débogage des outils DevTools de Chrome.

Bonjour tout 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.

Créez d'abord un nouveau dossier, par exemple myApp . Allez dans myApp et créez un nouveau fichier JavaScript contenant le code suivant ( hello.js le hello.js par exemple). Ensuite, installez le module express en utilisant npm install --save express depuis la ligne de commande. Reportez-vous à cette documentation 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);
});

À partir de 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 .

Routage de base Hello World

Une fois que vous avez compris comment créer un serveur HTTP avec un noeud, il est important de comprendre comment le faire «faire» des choses en fonction du chemin d'accès auquel l'utilisateur a accédé. Ce phénomène est appelé "routage".

L'exemple le plus fondamental 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 ça, vous vous retrouverez avec une fonction de rappel énorme, et nous ne voulons pas un désordre géant comme ça, alors voyons si nous pouvons le nettoyer.

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 rappel 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);

Maintenant, 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 aucun itinéraire n'est trouvé, le serveur répondra par un 404 (non trouvé).

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

Socket TLS: serveur et client

Les seules différences majeures entre ceci et une connexion TCP standard 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, c'est 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 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 private-key.pem 1024

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

openssl req -new -key private-key.pem -out csr.pem

Maintenant que nous avons rempli nos documents, il est temps de prétendre que nous sommes une autorité de signature géniale.

openssl x509 -req -in csr.pem -signkey private-key.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, le processus est très simple.

Important!

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

Serveur Socket 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();

});

TLS Socket Client

'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();

});

Bonjour tout le monde dans le REPL

Appelé sans arguments, Node.js démarre une REPL (Read-Eval-Print-Loop), également appelée « shell Node ».

À l'invite de commandes, tapez node .

$ node
>

À l'invite du shell Node > tapez "Hello World!"

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

Modules de base

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

Il y a actuellement 34 modules de base 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

affirmer

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

tampon

Avant l'introduction de TypedArray dans ECMAScript 2015 (ES6), le langage JavaScript ne disposait d'aucun mécanisme pour lire ou manipuler des flux de données binaires. La classe Buffer été introduite dans le cadre de l’API Node.js pour permettre l’interaction avec les flux d’octets dans le cadre d’activités telles que les flux TCP et les opérations de système de fichiers.

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

c / c ++ _ addons

Node.js Les Addons sont des objets partagés liés dynamiquement, écrits en C ou C ++, qui peuvent être chargés dans Node.js en utilisant la fonction require() , et utilisés comme s’ils étaient un module Node.js ordinaire. Ils servent principalement à fournir une interface entre JavaScript s'exécutant dans les bibliothèques Node.js et C / C ++.

child_process

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

grappe

Une seule instance de Node.js s'exécute dans un seul thread. Pour tirer parti des systèmes multi-core, l'utilisateur voudra parfois lancer un cluster de processus Node.js pour gérer la charge. Le module de cluster vous permet de créer facilement des processus enfants partageant tous des ports de serveur.

console

Le module de console fournit une console de débogage simple, similaire au mécanisme de console JavaScript fourni par les navigateurs Web.

crypto

Le crypto module fournit des fonctionnalités de chiffrement qui comprend un ensemble d'emballages pour le hachage de OpenSSL, HMAC, chiffrement, déchiffrement, signer et vérifier les fonctions.

deprecated_apis

Node.js peut rendre obsolètes les API lorsque: (a) l'utilisation de l'API est considérée comme non sécurisée, (b) une autre API améliorée a été mise à disposition, ou (c) des modifications de l'API sont attendues dans une prochaine version majeure .

dns

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

1. Fonctions qui utilisent les fonctionnalités du système d'exploitation sous-jacent pour effectuer la résolution de noms et 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 exception de dns.lookup() .

domaine

Ce module est en attente de dépréciation . Une fois qu'une API de remplacement a été finalisée, ce module sera complètement obsolète. La plupart des utilisateurs finaux ne devraient pas avoir de raison d'utiliser ce module. Les utilisateurs qui doivent absolument disposer de la fonctionnalité fournie par les domaines peuvent, pour le moment, compter sur elle, mais doivent s’attendre à devoir migrer vers une solution différente à l’avenir.

Événements

Une grande partie de l'API de base de Node.js est construite autour d'une architecture asynchrone pilotée par des événements idiomatiques dans laquelle certains types d'objets (appelés "émetteurs") émettent périodiquement des événements nommés provoquant l'appel des objets Fonction ("écouteurs").

fs

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

http

Les interfaces HTTP dans Node.js sont conçues pour prendre en charge de nombreuses fonctionnalités du protocole qui étaient traditionnellement difficiles à utiliser. En particulier, des messages volumineux, éventuellement codés en bloc. L'interface prend soin de ne jamais mettre en mémoire tampon des demandes ou des réponses entières - l'utilisateur peut diffuser des données.

https

HTTPS est le protocole HTTP sur TLS / SSL. Dans Node.js, ceci est implémenté en tant que module séparé.

module

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

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.

chemin

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

punycode

La version du module punycode intégrée à Node.js est obsolète .

chaîne de requête

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

readline

Le module readline fournit une interface pour lire les données à partir d’un flux lisible (tel que process.stdin ) une ligne à la fois.

repl

Le module repl fournit une implémentation REPL (Read-Eval-Print-Loop) disponible à la fois en tant que programme autonome ou dans d'autres applications.

courant

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

Il y a beaucoup d'objets de flux fournis par Node.js. Par exemple, une requête sur un serveur HTTP et process.stdout sont des 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 caractères codés sur plusieurs octets UTF-8 et UTF-16.

minuteries

Le module de timer expose une API globale pour les fonctions de planification à appeler ultérieurement. Comme les fonctions du minuteur sont des globales, il n'est pas nécessaire d'appeler require('timers') pour utiliser l'API.

Les fonctions du minuteur dans Node.js implémentent une API similaire à celle de l'API de temporisation fournie par les navigateurs Web, mais utilisent une implémentation interne différente basée sur la boucle d'événement Node.js.

tls_ (ssl)

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

tracé

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

Le suivi peut être activé en passant l' --trace-events-enabled lors du démarrage d'une 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 ce module directement.

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 syntaxique des URL.

util

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

v8

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

Remarque : Les API et l'implémentation sont susceptibles d'être modifiées à tout moment.

vm

Le module vm fournit des API pour compiler et exécuter du code dans les 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 fiable .

zlib

Le module zlib fournit des fonctionnalités de compression implémentées avec Gzip et Deflate / Inflate.

Comment faire fonctionner un serveur Web HTTPS de base!

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

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

1. Créez le dossier dans lequel vous souhaitez stocker votre clé et votre certificat:

   mkdir conf

2. allez dans ce répertoire:

   cd conf

3. récupérer ce fichier ca.cnf à utiliser comme raccourci de configuration:

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

4. créer 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

5. 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

6. récupérer ce fichier server.cnf à utiliser comme raccourci de configuration:

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

7. 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

8. 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

Étape 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

2. mettre à jour le magasin CA:

   sudo update-ca-certificates

Étape 3: Démarrer votre serveur de noeud

Tout d'abord, vous voulez créer un fichier server.js contenant votre code de serveur actuel.

La configuration minimale pour un serveur HTTPS dans Node.js serait la suivante:

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, vous devez apporter 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

2. lancez server.js :

   node server.js