Ascolta su HTTP e HTTPS per una singola app express

Question

Posso creare un server Express in ascolto sia su HTTP che su HTTPS, con le stesse route e gli stessi middleware?

Attualmente lo faccio con Express su HTTP, con stunnel tunneling HTTPS per Express, ma preferisco una soluzione di nodo puro.

posso farlo con questo codice, ma con il metodo handle che è contrassegnato come privato:

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

var app = express.createServer(); 
// init routes and middlewares 
app.listen(80); 

var privateKey = fs.readFileSync('privatekey.pem').toString(); 
var certificate = fs.readFileSync('certificate.pem').toString(); 
var options = {key: privateKey, cert: certificate}; 
https.createServer(options, function(req,res) 
{ 
    app.handle(req, res); 
}).listen(443); 

Answer 1

È possibile condividere l'applicazione via qualcosa come:

var register = function (app) { 
    // config middleware 
    app.configure({ 

    }); 

    // config routes 
    app.get(...); 
}; 

var http = express.createServer(); 
register(http); 
http.listen(80); 

var https = express.createServer({ key: /* https properties */ }); 
register(https); 
https.listen(443); 

Answer 2

post simile

Can I configure expressjs to serve some pages over http and others over https?

essere consapevoli del fatto che esprimono ora supporta la creazione di HTTPS con:

var app = require('express').createServer({ key: ... }); 

Answer 3

Come un eventuale aggiornamento a questa domanda, si potrebbe voler controllare i cambiamenti here per Express 3. Il documento di cambiamento dice:

Il il valore di ritorno di express() è una funzione JavaScript, che incapsula tutto ciò che fa spuntare un'app Express. Questo significa puoi versioni facilmente configurare HTTP e HTTPS della vostra applicazione di passarlo al nodo di http.createServer() e https.createServer():

In Espresso 3, express.createServer() è ora express()

Ecco un esempio completo per espresso 3 :

var fs = require('fs') 
    , https = require('https') 
    , http = require('http') 
    , express = require('express') 
    , keys_dir = 'keys/' 
    , server_options = { 
     key : fs.readFileSync(keys_dir + 'privatekey.pem'), 
     ca : fs.readFileSync(keys_dir + 'certauthority.pem'), 
     cert : fs.readFileSync(keys_dir + 'certificate.pem') 
     } 
    , app = express(); 
app.configure(function(){ 
    app.use(express.cookieParser()); 
    app.use(express.bodyParser()); 
    app.use(express.methodOverride()); 
    app.use(express.session({ secret: '' })); 
    app.use(app.router); 
}); 
app.configure('development',function(){ 
    app.use(express.static(__dirname + '/public')); 
    app.use(express.errorHandler({dumpExceptions: true, showStack:true})); 
    app.set('view options', { pretty: true }); 
}); 
app.get('/', function(req, res){ 
    res.send('Hello World!'); 
}); 
https.createServer(server_options,app).listen(7000); 
http.createServer(app).listen(8000); 

Answer 4

per consentire la vostra applicazione per ascoltare sia per http e https sulle porte 80 e 443, rispettivamente, effettuare le seguenti operazioni

Creare un app espresso:

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

L'applicazione restituito da express() è una funzione JavaScript. Può essere passato ai server HTTP del nodo come richiamo per gestire le richieste. Ciò semplifica la fornitura delle versioni HTTP e HTTPS della tua app utilizzando la stessa base di codice.

È possibile farlo nel modo seguente:

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

var options = { 
    key: fs.readFileSync('/path/to/key.pem'), 
    cert: fs.readFileSync('/path/to/cert.pem') 
}; 

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

Per dettagli completi vedere il doc