Einrichten einer Hapi.js Entwicklungsumgebung mit ServBay

Hapi.js ist ein leistungsstarkes und flexibles Node.js-Framework für die Entwicklung von Anwendungen und APIs. ServBay bietet Node.js-Entwicklern eine komfortable lokale Entwicklungsumgebung mit integriertem Node.js-Laufzeit, Unterstützung für verschiedene Datenbanken und einfach konfigurierbaren Webserver-Funktionen. Dieser Leitfaden zeigt Ihnen, wie Sie ein Hapi.js-Projekt in ServBay erstellen, ausführen und über die Webseiten-Funktion von ServBay darauf zugreifen. Zudem erfahren Sie, wie Sie auf die in ServBay integrierten Datenbanken zugreifen.

Was ist Hapi.js?

Hapi.js ist ein von Walmart Labs entwickeltes, leistungsfähiges und flexibles Node.js-Framework zur Erstellung von Anwendungen und Diensten. Es zeichnet sich durch ein ausgeklügeltes Plug-in-System, einen konfiguratorischen Ansatz und zahlreiche integrierte Sicherheitsfunktionen aus. Dadurch können Entwickler leistungsfähige und wartbare Webanwendungen und APIs besonders effizient erstellen.

Hauptmerkmale und Vorteile von Hapi.js

• Plug-in-System: Das leistungsstarke und einfach nutzbare Plug-in-System von Hapi.js ermöglicht es, die Funktionalität durch wiederverwendbare Module einfach zu erweitern oder Anwendungslogik zu strukturieren.
• Konfigurationsorientierte Entwicklung: Hapi.js setzt auf eine konfigurationsgetriebene Entwicklung – Routen, Validierungen, Caching und vieles mehr werden über detaillierte Optionen definiert.
• Eingabevalidierung: Über das integrierte Joi-Toolkit ermöglicht Hapi.js deklarative und sichere Validierung von Daten, um deren Integrität und Sicherheit sicherzustellen.
• Reiches Ökosystem: Eine aktive Community sowie zahlreiche offizielle und Third-Party-Plug-ins bieten Lösungen für Authentifizierung, Autorisierung, Caching, Logging und viele weitere Standardaufgaben.
• Sicherheitsfeatures: Das Framework bringt viele Sicherheitsmechanismen mit, die Entwickler beim Schutz vor typischen Web-Sicherheitsbedrohungen unterstützen, z. B. Input-Validierung und CORS.
• Logging und Debugging: Detaillierte Protokollierung des Request-Lebenszyklus und Debug-Tools erleichtern die Entwicklung.

Mit Hapi.js können Sie sich auf die Umsetzung Ihrer Geschäftslogik konzentrieren, während das Framework sich um komplexe HTTP-Prozesse, Routing, Validierung und Sicherheit kümmert.

Hapi.js-Projekt mit ServBay einrichten

In diesem Abschnitt erfahren Sie, wie Sie mithilfe der Node.js-Umgebung von ServBay ein Hapi.js-Projekt aufsetzen, ausführen und über die Webseiten-Funktion von ServBay (Reverse Proxy) zugänglich machen.

Voraussetzungen

Bitte stellen Sie sicher, dass folgende Bedingungen erfüllt sind:

1. Sie haben ServBay erfolgreich auf Ihrem macOS-System installiert.
2. Das Node.js-Paket ist in der ServBay-App aktiviert. Dies können Sie in der "Pakete"-Ansicht der ServBay-Konsole erledigen.
3. Sie sind mit grundlegenden Terminalbefehlen sowie dem Node.js-Paketmanager npm vertraut.

Hapi.js-Projekt anlegen

1. Projektverzeichnis initialisieren

   Öffnen Sie das Terminal und wechseln Sie zum empfohlenen Web-Root-Verzeichnis von ServBay unter /Applications/ServBay/www. Erstellen Sie hier einen neuen Projektordner (z.B. servbay-hapi-app) und wechseln Sie hinein:

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

2. Node.js-Projekt initialisieren

   Initialisieren Sie im Ordner das Node.js-Projekt:

   npm init -y

   Das erstellt die Datei package.json im Projektverzeichnis.

3. Hapi.js-Abhängigkeit installieren

   Installieren Sie das Hapi.js-Kernpaket:

   npm install @hapi/hapi

   Dadurch wird @hapi/hapi zur Projektabhängigkeit hinzugefügt.

4. Einstiegspunkt der App erstellen

   Erstellen Sie im Projektverzeichnis eine Datei namens server.js mit folgendem Beispielcode für einen einfachen Hapi.js-Server:

   'use strict'; // Strikten Modus aktivieren
   
   const Hapi = require('@hapi/hapi');
   
   const init = async () => {
   
     const server = Hapi.server({
       port: process.env.PORT || 3000, // Lauscht standardmäßig auf Port 3000 oder nach Umgebungsvariable PORT
       host: 'localhost' // Bindet an den lokalen Loopback-Adapter
     });
   
     // Definiert eine einfache Root-Route
     server.route({
       method: 'GET',
       path: '/',
       handler: (request, h) => {
         return 'Hello from Hapi.js powered by ServBay!';
       }
     });
   
     // Server starten
     await server.start();
     console.log('Server running on %s', server.info.uri);
   };
   
   // Behandlung nicht abgefangener Promise-Ablehnungen
   process.on('unhandledRejection', (err) => {
     console.error(err);
     process.exit(1); // Prozess verlassen
   });
   
   // Startet die Anwendung durch Aufruf der Init-Funktion
   init();

   Dieser Code startet einen Hapi-Server auf dem angegebenen Port (localhost:3000 oder nach Umgebungsvariable) und definiert einen einfachen GET-Handler für die Root-URL /.

Entwicklungsmodus starten und ServBay-Webseite konfigurieren

Während der Entwicklung können Sie Ihre Node.js-Anwendung direkt ausführen und mit der Reverse-Proxy-Funktion von ServBay einem lokalen Domainnamen zuweisen – so testen Sie bequem per Browser, inklusive SSL per ServBay.

1. Hapi.js Entwicklungsserver starten

   Stellen Sie sicher, dass Sie sich im Verzeichnis servbay-hapi-app befinden, und starten Sie den Server auf einem spezifischen Port (z. B. 8585), der später mit dem Reverse Proxy verknüpft wird:

   PORT=8585 node server.js

   Der Server zeigt im Terminal die verwendete Adresse, z. B. Server running on http://localhost:8585. Lassen Sie das Terminal geöffnet.

2. Website (Reverse Proxy) in ServBay anlegen

   Öffnen Sie ServBay, gehen Sie zur "Webseiten"-Ansicht und klicken Sie unten links auf das "+"-Symbol für eine neue Seite.

   • Name: ServBay Hapi Dev (kann frei gewählt werden, dient der Übersicht)
   • Domain: servbay-hapi-dev.servbay.demo (die .servbay.demo-Endung wird empfohlen, um Namenskonflikte zu vermeiden und das lokale CA-Zertifikat zu nutzen)
   • Type: Wählen Sie Reverse Proxy
   • Proxy zu:
     • Protokoll: http
     • IP-Adresse: 127.0.0.1 (weil der Node.js-Server lokal läuft)
     • Port: 8585 (entspricht dem Port aus dem Server-Startbefehl)

   Klicken Sie auf "Hinzufügen", um diese Webseite zu erstellen. ServBay konfiguriert nun den Webserver (z.B. Caddy oder Nginx) automatisch, sodass unter https://servbay-hapi-dev.servbay.demo alle Anfragen an http://127.0.0.1:8585 weitergeleitet werden. SSL-Zertifikate für .servbay.demo werden ebenfalls automatisch generiert und vom System als vertrauenswürdig eingestuft (über die ServBay User CA).

   Eine detaillierte Anleitung zur Website-Konfiguration finden Sie in der ServBay-Webseiten-Dokumentation.

3. Die laufende Hapi.js-Anwendung im Browser testen

   Öffnen Sie Ihren Browser und navigieren Sie zur eingerichteten Domain https://servbay-hapi-dev.servbay.demo. Es sollte die Seite mit "Hello from Hapi.js powered by ServBay!" erscheinen.

   Änderungen an server.js (idealerweise mit Hot-Reload via nodemon) werden über den ServBay-Proxy direkt im Browser sichtbar.

Beispiel: Produktions-Deployment

Für produktive Umgebungen empfiehlt sich ein Prozessmanager wie PM2 und eine angepasste Konfiguration. Zum Beispiel können Sie eine produktive Instanz auf einem anderen Port (z.B. 8586) betreiben:

1. Hapi.js-Produktionsserver starten

   Starten Sie die Anwendung mit einer anderen Portnummer (z.B. 8586) und aktivieren Sie den Production-Mode:

   PORT=8586 NODE_ENV=production node server.js

   (Hinweis: Für den Produktivbetrieb sollte ein Prozessmanager wie PM2 eingesetzt werden. ServBay unterstützt die Integration von PM2.)

2. Produktionswebseite in ServBay anlegen (Reverse Proxy)

   Fügen Sie in der ServBay-Webseiten-Übersicht erneut mit "+" eine weitere Seite hinzu:

   • Name: ServBay Hapi Prod
   • Domain: servbay-hapi-prod.servbay.demo
   • Typ: Reverse Proxy
   • Proxy zu:
     • Protokoll: http
     • IP-Adresse: 127.0.0.1
     • Port: 8586

   Klicken Sie auf "Hinzufügen".

3. Produktionsinstanz aufrufen

   Unter https://servbay-hapi-prod.servbay.demo erreichen Sie nun Ihre Anwendung im Produktionsmodus. Die Ausgabe entspricht ggfs. der im Entwicklermodus, es sei denn, Ihre Anwendung reagiert unterschiedlich auf NODE_ENV.

Mit der Webseiten-Funktion von ServBay behalten Sie die Kontrolle über mehrere lokale Entwicklungs- und produktionsnahe Instanzen, gemappt auf unterschiedliche Ports und Domains.

Anbindung der von ServBay bereitgestellten Datenbanken

ServBay bringt von Haus aus Support für mehrere Datenbanken: MySQL, MariaDB, PostgreSQL, MongoDB und Redis. Die folgenden Abschnitte zeigen, wie Sie diese aus Ihrem Hapi.js-Projekt heraus ansprechen.

Wichtig: Aktivieren Sie die gewünschten Datenbank-Pakete und starten Sie die Dienste über die "Pakete"-Ansicht von ServBay, bevor Sie eine Verbindung herstellen. Der Status der Datenbankserver wird im ServBay-Kontrollpanel angezeigt.

Standard-Zugangsdaten von ServBay:

• MySQL/MariaDB: Benutzername root, Passwort password
• PostgreSQL: Benutzername user, Passwort password
• MongoDB: Keine Authentifizierung (Voreinstellung)
• Redis: Keine Authentifizierung (Voreinstellung)

Hinweis: Aus Sicherheitsgründen wird dringend empfohlen, die Standardpasswörter insbesondere für andere als rein lokale Umgebungen zu ändern. In ServBay können Sie das root-Passwort für MySQL, MariaDB und PostgreSQL jederzeit über die Benutzeroberfläche zurücksetzen. Mehr dazu in der Dokumentation zur Passwortzurücksetzung.

Hier einige Beispielcodes für die Verbindung zu den verschiedenen Datenbanken (bitte die jeweiligen Client-Bibliotheken zuvor mit npm installieren):

1. MySQL-Verbindung

   MySQL-Client installieren:

   npm install mysql2 # oder mysql

   Beispiel (mit mysql2):

   const mysql = require('mysql2');
   
   const connection = mysql.createConnection({
     host: 'localhost',
     user: 'root', // Standardbenutzername von ServBay
     password: 'password', // Standardpasswort von ServBay
     database: 'servbay_hapi_app' // Bitte durch eigenen Datenbanknamen ersetzen
   });
   
   connection.connect(err => {
     if (err) {
       console.error('Error connecting to MySQL: ' + err.stack);
       return;
     }
     console.log('Connected to MySQL as id ' + connection.threadId);
   });
   
   // Verbindung bei Bedarf schließen
   // connection.end();

2. MariaDB-Verbindung

   MariaDB-Client installieren:

   npm install mariadb

   Beispiel:

   const mariadb = require('mariadb');
   const pool = mariadb.createPool({
     host: 'localhost',
     user: 'root', // Standardbenutzername von ServBay
     password: 'password', // Standardpasswort von ServBay
     database: 'servbay_hapi_app', // Bitte durch eigenen Datenbanknamen ersetzen
     connectionLimit: 5 // Größe des Verbindungspools
   });
   
   pool.getConnection()
     .then(conn => {
       console.log("Connected to MariaDB");
       // conn.query(...) führt Abfragen aus
       conn.release(); // Verbindung zurückgeben
     })
     .catch(err => {
       console.error("Not connected to MariaDB due to error: " + err);
     });

3. PostgreSQL-Verbindung

   PostgreSQL-Client installieren:

   npm install pg

   Beispiel:

   const { Pool } = require('pg');
   const pool = new Pool({
     user: 'user', // Standardbenutzername von ServBay
     host: 'localhost',
     database: 'servbay_hapi_app', // Bitte durch eigenen Datenbanknamen ersetzen
     password: 'password', // Standardpasswort von ServBay
     port: 5432, // PostgreSQL-Standardport
   });
   
   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(); // Client-Verbindung freigeben
       if (err) {
         console.error('Error executing query', err.stack);
       } else {
         console.log('PostgreSQL current time:', res.rows[0].now);
       }
     });
   });
   
   // Verbindungspool wird beim Beenden der App automatisch geschlossen
   // pool.end();

4. MongoDB-Verbindung

   MongoDB-Client installieren:

   npm install mongoose # oder mongodb

   Beispiel (mit mongoose):

   const mongoose = require('mongoose');
   
   mongoose.connect('mongodb://localhost/servbay-hapi-app', {
     useNewUrlParser: true,
     useUnifiedTopology: true,
     // Die in ServBay installierte MongoDB benötigt standardmäßig keine Authentifizierung.
     // Falls Authentifizierung aktiviert ist, die Optionen authSource, user, pass ergänzen.
     // authSource: 'admin',
     // user: 'your_username',
     // pass: 'your_password',
   })
   .then(() => console.log('MongoDB connected'))
   .catch(err => console.error('MongoDB connection error:', err));
   
   // Die Verbindung bleibt während der gesamten App-Laufzeit bestehen.
   // Verbindung schließen: mongoose.connection.close();

5. Redis-Verbindung

   Redis-Client installieren:

   npm install redis

   Beispiel:

   const redis = require('redis');
   // Standard-Verbindungsparameter: 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');
   });
   
   // Verbindung zum Redis-Server herstellen
   client.connect(); // Bei redis v4+ ist connect() erforderlich
   
   // Beispiel: Setzen/Holen von Werten
   // 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();
   
   // Verbindung beim Beenden der App schließen
   // client.quit();

Integrieren Sie die gewünschten Datenbank-Verbindungslogiken in Ihre Hapi.js-App, um in Ihrer lokalen Entwicklungsumgebung alle von ServBay bereitgestellten Datenbanken zu nutzen.

Fazit

Mit ServBay lässt sich eine Hapi.js-Entwicklungsumgebung auf macOS besonders effizient aufbauen. ServBay liefert eine Komplettlösung: einfach installierbares und verwaltbares Node.js-Laufzeitsystem, diverse nutzbare Datenbanken und eine unkomplizierte lokale Erreichbarkeit durch die Webseiten-Funktion inklusive Reverse Proxy und automatisierter SSL-Konfiguration. Folgen Sie der Anleitung, um Ihr Hapi.js-Projekt schnell zu starten und die starken Funktionen von ServBay optimal zu nutzen – so beschleunigen Sie Ihre Entwicklungsprozesse spürbar.