web-dev-qa-db-fra.com

Écoutez sur HTTP et HTTPS pour une seule application express

Puis-je créer un serveur Express à l'écoute à la fois sur HTTP et HTTPS, avec les mêmes routes et les mêmes middlewares?

Actuellement, je fais cela avec Express sur HTTP, avec stunnel tunneling HTTPS vers Express, mais je préfère une solution pure Node.

Je peux le faire avec ce code, mais en utilisant la méthode handle qui est marquée comme privée:

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 );
javascriptnode.jshttpsexpress
50
Jazz

Vous pouvez partager l'implémentation via quelque chose comme:

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);
25
Jan Jongboom

Comme une mise à jour possible de cette question, vous voudrez peut-être vérifier les modifications ici pour express 3. Le document de changement dit:

La valeur de retour de express() est une fonction JavaScript, encapsulant tout ce qui fait fonctionner une application Express. Cela signifie que vous pouvez facilement configurer les versions HTTP et HTTPS de votre application en la passant aux http.createServer() et https.createServer() du nœud:

Dans Express 3, express.createServer() est maintenant express()

Voici un exemple complet pour express 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);
36
SnapShot

Pour permettre à votre application d'écouter à la fois http et https sur les ports 80 Et 443 Respectivement, procédez comme suit

Créez une application express:

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

L'application renvoyée par express() est une fonction JavaScript. Il peut être transmis aux serveurs HTTP de Node en tant que rappel pour gérer les demandes. Cela facilite la fourniture des versions HTTP et HTTPS de votre application en utilisant la même base de code.

Vous pouvez le faire comme suit:

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

Pour plus de détails, voir doc

31
cmd

Vous pouvez utiliser express et https dans le même port.

cela fonctionne pour moi.

const express=require('express');
const app=express();
const cors=require('cors');
const path=require("path");
const routes=require('./routes/api');
const routerComplain=require('./routes/api');
const routerstores=require('./routes/api');
const routerstock=require('./routes/api');
const routerreport=require('./routes/api');
const routeritem=require('./routes/api');
const bodyParser=require('body-parser');
const routerRegister=require('./routes/api');
const mongoose=require('mongoose');
var server = require('http').Server(app);
var io = require('socket.io')(server);
require("dotenv").config();

mongoose.connect('mongodb://@@@@@@@@@@@@@@@@@',{ useNewUrlParser: true },(err)=>{
    if(!err){
        console.log('db connected')
    }else{
        console.log('error in db')
    }
});

mongoose.Promise = global.Promise;
app.use(express.static('public'));
app.use(bodyParser.json());
app.use(cors({credentials: true, Origin:'http://localhost:3000'}));
app.use(express.static(path.join(__dirname, "client", "build")))

app.use('/reg',routes);
app.use('/complain',routerComplain);
app.use('/register',routerRegister);
app.use('/stores',routerstores);
app.use('/reports',routerreport);
app.use('/stock',routerstock);
app.use('/items',routeritem);

app.get("*", (req, res) => {
    res.sendFile(path.join(__dirname, "client", "build", "index.html"));
});

io.on('connection', function (socket) {
    socket.emit('news', { hello: 'world' });
    socket.on('my other event', function (data) {
      console.log(data);
    });
  })

const port = process.env.port||4000;

server.listen(port,function(){
    console.log('now listening for request');
});
1
Charith Prasanna

Poste similaire

Puis-je configurer expressjs pour servir certaines pages sur http et d'autres sur https?

Sachez qu'express prend désormais en charge la création de serveurs Https avec:

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

Si vous souhaitez utiliser les deux ports traditionnels, l'une des solutions ci-dessus fonctionne probablement, mais en utilisant httpolyglot, vous pouvez vraiment facilement avoir http et https sur le même port avec les mêmes middlewares.

https://github.com/mscdex/httpolyglot

Voici un code squelette qui a fonctionné pour moi:

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

const options = {
    key: fs.readFileSync("/etc/ssl/certs/key"),
    cert: fs.readFileSync("/etc/ssl/certs/cer.cer")
};

httpolyglot.createServer(options, app).listen(port);

et si vous voulez le transfert http -> https, vous pouvez simplement ajouter cette fonction middleware avant l'appel createServer ():

app.use(function(req, res, next) {
    if (!req.secure ) {
            res.redirect (301, 'https://' + req.hostname + ':port' + req.originalUrl);
    }
    next();
});

Cela peut être configuré sur un port personnalisé

0
Peter Weeks