Configurer un Environnement de Développement Hapi.js avec ServBay

Hapi.js est un framework Node.js puissant et flexible, idéal pour la création d'applications web et d'API. ServBay offre aux développeurs Node.js un environnement local pratique qui intègre le runtime Node.js, plusieurs bases de données et un serveur web facile à configurer. Ce guide vous montrera comment créer et exécuter un projet Hapi.js sous ServBay, configurer la fonctionnalité Sites de ServBay pour y accéder, et illustrera comment se connecter aux bases de données intégrées de ServBay.

Qu'est-ce que Hapi.js ?

Hapi.js, développé à l'origine par Walmart Labs, est un framework Node.js robuste et modulaire pour la création d'applications et de services. Il est réputé pour son système de plugins puissant, son approche axée sur la configuration et ses fonctionnalités de sécurité intégrées, qui permettent aux développeurs de bâtir plus efficacement des applications web hautement performantes et maintenables.

Principales fonctionnalités et avantages de Hapi.js

Système de plugins : Hapi.js offre un système de plugins robuste et simple d’utilisation, facilitant l’extension des fonctionnalités du framework ou la structuration de la logique applicative en modules réutilisables.
Priorité à la configuration : Hapi.js privilégie le développement orienté configuration, permettant de définir routes, validation, cache, etc., via des options détaillées.
Validation des entrées : Livré avec la bibliothèque Joi, Hapi.js propose une validation déclarative et puissante des données pour garantir leur intégrité et sécurité.
Écosystème riche : Un écosystème dynamique avec de nombreux plugins officiels et tiers pour répondre à des besoins courants comme l’authentification, l’autorisation, la journalisation, le caching, etc.
Sécurité : De multiples fonctionnalités de sécurité intégrées protègent contre les failles web classiques, notamment la validation des entrées et la gestion CORS.
Logging et débogage : Cycle de vie des requêtes documenté, logs détaillés et outils de débogage intégrés.

Avec Hapi.js, les développeurs peuvent se concentrer sur la logique métier tandis que le framework gère la complexité sous-jacente des requêtes HTTP, du routage, de la validation et de la sécurité.

Créer un Projet Hapi.js avec ServBay

Cette section vous guide pour créer et exécuter un projet Hapi.js de base dans l’environnement Node.js fourni par ServBay, puis l’exposer via la fonctionnalité Sites (proxy inverse) de ServBay.

Prérequis

Avant de commencer, veuillez vérifier que :

Vous avez installé ServBay avec succès sur macOS.
Le package Node.js est activé dans l’application ServBay (onglet "Packages" du panneau de contrôle ServBay).
Vous savez utiliser le terminal et le gestionnaire de paquets npm de Node.js.

Création du projet Hapi.js

Initialiser le dossier du projet
Ouvrez le terminal et positionnez-vous dans le dossier racine web recommandé par ServBay : /Applications/ServBay/www. Créez un nouveau dossier de projet (par exemple servbay-hapi-app) puis entrez dans ce dossier :
bash
```
cd /Applications/ServBay/www
mkdir servbay-hapi-app
cd servbay-hapi-app
```
1
2
3
Initialiser un projet Node.js
Dans le dossier du projet, initialisez un nouveau projet Node.js :
bash
```
npm init -y
```
1
Cela générera un fichier package.json à la racine du projet.
Installer la dépendance Hapi.js
Installez le cœur du framework Hapi.js :
bash
```
npm install @hapi/hapi
```
1
@hapi/hapi sera alors ajouté à vos dépendances.

Créer le fichier d’entrée de l’application

Créez un fichier nommé server.js à la racine du projet et ajoutez le code suivant pour un serveur Hapi.js simple :

javascript

'use strict'; // Active le mode strict

const Hapi = require('@hapi/hapi');

const init = async () => {

  const server = Hapi.server({
    port: process.env.PORT || 3000, // Écoute sur le port 3000 par défaut, ou celui spécifié dans PORT
    host: 'localhost' // Adresse de loopback locale
  });

  // Définir une route racine simple
  server.route({
    method: 'GET',
    path: '/',
    handler: (request, h) => {
      return 'Hello from Hapi.js powered by ServBay!';
    }
  });

  // Démarrer le serveur
  await server.start();
  console.log('Server running on %s', server.info.uri);
};

// Gérer les erreurs de promesse non interceptées
process.on('unhandledRejection', (err) => {
  console.error(err);
  process.exit(1); // Quitte le processus
});

// Appeler init pour démarrer l’application
init();

Ce script lance un serveur Hapi qui écoute localhost sur le port indiqué (par défaut 3000) et gère la route / avec un message de bienvenue.

Lancer le mode développement et configurer le site ServBay

En phase de développement, lancez votre application Node.js et utilisez la fonctionnalité de proxy inverse de ServBay pour lier votre serveur à un nom de domaine personnalisé, tout en profitant du certificat SSL généré automatiquement par ServBay.

Démarrer le serveur Hapi.js en mode développement
Dans le terminal, dans le dossier servbay-hapi-app, exécutez la commande suivante pour lancer server.js sur un port (par exemple 8585) compatible avec le proxy de ServBay :
bash
```
PORT=8585 node server.js
```
1
Le serveur démarre et affiche une URI du type Server running on http://localhost:8585. Laissez ce terminal ouvert, le serveur est actif.
Configurer le site (proxy inverse) dans ServBay
Ouvrez l’application ServBay. Dans l’onglet "Sites", cliquez sur le bouton "+" en bas à gauche pour ajouter un nouveau site.
- Nom : ServBay Hapi Dev (nommer librement pour vous repérer dans la liste ServBay)
- Domaine : servbay-hapi-dev.servbay.demo (l’usage du suffixe .servbay.demo évite les conflits avec des domaines réels et permet l’utilisation du certificat CA local de ServBay)
- Type de site : sélectionnez Proxy inverse (Reverse Proxy)
- Proxy vers :
  - Protocole : http
  - Adresse IP : 127.0.0.1 (serveur Node.js local)
  - Port : 8585 (doit correspondre au PORT défini plus haut)
Cliquez sur "Ajouter" pour finaliser. ServBay gère alors automatiquement la configuration du serveur web (Caddy ou Nginx), effectue le proxy inverse de https://servbay-hapi-dev.servbay.demo vers http://127.0.0.1:8585, et génère un certificat SSL pour ce sous-domaine (via la CA utilisateur ServBay).
Pour un guide plus détaillé concernant la configuration d'un site dans ServBay, consultez la documentation officielle.
Accéder à votre application Hapi.js en développement
Ouvrez votre navigateur web et visitez https://servbay-hapi-dev.servbay.demo. La page devrait afficher "Hello from Hapi.js powered by ServBay!".
Toute modification de votre fichier server.js (en utilisant un outil comme nodemon pour le rechargement automatique) sera reflétée immédiatement grâce au proxy inverse configuré dans ServBay.

Déployer la version production (exemple)

Pour un environnement de production, il est recommandé d’utiliser une gestion de processus robuste (comme PM2) et une configuration adaptée. Voici un exemple simple de configuration sur un autre port, également exposé via proxy inverse ServBay :

Démarrer le serveur Hapi.js en mode production
Par exemple, pour lancer le serveur sur le port 8586 avec la variable d’environnement de production :
bash
```
PORT=8586 NODE_ENV=production node server.js
```
1
(Remarque : en production réelle, gérez les processus Node.js avec PM2 pour la résilience. ServBay supporte l’intégration avec PM2.)
Configurer le site proxy inverse pour la production dans ServBay
Ajoutez un autre site via l’onglet "Sites" :
- Nom : ServBay Hapi Prod
- Domaine : servbay-hapi-prod.servbay.demo
- Type de site : Proxy inverse (Reverse Proxy)
- Proxy vers :
  - Protocole : http
  - Adresse IP : 127.0.0.1
  - Port : 8586
Cliquez sur "Ajouter".
Accéder à l’application Hapi.js en production
Dans le navigateur, rendez-vous sur https://servbay-hapi-prod.servbay.demo. La sortie sera identique à celle du mode développement (sauf si votre code prévoit un comportement distinct selon NODE_ENV), mais fonctionne sur des paramètres simulant un environnement de production.

En utilisant la fonction Sites de ServBay, vous pouvez facilement gérer plusieurs domaines locaux pour le développement ou la simulation de production, chacun pointant vers des instances Hapi.js (ou autre Node.js) sur des ports différents.

Connexion aux bases de données intégrées de ServBay

ServBay intègre et prend en charge plusieurs bases de données : MySQL, MariaDB, PostgreSQL, MongoDB et Redis. Voici comment connecter votre projet Hapi.js à ces services.

Important : Avant de vous connecter à une base de données, activez le package correspondant dans l’onglet "Packages" de ServBay et assurez-vous que le service est démarré. Vous pouvez vérifier le statut du service depuis le panneau ServBay.

Voici les utilisateurs et mots de passe par défaut sur ServBay :

MySQL/MariaDB : utilisateur root, mot de passe password
PostgreSQL : utilisateur user, mot de passe password
MongoDB : authentification désactivée par défaut
Redis : authentification désactivée par défaut

Remarque : Pour des raisons de sécurité, il est fortement conseillé de modifier les mots de passe par défaut des bases de données dans ServBay, surtout si l'usage dépasse le local. Utilisez la fonction ServBay prévue à cet effet. Voir documentation pour réinitialiser le mot de passe.

Voici quelques extraits de code pour se connecter à différentes bases de données. Installez d’abord les clients nécessaires en npm.

Connexion à MySQL

Installer le client :

bash

npm install mysql2 # ou mysql

Exemple de connexion (avec mysql2) :

javascript

const mysql = require('mysql2');

const connection = mysql.createConnection({
  host: 'localhost',
  user: 'root', // Nom d’utilisateur par défaut ServBay
  password: 'password', // Mot de passe par défaut ServBay
  database: 'servbay_hapi_app' // Remplacez par le nom de votre base
});

connection.connect(err => {
  if (err) {
    console.error('Erreur de connexion MySQL : ' + err.stack);
    return;
  }
  console.log('Connecté à MySQL avec l’id ' + connection.threadId);
});

// Fermer la connexion si besoin
// connection.end();

Connexion à MariaDB

Installer le client :

bash

npm install mariadb

Exemple de connexion :

javascript

const mariadb = require('mariadb');
const pool = mariadb.createPool({
  host: 'localhost',
  user: 'root', // Nom d’utilisateur par défaut ServBay
  password: 'password', // Mot de passe par défaut ServBay
  database: 'servbay_hapi_app', // Remplacez par le nom de votre base
  connectionLimit: 5 // Taille du pool de connexions
});

pool.getConnection()
  .then(conn => {
    console.log("Connecté à MariaDB");
    // conn.query(...) exécuter les requêtes
    conn.release(); // Libérer la connexion vers le pool
  })
  .catch(err => {
    console.error("Non connecté à MariaDB, erreur : " + err);
  });

Connexion à PostgreSQL

Installer le client :

bash

npm install pg

Exemple de connexion :

javascript

const { Pool } = require('pg');
const pool = new Pool({
  user: 'user', // Nom d’utilisateur par défaut ServBay
  host: 'localhost',
  database: 'servbay_hapi_app', // Remplacez par le nom de votre base
  password: 'password', // Mot de passe par défaut ServBay
  port: 5432, // Port par défaut PostgreSQL
});

pool.connect((err, client, done) => {
  if (err) {
    console.error('Erreur de connexion PostgreSQL : ', err);
    return;
  }
  console.log('Connecté à PostgreSQL');
  client.query('SELECT NOW()', (err, res) => {
    done(); // Libérer la connexion client
    if (err) {
      console.error('Erreur lors de la requête', err.stack);
    } else {
      console.log('Heure actuelle PostgreSQL :', res.rows[0].now);
    }
  });
});

// Le pool sera fermé automatiquement à la sortie de l’application
// pool.end();

Connexion à MongoDB

Installer le client :

bash

npm install mongoose # ou mongodb

Exemple de connexion (avec mongoose) :

javascript

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/servbay-hapi-app', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  // L’installation MongoDB par défaut de ServBay n’exige pas d’authentification.
  // Si vous activez l’authentification, utilisez les options suivantes :
  // authSource: 'admin',
  // user: 'your_username',
  // pass: 'your_password',
})
.then(() => console.log('MongoDB connecté'))
.catch(err => console.error('Erreur de connexion MongoDB :', err));

// La connexion Mongoose reste active tout au long de l’application
// Pour se déconnecter : mongoose.connection.close();

Connexion à Redis

Installer le client :

bash

npm install redis

Exemple de connexion :

javascript

const redis = require('redis');
// Paramètres par défaut : host : 'localhost', port : 6379
const client = redis.createClient();

client.on('error', function (err) {
  console.error('Erreur Redis : ' + err);
});

client.on('connect', function () {
  console.log('Client Redis connecté');
});

// Connexion au serveur Redis
client.connect(); // Depuis redis v4+, l’appel à connect() est requis

// Exemple : set et get d’une clé
// async function exampleRedisUsage() {
//   await client.set('mykey', 'myvalue');
//   const value = await client.get('mykey');
//   console.log('Valeur depuis Redis :', value);
//   await client.del('mykey');
// }
// exampleRedisUsage();

// Fermer la connexion à la sortie de l’application
// client.quit();

Intégrez ces codes de connexion à votre application Hapi.js pour bénéficier localement de toutes les bases de données offertes par ServBay.

Conclusion

Avec ServBay, mettre en place un environnement Hapi.js sur macOS devient rapide et efficace. ServBay propose une solution tout-en-un : runtime Node.js simple à administrer, bases de données prêtes à l’emploi, gestion aisée des accès locaux grâce à la fonctionnalité Sites (proxy inverse et SSL automatique). En suivant ce guide, vous pouvez démarrer votre projet Hapi.js en quelques minutes et accélérer votre cycle de développement grâce à la puissance de ServBay.

Configurer un Environnement de Développement Hapi.js avec ServBay ​

Qu'est-ce que Hapi.js ? ​

Principales fonctionnalités et avantages de Hapi.js ​

Créer un Projet Hapi.js avec ServBay ​

Prérequis ​

Création du projet Hapi.js ​

Lancer le mode développement et configurer le site ServBay ​

Déployer la version production (exemple) ​

Connexion aux bases de données intégrées de ServBay ​

Conclusion ​

Configurer un Environnement de Développement Hapi.js avec ServBay

Qu'est-ce que Hapi.js ?

Principales fonctionnalités et avantages de Hapi.js

Créer un Projet Hapi.js avec ServBay

Prérequis

Création du projet Hapi.js

Lancer le mode développement et configurer le site ServBay

Déployer la version production (exemple)

Connexion aux bases de données intégrées de ServBay

Conclusion