Erste Schritte mit Fastify: Erstellung einer einfachen API

Einleitung

Fastify ist ein Web-Framework für Node.js, das sich auf die Bereitstellung einer hochperformanten und ressourcenschonenden Lösung für den Aufbau von Webanwendungen und APIs konzentriert. Es ist so konzipiert, dass es einfach zu bedienen ist und gleichzeitig leistungsstarke Funktionen bietet, die es ideal für eine Vielzahl von Anwendungsfällen machen. Fastify kann mit beeindruckenden Geschwindigkeits-Benchmarks aufwarten und ist bekannt für seine Fähigkeit, hohe Lasten effizient zu bewältigen.

Vorteile von Fastify:

Performance: Fastify wurde mit Fokus auf Geschwindigkeit entwickelt und ist damit eines der schnellsten Web-Frameworks, die für Node.js verfügbar sind. Sein geringer Overhead und seine effiziente Architektur tragen zu kürzeren Antwortzeiten und einer besseren Gesamtleistung bei.
Schema-basierte Validierung: Fastify bietet integrierte Unterstützung für die schema-basierte Validierung von Request- und Response-Payloads. Dies ermöglicht es Entwicklern, klare Erwartungen für eingehende Daten zu definieren, was zu verbesserter Zuverlässigkeit und Sicherheit führt.
Erweiterbarkeit: Fastify ist hochgradig erweiterbar und ermöglicht es Entwicklern, auf einfache Weise benutzerdefinierte Plugins und Middleware hinzuzufügen, um die Funktionalität ihrer Anwendungen zu erweitern. Dies macht es anpassungsfähig an eine Vielzahl von Projektanforderungen.
Asynchrone Unterstützung: Fastify unterstützt vollständig asynchrone Programmiermuster und eignet sich daher gut für die effiziente Verarbeitung von E/A-gebundenen Operationen. Es nutzt moderne JavaScript-Funktionen wie async/await, um asynchronen Code zu vereinfachen.
Entwicklerfreundlich: Mit seiner intuitiven API und umfassenden Dokumentation zielt Fastify darauf ab, eine entwicklerfreundliche Erfahrung zu bieten. Es bietet eine klare und prägnante Syntax, die es sowohl für Anfänger als auch für erfahrene Entwickler einfach macht, sie zu verstehen und zu verwenden.

Was in diesem Tutorial behandelt wird:

In diesem Tutorial werden wir die Grundlagen der Verwendung von Fastify zum Erstellen einer einfachen API behandeln. Ausgehend von der Einrichtung eines Fastify-Projekts werden wir nach und nach seine wichtigsten Funktionen erkunden, darunter die Routenverarbeitung, die Anforderungsvalidierung, Middleware, Fehlerbehandlung, Tests und Bereitstellung. Am Ende des Tutorials werden Sie ein solides Verständnis dafür haben, wie Sie Fastify verwenden, um robuste und effiziente Webanwendungen zu erstellen.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen installiert haben:

Node.js und npm: Fastify benötigt Node.js und npm, um auf Ihrem System installiert zu sein. Sie können sie von der offiziellen Node.js-Website herunterladen und installieren.
Grundkenntnisse in JavaScript und Node.js: Dieses Tutorial setzt voraus, dass Sie grundlegende Kenntnisse in JavaScript und der Arbeit mit Node.js haben. Vertrautheit mit Konzepten wie Callbacks, Promises und Modulen ist von Vorteil, wenn wir die Funktionen von Fastify erkunden.

Mit diesen Voraussetzungen können Sie sich in die Entwicklung mit Fastify stürzen! Fangen wir an.

Einrichten von Fastify

Installieren von Fastify über npm

Um mit Fastify zu beginnen, müssen Sie es zunächst über npm installieren, den Paketmanager für Node.js. Wenn Sie ein Fan von Yarn oder Bun sind, können Sie auch versuchen, diese zu verwenden. Für diesen Leitfaden verwende ich NPM.

Und falls Sie nicht wissen oder nicht genau verstehen, wie man NPM verwendet, können Sie sich dieses Tutorial ansehen, um sich damit vertraut zu machen.

Erstellen Sie zunächst einen neuen Ordner, z. B. auf Ihrem Desktop oder in Ihrem Arbeitsverzeichnis, in dem Sie das Fastify-Projekt einrichten möchten.

Führen Sie dazu einfach den folgenden Code Schritt für Schritt in Ihrem Terminal aus:

mkdir my-fastify-project
cd my-fastify-project

Nun haben Sie einen Ordner erstellt und sich von Ihrem Terminal aus in diesen Ordner verschoben. Gute Arbeit!

Als Nächstes initialisieren Sie npm für dieses Projekt und installieren das Fastify-Framework.

npm init -y
npm install fastify

An diesem Punkt besteht Ihr Projekt nur aus den Dateien package.json, package-lock.json und node_moudles, die Metadaten über Ihr Projekt und seine Abhängigkeiten enthalten. Wenn wir unsere Fastify-Anwendung weiterentwickeln, werden wir dieser Struktur weitere Dateien und Verzeichnisse hinzufügen.

Erstellen eines einfachen Servers

Einrichten eines einfachen Fastify-Servers

Nachdem wir unser Projekt eingerichtet haben, erstellen wir einen einfachen Fastify-Server. Erstellen Sie im Projektverzeichnis eine neue Datei namens index.js und fügen Sie den folgenden Code hinzu:

// Import the Fastify module
const fastify = require('fastify')();

// Define a route handler for the root URL
fastify.get('/', async (request, reply) => {
  return { hello: 'world' };
});

// Start the server
const start = async () => {
  try {
    await fastify.listen({ port: 3000 });
    console.log('Server is running on http://localhost:3000');
  } catch (error) {
    console.error('Error starting server:', error);
    process.exit(1);
  }
};

start();

Dieser Code richtet einen einfachen Fastify-Server ein, der auf eingehende HTTP-Anforderungen an Port 3000 wartet. Wenn eine Anforderung an die Stamm-URL (/) gestellt wird, antwortet er mit einem JSON-Objekt, das die Nachricht "hello": "world" enthält.

Damit der folgende Code funktioniert, müssen wir ihm sagen, dass er ausgeführt werden soll. Wie können wir das tun? Nun, wir können node index.js in unserem Terminal im Projektstammordner ausführen, und es funktioniert.

Aber das würde bedeuten, dass wir diesen Befehl jedes Mal ausführen müssen, wenn wir eine Datei aktualisieren. Das wollen wir uns nicht antun. Wir sollten in der Lage sein, die Datei zu speichern und automatisch das erneute Erstellen auszulösen. Wie können wir das tun?
Nun, da kommt Nodemon.

Um Nodemon zu installieren, führen Sie einfach den folgenden Code im Terminal aus;
npm install nodemon --save-dev.
Dadurch wird Nodemon installiert, und wir können uns auf unseren Code konzentrieren und ihn nicht manuell bitten, neu zu erstellen.

Aber wir sind noch nicht fertig mit Nodemon. Ich verspreche, dies ist der letzte Code, den wir für Nodemon konfigurieren werden. Was müssen wir tun? Wir müssen ihm sagen, dass er automatisch ausgelöst werden soll, wenn wir eine Datei speichern. Wie machen wir das?

Öffnen Sie Ihre package.json-Datei und ersetzen Sie den Abschnitt script durch den folgenden Code:

 "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

Und da sind wir! Wir sind mit der Nodemon-Konfiguration fertig, versprochen!

Um unseren Server zu starten, müssen wir jetzt npm run dev in unserem Projektstammverzeichnis ausführen. Sobald Sie dies getan haben, navigieren Sie zu Ihrem Browser und geben Sie http://localhost:3000/ ein - Sie sehen unsere Beispielantwort hello world, wie wir sie in unserer index.js-Datei oben definiert haben.

A page showing "Hello World" text from server output.

Hinzufügen von Routen zur Behandlung verschiedener HTTP-Methoden (GET, POST usw.)

Fastify macht es einfach, REST-APIs zu erstellen / Routen für die Behandlung verschiedener HTTP-Methoden wie GET, POST, PUT, DELETE usw. zu definieren. Fügen wir eine Route hinzu, um eine POST-Anforderung zu verarbeiten. Aktualisieren Sie Ihre index.js-Datei mit dem folgenden Code:

// Define a route handler for handling POST requests to '/data'
fastify.post('/data', async (request, reply) => {
  const payload = request.body;
  // Process the incoming data
  // For now, let's just echo back the received data
  return { receivedData: payload };
});

Jetzt kann unser Fastify-Server sowohl GET-Anforderungen an die Stamm-URL (/) als auch POST-Anforderungen an den Endpunkt /data verarbeiten.

Antworten mit JSON-Daten

In beiden von uns definierten Routenhandlern ('/' und '/data') antworten wir mit JSON-Daten, indem wir die integrierten Antwortmethoden von Fastify verwenden. Fastify serialisiert JavaScript-Objekte automatisch in JSON, wodurch es einfach ist, strukturierte Daten als Antworten zu senden.

Mit diesen Ergänzungen ist unser Fastify-Server jetzt in der Lage, grundlegende HTTP-Anforderungen zu verarbeiten und mit JSON-Daten zu antworten.

Aber wie testen wir die POST-Anforderung? Wir können eine POST-Anforderung nicht vom Browser aus testen, oder?
Um uns zu helfen, verwenden wir Apidog.

💡

Apidog ist ein API-Verwaltungstool, mit dem wir Design, Debug, Test, Dokument, Mock, und Build APIs Faster & Together.

button

Sie können sich für ein kostenloses Konto anmelden, die Weboberfläche ausprobieren oder die Desktop-App herunterladen, um Ihre neu erstellten APIs zu testen.

Um Ihnen zu helfen, die Verwendung von Apidog zu verstehen, finden Sie hier eine gut geschriebene Anleitung. Um das lange Gerede und Lesen zu überspringen, können Sie diesen Abschnitt durchsuchen - dies ist der wichtigste für uns jetzt.

Wenn Sie der obigen Anleitung gefolgt sind, sollten Sie mit Apidog in großem Umfang vertraut sein.

Tippen Sie auf die Anforderung von der Projektseite, und Sie können die API testen, die wir vom Fastify-Server erstellt haben.

Wie Sie im obigen Screenshot sehen können, müssen Sie die HTTP-Methode auf POST festlegen, die richtige URL eingeben (stellen Sie sicher, dass Ihr Server noch läuft) und Ihre Body-Payload eingeben.

Wenn Sie die obigen Schritte korrekt ausführen, erhalten Sie einen 200-Antwortcode, und Sie können die Antwort sehen.

Wenn alles gut für Sie funktioniert, sollten Sie die gleiche Antwort erhalten wie ich.

Middleware und Plugins

Einführung in Middleware in Fastify

Middleware-Funktionen in Fastify sind Funktionen, die Zugriff auf die Request- und Response-Objekte haben und Aufgaben wie Protokollierung, Authentifizierung, Datenparsing usw. ausführen können, bevor sie die Kontrolle an die nächste Middleware-Funktion oder den Routenhandler weitergeben. Middleware-Funktionen werden in der Reihenfolge ausgeführt, in der sie der Anwendungspipeline hinzugefügt werden.

Erstellen benutzerdefinierter Middleware-Funktionen

Sie können benutzerdefinierte Middleware-Funktionen in Fastify erstellen, indem Sie Funktionen definieren, die die Parameter request, reply und next akzeptieren. Hier ist ein Beispiel für eine benutzerdefinierte Protokollierungs-Middleware:

// Custom logging middleware
const loggerMiddleware = async (request, reply, next) => {
  console.log(`[${new Date().toISOString()}] ${request.method} ${request.url}`);
  next();
};

// Register middleware with Fastify
fastify.use(loggerMiddleware);

In diesem Beispiel protokolliert die Funktion loggerMiddleware den Zeitstempel, die HTTP-Methode und die URL jeder eingehenden Anforderung. Anschließend ruft sie die Funktion next() auf, um die Kontrolle an die nächste Middleware-Funktion oder den Routenhandler weiterzugeben.

So funktioniert Middleware vollständig in Node.js und seinen anderen Frameworks wie Express.js.

Installieren und Verwenden von Fastify-Plugins

Fastify bietet ein reichhaltiges Ökosystem von Plugins, die seine Funktionalität für verschiedene Zwecke wie Authentifizierung, Datenbankintegration, Validierung usw. erweitern. Sie können Fastify-Plugins über npm installieren und verwenden. So installieren Sie ein Plugin und registrieren es bei Fastify:

npm install fastify-auth fastify-cors

// Import required plugins
const fastifyAuth = require('fastify-auth');
const fastifyCors = require('fastify-cors');

// Register plugins with Fastify
fastify.register(fastifyAuth);
fastify.register(fastifyCors);

In diesem Beispiel haben wir zwei Plugins installiert und registriert: fastify-auth für die Authentifizierung und fastify-cors für die Unterstützung von Cross-Origin Resource Sharing (CORS).

Aber warten Sie. Wir werden das nicht testen. Das sind nur Beispiele, die zeigen, wie man Middleware und Plugins in Fastify installiert und ausführt.

Hier ist ein Artikel, um mehr über Middleware und Plugins zu erfahren. Sie können Ihre eigenen Recherchen und Erkenntnisse durchführen. Verwechseln Sie es einfach nicht. Middleware in Node.js und Fastify ist ein weites Thema.

Fehlerbehandlung

Behandlung von Fehlern in Fastify-Routen

In Fastify können Sie Fehler in Routenhandlern behandeln, indem Sie Fehler auslösen oder sie von asynchronen Funktionen zurückgeben. Fastify fängt diese Fehler automatisch ab und sendet eine entsprechende Fehlerantwort an den Client. Hier ist ein Beispiel:

// Route handler with error handling
fastify.get('/error', async (request, reply) => {
  // Simulate an error
  throw new Error('Oops! Something went wrong.');
});

In diesem Beispiel, sagen wir, ein Benutzer navigiert zu einem /error, das nicht existiert oder etwas anderes, können wir einen Fehler auslösen und den Benutzer wissen lassen, was passiert.

Wenn Sie neugierig sind (sollten Sie sein), hier ist ein Artikel, um mehr über Fehler zu erfahren.

Durch die Nutzung von Middleware, Plugins und Fehlerbehandlungsfunktionen in Fastify können Sie die Funktionalität und Zuverlässigkeit Ihrer Webanwendungen und APIs verbessern. Diese Funktionen ermöglichen es Ihnen, Ihren Code zu modularisieren, wiederverwendbare Komponenten hinzuzufügen und Fehler auf elegante Weise zu behandeln, was zu wartungsfreundlicheren und robusteren Anwendungen führt.

Schlussfolgerung

In diesem Tutorial haben wir eine umfassende Einführung in Fastify behandelt, ein schnelles und ressourcenschonendes Web-Framework für Node.js. Hier ist eine Zusammenfassung der wichtigsten Themen, die wir behandelt haben:

Einführung in Fastify: Wir begannen mit der Erörterung von Fastify und seinen Vorteilen gegenüber anderen Node.js-Frameworks, einschließlich seiner Leistungsvorteile, der benutzerfreundlichen API und des reichhaltigen Ökosystems von Plugins.
Einrichten von Fastify: Wir haben den Prozess der Installation von Fastify mit npm, der Initialisierung eines neuen Fastify-Projekts und der Erkundung der Projektstruktur durchlaufen. Dies bildete die Grundlage für die Erstellung von Fastify-Anwendungen.
Erstellen eines einfachen Servers: Wir haben gezeigt, wie man einen einfachen Fastify-Server einrichtet, Routen hinzufügt, um verschiedene HTTP-Methoden zu verarbeiten, und mit JSON-Daten antwortet. Dies veranschaulichte die Einfachheit und Flexibilität der Definition von Routen und der Verarbeitung von Anforderungen in Fastify.
Middleware und Plugins: Wir haben das Konzept der Middleware in Fastify eingeführt und gezeigt, wie man benutzerdefinierte Middleware-Funktionen erstellt. Darüber hinaus haben wir erörtert, wie Sie die Funktionalität von Fastify mit Plugins erweitern, sie installieren und verwenden, um Funktionen wie Authentifizierung und CORS-Unterstützung hinzuzufügen.
Fehlerbehandlung: Wir haben die Fehlerbehandlung in Fastify behandelt, einschließlich der Behandlung von Fehlern in Routen, der Verwendung der integrierten Fehlerbehandlungsfunktionen von Fastify und der Implementierung benutzerdefinierter Fehlerbehandlungslogik, um Ausnahmen zu verwalten und aussagekräftige Fehlerantworten an Clients bereitzustellen.

Durch dieses Tutorial haben Sie das Wissen erworben, um mit der Erstellung von Webanwendungen und APIs mit Fastify zu beginnen. Sie haben die Kernfunktionen von Fastify kennengelernt, wie Sie Anforderungen und Antworten verarbeiten, das Framework mit Plugins erweitern und Fehler effektiv verwalten. Mit diesen Fähigkeiten sind Sie bestens gerüstet, um erweiterte Funktionen von Fastify zu erkunden und effiziente, skalierbare Webanwendungen zu erstellen.

Denken Sie bei der weiteren Arbeit mit Fastify daran, die umfangreiche Dokumentation und das Plugin-Ökosystem zu erkunden, das verfügbar ist. Die Fastify-Community ist aktiv und unterstützend und bietet eine Fülle von Ressourcen, die Ihnen helfen, Ihre Fähigkeiten zu verbessern und robuste Anwendungen zu erstellen.

Vielen Dank, dass Sie diesem Tutorial zu Fastify gefolgt sind. Viel Spaß beim Codieren!