Laravel IO Socket und Redis über SSL https Verbindung

Question

Derzeit haben IO-Buchsen mit Laravel Broadcasting mit Redis perfekt funktioniert. Bis ich dann ein SSL-Zertifikat auf der Domain eingerichtet habe.

Ich habe redis-Server läuft auf Port 3001.

Dann gibt es ein socket.js ist auf 3000.

Mein JS auf der Seite, die ich über io hören hören ("// {{ $ hören}}: 3000 ').

Jede Anleitung wäre großartig, wie dies über https funktioniert. Würde ich einfach 443 als Port benutzen?

Danke.

Mein socket.js

var app = require('express')(); 
var http = require('http').Server(app); 
var io = require('socket.io')(http); 
var Redis = require('ioredis'); 
var redis = new Redis(); 
redis.subscribe('notifications', function(err, count) { 
}); 
redis.on('message', function(channel, message) { 
    console.log('Message Recieved: ' + message); 
    message = JSON.parse(message); 
    io.emit(channel + ':' + message.event, message.data); 
}); 
http.listen(3000, function(){ 
    console.log('Listening on Port 3000'); 
}); 

Answer 1

Zuerst Setup Ihre serverOptions Objekt:

var serverOptions = { 
    port: 3000, 
    host: 127.0.0.1, //address to your site 
    key: '/etc/nginx/ssl/your_site/server.key', //Or whatever the path to your SSL is 
    cert: '/etc/nginx/ssl/your_site/server.crt', 
    NPNProtocols: ['http/2.0', 'spdy', 'http/1.1', 'http/1.0'] 
} 

Für die NPNProtocols, Sie für alle von ihnen nicht kümmern können, aber sie sind als Referenz zur Verfügung gestellt.

Jetzt erstellen Sie einfach den Server.

var app = require('https').createServer(serverOptions), 
    io = require('socket.io')(app); 

Dieser hübsche Stecker sein sollte und in die Quelle an seinem Punkt spielen \

Als Seite beachten Sie Ihre Sachen ganz weit offen ist und jeder kann hören auf Ihrem Web-Socket, also sollte nichts gesendet werden, das hier privat ist. Wenn Sie Ihre Daten privat machen müssen, brauchen Sie eines von zwei Dingen.

1. So etwas wie JWT-Auth Token
2. Etwas Brauch, dass Schnittstelle mit der Redis Warteschlange:

Hier ist ein Beispiel für letzteres:

var SECRET_KEY = '<YOUR_LARAVEL_SECRET_KEY>'; 
var laravel_session_parser = { 
    ord: function (string) { 
     return string.charCodeAt(0); 
    }, 
    decryptSession: function (cookie, secret) { 
     if (cookie) { 
      var session_cookie = JSON.parse(new Buffer(cookie, 'base64')); 
      var iv = new Buffer(session_cookie.iv, 'base64'); 
      var value = new Buffer(session_cookie.value, 'base64'); 
      var rijCbc = new mcrypt.MCrypt('rijndael-128', 'cbc'); 
      rijCbc.open(secret, iv); 
      var decrypted = rijCbc.decrypt(value).toString(); 
      var len = decrypted.length - 1; 
      var pad = laravel_session_parser.ord(decrypted.charAt(len)); 
      return phpunserialize.unserialize(decrypted.substr(0, decrypted.length - pad)); 
     } 
     return null; 
    }, 
    getUidFromObj: function (obj, pattern) { 
     var regexp = /login_web_([a-zA-Z0-9]+)/gi; 
     if (pattern) { 
      regexp = pattern; 
     } 
     var u_id = null; 
     for (var key in obj) { 
      var matches_array = key.match(regexp); 
      if (matches_array && matches_array.length > 0) { 
       u_id = obj[matches_array[0]]; 
       return u_id; 
      } 
     } 
     return u_id; 
    }, 
    getRedisSession: function (s_id, cb) { 
     var _sessionId = 'laravel:' + s_id; 
     client.get(_sessionId, function (err, session) { 
      if (err) { 
       cb && cb(err); 
       return; 
      } 
      cb && cb(null, session); 
     }); 
    }, 
    getSessionId: function (session, _callback) { 
     var u_id = null, 
      err = null; 
     try { 
      var laravelSession = phpunserialize.unserialize(phpunserialize.unserialize(session)); 
      u_id = laravel_session_parser.getUidFromObj(laravelSession); 
     } catch (err) { 
      _callback(err, null); 
     } 
     _callback(err, u_id); 
    }, 
    ready: function (socket, _callback) { 
     if (typeof socket.handshake.headers.cookie === 'string') { 
      var cookies = cookie.parse(socket.handshake.headers.cookie); 
      var laravel_session = cookies.laravel_session; 
      var session_id = laravel_session_parser.decryptSession(laravel_session, SECRET_KEY); 

      laravel_session_parser.getRedisSession(session_id, function (err, session) { 
       if (!err && session) { 
        laravel_session_parser.getSessionId(session, function (err, user_id) { 
         if (user_id) { 
          _callback(null, session_id, user_id, laravel_session) 
         } else { 
          _callback(new Error('Authentication error'), null); 
         } 
        }); 
       } else { 
        _callback(new Error('Authentication error'), null); 
       } 
      }); 
     } 
    } 
}; 

Jetzt können Sie nur IO eine Instanz erhalten haben der Individuen session, wenn sie eine Verbindung zu socket.io

herstellen

io.on('connection', function (socket) { 
    laravel_session_parser.ready(socket, function(err, session_id, user_id, laravel_session) { 
     //log out the variables above to see what they provide 
    }); 
}); 

Hinweis, ziehe ich dotenv in NodeJS verwenden Umgebungsvariablen zwischen Laravel und Knoten zu teilen.

Dann können Sie process.env.APP_KEY tun, und Sie brauchen sich keine Sorgen über die Freigabe von Variablen.

Beachten Sie auch, dass das obige Skript nicht vollständig ist und nicht produktionsfertig ist, es soll nur als Beispiel dienen.