Node.js Tutorial
Erste Schritte mit Node.js

Bemerkungen

Versionen

Hallo Welt HTTP-Server

Installieren Sie zunächst Node.js für Ihre Plattform.

In diesem Beispiel erstellen wir einen HTTP-Server, der auf Port 1337 überwacht wird und der Hello, World! an den Browser. Beachten Sie, dass Sie anstelle von Port 1337 eine beliebige Portnummer Ihrer Wahl verwenden können, die derzeit von keinem anderen Dienst verwendet wird.

Der http - Modul ist ein Node.js Core - Modul (ein Modul in Node.js der Quelle enthält, die keine zusätzliche Ressourcen Installation erfordert). Das http Modul bietet die Funktionalität zum Erstellen eines HTTP-Servers mit der http.createServer() Methode. Erstellen Sie zum Erstellen der Anwendung eine Datei mit dem folgenden JavaScript-Code.

const http = require('http'); // Loads the http module

http.createServer((request, response) => {

    // 1. Tell the browser everything is OK (Status code 200), and the data is in plain text
    response.writeHead(200, {
        'Content-Type': 'text/plain'
    });

    // 2. Write the announced text to the body of the page
    response.write('Hello, World!\n');

    // 3. Tell the server that all of the response headers and body have been sent
    response.end();

}).listen(1337); // 4. Tells the server what port to be on

Speichern Sie die Datei mit einem beliebigen Dateinamen. Wenn wir es hello.js , können Sie die Anwendung ausführen, indem Sie in das Verzeichnis hello.js , in dem sich die Datei befindet, und den folgenden Befehl verwenden:

node hello.js

Auf den erstellten Server kann dann mit der URL http: // localhost: 1337 oder http://127.0.0.1:1337 im Browser zugegriffen werden.

Eine einfache Webseite wird mit dem Text „Hallo, Welt!“ Oben angezeigt, wie in der Abbildung unten gezeigt.

Bearbeitbares Online-Beispiel.

Hallo Weltbefehlszeile

Node.js kann auch zum Erstellen von Befehlszeilen-Dienstprogrammen verwendet werden. Das folgende Beispiel liest das erste Argument aus der Befehlszeile und gibt eine Hello-Nachricht aus.

So führen Sie diesen Code auf einem Unix-System aus:

1. Erstellen Sie eine neue Datei und fügen Sie den folgenden Code ein. Der Dateiname ist irrelevant.
2. Machen Sie diese Datei mit chmod 700 FILE_NAME ausführbar
3. Führen Sie die App mit ./APP_NAME David

Unter Windows führen Sie Schritt 1 aus und führen es mit dem node APP_NAME David

#!/usr/bin/env node

'use strict';

/*
    The command line arguments are stored in the `process.argv` array, 
    which has the following structure:
    [0] The path of the executable that started the Node.js process
    [1] The path to this application
    [2-n] the command line arguments

    Example: [ '/bin/node', '/path/to/yourscript', 'arg1', 'arg2', ... ]
    src: https://nodejs.org/api/process.html#process_process_argv
 */

// Store the first argument as username.
var username = process.argv[2];

// Check if the username hasn't been provided.
if (!username) {

    // Extract the filename
    var appName = process.argv[1].split(require('path').sep).pop();

    //  Give the user an example on how to use the app.
    console.error('Missing argument! Example: %s YOUR_NAME', appName);

    // Exit the app (success: 0, error: 1). 
    // An error will stop the execution chain. For example:
    //   ./app.js && ls       -> won't execute ls
    //   ./app.js David && ls -> will execute ls
    process.exit(1);
}

// Print the message to the console.
console.log('Hello %s!', username);

Node.js installieren und ausführen

Installieren Sie zunächst Node.js auf Ihrem Entwicklungscomputer.

Windows: Navigieren Sie zur Downloadseite und laden Sie das Installationsprogramm herunter bzw. führen Sie es aus.

Mac: Navigieren Sie zur Downloadseite und laden Sie das Installationsprogramm herunter bzw. führen Sie es aus. Alternativ können Sie den Knoten über den Homebrew-Knoten mithilfe des brew install node . Homebrew ist ein Befehlszeilen-Paketmanager für Macintosh. Weitere Informationen hierzu finden Sie auf der Homebrew-Website .

Linux: Befolgen Sie die Anweisungen für Ihre Distribution auf der Befehlszeilen-Installationsseite .

Ausführen eines Knotenprogramms

Um ein Node.js-Programm auszuführen, führen Sie einfach den node app.js oder nodejs app.js , wobei app.js der Dateiname des Quellcodes Ihrer Knoten-App ist. Sie müssen das .js Suffix für Node nicht .js , um das Skript zu finden, das Sie .js .

Alternativ kann unter UNIX-basierten Betriebssystemen ein Node-Programm als Terminalskript ausgeführt werden. Um dies zu tun, muss es mit einem Shebang beginnen, der auf den Node-Interpreter zeigt, z. B. #!/usr/bin/env node . Die Datei muss auch als ausführbar festgelegt werden. Dies kann mit chmod . Jetzt kann das Skript direkt von der Befehlszeile aus ausgeführt werden.

Online-Bereitstellung Ihrer Anwendung

Wenn Sie Ihre App in einer (Node.js-spezifischen) gehosteten Umgebung bereitstellen, bietet diese Umgebung normalerweise eine PORT -Umgebungsvariable an, auf der Sie Ihren Server ausführen können. Wenn Sie die Portnummer in process.env.PORT können Sie auf die Anwendung zugreifen.

Zum Beispiel,

http.createServer(function(request, response) {
   // your server code
}).listen(process.env.PORT);

Wenn Sie während des Debugging auf diesen Offlinezugriff zugreifen möchten, können Sie Folgendes verwenden:

http.createServer(function(request, response) {
  // your server code
}).listen(process.env.PORT || 3000);

Dabei ist 3000 die Offline-Portnummer.

Debuggen Ihrer NodeJS-Anwendung

Sie können den Node-Inspector verwenden. Führen Sie diesen Befehl aus, um ihn über npm zu installieren:

npm install -g node-inspector

Dann können Sie Ihre Anwendung mit debuggen

node-debug app.js

Das Github-Repository finden Sie hier: https://github.com/node-inspector/node-inspector

Debugging nativ

Sie können node.js auch nativ debuggen, indem Sie es wie folgt starten:

node debug your-script.js

Verwenden Sie den folgenden Befehl, um Ihren Debugger genau in einer von Ihnen gewünschten Codezeile abzubrechen:

debugger;

Weitere Informationen finden Sie hier .

Verwenden Sie in node.js 8 den folgenden Befehl:

node --inspect-brk your-script.js

Öffnen Sie dann about://inspect in einer aktuellen Version von Google Chrome und wählen Sie Ihr Knotenskript aus, um die Debugging-Funktionen der DevTools von Chrome zu erhalten.

Hallo Welt mit Express

Im folgenden Beispiel wird mit Express ein HTTP-Server erstellt, der auf Port 3000 überwacht wird und der mit "Hallo, Welt!" Antwortet. Express ist ein häufig verwendetes Web-Framework, das zum Erstellen von HTTP-APIs nützlich ist.

myApp einen neuen Ordner an, z. B. myApp . Gehen Sie zu myApp und myApp eine neue JavaScript-Datei, die den folgenden Code enthält (nennen wir es beispielsweise hello.js ). Installieren Sie dann das Express-Modul mit npm install --save express von der Befehlszeile aus. Weitere Informationen zum Installieren von Paketen finden Sie in dieser Dokumentation .

// Import the top-level function of express
const express = require('express');

// Creates an Express application using the top-level function
const app = express();

// Define port number as 3000
const port = 3000;

// Routes HTTP GET requests to the specified path "/" with the specified callback function
app.get('/', function(request, response) {
  response.send('Hello, World!');
});

// Make the app listen on port 3000
app.listen(port, function() {
  console.log('Server listening on http://localhost:' + port);
});

Führen Sie in der Befehlszeile den folgenden Befehl aus:

node hello.js

Öffnen Sie Ihren Browser und navigieren Sie zu http://localhost:3000 oder http://127.0.0.1:3000 , um die Antwort http://127.0.0.1:3000 .

Weitere Informationen zum Express-Framework finden Sie im Abschnitt Web Apps With Express

Hallo Weltgrundrouting

Wenn Sie wissen, wie ein HTTP-Server mit einem Knoten erstellt wird, ist es wichtig zu verstehen, wie er etwas erledigen kann, je nach dem Pfad, zu dem ein Benutzer navigiert hat. Dieses Phänomen wird "Routing" genannt.

Das einfachste Beispiel dafür wäre zu prüfen, if (request.url === 'some/path/here') und dann eine Funktion aufgerufen wird, die mit einer neuen Datei antwortet.

Ein Beispiel dafür ist hier zu sehen:

const http = require('http');

function index (request, response) {
    response.writeHead(200);
    response.end('Hello, World!');
}

http.createServer(function (request, response) {
    
    if (request.url === '/') {
        return index(request, response);
    }

    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);

}).listen(1337);

Wenn Sie Ihre "Routen" jedoch weiterhin so definieren, erhalten Sie eine massive Rückruffunktion, und wir möchten kein riesiges Durcheinander wie dieses, also lassen Sie uns sehen, ob wir das aufräumen können.

Lassen Sie uns zunächst alle Routen in einem Objekt speichern:

var routes = {
    '/': function index (request, response) {
        response.writeHead(200);
        response.end('Hello, World!');
    },
    '/foo': function foo (request, response) {
        response.writeHead(200);
        response.end('You are now viewing "foo"');
    }
}

Nachdem wir zwei Routen in einem Objekt gespeichert haben, können wir sie jetzt in unserem Hauptcallback nach ihnen suchen:

http.createServer(function (request, response) {
    
    if (request.url in routes) {
        return routes[request.url](request, response);
    }

    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);

}).listen(1337);

Jedes Mal, wenn Sie versuchen, auf Ihrer Website zu navigieren, wird die Existenz dieses Pfads in Ihren Routen überprüft und die entsprechende Funktion aufgerufen. Wird keine Route gefunden, antwortet der Server mit einem 404 (Not Found).

Und da haben Sie es - das Routing mit der HTTP-Server-API ist sehr einfach.

TLS Socket: Server und Client

Die einzigen Hauptunterschiede zwischen dieser und einer normalen TCP-Verbindung sind der private Schlüssel und das öffentliche Zertifikat, das Sie in ein Optionsobjekt setzen müssen.

So erstellen Sie einen Schlüssel und ein Zertifikat

Der erste Schritt in diesem Sicherheitsprozess ist die Erstellung eines privaten Schlüssels. Und was ist dieser private Schlüssel? Im Grunde handelt es sich dabei um ein zufälliges Rauschen, das zum Verschlüsseln von Informationen verwendet wird. Theoretisch könnten Sie einen Schlüssel erstellen und damit verschlüsseln, was Sie möchten. Es ist jedoch am besten, für bestimmte Dinge unterschiedliche Schlüssel zu verwenden. Wenn jemand Ihren privaten Schlüssel stiehlt, ist es ähnlich, wenn jemand Ihre Hausschlüssel stiehlt. Stellen Sie sich vor, Sie hätten mit dem gleichen Schlüssel Ihr Auto, Ihre Garage, Ihr Büro usw. gesperrt.

openssl genrsa -out private-key.pem 1024

Sobald wir unseren privaten Schlüssel haben, können wir eine CSR (Certificate Signing Request) erstellen. Dies ist unser Wunsch, den privaten Schlüssel von einer fancy Authority signieren zu lassen. Deshalb müssen Sie Informationen eingeben, die sich auf Ihr Unternehmen beziehen. Diese Informationen werden von der unterzeichnenden Behörde eingesehen und zur Bestätigung verwendet. In unserem Fall ist es egal, was Sie eingeben, da wir unser Zertifikat im nächsten Schritt selbst unterschreiben werden.

openssl req -new -key private-key.pem -out csr.pem

Jetzt, da unsere Papiere ausgefüllt sind, ist es an der Zeit, so zu tun, als wären wir eine coole Zeichnungsbehörde.

openssl x509 -req -in csr.pem -signkey private-key.pem -out public-cert.pem

Nachdem Sie nun den privaten Schlüssel und das öffentliche Zertifikat besitzen, können Sie eine sichere Verbindung zwischen zwei NodeJS-Apps herstellen. Und wie Sie im Beispielcode sehen können, ist dies ein sehr einfacher Prozess.

Wichtig!

Da wir das öffentliche Zertifikat selbst erstellt haben, ist unser Zertifikat in aller Ehrlichkeit wertlos, weil wir Nobodies sind. Der NodeJS-Server vertraut einem solchen Zertifikat standardmäßig nicht, und deshalb müssen wir ihm sagen, dass er unserem Zertifikat tatsächlich mit der folgenden Option rejectUnauthorized vertraut: false. Sehr wichtig : Setzen Sie diese Variable niemals in einer Produktionsumgebung auf true.

TLS-Socket-Server

'use strict';

var tls = require('tls');
var fs = require('fs');

const PORT = 1337;
const HOST = '127.0.0.1'

var options = {
    key: fs.readFileSync('private-key.pem'),
    cert: fs.readFileSync('public-cert.pem')
};

var server = tls.createServer(options, function(socket) {

    // Send a friendly message
    socket.write("I am the server sending you a message.");

    // Print the data that we received
    socket.on('data', function(data) {

        console.log('Received: %s [it is %d bytes long]',
            data.toString().replace(/(\n)/gm,""),
            data.length);

    });

    // Let us know when the transmission is over
    socket.on('end', function() {

        console.log('EOT (End Of Transmission)');

    });

});

// Start listening on a specific port and address
server.listen(PORT, HOST, function() {

    console.log("I'm listening at %s, on port %s", HOST, PORT);

});

// When an error occurs, show it.
server.on('error', function(error) {

    console.error(error);

    // Close the connection after the error occurred.
    server.destroy();

});

TLS-Socket-Client

'use strict';

var tls = require('tls');
var fs = require('fs');

const PORT = 1337;
const HOST = '127.0.0.1'

// Pass the certs to the server and let it know to process even unauthorized certs.
var options = {
    key: fs.readFileSync('private-key.pem'),
    cert: fs.readFileSync('public-cert.pem'),
    rejectUnauthorized: false
};

var client = tls.connect(PORT, HOST, options, function() {

    // Check if the authorization worked
    if (client.authorized) {
        console.log("Connection authorized by a Certificate Authority.");
    } else {
        console.log("Connection not authorized: " + client.authorizationError)
    }

    // Send a friendly message
    client.write("I am the client sending you a message.");

});

client.on("data", function(data) {

    console.log('Received: %s [it is %d bytes long]',
        data.toString().replace(/(\n)/gm,""),
        data.length);

    // Close the connection after receiving the message
    client.end();

});

client.on('close', function() {

    console.log("Connection closed");

});

// When an error ocoures, show it.
client.on('error', function(error) {

    console.error(error);

    // Close the connection after the error occurred.
    client.destroy();

});

Hallo Welt in der REPL

Bei Aufruf ohne Argumente startet Node.js eine REPL (Read-Eval-Print-Loop), die auch als " Node-Shell " bezeichnet wird.

Geben Sie an einer Eingabeaufforderung node .

$ node
>

Am Knoten Shell - Prompt > Typ „Hallo Welt!“

$ node
> "Hello World!"
'Hello World!'

Kern Module

Node.js ist eine Javascript-Engine (V8-Engine von Google für Chrome, die in C ++ geschrieben ist), mit der Javascript außerhalb des Browsers ausgeführt werden kann. Während zahlreiche Bibliotheken für die Erweiterung der Node-Funktionen verfügbar sind, enthält die Engine eine Reihe von Kernmodulen, die grundlegende Funktionen implementieren.

Derzeit sind 34 Kernmodule in Node enthalten:

[ 'assert',
  'buffer',
  'c/c++_addons',
  'child_process',
  'cluster',
  'console',
  'crypto',
  'deprecated_apis',
  'dns',
  'domain',
  'Events',
  'fs',
  'http',
  'https',
  'module',
  'net',
  'os',
  'path',
  'punycode',
  'querystring',
  'readline',
  'repl',
  'stream',
  'string_decoder',
  'timers',
  'tls_(ssl)',
  'tracing',
  'tty',
  'dgram',
  'url',
  'util',
  'v8',
  'vm',
  'zlib' ]

Diese Liste wurde von der Node-Dokumentations-API https://nodejs.org/api/all.html (JSON-Datei: https://nodejs.org/api/all.json ) abgerufen.

Alle Kernmodule auf einen Blick

behaupten

Das assert Modul bietet einen einfachen Satz von Assertionstests, mit denen Invarianten getestet werden können.

Puffer

Vor der Einführung von TypedArray in ECMAScript 2015 (ES6) verfügte die JavaScript-Sprache nicht über einen Mechanismus zum Lesen oder Bearbeiten von Binärdatenströmen. Die Buffer Klasse wurde als Teil der Node.js-API eingeführt, um die Interaktion mit Octet-Streams im Zusammenhang mit TCP-Streams und Dateisystemvorgängen zu ermöglichen.

TypedArray nun in ES6 TypedArray hinzugefügt wurde, implementiert die Buffer Klasse die Uin t8Array API auf eine Art und Weise, die für Node.js-Anwendungsfälle optimiert und geeignet ist.

c / c ++ _ Addons

Node.js Addons sind dynamisch verknüpfte, gemeinsam genutzte Objekte, die in C oder C ++ geschrieben wurden. Sie können mit der Funktion require() in Node.js geladen werden und werden so verwendet, als wären sie ein gewöhnliches Node.js-Modul. Sie dienen in erster Linie dazu, eine Schnittstelle zwischen JavaScript in Node.js und C / C ++ - Bibliotheken bereitzustellen.

child_process

Das child_process Modul bietet die Möglichkeit, child_process Prozesse auf ähnliche Weise wie popen (3) zu erzeugen.

Cluster

Eine einzelne Instanz von Node.js wird in einem einzelnen Thread ausgeführt. Um Multi-Core-Systeme zu nutzen, möchte der Benutzer manchmal ein Cluster von Node.js-Prozessen starten, um die Last zu handhaben. Mit dem Cluster-Modul können Sie auf einfache Weise untergeordnete Prozesse erstellen, die alle Serverports gemeinsam nutzen.

Konsole

Das console bietet eine einfache Debugging-Konsole, die dem von Webbrowsern bereitgestellten JavaScript-Konsolenmechanismus ähnelt.

Krypto

Das crypto bietet eine kryptografische Funktionalität, die eine Reihe von Wrappern für die Hash-, HMAC-, Verschlüsselungs-, Entschlüsselungs-, Signatur- und Überprüfungsfunktionen von OpenSSL umfasst.

deprecated_apis

Node.js kann APIs ablehnen, wenn entweder (a) die Verwendung der API als unsicher angesehen wird, (b) eine verbesserte alternative API zur Verfügung gestellt wurde oder (c) in einer zukünftigen Hauptversion Änderungen der API erwartet werden .

dns

Das dns Modul enthält Funktionen, die zwei verschiedenen Kategorien angehören:

1. Funktionen, die die zugrunde liegenden Betriebssystemeinrichtungen zur Namensauflösung verwenden und nicht notwendigerweise Netzwerkkommunikation durchführen. Diese Kategorie enthält nur eine Funktion: dns.lookup() .
2. Funktionen, die eine Verbindung zu einem tatsächlichen DNS-Server herstellen, um die Namensauflösung durchzuführen, und die immer das Netzwerk verwenden, um DNS-Abfragen auszuführen. Diese Kategorie enthält alle Funktionen im dns Modul mit Ausnahme von dns.lookup() .

Domain

Dieses Modul steht noch aus . Sobald eine Ersatz-API abgeschlossen ist, wird dieses Modul vollständig abgelehnt. Die meisten Endbenutzer sollten keinen Grund haben, dieses Modul zu verwenden. Benutzer, die unbedingt über die Funktionalität von Domains verfügen müssen, können sich vorerst darauf verlassen, sollten aber in der Zukunft auf eine andere Lösung umsteigen müssen.

Veranstaltungen

Ein Großteil der Kern-API von Node.j basiert auf einer idiomatischen, asynchronen, ereignisgesteuerten Architektur, in der bestimmte Arten von Objekten (als "Emitter" bezeichnet) in regelmäßigen Abständen benannte Ereignisse ausgeben, die den Aufruf von Function-Objekten ("Listeners") bewirken.

fs

File I / O wird von einfachen Wrappern für POSIX-Standardfunktionen bereitgestellt. Um dieses Modul zu verwenden, require('fs') . Alle Methoden haben asynchrone und synchrone Formen.

http

Die HTTP-Schnittstellen in Node.js unterstützen viele Funktionen des Protokolls, die traditionell schwer zu verwenden waren. Insbesondere große, möglicherweise chunkcodierte Nachrichten. Die Benutzeroberfläche achtet nicht darauf, ganze Anfragen oder Antworten zu puffern - der Benutzer kann Daten streamen.

https

HTTPS ist das HTTP-Protokoll über TLS / SSL. In Node.js ist dies als separates Modul implementiert.

Modul

Node.js verfügt über ein einfaches Modulladesystem. In Node.js befinden sich Dateien und Module in einer Eins-zu-Eins-Entsprechung (jede Datei wird als separates Modul behandelt).

Netz

Das net Modul ermöglicht Ihnen mit einem asynchronen Netzwerk - Wrapper. Es enthält Funktionen zum Erstellen von Servern und Clients (Streams genannt). Sie können dieses Modul mit require('net'); einschließen require('net'); .

os

Das os Modul stellt eine Reihe von Betriebssystemmethoden zur Verfügung.

Pfad

Das path - Modul bietet Dienstprogramme für die mit Datei- und Verzeichnispfaden arbeiten.

Punycode

Die Version des in Node.js gebündelten Punycode-Moduls wird nicht mehr unterstützt .

Querzeichenfolge

Das Modul querystring bietet Dienstprogramme zum Analysieren und Formatieren von URL- querystring .

Zeile lesen

Das readline Modul bietet eine Schnittstelle zum Lesen von Daten aus einem lesbaren Stream (z. B. process.stdin ) Zeile für Zeile.

repl

Das repl Modul bietet eine REPL-Implementierung (Read-Eval-Print-Loop), die sowohl als eigenständiges Programm als auch in andere Anwendungen verfügbar ist.

Strom

Ein Stream ist eine abstrakte Schnittstelle zum Arbeiten mit Streaming-Daten in Node.js. Das stream Modul bietet eine Basis-API, mit der sich Objekte, die die Stream-Schnittstelle implementieren, leicht erstellen lassen.

Es gibt viele Stream-Objekte, die von Node.js bereitgestellt werden. Beispielsweise sind eine Anforderung an einen HTTP-Server und process.stdout beide Stream-Instanzen.

string_decoder

Das string_decoder Modul stellt eine API zum Dekodieren Buffer Objekte in Zeichenfolgen in einer Weise , die Multi-Byte - UTF-8 und UTF-16 - Zeichen codiert bewahrt.

Timer

Das timer stellt eine globale API zum Planen von Funktionen bereit, die zu einem späteren Zeitpunkt aufgerufen werden sollen. Da es sich bei den Timer-Funktionen um globale Werte handelt, müssen für den Einsatz der API keine „timers“ require('timers') aufgerufen werden.

Die Zeitgeberfunktionen in Node.js implementieren eine ähnliche API wie die von Web-Browsern bereitgestellte Timer-API, verwenden jedoch eine andere interne Implementierung, die auf der Node.js-Ereignisschleife basiert.

tls_ (ssl)

Das tls Modul bietet eine Implementierung der Protokolle Transport Layer Security (TLS) und SSL (Secure Socket Layer), die auf OpenSSL basieren.

Rückverfolgung

Das Ablaufereignis bietet einen Mechanismus zum Zentralisieren der Ablaufverfolgungsinformationen, die von V8, dem Knotenkern und dem Benutzerraumcode generiert werden.

Die --trace-events-enabled kann aktiviert werden, indem beim Starten einer Node.js-Anwendung --trace-events-enabled Flag --trace-events-enabled .

tty

Das tty Modul stellt die Klassen tty.ReadStream und tty.WriteStream . In den meisten Fällen ist es nicht notwendig oder möglich, dieses Modul direkt zu verwenden.

dgram

Das dgram Modul bietet eine Implementierung von UDP-Datagram-Sockets.

URL

Das url Modul stellt Dienstprogramme für die URL-Auflösung und -Parsing bereit.

util

Das util Modul ist hauptsächlich für die Unterstützung der internen APIs von Node.js konzipiert. Viele Dienstprogramme sind jedoch auch für Anwendungs- und Modulentwickler nützlich.

v8

Das v8 Modul macht APIs verfügbar, die für die in der Binärdatei Node.js integrierte Version von V8 spezifisch sind.

Hinweis : Die APIs und die Implementierung können jederzeit geändert werden.

vm

Das vm Modul stellt APIs zum Kompilieren und Ausführen von Code in virtuellen V8-VM-Kontexten bereit. JavaScript-Code kann kompiliert und sofort ausgeführt oder kompiliert, gespeichert und später ausgeführt werden.

Hinweis : Das VM-Modul ist kein Sicherheitsmechanismus. Verwenden Sie es nicht, um nicht vertrauenswürdigen Code auszuführen .

zlib

Das zlib Modul bietet Kompressionsfunktionen, die mit Gzip und Deflate / Inflate implementiert werden.

So installieren Sie einen einfachen HTTPS-Webserver!

Sobald Sie node.js auf Ihrem System installiert haben, können Sie einfach die folgenden Schritte ausführen, um einen grundlegenden Webserver mit Unterstützung für HTTP und HTTPS zu erhalten!

Schritt 1: Erstellen Sie eine Zertifizierungsstelle

1. Erstellen Sie den Ordner, in dem Sie Ihren Schlüssel und Ihr Zertifikat speichern möchten:

   mkdir conf

2. Gehen Sie zu diesem Verzeichnis:

   cd conf

3. ca.cnf diese ca.cnf Datei, um sie als Konfigurationsverknüpfung zu verwenden:

   wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf

4. Erstellen Sie eine neue Zertifizierungsstelle mit dieser Konfiguration:

   openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem

5. Jetzt, da wir unsere Zertifizierungsstelle in ca-key.pem und ca-cert.pem , generieren wir einen privaten Schlüssel für den Server:

   openssl genrsa -out key.pem 4096

6. server.cnf diese server.cnf Datei, um sie als Konfigurationsverknüpfung zu verwenden:

   wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/server.cnf

7. Generieren Sie die Zertifikatsignierungsanforderung mit dieser Konfiguration:

   openssl req -new -config server.cnf -key key.pem -out csr.pem

8. unterschreibe die Anfrage:

   openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in csr.pem -CA ca-cert.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem

Schritt 2: Installieren Sie Ihr Zertifikat als Stammzertifikat

1. Kopieren Sie Ihr Zertifikat in den Ordner Ihrer Stammzertifikate:

   sudo cp ca-crt.pem /usr/local/share/ca-certificates/ca-crt.pem

2. CA Store aktualisieren:

   sudo update-ca-certificates

Schritt 3: Starten Sie Ihren Knotenserver

Zunächst möchten Sie eine server.js Datei erstellen, die Ihren tatsächlichen server.js enthält.

Das minimale Setup für einen HTTPS-Server in Node.js wäre ungefähr so:

var https = require('https');
var fs = require('fs');

var httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

var app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

https.createServer(httpsOptions, app).listen(4433);

Wenn Sie auch HTTP-Anfragen unterstützen möchten, müssen Sie nur diese kleine Änderung vornehmen:

var http = require('http');
var https = require('https');
var fs = require('fs');

var httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

var app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

http.createServer(app).listen(8888);
https.createServer(httpsOptions, app).listen(4433);

1. Gehen Sie in das Verzeichnis, in dem sich Ihre server.js befindet:

   cd /path/to

2. Führen Sie server.js :

   node server.js