NestJS vs. Encore.ts: Auswahl des richtigen Frameworks für Ihre TypeScript-Microservices

Einführung

Wenn Webanwendungen größer werden, steigt auch die Komplexität bei der Entwicklung und Wartung des Systems. Eine gängige Methode zur Lösung dieses Problems ist die Verwendung der Microservice-Architektur, bei der Entwickler Systeme in kleinere, gut verwaltete Komponenten aufteilen, die individuell verwaltet und skaliert werden können.

Um dies effektiv zu tun, ist es oft hilfreich, ein Microservice-Framework zu verwenden. Die Auswahl des richtigen Frameworks, das Microservices nativ unterstützt, kann jedoch eine Herausforderung sein. In diesem Artikel werfen wir einen Blick auf Encore.ts und Nest.js als die beiden relevanten Alternativen, da beide nativ Microservices-Architekturen und TypeScript unterstützen.

Encore.ts ist ein neueres Open-Source-Framework, das sich durch hohe Leistung, Typsicherheit und Beobachtbarkeitsfunktionen auszeichnet. Nest.js hingegen leitet das TypeScript-Framework zum Erstellen von Microservices-Anwendungen. Jedes von ihnen hat etwas Starkes zu bieten, daher werden wir jedes Framework im Hinblick auf Architektur, Leistung und Skalierbarkeit untersuchen und erklären, wie wir feststellen können, welches für Sie am besten geeignet ist.

Bevor wir beginnen, schauen wir uns die Benchmark-Daten im Bild unten an:

Die Benchmark-Daten zeigen, dass Encore.ts 121.005 Anfragen pro Sekunde ohne Validierung und 107.018 mit Schemavalidierung verarbeiten kann. Das ist deutlich schneller als herkömmliche Frameworks. Beispielsweise erreicht Express.js mit Zod ohne Validierung nur etwa 15.707 Anfragen pro Sekunde und damit 11.878. Encore.ts ist also etwa neunmal schneller als Express, auf dem Nestjs aufbaut.

Übersicht über Encore.ts und NestJS

Wenn Sie ein Projekt starten, möchten Sie ein Framework, das nicht nur leistungsstark, sondern auch für Entwickler einfach zu verwenden ist. Encore.ts und NestJS zeichnen sich durch Microservice-Frameworks aus, die über integrierte Unterstützung für Typescript verfügen, aber auf ihre eigene Art und Weise funktionieren.

Encore.ts ist ein cloudnatives Open-Source-Framework für die Backend-Entwicklung mit integrierter Infrastrukturautomatisierung. Es ermöglicht Ihnen den Aufbau modularer verteilter Systeme mithilfe deklarativer Infrastrukturbibliotheken.

Encore.ts läuft auf einer Rust-Laufzeitumgebung, die über Napi in Node.js integriert ist, um eine außergewöhnliche Leistung bei der Verarbeitung von E/A und Multithreading zu erzielen und Ihnen gleichzeitig das Schreiben von Logik in TypeScript zu ermöglichen.

Hier ist ein einfaches Beispiel, wie Sie einen Dienst in Encore.ts definieren können:

import { Service } from "encore.dev/service";

export default new Service("hello");

Wenn dieser Hallo-Dienst erstellt wird, behandelt Encore.ts automatisch das gesamte Verzeichnis als Teil des Dienstes – es ist keine zusätzliche Konfiguration erforderlich.

Andererseits hat NestJS seinen eigenen Stil. Es handelt sich um ein flexibles TypeScript-Framework, mit dem Sie die vollständige Kontrolle darüber haben, wie Sie Ihre App erstellen, und das Ihnen die Freiheit gibt, die Dinge nach Ihren Wünschen zu strukturieren.

NestJS übernimmt zwar keine Infrastrukturautomatisierung, erleichtert aber die Integration in nahezu jede Bibliothek von Drittanbietern, was viele Möglichkeiten für verschiedene Projekte eröffnet.

Hier sehen Sie, wie Sie einen ähnlichen Dienst in NestJS definieren können:

import { Service } from "encore.dev/service";

export default new Service("hello");

NestJS bietet Ihnen mehr Flexibilität, jedoch ohne die integrierte Automatisierung von Encore.ts.

Architektur und Design

Die Architektur eines Frameworks bestimmt, wie Ihre Anwendung im Laufe der Zeit erstellt und gewartet wird. Sowohl Encore.ts als auch NestJS sind robust, aber ihre Kernphilosophien unterscheiden sich.

Encore.ts ist eigensinnig und *Cloud-first, was es ideal für große typsichere *verteilte Systeme mit vielen Microservices macht. Eine seiner herausragenden Funktionen ist die native Unterstützung für Pub/Sub, die eine ereignisgesteuerte Architektur nahtlos ermöglicht.

So können Sie einen ereignisgesteuerten Dienst in Encore.ts mithilfe von Pub/Sub definieren:

import { Controller, Get } from '@nestjs/common';

@Controller('hello')
export class HelloWorldController {
  @Get()
  sayHello(): string {
    return 'Hello, World!';
  }
}

NestJS ist zwar in der Lage, Microservices und ereignisgesteuerte Architekturen zu unterstützen, bietet aber einen modulareren Ansatz. Sein Kern folgt dem MVC-Muster und ermöglicht es Entwicklern, Systeme nach ihren Vorstellungen zu erstellen, indem es eine größere Kontrolle über Konfigurationen bietet.

So können Sie beispielsweise Dienste und Ereignisse in NestJS mit einem weitaus modulareren Ansatz definieren:

import { Topic, Subscription } from "encore.dev/pubsub";

// Define the event type for order creation
export interface OrderCreatedEvent {
    orderId: string;
}

// Create a topic for order creation events
export const orders = new Topic<OrderCreatedEvent>("orders", {
    deliveryGuarantee: "at-least-once",
});

// Create a subscription to listen for the order creation event
export const _ = new Subscription(orders, "process-order", {
    handler: async (event: OrderCreatedEvent) => {
        console.log('Order created:', event.orderId);
    },
});

NestJS gewährt konstruktionsbedingt viel Kontrolle darüber, wie Komponenten interagieren, aber der Nachteil ist viel mehr Standard und Sie müssen auch die Infrastrukturkonfigurationen selbst verwalten.

Integrierte Funktionen und Erweiterbarkeit

Bei der Entwicklung verteilter Systeme erleichtern die vom Framework bereitgestellten Funktionen häufig die Entwicklung auf die Gefahr hin, zu übermäßiger Komplexität zu führen.

Das herausragende Merkmal von Encore.ts besteht darin, dass es Möglichkeiten zur Automatisierung der Infrastrukturbereitstellung bietet, sowohl in der lokalen Entwicklung als auch in Cloud-Umgebungen. Dazu gehören Datenbanken, Pub/Sub, Cron-Jobs und mehr. Encore.ts bietet außerdem ein lokales Entwicklungs-Dashboard, das automatisch API-Dokumentation, Architekturdiagramme und verteilte Ablaufverfolgung generiert. Es generiert auch die Frontend-Clients, einschließlich der OpenAPI-Spezifikationsunterstützung für REST-APIs, was für Entwickler eine große Zeitersparnis bedeuten kann.

Hier ist ein Beispiel für die Definition einer REST-API in Encore.ts, die auch automatisch die OpenAPI-Dokumentation generiert:

import { Service } from "encore.dev/service";

export default new Service("hello");

Mit Encore.ts sind Dokumentation und Diagramme automatisch und ohne zusätzliche Einrichtung verfügbar, sobald Sie Ihren Service definieren.

NestJS erfreut sich aufgrund seiner Flexibilität großer Beliebtheit. Vom ersten Tag an unterstützt es problemlos REST, GraphQL und WebSocket, aber der Hauptgrund für seine Beliebtheit ist, dass es sich problemlos mit Bibliotheken von Drittanbietern verbinden lässt.

Wenn Sie beispielsweise GraphQL-Unterstützung hinzufügen möchten, ist dies ein einfacher Vorgang.

import { Controller, Get } from '@nestjs/common';

@Controller('hello')
export class HelloWorldController {
  @Get()
  sayHello(): string {
    return 'Hello, World!';
  }
}

NestJS macht es einfach, auf seinen Kernfunktionen aufzubauen, bietet aber nicht das gleiche Maß an automatisierter Infrastruktur und Funktionen wie Encore.ts.

Leistung und Skalierbarkeit

Leistung ist beim Aufbau verteilter Systeme von entscheidender Bedeutung, insbesondere im großen Maßstab.

Encore.ts ist mit seiner Rust-Laufzeitumgebung, die E/A-Vorgänge und Multithreading effizient verarbeitet, auf hohe Leistung ausgelegt. Die Geschwindigkeit und Speichersicherheit von Rust verschaffen Encore.ts einen erheblichen Vorteil gegenüber rein Node.js-basierten Frameworks. Was die Skalierbarkeit betrifft, ist Encore.ts cloudnativ und kann abhängig von Ihrer Bereitstellungsstrategie mithilfe einer serverlosen Architektur oder Kubernetes automatisch skaliert werden.

NestJS hingegen ist im Umgang mit Leistung und Skalierbarkeit traditioneller. Da NestJS rein auf TypeScript und JavaScript basiert, ist es auf die Leistungsoptimierungen angewiesen, die Sie während der Einrichtung anwenden. Die Skalierung einer NestJS-App umfasst normalerweise die manuelle Konfiguration von Kubernetes, Docker oder serverlosen Plattformen wie AWS Lambda.

Während NestJS Flexibilität bei der Skalierung bietet, erfordert die Konfiguration mehr manuellen Aufwand als die integrierte Automatisierung von Encore.ts.

Lassen Sie uns den Leistungsunterschied zwischen encore.ts und Nest.js anhand der Benchmark-Daten im Bild unten verstehen:

Aus den Benchmark-Daten sticht encore.ts mit einer Startzeit von nur 8,3 Millisekunden hervor, wenn es um Leistung geht, während NestJS etwa 143,7 Millisekunden benötigt und damit fast neunmal schneller ist als herkömmliche Frameworks.

Bereitstellungsstrategien

Wie Sie Ihre Anwendung bereitstellen, ist ein wichtiger Aspekt bei jedem Projekt, insbesondere wenn es um Cloud-Umgebungen geht.

Encore.ts bietet einen einfachen Weg zur Bereitstellung über seine Open-Source-Tools oder die Encore Cloud Platform. Mit der Open-Source-Version können Sie Encore Build verwenden, um Ihr Projekt zu erstellen und ein Docker-Image zu erstellen, das dann überall dort bereitgestellt werden kann, wo Docker unterstützt wird:

import { Topic, Subscription } from "encore.dev/pubsub";

// Define the event type for order creation
export interface OrderCreatedEvent {
    orderId: string;
}

// Create a topic for order creation events
export const orders = new Topic<OrderCreatedEvent>("orders", {
    deliveryGuarantee: "at-least-once",
});

// Create a subscription to listen for the order creation event
export const _ = new Subscription(orders, "process-order", {
    handler: async (event: OrderCreatedEvent) => {
        console.log('Order created:', event.orderId);
    },
});

Dadurch wird ein Docker-Image erstellt, das überall bereitgestellt werden kann.

Wenn Sie sich alternativ für die Encore Cloud Platform entscheiden, automatisiert diese die gesamte CI/CD-Pipeline und stellt sie direkt in Ihrer eigenen Cloud auf AWS oder GCP mit serverlosen oder Kubernetes-Optionen bereit.

Im Gegensatz dazu erfordert NestJS eine manuelle Einrichtung für die Bereitstellung. Normalerweise verwenden Entwickler Docker, um NestJS-Anwendungen zu containerisieren und sie bei einem Cloud-Anbieter ihrer Wahl bereitzustellen. Dies gibt Ihnen zwar die Kontrolle über Ihre Bereitstellungsstrategie, erfordert jedoch mehr Konfiguration – selbst für eine einfache Anwendung müssen Sie viele Schritte durchlaufen:

1. Erstellen Sie eine Docker-Datei:

import { Service } from "encore.dev/service";

export default new Service("hello");

1. Erstellen Sie eine docker-compose.yml-Datei:

import { Controller, Get } from '@nestjs/common';

@Controller('hello')
export class HelloWorldController {
  @Get()
  sayHello(): string {
    return 'Hello, World!';
  }
}

1. Erstellen Sie einen GitHub-Aktionsworkflow für NestJS

import { Topic, Subscription } from "encore.dev/pubsub";

// Define the event type for order creation
export interface OrderCreatedEvent {
    orderId: string;
}

// Create a topic for order creation events
export const orders = new Topic<OrderCreatedEvent>("orders", {
    deliveryGuarantee: "at-least-once",
});

// Create a subscription to listen for the order creation event
export const _ = new Subscription(orders, "process-order", {
    handler: async (event: OrderCreatedEvent) => {
        console.log('Order created:', event.orderId);
    },
});

Je größer Ihre Anwendung wird und je mehr Bedarf Sie an mehreren Staging- und Testumgebungen haben, desto aufwändiger wird dieser manuelle Konfigurationsansatz – und der Zeitaufwand für die Wartung nimmt kontinuierlich zu.

Überlegungen zu Anwendungsfällen

Bei der Wahl zwischen Encore.ts und NestJS sollte die Entscheidung auf den spezifischen Anforderungen Ihres Projekts basieren.

Encore.ts eignet sich perfekt für Cloud-First-Anwendungen und große verteilte Systeme, die von integrierter Automatisierung profitieren. Dank der auf Rust basierenden Laufzeit- und Infrastrukturverwaltung ist es ideal für ereignisgesteuerte Architekturen, Microservices und Hochleistungsanwendungen. Die schnell wachsende Community von Encore ist eine zuverlässige Quelle für Support und die Suche nach Möglichkeiten zur Integration von Tools von Drittanbietern.

Andererseits glänzt NestJS, wenn Flexibilität und Anpassung erforderlich sind. Es eignet sich gut für Unternehmensanwendungen, die eine detaillierte Kontrolle aller Aspekte erfordern und bei denen der Zeitaufwand für die manuelle Konfiguration akzeptabel ist. Das relativ umfangreiche Ökosystem und die Community-Unterstützung von NestJS erleichtern das Auffinden von Ressourcen und Tools von Drittanbietern.

Fazit

Die Wahl zwischen Encore.ts und NestJS hängt von den spezifischen Anforderungen Ihres Projekts ab.

Wenn Sie nach einem einfachen, leistungsstarken, cloudnativen Framework mit integrierter Automatisierung suchen, ist Encore.ts eine ausgezeichnete Wahl. Es rationalisiert die Entwicklung verteilter Systeme durch die automatische Verwaltung der Infrastruktur und seine Rust-basierte Leistung ist kaum zu übertreffen.

Wenn Sie jedoch ein sehr flexibles, modulares Framework benötigen, das Ihnen die Kontrolle über jeden einzelnen Aspekt gibt, ist NestJS wahrscheinlich die richtige Wahl. Seine Erweiterbarkeit und sein großes Ökosystem machen es zu einer guten Wahl für maßgeschneiderte Unternehmenslösungen.

Beide Frameworks sind für sich genommen leistungsstark und die beste Wahl hängt davon ab, ob Sie Wert auf Leistung und Einfachheit oder volle Flexibilität und Kontrolle legen.

Nächste Schritte

Wenn Leistung und Einfachheit für Ihr Projekt wichtig sind, ist es möglicherweise eine gute Idee, Encore.ts auszuprobieren. Und es ist alles Open Source, sodass Sie den Code ausprobieren und auf GitHub beitragen können.

Das obige ist der detaillierte Inhalt vonNestJS vs. Encore.ts: Auswahl des richtigen Frameworks für Ihre TypeScript-Microservices. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!