node http proxy
1.0.0
node-http-proxy เป็นไลบรารีพร็อกซีที่ตั้งโปรแกรมได้ HTTP ที่รองรับ websockets เหมาะสำหรับการใช้งานส่วนประกอบต่างๆ เช่น Reverse Proxies และ Load Balancer
npm install http-proxy --save
กลับไปด้านบน
คลิกที่นี่
กลับไปด้านบน
พร็อกซีใหม่ถูกสร้างขึ้นโดยการเรียก createProxyServer และส่งวัตถุ options เป็นอาร์กิวเมนต์ (คุณสมบัติที่ถูกต้องมีอยู่ที่นี่)
var httpProxy = require ( 'http-proxy' ) ;
var proxy = httpProxy . createProxyServer ( options ) ; // See (†)†เว้นแต่ว่าจะมีการเรียกใช้ Listen(..) บนออบเจ็กต์ สิ่งนี้จะไม่สร้างเว็บเซิร์ฟเวอร์ ดูด้านล่าง
วัตถุจะถูกส่งกลับด้วยสี่วิธี:
req, res, [options] (ใช้สำหรับพร็อกซีคำขอ HTTP (S) ปกติ)req, socket, head, [options] (ใช้สำหรับพร็อกซีคำขอ WS(S))port (ฟังก์ชันที่ล้อมอ็อบเจ็กต์ไว้ในเว็บเซิร์ฟเวอร์ เพื่อความสะดวกของคุณ)[callback] (ฟังก์ชั่นที่ปิดเว็บเซิร์ฟเวอร์ภายในและหยุดฟังบนพอร์ตที่กำหนด)จากนั้นจึงเป็นไปได้ที่จะร้องขอพร็อกซีโดยการเรียกใช้ฟังก์ชันเหล่านี้
http . createServer ( function ( req , res ) {
proxy . web ( req , res , { target : 'http://mytarget.com:8080' } ) ;
} ) ;สามารถรับฟังข้อผิดพลาดได้โดยใช้ Event Emitter API
proxy . on ( 'error' , function ( e ) {
...
} ) ;หรือใช้ Callback API
proxy . web ( req , res , { target : 'http://mytarget.com:8080' } , function ( e ) { ... } ) ; เมื่อมีการส่งคำขอผ่านพร็อกซี คำขอจะเป็นไปตามไปป์ไลน์ที่แตกต่างกันสองรายการ (มีให้ที่นี่) ซึ่งใช้การแปลงกับทั้งออบเจ็กต์ req และ res ไปป์ไลน์แรก (ขาเข้า) มีหน้าที่สร้างและจัดการสตรีมที่เชื่อมต่อไคลเอนต์ของคุณกับเป้าหมาย ไปป์ไลน์ที่สอง (ขาออก) มีหน้าที่ในการสร้างและจัดการสตรีมที่ส่งคืนข้อมูลไปยังไคลเอนต์จากเป้าหมายของคุณ
กลับไปด้านบน
var http = require ( 'http' ) ,
httpProxy = require ( 'http-proxy' ) ;
//
// Create your proxy server and set the target in the options.
//
httpProxy . createProxyServer ( { target : 'http://localhost:9000' } ) . listen ( 8000 ) ; // See (†)
//
// Create your target server
//
http . createServer ( function ( req , res ) {
res . writeHead ( 200 , { 'Content-Type' : 'text/plain' } ) ;
res . write ( 'request successfully proxied!' + 'n' + JSON . stringify ( req . headers , true , 2 ) ) ;
res . end ( ) ;
} ) . listen ( 9000 ) ;†การเรียกใช้ Listen(..) จะทำให้เกิดการสร้างเว็บเซิร์ฟเวอร์ มิฉะนั้น จะมีเพียงอินสแตนซ์พร็อกซีเท่านั้นที่ถูกสร้างขึ้น
กลับไปด้านบน
ตัวอย่างนี้แสดงวิธีที่คุณสามารถพร็อกซีคำขอโดยใช้เซิร์ฟเวอร์ HTTP ของคุณเอง และคุณยังสามารถใช้ตรรกะของคุณเองในการจัดการคำขอได้อีกด้วย
var http = require ( 'http' ) ,
httpProxy = require ( 'http-proxy' ) ;
//
// Create a proxy server with custom application logic
//
var proxy = httpProxy . createProxyServer ( { } ) ;
//
// Create your custom server and just call `proxy.web()` to proxy
// a web request to the target passed in the options
// also you can use `proxy.ws()` to proxy a websockets request
//
var server = http . createServer ( function ( req , res ) {
// You can define here your custom logic to handle the request
// and then proxy the request.
proxy . web ( req , res , { target : 'http://127.0.0.1:5050' } ) ;
} ) ;
console . log ( "listening on port 5050" )
server . listen ( 5050 ) ;กลับไปด้านบน
ตัวอย่างนี้แสดงวิธีที่คุณสามารถพร็อกซีคำขอโดยใช้เซิร์ฟเวอร์ HTTP ของคุณเองซึ่งแก้ไขคำขอพร็อกซีขาออกโดยการเพิ่มส่วนหัวพิเศษ
var http = require ( 'http' ) ,
httpProxy = require ( 'http-proxy' ) ;
//
// Create a proxy server with custom application logic
//
var proxy = httpProxy . createProxyServer ( { } ) ;
// To modify the proxy connection before data is sent, you can listen
// for the 'proxyReq' event. When the event is fired, you will receive
// the following arguments:
// (http.ClientRequest proxyReq, http.IncomingMessage req,
// http.ServerResponse res, Object options). This mechanism is useful when
// you need to modify the proxy request before the proxy connection
// is made to the target.
//
proxy . on ( 'proxyReq' , function ( proxyReq , req , res , options ) {
proxyReq . setHeader ( 'X-Special-Proxy-Header' , 'foobar' ) ;
} ) ;
var server = http . createServer ( function ( req , res ) {
// You can define here your custom logic to handle the request
// and then proxy the request.
proxy . web ( req , res , {
target : 'http://127.0.0.1:5050'
} ) ;
} ) ;
console . log ( "listening on port 5050" )
server . listen ( 5050 ) ;กลับไปด้านบน
บางครั้งเมื่อคุณได้รับเอกสาร HTML/XML จากเซิร์ฟเวอร์ต้นทาง คุณต้องการแก้ไขก่อนที่จะส่งต่อ
Harmon อนุญาตให้คุณทำเช่นนี้ในรูปแบบการสตรีมเพื่อลดแรงกดดันต่อพร็อกซีให้เหลือน้อยที่สุด
กลับไปด้านบน
var http = require ( 'http' ) ,
httpProxy = require ( 'http-proxy' ) ;
//
// Create a proxy server with latency
//
var proxy = httpProxy . createProxyServer ( ) ;
//
// Create your server that makes an operation that waits a while
// and then proxies the request
//
http . createServer ( function ( req , res ) {
// This simulates an operation that takes 500ms to execute
setTimeout ( function ( ) {
proxy . web ( req , res , {
target : 'http://localhost:9008'
} ) ;
} , 500 ) ;
} ) . listen ( 8008 ) ;
//
// Create your target server
//
http . createServer ( function ( req , res ) {
res . writeHead ( 200 , { 'Content-Type' : 'text/plain' } ) ;
res . write ( 'request successfully proxied to: ' + req . url + 'n' + JSON . stringify ( req . headers , true , 2 ) ) ;
res . end ( ) ;
} ) . listen ( 9008 ) ;กลับไปด้านบน
คุณสามารถเปิดใช้งานการตรวจสอบความถูกต้องของใบรับรอง SSL ที่ปลอดภัยกับการเชื่อมต่อเป้าหมายได้ (หลีกเลี่ยงใบรับรองที่ลงนามด้วยตนเอง) เพียงตั้งค่า secure: true ในตัวเลือก
//
// Create the HTTPS proxy server in front of a HTTP server
//
httpProxy . createServer ( {
target : {
host : 'localhost' ,
port : 9009
} ,
ssl : {
key : fs . readFileSync ( 'valid-ssl-key.pem' , 'utf8' ) ,
cert : fs . readFileSync ( 'valid-ssl-cert.pem' , 'utf8' )
}
} ) . listen ( 8009 ) ; //
// Create the proxy server listening on port 443
//
httpProxy . createServer ( {
ssl : {
key : fs . readFileSync ( 'valid-ssl-key.pem' , 'utf8' ) ,
cert : fs . readFileSync ( 'valid-ssl-cert.pem' , 'utf8' )
} ,
target : 'https://localhost:9010' ,
secure : true // Depends on your needs, could be false.
} ) . listen ( 443 ) ; //
// Create an HTTP proxy server with an HTTPS target
//
httpProxy . createProxyServer ( {
target : {
protocol : 'https:' ,
host : 'my-domain-name' ,
port : 443 ,
pfx : fs . readFileSync ( 'path/to/certificate.p12' ) ,
passphrase : 'password' ,
} ,
changeOrigin : true ,
} ) . listen ( 8000 ) ;กลับไปด้านบน
คุณสามารถเปิดใช้งานการสนับสนุน websocket สำหรับพร็อกซีโดยใช้ ws:true ในตัวเลือก
//
// Create a proxy server for websockets
//
httpProxy . createServer ( {
target : 'ws://localhost:9014' ,
ws : true
} ) . listen ( 8014 ) ; นอกจากนี้ คุณยังสามารถพร็อกซีคำขอ websocket เพียงแค่เรียกใช้เมธอด ws(req, socket, head)
//
// Setup our server to proxy standard HTTP requests
//
var proxy = new httpProxy . createProxyServer ( {
target : {
host : 'localhost' ,
port : 9015
}
} ) ;
var proxyServer = http . createServer ( function ( req , res ) {
proxy . web ( req , res ) ;
} ) ;
//
// Listen to the `upgrade` event and proxy the
// WebSocket requests as well.
//
proxyServer . on ( 'upgrade' , function ( req , socket , head ) {
proxy . ws ( req , socket , head ) ;
} ) ;
proxyServer . listen ( 8015 ) ;กลับไปด้านบน
httpProxy.createProxyServer รองรับอ็อพชันต่อไปนี้:
target : สตริง url ที่จะแยกวิเคราะห์ด้วยโมดูล url
ไปข้างหน้า : สตริง url ที่จะแยกวิเคราะห์ด้วยโมดูล url
ตัวแทน : วัตถุที่จะส่งผ่านไปยัง http (s) คำขอ (ดูตัวแทน https ของโหนดและวัตถุตัวแทน http)
ssl : วัตถุที่จะส่งไปยัง https.createServer()
ws : จริง/เท็จ หากคุณต้องการพร็อกซีเว็บซ็อกเก็ต
xfwd : true/false เพิ่มส่วนหัว x-forward
ปลอดภัย : จริง/เท็จ หากคุณต้องการตรวจสอบใบรับรอง SSL
toProxy : จริง/เท็จ ส่งผ่าน URL ที่แน่นอนเป็น path (มีประโยชน์สำหรับการพร็อกซีไปยังพร็อกซี)
prependPath : true/false, Default: true - ระบุว่าคุณต้องการเพิ่มเส้นทางของเป้าหมายไว้หน้าเส้นทางพร็อกซีหรือไม่
IgnPath : true/false, Default: false - ระบุว่าคุณต้องการละเว้นเส้นทางพร็อกซีของคำขอที่เข้ามาหรือไม่ (หมายเหตุ: คุณจะต้องต่อท้าย / ด้วยตนเอง หากจำเป็น)
localAddress : สตริงอินเทอร์เฟซท้องถิ่นเพื่อผูกสำหรับการเชื่อมต่อขาออก
changeOrigin : true/false, Default: false - เปลี่ยนที่มาของส่วนหัวของโฮสต์เป็น URL เป้าหมาย
PreservHeaderKeyCase : true/false, Default: false - ระบุว่าคุณต้องการเก็บตัวพิมพ์เล็กหรือใหญ่ของคีย์ส่วนหัวการตอบกลับ
auth : การรับรองความถูกต้องพื้นฐาน เช่น 'ผู้ใช้:รหัสผ่าน' เพื่อคำนวณส่วนหัวการอนุญาต
hostRewrite : เขียนชื่อโฮสต์ตำแหน่งใหม่ในการเปลี่ยนเส้นทาง (201/301/302/307/308)
autoRewrite : เขียนใหม่ตำแหน่งโฮสต์/พอร์ตบนการเปลี่ยนเส้นทาง (201/301/302/307/308) ตามโฮสต์/พอร์ตที่ร้องขอ ค่าเริ่มต้น: เท็จ
protocolRewrite : เขียนโปรโตคอลตำแหน่งใหม่บน (201/301/302/307/308) เปลี่ยนเส้นทางไปที่ 'http' หรือ 'https' ค่าเริ่มต้น: เป็นโมฆะ
cookieDomainRewrite : เขียนโดเมนใหม่ของส่วนหัว set-cookie ค่าที่เป็นไปได้:
false (ค่าเริ่มต้น): ปิดใช้งานการเขียนคุกกี้ใหม่cookieDomainRewrite: "new.domain" หากต้องการลบโดเมน ให้ใช้ cookieDomainRewrite: """*" เพื่อจับคู่โดเมนทั้งหมด ตัวอย่างเช่น ให้โดเมนหนึ่งไม่เปลี่ยนแปลง เขียนโดเมนหนึ่งใหม่และลบโดเมนอื่น: cookieDomainRewrite: {
"unchanged.domain": "unchanged.domain",
"old.domain": "new.domain",
"*": ""
}
cookiePathRewrite : เขียนเส้นทางของส่วนหัว set-cookie ใหม่ ค่าที่เป็นไปได้:
false (ค่าเริ่มต้น): ปิดใช้งานการเขียนคุกกี้ใหม่cookiePathRewrite: "/newPath/" หากต้องการลบเส้นทาง ให้ใช้ cookiePathRewrite: "" หากต้องการตั้งค่าเส้นทางไปยังรูทให้ใช้ cookiePathRewrite: "/""*" เพื่อจับคู่เส้นทางทั้งหมด ตัวอย่างเช่น หากต้องการให้เส้นทางหนึ่งไม่เปลี่ยนแปลง ให้เขียนเส้นทางหนึ่งใหม่และลบเส้นทางอื่นออก: cookiePathRewrite: {
"/unchanged.path/": "/unchanged.path/",
"/old.path/": "/new.path/",
"*": ""
}
headers : วัตถุที่มีส่วนหัวพิเศษที่จะเพิ่มในคำขอเป้าหมาย
proxyTimeout : การหมดเวลา (เป็นมิลลิวินาที) สำหรับคำขอพร็อกซีขาออก
timeout : หมดเวลา (เป็นมิลลิวินาที) สำหรับคำขอที่เข้ามา
followRedirects : true/false, Default: false - ระบุว่าคุณต้องการติดตามการเปลี่ยนเส้นทางหรือไม่
selfHandleResponse จริง/เท็จ หากตั้งค่าเป็นจริง จะไม่มีการเรียกผ่าน webOutgoing ใดๆ และเป็นความรับผิดชอบของคุณที่จะต้องส่งคืนการตอบกลับอย่างเหมาะสมโดยการฟังและดำเนินการกับเหตุการณ์ proxyRes
buffer : กระแสข้อมูลที่จะส่งเป็นเนื้อหาคำขอ บางทีคุณอาจมีมิดเดิลแวร์บางตัวที่ใช้สตรีมคำขอก่อนที่จะทำการพร็อกซี เช่น หากคุณอ่านเนื้อความของคำขอลงในฟิลด์ที่เรียกว่า 'req.rawbody' คุณสามารถรีสตรีมฟิลด์นี้ใหม่ในตัวเลือกบัฟเฟอร์:
'use strict';
const streamify = require('stream-array');
const HttpProxy = require('http-proxy');
const proxy = new HttpProxy();
module.exports = (req, res, next) => {
proxy.web(req, res, {
target: 'http://localhost:4003/',
buffer: streamify(req.rawBody)
}, next);
};
หมายเหตุ: options.ws และ options.ssl เป็นทางเลือก options.target และ options.forward ต้องไม่ขาดทั้งคู่
หากคุณใช้เมธอด proxyServer.listen ตัวเลือกต่อไปนี้ยังสามารถใช้ได้:
กลับไปด้านบน
error : เหตุการณ์ข้อผิดพลาดจะถูกส่งออกมาหากคำขอไปยังเป้าหมายล้มเหลว เราไม่ดำเนินการจัดการข้อผิดพลาดใดๆ กับข้อความที่ส่งระหว่างไคลเอนต์และพร็อกซี และข้อความที่ส่งระหว่างพร็อกซีและเป้าหมาย ดังนั้นจึงขอแนะนำให้คุณรับฟังข้อผิดพลาดและจัดการกับข้อผิดพลาดเหล่านั้นproxyReq : เหตุการณ์นี้ถูกส่งก่อนที่จะส่งข้อมูล มันให้โอกาสคุณในการแก้ไขวัตถุคำขอ proxyReq ใช้กับการเชื่อมต่อ "เว็บ"proxyReqWs : เหตุการณ์นี้ถูกส่งก่อนที่จะส่งข้อมูล มันให้โอกาสคุณในการแก้ไขวัตถุคำขอ proxyReq ใช้กับการเชื่อมต่อ "websocket"proxyRes : เหตุการณ์นี้จะถูกส่งออกมาหากคำขอไปยังเป้าหมายได้รับการตอบกลับopen : เหตุการณ์นี้จะถูกส่งออกมาเมื่อมีการสร้างพร็อกซี websocket และไพพ์ไปยัง websocket เป้าหมายclose : เหตุการณ์นี้จะถูกส่งออกมาเมื่อพร็อกซี websocket ถูกปิดproxySocket : เลิกใช้แล้วเพื่อ open . var httpProxy = require ( 'http-proxy' ) ;
// Error example
//
// Http Proxy Server with bad target
//
var proxy = httpProxy . createServer ( {
target : 'http://localhost:9005'
} ) ;
proxy . listen ( 8005 ) ;
//
// Listen for the `error` event on `proxy`.
proxy . on ( 'error' , function ( err , req , res ) {
res . writeHead ( 500 , {
'Content-Type' : 'text/plain'
} ) ;
res . end ( 'Something went wrong. And we are reporting a custom error message.' ) ;
} ) ;
//
// Listen for the `proxyRes` event on `proxy`.
//
proxy . on ( 'proxyRes' , function ( proxyRes , req , res ) {
console . log ( 'RAW Response from the target' , JSON . stringify ( proxyRes . headers , true , 2 ) ) ;
} ) ;
//
// Listen for the `open` event on `proxy`.
//
proxy . on ( 'open' , function ( proxySocket ) {
// listen for messages coming FROM the target here
proxySocket . on ( 'data' , hybiParseAndLogMessage ) ;
} ) ;
//
// Listen for the `close` event on `proxy`.
//
proxy . on ( 'close' , function ( res , socket , head ) {
// view disconnected websocket connections
console . log ( 'Client disconnected' ) ;
} ) ;กลับไปด้านบน
var proxy = new httpProxy . createProxyServer ( {
target : {
host : 'localhost' ,
port : 1337
}
} ) ;
proxy . close ( ) ;กลับไปด้านบน
หากคุณต้องการจัดการการตอบสนองของคุณเองหลังจากได้รับ proxyRes คุณสามารถทำได้ด้วย selfHandleResponse ดังที่คุณเห็นด้านล่าง หากคุณใช้ตัวเลือกนี้ คุณจะสามารถสกัดกั้นและอ่าน proxyRes ได้ แต่คุณต้องแน่ใจว่าได้ตอบกลับไปยัง res เอง มิฉะนั้นไคลเอ็นต์ดั้งเดิมจะไม่ได้รับข้อมูลใดๆ
var option = {
target : target ,
selfHandleResponse : true
} ;
proxy . on ( 'proxyRes' , function ( proxyRes , req , res ) {
var body = [ ] ;
proxyRes . on ( 'data' , function ( chunk ) {
body . push ( chunk ) ;
} ) ;
proxyRes . on ( 'end' , function ( ) {
body = Buffer . concat ( body ) . toString ( ) ;
console . log ( "res from proxied server:" , body ) ;
res . end ( "my response to cli" ) ;
} ) ;
} ) ;
proxy . web ( req , res , option ) ;
API ตารางพร็อกซีพร้อมใช้งานผ่านโมดูลเสริมนี้ ซึ่งช่วยให้คุณกำหนดชุดกฎเพื่อแปลเส้นทางที่ตรงกันเป็นเส้นทางเป้าหมายที่พร็อกซีย้อนกลับจะสื่อสารด้วย
$ npm test
โลโก้ที่สร้างโดย Diego Pasquali
กลับไปด้านบน
master )กลับไปด้านบน
ใบอนุญาต MIT (MIT)
ลิขสิทธิ์ (c) 2010 - 2016 Charlie Robbins, Jarrett Cruger และผู้มีส่วนร่วม
อนุญาตให้บุคคลใดก็ตามที่ได้รับสำเนาของซอฟต์แวร์นี้และไฟล์เอกสารที่เกี่ยวข้อง ("ซอฟต์แวร์") อนุญาตโดยไม่เสียค่าใช้จ่าย เพื่อจัดการกับซอฟต์แวร์โดยไม่มีข้อจำกัด รวมถึงแต่ไม่จำกัดเพียงสิทธิ์ในการใช้ คัดลอก ปรับเปลี่ยน ผสาน เผยแพร่ แจกจ่าย ให้อนุญาตช่วง และ/หรือขายสำเนาของซอฟต์แวร์ และอนุญาตให้บุคคลที่ได้รับซอฟต์แวร์นี้สามารถทำได้ ภายใต้เงื่อนไขต่อไปนี้:
ประกาศเกี่ยวกับลิขสิทธิ์ข้างต้นและประกาศการอนุญาตนี้จะรวมอยู่ในสำเนาทั้งหมดหรือส่วนสำคัญของซอฟต์แวร์
ซอฟต์แวร์นี้มีให้ "ตามที่เป็น" โดยไม่มีการรับประกันใดๆ ทั้งโดยชัดแจ้งหรือโดยนัย ซึ่งรวมถึงแต่ไม่จำกัดเพียงการรับประกันความสามารถในการค้าขาย ความเหมาะสมสำหรับวัตถุประสงค์เฉพาะ และการไม่ละเมิด ไม่ว่าในกรณีใดผู้เขียนหรือผู้ถือลิขสิทธิ์จะต้องรับผิดต่อการเรียกร้องค่าเสียหายหรือความรับผิดอื่นใดไม่ว่าในการกระทำของสัญญาการละเมิดหรืออย่างอื่นที่เกิดขึ้นจากหรือเกี่ยวข้องกับซอฟต์แวร์หรือการใช้งานหรือข้อตกลงอื่น ๆ ใน ซอฟต์แวร์.
