Heroku NodeJS http zu https ssl erzwungene Weiterleitung

Ich habe eine Anwendung auf Heroku mit Express auf Knoten mit https. Wie identifiziere ich das Protokoll, um eine Umleitung zu https mit nodejs auf heroku zu erzwingen?

Meine App ist nur ein einfacher http-Server. Sie erkennt (noch) nicht, dass Heroku https-Anfragen sendet:

/* Heroku provides the port they want you on in this environment variable (hint: it's not 80) */
app.listen(process.env.PORT || 3000);

Ab heute, dem 10. Oktober 2014 , mit Heroku Cedar Stack und ExpressJS ~ 3.4.4 , ist hier ein funktionierender Satz von Code.

Die Hauptsache, an die wir uns erinnern sollten, ist, dass wir Heroku einsetzen. Die SSL-Beendigung erfolgt am Load Balancer, bevor der verschlüsselte Datenverkehr Ihre Knoten-App erreicht. Es ist möglich zu testen, ob https verwendet wurde, um die Anforderung mit req.headers ['x-forwarded-proto'] === 'https' zu stellen .

Wir müssen uns nicht darum kümmern, lokale SSL-Zertifikate in der App usw. zu haben, wie Sie es vielleicht tun, wenn Sie in anderen Umgebungen hosten. Sie sollten jedoch zuerst ein SSL-Add-On über Heroku-Add-Ons anwenden lassen, wenn Sie Ihr eigenes Zertifikat, Ihre eigenen Subdomains usw. verwenden.

Fügen Sie dann einfach Folgendes hinzu, um die Umleitung von etwas anderem als HTTPS zu HTTPS durchzuführen. Dies kommt der oben akzeptierten Antwort sehr nahe, aber:

1. Stellt sicher, dass Sie "app.use" verwenden (für alle Aktionen, nicht nur get)
2. Externalisiert die forceSsl-Logik explizit in eine deklarierte Funktion
3. Verwendet '*' nicht mit "app.use" - dies ist tatsächlich fehlgeschlagen, als ich es getestet habe.
4. Hier möchte ich nur SSL in der Produktion. (Ändern Sie nach Ihren Wünschen)

Code:

 var express = require('express'),
   env = process.env.NODE_ENV || 'development';

 var forceSsl = function (req, res, next) {
    if (req.headers['x-forwarded-proto'] !== 'https') {
        return res.redirect(['https://', req.get('Host'), req.url].join(''));
    }
    return next();
 };

 app.configure(function () {

    if (env === 'production') {
        app.use(forceSsl);
    }

    // other configurations etc for express go here...
}

Hinweis für Benutzer von SailsJS (0.10.x). Sie können einfach eine Richtlinie (erzwingenSsl.js) in API / Richtlinien erstellen:

module.exports = function (req, res, next) {
  'use strict';
  if ((req.headers['x-forwarded-proto'] !== 'https') && (process.env.NODE_ENV === 'production')) {
    return res.redirect([
      'https://',
      req.get('Host'),
      req.url
    ].join(''));
  } else {
    next();
  }
};

Verweisen Sie dann zusammen mit anderen Richtlinien auf config / Policies.js, z.

'*': ['authentifiziert', 'erzwingenSsl']

Die Antwort ist, den Header von 'x-forwarded-proto' zu verwenden, den Heroku weiterleitet, während es sein Proxy-Dingamabob tut. (Randnotiz: Sie übergeben auch einige andere x-Variablen, die nützlich sein können, überprüfen Sie sie ).

Mein Code:

/* At the top, with other redirect methods before other routes */
app.get('*',function(req,res,next){
  if(req.headers['x-forwarded-proto']!='https')
    res.redirect('https://mypreferreddomain.com'+req.url)
  else
    next() /* Continue to other routes if we're not redirecting */
})

Danke Brandon, ich habe nur auf diese 6-stündige Verspätung gewartet, bei der ich meine eigene Frage nicht beantworten konnte.

Die akzeptierte Antwort enthält eine fest codierte Domain. Dies ist nicht gut, wenn Sie denselben Code auf mehreren Domains haben (z. B. dev-yourapp.com, test-yourapp.com, yourapp.com).

Verwenden Sie stattdessen Folgendes:

/* Redirect http to https */
app.get('*', function(req,res,next) {
  if(req.headers['x-forwarded-proto'] != 'https' && process.env.NODE_ENV === 'production')
    res.redirect('https://'+req.hostname+req.url)
  else
    next() /* Continue to other routes if we're not redirecting */
});

https://blog.mako.ai/2016/03/30/redirect-http-to-https-on-heroku-and-node-generally/

Ich habe ein kleines Knotenmodul geschrieben, das SSL für Expressprojekte erzwingt. Es funktioniert sowohl in Standardsituationen als auch bei Reverse-Proxys (Heroku, Nodejitsu usw.).

https://github.com/florianheinemann/express-sslify

Wenn Sie den x-forwarded-protoHeader auf Ihrem lokalen Host testen möchten , können Sie mit nginx eine vhost-Datei einrichten, die alle Anforderungen an Ihre Knoten-App weiterleitet. Ihre nginx vhost-Konfigurationsdatei könnte folgendermaßen aussehen

NginX

server {
  listen 80;
  listen 443;

  server_name dummy.com;

  ssl on;
  ssl_certificate     /absolute/path/to/public.pem;
  ssl_certificate_key /absolute/path/to/private.pem;

  access_log /var/log/nginx/dummy-access.log;
  error_log /var/log/nginx/dummy-error.log debug;

  # node
  location / {
    proxy_pass http://127.0.0.1:3000/;
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
  }
}

Die wichtigen Punkte hierbei sind, dass Sie alle Anforderungen an den localhost-Port 3000 weiterleiten (hier wird Ihre Knoten-App ausgeführt) und eine Reihe von Headern einrichten, einschließlich X-Forwarded-Proto

Erkennen Sie dann in Ihrer App diesen Header wie gewohnt

ausdrücken

var app = express()
  .use(function (req, res, next) {
    if (req.header('x-forwarded-proto') == 'http') {
      res.redirect(301, 'https://' + 'dummy.com' + req.url)
      return
    }
    next()
  })

Koa

var app = koa()
app.use(function* (next) {
  if (this.request.headers['x-forwarded-proto'] == 'http') {
    this.response.redirect('https://' + 'dummy.com' + this.request.url)
    return
  }
  yield next
})

Gastgeber

Schließlich müssen Sie diese Zeile zu Ihrer hostsDatei hinzufügen

127.0.0.1 dummy.com

Sie sollten einen Blick auf heroku-ssl-redirect werfen . Es wirkt wie ein Zauber!

var sslRedirect = require('heroku-ssl-redirect');
var express = require('express');
var app = express();

// enable ssl redirect
app.use(sslRedirect());

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

app.listen(3000);

Wenn Sie cloudflare.com als CDN in Kombination mit heroku verwenden, können Sie die automatische SSL-Umleitung innerhalb von Cloudflare auf folgende Weise aktivieren:

1. Melden Sie sich an und gehen Sie zu Ihrem Dashboard

2. Wählen Sie Seitenregeln

   

3. Fügen Sie Ihre Domain hinzu, z. B. www.example.com, und wechseln Sie immer mit https zu on

Loopback-Benutzer können eine leicht angepasste Version von arcseldon answer als Middleware verwenden:

server / middleware / forcessl.js

module.exports = function() {  
  return function forceSSL(req, res, next) {
    var FORCE_HTTPS = process.env.FORCE_HTTPS || false;
      if (req.headers['x-forwarded-proto'] !== 'https' && FORCE_HTTPS) {
        return res.redirect(['https://', req.get('Host'), req.url].join(''));
      }
      next();
    };
 };

server / server.js

var forceSSL = require('./middleware/forcessl.js');
app.use(forceSSL());

Dies ist eine Express-spezifischere Methode, um dies zu tun.

app.enable('trust proxy');
app.use('*', (req, res, next) => {
  if (req.secure) {
    return next();
  }
  res.redirect(`https://${req.hostname}${req.url}`);
});

app.all('*',function(req,res,next){
  if(req.headers['x-forwarded-proto']!='https') {
    res.redirect(`https://${req.get('host')}`+req.url);
  } else {
    next(); /* Continue to other routes if we're not redirecting */
  }
});

Mit app.use und dynamischer URL. Funktioniert sowohl lokal als auch auf Heroku für mich

app.use(function (req, res, next) {
  if (req.header('x-forwarded-proto') === 'http') {
    res.redirect(301, 'https://' + req.hostname + req.url);
    return
  }
  next()
});

Das Überprüfen des Protokolls im X-Forwarded-Proto-Header funktioniert bei Heroku einwandfrei, genau wie Derek darauf hingewiesen hat. Für was es wert ist , hier ist ein Kern der Express Middleware , die ich benutze und seinen entsprechenden Tests.