Configurare un ambiente di sviluppo Hapi.js con ServBay

Hapi.js è un framework Node.js potente e flessibile, ideale per costruire applicazioni e API. ServBay fornisce agli sviluppatori Node.js un ambiente di sviluppo locale pratico, integrando runtime Node.js, diverse basi dati e funzionalità di server web semplici da configurare. Questa guida ti accompagnerà nella creazione e nell'esecuzione di un progetto Hapi.js con ServBay, nella configurazione della funzione Siti Web di ServBay per l’accesso tramite proxy inverso e nella connessione ai database integrati di ServBay.

Cos’è Hapi.js?

Hapi.js è un framework Node.js sviluppato da Walmart Labs per creare applicazioni e servizi web in modo potente e modulare. È noto per il suo solido sistema di plugin, l’approccio “configuration-driven” e le avanzate caratteristiche di sicurezza integrate, consentendo agli sviluppatori di realizzare facilmente applicazioni web e API performanti e mantenibili.

Caratteristiche e vantaggi principali di Hapi.js

• Sistema di plugin: Hapi.js offre un sistema di plugin potente e semplice da usare, che consente di estendere facilmente le funzionalità del framework o di organizzare la logica dell’applicazione in moduli riutilizzabili.
• Orientato alla configurazione: Hapi.js promuove uno sviluppo basato su configurazione, permettendo di definire comportamento di routing, validazioni, caching, ecc. tramite opzioni dettagliate.
• Validazione degli input: Include la libreria Joi, una soluzione dichiarativa e robusta per la validazione dei dati, assicurando integrità e sicurezza dei dati ricevuti.
• Ecosistema ricco: Vanta una comunità attiva e un’ampia gamma di plugin ufficiali e di terze parti per autenticazione, autorizzazione, caching, logging, e tante altre funzionalità strategiche.
• Sicurezza: Numerose feature di sicurezza sono integrate nel framework, aiutando a prevenire i rischi web comuni, come validazione degli input e controlli CORS.
• Logging e debug: Offre strumenti dettagliati per il logging del ciclo di vita delle richieste e per la fase di debug.

Grazie a Hapi.js, gli sviluppatori possono concentrarsi sulla logica applicativa, delegando la gestione di HTTP, routing, validazione e sicurezza al framework.

Configurare un progetto Hapi.js con ServBay

Questa sezione mostra come usare l’ambiente Node.js fornito da ServBay per creare ed eseguire un semplice progetto Hapi.js, e come sfruttare la funzione Siti Web (proxy inverso) di ServBay per accedervi.

Prerequisiti

Prima di iniziare, assicurati di:

1. Aver installato con successo ServBay su macOS.
2. Aver attivato il pacchetto Node.js in ServBay. Puoi trovarlo e abilitarlo dal tab "Pacchetti" del pannello di controllo ServBay.
3. Conoscere le basi dell’uso del terminale e del gestore pacchetti npm per Node.js.

Creazione del progetto Hapi.js

1. Inizializza la cartella del progetto

   Apri il terminale, entra nella directory consigliata da ServBay /Applications/ServBay/www, crea una cartella per il nuovo progetto (es. servbay-hapi-app) ed entra al suo interno:

   cd /Applications/ServBay/www
   mkdir servbay-hapi-app
   cd servbay-hapi-app

2. Inizializza il progetto Node.js

   All’interno della directory, avvia la creazione di un progetto Node.js:

   npm init -y

   Questo comando crea un file package.json nella root del progetto.

3. Installa le dipendenze di Hapi.js

   Installa la libreria principale Hapi.js tramite npm:

   npm install @hapi/hapi

   Questo comando aggiungerà @hapi/hapi alle dipendenze del tuo progetto.

4. Crea il file di ingresso dell’app

   Nella directory principale del progetto, crea un file chiamato server.js e inserisci il seguente codice per impostare un semplice server Hapi.js:

   'use strict'; // Attiva la modalità rigorosa
   
   const Hapi = require('@hapi/hapi');
   
   const init = async () => {
   
     const server = Hapi.server({
       port: process.env.PORT || 3000, // Ascolta sulla porta 3000 di default, oppure quella specificata tramite la variabile d'ambiente PORT
       host: 'localhost' // Ascolta l’indirizzo di loopback locale
     });
   
     // Definisci una semplice rotta di root
     server.route({
       method: 'GET',
       path: '/',
       handler: (request, h) => {
         return 'Hello from Hapi.js powered by ServBay!';
       }
     });
   
     // Avvia il server
     await server.start();
     console.log('Server running on %s', server.info.uri);
   };
   
   // Gestisce errori di Promise Rejection non catturati
   process.on('unhandledRejection', (err) => {
     console.error(err);
     process.exit(1); // Termina il processo
   });
   
   // Avvia l’applicazione chiamando la funzione init
   init();

   Questo codice avvia un server Hapi che ascolta la porta specificata (localhost, default 3000), e definisce un semplice handler GET per la rotta /.

Attivare la modalità sviluppo e configurare il sito ServBay

Durante lo sviluppo, puoi eseguire direttamente l’app Node.js e mappare il tuo progetto ad un dominio personalizzato tramite il proxy inverso di ServBay, sfruttando anche il certificato SSL fornito per l’ambiente locale.

1. Avvia il server di sviluppo Hapi.js

   Dal terminale, assicurati di essere nella cartella servbay-hapi-app, quindi lancia server.js specificando una porta, ad esempio 8585:

   PORT=8585 node server.js

   Il server si avvierà, mostrando l’URI in ascolto, es. Server running on http://localhost:8585. Mantieni questa finestra terminale aperta mentre il server è attivo.

2. Configura il sito (proxy inverso) in ServBay

   Apri l’applicazione ServBay. Vai al tab "Siti Web" e clicca il pulsante "+" in basso a sinistra per aggiungere un nuovo sito.

   • Nome (Name): ServBay Hapi Dev (puoi scegliere un altro nome a piacere)
   • Dominio (Domain): servbay-hapi-dev.servbay.demo (si consiglia di usare il suffisso .servbay.demo per evitare conflitti e sfruttare il CA locale di ServBay)
   • Tipo sito (Type): seleziona Proxy inverso (Reverse Proxy)
   • Proxy a (Proxy to):
     • Protocollo (Protocol): http
     • Indirizzo IP (IP Address): 127.0.0.1 (il server Node gira su loopback)
     • Porta (Port): 8585 (uguale a quella scelta per PORT)

   Clicca su "Aggiungi" per completare la configurazione. ServBay predisporrà automaticamente il server web (ad es. Caddy o Nginx) per fare proxy da https://servbay-hapi-dev.servbay.demo verso http://127.0.0.1:8585 e genererà un certificato SSL valido (CA locale di ServBay) per accessi HTTPS.

   Per informazioni dettagliate sulla configurazione, consulta le istruzioni ServBay.

3. Accedi all’app Hapi.js in sviluppo

   Apri il browser e visita https://servbay-hapi-dev.servbay.demo. Dovresti vedere la pagina con il messaggio "Hello from Hapi.js powered by ServBay!".

   Qualsiasi modifica a server.js (spesso combinata con strumenti come nodemon per il ricaricamento automatico) sarà riflessa tramite il proxy inverso su ServBay nel browser.

Esempio di distribuzione in produzione

Per l’ambiente di produzione, ti servirà una gestione dei processi più robusta (ad es. PM2) e opzioni di configurazione differenti. Ecco un esempio pratico per far girare l’app su un’altra porta e mappare il traffico tramite il proxy inverso di ServBay:

1. Avvia il server Hapi.js in produzione

   Supponi di eseguire l’app su una porta diversa (es. 8586) e in modalità produzione:

   PORT=8586 NODE_ENV=production node server.js

   (Nota: in ambienti reali è bene utilizzare PM2 o tool simili per gestire i processi Node.js, garantendone la stabilità e il riavvio automatico. ServBay supporta anche l’integrazione con PM2).

2. Configura il sito di produzione (proxy inverso) in ServBay

   Nel tab "Siti Web" di ServBay, clicca ancora "+" per aggiungere un nuovo sito:

   • Nome: ServBay Hapi Prod
   • Dominio: servbay-hapi-prod.servbay.demo
   • Tipo sito: Proxy inverso (Reverse Proxy)
   • Proxy a:
     • Protocollo: http
     • Indirizzo IP: 127.0.0.1
     • Porta: 8586

   Clicca "Aggiungi".

3. Accedi all’app Hapi.js in produzione

   Apri il browser su https://servbay-hapi-prod.servbay.demo. Dovresti vedere lo stesso output che in sviluppo (a meno che il tuo codice non distingua tra NODE_ENV), ma lancia ora su una porta e una configurazione pensate per una simulazione di produzione.

La funzione Siti Web di ServBay consente di gestire con facilità diversi domini locali per lo sviluppo o la produzione simulata, mappandoli su varie istanze Hapi.js (o altre app Node.js) in ascolto su porte differenti.

Collegarsi ai database offerti da ServBay

ServBay integra e supporta simultaneamente database come MySQL, MariaDB, PostgreSQL, MongoDB e Redis. Qui di seguito trovi esempi pratici su come collegare un progetto Hapi.js a queste basi dati.

Importante: Prima di connetterti, assicurati di aver abilitato e avviato i pacchetti database desiderati dal tab "Pacchetti" in ServBay. Puoi controllare lo stato dei database direttamente dal pannello di controllo.

Le credenziali di default per i database ServBay sono:

• MySQL/MariaDB: utente root, password password
• PostgreSQL: utente user, password password
• MongoDB: nessuna autenticazione richiesta (di default)
• Redis: nessuna autenticazione richiesta (di default)

Nota: Per sicurezza, si raccomanda di cambiare la password di default dei database su ServBay, specialmente se l’ambiente è accessibile dall’esterno. Puoi modificare la password root per MySQL, MariaDB e PostgreSQL direttamente da ServBay. Consulta la documentazione per il reset password database.

Esempi di connessione ai vari database (installa prima il client corrispondente con npm):

1. Connessione a MySQL

   Installa il client MySQL:

   npm install mysql2 # oppure mysql

   Codice di esempio (usando mysql2):

   const mysql = require('mysql2');
   
   const connection = mysql.createConnection({
     host: 'localhost',
     user: 'root', // Username di default ServBay
     password: 'password', // Password di default ServBay
     database: 'servbay_hapi_app' // Sostituisci con il tuo DB
   });
   
   connection.connect(err => {
     if (err) {
       console.error('Error connecting to MySQL: ' + err.stack);
       return;
     }
     console.log('Connected to MySQL as id ' + connection.threadId);
   });
   
   // Chiudi la connessione se necessario
   // connection.end();

2. Connessione a MariaDB

   Installa il client MariaDB:

   npm install mariadb

   Codice di esempio:

   const mariadb = require('mariadb');
   const pool = mariadb.createPool({
     host: 'localhost',
     user: 'root', // Username di default ServBay
     password: 'password', // Password di default
     database: 'servbay_hapi_app', // Sostituisci con il tuo DB
     connectionLimit: 5 // Dimensione del pool
   });
   
   pool.getConnection()
     .then(conn => {
       console.log("Connected to MariaDB");
       // conn.query(...) per eseguire query
       conn.release(); // Rilascia la connessione al pool
     })
     .catch(err => {
       console.error("Not connected to MariaDB due to error: " + err);
     });

3. Connessione a PostgreSQL

   Installa il client PostgreSQL:

   npm install pg

   Codice di esempio:

   const { Pool } = require('pg');
   const pool = new Pool({
     user: 'user', // Username di default ServBay
     host: 'localhost',
     database: 'servbay_hapi_app', // Sostituisci con il tuo DB
     password: 'password', // Password di default ServBay
     port: 5432, // Porta predefinita PostgreSQL
   });
   
   pool.connect((err, client, done) => {
     if (err) {
       console.error('Error connecting to PostgreSQL: ', err);
       return;
     }
     console.log('Connected to PostgreSQL');
     client.query('SELECT NOW()', (err, res) => {
       done(); // Rilascia la connessione al pool
       if (err) {
         console.error('Error executing query', err.stack);
       } else {
         console.log('PostgreSQL current time:', res.rows[0].now);
       }
     });
   });
   
   // Il pool si chiuderà automaticamente alla chiusura dell’applicazione
   // pool.end();

4. Connessione a MongoDB

   Installa il client MongoDB:

   npm install mongoose # oppure mongodb

   Codice di esempio (usando mongoose):

   const mongoose = require('mongoose');
   
   mongoose.connect('mongodb://localhost/servbay-hapi-app', {
     useNewUrlParser: true,
     useUnifiedTopology: true,
     // L'installazione MongoDB su ServBay non richiede autenticazione di default; se necessario, aggiungi authSource, user, pass nelle opzioni
     // authSource: 'admin',
     // user: 'your_username',
     // pass: 'your_password',
   })
   .then(() => console.log('MongoDB connected'))
   .catch(err => console.error('MongoDB connection error:', err));
   
   // La connessione rimane attiva per tutta la vita dell’applicazione
   // Per disconnettersi: mongoose.connection.close();

5. Connessione a Redis

   Installa il client Redis:

   npm install redis

   Codice di esempio:

   const redis = require('redis');
   // Usa i parametri di default: host: 'localhost', port: 6379
   const client = redis.createClient();
   
   client.on('error', function (err) {
     console.error('Redis Error: ' + err);
   });
   
   client.on('connect', function () {
     console.log('Redis client connected');
   });
   
   // Connettiti al server Redis
   client.connect(); // Per redis v4+ è necessario chiamare connect()
   
   // Esempio: impostare e recuperare valori chiave
   // async function exampleRedisUsage() {
   //   await client.set('mykey', 'myvalue');
   //   const value = await client.get('mykey');
   //   console.log('Value from Redis:', value);
   //   await client.del('mykey');
   // }
   // exampleRedisUsage();
   
   // Chiudi la connessione quando non serve più
   // client.quit();

Integra questo codice nel tuo progetto Hapi.js per sfruttare le potenzialità dei database ServBay durante lo sviluppo locale.

Conclusione

ServBay rende estremamente efficiente la configurazione di un ambiente Hapi.js su macOS. Offre una soluzione all-in-one con runtime Node.js gestito, diversi database pronti all’uso e la funzione Siti Web che semplifica l’accesso locale tramite proxy inverso e SSL automatico. Seguendo i passaggi di questa guida, puoi avviare rapidamente il tuo progetto Hapi.js e sfruttare al meglio le funzionalità ServBay, accelerando il tuo workflow di sviluppo.