Beaucoup de personnes découvrent Node.js avec l’envie de créer un petit serveur web, mais se retrouvent vite face à une feuille blanche. C’est compréhensible : lorsque l’on débute, le simple fait d’afficher une page HTML peut sembler un chantier colossal. Pourtant, avec quelques explications claires et un peu de pratique, tout devient beaucoup plus simple. Vous allez voir que créer un serveur node.js n’a rien d’un parcours du combattant, surtout si l’on s’appuie sur Express, un outil qui vous simplifie réellement la vie.

• Comprendre comment fonctionne un serveur Node.js et gagner enfin en confiance pour créer vos propres projets sans être bloqué par la technique.
• Savoir mettre en place un serveur Express clair, organisé et capable d’afficher un vrai site avec HTML, CSS, images et scripts.
• Acquérir les bases nécessaires pour évoluer vers des projets plus ambitieux : routes propres, middlewares, gestion d’erreurs et premières notions de déploiement.

J’ai encore en tête la première fois où j’ai tenté de fabriquer un serveur en partant de zéro. À l’époque, j’avais l’impression d’essayer d’assembler une voiture sans plan de montage. Puis j’ai découvert Express. Nous allons avancer pas à pas, sans stress et en comprenant vraiment ce que l’on fait.

Nous allons prendre le temps d’explorer ensemble les bases indispensables : installer Node.js, créer un serveur node.js avec le module http, puis découvrir la puissance d’Express pour aller plus vite et travailler sereinement. L’objectif est simple : que vous soyez capable, à la fin de ce guide, de créer votre propre serveur fonctionnel, d’y afficher des pages HTML et de servir vos fichiers statiques comme un véritable site web.

Avant de commencer : comprendre ce qu’est un serveur Node.js

Avant de rentrer dans le code, il est utile de poser les bases. Vous allez beaucoup rencontrer les termes serveur, requête et réponse. Ils sont essentiels pour comprendre le fonctionnement de Node.js.

Un serveur, c’est simplement un programme qui reste ouvert et attend qu’un utilisateur lui demande quelque chose. L’utilisateur (souvent un navigateur comme Chrome, Firefox, Safari…) envoie une requête. Le serveur, lui, répond avec ce qu’il a sous la main : une page HTML, un fichier CSS, une image ou parfois un message en texte brut.

Node.js est parfait pour cela, parce qu’il sait gérer beaucoup de connexions en même temps sans se fatiguer. Là où d’autres technologies aiment multiplier les processus, Node.js fonctionne comme quelqu’un qui sait jongler avec plusieurs tâches en même temps. Il ne bloque pas, il ne se fige pas, il gère tout en douceur, et c’est ce qui fait sa force.

Lorsque l’on comprend cela, créer un serveur devient beaucoup plus logique. Ce n’est pas de la magie, c’est simplement un échange permanent entre un client et un programme qui écoute.

Installer Node.js : le premier pas indispensable

Pour travailler avec Express, il faut évidemment installer Node.js. L’installation est simple et ne prend que quelques minutes. Il suffit de vous rendre sur le site officiel de Node.js et de télécharger la version recommandée pour votre système. Une fois installé, vous pouvez vérifier que tout fonctionne en ouvrant votre terminal et en tapant deux petites commandes.

La première permet de vérifier que Node.js est bien présent, tandis que la seconde vérifie l’outil npm, indispensable pour installer Express. Si les deux commandes vous retournent un numéro de version, c’est que vous êtes prêt à continuer. En cas d’erreur, il suffit généralement de relancer l’installation.

Lorsque vous débutez, il est normal de vous demander si tout fonctionne vraiment. La bonne nouvelle, c’est que Node.js se montre rarement capricieux à cette étape. Une installation propre et vous voilà prêt à écrire vos premiers scripts comme un vrai développeur.

Si vous débutez : Comprendre et installer Node.js.

Un serveur web est donc finalement un programme qui attend qu’un client (souvent un navigateur) lui demande quelque chose, puis qui lui renvoie une réponse.

Lorsque votre navigateur appelle une page comme https://code.crea-troyes.fr, il envoie un message à un serveur : « Bonjour, puis-je avoir le contenu de la page d’accueil ? ». Le serveur vérifie ce qu’il doit renvoyer, et lui transmet le HTML correspondant. C’est tout. Le reste n’est que variations sur cette idée.

Avec Node.js, vous pouvez écrire ce programme vous-même, dans un simple fichier JavaScript. C’est puissant, mais c’est aussi très accessible, surtout lorsqu’on prend tout depuis le début.

Pour illustrer, imaginez que vous tenez une petite librairie. Un client entre et vous demande un livre précis. Vous lui répondez en allant le chercher dans le bon rayon. Un serveur fonctionne exactement de cette manière. Vous recevez une requête et vous envoyez une réponse.

L’avantage incroyable de Node.js, c’est qu’il vous donne tout ce qu’il faut pour faire fonctionner cette librairie numérique dans un seul langage : JavaScript.

Créer un premier serveur web avec le module http

Node.js inclut nativement un module appelé http qui permet de créer un serveur node.js minimaliste. Il ne nécessite aucune installation supplémentaire. C’est l’occasion parfaite pour comprendre le mécanisme fondamental d’un serveur.

Premier serveur Node.js

Créez un nouveau dossier sur votre ordinateur, par exemple serveur-test. À l’intérieur, créez un fichier nommé server.js. Ouvrez-le avec votre éditeur de code (VS Code, Sublime, peu importe). Ajoutez le code suivant :

const http = require('http');

const serveur = http.createServer((req, res) => {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Bonjour, vous êtes connecté à mon premier serveur Node.js !');
});

serveur.listen(3000, () => {
    console.log('Serveur démarré sur https://localhost:3000');
});

Cela peut sembler simple. Et c’est justement le but. Vous venez de créer un serveur web fonctionnel. Lorsque vous lancez :

node server.js

Node démarre un programme qui attend qu’un navigateur demande quelque chose. Si vous ouvrez https://localhost:3000 dans votre navigateur, vous verrez votre message apparaître.

Vous venez de créer un vrai serveur Node.js.

Ce que fait réellement ce code

Le module http offre une méthode createServer, qui prend une fonction callback. Cette fonction s’exécute à chaque requête. Elle reçoit deux objets :

• req, qui représente la requête du client ;
• res, qui représente la réponse du serveur.

Dans notre exemple, nous répondons toujours la même chose, mais vous verrons rapidement comment aller beaucoup plus loin.

Les limites du module http

Même si ce module est idéal pour apprendre, vous constaterez très vite qu’il devient difficile à utiliser lorsque les choses se complexifient.

S’il vous faut gérer plusieurs routes comme /, /apropos, /contact, vous devrez écrire beaucoup de conditions. Si vous souhaitez servir un fichier HTML, vous devrez le lire depuis le disque, ajouter des en-têtes manuellement, gérer les erreurs… Cela devient rapidement inconfortable.

C’est là qu’intervient Express, une véritable bouffée d’air frais pour créer un serveur node.js Express clair, élégant et surtout beaucoup plus simple à maintenir.

Avant d’installer Express, voyons comment préparer un projet Node.js comme un vrai développeur.

Initialiser un projet Node.js correctement

Dans votre dossier de projet, exécutez :

npm init -y

Cette commande crée un fichier package.json, qui contiendra les informations de votre projet et la liste des dépendances.

Tout savoir sur NPM et la gestion des packages Node.js.

Ce fichier est essentiel. Il permet de partager votre projet proprement, d’installer ou désinstaller des modules, et de garder une structure professionnelle.

Une fois cela fait, nous pouvons installer Express :

npm install express

Node télécharge le framework et vous pouvez commencer à l’utiliser.

Créer un premier serveur Express node.js

Express simplifie énormément la création d’un serveur Node.js. Là où il fallait plusieurs lignes pour renvoyer une réponse, Express se charge du reste et propose une syntaxe lisible.

Créez un fichier app.js :

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

app.get('/', (req, res) => {
    res.send('Bienvenue sur mon serveur Express !');
});

app.listen(3000, () => {
    console.log('Serveur Express démarré sur https://localhost:3000');
});

Relancez votre projet :

node app.js

Ouvrez https://localhost:3000 et admirez votre premier serveur Express opérationnel. C’est clairement plus propre que la version avec http.

Express offre une manière naturelle de créer des routes. Le navigateur demande la page d’accueil, Express renvoie la réponse. Si vous voulez une page contact :

app.get('/contact', (req, res) => {
    res.send('Page contact');
});

C’est aussi simple que ça.

Servir des fichiers statiques avec Express

Dans un site réel, vous avez des fichiers HTML, des feuilles de style CSS, des images, des scripts JavaScript front-end. Vous devez les rendre accessibles depuis votre serveur, sinon le navigateur ne peut pas les afficher.

Express propose une méthode très pratique : express.static.

Préparer une structure de fichiers

Dans votre dossier de projet, créez un dossier public :

public
  index.html
  style.css
  logo.png

Dans app.js, ajoutez :

app.use(express.static('public'));

Dès que vous faites cela, Express ouvre automatiquement le dossier public pour le navigateur. Cela signifie que si votre index.html contient :

<link rel="stylesheet" href="style.css">
<img src="logo.png">

Express saura les envoyer au navigateur sans que vous n’écriviez une seule ligne supplémentaire.

Essayez. Mettez quelque chose dans index.html comme :

<h1>Bienvenue dans ma page HTML servie avec Express</h1>

Puis rechargez https://localhost:3000. Votre serveur est désormais capable de servir des fichiers statiques exactement comme un vrai site web professionnel.

Aller plus loin avec Express : routes, architecture et logique métier

À ce stade, vous avez un serveur Node.js fonctionnel et propre grâce à Express. Vous savez répondre à une requête, créer des routes simples et servir des fichiers statiques. C’est déjà un énorme pas, surtout lorsqu’on débute. Mais un vrai serveur web, même simple, ne se limite pas à renvoyer une page d’accueil et un fichier CSS. Vous avez besoin d’un minimum d’organisation.

Lorsque l’on commence à empiler plusieurs routes, plusieurs pages et un peu de logique, un seul fichier app.js devient vite trop encombrant. C’est un peu comme ranger tous vos vêtements dans un seul tiroir : ça fonctionne… mais au bout d’un moment, on ne trouve plus rien. Alors, il est temps de mieux structurer votre serveur Express.

Comprendre l’intérêt d’organiser son code

Avant même de toucher à la structure, il est essentiel de comprendre pourquoi on prend le temps d’organiser un serveur. Au tout début, cela peut sembler superflu. Après tout, quelques routes suffisent. Mais imaginez que vous ajoutiez un formulaire de contact, puis une section blog, puis une page boutique, puis une zone administrateur. Très vite, vous aurez besoin de séparer vos responsabilités.

Organiser votre serveur, c’est aussi une manière de faciliter votre vie future de développeur. On ne le dit pas assez : les erreurs et les bugs viennent souvent d’un code mal rangé. Et comme pour une maison, lorsque tout est à sa place, vous respirez mieux.

Pour illustrer ce principe, lors de l’un de mes premiers projets professionnels, j’avais tout mis dans un unique fichier. Tout. Les routes, les fonctions utilitaires, la configuration… Un chaos assumé. Le jour où il a fallu corriger un simple bug dans une route, j’ai passé un temps fou à naviguer dans le fichier en me demandant pourquoi j’avais fait ça. À la pause de midi, j’avais déjà réorganisé tout le projet. Et malheureusement, j’avais aussi compris que l’ordre, ce n’est pas une option : c’est une politesse que l’on se fait à soi-même.

Créer un dossier routes pour séparer vos pages

Express simplifie la gestion des routes en permettant de créer des fichiers dédiés. Commençons simplement. Créez un dossier routes dans votre projet :

routes
    accueil.js
    contact.js

Dans accueil.js :

const express = require('express');
const router = express.Router();

router.get('/', (req, res) => {
    res.send('Page d’accueil servie depuis un fichier séparé');
});

module.exports = router;

Dans contact.js :

const express = require('express');
const router = express.Router();

router.get('/contact', (req, res) => {
    res.send('Page contact servie depuis un fichier séparé');
});

module.exports = router;

Puis, dans votre app.js :

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

const accueilRoutes = require('./routes/accueil');
const contactRoutes = require('./routes/contact');

app.use(accueilRoutes);
app.use(contactRoutes);

app.listen(3000, () => {
    console.log('Serveur prêt sur https://localhost:3000');
});

Avec seulement quelques lignes, vous venez de transformer un serveur basique en un serveur Express organisé comme un vrai projet professionnel. C’est compréhensible, modulable, et vous pouvez maintenant ajouter autant de routes que nécessaire sans transformer votre code en spaghetti.

Ajouter des paramètres dynamiques dans les routes

Un serveur moderne ne propose pas uniquement des pages statiques. Souvent, les adresses contiennent des informations variables, comme :

/article/12
/utilisateur/alban
/produit/trottinette-electric-3000

Express permet de gérer cela de manière très élégante. Dans votre fichier accueil.js ou dans un nouveau fichier de route, ajoutez :

router.get('/article/:id', (req, res) => {
    const articleId = req.params.id;
    res.send(`Vous consultez l’article numéro ${articleId}`);
});

Si vous visitez https://localhost:3000/article/42, Express récupère automatiquement la valeur 42 dans req.params.id.

C’est simple, mais c’est extrêmement puissant. C’est grâce à ce mécanisme que l’on peut afficher une fiche produit, une page utilisateur, ou une catégorie d’articles sans avoir à créer une route pour chaque cas.

Comprendre le rôle du middleware dans Express

Le middleware, c’est l’un des concepts centraux d’Express. On pourrait presque le comparer à un tapis roulant dans une usine : chaque requête passe dessus, puis différents modules peuvent intervenir pour ajouter des informations, vérifier quelque chose, ou décider de la suite à donner.

Par exemple, si vous voulez afficher l’heure à laquelle une requête arrive :

app.use((req, res, next) => {
    console.log('Requête reçue à', new Date().toLocaleTimeString());
    next();
});

Le fameux next() dit à Express de poursuivre son chemin. Sans lui, la requête resterait bloquée.

On peut aussi utiliser les middlewares pour :

• Filtrer les accès
• Gérer les formulaires
• Protéger des routes privées
• Ajouter des en-têtes personnalisés
• Servir des fichiers statiques

Le concept peut sembler un peu abstrait au début, mais rassurez-vous : vous l’utiliserez en continu sans même vous en rendre compte.

Gérer les pages HTML avec res.sendFile

Jusqu’ici, nous avons envoyé des textes simples. Mais dans un vrai site, vous souhaitez renvoyer des pages HTML. Express le permet avec res.sendFile.

Créez un fichier accueil.html dans votre dossier public ou dans un dossier views :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Page d’accueil</title>
</head>
<body>
    <h1>Bienvenue sur mon site créé avec Express</h1>
</body>
</html>

Dans votre route accueil.js, remplacez res.send par :

const path = require('path');

router.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, '../views/accueil.html'));
});

Vous venez de servir une vraie page HTML depuis votre serveur Node.js avec Express. Et contrairement au module http, vous n’avez pas besoin de gérer manuellement les en-têtes ou le type MIME.

Servir plusieurs pages HTML avec Express

Si vous avez plusieurs pages, vous pouvez bien sûr dupliquer sendFile. Mais vous pouvez aussi organiser vos fichiers dans un dossier dédié, par exemple views, comme dans la plupart des frameworks :

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

views
    accueil.html
    contact.html
    apropos.html

Et dans vos routes :

router.get('/apropos', (req, res) => {
    res.sendFile(path.join(__dirname, '../views/apropos.html'));
});

Cela vous donne un vrai mini-site, capable de répondre aux URLs essentielles. Mais avant d’aller plus loin, parlons du dossier public, qui joue un rôle indispensable.

Le rôle stratégique du dossier public dans un serveur Express

Vous avez déjà vu que express.static permet de servir des fichiers statiques sans effort. Mais il est important de comprendre ce que cela signifie réellement.

Lorsque vous écrivez :

app.use(express.static('public'));

Vous dites à Express que tout fichier présent dans public peut être accessible directement depuis un navigateur. C’est pourquoi un fichier style.css accessible dans public peut être appelé depuis votre HTML sans dossier intermédiaire.

Ce mécanisme est essentiel pour la performance, car Express optimise automatiquement l’envoi de ces fichiers. Vous n’avez plus besoin d’une route spécifique pour une image, une vidéo ou une feuille de style.

Par exemple, si vous avez un fichier public/images/logo.jpg, dans votre HTML vous pouvez écrire :

<img src="/images/logo.jpg">

Express se charge de tout. Pas d’en-têtes compliqués, pas de chemins étranges, pas de code supplémentaire. C’est exactement ce qui se passe sur un serveur professionnel : il y a un dossier destiné aux fichiers que les visiteurs peuvent télécharger librement.

Utiliser un moteur de templates pour éviter de dupliquer vos pages HTML

Lorsque votre projet commence à grandir, vous vous rendrez compte qu’écrire vos pages HTML entièrement à la main dans sendFile peut devenir répétitif. C’est particulièrement vrai si vos pages partagent des éléments identiques : un en-tête, un menu, un pied de page. Répéter ces éléments dans chaque fichier finit par créer de la duplication, ce qui peut poser problème à la moindre modification.

C’est ici que les moteurs de templates entrent en scène. Avec Express, vous pouvez utiliser EJS, Pug, Handlebars, ou bien d’autres. Pour un débutant, EJS est souvent le plus simple à comprendre, car il ressemble énormément au HTML classique.

Installer EJS dans votre serveur Express

Dans votre terminal, tapez :

npm install ejs

Ensuite, dans votre app.js :

app.set('view engine', 'ejs');
app.set('views', './views');

Dès lors, Express est capable de rendre des fichiers .ejs exactement comme des pages HTML, mais avec en plus la possibilité d’injecter des données dynamiques.

Créez un fichier views/accueil.ejs :

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title><%= titre %></title>
</head>
<body>
    <h1><%= message %></h1>
</body>
</html>

Dans votre route accueil.js, modifiez la réponse :

router.get('/', (req, res) => {
    res.render('accueil', {
        titre: 'Accueil Express',
        message: 'Bienvenue sur ma page rendue avec un moteur de template'
    });
});

Rechargez https://localhost:3000, et vous verrez votre page HTML s’afficher avec les données que vous avez transmises.

C’est ce mécanisme qui vous permet de gérer des pages dynamiques, des listes d’articles, des formulaires remplis, des tableaux, ou tout contenu généré par votre serveur Express.

Utiliser des layouts pour éviter la duplication

Vous pouvez aller plus loin en créant un layout, un fichier gabarit qui contient la structure commune de votre site. Créez par exemple views/layout.ejs :

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title><%= titre %></title>
    <link rel="stylesheet" href="/style.css">
</head>
<body>
    <header>
        <h2>Mon super site Express</h2>
    </header>

    <main>
        <%- contenu %>
    </main>

    <footer>
        <p>Créé avec Express et Node.js</p>
    </footer>
</body>
</html>

Ensuite, dans accueil.ejs :

<% layout('layout', { titre: titre }) %>
<h1><%= message %></h1>

Selon le moteur utilisé, la syntaxe varie légèrement, mais l’idée reste la même : vous définissez un cadre général et vous injectez votre contenu dans une zone précise. Vous gagnez en clarté, en rapidité, et surtout en confort.

Structurer un serveur Express avec le modèle MVC

L’un des objectifs de cet article est de vous amener vers une construction professionnelle, même si vous êtes encore au début de votre apprentissage. C’est ici que l’architecture MVC entre en jeu. Même si le concept peut paraître un peu abstrait, il est en réalité très simple lorsqu’on le compare à quelque chose du quotidien.

Imaginez que vous prépariez un repas dans votre cuisine. Le MVC organise votre travail en trois zones :

• Le modèle : la partie où vous stockez les ingrédients
• La vue : l’assiette que vous servez
• Le contrôleur : le cuisinier qui prend les ingrédients et prépare le plat

Avec un serveur Node.js, c’est pareil. Vous séparez vos données, votre logique et votre affichage. Dans un petit projet, cela peut sembler exagéré, mais dans un projet réel, c’est un véritable sauveur.

Mettre en place un MVC simple

Commencez en créant trois dossiers :

models
views
controllers

Nous avons déjà utilisé views. Créons maintenant une logique simple avec un modèle et un contrôleur. Dans models/articles.js :

const articles = [
    { id: 1, titre: 'Découvrir Node.js', contenu: 'Un guide pour débuter...' },
    { id: 2, titre: 'Comprendre Express', contenu: 'Simplifiez vos serveurs...' }
];

exports.getTousLesArticles = () => articles;

exports.getArticleParId = (id) => {
    return articles.find(article => article.id === parseInt(id));
};

Dans controllers/articlesController.js :

const Article = require('../models/articles');

exports.pageListe = (req, res) => {
    const liste = Article.getTousLesArticles();
    res.render('articles_liste', { titre: 'Articles', liste });
};

exports.pageDetail = (req, res) => {
    const article = Article.getArticleParId(req.params.id);
    if (!article) {
        return res.status(404).send('Article introuvable');
    }
    res.render('article_detail', { titre: article.titre, article });
};

Dans routes/articles.js :

const express = require('express');
const router = express.Router();
const ctrl = require('../controllers/articlesController');

router.get('/articles', ctrl.pageListe);
router.get('/articles/:id', ctrl.pageDetail);

module.exports = router;

Dans app.js :

const express = require('express');
const app = express();
const articlesRoutes = require('./routes/articles');

app.set('view engine', 'ejs');
app.set('views', './views');

app.use(express.static('public'));
app.use(articlesRoutes);

app.listen(3000);

Avec cela, vous avez un mini-site complet où les pages HTML sont générées dynamiquement, et où votre logique métier est bien séparée. Vous êtes officiellement en train de construire un véritable serveur Express professionnel.

Lire les données d’un formulaire dans Express

Un site sans formulaire serait bien triste. Que ce soit pour une page de contact, une inscription, un commentaire ou une recherche, vous aurez besoin de récupérer ce que l’utilisateur tape dans un champ.

Créer un formulaire simple

Dans views/contact.ejs :

<form action="/contact" method="POST">
    <label>Votre nom :</label>
    <input type="text" name="nom">

    <label>Votre message :</label>
    <textarea name="message"></textarea>

    <button type="submit">Envoyer</button>
</form>

Dans votre app.js, activez le middleware permettant de lire les données POST :

app.use(express.urlencoded({ extended: true }));

Dans votre route contact.js :

router.post('/contact', (req, res) => {
    const nom = req.body.nom;
    const message = req.body.message;

    res.send(`Merci ${nom}, votre message a été reçu : ${message}`);
});

Vous venez de gérer votre première requête POST avec Express. C’est simple, mais essentiel pour toutes les interactions utilisateur.

Éviter les erreurs fréquentes des débutants

Lorsqu’on construit un serveur Node.js, on commet tous les mêmes erreurs au début. Les plus courantes sont très simples à repérer :

• Ne pas utiliser next() dans un middleware, ce qui bloque tout
• Oublier d’importer path pour envoyer des fichiers HTML
• Mal nommer un dossier (views au lieu de view)
• Oublier express.urlencoded pour traiter les formulaires
• Tenter d’utiliser res.sendFile avec un chemin relatif incorrect
• Une bonne habitude consiste à relire votre console lorsque vous lancez node app.js. Express affiche souvent exactement où se trouve l’erreur.

Déployer un serveur Node.js : passer du local à Internet

Vous savez désormais créer un serveur Express clair, organisé, capable de gérer des routes, d’afficher des pages dynamiques et de servir des fichiers statiques. C’est un excellent début. Mais un serveur local qui fonctionne seulement sur votre ordinateur ne suffit pas : il faut apprendre à le mettre en ligne.

Déployer un projet peut sembler impressionnant la première fois. Pourtant, avec un peu de méthode et quelques outils modernes, cela devient une étape logique, presque naturelle. C’est un peu comme déménager : la première fois, vous emballez tout n’importe comment. La deuxième, vous avez déjà un plan, et tout va beaucoup plus vite.

Utiliser un service comme Render ou Railway

Ces services sont très appréciés des débutants car ils permettent de déployer un projet Node.js gratuitement. Le principe est simple :

• Vous envoyez votre projet depuis GitHub
• La plateforme installe automatiquement Node.js
• Elle détecte votre fichier app.js ou server.js
• Elle lance le serveur et vous donne une URL publique
• Pour Render, il suffit d’un dépôt GitHub contenant :
• Un package.json
• Un script start dans package.json
• Votre code Express

Par exemple, dans package.json :

"scripts": {
  "start": "node app.js"
}

Une fois votre projet envoyé sur GitHub, vous ouvrez Render, créez un nouveau service, sélectionnez votre dépôt, et la plateforme fait le reste.

Votre serveur Node.js passe alors de votre machine à Internet.

Déployer sur un serveur VPS (niveau intermédiaire)

Si vous souhaitez aller plus loin et avoir plus de contrôle, un hébergement VPS comme ceux proposés par OVH, Hetzner ou Scaleway vous permet d’installer Node.js et d’exécuter votre serveur Express comme sur votre ordinateur. Le principe est simple :

• Vous vous connectez en SSH à votre serveur
• Vous installez Node.js
• Vous envoyez votre projet
• Vous lancez votre serveur Express

Pour exécuter votre serveur en continu, même si vous fermez la connexion SSH, vous pouvez utiliser PM2 :

npm install -g pm2
pm2 start app.js
pm2 save
pm2 startup

PM2 surveille votre application, la relance automatiquement en cas de crash et vous affiche des logs clairs. C’est un peu le garde du corps de votre serveur Node.js.

Gérer le port et les variables d’environnement

Lorsque vous déployez, vous ne pouvez plus vous contenter de mettre un port fixe comme 3000. Les plateformes définissent souvent leur propre port via une variable.

Vous devez écrire :

const port = process.env.PORT || 3000;
app.listen(port);

Les variables d’environnement (comme PORT) permettent aussi de gérer d’autres paramètres sensibles : mots de passe, API keys, configuration de base de données, etc.

For example, créez un fichier .env à la racine :

PORT=3000
ENVIRONNEMENT=dev

Installez dotenv :

npm install dotenv

Et dans app.js :

require('dotenv').config();

C’est une bonne habitude professionnelle et un geste important pour sécuriser votre serveur Express.

Sécuriser un serveur Express : bonnes pratiques indispensables

Même un petit serveur doit être protégé. On ne plaisante pas avec la sécurité. La bonne nouvelle, c’est que pour un débutant, suivre quelques règles simples suffit pour éviter la majorité des problèmes.

Ne jamais exposer vos fichiers sensibles

Le dossier public est public. Les autres dossiers ne doivent jamais être accessibles depuis l’extérieur. Express les protège naturellement, à condition de ne pas exposer manuellement un chemin dangereux.

Si vous écrivez :

app.use('/secret', express.static('controllers'));

Alors n’importe qui pourrait aller lire votre logique métier. C’est une erreur courante parmi les débutants.

Limiter la quantité d’informations envoyées en cas d’erreur

Lorsque quelque chose se passe mal, Express génère une erreur. Mais il ne doit pas afficher votre stack complète en production, car cela peut dévoiler des chemins internes ou des détails sensibles.

Utilisez :

if (process.env.NODE_ENV === 'production') {
    app.use((err, req, res, next) => {
        res.status(500).send('Une erreur s’est produite.');
    });
}

En développement, vous pouvez laisser Express afficher les détails, cela aide à corriger les problèmes.

Éviter la surcharge de votre serveur Node.js

Node.js est rapide, mais il n’aime pas les opérations lourdes comme analyser de gros fichiers ou effectuer des calculs trop complexes directement dans une route. Si vous bloquez l’exécution, votre serveur entier peut sembler figé.

La règle :

Ne jamais mettre du code qui prend longtemps dans une requête Express.
Dans ces cas-là, utilisez des workers ou des scripts exécutés séparément.

Comprendre les environnements : développement vs production

Votre serveur Node.js ne fonctionne pas de la même manière selon l’endroit où il est exécuté. En développement :

• Vous voulez des messages d’erreur détaillés
• Vous voulez recharger automatiquement le serveur
• Vous faites des tests

En production :

• Vous voulez de la stabilité
• Vous voulez cacher les détails techniques aux visiteurs
• Vous optimisez les performances

Pour recharger automatiquement le serveur en développement, installez nodemon :

npm install -g nodemon
nodemon app.js

À chaque modification, nodemon relance le serveur Express automatiquement. Cela vous fait gagner du temps et évite les manipulations répétitives.

Gérer les erreurs globalement dans Express

Une erreur peut survenir n’importe où. Vous pouvez donc définir un middleware spécial à la fin de vos routes pour capturer toute erreur inattendue.

app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send('Erreur interne du serveur Express');
});

Ce middleware n’est appelé que lorsqu’une erreur est transmise à next(err). Cela permet d’avoir un point unique pour gérer vos erreurs, ce qui est plus efficace et plus propre.

Votre premier vrai serveur Node.js est né

Vous avez maintenant tout ce qu’il faut pour créer un serveur Node.js solide, structuré et prêt à accueillir vos futurs projets. Vous savez construire un serveur de base avec le module http, puis passer à un serveur Express beaucoup plus fiable et confortable. Vous savez organiser vos routes, utiliser un moteur de templates, lire des formulaires, servir des fichiers statiques et même structurer votre projet selon le modèle MVC.

Mais au-delà de la technique, il faut retenir une chose : un serveur web n’est pas une machine mystérieuse. C’est un programme que vous contrôlez totalement, ligne après ligne. Le jour où vous verrez votre serveur Express tourner en ligne, accessible depuis n’importe quel navigateur, vous ressentirez un vrai petit frisson. Pas celui du danger, mais celui de la fierté de créer quelque chose de vivant.

Peu importe d’où vous partez, vous pouvez aller très loin avec Node.js. L’important est d’y aller étape par étape, tranquillement, comme vous venez de le faire tout au long de cet article. Vous avez franchi un cap important, et ce n’est que le début de votre aventure dans le développement backend.

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr