Créer et exécuter un projet Express.js avec ServBay

Qu'est-ce qu'Express.js ?

Express.js est un framework web rapide, ouvert et minimaliste basé sur Node.js. Il propose de puissantes fonctionnalités pour concevoir des applications web monopages, multipages et hybrides. Express.js est l’un des frameworks les plus populaires de l’écosystème Node.js, apprécié des développeurs pour sa conception épurée et flexible.

Principales caractéristiques et avantages d’Express.js

• Simplicité et flexibilité : Express.js fournit une API intuitive et un système de middlewares souple, rendant le développement web très efficace.
• Middlewares : Prise en charge de nombreux middlewares pour gérer aisément les requêtes et réponses (par exemple : analyse du corps des requêtes, gestion de session, fichiers statiques, etc.).
• Routage : Routage puissant permettant de traiter les requêtes selon la méthode HTTP (GET, POST, PUT, DELETE, etc.) et le chemin URL.
• Excellente intégration : Compatible avec de nombreux moteurs de templates (Pug, EJS, Handlebars), bases de données (MongoDB, MySQL, PostgreSQL), et autres modules Node.js.
• Communauté et écosystème : Bénéficie d’une vaste communauté et d’un nombre important de middlewares et plugins tiers, offrant de nombreuses solutions et ressources.

Express.js permet ainsi aux développeurs de construire rapidement des applications web et API performantes. ServBay, en tant qu’environnement de développement web local puissant, fournit un environnement Node.js optimisé pour l’exécution de projets Express.js, ainsi que des fonctions avancées de gestion web (proxy inverse) et de bases de données.

Créer et exécuter un projet Express.js avec ServBay

Ce guide vous explique comment utiliser l’environnement Node.js de ServBay pour créer, configurer et exécuter un projet Express.js. Nous allons utiliser la fonction Sites de ServBay pour mettre en place un serveur web, et accéder au projet via un proxy inverse. Cette méthode est particulièrement adaptée à Node.js, Python, Go, Java, et toute application nécessitant l'utilisation d’un port spécifique.

Prérequis

Avant de commencer, assurez-vous que :

• ServBay est installé avec succès sur macOS.
• Le package Node.js est installé et activé dans ServBay. Vous pouvez le gérer via l’onglet “Packages” du panneau de contrôle ServBay.
• (Facultatif) Si vous comptez connecter une base de données, vérifiez que le ou les packages concernés (MariaDB, PostgreSQL, MongoDB, Redis, MySQL) sont également installés et activés dans ServBay.
• Vous disposez de connaissances de base en terminal/ligne de commande.

Créer un projet Express.js

1. Initialiser le projet

   Lancez votre terminal, naviguez vers le dossier racine des sites recommandé par ServBay /Applications/ServBay/www. Utilisez ensuite la commande npx express-generator pour générer la structure de base de votre projet Express.js. npx est inclus avec npm v5.2+ et permet d'exécuter des exécutables Node.js directement.

   cd /Applications/ServBay/www
   npx express-generator servbay-express-app

   Cela crée un dossier servbay-express-app dans /Applications/ServBay/www contenant l’ossature d’un projet Express.js.

2. Installer les dépendances

   Entrez dans le dossier du projet, puis exécutez npm install pour installer toutes les dépendances essentielles (dont le framework Express.js, moteur de templates, service de fichiers statiques, etc.).

   cd servbay-express-app
   npm install

   Patientez le temps de l’installation.

Modifier le contenu affiché par Express.js

Pour vérifier le bon fonctionnement du projet, nous allons modifier l’affichage initial de la page d’accueil.

1. Éditer le fichier routes/index.js

   Un projet Express.js s’appuie sur différents fichiers de routes pour gérer les URL. Ouvrez le fichier routes/index.js du projet. Ce fichier traite les requêtes GET vers / (la racine). Modifiez le code pour ne plus afficher le template Pug par défaut, mais renvoyer une simple réponse texte.

   var express = require('express');
   var router = express.Router();
   
   /* GET home page. */
   router.get('/', function(req, res, next) {
     // Modification : envoyer une réponse texte
     res.send('Hello ServBay!');
   });
   
   module.exports = router;

   Enregistrez le fichier.

Passer en mode développement

Pendant le développement, il est courant d’exécuter un serveur local pour visualiser en temps réel les modifications. Un projet Express.js peut démarrer avec la commande npm start.

1. Lancer le serveur de développement

   À la racine du projet (servbay-express-app), exécutez la commande suivante pour démarrer le serveur en attribuant le port 8585 (par la variable d’environnement PORT). La variable DEBUG active les logs de debug.

   cd /Applications/ServBay/www/servbay-express-app
   PORT=8585 DEBUG=servbay-express-app:* npm start

   Le terminal affiche alors les informations de démarrage du serveur sur le port 8585.

2. Configurer le proxy inverse du site dans ServBay

   Puisque l’application Express.js fonctionne sur un port spécifique (8585, différent des ports web standards 80/443), nous allons configurer un proxy inverse via la fonction Sites de ServBay. Le serveur web ServBay (généralement Caddy) écoutera sur 80/443 et transfèrera les requêtes du domaine choisi vers 127.0.0.1:8585.

   Ouvrez le panneau de contrôle ServBay, passez à l’onglet “Sites” et ajoutez un site. Indiquez :

   • Nom : My first Express.js dev site (un nom reconnaissable)
   • Domaine : servbay-express-test.servbay.demo (l’extension .servbay.demo permet d’activer automatiquement HTTPS via la User CA de ServBay)
   • Type de site : sélectionnez Proxy inverse
   • IP : 127.0.0.1 (ou localhost)
   • Port : 8585 (le port de l’application Express.js)

   Sauvegardez et appliquez les modifications. ServBay configurera automatiquement le serveur web et générera le certificat SSL (pour les domaines en .servbay.demo).

   Consultez la documentation ServBay pour plus de détails sur l’ajout d’un site Node.js pour le développement.

3. Accéder au site en mode développement

   Dans votre navigateur, ouvrez l’URL https://servbay-express-test.servbay.demo. Le serveur web de ServBay recevra la requête et la transférera via proxy vers l’application Express.js sur le port 8585. La page devrait afficher "Hello ServBay!".

   ServBay prend en charge les domaines personnalisés et les certificats SSL gratuits (dont la gestion automatique HTTPS sur .servbay.demo), ce qui vous permet de tester en local dans des conditions proches de la production.

Déployer la version production

Quand votre projet Express.js est prêt, vous pouvez le faire tourner en mode production pour simuler l’environnement de déploiement réel et effectuer des tests finaux.

1. Préparer l’environnement production

   Généralement, on affecte à la variable NODE_ENV la valeur production lors du lancement en prod. Cela modifie parfois le comportement de certains packages (désactivation du debug, optimisation, etc.). Vérifiez que votre code réagit bien à ce réglage.

2. Démarrer le serveur en mode production

   Depuis la racine du projet, lancez la commande ci-dessous, en utilisant un autre port (par exemple 8586) pour distinguer la prod du dev, et en fixant NODE_ENV à production :

   cd /Applications/ServBay/www/servbay-express-app
   PORT=8586 NODE_ENV=production npm start

   Le serveur démarre sur le port 8586.

3. Configurer le proxy inverse pour la version production

   Répétez la même démarche que pour le mode dev, en créant un nouveau site proxy inverse dans ServBay, pour la production :

   • Nom : My first Express.js production site
   • Domaine : servbay-express-test-prod.servbay.demo (ou tout autre domaine de test/production souhaité)
   • Type de site : Proxy inverse
   • IP : 127.0.0.1
   • Port : 8586

   Enregistrez et appliquez les paramètres.

4. Accéder au site en mode production

   Dans votre navigateur, ouvrez https://servbay-express-test-prod.servbay.demo. Vous accéderez ainsi en local, via le proxy de ServBay, à l’instance Express.js tournant sur le port 8586. Parfait pour tester le fonctionnement en condition de production.

Connexion aux bases de données

ServBay propose plusieurs packages de bases de données pour le développement local : MariaDB, PostgreSQL, MongoDB, Redis. Une fois ces services activés dans ServBay, votre projet Express.js peut s’y connecter facilement. ServBay préconfigure souvent des utilisateurs/mots de passe par défaut (par exemple, MariaDB/MySQL : root & password, PostgreSQL : user & password, base servbay_default). Reportez-vous à l’interface de ServBay ou à la configuration par défaut si besoin.

Voici des exemples de connexion aux bases de données principales dans un projet Express.js. Assurez-vous d’avoir installé le driver Node.js correspondant via npm install <nom-du-package>.

1. Connexion à MongoDB

   Installez d’abord le driver MongoDB Mongoose :

   npm install mongoose

   Dans le code de votre projet (par exemple dans app.js ou un fichier dédié) :

   var mongoose = require('mongoose');
   
   // Connexion à une instance MongoDB locale, base : servbay-express-app
   // Par défaut, MongoDB sur ServBay n'exige pas d'authentification
   mongoose.connect('mongodb://localhost/servbay-express-app', {
     useNewUrlParser: true,
     useUnifiedTopology: true
   })
   .then(() => console.log('Connecté à MongoDB'))
   .catch(err => console.error('Erreur de connexion MongoDB :', err));

   Vérifiez que le service MongoDB de ServBay est lancé.

2. Connexion à Redis

   Installez le client Redis :

   npm install redis

   Puis utilisez-le dans votre projet :

   var redis = require('redis');
   // Par défaut, Redis fonctionne sur localhost:6379 sans mot de passe sur ServBay
   var client = redis.createClient({
       host: 'localhost',
       port: 6379
   });
   
   client.on('connect', function() {
       console.log('Connecté à Redis');
   });
   
   client.on('error', function (err) {
     console.log('Erreur Redis : ' + err);
   });
   
   // Exemple : set/get d'une clé
   // client.set('mykey', 'Hello from Express!', redis.print);
   // client.get('mykey', function(err, reply) {
   //     if (err) throw err;
   //     console.log(reply); // Affiche "Hello from Express!"
   // });
   
   // Utilisez l'objet client pour vos opérations Redis selon vos besoins

   Vérifiez que le package Redis de ServBay est activé.

3. Connexion à MariaDB / MySQL

   MariaDB et MySQL sont gérés de façon similaire, par exemple avec le package mariadb (également compatible MySQL) ou mysql2.

   Installez le package pertinent :

   npm install mariadb # ou npm install mysql2

   Connectez-vous ensuite avec les identifiants par défaut de ServBay (root/password), en adaptant le nom de base selon vos besoins.

   var mariadb = require('mariadb');
   // Par défaut, MariaDB/MySQL tourne sur localhost:3306 dans ServBay
   var pool = mariadb.createPool({
     host: 'localhost',
     port: 3306, // Port par défaut
     user: 'root', // Utilisateur par défaut
     password: 'password', // Mot de passe par défaut
     database: 'servbay_express_app', // À créer dans ServBay si nécessaire
     connectionLimit: 5 // Taille du pool de connexions
   });
   
   pool.getConnection()
     .then(conn => {
       console.log("Connecté à MariaDB/MySQL");
       // Utilisez conn pour vos requêtes
       // conn.query("SELECT 1").then(...).catch(...).finally(() => conn.release());
       conn.release(); // Libérer la connexion dans le pool
     })
     .catch(err => {
       console.log("Connexion échouée, erreur : " + err);
     });

   Avant de vous connecter, créez la base de données servbay_express_app via les outils graphiques de ServBay (phpMyAdmin, Adminer, etc.). Vérifiez que le service MariaDB/MySQL est démarré dans ServBay.

4. Connexion à PostgreSQL

   Installez le client pg :

   npm install pg

   Utilisez les paramètres par défaut (user : user, mot de passe : password, base : servbay_default) pour vous connecter :

   var { Pool } = require('pg');
   // Par défaut, PostgreSQL sur ServBay écoute sur localhost:5432
   var pool = new Pool({
     user: 'user', // Utilisateur par défaut
     host: 'localhost',
     database: 'servbay_default', // Base par défaut ou autre base créée
     password: 'password', // Mot de passe par défaut
     port: 5432, // Port par défaut
   });
   
   pool.connect((err, client, done) => {
     if (err) {
       console.error('Erreur de connexion PostgreSQL :', err);
       return;
     }
     console.log('Connecté à PostgreSQL');
     // Utilisez client pour exécuter vos requêtes
     // client.query('SELECT NOW()', (err, res) => { ... done(); });
     done(); // Libérer la connexion
   });
   
   // Ou version async/await
   // try {
   //   const client = await pool.connect();
   //   console.log('Connecté à PostgreSQL');
   //   // const res = await client.query('SELECT NOW()');
   //   // console.log(res.rows[0]);
   //   client.release();
   // } catch (err) {
   //   console.error('Erreur de connexion PostgreSQL :', err);
   // }

   Pensez à activer PostgreSQL dans ServBay.

Résumé

Grâce à ces étapes, vous avez appris à créer, configurer et lancer un projet Express.js avec ServBay. Vous savez désormais :

• Initialiser un projet Express.js via express-generator.
• Exécuter l’application sur un port dédié.
• Configurer un proxy inverse dans les Sites ServBay pour accéder à votre application Node.js en HTTP/S standard.
• Connecter votre projet à différentes bases de données supportées par ServBay.

ServBay simplifie grandement la gestion et la mise en place d’un environnement de développement Node.js (Express.js) local, pour vous permettre de vous concentrer sur le code. D’autres fonctions (certificats SSL automatiques, sauvegarde des sites, visualisation des logs, etc.) vous offrent également plus de confort et de sécurité pendant le développement.