Napotkałem podobny problem z uruchomieniem SSL na porcie innym niż port 443. W moim przypadku miałem certyfikat pakietu, a także certyfikat i klucz. Węzeł wymaga rozbicia tych certyfikatów na oddzielne elementy tablicy.

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

    var options = {
      ca: [fs.readFileSync(PATH_TO_BUNDLE_CERT_1), fs.readFileSync(PATH_TO_BUNDLE_CERT_2)],
      cert: fs.readFileSync(PATH_TO_CERT),
      key: fs.readFileSync(PATH_TO_KEY)
    };

    app = express()

    app.get('/', function(req,res) {
        res.send('hello');
    });

    var server = https.createServer(options, app);

    server.listen(8001, function(){
        console.log("server running at https://IP_ADDRESS:8001/")
    });

W aplikacji.js musisz określić https i odpowiednio utworzyć serwer. Upewnij się również, że port, którego próbujesz użyć, umożliwia ruch przychodzący.

Łącznie Z Punktami:

1. konfiguracja SSL
   1. W config / local.js
   2. W config / env / production.js

Obsługa HTTP i WS

1. Aplikacja musi działać na HTTP w rozwoju, więc możemy łatwo debugować nasze app.
2. Aplikacja musi działać na https w produkcji ze względu na bezpieczeństwo.
3. żądanie HTTP produkcji aplikacji powinno zawsze przekierowywać na https.

Konfiguracja SSL

W Sailsjs są dwa sposoby skonfiguruj wszystkie rzeczy, najpierw należy skonfigurować w folderze config z każdym z nich ma swoje oddzielne pliki (np. połączenie z bazą danych dotyczące ustawień leży w połączeniach.js). Druga to konfiguracja na bazie środowiska, każdy plik środowiska prezentuje się w folderze config/env, a każdy plik zawiera ustawienia dla konkretnego env.

Sails najpierw szuka w folderze config / env, a następnie oczekuje na config/*.js

teraz pozwala ustawić ssl w config/local.js.

var local = {
   port: process.env.PORT || 1337,
   environment: process.env.NODE_ENV || 'development'
};

if (process.env.NODE_ENV == 'production') {
    local.ssl = {
        secureProtocol: 'SSLv23_method',
        secureOptions: require('constants').SSL_OP_NO_SSLv3,
        ca: require('fs').readFileSync(__dirname + '/path/to/ca.crt','ascii'),
        key: require('fs').readFileSync(__dirname + '/path/to/jsbot.key','ascii'),
        cert: require('fs').readFileSync(__dirname + '/path/to/jsbot.crt','ascii')
    };
    local.port = 443; // This port should be different than your default port
}

module.exports = local;

Alternatywę możesz dodać w config/env / production.js też. (Ten fragment pokazuje również, jak obsługiwać wiele certi CARoot)

Lub w produkcja.js

module.exports = {
    port: 443,
    ssl: {
        secureProtocol: 'SSLv23_method',
        secureOptions: require('constants').SSL_OP_NO_SSLv3,
        ca: [
            require('fs').readFileSync(__dirname + '/path/to/AddTrustExternalCARoot.crt', 'ascii'),
            require('fs').readFileSync(__dirname + '/path/to/COMODORSAAddTrustCA.crt', 'ascii'),
            require('fs').readFileSync(__dirname + '/path/to/COMODORSADomainValidationSecureServerCA.crt', 'ascii')
        ],
        key: require('fs').readFileSync(__dirname + '/path/to/jsbot.key', 'ascii'),
        cert: require('fs').readFileSync(__dirname + '/path/to/jsbot.crt', 'ascii')
    }
};

Http/https & ws / wss przekierowanie

Tutaj ws to gniazdo sieciowe, a wss reprezentuje bezpieczne gniazdo sieciowe, ponieważ skonfigurowaliśmy ssl, a teraz http i WS oba żądania stają się bezpieczne i przekształcają się odpowiednio w https i wss.

Są wiele źródeł z naszej aplikacji otrzyma żądanie jak każdy post na blogu, post w mediach społecznościowych, ale nasz serwer działa tylko na https, więc gdy jakiekolwiek żądanie pochodzi z http, daje błąd "ta strona nie może być osiągnięta" w przeglądarce klienta. I tracimy ruch na naszej stronie. Więc musimy przekierować żądanie http do https, te same zasady pozwalają na websocket inaczej Gniazdo zawiedzie.

Musimy więc uruchomić ten sam serwer na porcie 80 (http) i przekierować wszystkie żądania na port 443(https). Sails najpierw skompiluje config/bootstrap.js plik przed podniesieniem serwera. Tutaj możemy uruchomić nasz serwer express na porcie 80.

W config/bootstrap.js (Utwórz serwer http i przekieruj wszystkie żądania na https)

module.exports.bootstrap = function(cb) {
    var express = require("express"),
        app = express();

    app.get('*', function(req, res) {  
        if (req.isSocket) 
            return res.redirect('wss://' + req.headers.host + req.url)  

        return res.redirect('https://' + req.headers.host + req.url)  
    }).listen(80);
    cb();
};

Teraz możesz odwiedzić http://www.yourdomain.com , przekieruje na https://www.yourdomain.com

Tak to dla mnie działa. Użyte przekierowanie przekieruje również cały normalny http.

const express = require('express');
const bodyParser = require('body-parser');
const path = require('path');
const http = require('http');
const app = express();
var request = require('request');
//For https
const https = require('https');
var fs = require('fs');
var options = {
  key: fs.readFileSync('certificates/private.key'),
  cert: fs.readFileSync('certificates/certificate.crt'),
  ca: fs.readFileSync('certificates/ca_bundle.crt')
};

// API file for interacting with MongoDB
const api = require('./server/routes/api');

// Parsers
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));

// Angular DIST output folder
app.use(express.static(path.join(__dirname, 'dist')));

// API location
app.use('/api', api);

// Send all other requests to the Angular app
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'dist/index.html'));
});
app.use(function(req,resp,next){
  if (req.headers['x-forwarded-proto'] == 'http') {
      return resp.redirect(301, 'https://' + req.headers.host + '/');
  } else {
      return next();
  }
});


http.createServer(app).listen(80)
https.createServer(options, app).listen(443);

Użyj greenlock-express: darmowy SSL, zautomatyzowany HTTPS

Greenlock obsługuje wydawanie i odnawianie certyfikatów (za pomocą Let ' s Encrypt) oraz przekierowanie http = > https, gotowe do użycia.

express-app.js:

var express = require('express');
var app = express();

app.use('/', function (req, res) {
  res.send({ msg: "Hello, Encrypted World!" })
});

// DO NOT DO app.listen()
// Instead export your app:
module.exports = app;

server.js:

require('greenlock-express').create({
  // Let's Encrypt v2 is ACME draft 11
  version: 'draft-11'
, server: 'https://acme-v02.api.letsencrypt.org/directory'

  // You MUST change these to valid email and domains
, email: '[email protected]'
, approveDomains: [ 'example.com', 'www.example.com' ]
, agreeTos: true
, configDir: "/path/to/project/acme/"

, app: require('./express-app.j')

, communityMember: true // Get notified of important updates
, telemetry: true       // Contribute telemetry data to the project
}).listen(80, 443);

Screencast

Obejrzyj prezentację QuickStart: https://youtu.be/e8vaR4CEZ5s

Dla Localhost

Nie możesz mieć certyfikatów SSL na localhost. Możesz jednak użyć czegoś w rodzaju Telebit , który pozwoli Ci uruchamiać lokalne aplikacje jako prawdziwe.

Możesz również używać domen prywatnych z Greenlock poprzez wyzwania DNS-01, o których mowa w README wraz z różnymi wtyczkami, które go obsługują.

Porty niestandardowe (tj. nr 80 / 443)

Przeczytaj powyższą notatkę o localhost - nie możesz używać niestandardowych portów z Let ' s Encrypt ani jedno, ani drugie.

Możesz jednak ujawnić swoje wewnętrzne niestandardowe porty jako zewnętrzne standardowe porty poprzez port-forward, SNI-route lub użyć czegoś takiego jak Telebit, który robi SNI-routing i przekierowanie / przekazywanie portów dla Ciebie.

Możesz również użyć wyzwań DNS-01, w którym to przypadku nie będziesz musiał w ogóle ujawniać portów i możesz również zabezpieczyć domeny w sieciach prywatnych w ten sposób.

This is my Kodeks Pracy na express 4.0.

Express 4.0 bardzo różni się od 3.0 i innych.

4.0 Masz plik / bin / www, który dodasz tutaj https.

"npm start" jest standardowym sposobem uruchamiania serwera express 4.0.

Funkcja ReadFileSync() powinna używać __dirname get current directory

While require() Użyj ./ Zobacz aktualne katalog.

najpierw zrób to prywatnie.kluczowe i publiczne.plik cert w folderze / bin, Jest to ten sam folder co plik WWW.

Najpierw przejdź do Utwórz samodzielnie podpisany certyfikat SSL

• Idź do terminala i uruchom następujące polecenie.

Sudo openssl req-x509-nodes-days 365-newkey rsa: 2048-keyout ./ align = "left" / klucz-out własny podpis.crt

• i umieścić następujące informacje
• Nazwa kraju (2-literowy kod) [AU]: US
• Nazwa stanu lub prowincji (pełna nazwa) [Some-State]: NY
• nazwa miejscowości (np. miasto) []: NY
• Nazwa organizacji (np. firma) [Internet Widgits Pty Ltd]: xyz (Twoja - organizacja)
• Nazwa jednostki organizacyjnej (np. sekcja) []: xyz (Nazwa Twojej jednostki)
• Nazwa zwyczajowa (np. serwer FQDN lub Twoja nazwa) []: www.xyz.com (Twój URL)
• adres e-mail []: twój e-mail

Po utworzeniu Dodaj plik key & cert w swoim kodzie, mój plik bin/www wygląda na przykład.

     var app = require('../app'); 
    var debug = require('debug')('driftApp:server');
    //var http = require('http');
    var http = require('https');
    var fs = require('fs');

    var key = fs.readFileSync(__dirname + '/../certs/selfsigned.key');
    var cert = fs.readFileSync(__dirname + '/../certs/selfsigned.crt');
    var options = {
     key: key,
     cert: cert
    };

    var port = normalizePort(process.env.PORT || '3000');
    app.set('port', port);
    console.log("Server Started On Port: ", port);
    //var server = http.createServer(app);
    var server = http.createServer(options, app);
    server.listen(port);
    server.on('error', onError);
    server.on('listening', onListening);
    function normalizePort(val) {
    var port = parseInt(val, 10);

    if (isNaN(port)) {
     // named pipe
     return val;
    }
    if (port >= 0) {
     // port number
     return port;
    }
    return false;
    }
    function onError(error) {
    if (error.syscall !== 'listen') {
     throw error;
    }
    var bind = typeof port === 'string' ?
     'Pipe ' + port :
     'Port ' + port;
    // handle specific listen errors with friendly messages
    switch (error.code) {
     case 'EACCES':
        console.error(bind + ' requires elevated privileges');
        process.exit(1);
        break;
     case 'EADDRINUSE':
        console.error(bind + ' is already in use');
        process.exit(1);
        break;
     default:
        throw error;
      }
     }
    function onListening() {
    var addr = server.address();
    var bind = typeof addr === 'string' ?
     'pipe ' + addr :
     'port ' + addr.port;
     debug('Listening on ' + bind);
    }

• wreszcie uruchomić aplikację przy użyciu https