Ecoutez sur HTTP et HTTPS pour une seule application express

Puis-je créer un Express server écoute sur HTTP et HTTPS, avec les mêmes itinéraires et les mêmes middlewares?

Actuellement je le fais avec Express sur HTTP, avec stunnel de tunnel HTTPS Exprimer, mais je préfère un pur Nœud solution.

Je peux le faire avec ce code, mais à l'aide de la handle méthode est marqué comme privé:

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

Répondu succinctement ici: stackoverflow.com/a/23894573/1882064

InformationsquelleAutor Jazz | 2011-12-02

Vous pouvez partager la mise en œuvre par 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);

Belle façon de faire cela!
Cette solution est maintenant obsolète. Est-il une nouvelle solution?
Voir cmd de la solution ci-dessous. Il fonctionne avec les versions actuelles de Nœud (v4.4.2) et Express (4.13.4)

InformationsquelleAutor Jan Jongboom

Comme une possible mise à jour à cette question, vous pourriez vouloir vérifier les changements ici express 3. Le document de changement de dit:

La valeur de retour de express() est une Fonction JavaScript,
l'encapsulation de tout ce qui rend un Express app tique. Cela signifie
vous pouvez facilement configurer les protocoles HTTP et HTTPS versions de votre application par
en passant à du nœud http.createServer() et https.createServer():

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

Voici un exemple complet pour exprimer 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);

Il est préférable de répondre à une question en utilisant la même langue que le demandeur a utilisé. J'ai pris la liberté de traduire le coffeescript à la vanille JS.
Répondu succinctement ici: stackoverflow.com/a/23894573/1882064

InformationsquelleAutor SnapShot

29

Pour permettre à votre application pour écouter les deux http et https sur les ports 80 et 443 respectivement, procédez de la manière suivante

Créer un express app:
```
var express = require('express');
var app = express();
```
L'application retourné par express() est une fonction JavaScript. Il peut être transmis à Nœud serveurs HTTP comme un rappel pour traiter les demandes. Cela rend plus facile de fournir à la fois les protocoles HTTP et HTTPS versions 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 le détail voir le doc

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

InformationsquelleAutor Charith Prasanna

0

Poste similaire

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

Être conscient qui expriment désormais en charge la création de serveurs Https avec:
```
 var app = require('express').createServer({ key: ... });
```
- Je sais comment créer un serveur HTTPS, mais pas un serveur répondant à la fois sur HTTP et HTTPS.
- Avez-vous lu l'autre post? Il y a un exemple dans le post. Vous créez 2 instances de serveur et d'en faire une écoute sur le port 80 et l'autre sur 443, Http et Https.
- Oui, j'ai lu l'autre post: il y a 2 instances de serveur avec des itinéraires différents. Je veux les mêmes routes pour les deux (ou une seule instance à l'écoute sur HTTP et HTTPS).
- vous pouvez déclarer l'itinéraire fonctions séparément, puis de les utiliser pour déclarer l'itinéraire pour les deux serveurs. D'autres que je ne connais pas de moyen simple de faire ce que vous essayez de faire. Pourquoi auriez-vous besoin pour servir le même contenu sur http et https?
- Parce que ce serveur de contenu seront inclus dans les protocoles HTTP et HTTPS sites. Je peux déclarer les routes et les middlewares pour les deux serveurs, mais j'espérais que je pourrais faire mieux.
- Pas ce que je peux penser à du haut de ma tête. Désolé
- J'ai commencé par écouter les protocoles http et https, mais alors j'ai gratté l'idée et utilisé nginx pour faire des traitement de la demande (http et https) et utiliser http seule dans mon nœud de l'application. La vie beaucoup plus facile dans la production, le développement et les tests.
InformationsquelleAutor Declan Cook
0

Si vous souhaitez utiliser les deux ports, l'une des solutions ci-dessus ne fonctionne probablement, mais à l'aide de httpolyglot, vous pouvez vraiment très facilement de http et de https sur le port avec la même middlewares.

https://github.com/mscdex/httpolyglot

Voici un squelette de code 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 souhaitez http -> redirection https, vous pouvez simplement ajouter cette middleware fonction avant la createServer() appel:
```
app.use(function(req, res, next) {
if (!req.secure ) {
res.redirect (301, 'https://' + req.hostname + ':port' + req.originalUrl);
}
next();
});
```
Cela peut être réglé sur un port personnalisé

InformationsquelleAutor Peter Weeks

Vous devez vous connecter pour publier un commentaire.