Ackermann Node.js – Rezepte und Lösungen

1. Auflage 2019
ISBN: 978-3-8362-6455-6
Verlag: Rheinwerk
Format: EPUB
Kopierschutz: 0 - No protection

E-Book, Deutsch, 651 Seiten

Reihe: Rheinwerk Computing

Ganz egal, wie neu oder vertraut Ihnen Node.js ist, Sie kennen sicherlich die Situation, manchmal inmitten eines Projekts vor scheinbar unlösbaren Problemen zu stehen: mal funktioniert der Datenbankzugriff nicht, mal laufen die Anfragen an die Webservices einfach ins Leere. Und dabei müssen Sie Ihre Webanwendung so schnell wie möglich fertigstellen. Sie haben also weder Zeit noch Lust, sich durch ewig lange Dokumentationen oder ein umfangreiches Handbuch zu wühlen, bis Sie den entscheidenden Hinweis entdeckt haben. Abhilfe schafft hier die vorliegende Rezeptsammlung! Der Autor stellt über 100 verschiedene Problemfelder aus dem Praxisalltag vor und zeigt Ihnen konkrete Lösungswege für diese auf.

Aus dem Inhalt:

• Projektstruktur und Konfiguration: Node.js installieren, verwenden und debuggen
• Events, I/O und Streams
• Mit Dateisystemen und Dateiformaten arbeiten
• Auf Datenbanken zugreifen
• Persistzenz, Messaging und Enterprise Integration: ActiveMQ, Apache Kafka, HiveMQ, RabbitMQ, ZeroMQ
• Webanwendungen, Sockets und Email-Kommunikation
• Webservices und Microservices: GET-, POST-, PUT- und DELETE-Anfragen
• Web APIs
• Entwicklungsprozesse optimieren
• Performance und Sicherheit verbessern
• Deployment, Publishing und Betrieb

Philip Ackermann ist CTO der Cedalo AG und Autor mehrerer Fachbücher und Fachartikel über Java und JavaScript. Seine Schwerpunkte liegen in der Konzeption und Entwicklung von Node.js- und JEE-Projekten in den Bereichen Industrie 4.0 und Internet of Things.

Autoren/Hrsg.

Ackermann, Philip

Inhaltsverzeichnis

Materialien zum Buch ... 19  Geleitwort des Fachgutachters ... 21  Vorwort ... 23  1.  Initialisierung und Setup ... 27  1.1 ... Rezept 1: Node.js installieren ... 27  1.2 ... Rezept 2: Mehrere Node.js-Versionen parallel betreiben ... 35  1.3 ... Rezept 3: Ein neues Node.js-Package manuell erstellen ... 41  1.4 ... Rezept 4: Ein neues Node.js-Package automatisch erstellen ... 45  1.5 ... Rezept 5: Den Kommandozeilenwizard von npm anpassen ... 49  1.6 ... Rezept 6: Abhängigkeiten richtig installieren und verwalten ... 54  1.7 ... Rezept 7: Packages in Mono-Repositorys organisieren ... 59  1.8 ... Zusammenfassung ... 66  2.  Package Management ... 67  2.1 ... Rezept 8: Semantische Versionierung richtig einsetzen ... 67  2.2 ... Rezept 9: Den alternativen Package Manager »Yarn« verwenden ... 73  2.3 ... Rezept 10: Den alternativen Package Manager »pnpm« verwenden ... 78  2.4 ... Rezept 11: Lokale Abhängigkeiten für die Entwicklung verlinken ... 84  2.5 ... Rezept 12: Informationen zu verwendeten Abhängigkeiten abrufen ... 88  2.6 ... Rezept 13: Lizenzen der verwendeten Abhängigkeiten ermitteln ... 94  2.7 ... Rezept 14: Nicht verwendete oder fehlende Abhängigkeiten ermitteln ... 97  2.8 ... Rezept 15: Veraltete Abhängigkeiten ermitteln ... 99  2.9 ... Zusammenfassung ... 101  3.  Logging und Debugging ... 103  3.1 ... Rezept 16: Logging für Node.js-Packages einrichten ... 103  3.2 ... Rezept 17: Logging für Node.js-Applikationen einrichten ... 109  3.3 ... Rezept 18: Logging über Adapter-Packages einrichten ... 114  3.4 ... Rezept 19: Applikationen mit Chrome Developer Tools debuggen ... 118  3.5 ... Rezept 20: Applikationen mit Visual Studio Code debuggen ... 122  3.6 ... Rezept 21: Applikationen über die Kommandozeile debuggen ... 125  3.7 ... Zusammenfassung ... 129  4.  Konfiguration und Internationalisierung ... 131  4.1 ... Rezept 22: Applikationen konfigurieren über Umgebungsvariablen ... 132  4.2 ... Rezept 23: Applikationen konfigurieren über Konfigurationsdateien ... 137  4.3 ... Rezept 24: Applikationen konfigurieren über Kommandozeilenargumente ... 141  4.4 ... Rezept 25: Applikationen optimal konfigurierbar machen ... 147  4.5 ... Rezept 26: Mehrsprachige Applikationen erstellen ... 151  4.6 ... Rezept 27: Sprachdateien verwenden ... 161  4.7 ... Zusammenfassung ... 163  5.  Dateisystem, Streams und Events ... 165  5.1 ... Rezept 28: Mit Dateien und Verzeichnissen arbeiten ... 165  5.2 ... Rezept 29: Dateien und Verzeichnisse überwachen ... 173  5.3 ... Rezept 30: Daten mit Streams lesen ... 178  5.4 ... Rezept 31: Daten mit Streams schreiben ... 182  5.5 ... Rezept 32: Mehrere Streams über Piping kombinieren ... 184  5.6 ... Rezept 33: Eigene Streams implementieren ... 190  5.7 ... Rezept 34: Events versenden und empfangen ... 199  5.8 ... Rezept 35: Erweiterte Features beim Event-Handling verwenden ... 206  5.9 ... Zusammenfassung ... 209  6.  Datenformate ... 211  6.1 ... Rezept 36: XML verarbeiten ... 211  6.2 ... Rezept 37: XML generieren ... 218  6.3 ... Rezept 38: RSS und Atom generieren und verarbeiten ... 224  6.4 ... Rezept 39: CSV verarbeiten ... 229  6.5 ... Rezept 40: HTML mit Template-Engines generieren ... 233  6.6 ... Rezept 41: HTML mit der DOM-API generieren ... 239  6.7 ... Rezept 42: YAML verarbeiten und generieren ... 244  6.8 ... Rezept 43: TOML verarbeiten ... 253  6.9 ... Rezept 44: INI verarbeiten und generieren ... 259  6.10 ... Rezept 45: JSON validieren ... 264  6.11 ... Rezept 46: JavaScript verarbeiten und generieren ... 270  6.12 ... Rezept 47: CSS verarbeiten und generieren ... 277  6.13 ... Zusammenfassung ... 284  7.  Persistenz ... 285  7.1 ... Rezept 48: Auf eine MySQL-Datenbank zugreifen ... 285  7.2 ... Rezept 49: Auf eine PostgreSQL-Datenbank zugreifen ... 292  7.3 ... Rezept 50: Objektrelationale Mappings definieren ... 299  7.4 ... Rezept 51: Auf eine MongoDB-Datenbank zugreifen ... 307  7.5 ... Rezept 52: Auf eine Redis-Datenbank zugreifen ... 316  7.6 ... Rezept 53: Auf eine Cassandra-Datenbank zugreifen ... 326  7.7 ... Zusammenfassung ... 332  8.  Webanwendungen und Webservices ... 333  8.1 ... Rezept 54: Einen HTTP-Server implementieren ... 333  8.2 ... Rezept 55: Eine Webanwendung über HTTPS betreiben ... 337  8.3 ... Rezept 56: Eine REST-API implementieren ... 341  8.4 ... Rezept 57: Einen HTTP-Client implementieren ... 355  8.5 ... Rezept 58: Authentifizierung implementieren ... 359  8.6 ... Rezept 59: Authentifizierung mit »Passport.js« implementieren ... 366  8.7 ... Rezept 60: Eine GraphQL-API implementieren ... 371  8.8 ... Rezept 61: Anfragen an eine GraphQL-API stellen ... 379  8.9 ... Rezept 62: Eine GraphQL-API über HTTP betreiben ... 383  8.10 ... Zusammenfassung ... 390  9.  Sockets und Messaging ... 391  9.1 ... Rezept 63: Einen TCP-Server erstellen ... 392  9.2 ... Rezept 64: Einen TCP-Client erstellen ... 396  9.3 ... Rezept 65: Einen WebSocket-Server erstellen ... 400  9.4 ... Rezept 66: Einen WebSocket-Client erstellen ... 405  9.5 ... Rezept 67: Nachrichtenformate für WebSocket-Kommunikation definieren ... 407  9.6 ... Rezept 68: Subprotokolle für WebSocket-Kommunikation definieren ... 412  9.7 ... Rezept 69: Server-Sent Events generieren ... 415  9.8 ... Rezept 70: Über AMQP auf RabbitMQ zugreifen ... 419  9.9 ... Rezept 71: Einen MQTT-Broker erstellen ... 431  9.10 ... Rezept 72: Über MQTT auf einen MQTT-Broker zugreifen ... 436  9.11 ... Rezept 73: E-Mails versenden ... 443  9.12 ... Zusammenfassung ... 446

10.  Testing und TypeScript ... 449  10.1 ... Rezept 74: Unit-Tests schreiben ... 449  10.2 ... Rezept 75: Unit-Tests automatisch neu ausführen ... 458  10.3 ... Rezept 76: Die Testabdeckung ermitteln ... 459  10.4 ... Rezept 77: Unit-Tests für REST-APIs implementieren ... 463  10.5 ... Rezept 78: Eine Node.js-Applikation in TypeScript implementieren ... 468  10.6 ... Rezept 79: TypeScript-basierte Applikationen automatisch neu kompilieren ... 475  10.7 ... Zusammenfassung ... 479

11.  Skalierung, Performance und Sicherheit ... 481  11.1 ... Rezept 80: Externe Anwendungen als Unterprozess ausführen ... 482  11.2 ... Rezept 81: Externe Anwendungen als Stream verarbeiten ... 486  11.3 ... Rezept 82: Node.js-Applikationen als Unterprozess aufrufen ... 489  11.4 ... Rezept 83: Eine Node.js-Anwendung clustern ... 495  11.5 ... Rezept 84: Unterprozesse über einen Prozessmanager verwalten ... 499  11.6 ... Rezept 85: Systeminformationen, CPU-Auslastung und Speicherverbrauch ermitteln ... 504  11.7 ... Rezept 86: Speicherprobleme identifizieren ... 511  11.8 ... Rezept 87: CPU-Probleme identifizieren ... 520  11.9 ... Rezept 88: Schwachstellen von verwendeten Abhängigkeiten erkennen ... 528  11.10 ... Rezept 89: JavaScript dynamisch laden und ausführen ... 535  11.11 ... Zusammenfassung ... 541

12.  Native Module ... 543  12.1 ... Rezept 90: Native Node.js-Module mit der V8-API erstellen ... 543  12.2 ... Rezept 91: Native Node.js-Module mit der NAN-API erstellen ... 550  12.3 ... Rezept 92: Native Node.js-Module mit der N-API erstellen ... 554  12.4 ... Rezept 93: Werte und Objekte zurückgeben mit der N-API ... 561  12.5 ... Rezept 94: Callbacks aufrufen mit der N-API ... 568  12.6 ... Rezept 95: Promises zurückgeben mit der N-API ... 573  12.7 ... Rezept 96: Assertions verwenden mit der N-API ... 576  12.8 ... Rezept 97: Native Node.js-Module debuggen ... 580  12.9 ... Zusammenfassung ... 584

13.  Publishing, Deployment und Microservices ... 587  13.1 ... Rezept 98: Eine private npm-Registry verwenden ... 588  13.2 ... Rezept 99: Docker verstehen ... 595  13.3 ... Rezept 100: Ein Docker Image für eine Node.js-Applikation erstellen ... 607  13.4 ... Rezept 101: Einen Docker-Container starten ... 612  13.5 ... Rezept 102: Microservice-Architekturen verstehen ... 616  13.6 ... Rezept 103: Microservice-Architekturen aufsetzen mit Docker Compose ... 625  13.7 ... Rezept 104: Den Quelltext bundeln und komprimieren mit Webpack ... 631  13.8 ... Zusammenfassung ... 639

Anhang:.  Rezept 105 ... 641  Index ... 643

Leseproben

Vorwort

Das erste Mal in Kontakt kam ich mit Node.js vor ungefähr acht Jahren: Im Jahr 2011 arbeitete ich beim Fraunhofer-Institut für Angewandte Informationstechnik an einer Software zur Evaluierung von Websites hinsichtlich Aspekten wie Barrierefreiheit, Suchmaschinenoptimierung, Corporate Identity und Web Compliance im Allgemeinen. Die Software war in der ersten Version unter Verwendung des GUI-Frameworks Swing als reine Java-Desktopanwendung implementiert und später in Version 2 als Client-/Server-Webanwendung auf Basis von Webservices migriert worden.

Die Software war zwar stabil, aber mit der Zeit merkten wir, dass wir immer mehr an die Grenzen von Java stießen. Bei den Websites, die mit der Software evaluiert werden sollten, handelte es sich größtenteils nicht mehr um statische Websites, sondern um Single-Page Applications, was wiederum verlangte, diese Applikationen auch auf Server-Seite zu rendern, um eine aussagekräftige Evaluierung durchführen zu können. Da die Möglichkeiten, die Java diesbezüglich zu dieser Zeit bot, für uns nicht zufriedenstellend waren, suchten wir nach Alternativen und fanden sie in dem Headless Browser PhantomJS, einem Browser ohne grafische Oberfläche, der über JavaScript gesteuert werden kann.

Mit diesem ersten Schritt von Java in Richtung JavaScript führte eines zum anderen, und wir entschieden uns, im Hinblick auf Version 3 der Software zunächst einzelne Komponenten und im Laufe des anschließenden Refactorings nahezu alle Komponenten in JavaScript neu zu schreiben. Ausschlaggebender Punkt dafür war aber nicht PhantomJS, sondern ein anderer neuer Player im JavaScript-Universum: die Laufzeitumgebung Node.js (damals noch in Version 0.1), die es überhaupt erst möglich machte, JavaScript effizient auf dem Server auszuführen, und die aus genau diesem Grund maßgeblich für den erneuten Erfolg von JavaScript mitverantwortlich war und immer noch ist.

Der Erfolg von JavaScript und Node.js ist nach wie vor ungebrochen. Ob im Bereich von Webanwendungen, mobiler Anwendungen, IoT-Anwendungen, Desktopanwendungen oder im Rahmen des Build-Prozesses. Ob auf einem herkömmlichen Server, in der Cloud oder auf einem Minicomputer wie dem Raspberry Pi: JavaScript und damit Node.js spielt mittlerweile in allen Bereichen eine wichtige Rolle und ist damit eine ernstzunehmende Konkurrenz für »die großen Sprachen« Java, C# oder PHP.

Aktuelle Umfragen, Trends und die Popularität von Node.js-Projekten bei GitHub sind nur einige Indikatoren hierfür. Hinzu kommt die große Community und die Menge an Open-Source-Projekten: So listet bspw. die Package-Registry des Node.js Package Managers derzeit mehr als 1.000.000 Packages (zum Vergleich: Vor etwa einem Jahr waren es noch rund 700.000 Packages) auf. Zudem gelten Node.js-Anwendungen als äußerst performant, sind dank nicht blockierender Ein- und Ausgabe hervorragend skalierbar und – auch aus Projektmanagementsicht – insofern erstrebenswert, als dass im besten Fall die gleichen JavaScript-Entwickler, die das Frontend entwickeln, auch in der Lage sind, das Backend zu entwickeln.

Doch wie soll man sich im Dschungel der Packages zurechtfinden, und welche Aspekte sind relevant für die Implementierung von Node.js-Projekten?

In diesem Buch habe ich Ihnen eine repräsentative Auswahl von praxiserprobten Techniken und Rezepten vorbereitet, die meine Erfahrung aus über acht Jahren Projekt- und (insbesondere) Produktentwicklung mit Node.js und über 20 Jahren in der Software- und Webentwicklung widerspiegeln. Dabei war mir wichtig, trotz komprimierter Rezept-Form ein Maximum an Informationsgehalt sicherzustellen und Ihnen so viel Insiderwissen wie möglich zu vermitteln.

Für wen ist dieses Buch?

Wenn ich als Entwickler – entsprechende Grundkenntnisse in der Programmierung vorausgesetzt – eine neue Programmiersprache lernen möchte und die Wahl hätte zwischen einem Buch, das alle Grundlagen behandelt, und einem Buch, das mir auf den Punkt genau Problemstellungen und die dazu passenden Lösungen präsentiert, würde ich zu letzterem greifen.

Mich würden in erster Linie nicht Fragen interessieren wie »Wie erstelle ich eine for-Schleife?«, »Wie erzeuge ich Objekte?«, »Wie erstelle ich eine Variable vom Typ String?« (okay, diese Fragen würde ich mir auch stellen, aber sie sind doch vermutlich innerhalb weniger Minuten geklärt), sondern Fragen wie »Wie implementiere ich eine REST-API?«, »Wie greife ich auf Datenbanken zu?«, »Welche Tools und Bibliotheken gibt es für welchen Anwendungsfall?« und »Wie strukturiere ich meine Applikation?«.

Node.js lernen Sie natürlich nicht allein dadurch, dass Sie ein Buch (oder mehrere) zu diesem Thema lesen. Sie müssen sich schon selbst die Hände schmutzig machen. Und hierbei, denke ich, eignet sich der rezeptartige Aufbau besonders gut. Mich haben immer schon Bücher, die diesem Aufbau folgen, mehr angesprochen, beispielsweise die Klassiker »Refactoring« von Martin Fowler, »Design Patterns – Elements of Reusable Object-Oriented Software« der »Gang of Four« oder – ebenfalls ein Klassiker, zumindest in der Java-Community – »Effective Java« von Joshua Block.

Wenn Sie dies ähnlich wie ich sehen und einen rezeptartigen Aufbau ebenso als effizienter empfinden, können Sie bedenkenlos zu dem vorliegenden Buch greifen.

Wie ist dieses Buch aufgebaut?

Insgesamt besteht das Buch aus 13 Kapiteln zu Themen, die ich als besonders wichtig empfinde, wenn es um die Entwicklung unter Node.js geht. Verteilt auf diese Kapitel sind insgesamt 105 Rezepte, mal mehr, mal weniger lang. Das liegt in der Natur der Sache: Wie man den Inhalt einer Datei einliest, ist einfach schneller erklärt als das Konzept und die Verwendung von GraphQL, Event-Handling ist schneller erklärt als die Besonderheiten und Features des MQTT-Protokolls, und wie man eine Webanwendung über HTTPS bereitstellt, ist schneller erklärt als das Deployment über Docker.

Jedes Rezept beginnt mit einer konkreten, meist aus einem Satz bestehenden Problemstellung, anhand derer Sie – zusammen mit der sprechenden Überschrift des Rezeptes – direkt erkennen können, ob das Rezept für Ihren konkreten Anwendungsfall relevant ist oder nicht. Anschließend folgt immer der Abschnitt »Lösung«, in dem ich erläutere, wie Sie das beschriebene Problem am besten angehen und lösen. Jedes Rezept endet mit einem Abschnitt »Ausblick«, in dem ich einerseits auf weiterführende Informationen und alternative Lösungsstrategien eingehe, aber auch auf andere Rezepte verweise, die mit dem jeweils aktuellen Rezept verwandt sind. Den Quelltext zu den Rezepten können Sie übrigens auf der offiziellen Website zum Buch unter www.rheinwerk-verlag.de/nodejs_4698/ herunterladen. Alternativ dazu steht der Quelltext auch in einem GitHub-Repository unter https://github.com/cleancoderocker/nodejskochbuch zur Verfügung.

Wenn Sie mein JavaScript-Profibuch »Professionell entwickeln mit JavaScript – Design, Patterns und Praxistipps« gelesen haben, wissen Sie, dass es in JavaScript nicht immer nur die eine richtige Technik gibt, um ein Problem zu lösen. Stattdessen führen viele verschiedene Wege zum Ziel. Und genauso verhält es sich auch mit der Entwicklung unter Node.js. Unabhängig von den JavaScript-Techniken, die natürlich auch unter Node.js relevant sind, gibt es oft verschiedene weitere Techniken, um die gegebenen Problemstellungen zu lösen. Auch hier gibt es nicht immer den einen richtigen Weg. Vielmehr sollen Sie mit den Rezepten und Lösungen in diesem Buch lernen, Problemstellungen richtig einzuschätzen und selbstständig in der Lage zu sein, die richtige Lösung anzuwenden.

Wie sollte ich das Buch durchlesen?

Prinzipiell können Sie das Buch auf verschiedene Arten durchlesen bzw. durcharbeiten. Trotz des rezeptartigen Aufbaus folgt das Buch einem roten Faden, der sich vom ersten Rezept bis zum letzten Rezept durchzieht. In den allermeisten Fällen sind die Rezepte zwar vollständig unabhängig voneinander, und nur in einigen wenigen Fällen bauen einzelne Rezepte auf anderen Rezepten auf, allerdings sind Rezepte zu grundlegenden Themen tendenziell weiter vorn im Buch angeordnet als Rezepte zu fortgeschrittenen Themen. Persönlich würde ich Ihnen also raten, das Buch von vorn bis hinten durchzuarbeiten. Damit ist sichergestellt, dass Ihnen nichts Wichtiges entgeht und Ihnen für spätere Rezepte kein Wissen aus vorherigen Rezepten fehlt.

Als Kochbuch soll das Buch natürlich vor allem schnell für einen konkreten Anwendungsfall die entsprechende Lösung liefern. Es spricht also auch nichts dagegen, die Rezepte nach Bedarf durchzuarbeiten. Mit den sprechenden Rezept-Überschriften und dem Index sollten Sie schnell die entsprechende Lösung für eine konkrete Problemstellung finden.

Zu guter Letzt soll das Buch natürlich auch als Nachschlagewerk dienen, das Sie immer wieder gern aus dem Regal ziehen, um Wissen bei Bedarf aufzufrischen. Genauso, wie ich das selbst noch heute immer wieder mit den oben genannten Klassikern mache.

Danksagung

Am allermeisten möchte ich wie immer meiner Frau und meinen Kindern danken für ihre Geduld und Unterstützung während der Zeit, die ich an diesem Buch gearbeitet habe. Auch wenn ich dieses Mal versucht habe, das Schreiben in die sehr frühen Morgenstunden und sehr späten Abendstunden zu legen, bin ich dankbar für die Zeit, die sie mir hierfür gegeben haben.

Außerdem bedanke ich mich bei meinem Lektor Stephan Mattescheck für die wie immer sehr...

Über Autor(innen)

Ackermann, Philip
Philip Ackermann ist CTO der Cedalo AG und Autor mehrerer Fachbücher und Fachartikel über Java und JavaScript. Seine Schwerpunkte liegen in der Konzeption und Entwicklung von Node.js- und JEE-Projekten in den Bereichen Industrie 4.0 und Internet of Things.