Node.jsRozpoczęcie pracy z Node.js


Uwagi

Node.js to oparta na zdarzeniach, nieblokująca, asynchroniczna struktura we / wy korzystająca z silnika JavaScript V8 Google. Służy do tworzenia aplikacji, które intensywnie wykorzystują możliwość uruchamiania JavaScript zarówno po stronie klienta, jak i po stronie serwera, a zatem korzystają z możliwości ponownego użycia kodu i braku przełączania kontekstu. Jest to oprogramowanie typu open source i wieloplatformowe. Aplikacje Node.js są napisane w czystym JavaScript i mogą być uruchamiane w środowisku Node.js w systemach Windows, Linux itp.

Wersje

Wersja Data wydania
wersja 8.2.1 2017-07-20
8.2.0 2017-07-19
wersja 8.1.4 2017-07-11
8.1.3 2017-06-29
8.1.2 15.06.2017
8.1.1 13.06.2017
8.1.0 2017-06-08
8.0.0 2017-05-30
v7.10.0 02.05.2017
wersja 7.0.0 2017-04-11
v7.8.0 29.03.2017
v7.7.4 21.03.2017
v7.7.3 14.03.2017
v7.7.2 2017-03-08
v7.7.1 02.03.2017
wersja 7.0.0 28.02.2017
wersja 7.0.0 21.02.2017
wersja 7.5.0 31.01.2017
wersja 7.4.0 2017-01-04
wersja 7.3.0 2016-12-20
wersja 7.2.1 06.12.2016
wersja 7.2.0 22.11.2016
wersja 7.1.0 08.11.2016
wersja 7.0.0 2016-10-25
v6.11.0 2017-06-06
v6.10.3 02.05.2017
v6.10.2 2017-04-04
v6.10.1 21.03.2017
v6.10.0 21.02.2017
v6.9.5 31.01.2017
v6.9.4 2017-01-05
v6.9.3 2017-01-05
v6.9.2 06.12.2016
v6.9.1 19.10.2016
wersja 6.0.0 18.10.2016
v6.8.1 14.10.2016
wersja 6.0.0 2016-10-12
v6.7.0 27.09.2016
wersja 6.0.0 14.09.2016
wersja 6.0.0 26.08.2016
wersja 6.0.0 12.08.2016
wersja 6.3.1 2016-07-21
wersja 6.3.0 2016-07-06
wersja 6.2.2 16.06.2016
wersja 6.2.1 02.06.2016
wersja 6.2.0 2016-05-17
wersja 6.1.0 2016-05-05
wersja 6.0.0 26.04.2016
v5.12.0 23.06.2016
v5.11.1 2016-05-05
v5.11.0 21.04.2016
wersja 5.1.1 2016-04-05
wersja 5.10 01.04.2016
wersja 5.9 16.03.2016
wersja 5.5 2016-03-09
v5.7 23.02.2016
wersja 5.6 2016-02-09
wersja 5.5 21.01.2016
wersja 5.4 2016-01-06
wersja 5.3 2015-12-15
wersja 5.2 2015-12-09
wersja 5.1 17.11.2015
wersja 5.0 2015-10-29
wersja 4.4 08.03.2016
wersja 4.3 2016-02-09
wersja 4.2 2015-10-12
wersja 4.1 17.09.2015
wersja 4.0 08.09.2015
io.js v3.3 02.09.2015
io.js v3.2 25.08.2015
io.js v3.1 19.08.2015
io.js v3.0 2015-08-04
io.js v2.5 2015-07-28
io.js v2.4 2015-07-17
io.js v2.3 2015-06-13
io.js v2.2 01.06.2015
io.js v2.1 2015-05-24
io.js v2.0 2015-05-04
io.js v1.8 21.04.2015
io.js v1.7 17.04.2015
io.js v1.6 2015-03-20
io.js v1.5 2015-03-06
io.js v1.4 27.02.2015
io.js v1.3 2015-02-20
io.js v1.2 2015-02-11
io.js v1.1 2015-02-03
io.js v1.0 14.01.2015
v0.12 2016-02-09
v0.11 28.03.2013
v0.10 2013-03-11
v0.9 2012-07-20
v0.8 22.06.2012
v0.7 17.01.2012
v0.6 2011-11-04
v0.5 26.08.2011
wersja 0.4 26.08.2011
wersja 0.3 26.08.2011
wersja 0.2 26.08.2011
v0.1 26.08.2011

Serwer HTTP Hello World

Najpierw zainstaluj Node.js na swojej platformie.

W tym przykładzie utworzymy serwer HTTP nasłuchujący na porcie 1337, który wysyła Hello, World! do przeglądarki. Zauważ, że zamiast korzystać z portu 1337, możesz użyć dowolnego numeru portu, który obecnie nie jest używany przez żadną inną usługę.

Moduł http to moduł podstawowy Node.js (moduł zawarty w źródle Node.js, który nie wymaga instalowania dodatkowych zasobów). Moduł http zapewnia funkcję tworzenia serwera HTTP przy użyciu metody http.createServer() . Aby utworzyć aplikację, utwórz plik zawierający następujący kod JavaScript.

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
 

Zapisz plik pod dowolną nazwą. W takim przypadku, jeśli hello.js go hello.js , możemy uruchomić aplikację, przechodząc do katalogu, w którym znajduje się plik i używając następującej komendy:

node hello.js
 

Do utworzonego serwera można uzyskać dostęp za pomocą adresu URL http: // localhost: 1337 lub http://127.0.0.1:1337 w przeglądarce.

Pojawi się prosta strona internetowa z napisem „Hello, World!” tekst u góry, jak pokazano na zrzucie ekranu poniżej.

Zrzut ekranu

Przykład edytowalny online.

Moduły podstawowe

Node.js to silnik Javascript (silnik Google V8 dla Chrome, napisany w C ++), który pozwala na uruchomienie Javascript poza przeglądarką. Chociaż dostępnych jest wiele bibliotek do rozszerzania funkcjonalności Node, silnik jest wyposażony w zestaw podstawowych modułów implementujących podstawowe funkcje.

Obecnie w węźle znajdują się 34 podstawowe moduły:

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

Ta lista została uzyskana z interfejsu API dokumentacji węzła https://nodejs.org/api/all.html (plik JSON: https://nodejs.org/api/all.json ).

Wszystkie moduły podstawowe w skrócie

zapewniać

assert Moduł zapewnia prosty zestaw testów twierdzenie, że mogą być używane do niezmienników testowych.

bufor

Przed wprowadzeniem TypedArray w ECMAScript 2015 (ES6) język JavaScript nie miał mechanizmu odczytu ani manipulowania strumieniami danych binarnych. Klasa Buffer została wprowadzona jako część interfejsu API Node.js, aby umożliwić interakcję ze strumieniami oktetów w kontekście takich rzeczy, jak strumienie TCP i operacje systemu plików.

Teraz, TypedArray został dodany w ES6, że Buffer klasa implementuje Uin t8Array API w sposób, który jest bardziej zoptymalizowany i nadaje się do przypadków użycia node.js'.

c / c ++ _ dodatki

Dodatki Node.js to dynamicznie połączone obiekty współdzielone, napisane w C lub C ++, które można załadować do Node.js za pomocą funkcji require() i używać tak, jakby były zwykłym modułem Node.js. Służą one przede wszystkim do zapewnienia interfejsu między JavaScript działającym w Node.js a bibliotekami C / C ++.

child_process

Moduł child_process zapewnia możliwość odradzania procesów potomnych w sposób podobny, ale nie identyczny, do popen (3).

grupa

Pojedyncze wystąpienie Node.js działa w jednym wątku. Aby skorzystać z systemów wielordzeniowych, użytkownik czasami chce uruchomić klaster procesów Node.js w celu obsługi obciążenia. Moduł klastra umożliwia łatwe tworzenie procesów potomnych, które współużytkują porty serwera.

konsola

Moduł console zapewnia prostą konsolę debugowania podobną do mechanizmu konsoli JavaScript udostępnianego przez przeglądarki internetowe.

krypto

crypto Moduł udostępnia funkcje kryptograficzne, które zawiera zestaw opakowań dla hash OpenSSL, HMAC, szyfrem, rozszyfrować, podpisać i zweryfikować funkcje.

przestarzałe_apis

Node.js może wycofać interfejsy API, gdy: (a) użycie interfejsu API zostanie uznane za niebezpieczne, (b) udostępniono ulepszoną alternatywną wersję interfejsu API lub (c) oczekiwane są zmiany w interfejsie API w przyszłej głównej wersji .

dns

Moduł dns zawiera funkcje należące do dwóch różnych kategorii:

  1. Funkcje, które używają podstawowych funkcji systemu operacyjnego do rozpoznawania nazw i które niekoniecznie wykonują komunikację sieciową. Ta kategoria zawiera tylko jedną funkcję: dns.lookup() .
  2. Funkcje, które łączą się z rzeczywistym serwerem DNS w celu rozpoznawania nazw i które zawsze używają sieci do wykonywania zapytań DNS. Ta kategoria zawiera wszystkie funkcje w module dns oprócz dns.lookup() .

domena

Ten moduł oczekuje na wycofanie . Po sfinalizowaniu zastępczego interfejsu API ten moduł będzie całkowicie przestarzały. Większość użytkowników końcowych nie powinna mieć powodu, aby korzystać z tego modułu. Użytkownicy, którzy absolutnie muszą mieć funkcje zapewniane przez domeny, mogą na razie na nich polegać, ale powinni spodziewać się, że w przyszłości będą musieli przejść na inne rozwiązanie.

Wydarzenia

Duża część podstawowego interfejsu API Node.js jest zbudowana wokół idiomatycznej architektury asynchronicznej sterowanej zdarzeniami, w której niektóre rodzaje obiektów (zwane „emiterami”) okresowo emitują nazwane zdarzenia, które powodują wywoływanie obiektów funkcji („nasłuchujących”).

fs

Plikowe operacje wejścia / wyjścia są dostarczane przez proste opakowania wokół standardowych funkcji POSIX. Aby użyć tego modułu, require('fs') . Wszystkie metody mają formy asynchroniczne i synchroniczne.

http

Interfejsy HTTP w Node.js są zaprojektowane do obsługi wielu funkcji protokołu, które były tradycyjnie trudne w użyciu. W szczególności duże, prawdopodobnie zakodowane fragmentami wiadomości. Interfejs jest ostrożny, aby nigdy nie buforować całych żądań lub odpowiedzi - użytkownik może przesyłać strumieniowo dane.

https

HTTPS to protokół HTTP przez TLS / SSL. W Node.js jest to zaimplementowane jako osobny moduł.

moduł

Node.js ma prosty system ładowania modułów. W Node.js pliki i moduły są w korespondencji jeden do jednego (każdy plik jest traktowany jako osobny moduł).

netto

Moduł net zapewnia asynchroniczne opakowanie sieciowe. Zawiera funkcje tworzenia zarówno serwerów, jak i klientów (zwane strumieniami). Możesz dołączyć ten moduł z require('net'); .

os

Moduł os zapewnia szereg metod związanych z systemem operacyjnym.

ścieżka

Moduł path zapewnia narzędzia do pracy ze ścieżkami plików i katalogów.

punycode

Wersja modułu punycode zawartego w Node.js jest przestarzała .

querystring

Moduł querystring zapewnia narzędzia do analizowania i formatowania ciągów zapytań adresów URL.

Czytaj linię

Moduł readline zapewnia interfejs do odczytu danych ze strumienia do odczytu (takiego jak process.stdin ) po jednej linii na raz.

repl

Moduł repl zapewnia implementację Read-Eval-Print-Loop (REPL), która jest dostępna zarówno jako samodzielny program, jak i dostępna w innych aplikacjach.

strumień

Strumień to abstrakcyjny interfejs do pracy ze strumieniowymi danymi w Node.js. Moduł stream zapewnia podstawowy interfejs API, który ułatwia budowanie obiektów implementujących interfejs strumienia.

Istnieje wiele obiektów strumienia udostępnianych przez Node.js. Na przykład żądanie do serwera HTTP i process.stdout są instancjami strumieniowymi.

ciąg_dekodera

Moduł string_decoder zapewnia interfejs API do dekodowania obiektów Buffer na ciągi znaków w sposób, który zachowuje zakodowane wielobajtowe znaki UTF-8 i UTF-16.

timery

Moduł timer udostępnia globalny interfejs API do wywoływania funkcji planowania, które będą wywoływane w przyszłości. Ponieważ funkcje timera są globalne, nie ma potrzeby wywoływania require('timers') do korzystania z API.

Funkcje timera w Node.js implementują podobny interfejs API, jak API timerów dostarczane przez przeglądarki internetowe, ale używają innej wewnętrznej implementacji zbudowanej wokół pętli zdarzeń Node.js.

tls_ (ssl)

Moduł tls zapewnia implementację protokołów Transport Layer Security (TLS) i Secure Socket Layer (SSL), które są zbudowane na OpenSSL.

rysunek kalkowy

Zdarzenie śledzenia zapewnia mechanizm scentralizowania informacji o śledzeniu generowanych przez V8, rdzeń węzła i kod przestrzeni użytkownika.

Śledzenie można włączyć, przekazując --trace-events-enabled podczas uruchamiania aplikacji --trace-events-enabled

tty

Moduł tty zapewnia klasy tty.ReadStream i tty.WriteStream . W większości przypadków bezpośrednie użycie tego modułu nie będzie konieczne ani możliwe.

dgram

Moduł dgram zapewnia implementację gniazd datagramowych UDP.

URL

Moduł url zapewnia narzędzia do rozpoznawania i analizowania adresów URL.

util

Moduł util został zaprojektowany przede wszystkim do obsługi wewnętrznych interfejsów API Node.js. Jednak wiele narzędzi jest przydatnych także dla programistów aplikacji i modułów.

wersja 8

Moduł v8 udostępnia interfejsy API specyficzne dla wersji V8 wbudowanej w plik binarny Node.js.

Uwaga : Interfejsy API i implementacja mogą ulec zmianie w dowolnym momencie.

vm

Moduł vm zapewnia interfejsy API do kompilowania i uruchamiania kodu w kontekście maszyn wirtualnych V8. Kod JavaScript można skompilować i uruchomić natychmiast lub skompilować, zapisać i uruchomić później.

Uwaga : moduł VM nie jest mechanizmem bezpieczeństwa. Nie używaj go do uruchamiania niezaufanego kodu .

zlib

Moduł zlib zapewnia funkcjonalność kompresji za pomocą Gzip i Deflate / Inflate.

Debugowanie aplikacji NodeJS

Możesz użyć inspektora węzłów. Uruchom to polecenie, aby zainstalować go za pomocą npm:

npm install -g node-inspector
 

Następnie możesz debugować aplikację za pomocą

node-debug app.js
 

Repozytorium Github można znaleźć tutaj: https://github.com/node-inspector/node-inspector


Debugowanie natywnie

Możesz również debugować plik node.js natywnie, uruchamiając go w następujący sposób:

node debug your-script.js
 

Aby przerwać debugowanie dokładnie w żądanej linii kodu, użyj tego:

debugger;
 

Aby uzyskać więcej informacji, zobacz tutaj .

W node.js 8 użyj następującego polecenia:

node --inspect-brk your-script.js
 

Następnie otwórz about://inspect w najnowszej wersji Google Chrome i wybierz skrypt Node, aby uzyskać debugowanie w Chrome DevTools.

Wdrażanie aplikacji online

Podczas wdrażania aplikacji w środowisku hostowanym (specyficznym dla Node.js), środowisko to zwykle oferuje zmienną środowiskową PORT , za pomocą której można uruchamiać serwer. Zmiana numeru portu na process.env.PORT umożliwia dostęp do aplikacji.

Na przykład,

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

Ponadto, jeśli chcesz uzyskać dostęp do tego trybu offline podczas debugowania, możesz użyć tego:

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

gdzie 3000 to numer portu offline.

Podstawowy routing Hello World

Gdy zrozumiesz, jak utworzyć serwer HTTP z węzłem, ważne jest, aby zrozumieć, jak „robić” rzeczy w oparciu o ścieżkę, do której nawigował użytkownik. Zjawisko to nazywa się „routingiem”.

Najbardziej podstawowym przykładem tego jest sprawdzenie, if (request.url === 'some/path/here') , a następnie wywołanie funkcji, która odpowiada nowym plikiem.

Przykład tego można zobaczyć tutaj:

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

Jeśli nadal będziesz definiować swoje „trasy” w ten sposób, skończysz z jedną ogromną funkcją oddzwaniania, a my nie chcemy takiego gigantycznego bałaganu, więc zobaczmy, czy możemy to wyczyścić.

Najpierw przechowujmy wszystkie nasze trasy w obiekcie:

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

Teraz, gdy mamy zapisane 2 trasy w obiekcie, możemy je teraz sprawdzić w naszym głównym wywołaniu zwrotnym:

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

Teraz za każdym razem, gdy spróbujesz poruszać się po swojej witrynie, sprawdzi ona istnienie tej ścieżki na twoich trasach i wywoła odpowiednią funkcję. Jeśli nie zostanie znaleziona żadna trasa, serwer odpowie 404 (Nie znaleziono).

I gotowe - routing za pomocą interfejsu API serwera HTTP jest bardzo prosty.

Linia poleceń Hello World

Node.js można także wykorzystać do tworzenia narzędzi wiersza poleceń. Poniższy przykład czyta pierwszy argument z wiersza poleceń i wyświetla komunikat Hello.

Aby uruchomić ten kod w systemie Unix:

  1. Utwórz nowy plik i wklej poniższy kod. Nazwa pliku nie ma znaczenia.
  2. Udostępnij ten plik jako chmod 700 FILE_NAME
  3. Uruchom aplikację z ./APP_NAME David

W systemie Windows wykonaj krok 1 i uruchom go z 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);
 

Witaj świecie w REPL

Po wywołaniu bez argumentów, Node.js uruchamia REPL (Read-Eval-Print-Loop) znany również jako „ powłoka węzła ”.

W wierszu polecenia wpisz node .

$ node
>
 

W wierszu powłoki Node > wpisz „Hello World!”

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

Hello World with Express

W poniższym przykładzie użyto Express do utworzenia serwera HTTP nasłuchującego na porcie 3000, który odpowiada „Witaj, świecie!”. Express to powszechnie używana platforma internetowa, która jest przydatna do tworzenia interfejsów API HTTP.

Najpierw utwórz nowy folder, np. myApp . Przejdź do myApp i utwórz nowy plik JavaScript zawierający następujący kod ( hello.js go na przykład hello.js ). Następnie zainstaluj moduł ekspresowy za pomocą npm install --save express z wiersza poleceń. Więcej informacji na temat instalowania pakietów można znaleźć w tej dokumentacji .

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

W wierszu polecenia uruchom następujące polecenie:

node hello.js
 

Otwórz przeglądarkę i przejdź do http://localhost:3000 lub http://127.0.0.1:3000 aby zobaczyć odpowiedź.

Aby uzyskać więcej informacji o frameworku Express, możesz sprawdzić sekcję Aplikacje internetowe z Express

Jak uruchomić podstawowy serwer HTTPS!

Po zainstalowaniu node.js w systemie, wystarczy wykonać poniższą procedurę, aby uzyskać podstawowy serwer WWW działający z obsługą zarówno HTTP, jak i HTTPS!



Krok 1: Zbuduj ośrodek certyfikacji

  1. utwórz folder, w którym chcesz przechowywać swój klucz i certyfikat:

    mkdir conf


  1. przejdź do tego katalogu:

    cd conf


  1. ca.cnf ten plik ca.cnf , aby użyć go jako skrótu konfiguracji:

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


  1. utwórz nowy urząd certyfikacji przy użyciu tej konfiguracji:

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


  1. teraz, gdy mamy nasz urząd certyfikacji w ca-key.pem i ca-cert.pem , wygenerujmy klucz prywatny dla serwera:

    openssl genrsa -out key.pem 4096


  1. pobierz ten plik server.cnf , aby użyć go jako skrótu konfiguracji:

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


  1. wygeneruj żądanie podpisania certyfikatu przy użyciu tej konfiguracji:

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


  1. podpisać wniosek:

    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



Krok 2: Zainstaluj certyfikat jako certyfikat główny

  1. skopiuj swój certyfikat do folderu głównego certyfikatów:

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


  1. zaktualizuj sklep CA:

    sudo update-ca-certificates



Krok 3: Uruchomienie serwera węzła

Najpierw chcesz utworzyć plik server.js zawierający rzeczywisty kod serwera.

Minimalna konfiguracja serwera HTTPS w Node.js wyglądałaby mniej więcej tak:

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

Jeśli chcesz również obsługiwać żądania HTTP, musisz wprowadzić tylko małą modyfikację:

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. przejdź do katalogu, w którym znajduje się twoja server.js :

    cd /path/to


  1. uruchom server.js :

    node server.js

Instalowanie i uruchamianie Node.js

Aby rozpocząć, zainstaluj Node.js na komputerze programisty.

Windows: przejdź do strony pobierania i pobierz / uruchom instalator.

Mac: przejdź do strony pobierania i pobierz / uruchom instalator. Alternatywnie można zainstalować Węzeł za pomocą Homebrew przy użyciu brew install node . Homebrew to menedżer pakietów wiersza poleceń dla komputerów Macintosh, a więcej informacji na ten temat można znaleźć na stronie internetowej Homebrew .

Linux: Postępuj zgodnie z instrukcjami dla swojej dystrybucji na stronie instalacji wiersza poleceń .


Uruchamianie programu węzłów

Aby uruchomić program Node.js, wystarczy uruchomić node app.js lub nodejs app.js , gdzie app.js to nazwa pliku źródłowego aplikacji węzła. Nie musisz dołączać sufiksu .js aby Node znalazł skrypt, który chcesz uruchomić.

Alternatywnie w systemach operacyjnych UNIX program Node może być wykonywany jako skrypt terminala. Aby to zrobić, należy zacząć od fragmentu wskazującego na interpreter węzła, takiego jak węzeł #!/usr/bin/env node . Plik musi być również ustawiony jako wykonywalny, co można zrobić za pomocą chmod . Teraz skrypt można uruchomić bezpośrednio z wiersza poleceń.

Gniazdo TLS: serwer i klient

Jedynymi głównymi różnicami między tym a zwykłym połączeniem TCP są klucz prywatny i certyfikat publiczny, które trzeba ustawić w obiekt opcji.

Jak utworzyć klucz i certyfikat

Pierwszym krokiem w tym procesie bezpieczeństwa jest utworzenie klucza prywatnego. A czym jest ten klucz prywatny? Zasadniczo jest to zestaw losowych szumów używanych do szyfrowania informacji. Teoretycznie możesz utworzyć jeden klucz i użyć go do szyfrowania czegokolwiek chcesz. Ale najlepszą praktyką jest posiadanie różnych kluczy do określonych rzeczy. Ponieważ jeśli ktoś ukradnie twój klucz prywatny, jest to podobne do tego, że ktoś ukradnie twoje klucze do domu. Wyobraź sobie, że użyłeś tego samego klucza do zamknięcia samochodu, garażu, biura itp.

openssl genrsa -out private-key.pem 1024

Po uzyskaniu klucza prywatnego możemy utworzyć CSR (żądanie podpisania certyfikatu), które jest naszą prośbą o podpisanie klucza prywatnego przez fantazyjny organ. Dlatego musisz wprowadzić informacje związane z Twoją firmą. Informacje te będą widoczne dla organu podpisującego i wykorzystane do weryfikacji użytkownika. W naszym przypadku nie ma znaczenia, co wpiszesz, ponieważ w następnym kroku sami podpiszemy nasz certyfikat.

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

Teraz, gdy mamy już wypełnioną papierkową robotę, czas udawać, że jesteśmy świetnym autorytetem do podpisywania umów.

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

Teraz, gdy masz klucz prywatny i publiczny certyfikat, możesz ustanowić bezpieczne połączenie między dwiema aplikacjami NodeJS. Jak widać w przykładowym kodzie, jest to bardzo prosty proces.

Ważny!

Ponieważ sami stworzyliśmy publiczny certyfikat, szczerze mówiąc, nasz certyfikat jest bezwartościowy, ponieważ jesteśmy nikim. Serwer NodeJS domyślnie nie ufa takiemu certyfikatowi i dlatego musimy powiedzieć mu, aby faktycznie ufał naszemu certyfikatowi za pomocą następującej opcji odrzucaniaUnieautoryzowane: fałszywe. Bardzo ważne : nigdy nie ustawiaj tej zmiennej na true w środowisku produkcyjnym.

Serwer gniazd TLS

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

});
 

Klient gniazda TLS

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

});