node http proxy
1.0.0
node-http-proxy ist eine programmierbare HTTP-Proxy-Bibliothek, die Websockets unterstützt. Es eignet sich zur Implementierung von Komponenten wie Reverse-Proxys und Load Balancern.
npm install http-proxy --save
Zurück nach oben
klicken Sie hier
Zurück nach oben
Ein neuer Proxy wird erstellt, indem createProxyServer aufgerufen und ein options als Argument übergeben wird (gültige Eigenschaften sind hier verfügbar).
var httpProxy = require ( 'http-proxy' ) ;
var proxy = httpProxy . createProxyServer ( options ) ; // See (†)†Solange listen(..) nicht für das Objekt aufgerufen wird, wird dadurch kein Webserver erstellt. Siehe unten.
Ein Objekt wird mit vier Methoden zurückgegeben:
req, res, [options] (wird für die Weiterleitung regulärer HTTP(S)-Anfragen verwendet)req, socket, head, [options] (wird für die Weiterleitung von WS(S)-Anfragen verwendet)port (eine Funktion, die das Objekt zu Ihrer Bequemlichkeit in einen Webserver einschließt)[callback] (eine Funktion, die den inneren Webserver schließt und die Überwachung des angegebenen Ports beendet)Durch den Aufruf dieser Funktionen ist es dann möglich, Anfragen weiterzuleiten
http . createServer ( function ( req , res ) {
proxy . web ( req , res , { target : 'http://mytarget.com:8080' } ) ;
} ) ;Fehler können entweder mithilfe der Event Emitter-API abgehört werden
proxy . on ( 'error' , function ( e ) {
...
} ) ;oder über die Callback-API
proxy . web ( req , res , { target : 'http://mytarget.com:8080' } , function ( e ) { ... } ) ; Wenn eine Anfrage per Proxy weitergeleitet wird, folgt sie zwei verschiedenen Pipelines (hier verfügbar), die Transformationen sowohl auf das req als auch auf das res Objekt anwenden. Die erste Pipeline (eingehend) ist für die Erstellung und Bearbeitung des Streams verantwortlich, der Ihren Client mit dem Ziel verbindet. Die zweite Pipeline (ausgehend) ist für die Erstellung und Bearbeitung des Streams verantwortlich, der von Ihrem Ziel Daten an den Client zurückgibt.
Zurück nach oben
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 ) ;†Der Aufruf von listen(..) löst die Erstellung eines Webservers aus. Andernfalls wird nur die Proxy-Instanz erstellt.
Zurück nach oben
Dieses Beispiel zeigt, wie Sie eine Anfrage mithilfe Ihres eigenen HTTP-Servers weiterleiten und Ihre eigene Logik zur Verarbeitung der Anfrage einsetzen können.
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 ) ;Zurück nach oben
Dieses Beispiel zeigt, wie Sie eine Anfrage mithilfe Ihres eigenen HTTP-Servers weiterleiten können, der die ausgehende Proxy-Anfrage durch Hinzufügen eines speziellen Headers ändert.
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 ) ;Zurück nach oben
Wenn Sie ein HTML/XML-Dokument vom Ursprungsserver erhalten haben, möchten Sie es manchmal ändern, bevor Sie es weiterleiten.
Mit Harmon können Sie dies im Streaming-Stil tun, um den Druck auf den Proxy so gering wie möglich zu halten.
Zurück nach oben
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 ) ;Zurück nach oben
Sie können die Validierung eines sicheren SSL-Zertifikats für die Zielverbindung aktivieren (selbstsignierte Zertifikate vermeiden), indem Sie in den Optionen einfach secure: true festlegen.
//
// 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 ) ;Zurück nach oben
Sie können die Websocket-Unterstützung für den Proxy mit ws:true in den Optionen aktivieren.
//
// Create a proxy server for websockets
//
httpProxy . createServer ( {
target : 'ws://localhost:9014' ,
ws : true
} ) . listen ( 8014 ) ; Sie können die Websocket-Anfragen auch weiterleiten, indem Sie einfach die Methode ws(req, socket, head) aufrufen.
//
// 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 ) ;Zurück nach oben
httpProxy.createProxyServer unterstützt die folgenden Optionen:
Ziel : URL-String, der mit dem URL-Modul analysiert werden soll
vorwärts : URL-Zeichenfolge, die mit dem URL-Modul analysiert werden soll
agent : Objekt, das an http(s).request übergeben werden soll (siehe Knoten-https-Agent und http-Agent-Objekte)
ssl : Objekt, das an https.createServer() übergeben werden soll
ws : true/false, wenn Sie WebSockets als Proxy verwenden möchten
xfwd : wahr/falsch, fügt x-forward-Header hinzu
secure : wahr/falsch, wenn Sie die SSL-Zertifikate überprüfen möchten
toProxy : wahr/falsch, übergibt die absolute URL als path (nützlich für die Weiterleitung an Proxys)
prependPath : true/false, Standard: true – geben Sie an, ob Sie den Pfad des Ziels dem Proxy-Pfad voranstellen möchten
ignorePath : true/false, Standard: false – geben Sie an, ob Sie den Proxy-Pfad der eingehenden Anfrage ignorieren möchten (Hinweis: Sie müssen / bei Bedarf manuell anhängen).
localAddress : Lokale Schnittstellenzeichenfolge zum Binden für ausgehende Verbindungen
changeOrigin : true/false, Standard: false – ändert den Ursprung des Host-Headers in die Ziel-URL
PreserveHeaderKeyCase : wahr/falsch, Standard: falsch – geben Sie an, ob Sie die Groß-/Kleinschreibung des Antwort-Header-Schlüssels beibehalten möchten
auth : Basisauthentifizierung, z. B. „Benutzer:Passwort“, um einen Autorisierungsheader zu berechnen.
hostRewrite : schreibt den Standort-Hostnamen bei (201/301/302/307/308)-Weiterleitungen neu.
autoRewrite : schreibt den Standort-Host/Port bei (201/301/302/307/308)-Umleitungen basierend auf dem angeforderten Host/Port neu. Standard: false.
ProtocolRewrite : schreibt das Standortprotokoll auf (201/301/302/307/308) um und leitet zu „http“ oder „https“ weiter. Standard: null.
cookieDomainRewrite : schreibt die Domäne der set-cookie -Header neu. Mögliche Werte:
false (Standard): Cookie-Neuschreiben deaktivierencookieDomainRewrite: "new.domain" . Um die Domäne zu entfernen, verwenden Sie cookieDomainRewrite: "" ."*" um alle Domänen abzugleichen. Behalten Sie beispielsweise eine Domäne unverändert bei, schreiben Sie eine Domäne neu und entfernen Sie andere Domänen: cookieDomainRewrite: {
"unchanged.domain": "unchanged.domain",
"old.domain": "new.domain",
"*": ""
}
cookiePathRewrite : schreibt den Pfad der set-cookie -Header neu. Mögliche Werte:
false (Standard): Cookie-Neuschreiben deaktivierencookiePathRewrite: "/newPath/" . Um den Pfad zu entfernen, verwenden Sie cookiePathRewrite: "" . Um den Pfad zum Stammverzeichnis festzulegen, verwenden Sie cookiePathRewrite: "/" ."*" um alle Pfade abzugleichen. Um beispielsweise einen Pfad unverändert zu lassen, schreiben Sie einen Pfad neu und entfernen Sie andere Pfade: cookiePathRewrite: {
"/unchanged.path/": "/unchanged.path/",
"/old.path/": "/new.path/",
"*": ""
}
Header : Objekt mit zusätzlichen Headern, die Zielanfragen hinzugefügt werden sollen.
ProxyTimeout : Zeitüberschreitung (in Millisekunden) für ausgehende Proxy-Anfragen
Timeout : Timeout (in Millisekunden) für eingehende Anfragen
followRedirects : true/false, Standard: false – geben Sie an, ob Sie Weiterleitungen folgen möchten
selfHandleResponse true/false, wenn auf true gesetzt, wird keiner der webOutgoing-Durchgänge aufgerufen und es liegt in Ihrer Verantwortung, die Antwort angemessen zurückzugeben, indem Sie das proxyRes -Ereignis abhören und darauf reagieren
Puffer : Datenstrom, der als Anforderungstext gesendet werden soll. Möglicherweise verfügen Sie über eine Middleware, die den Anforderungsstrom verbraucht, bevor sie ihn weiterleitet. Wenn Sie beispielsweise den Hauptteil einer Anforderung in ein Feld namens „req.rawbody“ einlesen, können Sie dieses Feld in der Pufferoption erneut streamen:
'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);
};
HINWEIS: options.ws und options.ssl sind optional. options.target und options.forward dürfen nicht beide fehlen
Wenn Sie die Methode proxyServer.listen verwenden, gelten auch die folgenden Optionen:
Zurück nach oben
error : Das Fehlerereignis wird ausgegeben, wenn die Anforderung an das Ziel fehlschlägt. Wir führen keine Fehlerbehandlung für Nachrichten durch, die zwischen Client und Proxy sowie zwischen Proxy und Ziel weitergeleitet werden. Daher wird empfohlen, dass Sie auf Fehler achten und diese behandeln.proxyReq : Dieses Ereignis wird ausgegeben, bevor die Daten gesendet werden. Es gibt Ihnen die Möglichkeit, das ProxyReq-Anforderungsobjekt zu ändern. Gilt für „Web“-VerbindungenproxyReqWs : Dieses Ereignis wird ausgegeben, bevor die Daten gesendet werden. Es gibt Ihnen die Möglichkeit, das ProxyReq-Anforderungsobjekt zu ändern. Gilt für „Websocket“-VerbindungenproxyRes : Dieses Ereignis wird ausgegeben, wenn die Anfrage an das Ziel eine Antwort erhalten hat.open : Dieses Ereignis wird ausgegeben, sobald der Proxy-Websocket erstellt und an den Ziel-Websocket weitergeleitet wurde.close : Dieses Ereignis wird ausgegeben, sobald der Proxy-Websocket geschlossen wurde.proxySocket : Veraltet zugunsten von 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' ) ;
} ) ;Zurück nach oben
var proxy = new httpProxy . createProxyServer ( {
target : {
host : 'localhost' ,
port : 1337
}
} ) ;
proxy . close ( ) ;Zurück nach oben
Wenn Sie Ihre eigene Antwort nach Erhalt des proxyRes verarbeiten möchten, können Sie dies mit selfHandleResponse tun. Wie Sie unten sehen können, können Sie bei Verwendung dieser Option die proxyRes abfangen und lesen. Sie müssen jedoch auch darauf achten, auf die res selbst zu antworten, da der ursprüngliche Client sonst niemals Daten empfängt.
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 ) ;
Über dieses Zusatzmodul ist eine Proxy-Tabellen-API verfügbar, mit der Sie eine Reihe von Regeln definieren können, um übereinstimmende Routen in Zielrouten zu übersetzen, mit denen der Reverse-Proxy kommuniziert.
$ npm test
Logo erstellt von Diego Pasquali
Zurück nach oben
master unterscheiden muss)Zurück nach oben
Die MIT-Lizenz (MIT)
Copyright (c) 2010 – 2016 Charlie Robbins, Jarrett Cruger und die Mitwirkenden.
Hiermit wird jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die „Software“) erhält, kostenlos die Erlaubnis erteilt, mit der Software ohne Einschränkung zu handeln, einschließlich und ohne Einschränkung der Rechte zur Nutzung, zum Kopieren, Ändern und Zusammenführen , Kopien der Software zu veröffentlichen, zu verteilen, unterzulizenzieren und/oder zu verkaufen und Personen, denen die Software zur Verfügung gestellt wird, dies zu gestatten, vorbehaltlich der folgenden Bedingungen:
Der obige Urheberrechtshinweis und dieser Genehmigungshinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein.
DIE SOFTWARE WIRD „WIE BESEHEN“ ZUR VERFÜGUNG GESTELLT, OHNE JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GEWÄHRLEISTUNG, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GEWÄHRLEISTUNG DER MARKTGÄNGIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER HAFTBAR FÜR JEGLICHE ANSPRÜCHE, SCHÄDEN ODER ANDERE HAFTUNG, WEDER AUS EINER VERTRAGLICHEN HANDLUNG, AUS HANDLUNG ODER ANDERWEITIG, DIE SICH AUS, AUS ODER IN ZUSAMMENHANG MIT DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN HANDELN IN DER SOFTWARE ERGEBEN SOFTWARE.
