Konfiguration und Ausführung eines LoopBack-Projekts in ServBay

Was ist LoopBack?

LoopBack ist ein von IBM entwickeltes, sehr skalierbares Open-Source-Node.js-Framework, das speziell für den schnellen Aufbau von APIs und Microservices konzipiert wurde. Es setzt auf modellgetriebene Entwicklung (Model Driven Development, MDD), mit der Entwickler Datenmodelle effizient definieren und dabei leistungsfähige RESTful APIs automatisch generieren können. LoopBack bietet eine breite Palette integrierter Funktionen wie Datenquellenanbindung, Benutzer-Authentifizierung & -Autorisierung, API-Explorer-Unterstützung und den Zugang zu verschiedenen Datenbanken und Protokollen.

Wichtige Eigenschaften und Vorteile von LoopBack

• Modellgetriebene Entwicklung (MDD): Datenmodelle werden auf intuitive Weise definiert; das Framework generiert passende API-Endpunkte und Validierungslogik automatisch.
• Unterstützung mehrerer Datenquellen: Einfache Anbindung beliebter Datenbanken (wie MongoDB, MySQL, PostgreSQL, MariaDB etc.) sowie REST- und SOAP-Dienste.
• Leistungsstarke CLI-Tools: Mit der LoopBack-CLI (Command Line Interface) stehen viele Befehle zur Verfügung, die z. B. die Projektinitialisierung, Modell-Definition und Datenquellenkonfiguration erheblich vereinfachen.
• Modularität und Erweiterbarkeit: Das flexible Design ermöglicht die Integration von Drittanbieter-Bibliotheken und -Services über Komponenten und Erweiterungen, um spezifische Anforderungen zu erfüllen.
• Eingebaute Sicherheitsfunktionen: Direkt einsetzbare Authentifizierungs- und Autorisierungsmechanismen machen den Aufbau sicherer APIs besonders einfach.

Mit LoopBack können Entwickler Backend- und API-Anwendungen im Web schnell, performant und wartungsfreundlich realisieren.

LoopBack-Projekt mit ServBay einrichten und betreiben

Diese Anleitung zeigt Ihnen, wie Sie im Node.js-Umfeld von ServBay ein neues LoopBack-Projekt anlegen und betreiben. Wir nutzen dabei die Funktion „Webseiten“ von ServBay, um einen lokalen Webserver zu konfigurieren. Durch Reverse Proxy leitet ServBay externe Requests an den Port des LoopBack-Servers weiter – so gelingt komfortabler lokaler Zugriff und Debugging im Entwicklungsmodus.

LoopBack-Projekt erstellen

1. LoopBack-CLI installieren

   Stellen Sie zunächst sicher, dass Sie das Node.js-Paket in ServBay installiert und aktiviert haben. Öffnen Sie anschließend das Terminal und installieren Sie das LoopBack-CLI-Tool global via npm:

   npm install -g @loopback/cli

2. Projekt initialisieren

   Navigieren Sie in das empfohlene Webseiten-Stammverzeichnis von ServBay, /Applications/ServBay/www, und initialisieren Sie mit CLI ein neues LoopBack-Projekt. Verwenden Sie als Projektnamen am besten Kleinbuchstaben und Bindestriche, z. B. servbay-loopback-app:

   cd /Applications/ServBay/www
   lb4 app servbay-loopback-app

   Die CLI führt Sie durch den Einrichtungsdialog, bei dem Sie u. a. Features (wie REST API, Serialisierung, Authentifizierung etc.) auswählen und die Projektstruktur konfigurieren können. Treffen Sie die Wahl passend zu Ihrem Vorhaben.

3. Projektabhängigkeiten installieren

   Wechseln Sie ins neue Projektverzeichnis und installieren Sie die erforderlichen Node.js-Abhängigkeiten:

   cd servbay-loopback-app
   npm install

LoopBack-Projekt Rückgabewert anpassen (optional)

Um zu zeigen, wie Sie Ihre Anwendung über ServBay aufrufen, können wir den Standard-Endpoint /ping anpassen und mit einer individuellen Antwort versehen.

1. Datei src/controllers/ping.controller.ts bearbeiten

   Suchen Sie in Ihrem LoopBack-Projekt die Datei src/controllers/ping.controller.ts und ändern Sie deren Inhalt wie folgt, damit /ping die Zeichenkette „Hello ServBay!“ zurückgibt:

   import {get} from '@loopback/rest';
   
   export class PingController {
     constructor() {}
   
     @get('/ping')
     ping(): string {
       // Rückgabewert auf "Hello ServBay!" ändern
       return 'Hello ServBay!';
     }
   }

Projekt im Entwicklungsmodus ausführen

Im Entwicklungsmodus nutzen Sie in der Regel den eingebauten Entwicklungsserver von LoopBack, um schnell Änderungen zu testen. Über den Reverse Proxy von ServBay ist der Server auch bequem vom Browser aus zugänglich.

1. Entwicklungsserver starten

   Starten Sie das LoopBack-Projekt im Projektverzeichnis via Terminal. Die Anwendung hört standardmäßig an einem bestimmten Port. Über die Umgebungsvariable PORT legen Sie den Port fest, z. B. 8585:

   cd /Applications/ServBay/www/servbay-loopback-app
   PORT=8585 npm start

   Nach dem Start erscheint im Terminal eine Meldung wie „Server is running at http://[::1]:8585“.

2. ServBay-Webseite (Reverse Proxy) konfigurieren

   Öffnen Sie das ServBay-Kontrollzentrum und wechseln Sie zum Bereich „Webseiten“. Dort klicken Sie auf „Hinzufügen“, um eine neue Reverse-Proxy-Seite einzurichten, die externe Domain- und Port-Anfragen an die interne Adresse und den Port der LoopBack-Anwendung weiterleitet:

   • Name: z. B. My first LoopBack dev site (zur Identifikation in ServBay)
   • Domain: z. B. servbay-loopback-dev.servbay.demo (diese Adresse verwenden Sie im Browser)
   • Typ: Reverse Proxy auswählen
   • IP-Adresse: 127.0.0.1 (die LoopBack-App läuft lokal)
   • Port: 8585 (Port des LoopBack-Servers)

   Nach Abschluss speichern Sie die Einstellungen und übernehmen die Änderungen in ServBay. Die lokale DNS-Konfiguration (über die Anpassung an /etc/hosts oder das ServBay Helper Tool) sowie der eingesetzte Webserver (Caddy oder Nginx) werden automatisch angepasst, sodass Sie den gewählten Domainnamen direkt nutzen können.

   Ausführliche Hinweise zur Einrichtung eines Reverse-Proxy-Webseiten in ServBay finden Sie unter: Node.js-Entwicklungswebseite hinzufügen.

3. Anwendung im Entwicklungsmodus aufrufen

   Öffnen Sie Ihren Webbrowser und gehen Sie auf die konfigurierte Domain sowie den Endpunkt Ihrer LoopBack-Anwendung, z. B. https://servbay-loopback-dev.servbay.demo/ping.

   Dank der automatischen SSL-Zertifikatskonfiguration von ServBay (via User CA oder Public CA) können Sie Ihr Projekt direkt per HTTPS auf Ihrem lokalen Entwicklungsserver aufrufen. Das simuliert Zugriffsszenarios aus der Produktivumgebung, um frühzeitig SSL-bezogene Probleme zu erkennen. Weitere Details zur SSL-Unterstützung von ServBay finden Sie unter: Website mit SSL schützen.

Deployment im Produktionsmodus (optional)

Wenn Ihr LoopBack-Projekt bereit für den Einsatz ist, läuft es im Produktionsmodus (production mode). Dadurch werden zumeist die Performance verbessert und Debug-Ausgaben minimiert.

1. Produktionsserver starten

   Starten Sie im Projektstamm Ordner die LoopBack-Anwendung im Produktionsmodus. Setzen Sie beispielsweise den Port auf 8586 und die Umgebungsvariable NODE_ENV auf production:

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

2. ServBay-Webseite (Reverse Proxy) für Produktion anlegen/anpassen

   Wechseln Sie in ServBay erneut in den Bereich „Webseiten“ und legen Sie eine neue Reverse-Proxy-Seite für die Produktion an oder passen Sie die bestehende an, sodass sie auf Ihre produktive LoopBack-Anwendung verweist:

   • Name: z. B. My first LoopBack production site
   • Domain: z. B. servbay-loopback-prod.servbay.demo
   • Typ: Reverse Proxy auswählen
   • IP-Adresse: 127.0.0.1
   • Port: 8586 (Port der Anwendung im Produktionsmodus)

   Speichern Sie die Einstellung und übernehmen Sie die Änderungen.

3. Produktionsanwendung aufrufen

   Navigieren Sie in Ihrem Webbrowser zu der dafür vorgesehenen Domain, z. B. https://servbay-loopback-prod.servbay.demo/ping, um die produktive Anwendung zu überprüfen. ServBay stellt auch für diese Domain automatischen HTTPS-Support bereit.

Datenbankanbindung

Das LoopBack-Framework unterstützt zahlreiche Datenbanken über DataSource-Connectoren. In ServBay finden Sie vorkonfigurierte Pakete für MySQL, MariaDB, PostgreSQL, MongoDB und Redis, die Sie ganz einfach starten und in Ihr LoopBack-Projekt einbinden können.

Nachfolgend finden Sie Beispielkonfigurationen für gängige Datenbanken in Verbindung mit ServBay. Passen Sie die Beispiele entsprechend Ihren Anforderungen an.

Wichtiger Hinweis: Die Benutzernamen und Passwörter in den Konfigurationsbeispielen sind Platzhalter. Verwenden Sie stets die realen Zugangsdaten, die Sie für den Root-User oder für andere Benutzer im ServBay Control Panel vergeben haben. Dort können Sie Datenbank-Nutzer und Passwörter verwalten.

1. Verbindung zu MongoDB

   Installieren und starten Sie in ServBay das MongoDB-Paket. Dann installieren Sie den MongoDB-Connector für LoopBack:

   npm install --save @loopback/connector-mongodb

   Konfigurieren Sie anschließend die Datenquelle im Projekt (z. B. in src/datasources/mongodb.datasource.ts):

   // src/datasources/mongodb.datasource.ts
   import {juggler} from '@loopback/repository';
   
   const config = {
     name: 'mongodb',
     connector: 'mongodb',
     // ServBay MongoDB läuft standardmäßig auf localhost:27017
     url: 'mongodb://localhost:27017/servbay-loopback-app', // Ersetzen Sie den Datenbanknamen nach Bedarf
     host: 'localhost',
     port: 27017,
     user: '', // Falls Benutzer-Authentifizierung genutzt wird, tragen Sie den Usernamen ein
     password: '', // Falls Benutzer-Authentifizierung genutzt wird, hier das Passwort
     database: 'servbay-loopback-app', // Ihren Datenbanknamen anpassen
     // Weitere optionale Einstellungen...
   };
   
   export class MongodbDataSource extends juggler.DataSource {
     static dataSourceName = 'mongodb';
     constructor() {
       super(config);
     }
   }

2. Verbindung zu Redis

   Installieren und starten Sie den Redis-Service in ServBay. Installieren Sie anschließend einen Redis-Connector für LoopBack (Hinweis: Es gibt kein offizielles @loopback/connector-redis, sondern vornehmlich Community-Lösungen wie loopback-connector-redis oder Sie verwenden das Node.js-redis-Modul in Kombination mit LoopBack-Services):

   npm install --save loopback-connector-redis # oder ein anderes kompatibles Redis-Modul

   Konfigurieren Sie die Datenquelle (Beispiel basierend auf loopback-connector-redis):

   // src/datasources/redis.datasource.ts
   import {juggler} from '@loopback/repository';
   
   const config = {
     name: 'redis',
     connector: 'redis',
     // ServBay Redis läuft standardmäßig auf localhost:6379
     url: 'redis://localhost:6379',
     // Weitere optionale Einstellungen...
   };
   
   export class RedisDataSource extends juggler.DataSource {
     static dataSourceName = 'redis';
     constructor() {
       super(config);
     }
   }

   Hinweis: LoopBack 4 unterscheidet sich beim Umgang mit Datenquellen von LoopBack 3. Das Beispiel orientiert sich an einem klassischen Connector-Ansatz. In LoopBack 4 empfiehlt sich die Nutzung des @datasource-Decorators aus @loopback/repository und eine modernere Konfiguration. Die Parameter host, port, user, password, database bleiben jedoch üblich. Details dazu finden Sie in der offiziellen LoopBack 4-Dokumentation.

3. Verbindung zu MariaDB (oder MySQL)

   Installieren und starten Sie MariaDB oder MySQL in ServBay. Beide werden von ServBay unterstützt; der LoopBack-MySQL-Connector ist in der Regel auch mit MariaDB kompatibel. Installieren Sie anschließend den MySQL-Connector für LoopBack:

   npm install --save @loopback/connector-mysql

   Konfigurieren Sie dann Ihre Datenquelle:

   // src/datasources/mariadb.datasource.ts oder mysql.datasource.ts
   import {juggler} from '@loopback/repository';
   
   const config = {
     name: 'mariadb', // oder 'mysql'
     connector: 'mysql', // Verwenden Sie den MySQL-Connector
     // url: '', // Alternativ kann auch die URL genutzt werden oder die Einzelparameter
     host: 'localhost', // ServBay-Datenbanken laufen lokal
     port: 3306, // MariaDB/MySQL Standardport
     user: 'root', // ServBay verwendet häufig 'root' als Default-Nutzer
     password: 'password', // << Hier Ihr tatsächliches Datenbankpasswort eintragen! >>
     database: 'servbay_loopback_app', // Ihren Datenbanknamen anpassen
     // Weitere optionale Einstellungen...
   };
   
   export class MariaDbDataSource extends juggler.DataSource {
     static dataSourceName = 'mariadb'; // oder 'mysql'
     constructor() {
       super(config);
     }
   }

   Achten Sie darauf, dass das Beispiel password: 'password' lediglich ein Platzhalter ist. Das tatsächlich gesetzte Root-Passwort finden oder ändern Sie im ServBay Control Panel und tragen es dann hier ein.

4. Verbindung zu PostgreSQL

   Installieren und starten Sie das PostgreSQL-Paket in ServBay. Installieren Sie anschließend den PostgreSQL-Connector für LoopBack:

   npm install --save @loopback/connector-postgresql

   Konfigurieren Sie anschließend die Datenquelle:

   // src/datasources/postgresql.datasource.ts
   import {juggler} from '@loopback/repository';
   
   const config = {
     name: 'postgresql',
     connector: 'postgresql',
     // url: '', // Alternativ ist das URL-Format oder Einzelparameter möglich
     host: 'localhost', // ServBay PostgreSQL läuft lokal
     port: 5432, // Standardport von PostgreSQL
     user: 'user', // << Hier Benutzername aus ServBay eintragen >>
     password: 'password', // << Hier echtes Passwort aus ServBay eintragen >>
     database: 'servbay_loopback_app', // Ihren Datenbanknamen anpassen
     // Weitere optionale Einstellungen...
   };
   
   export class PostgresqlDataSource extends juggler.DataSource {
     static dataSourceName = 'postgresql';
     constructor() {
       super(config);
     }
   }

   Achtung: Die Beispielwerte für user: 'user' und password: 'password' sind Platzhalter. Die echten Zugangsdaten für Ihren PostgreSQL-Benutzer entnehmen oder vergeben Sie im ServBay-Control Panel.

Fazit

Mit diesen Schritten haben Sie ein LoopBack-Node.js-Projekt in ServBay erfolgreich erstellt, konfiguriert und ausgeführt. Sie wissen nun, wie Reverse-Proxy-Webseiten in ServBay zum Zugriff auf Ihre Anwendung eingerichtet werden und wie Ihr LoopBack-Projekt mit verschiedenen von ServBay unterstützten Datenbanken verbunden werden kann.

ServBay bietet eine stabile, komfortable lokale Entwicklungsumgebung für Node.js-Frameworks wie LoopBack – inklusive Webserver, Datenbanken und Runtime-Unterstützung für verschiedene Programmiersprachen. Dank der integrierten Seitenverwaltung, SSL-Unterstützung und Datenbankintegration können Sie Entwicklungs- und Testprozesse lokal effizienter und sicherer gestalten.