Node.js Zelfstudie
Aan de slag met Node.js

Opmerkingen

versies

Hallo wereld HTTP-server

Installeer eerst Node.js voor uw platform.

In dit voorbeeld maken we een HTTP-server die luistert op poort 1337, die Hello, World! verzendt Hello, World! naar de browser. Merk op dat u in plaats van poort 1337 elk poortnummer van uw keuze kunt gebruiken dat momenteel niet door andere services wordt gebruikt.

De http module is een Node.js- kernmodule (een module die is opgenomen in de bron van Node.js, waarvoor geen extra bronnen hoeven te worden geïnstalleerd). De http module biedt de functionaliteit om een HTTP-server te maken met behulp van de methode http.createServer() . Maak een bestand met de volgende JavaScript-code om de toepassing te maken.

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

Sla het bestand op met een willekeurige bestandsnaam. In dit geval, als we het hello.js , kunnen we de toepassing uitvoeren door naar de map te gaan waarin het bestand zich bevindt en de volgende opdracht te gebruiken:

node hello.js

De gemaakte server kan vervolgens worden geopend met de URL http: // localhost: 1337 of http://127.0.0.1:1337 in de browser.

Er verschijnt een eenvoudige webpagina met een "Hallo wereld!" tekst bovenaan, zoals weergegeven in de onderstaande schermafbeelding.

Bewerkbaar online voorbeeld.

Hallo wereld opdrachtregel

Node.js kan ook worden gebruikt om opdrachtregelprogramma's te maken. In het onderstaande voorbeeld wordt het eerste argument van de opdrachtregel gelezen en wordt een Hallo-bericht afgedrukt.

Om deze code op een Unix-systeem uit te voeren:

1. Maak een nieuw bestand en plak de onderstaande code. De bestandsnaam is niet relevant.
2. Maak dit bestand uitvoerbaar met chmod 700 FILE_NAME
3. Voer de app uit met ./APP_NAME David

In Windows voert u stap 1 uit en voert u deze uit met 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 installeren en uitvoeren

Installeer Node.js om te beginnen op uw ontwikkelingscomputer.

Windows: ga naar de downloadpagina en download / voer het installatieprogramma uit.

Mac: ga naar de downloadpagina en download / voer het installatieprogramma uit. Als alternatief kunt u Node installeren via Homebrew met behulp van brew install node . Homebrew is een opdrachtregelpakketbeheer voor Macintosh en meer informatie hierover is te vinden op de Homebrew-website .

Linux: volg de instructies voor uw distro op de installatiepagina van de opdrachtregel .

Een knooppuntprogramma uitvoeren

Om een Node.js-programma uit te voeren, voert u eenvoudig node app.js of nodejs app.js , waarbij app.js de bestandsnaam is van de broncode van uw knooppunt-app. U hoeft het .js achtervoegsel voor Node niet op te nemen om het script te vinden dat u wilt uitvoeren.

Als alternatief onder op UNIX gebaseerde besturingssystemen kan een Node-programma worden uitgevoerd als een terminalscript. Om dit te doen, moet het beginnen met een shebang die naar de Node-interpreter verwijst, zoals #!/usr/bin/env node . Het bestand moet ook worden ingesteld als uitvoerbaar, wat kan worden gedaan met behulp van chmod . Nu kan het script direct vanaf de opdrachtregel worden uitgevoerd.

Uw toepassing online implementeren

Wanneer u uw app implementeert in een (Node.js-specifieke) gehoste omgeving, biedt deze omgeving meestal een PORT omgevingsvariabele die u kunt gebruiken om uw server op te laten draaien. Door het poortnummer te wijzigen in process.env.PORT heeft u toegang tot de applicatie.

Bijvoorbeeld,

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

Als u hier tijdens het debuggen toegang toe wilt hebben, kunt u dit ook gebruiken:

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

waarbij 3000 het offline poortnummer is.

Foutopsporing in uw NodeJS-toepassing

U kunt de knooppuntinspecteur gebruiken. Voer deze opdracht uit om het te installeren via npm:

npm install -g node-inspector

Vervolgens kunt u uw toepassing debuggen met

node-debug app.js

De Github-repository is hier te vinden: https://github.com/node-inspector/node-inspector

Standaard debuggen

Je kunt node.js ook native debuggen door het als volgt te starten:

node debug your-script.js

Om uw debugger precies in een gewenste coderegel te onderbreken, gebruikt u dit:

debugger;

Voor meer informatie zie hier .

Gebruik in node.js 8 de volgende opdracht:

node --inspect-brk your-script.js

Open vervolgens about://inspect in een recente versie van Google Chrome en selecteer uw Node-script om de foutopsporingservaring van de DevTools van Chrome te krijgen.

Hallo wereld met Express

In het volgende voorbeeld wordt Express gebruikt om een HTTP-server te maken die luistert op poort 3000, die reageert met "Hallo wereld!". Express is een veelgebruikt webframework dat handig is voor het maken van HTTP-API's.

Maak eerst een nieuwe map aan, bijv. myApp . Ga naar myApp en maak een nieuw JavaScript-bestand met de volgende code (laten we het bijvoorbeeld hello.js ). Installeer vervolgens de express-module met behulp van npm install --save express vanaf de opdrachtregel. Raadpleeg deze documentatie voor meer informatie over het installeren van pakketten .

// 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);
});

Voer vanaf de opdrachtregel de volgende opdracht uit:

node hello.js

Open uw browser en navigeer naar http://localhost:3000 of http://127.0.0.1:3000 om het antwoord te zien.

Voor meer informatie over het Express-framework kunt u het gedeelte Web-apps met Express raadplegen

Hallo wereld basisroutering

Als u eenmaal begrijpt hoe u een HTTP-server met knooppunt maakt, is het belangrijk om te begrijpen hoe u dingen kunt "doen" op basis van het pad waarnaar een gebruiker is genavigeerd. Dit fenomeen wordt "routing" genoemd.

Het meest eenvoudige voorbeeld hiervan is om te controleren if (request.url === 'some/path/here') en vervolgens een functie aan te roepen die reageert met een nieuw bestand.

Een voorbeeld hiervan is hier te zien:

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);

Als je echter je "routes" op deze manier blijft definiëren, krijg je een enorme callback-functie, en we willen zo'n gigantische puinhoop niet, dus laten we kijken of we dit kunnen opruimen.

Laten we eerst al onze routes opslaan in een object:

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"');
    }
}

Nu we 2 routes in een object hebben opgeslagen, kunnen we deze nu controleren in onze belangrijkste callback:

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);

Elke keer dat u probeert om door uw website te navigeren, zal het controleren op het bestaan van dat pad in uw routes en zal het de respectieve functie aanroepen. Als er geen route wordt gevonden, reageert de server met een 404 (niet gevonden).

En daar heb je het - routing met de HTTP Server API is heel eenvoudig.

TLS-socket: server en client

Het enige grote verschil tussen deze en een normale TCP-verbinding zijn de privésleutel en het openbare certificaat dat u moet instellen in een optieobject.

Een sleutel en certificaat maken

De eerste stap in dit beveiligingsproces is het maken van een persoonlijke sleutel. En wat is deze privésleutel? Kortom, het is een set willekeurige ruis die wordt gebruikt om informatie te coderen. In theorie zou u één sleutel kunnen maken en deze kunnen gebruiken om te coderen wat u maar wilt. Maar het is best om verschillende sleutels voor specifieke dingen te hebben. Want als iemand je privésleutel steelt, is het vergelijkbaar met iemand die je huissleutels steelt. Stel je voor dat je dezelfde sleutel hebt gebruikt om je auto, garage, kantoor, etc. te vergrendelen

openssl genrsa -out private-key.pem 1024

Zodra we onze privésleutel hebben, kunnen we een CSR (certificaatondertekeningsverzoek) maken. Dit is ons verzoek om de privésleutel te laten ondertekenen door een chique autoriteit. Daarom moet u informatie met betrekking tot uw bedrijf invoeren. Deze informatie wordt door de ondertekenende autoriteit bekeken en gebruikt om u te verifiëren. In ons geval maakt het niet uit wat u typt, want in de volgende stap gaan we ons certificaat zelf ondertekenen.

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

Nu we ons papierwerk hebben ingevuld, is het tijd om te doen alsof we een coole ondertekenende autoriteit zijn.

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

Nu u de privésleutel en de openbare cert hebt, kunt u een veilige verbinding tot stand brengen tussen twee NodeJS-apps. En, zoals je kunt zien in de voorbeeldcode, is het een heel eenvoudig proces.

Belangrijk!

Aangezien we het publiek zelf hebben opgericht, is ons certificaat in alle eerlijkheid waardeloos, omdat we niemand zijn. De NodeJS-server vertrouwt een dergelijk certificaat niet standaard, en daarom moeten we het vertellen dat het onze cert echt moet vertrouwen met de volgende optie rejectUnauthorized: false. Zeer belangrijk : stel deze variabele nooit in op waar in een productieomgeving.

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-socketclient

'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 wereld in de REPL

Bij aanroep zonder argumenten start Node.js een REPL (Read-Eval-Print-Loop) ook bekend als de " Node shell ".

Typ een node bij een opdrachtprompt.

$ node
>

Bij de Node shell-prompt > typ "Hallo wereld!"

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

Kernmodules

Node.js is een Javascript-engine (Google's V8-engine voor Chrome, geschreven in C ++) waarmee JavaScript buiten de browser kan worden uitgevoerd. Hoewel er talloze bibliotheken beschikbaar zijn om de functionaliteiten van Node uit te breiden, wordt de engine geleverd met een set kernmodules die basisfunctionaliteiten implementeren.

Er zijn momenteel 34 kernmodules opgenomen in Node:

[ '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' ]

Deze lijst is verkregen uit de Node-documentatie-API https://nodejs.org/api/all.html (JSON-bestand: https://nodejs.org/api/all.json ).

Alle kernmodules in één oogopslag

assert

De assert biedt een eenvoudige set assertietests die kunnen worden gebruikt om invarianten te testen.

buffer

Voorafgaand aan de introductie van TypedArray in ECMAScript 2015 (ES6), had de JavaScript-taal geen mechanisme voor het lezen of manipuleren van stromen van binaire gegevens. De klasse Buffer is geïntroduceerd als onderdeel van de Node.js API om interactie met octetstreams mogelijk te maken in de context van zaken als TCP-streams en bewerkingen van bestandssystemen.

Nu TypedArray is toegevoegd in ES6, implementeert de klasse Buffer de Uin t8Array API op een manier die meer is geoptimaliseerd en meer geschikt is voor de use cases van Uin t8Array

C / C ++ _ add

Node.js-add-ons zijn dynamisch gekoppelde gedeelde objecten, geschreven in C of C ++, die kunnen worden geladen in Node.js met behulp van de require() -functie en kunnen worden gebruikt alsof ze een gewone Node.js-module zijn. Ze worden voornamelijk gebruikt om een interface te bieden tussen JavaScript dat wordt uitgevoerd in Node.js en C / C ++ - bibliotheken.

child_process

De module child_process biedt de mogelijkheid om onderliggende processen te spawnen op een manier die vergelijkbaar is met, maar niet identiek, aan popen (3).

TROS

Een enkele instantie van Node.js wordt uitgevoerd in een enkele thread. Om te profiteren van multi-core systemen zal de gebruiker soms een cluster van Node.js-processen willen starten om de belasting af te handelen. Met de clustermodule kunt u eenvoudig onderliggende processen maken die allemaal serverpoorten delen.

troosten

De console biedt een eenvoudige foutopsporingsconsole die vergelijkbaar is met het JavaScript-consolemechanisme van webbrowsers.

crypto

De crypto biedt cryptografische functionaliteit met een set wrappers voor OpenSSL's hash-, HMAC-, codeer-, decodeer-, onderteken- en verifieerfuncties.

deprecated_apis

Node.js kan API's afschrijven wanneer: (a) het gebruik van de API als onveilig wordt beschouwd, (b) een verbeterde alternatieve API beschikbaar is gesteld, of (c) in een toekomstige belangrijke release breken van wijzigingen in de API wordt verwacht .

dns

De dns module bevat functies die tot twee verschillende categorieën behoren:

1. Functies die gebruikmaken van de onderliggende besturingssysteemfaciliteiten om naamomzetting uit te voeren en die niet noodzakelijkerwijs netwerkcommunicatie uitvoeren. Deze categorie bevat slechts één functie: dns.lookup() .
2. Functies die verbinding maken met een echte DNS-server om naamomzetting uit te voeren en die altijd het netwerk gebruiken om DNS-query's uit te voeren. Deze categorie bevat alle functies in de dns module behalve dns.lookup() .

domein

Deze module is in afwachting van afschrijving . Zodra een vervangende API is voltooid, wordt deze module volledig verouderd. De meeste eindgebruikers zouden geen reden moeten hebben om deze module te gebruiken. Gebruikers die absoluut over de functionaliteit moeten beschikken die domeinen bieden, kunnen hier voorlopig op vertrouwen, maar verwachten in de toekomst naar een andere oplossing te moeten migreren.

Evenementen

Veel van de kern-API van Node.js is gebouwd rond een idiomatische asynchrone gebeurtenisgestuurde architectuur waarin bepaalde soorten objecten ("emitters" genoemd) periodiek genoemde gebeurtenissen uitzenden die ervoor zorgen dat Function-objecten ("listeners") worden aangeroepen.

fs

File I / O wordt geleverd door eenvoudige wrappers rond standaard POSIX-functies. Om deze module te gebruiken heb je require('fs') . Alle methoden hebben asynchrone en synchrone vormen.

http

De HTTP-interfaces in Node.js zijn ontworpen om vele functies van het protocol te ondersteunen die van oudsher moeilijk te gebruiken zijn. In het bijzonder grote, mogelijk in brokken gecodeerde berichten. De interface zorgt ervoor dat nooit volledige aanvragen of antwoorden worden gebufferd - de gebruiker kan gegevens streamen.

https

HTTPS is het HTTP-protocol via TLS / SSL. In Node.js wordt dit geïmplementeerd als een afzonderlijke module.

module

Node.js heeft een eenvoudig module-laadsysteem. In Node.js staan bestanden en modules in één-op-één correspondentie (elk bestand wordt als een afzonderlijke module behandeld).

netto

De net module biedt u een asynchrone netwerk wrapper. Het bevat functies voor het maken van zowel servers als clients (streams genoemd). U kunt deze module opnemen met require('net'); .

os

De os module biedt een aantal besturingssysteemgerelateerde hulpprogramma's.

pad

Het path module bevat functies voor het werken met bestanden en directory paden.

punycode

De versie van de punycodemodule gebundeld in Node.js wordt verouderd .

querystring

De querystring biedt hulpprogramma's voor het parseren en opmaken van URL-queryreeksen.

Lees regel

De readline biedt een interface voor het één regel per keer lezen van gegevens uit een leesbare stroom (zoals process.stdin ).

REPL

De repl module biedt een Read-Eval-Print-Loop (REPL) -implementatie die beschikbaar is als een zelfstandig programma of kan worden opgenomen in andere toepassingen.

stroom

Een stream is een abstracte interface voor het werken met streaming-gegevens in Node.js. De stream biedt een basis-API waarmee u eenvoudig objecten kunt bouwen die de stream-interface implementeren.

Er zijn veel stream-objecten beschikbaar gesteld door Node.js. Een aanvraag voor een HTTP-server en process.stdout zijn bijvoorbeeld beide streaminstanties.

string_decoder

De string_decoder module voorziet een API voor het decoderen Buffer objecten in strings op een manier die domeinen gecodeerd multi-byte UTF-8 en UTF-16 tekens.

timers

De timer onthult een globale API voor planningsfuncties die in de toekomst moeten worden gebruikt. Omdat de timerfuncties globals zijn, is het niet nodig om require('timers') aan te roepen require('timers') de API te gebruiken.

De timerfuncties in Node.js implementeren een vergelijkbare API als de timers-API die wordt geleverd door webbrowsers, maar gebruiken een andere interne implementatie die is opgebouwd rond de Event Loop van Node.js.

tls_ (ssl)

De tls module biedt een implementatie van de protocollen Transport Layer Security (TLS) en Secure Socket Layer (SSL) die bovenop OpenSSL zijn gebouwd.

tracing

Trace Event biedt een mechanisme voor het centraliseren van traceringsinformatie gegenereerd door V8, Node core en userpace-code.

Traceren kan worden ingeschakeld door de --trace-events-enabled passeren bij het starten van een Node.js-toepassing.

tty

De tty module biedt de klassen tty.ReadStream en tty.WriteStream . In de meeste gevallen is het niet nodig of mogelijk om deze module direct te gebruiken.

dgram

De dgram module biedt een implementatie van UDP Datagram-sockets.

url

De url module biedt hulpprogramma's voor URL-resolutie en parsing.

util

De util module is primair ontworpen om de behoeften van de interne API's van Node.js te ondersteunen. Veel van de hulpprogramma's zijn echter ook nuttig voor ontwikkelaars van toepassingen en modules.

v8

De v8 module biedt API's die specifiek zijn voor de versie van V8 die is ingebouwd in het binaire bestand Node.js.

Opmerking : de API's en implementatie kunnen op elk moment worden gewijzigd.

vm

De vm module biedt API's voor het compileren en uitvoeren van code binnen V8 Virtual Machine-contexten. JavaScript-code kan worden gecompileerd en onmiddellijk worden uitgevoerd of gecompileerd, opgeslagen en later worden uitgevoerd.

Opmerking : de VM-module is geen beveiligingsmechanisme. Gebruik het niet om niet-vertrouwde code uit te voeren .

zlib

De zlib module biedt compressiefunctionaliteit geïmplementeerd met behulp van Gzip en Deflate / Inflate.

Een eenvoudige HTTPS-webserver in gebruik nemen!

Nadat u node.js op uw systeem hebt geïnstalleerd, kunt u gewoon de onderstaande procedure volgen om een eenvoudige webserver te laten draaien met ondersteuning voor zowel HTTP als HTTPS!

Stap 1: Bouw een certificaatautoriteit

1. maak de map waarin u uw sleutel en certificaat wilt opslaan:

   mkdir conf

2. ga naar die map:

   cd conf

3. pak dit ca.cnf bestand om te gebruiken als een configuratiesnelkoppeling:

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

4. maak een nieuwe certificaatautoriteit met behulp van deze configuratie:

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

5. Nu we onze certificaatautoriteit hebben in ca-key.pem en ca-cert.pem , laten we een privésleutel voor de server genereren:

   openssl genrsa -out key.pem 4096

6. pak dit server.cnf bestand om als configuratiesnelkoppeling te gebruiken:

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

7. genereer het certificaatverzoek met deze configuratie:

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

8. teken de aanvraag:

   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

Stap 2: Installeer uw certificaat als rootcertificaat

1. kopieer uw certificaat naar de map van uw rootcertificaten:

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

2. update CA store:

   sudo update-ca-certificates

Stap 3: Uw knooppuntserver starten

Eerst wilt u een server.js bestand maken dat uw werkelijke servercode bevat.

De minimale installatie voor een HTTPS-server in Node.js zou er ongeveer zo uitzien:

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);

Als u ook http-aanvragen wilt ondersteunen, moet u alleen deze kleine wijziging aanbrengen:

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. ga naar de map waar uw server.js zich bevindt:

   cd /path/to

2. voer server.js :

   node server.js