Erfahren Sie, wie Sie Serverless mit Node.js ausführen können

Blog

Erfahren Sie, wie Sie Serverless mit Node.js ausführen können

Erfahren Sie, wie Sie Serverless mit Node.js ausführen können

Einführung

Die meisten Webanwendungen laufen auf Servern mit hohem Wartungsaufwand. Heutzutage verfügen Software-Engineering-Teams über dedizierte DevOps/Infra-Ingenieure, die bei der Verwaltung, Bereitstellung und Wartung dieser Server helfen. Aufgrund der damit verbundenen Herausforderungen wurde die Notwendigkeit, alternative Lösungen voranzutreiben, notwendig. Serverlose Anwendungen glänzen in dieser Hinsicht.

Als Framework hilft es beim Erstellen von sowohl Microservice- als auch Full-Stack-basierten Anwendungen und befreit Unternehmen jeder Größenordnung vom Bereitstellungsprozess für umfangreiche Server-Setup, Wartung und Konfiguration.

Wie funktioniert das Bezahlen für die genauen Ressourcen, die Sie verbrauchen? Das Schöne an Serverless als Framework ist, dass Sie nur den gleichen Betrag für die Ressourcen bezahlen müssen, die zum Betrieb Ihrer gesamten Infrastruktur erforderlich sind.

Serverloser Code sind zustandslose Funktionen, die durch das Auftreten von Ereignissen ausgelöst oder ausgeführt werden – beispielsweise Netzwerkereignisse (HTTP-Anforderungs-/Antwortzyklus). Bei serverlosen Anwendungen müssen Funktionskontexte, die an bestimmte Ereignisse gebunden sind, ausgeführt werden, bevor diese Ereignisse abgeschlossen sind.

Die Idee dabei ist, dass der Zustand nicht über mehrere oder unterschiedliche Funktionsaufrufe oder Kontexte hinweg beibehalten wird. Darüber hinaus wird jedes andere neue Ereignis, das durch einen Funktionsaufruf ausgelöst wird, in einer neuen Containerinstanz behandelt, automatisch verschmäht.

Keine Sorge, wir werden dies später verstehen, wenn wir unseren Antrag ausarbeiten.

Vorteile

Für serverlose Anwendungen ein Stück Code – normalerweise eine Funktion wie Lambda , zum Beispiel – wird basierend auf der Art der ausgelösten Ereignisse ausgeführt. Wenn dies geschieht, werden Ressourcen im laufenden Betrieb zugewiesen, um diese Ereignisse zu bedienen.

Die Ressourcenzuweisung bezieht sich in diesem Fall hauptsächlich auf die Anzahl der eingehenden oder gleichzeitigen Ereignisse oder Anforderungen. Dies wird ausschließlich von Cloud-Anbietern (AWS, GCP, Azure etc.), die diese Dienste anbieten, bestimmt und anschließend abgewickelt/bereitgestellt.

Zu den Vorteilen serverloser Anwendungen gehören:

  • Serverlose Anwendungen werden bei Bedarf basierend auf der Anzahl der Ressourcen skaliert, die für die Verarbeitung von Anfragen erforderlich sind
  • Gleichzeitige Anfragen werden in neuen Containerinstanzen verschmäht
  • Sicherheitsupdates oder Patches werden für uns abgewickelt
  • Jedes andere technische Detail wird von den jeweiligen Cloud-Anbietern übernommen, damit wir uns als Ingenieure mehr auf die Wartung der Kernanwendungen und die Implementierung von Funktionen konzentrieren können
  • Schnellere Ausführung des Bereitstellungszyklus über einen einzigen Befehl, |_+_|
  • Serverless bietet eine Abstraktion für die Cloud-Infrastruktur
  • Am wichtigsten ist, dass Sie genau die verbrauchten Ressourcen bezahlen, da die Serververwaltung in unserem Auftrag erfolgt

Aufgrund der zustandslosen Natur serverloser Anwendungen können Kaltstarts auftreten, die zu Zeitüberschreitungen führen. Dies liegt daran, dass Funktionen in isolierten Containern (durch Ereignisse verworfen oder ausgelöst) mit unterschiedlichen oder unterschiedlichen Kontexten oder Umgebungen ausgeführt werden. Aus diesem Grund können Anwendungen anfänglich geringe Reaktionszeiten, Durchsatz und Latenz aufweisen.

Kaltstarts sind analog zum Starten eines Fahrzeugs nach längerem Stillstand auf einer Stelle. Probleme mit Kaltstarts hängen mit Verzögerungen durch das Netzwerk zusammen, das verwendet wird, um Anfragen zu bedienen; der Cloud-Dienstanbieter; die Größe der Funktionspakete, die zum Ausführen oder Ausführen eines Codes erforderlich sind (auch schlecht optimierter Code); und so weiter.

Um diese Probleme zu lösen, gibt es Möglichkeiten, unsere Funktionen warm zu halten. Beispielsweise können wir Ereignisaufrufe zwischenspeichern, normalerweise indem wir unsere Containerinstanz für einige Zeit laufen lassen. Darüber hinaus können wir Open-Source-Bibliotheken wie Serverloses Webpack um solche Herausforderungen zu meistern. webpack hilft dabei, unsere Funktionen zu bündeln und zu optimieren und sie leichtgewichtig zu machen.

In diesem Tutorial werden wir uns mit dem Erstellen einer serverlosen, auf Microservices basierenden Anwendung befassen. Bevor wir beginnen, werfen wir einen Blick auf die Anforderungen oder Tools, die wir auf unseren Maschinen installieren müssen.

Voraussetzungen

Um diesem Tutorial leicht zu folgen, sollten wir:

  • Lassen Sie Node und npm auf unseren Maschinen installieren
  • Grundkenntnisse im Umgang mit der Kommandozeile haben

Um mit der serverlosen Entwicklung zu beginnen, müssen wir die CLI installieren, damit wir serverlos-spezifische Befehle ausführen können. Um es zu installieren, können wir Folgendes ausführen:

sls deploy

Weiter oben in diesem Tutorial haben wir erklärt, wie serverloser Code als zustandslose Funktionen ausgeführt wird. Schauen Sie sich das folgende Beispiel an:

$ npm install serverless -g

Sehen wir uns an, wie die obige serverlose Funktion ausgeführt wird. Die |_+_| const ist der Name unserer serverlosen Funktion.

Die |_+_| object, das eines unserer Funktionsargumente ist, stellt die Informationen über die Art des Ereignisses dar, das unsere Funktion auslösen und veranlassen würde, einen Teil unseres Codes auszuführen.

Die |_+_| -Objekt enthält Informationen über die Umgebung, in der unsere Funktion ausgeführt werden soll (beachten Sie, dass dies normalerweise von Cloud-Anbietern in unserem Auftrag durchgeführt wird).

Schließlich die |_+_| -Funktion sorgt dafür, dass eine Antwort oder ein Fehlerobjekt zurückgegeben wird, normalerweise basierend auf der Anforderung von Benutzerereignissen.

Beachten Sie, dass es in diesem Tutorial andere wichtige Verfahren und Einrichtungsprozesse gibt, die wir nicht behandeln werden, einfach weil sie nicht unser Hauptaugenmerk sind. Es ist jedoch sehr wichtig, dass wir uns ihrer bewusst sind, wenn wir Bereitstellungen für unsere serverlosen Anwendungen handhaben. Sie beinhalten:

  • Erstellen eines AWS-Kontos – um ein kostenloses Konto zu erstellen, können Sie sich dies ansehen Verknüpfung
  • Identitäts- und Zugriffsverwaltung (IAM) für Benutzerrollen/Richtlinien einrichten
  • Konfigurieren der AWS CLI
  • Konfigurieren anderer AWS-Services, die wir möglicherweise benötigen, wie Datenbanken usw.

Wie wir oben sehen können, beziehen wir uns ausdrücklich auf AWS als unseren Cloud-Dienstleister, was in der Folge bedeutet, dass wir diese nutzen werden AWS Lambda-Funktionen und der API-Gateway um unsere Backend-API zu erstellen.

Beachten Sie auch, dass wir beides ebenfalls verwenden könnten Azurblau oder GCP für unseren obigen Anwendungsfall.

Erstellen einer auf Microservices basierenden serverlosen Anwendung

Beginnen wir, wie bereits erwähnt, mit der Einrichtung für die lokale Entwicklung. Wenn wir die serverlose CLI noch nicht global installiert haben, können wir dies jetzt tun:

const handlerFunction = (event, context, callback) => { // handle business logic code here based on the kind of request // handle callback here callback(error, result) } module.exports = handlerFunction;

Serverless als Framework hilft uns als Ingenieure bei der Handhabung der harten Teile. Alles, was wir tun müssen, ist gut strukturierten Code als zustandslose Funktionen in jeder Sprache zu schreiben, die eine serverlose Implementierung unterstützt.

wie kaufe ich bei kucoin

Nun können wir ein neues Verzeichnis erstellen und es |_+_| nennen:

handleFunction

Wir können auch andere Dienste der jeweiligen Cloud-Anbieter einrichten, wie Datenbanken, Speichermechanismen und andere erforderliche Konfigurationen. In diesem Tutorial verwenden wir MongoDB, da wir damit wahrscheinlich bereits vertraut sind.

Darüber hinaus würden wir unsere API mithilfe der serverlos-http Paket. Mit diesem Paket kann unsere API einer Express-App ähnlich sehen, die wir wahrscheinlich auch gewohnt sind.

Fahren wir fort und lassen Sie uns eine serverlose Boilerplate-Anwendung booten. Wir können dies tun, indem wir den folgenden einfachen Befehl auf unserem Terminal ausführen:

event

Wir erhalten die folgende Ausgabe mit den unten gezeigten Vorlagendateien:

Ausgabevorlagendateien
Abbildung 1: Ausgabe nach Ausführung des serverless create –template-Befehls.

Ordnerhierarchie
Abbildung 2: Ordnerhierarchie nach dem Ausführen des obigen Befehls.

Schauen Sie sich die vom Starter generierten Dateien an, die |_+_| -Datei wird verwendet, um unsere gesamte Anwendung zu konfigurieren – die Art von Diensten, die wir hinzufügen möchten, und wie der Pfad zu unseren Routen und Controllern für unsere Anwendung konfiguriert wird. Die |_+_| Datei enthält die tatsächlichen Funktionen, die unserem Cloud-Anbieter bereitgestellt werden, um unsere Codelogik auszuführen.

Spitze: Wir können die |_+_| . ausführen Befehl, um eine Liste der verfügbaren Befehle mit ihren jeweiligen Beschreibungen in der Befehlszeile anzuzeigen.

Beginnen wir mit der Ausarbeitung unserer Anwendung. Führen Sie den |_+_| . aus Befehl zum Generieren eines |_+_| Datei, dann fangen wir an, andere Abhängigkeiten hinzuzufügen.

Wir beginnen mit der Installation der serverlos-offline Plugin. Dieses Paket spiegelt die Umgebung des API-Gateways lokal und hilft uns, unsere Anwendung schnell zu testen, während wir daran arbeiten. Wir sollten auch weitermachen und das |_+_| . installieren Plugin, mit dem wir unsere Umgebungsvariable einrichten.

Um sie als Dev-Abhängigkeiten zu installieren, können wir Folgendes ausführen:

context

Nachdem die Installation abgeschlossen ist, können wir sie zu unserem |_+_| . hinzufügen Datei.

callback

Lassen Sie uns nun die anderen Pakete installieren, die wir für unsere App benötigen. Wir werden Body-Parser, Mungo, Express, serverless-http und uuid installieren. Wir können dies tun, indem wir Folgendes ausführen:

$ npm i serverless -g

Nach dem Installationsprozess wird unser |_+_| Datei sollte so aussehen.

serveless-example

Lassen Sie uns nun alle Ordner und Dateien erstellen, die wir benötigen. Für eine Microservice-basierte Anwendung können wir |_+_|, |_+_| und |_+_| . erstellen Verzeichnisse. Danach können wir die entsprechenden Dateien in diesen Verzeichnissen erstellen. Beachten Sie, dass wir eine Produkt-API erstellen werden, um zu zeigen, wie eine serverlose Microservice-basierte Anwendung in Node.js erstellt wird.

Um diese Ordner zu erstellen, können wir den folgenden Befehl ausführen:

$ mkdir serverless-example $ cd serverless-example

Danach können wir durch die Verzeichnisse navigieren und die entsprechenden Dateien mit dem Namen |_+_| erstellen. Danach können wir unsere |_+_| . erstellen Datei zum Speichern unserer Umgebungsvariablen. Schließlich können wir die Datenbankkonfigurationsdatei erstellen, die unsere Datenbankverbindung zu einer lokalen Mongo-Instanz enthält, die auf unserem Computer ausgeführt wird. In diesem Tutorial verwenden wir Mungo als unser ORM, um eine Verbindung zu MongoDB herzustellen.

So sollte unsere Ordnerstruktur aussehen, wenn wir fertig sind:

Aktuelle Ordnerstruktur
Abbildung 3: Unsere aktuelle Ordnerstruktur.
Jetzt können wir fortfahren und anfangen, Code zu schreiben. Im Inneren des |_+_| Datei zeigen wir, wie wir uns lokal mit unserer Datenbankinstanz verbinden.

praktisches Deep Learning für Programmierer
serverless create --template aws-nodejs

Wie bereits erwähnt, verwenden wir Mungo, um verbinde dich mit unserer MongoDB örtlich. Außerdem erhalten wir Zugriff auf die MongoDB-Verbindungszeichenfolge mithilfe der |_+_| Paket. Um einen Blick auf das Format unserer |_+_| zu werfen, können wir die |_+_| Datei.

Danach können wir fortfahren und unser Produktschema innerhalb des |_+_| . einrichten Verzeichnis. Werfen wir einen Blick auf die |_+_| Datei:

serverless.yml

Danach können wir fortfahren und die |_+_| . erstellen Datei im |_+_| Verzeichnis. Die Logik hier wird enthalten, wie unsere |_+_| spricht mit der Datenbank – im Grunde wie sie CRUD-Operationen handhabt. Schauen wir uns den Inhalt der Datei genauer an:

handler.js

In der obigen Datei haben wir alle Interaktionen mit der Datenbank behandelt. Wir nannten |_+_|, |_+_| und |_+_| MongoDB-Methoden, um damit zu interagieren.

Und schließlich kommen wir zum wichtigsten Teil: dem |_+_| Datei, die die Kernlogik unserer App verarbeitet. Es behandelt im Wesentlichen, wie unsere Funktionen aufgerufen werden. Hier sind die Inhalte der |_+_| Datei:

serverless help

Wir importieren alle notwendigen Abhängigkeiten wie die |_+_| Paket, mit dem wir unsere serverlose Anwendung wie eine normale Express-Anwendung einrichten können. Natürlich haben wir auch unser Express-Paket importiert und eine Express-App gestartet.

Danach importieren wir unsere Datenbankverbindung und unsere |_+_| Datei. Diese Datei verarbeitet das Erstellen eines neuen Produkts, das Abrufen aller Produkte aus der Datenbank und das Abrufen eines Produkts anhand seiner |_+_|. In der letzten Zeile sehen wir, wie wir unsere Express-App mit dem Serverless-http-Paket umhüllen.

Endlich unser |_+_| Datei sollte wie folgt aussehen, nachdem sie fertig sind:

npm init

Wir haben unsere App und die erforderlichen Dienste oder Plugins konfiguriert, beachten Sie jedoch, dass es bei größeren Anwendungen möglicherweise andere zusätzliche Dienste gibt, die wir möglicherweise hinzufügen müssen. Blick auf |_+_| config, können wir sehen, wie wir den Verweis auf unsere Controller-Datei erhalten und auch die Routing-Pfade richtig eingestellt haben.

Nachdem wir mit der gesamten Einrichtung fertig sind, starten wir unsere App und testen unsere APIs. Dazu können wir |_+_| . ausführen in unserem Terminal. Wenn wir dies tun, erhalten wir die folgende Ausgabe:

npm start Ausgabe
Zweite Hälfte von npm start Output
Abbildung 4: Anzeige der Ausgabe, wenn wir den Befehl npm start ausführen.

Hier sehen wir, dass alle unsere Routen und Umgebungsvariablen für uns auf unserem Terminal angezeigt werden. Jetzt können wir unsere API testen. In diesem Tutorial verwenden wir POSTMAN zum Testen. Lassen Sie uns ein neues Produkt erstellen.

Erstellen eines neuen Produkts mit POSTMAN
Abbildung 5: Zeigt, wie Sie mit POSTMAN ein neues Produkt erstellen.

Nebenbei können wir weitere Produkte erstellen und auch die anderen Endpunkte ausprobieren. Das Code-Repository für das obige Tutorial finden Sie hier auf GitHub .

Abschluss

Serverlose Anwendungen sind gekommen, um zu bleiben. Alles, was wir tun müssen, ist, unsere Funktionen mit einem einzigen Befehl zu schreiben und bereitzustellen, und wir sind live. Obwohl es einige andere Vorkonfigurationsoptionen gibt, die wir in diesem Tutorial nicht behandelt haben, konnten wir erfolgreich eine minimale, skalierbare Microservice-basierte Anwendung erstellen, die serverlose Technologien nutzt.

Es gibt zwar andere Möglichkeiten, serverlose Anwendungen zu erstellen, aber das Schöne an unserem Ansatz hier ist, dass wir eine alte Express-Anwendung schnell in eine serverlose Anwendung umwandeln können, da wir mit der aktuellen Struktur unseres Projekts ziemlich vertraut sind.

Probieren Sie dieses Setup aus und lassen Sie es mich wissen, wenn Sie Fragen oder Feedback im Kommentarbereich unten haben. Dankeschön!

#Serverlos #nodejs #microservice