WebSocket Node构建HTTP隧道实现实例

更新时间：2023年11月24日 10:05:10 作者：月弦笙音

这篇文章主要为大家介绍了WebSocket Node构建HTTP隧道实现实例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

前言

当我们开发一些与第三方服务集成的应用程序时，我们需要使我们的本地开发服务器暴露在网上。为此，我们需要为本地服务器提供一个 HTTP 隧道。HTTP 隧道如何工作？嘎嘎嘎，看下面！😍😍

为什么我们需要部署自己的 HTTP 隧道服务？

HTTP隧道有很多很❤的在线服务。🥑，我们可以用来获得付费的固定公共域来连接你的本地服务器。它还有一个免费包。但是对于免费套餐🍔，你无法获得固定域。重新启动客户端后，你将获得一个新的随机域。当你需要在第三方服务中保存域时，这很不方便。

要获得固定域，我们可以在自己的服务器中部署HTTP隧道。还提供用于服务器端部署的开源版本。但它是旧的 1.x 版本，不建议在生产环境中部署，存在一些严重的可靠性问题。

使用我们自己的服务器，它还可以确保数据安全。✨

关于精简版 HTTP 隧道简介

Lite HTTP 隧道是我最近为自托管 HTTP 隧道服务构建的。你可以使用 Github 存储库中的按钮部署它，以快速获得免费的固定 Heroku 域。Heroku

它是基于并且只有几个代码构建的。它使用 WebSocket 将 HTTP/HTTPS 请求从公共服务器流式传输到本地服务器。Express.js`Socket.io`

如何实现它

步骤 1：在服务器和客户端之间建立 WebSocket 连接

支持服务器端的WebSocket连接：socket.io

const http = require('http');
const express = require('express');
const { Server } = require('socket.io');
const app = express();
const httpServer = http.createServer(app);
const io = new Server(httpServer);
let connectedSocket = null;
io.on('connection', (socket) => {
  console.log('client connected');
  connectedSocket = socket;
  const onMessage = (message) => {
    if (message === 'ping') {
      socket.send('pong');
    }
  }
  const onDisconnect = (reason) => {
    console.log('client disconnected: ', reason);
    connectedSocket = null;
    socket.off('message', onMessage);
    socket.off('error', onError);
  };
  const onError = (e) => {
    connectedSocket = null;
    socket.off('message', onMessage);
    socket.off('disconnect', onDisconnect);
  };
  socket.on('message', onMessage);
  socket.once('disconnect', onDisconnect);
  socket.once('error', onError);
});
httpServer.listen(process.env.PORT);

✔在客户端连接 WebSocket：

const { io } = require('socket.io-client');
let socket = null;
function initClient(options) {
  socket = io(options.server, {
    transports: ["websocket"],
    auth: {
      token: options.jwtToken,
    },
  });
  socket.on('connect', () => {
    if (socket.connected) {
      console.log('client connect to server successfully');
    }
  });
  socket.on('connect_error', (e) => {
    console.log('connect error', e && e.message);
  });
  socket.on('disconnect', () => {
    console.log('client disconnected');
  });
}

步骤 2：使用 JWT 令牌保护 Websocket 连接

✔在服务器端，我们使用 socket.io 中间件来拒绝无效连接：

const jwt = require('jsonwebtoken');
io.use((socket, next) => {
  if (connectedSocket) {
    return next(new Error('Connected error'));
  }
  if (!socket.handshake.auth || !socket.handshake.auth.token){
    next(new Error('Authentication error'));
  }
  jwt.verify(socket.handshake.auth.token, process.env.SECRET_KEY, function(err, decoded) {
    if (err) {
      return next(new Error('Authentication error'));
    }
    if (decoded.token !== process.env.VERIFY_TOKEN) {
      return next(new Error('Authentication error'));
    }
    next();
  });  
});

步骤 3：将请求从服务器流式传输到客户端

✔我们实现一个可写流来将请求数据发送到隧道客户端：

const { Writable } = require('stream');
class SocketRequest extends Writable {
  constructor({ socket, requestId, request }) {
    super();
    this._socket = socket;
    this._requestId = requestId;
    this._socket.emit('request', requestId, request);
  }
  _write(chunk, encoding, callback) {
    this._socket.emit('request-pipe', this._requestId, chunk);
    this._socket.conn.once('drain', () => {
      callback();
    });
  }
  _writev(chunks, callback) {
    this._socket.emit('request-pipes', this._requestId, chunks);
    this._socket.conn.once('drain', () => {
      callback();
    });
  }
  _final(callback) {
    this._socket.emit('request-pipe-end', this._requestId);
    this._socket.conn.once('drain', () => {
      callback();
    });
  }
  _destroy(e, callback) {
    if (e) {
      this._socket.emit('request-pipe-error', this._requestId, e && e.message);
      this._socket.conn.once('drain', () => {
        callback();
      });
      return;
    }
    callback();
  }
}
app.use('/', (req, res) => {
  if (!connectedSocket) {
    res.status(404);
    res.send('Not Found');
    return;
  }
  const requestId = uuidV4();
  const socketRequest = new SocketRequest({
    socket: connectedSocket,
    requestId,
    request: {
      method: req.method,
      headers: { ...req.headers },
      path: req.url,
    },
  });
  const onReqError = (e) => {
    socketRequest.destroy(new Error(e || 'Aborted'));
  }
  req.once('aborted', onReqError);
  req.once('error', onReqError);
  req.pipe(socketRequest);
  req.once('finish', () => {
    req.off('aborted', onReqError);
    req.off('error', onReqError);
  });
  // ...
});

✔实现可读的流以在客户端获取请求数据：

const stream = require('stream');
class SocketRequest extends stream.Readable {
  constructor({ socket, requestId }) {
    super();
    this._socket = socket;
    this._requestId = requestId;
    const onRequestPipe = (requestId, data) => {
      if (this._requestId === requestId) {
        this.push(data);
      }
    };
    const onRequestPipes = (requestId, data) => {
      if (this._requestId === requestId) {
        data.forEach((chunk) => {
          this.push(chunk);
        });
      }
    };
    const onRequestPipeError = (requestId, error) => {
      if (this._requestId === requestId) {
        this._socket.off('request-pipe', onRequestPipe);
        this._socket.off('request-pipes', onRequestPipes);
        this._socket.off('request-pipe-error', onRequestPipeError);
        this._socket.off('request-pipe-end', onRequestPipeEnd);
        this.destroy(new Error(error));
      }
    };
    const onRequestPipeEnd = (requestId, data) => {
      if (this._requestId === requestId) {
        this._socket.off('request-pipe', onRequestPipe);
        this._socket.off('request-pipes', onRequestPipes);
        this._socket.off('request-pipe-error', onRequestPipeError);
        this._socket.off('request-pipe-end', onRequestPipeEnd);
        if (data) {
          this.push(data);
        }
        this.push(null);
      }
    };
    this._socket.on('request-pipe', onRequestPipe);
    this._socket.on('request-pipes', onRequestPipes);
    this._socket.on('request-pipe-error', onRequestPipeError);
    this._socket.on('request-pipe-end', onRequestPipeEnd);
  }
  _read() {}
}
socket.on('request', (requestId, request) => {
  console.log(`${request.method}: `, request.path);
  request.port = options.port;
  request.hostname = options.host;
  const socketRequest = new SocketRequest({
    requestId,
    socket: socket,
  });
  const localReq = http.request(request);
  socketRequest.pipe(localReq);
  const onSocketRequestError = (e) => {
    socketRequest.off('end', onSocketRequestEnd);
    localReq.destroy(e);
  };
  const onSocketRequestEnd = () => {
    socketRequest.off('error', onSocketRequestError);
  };
  socketRequest.once('error', onSocketRequestError);
  socketRequest.once('end', onSocketRequestEnd);
  // ...
});

步骤 4：将响应从客户端流式传输到服务器

✔实现可写流以将响应数据发送到隧道服务器：

const stream = require('stream');
class SocketResponse extends stream.Writable {
  constructor({ socket, responseId }) {
    super();
    this._socket = socket;
    this._responseId = responseId;
  }
  _write(chunk, encoding, callback) {
    this._socket.emit('response-pipe', this._responseId, chunk);
    this._socket.io.engine.once('drain', () => {
      callback();
    });
  }
  _writev(chunks, callback) {
    this._socket.emit('response-pipes', this._responseId, chunks);
    this._socket.io.engine.once('drain', () => {
      callback();
    });
  }
  _final(callback) {
    this._socket.emit('response-pipe-end', this._responseId);
    this._socket.io.engine.once('drain', () => {
      callback();
    });
  }
  _destroy(e, callback) {
    if (e) {
      this._socket.emit('response-pipe-error', this._responseId, e && e.message);
      this._socket.io.engine.once('drain', () => {
        callback();
      });
      return;
    }
    callback();
  }
  writeHead(statusCode, statusMessage, headers) {
    this._socket.emit('response', this._responseId, {
      statusCode,
      statusMessage,
      headers,
    });
  }
}
socket.on('request', (requestId, request) => {
    // ...stream request and send request to local server...
    const onLocalResponse = (localRes) => {
      localReq.off('error', onLocalError);
      const socketResponse = new SocketResponse({
        responseId: requestId,
        socket: socket,
      });
      socketResponse.writeHead(
        localRes.statusCode,
        localRes.statusMessage,
        localRes.headers
      );
      localRes.pipe(socketResponse);
    };
    const onLocalError = (error) => {
      console.log(error);
      localReq.off('response', onLocalResponse);
      socket.emit('request-error', requestId, error && error.message);
      socketRequest.destroy(error);
    };
    localReq.once('error', onLocalError);
    localReq.once('response', onLocalResponse);
  });

✔实现可读流以在隧道服务器中获取响应数据：

class SocketResponse extends Readable {
  constructor({ socket, responseId }) {
    super();
    this._socket = socket;
    this._responseId = responseId;
    const onResponse = (responseId, data) => {
      if (this._responseId === responseId) {
        this._socket.off('response', onResponse);
        this._socket.off('request-error', onRequestError);
        this.emit('response', data.statusCode, data.statusMessage, data.headers);
      }
    }
    const onResponsePipe = (responseId, data) => {
      if (this._responseId === responseId) {
        this.push(data);
      }
    };
    const onResponsePipes = (responseId, data) => {
      if (this._responseId === responseId) {
        data.forEach((chunk) => {
          this.push(chunk);
        });
      }
    };
    const onResponsePipeError = (responseId, error) => {
      if (this._responseId !== responseId) {
        return;
      }
      this._socket.off('response-pipe', onResponsePipe);
      this._socket.off('response-pipes', onResponsePipes);
      this._socket.off('response-pipe-error', onResponsePipeError);
      this._socket.off('response-pipe-end', onResponsePipeEnd);
      this.destroy(new Error(error));
    };
    const onResponsePipeEnd = (responseId, data) => {
      if (this._responseId !== responseId) {
        return;
      }
      if (data) {
        this.push(data);
      }
      this._socket.off('response-pipe', onResponsePipe);
      this._socket.off('response-pipes', onResponsePipes);
      this._socket.off('response-pipe-error', onResponsePipeError);
      this._socket.off('response-pipe-end', onResponsePipeEnd);
      this.push(null);
    };
    const onRequestError = (requestId, error) => {
      if (requestId === this._responseId) {
        this._socket.off('request-error', onRequestError);
        this._socket.off('response', onResponse);
        this._socket.off('response-pipe', onResponsePipe);
        this._socket.off('response-pipes', onResponsePipes);
        this._socket.off('response-pipe-error', onResponsePipeError);
        this._socket.off('response-pipe-end', onResponsePipeEnd);
        this.emit('requestError', error);
      }
    };
    this._socket.on('response', onResponse);
    this._socket.on('response-pipe', onResponsePipe);
    this._socket.on('response-pipes', onResponsePipes);
    this._socket.on('response-pipe-error', onResponsePipeError);
    this._socket.on('response-pipe-end', onResponsePipeEnd);
    this._socket.on('request-error', onRequestError);
  }
  _read(size) {}
}
app.use('/', (req, res) => {
  // ... stream request to tunnel client
  const onResponse = (statusCode, statusMessage, headers) => {
    socketRequest.off('requestError', onRequestError)
    res.writeHead(statusCode, statusMessage, headers);
  };
  socketResponse.once('requestError', onRequestError)
  socketResponse.once('response', onResponse);
  socketResponse.pipe(res);
  const onSocketError = () => {
    res.end(500);
  };
  socketResponse.once('error', onSocketError);
  connectedSocket.once('close', onSocketError)
  res.once('close', () => {
    connectedSocket.off('close', onSocketError);
    socketResponse.off('error', onSocketError);
  });
});

👍完成所有步骤后，我们支持将 HTTP 请求流式传输到本地计算机，并将响应从本地服务器发送到原始请求。它是一个精简的解决方案，但它稳定且易于在任何环境中部署。Node.js

如果你只想查找具有免费固定域的HTTP隧道服务，则可以尝试在Github自述文件中将Lite HTTP Tunnel项目部署到with中。希望小伙伴们能从这篇文章中学到一些东西😍。Heroku`Heroku deploy button`

以上就是WebSocket Node构建HTTP隧道实现实例的详细内容，更多关于WebSocket Node构建HTTP的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

Node.js对MongoDB进行增删改查操作的实例代码
这篇文章主要介绍了Node.js对MongoDB进行增删改查操作 ,需要的朋友可以参考下
2019-04-04
Nodejs中的计时器(setTimeout setIntervals etImmediate)使用案例解析
这篇文章主要介绍了Nodejs中的计时器(setTimeout setIntervals etImmediate)使用案例解析,有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-06-06
用Node写一条配置环境的指令
这篇文章主要介绍了用Node写一条配置环境的指令，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-11-11
Nodejs 发布自己的npm包并制作成命令行工具的实例讲解
今天小编就为大家分享一篇Nodejs 发布自己的npm包并制作成命令行工具的实例讲解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2018-05-05
使用Express+Node.js对mysql进行增改查操作
这篇文章主要介绍了使用Express+Node.js对mysql进行增改查操作，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的小伙伴可以参考一下
2022-08-08
详解KOA2如何手写中间件(装饰器模式)
这篇文章主要介绍了详解KOA2如何手写中间件(装饰器模式)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2018-10-10
Node.js高级编程使用RPC通信示例详解
这篇文章主要为大家介绍了Node.js高级编程使用RPC通信示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-01-01
nodejs入门教程一：概念与用法简介
这篇文章主要介绍了nodejs入门教程之概念与用法,结合实例形式分析了nodejs基本概念、功能、命令与相关使用技巧,需要的朋友可以参考下
2017-04-04
Node.js使用Koa搭建基础项目
时下前端工程师有很多人比较关注NodeJs以及express 框架或者Koa 框架之类的新技术。难得我最近闲时较多，利用一下旧历新年尚未正式到来的这片闲暇，也来涉足其中，一窥其中奥妙。
2018-01-01
Node.js API详解之 vm模块用法实例分析
这篇文章主要介绍了Node.js API详解之 vm模块用法,结合实例形式分析了Node.js API中vm模块基本功能、函数、使用方法及相关操作注意事项,需要的朋友可以参考下
2020-05-05