Top
Home • Kategorien • JavaScript • Molecular

Molecular

Ein Microservice Framework für NodeJS.

$ npm install --save moleculer

Der ServiceBroker ist die Komponente welche das managen übernimmt.
Grundsätzlich erstellt man eine Instanz des Brokers, registriert Services und ruft diese auf.

const { ServiceBroker } = require("moleculer");
const broker = new ServiceBroker({});

Nachdem eine Broker Instanz erstellt wurde, lädt man die Services aus einem Verzeichnis.

broker.loadServices(folder = "./services", fileMask = "*.service.js");
broker.loadServices(); // default settings

Anschliessend können die Service in dieser Form aufgerufen werden.

let promisedCall = broker.call(service.action, params[, opts]);

Wenn der Broker einen Service aufruft, erzeugt er ein Context Objekt für den Request und übergibt dieses an den Action Handler des Services, params ist Teil des Context Objekts.

Der Broker hat einen Event Bus womit man Events lokal und global senden kann.

broker.emitLocal("user.arrived", { name: 'Moleculer' });
broker.emit("user.arrived", { name: 'Moleculer' });

Als Beispiel kann der Broker alle Events empfangen die von Services ausgetauscht werden.

broker.on("**", (payload, sender) => console.log(payload, sender));

Es werden interne Actions zur Verfügung gestellt um den Status des Brokers abzufragen.

$node.services
$node.actions
$node.list
$node.health
$node.stats

Der Broker serialisiert die Daten als JSON und nutzt dazu das Modul serializer.
Ein anderes Modul sind die Transporter wenn Services auf unterschiedlichen Nodes laufen.

Ein Service der vom Broker verwaltet wird hat dieses grundlegende Schema.

{
    name: "serviceName",
    actions: {
        // called from broker
    },
    events: {
        // subscribe to events
    },
    methods: {
        // private functions for the service
    },
    created() {
        // fired when created
    },
    started() {
        // fired when broker starts
    }
    stopped() {
        // fired when broker stops
    }
}

Ein einfacher Service könnte so aussehen.

module.exports = {
    name: "social",
    actions: {
        welcome(ctx) {
            return "Welcome " + ctx.params.name;
        }
    },
    events: {
        "user.arrived": function(payload, sender, eventName) {
            this.broker.call("social.welcome", {name: payload['name']})
                    .then(res => console.log(res));
        }
    }
};

Der Service kann entsprechend aufgerufen werden, wenn der Broker instanziert ist.

broker.call("social.welcome", {name: 'Moleculer'})
    .then(res => console.log(res));

Um unter Services Funktionalitäten wiederzuverwenden kann man Mixins nutzen.
Dazu erstellt man eine separate Datei in der die Funktionalität definiert ist.

module.exports = {
    methods: {
        capitalizeFirst(string) {
            return string.charAt(0).toUpperCase() + string.slice(1);
        }
    }
};

Ein Service kann dann entsprechend Funktionalitäten hinzufügen.

const baseService = require("./base");

module.exports = {
    name: "social",
    mixins: [baseService],
    actions: {
        welcome(ctx) {
            return "Welcome " + this.capitalizeFirst(ctx.params.name);
        }
    }
};

Services können sich mit Events benachrichtigen oder man kann über das Context Objekt mit dem Broker Services aufrufen.

Es existiert ein API Gateway um Services über HTTP oder HTTPS zur Verfügung zu stellen.

npm install --save moleculer-web

Dem Broker wird dazu ein weiterer Service hinzugefügt.

const ApiService = require("moleculer-web");
...
broker.createService({
    mixins: ApiService,
    settings: {
        port: 3000,
        routes: [{
            path: "/api"
        }]
    }
});

Der Service kann nun über einen URI referenziert werden.

http://localhost:3000/api/social/welcome?name=molecular

Moleculer hat noch mehr zu bieten, das Projekt ist noch recht neu, einen Blick ist es wert.