node http proxy
1.0.0
node-http-proxy es una biblioteca de proxy programable HTTP que admite websockets. Es adecuado para implementar componentes como proxies inversos y equilibradores de carga.
npm install http-proxy --save
Volver arriba
haga clic aquí
Volver arriba
Se crea un nuevo proxy llamando createProxyServer y pasando un objeto options como argumento (las propiedades válidas están disponibles aquí)
var httpProxy = require ( 'http-proxy' ) ;
var proxy = httpProxy . createProxyServer ( options ) ; // See (†)†A menos que se invoque listening(..) en el objeto, esto no crea un servidor web. Vea abajo.
Se devolverá un objeto con cuatro métodos:
req, res, [options] (usado para enviar solicitudes HTTP(S) regulares)req, socket, head, [options] (usado para enviar solicitudes WS(S))port de escucha (una función que envuelve el objeto en un servidor web, para su comodidad)[callback] (una función que cierra el servidor web interno y deja de escuchar en un puerto determinado)Entonces es posible enviar solicitudes mediante proxy llamando a estas funciones
http . createServer ( function ( req , res ) {
proxy . web ( req , res , { target : 'http://mytarget.com:8080' } ) ;
} ) ;Los errores se pueden escuchar utilizando la API del emisor de eventos
proxy . on ( 'error' , function ( e ) {
...
} ) ;o usando la API de devolución de llamada
proxy . web ( req , res , { target : 'http://mytarget.com:8080' } , function ( e ) { ... } ) ; Cuando una solicitud se envía mediante proxy, sigue dos canales diferentes (disponibles aquí) que aplican transformaciones tanto al objeto req como res . La primera canalización (entrante) es responsable de la creación y manipulación de la secuencia que conecta a su cliente con el objetivo. El segundo canal (saliente) es responsable de la creación y manipulación del flujo que, desde su objetivo, devuelve datos al cliente.
Volver arriba
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 ) ;†Invocar listening(..) desencadena la creación de un servidor web. De lo contrario, solo se crea la instancia de proxy.
Volver arriba
Este ejemplo muestra cómo puede enviar una solicitud utilizando su propio servidor HTTP y también puede poner su propia lógica para manejar la solicitud.
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 ) ;Volver arriba
Este ejemplo muestra cómo puede enviar una solicitud utilizando su propio servidor HTTP que modifica la solicitud de proxy saliente agregando un encabezado especial.
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 ) ;Volver arriba
A veces, cuando recibe un documento HTML/XML del servidor de origen, desea modificarlo antes de reenviarlo.
Harmon le permite hacer esto en un estilo de transmisión para mantener la presión sobre el proxy al mínimo.
Volver arriba
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 ) ;Volver arriba
Puede activar la validación de un certificado SSL seguro para la conexión de destino (evite los certificados autofirmados), simplemente configure secure: true en las opciones.
//
// 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 ) ;Volver arriba
Puede activar el soporte websocket para el proxy usando ws:true en las opciones.
//
// Create a proxy server for websockets
//
httpProxy . createServer ( {
target : 'ws://localhost:9014' ,
ws : true
} ) . listen ( 8014 ) ; También puede representar las solicitudes de websocket simplemente llamando al método 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 ) ;Volver arriba
httpProxy.createProxyServer admite las siguientes opciones:
objetivo : cadena de URL que se analizará con el módulo de URL
adelante : cadena de URL que se analizará con el módulo de URL
agente : objeto que se pasará a http(s).request (consulte Agente https de Node y objetos de agente http)
ssl : objeto que se pasará a https.createServer()
ws : verdadero/falso, si desea proxy de websockets
xfwd : verdadero/falso, agrega encabezados x-forward
seguro : verdadero/falso, si desea verificar los certificados SSL
toProxy : verdadero/falso, pasa la URL absoluta como path (útil para enviar proxy a servidores proxy)
prependPath : verdadero/falso, predeterminado: verdadero: especifique si desea anteponer la ruta del destino a la ruta del proxy
ignorePath : verdadero/falso, Valor predeterminado: falso: especifique si desea ignorar la ruta del proxy de la solicitud entrante (nota: deberá agregar / manualmente si es necesario).
localAddress : cadena de interfaz local para vincular conexiones salientes
changeOrigin : verdadero/falso, predeterminado: falso: cambia el origen del encabezado del host a la URL de destino
preserveHeaderKeyCase : verdadero/falso, predeterminado: falso: especifique si desea mantener mayúsculas y minúsculas en la clave del encabezado de respuesta
auth : autenticación básica, es decir, 'usuario:contraseña' para calcular un encabezado de autorización.
hostRewrite : reescribe el nombre de host de la ubicación en las redirecciones (201/301/302/307/308).
autoRewrite : reescribe la ubicación del host/puerto en (201/301/302/307/308) redirecciones según el host/puerto solicitado. Valor predeterminado: falso.
protocolRewrite : reescribe el protocolo de ubicación en (201/301/302/307/308) redirecciones a 'http' o 'https'. Valor predeterminado: nulo.
cookieDomainRewrite : reescribe el dominio de los encabezados set-cookie . Valores posibles:
false (predeterminado): deshabilita la reescritura de cookiescookieDomainRewrite: "new.domain" . Para eliminar el dominio, utilice cookieDomainRewrite: "" ."*" para hacer coincidir todos los dominios. Por ejemplo, mantenga un dominio sin cambios, reescriba un dominio y elimine otros dominios: cookieDomainRewrite: {
"unchanged.domain": "unchanged.domain",
"old.domain": "new.domain",
"*": ""
}
cookiePathRewrite : reescribe la ruta de los encabezados set-cookie . Valores posibles:
false (predeterminado): deshabilita la reescritura de cookiescookiePathRewrite: "/newPath/" . Para eliminar la ruta, utilice cookiePathRewrite: "" . Para establecer la ruta a la raíz, use cookiePathRewrite: "/" ."*" para hacer coincidir todas las rutas. Por ejemplo, para mantener una ruta sin cambios, reescriba una ruta y elimine otras rutas: cookiePathRewrite: {
"/unchanged.path/": "/unchanged.path/",
"/old.path/": "/new.path/",
"*": ""
}
encabezados : objeto con encabezados adicionales que se agregarán a las solicitudes de destino.
proxyTimeout : tiempo de espera (en milisegundos) para solicitudes de proxy salientes
timeout : tiempo de espera (en milisegundos) para solicitudes entrantes
followRedirects : verdadero/falso, predeterminado: falso: especifique si desea seguir las redirecciones
selfHandleResponse verdadero/falso, si se establece en verdadero, no se llama a ninguno de los pases webOutgoing y es su responsabilidad devolver adecuadamente la respuesta escuchando y actuando en el evento proxyRes
buffer : flujo de datos para enviar como cuerpo de la solicitud. Tal vez tenga algún middleware que consuma el flujo de solicitud antes de enviarlo por proxy, por ejemplo, si lee el cuerpo de una solicitud en un campo llamado 'req.rawbody', puede volver a transmitir este campo en la opción de búfer:
'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);
};
NOTA: options.ws y options.ssl son opcionales. options.target y options.forward no pueden faltar al mismo tiempo
Si está utilizando el método proxyServer.listen , las siguientes opciones también son aplicables:
Volver arriba
error : el evento de error se emite si falla la solicitud al destino. No realizamos ningún manejo de errores de los mensajes pasados entre el cliente y el proxy, ni de los mensajes pasados entre el proxy y el destino, por lo que se recomienda que escuche los errores y los maneje.proxyReq : este evento se emite antes de enviar los datos. Le brinda la oportunidad de modificar el objeto de solicitud proxyReq. Se aplica a conexiones "web"proxyReqWs : este evento se emite antes de enviar los datos. Le brinda la oportunidad de modificar el objeto de solicitud proxyReq. Se aplica a conexiones "websocket"proxyRes : este evento se emite si la solicitud al objetivo obtuvo una respuesta.open : este evento se emite una vez que se creó el websocket proxy y se canalizó al websocket de destino.close : este evento se emite una vez que se cierra el websocket proxy.proxySocket : obsoleto en favor de 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' ) ;
} ) ;Volver arriba
var proxy = new httpProxy . createProxyServer ( {
target : {
host : 'localhost' ,
port : 1337
}
} ) ;
proxy . close ( ) ;Volver arriba
Si desea manejar su propia respuesta después de recibir proxyRes , puede hacerlo con selfHandleResponse . Como puede ver a continuación, si usa esta opción, podrá interceptar y leer el proxyRes , pero también debe asegurarse de responder al res , de lo contrario, el cliente original nunca recibirá ningún dato.
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 ) ;
Una API de tabla de proxy está disponible a través de este módulo complementario, que le permite definir un conjunto de reglas para traducir rutas coincidentes en rutas de destino con las que hablará el proxy inverso.
$ npm test
Logotipo creado por Diego Pasquali
Volver arriba
master )Volver arriba
La licencia MIT (MIT)
Copyright (c) 2010 - 2016 Charlie Robbins, Jarrett Cruger y los colaboradores.
Por el presente se otorga permiso, sin cargo, a cualquier persona que obtenga una copia de este software y los archivos de documentación asociados (el "Software"), para operar con el Software sin restricciones, incluidos, entre otros, los derechos de uso, copia, modificación, fusión. , publicar, distribuir, sublicenciar y/o vender copias del Software, y permitir que las personas a quienes se les proporciona el Software lo hagan, sujeto a las siguientes condiciones:
El aviso de derechos de autor anterior y este aviso de permiso se incluirán en todas las copias o partes sustanciales del Software.
EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO, PERO NO LIMITADO A, LAS GARANTÍAS DE COMERCIABILIDAD, IDONEIDAD PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O TITULARES DE DERECHOS DE AUTOR SERÁN RESPONSABLES DE NINGÚN RECLAMO, DAÑO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN CONTRACTUAL, AGRAVIO O DE OTRA MANERA, QUE SURJA DE, FUERA DE O EN RELACIÓN CON EL SOFTWARE O EL USO U OTRAS NEGOCIOS EN EL SOFTWARE.
