Konfiguracja środowiska deweloperskiego Hapi.js w ServBay

Hapi.js to potężny i elastyczny framework Node.js, idealny do tworzenia aplikacji i API. ServBay zapewnia wygodne lokalne środowisko dla deweloperów Node.js, integrując uruchamianie Node.js, liczne bazy danych oraz łatwą konfigurację serwera WWW. Ten poradnik przeprowadzi Cię przez proces tworzenia oraz uruchomienia projektu Hapi.js w środowisku ServBay, pokaże jak skonfigurować funkcję strony w ServBay, a także jak połączyć się z wbudowanymi bazami danych.

Czym jest Hapi.js?

Hapi.js to rozwijany przez Walmart Labs potężny i elastyczny framework Node.js do tworzenia aplikacji oraz usług. Znany jest z rozbudowanego systemu wtyczek, podejścia opartego na konfiguracji oraz wbudowanych funkcji bezpieczeństwa, które umożliwiają szybkie budowanie wydajnych i łatwych w utrzymaniu aplikacji internetowych i API.

Kluczowe cechy i zalety Hapi.js

• System wtyczek: Hapi.js oferuje potężny i intuicyjny system pluginów, pozwalający łatwo rozbudować funkcjonalności frameworka oraz logicznie organizować aplikację w moduły wielokrotnego użytku.
• Konfiguracja ponad kodowaniem: Rozwój aplikacji w Hapi.js opiera się na konfigurowaniu – precyzyjne opcje ustawień definiują trasowanie, walidację, cache i inne zachowania.
• Walidacja wejścia: Dzięki wbudowanej bibliotece Joi, framework oferuje deklaratywną walidację danych, dbając o ich integralność i bezpieczeństwo.
• Bogaty ekosystem: Aktywna społeczność i ogrom zasobów – oficjalnych i zewnętrznych pluginów – zaspokaja potrzeby w zakresie uwierzytelniania, autoryzacji, logowania, cache'owania i innych funkcjonalności.
• Bezpieczeństwo: Framework zawiera wiele mechanizmów ochronnych chroniących przed typowymi zagrożeniami webowymi, np. walidację wejścia czy kontrolę CORS.
• Logowanie i debugowanie: Zapewnia szczegółowe logi cyklu życia żądania oraz narzędzia do debugowania.

Dzięki Hapi.js deweloperzy mogą skupić się na logice biznesowej, a zarządzanie trasami, walidacją czy zabezpieczeniami pozostawić frameworkowi.

Tworzenie projektu Hapi.js z użyciem ServBay

W tej części dowiesz się, jak stworzyć i uruchomić podstawowy projekt Hapi.js korzystając ze środowiska Node.js dostępnego w ServBay oraz skonfigurować funkcję strony (reverse proxy) dla wygodnego dostępu.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że:

1. ServBay jest poprawnie zainstalowany na Twoim macOS (ServBay).
2. W aplikacji ServBay włączony jest pakiet Node.js. Znajdziesz go i aktywujesz w zakładce "Pakiety" w panelu ServBay.
3. Znasz podstawowe polecenia terminala oraz obsługę npm – menedżera paczek Node.js.

Tworzenie projektu Hapi.js

1. Inicjalizacja katalogu projektu

   Otwórz terminal, przejdź do sugerowanego przez ServBay katalogu stron WWW /Applications/ServBay/www. Utwórz tam folder na nowy projekt (przykładowo servbay-hapi-app) i wejdź do niego:

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

2. Inicjalizacja projektu Node.js

   W katalogu projektu uruchom inicjalizację za pomocą npm:

   npm init -y

   W efekcie powstanie plik package.json w głównym folderze projektu.

3. Instalacja zależności Hapi.js

   Zainstaluj bibliotekę Hapi.js poleceniem:

   npm install @hapi/hapi

   To polecenie doda @hapi/hapi do zależności Twojego projektu.

4. Utworzenie pliku wejściowego aplikacji

   W katalogu głównym projektu stwórz plik server.js i wklej poniższy kod uruchamiający prosty serwer Hapi.js:

   'use strict'; // Włączenie trybu ścisłego
   
   const Hapi = require('@hapi/hapi');
   
   const init = async () => {
   
     const server = Hapi.server({
       port: process.env.PORT || 3000, // Nasłuchiwanie na porcie 3000 lub ustawionym przez zmienną środowiskową PORT
       host: 'localhost' // Nasłuch na adresie lokalnym
     });
   
     // Definicja prostego route'u głównego
     server.route({
       method: 'GET',
       path: '/',
       handler: (request, h) => {
         return 'Hello from Hapi.js powered by ServBay!';
       }
     });
   
     // Uruchomienie serwera
     await server.start();
     console.log('Server running on %s', server.info.uri);
   };
   
   // Obsługa nieobsłużonych błędów Promise Rejection
   process.on('unhandledRejection', (err) => {
     console.error(err);
     process.exit(1); // Zakończenie procesu
   });
   
   // Wywołanie funkcji init w celu uruchomienia aplikacji
   init();

   Powyższy kod uruchamia serwer Hapi nasłuchujący na wskazanym porcie localhost (domyślnie 3000), z prostym handlerem GET pod ścieżką /.

Tryb deweloperski i konfiguracja strony w ServBay

Podczas pracy nad projektem możesz uruchomić aplikację Node.js i za pomocą funkcji reverse proxy w ServBay udostępnić ją pod własną domeną lokalną, korzystając przy tym z certyfikatu SSL.

1. Uruchomienie serwera developerskiego Hapi.js

   Upewnij się, że jesteś w katalogu servbay-hapi-app, a następnie uruchom plik server.js na wybranym porcie (np. 8585) poleceniem:

   PORT=8585 node server.js

   Serwer wystartuje i pokaże adres URI, np. Server running on http://localhost:8585. Pozostaw terminal otwarty i działający serwer.

2. Konfiguracja strony (reverse proxy) w ServBay

   Otwórz aplikację ServBay. Przejdź na zakładkę "Strony", a następnie kliknij przycisk "+" w lewym dolnym rogu, aby dodać nową stronę.

   • Nazwa (Name): ServBay Hapi Dev (dowolna, do identyfikacji w aplikacji)
   • Domena (Domain): servbay-hapi-dev.servbay.demo (zaleca się końcówkę .servbay.demo dla uniknięcia konfliktu z prawdziwymi domenami i wygodnego korzystania z CA ServBay)
   • Typ strony (Type): Wybierz Reverse Proxy
   • Proxy do (Proxy to):
     • Protokół (Protocol): http
     • Adres IP (IP Address): 127.0.0.1 (serwer Node.js działa lokalnie)
     • Port: 8585 (zgodny ze zmienną PORT przy uruchamianiu serwera)

   Kliknij "Dodaj" aby potwierdzić. ServBay skonfiguruje dla Ciebie serwer WWW (np. Caddy lub Nginx), żeby żądania do https://servbay-hapi-dev.servbay.demo były kierowane do http://127.0.0.1:8585. System automatycznie wygeneruje certyfikat SSL dla domeny .servbay.demo (przez User CA ServBay), dzięki czemu możesz korzystać z HTTPS w lokalnym środowisku.

   Szczegółowe kroki znajdziesz w dokumentacji konfiguracji stron ServBay.

3. Dostęp do aplikacji Hapi.js w trybie deweloperskim

   Otwórz przeglądarkę i wejdź na skonfigurowaną domenę https://servbay-hapi-dev.servbay.demo. Powinieneś zobaczyć komunikat "Hello from Hapi.js powered by ServBay!".

   Teraz wszelkie zmiany w pliku server.js (w połączeniu z narzędziami jak nodemon – do automatycznego przeładowania) będą natychmiast widoczne w przeglądarce dzięki reverse proxy ServBay.

Wdrożenie wersji produkcyjnej (przykład)

W środowisku produkcyjnym warto użyć menedżera procesów (np. PM2) i osobnej konfiguracji. Oto krótki przykład uruchomienia aplikacji na innym porcie i powiązania jej z reverse proxy ServBay:

1. Uruchomienie serwera produkcyjnego Hapi.js

   Załóżmy, że do uruchomienia produkcyjnego wybierasz port 8586 oraz odpowiednią konfigurację środowiska:

   PORT=8586 NODE_ENV=production node server.js

   (Uwaga: w produkcji zwykle stosuje się PM2 lub podobne narzędzia do zarządzania procesami Node.js. ServBay obsługuje także integrację z PM2).

2. Konfiguracja strony produkcyjnej (reverse proxy) w ServBay

   Przejdź ponownie do zakładki "Strony" w aplikacji ServBay i kliknij "+" aby dodać kolejną stronę:

   • Nazwa (Name): ServBay Hapi Prod
   • Domena (Domain): servbay-hapi-prod.servbay.demo
   • Typ strony (Type): Reverse Proxy
   • Proxy do (Proxy to):
     • Protokół (Protocol): http
     • Adres IP (IP Address): 127.0.0.1
     • Port: 8586

   Kliknij "Dodaj".

3. Dostęp do produkcyjnej wersji Hapi.js

   W przeglądarce odwiedź adres https://servbay-hapi-prod.servbay.demo. Zobaczysz taki sam komunikat (chyba, że Twój kod w trybie NODE_ENV=production działa inaczej), jednak aplikacja uruchamiana jest w symulowanych warunkach produkcyjnych.

Dzięki funkcji stron w ServBay możesz wygodnie zarządzać wieloma domenami lokalnymi – zarówno dla środowisk deweloperskich jak i testów produkcyjnych na osobnych portach dla projektów Hapi.js (lub innych aplikacji Node.js).

Połączenie z bazami danych w ServBay

ServBay zawiera i obsługuje wiele systemów bazodanowych: MySQL, MariaDB, PostgreSQL, MongoDB oraz Redis. Poniżej znajdziesz przykłady łączenia się z tymi bazami w projekcie Hapi.js.

Ważne: Przed podłączeniem się do wybranej bazy upewnij się, że w zakładce "Pakiety" w ServBay masz aktywowany odpowiedni pakiet oraz uruchomioną usługę danej bazy. Statusy usług sprawdzisz w panelu ServBay.

Domyślne login i hasło do baz ServBay:

• MySQL/MariaDB: użytkownik root, hasło password
• PostgreSQL: użytkownik user, hasło password
• MongoDB: domyślnie bez uwierzytelniania
• Redis: domyślnie bez uwierzytelniania

Uwaga: Ze względów bezpieczeństwa zdecydowanie zaleca się zmianę domyślnych haseł baz w ServBay (zwłaszcza w środowisku innym niż lokalne). Hasła dla MySQL, MariaDB i PostgreSQL można łatwo zmienić bezpośrednio z poziomu ServBay. Skorzystaj z dokumentacji resetowania haseł.

Poniżej przykładowe fragmenty kodu dla połączenia z każdą z baz. Przed użyciem zainstaluj odpowiednie biblioteki klienckie przez npm.

1. Połączenie z MySQL

   Instalacja klienta MySQL:

   npm install mysql2 # lub mysql

   Przykładowy kod połączenia (przez mysql2):

   const mysql = require('mysql2');
   
   const connection = mysql.createConnection({
     host: 'localhost',
     user: 'root', // domyślny użytkownik ServBay
     password: 'password', // domyślne hasło ServBay
     database: 'servbay_hapi_app' // zamień na nazwę swojej bazy
   });
   
   connection.connect(err => {
     if (err) {
       console.error('Error connecting to MySQL: ' + err.stack);
       return;
     }
     console.log('Connected to MySQL as id ' + connection.threadId);
   });
   
   // Zamknięcie połączenia gdy jest niepotrzebne
   // connection.end();

2. Połączenie z MariaDB

   Instalacja klienta MariaDB:

   npm install mariadb

   Przykładowy kod:

   const mariadb = require('mariadb');
   const pool = mariadb.createPool({
     host: 'localhost',
     user: 'root', // domyślny użytkownik ServBay
     password: 'password', // domyślne hasło ServBay
     database: 'servbay_hapi_app', // zamień na swoją nazwę bazy
     connectionLimit: 5 // rozmiar puli
   });
   
   pool.getConnection()
     .then(conn => {
       console.log("Connected to MariaDB");
       // conn.query(...) wykonywanie zapytań
       conn.release(); // zwolnienie połączenia do puli
     })
     .catch(err => {
       console.error("Not connected to MariaDB due to error: " + err);
     });

3. Połączenie z PostgreSQL

   Instalacja klienta PostgreSQL:

   npm install pg

   Przykładowy kod:

   const { Pool } = require('pg');
   const pool = new Pool({
     user: 'user', // domyślny użytkownik ServBay
     host: 'localhost',
     database: 'servbay_hapi_app', // zamień na swoją nazwę bazy
     password: 'password', // domyślne hasło ServBay
     port: 5432, // domyślny port
   });
   
   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(); // zwolnienie klienta
       if (err) {
         console.error('Error executing query', err.stack);
       } else {
         console.log('PostgreSQL current time:', res.rows[0].now);
       }
     });
   });
   
   // Połączenie zamykane automatycznie po zakończeniu działania aplikacji
   // pool.end();

4. Połączenie z MongoDB

   Instalacja klienta MongoDB:

   npm install mongoose # lub mongodb

   Przykładowy kod (przez mongoose):

   const mongoose = require('mongoose');
   
   mongoose.connect('mongodb://localhost/servbay-hapi-app', {
     useNewUrlParser: true,
     useUnifiedTopology: true,
     // W domyślnej instalacji ServBay nie wymaga autoryzacji. Jeśli wymagana – dodaj odpowiednie opcje.
     // authSource: 'admin',
     // user: 'your_username',
     // pass: 'your_password',
   })
   .then(() => console.log('MongoDB connected'))
   .catch(err => console.error('MongoDB connection error:', err));
   
   // Połączenie przez mongoose utrzymywane jest przez cały czas działania aplikacji
   // Rozłącz: mongoose.connection.close();

5. Połączenie z Redis

   Instalacja klienta Redis:

   npm install redis

   Przykładowy kod:

   const redis = require('redis');
   // Domyślne parametry: 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');
   });
   
   // Połączenie z serwerem Redis – od wersji redis v4+ wymagane connect()
   client.connect();
   
   // Przykład: ustawianie i pobieranie klucza
   // 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();
   
   // Zamknięcie połączenia przy wychodzeniu z aplikacji
   // client.quit();

Włączając te fragmenty kodu do swojego projektu Hapi.js, uzyskasz natychmiastowy dostęp do wszystkich najważniejszych baz danych oferowanych przez ServBay w środowisku lokalnym.

Podsumowanie

ServBay znacząco upraszcza budowanie środowiska Hapi.js na macOS. Oferuje kompleksowe rozwiązanie: łatwą w instalacji i zarządzaniu platformę Node.js, gotowe do użycia bazy danych oraz intuicyjną konfigurację funkcji stron (reverse proxy z automatycznym SSL) umożliwiającą szybki, bezpieczny dostęp lokalny. Stosując powyższe kroki natychmiast uruchomisz własny projekt Hapi.js i wykorzystasz funkcjonalności ServBay, które realnie przyspieszają cały proces developmentu.