node http proxy
1.0.0
node-http-proxy est une bibliothèque de proxy HTTP programmable qui prend en charge les websockets. Il convient à la mise en œuvre de composants tels que des proxys inverses et des équilibreurs de charge.
npm install http-proxy --save
Retour en haut
Cliquez ici
Retour en haut
Un nouveau proxy est créé en appelant createProxyServer et en passant un objet options comme argument (les propriétés valides sont disponibles ici)
var httpProxy = require ( 'http-proxy' ) ;
var proxy = httpProxy . createProxyServer ( options ) ; // See (†)†À moins que Listen(..) soit invoqué sur l'objet, cela ne crée pas de serveur Web. Voir ci-dessous.
Un objet sera renvoyé avec quatre méthodes :
req, res, [options] (utilisé pour proxy les requêtes HTTP(S) régulières)req, socket, head, [options] (utilisé pour le proxy des requêtes WS(S))port d'écoute (une fonction qui enveloppe l'objet dans un serveur Web, pour votre commodité)[callback] (une fonction qui ferme le serveur Web interne et arrête l'écoute sur le port donné)Il est alors possible de proxyer les requêtes en appelant ces fonctions
http . createServer ( function ( req , res ) {
proxy . web ( req , res , { target : 'http://mytarget.com:8080' } ) ;
} ) ;Les erreurs peuvent être écoutées soit en utilisant l'API Event Emitter
proxy . on ( 'error' , function ( e ) {
...
} ) ;ou en utilisant l'API de rappel
proxy . web ( req , res , { target : 'http://mytarget.com:8080' } , function ( e ) { ... } ) ; Lorsqu'une requête est proxy, elle suit deux pipelines différents (disponibles ici) qui appliquent des transformations aux objets req et res . Le premier pipeline (entrant) est responsable de la création et de la manipulation du flux qui connecte votre client à la cible. Le deuxième pipeline (sortant) est responsable de la création et de la manipulation du flux qui, depuis votre cible, renvoie les données au client.
Retour en haut
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 ) ;†L'appel de Listen(..) déclenche la création d'un serveur Web. Sinon, seule l'instance proxy est créée.
Retour en haut
Cet exemple montre comment vous pouvez proxy une requête en utilisant votre propre serveur HTTP et vous pouvez également mettre votre propre logique pour gérer la requête.
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 ) ;Retour en haut
Cet exemple montre comment vous pouvez proxy une requête à l'aide de votre propre serveur HTTP qui modifie la requête proxy sortante en ajoutant un en-tête spécial.
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 ) ;Retour en haut
Parfois, lorsque vous recevez un document HTML/XML du serveur d'origine, vous souhaitez le modifier avant de le transmettre.
Harmon vous permet de le faire dans un style de streaming afin de minimiser la pression sur le proxy.
Retour en haut
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 ) ;Retour en haut
Vous pouvez activer la validation d'un certificat SSL sécurisé sur la connexion cible (éviter les certificats auto-signés), il suffit de définir secure: true dans les options.
//
// 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 ) ;Retour en haut
Vous pouvez activer la prise en charge websocket pour le proxy en utilisant ws:true dans les options.
//
// Create a proxy server for websockets
//
httpProxy . createServer ( {
target : 'ws://localhost:9014' ,
ws : true
} ) . listen ( 8014 ) ; Vous pouvez également proxy les requêtes websocket en appelant simplement la méthode 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 ) ;Retour en haut
httpProxy.createProxyServer prend en charge les options suivantes :
target : chaîne d'url à analyser avec le module url
forward : chaîne d'url à analyser avec le module url
agent : objet à passer à http(s).request (voir les objets agent https et agent http du nœud)
ssl : objet à passer à https.createServer()
ws : vrai/faux, si vous souhaitez proxy des websockets
xfwd : vrai/faux, ajoute les en-têtes x-forward
secure : vrai/faux, si vous souhaitez vérifier les certificats SSL
toProxy : vrai/faux, transmet l'URL absolue comme path (utile pour le proxy vers des proxys)
prependPath : true/false, Default: true - spécifiez si vous souhaitez ajouter le chemin de la cible au chemin du proxy
ignorePath : true/false, Default : false - spécifiez si vous souhaitez ignorer le chemin proxy de la requête entrante (remarque : vous devrez ajouter / manuellement si nécessaire).
localAddress : chaîne d'interface locale à lier pour les connexions sortantes
changeOrigin : true/false, Default : false - modifie l'origine de l'en-tête de l'hôte en URL cible
préserverHeaderKeyCase : true/false, Default: false - spécifiez si vous souhaitez conserver la casse des lettres de la clé d'en-tête de réponse
auth : Authentification de base, c'est-à-dire 'user:password' pour calculer un en-tête d'autorisation.
hostRewrite : réécrit le nom d'hôte de l'emplacement sur les redirections (201/301/302/307/308).
autoRewrite : réécrit l'emplacement hôte/port sur les redirections (201/301/302/307/308) en fonction de l'hôte/port demandé. Par défaut : faux.
protocolRewrite : réécrit le protocole de localisation sur les redirections (201/301/302/307/308) vers 'http' ou 'https'. Par défaut : nul.
cookieDomainRewrite : réécrit le domaine des en-têtes set-cookie . Valeurs possibles :
false (par défaut) : désactiver la réécriture des cookiescookieDomainRewrite: "new.domain" . Pour supprimer le domaine, utilisez cookieDomainRewrite: "" ."*" pour faire correspondre tous les domaines. Par exemple, conservez un domaine inchangé, réécrivez un domaine et supprimez les autres domaines : cookieDomainRewrite: {
"unchanged.domain": "unchanged.domain",
"old.domain": "new.domain",
"*": ""
}
cookiePathRewrite : réécrit le chemin des en-têtes set-cookie . Valeurs possibles :
false (par défaut) : désactiver la réécriture des cookiescookiePathRewrite: "/newPath/" . Pour supprimer le chemin, utilisez cookiePathRewrite: "" . Pour définir le chemin vers la racine, utilisez cookiePathRewrite: "/" ."*" pour faire correspondre tous les chemins. Par exemple, pour conserver un chemin inchangé, réécrivez un chemin et supprimez les autres : cookiePathRewrite: {
"/unchanged.path/": "/unchanged.path/",
"/old.path/": "/new.path/",
"*": ""
}
headers : objet avec des en-têtes supplémentaires à ajouter aux requêtes cibles.
proxyTimeout : timeout (en millis) pour les requêtes proxy sortantes
timeout : timeout (en millis) pour les requêtes entrantes
followRedirects : true/false, Par défaut : false - précisez si vous souhaitez suivre les redirections
selfHandleResponse true/false, si défini sur true, aucune des passes webOutgoing n'est appelée et il est de votre responsabilité de renvoyer la réponse de manière appropriée en écoutant et en agissant sur l'événement proxyRes .
buffer : flux de données à envoyer comme corps de la requête. Peut-être avez-vous un middleware qui consomme le flux de requête avant de le transmettre par proxy, par exemple. Si vous lisez le corps d'une requête dans un champ appelé « req.rawbody », vous pouvez retransmettre ce champ dans l'option buffer :
'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);
};
REMARQUE : options.ws et options.ssl sont facultatifs. options.target et options.forward ne peuvent pas manquer tous les deux
Si vous utilisez la méthode proxyServer.listen , les options suivantes sont également applicables :
Retour en haut
error : L'événement d'erreur est émis si la requête adressée à la cible échoue. Nous ne traitons pas les erreurs des messages transmis entre le client et le proxy, ni des messages transmis entre le proxy et la cible. Il est donc recommandé d'écouter les erreurs et de les gérer.proxyReq : Cet événement est émis avant l'envoi des données. Cela vous donne la possibilité de modifier l'objet de requête proxyReq. S'applique aux connexions "web"proxyReqWs : Cet événement est émis avant l'envoi des données. Cela vous donne la possibilité de modifier l'objet de requête proxyReq. S'applique aux connexions "websocket"proxyRes : Cet événement est émis si la requête adressée à la cible a obtenu une réponse.open : cet événement est émis une fois que le websocket proxy a été créé et redirigé vers le websocket cible.close : Cet événement est émis une fois le proxy websocket fermé.proxySocket : obsolète au profit 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' ) ;
} ) ;Retour en haut
var proxy = new httpProxy . createProxyServer ( {
target : {
host : 'localhost' ,
port : 1337
}
} ) ;
proxy . close ( ) ;Retour en haut
Si vous souhaitez gérer votre propre réponse après avoir reçu le proxyRes , vous pouvez le faire avec selfHandleResponse . Comme vous pouvez le voir ci-dessous, si vous utilisez cette option, vous pouvez intercepter et lire le proxyRes mais vous devez également vous assurer de répondre au res lui-même, sinon le client d'origine ne recevra jamais aucune donnée.
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 ) ;
Une API de table proxy est disponible via ce module complémentaire, qui vous permet de définir un ensemble de règles pour traduire les routes correspondantes en routes cibles avec lesquelles le proxy inverse communiquera.
$ npm test
Logo créé par Diego Pasquali
Retour en haut
master )Retour en haut
La licence MIT (MIT)
Copyright (c) 2010 - 2016 Charlie Robbins, Jarrett Cruger et les contributeurs.
L'autorisation est accordée par la présente, gratuitement, à toute personne obtenant une copie de ce logiciel et des fichiers de documentation associés (le « Logiciel »), d'utiliser le Logiciel sans restriction, y compris, sans limitation, les droits d'utilisation, de copie, de modification, de fusion. , publier, distribuer, accorder des sous-licences et/ou vendre des copies du Logiciel, et permettre aux personnes à qui le Logiciel est fourni de le faire, sous réserve des conditions suivantes :
L'avis de droit d'auteur ci-dessus et cet avis d'autorisation doivent être inclus dans toutes les copies ou parties substantielles du logiciel.
LE LOGICIEL EST FOURNI « EN L'ÉTAT », SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU IMPLICITE, Y COMPRIS MAIS SANS LIMITATION LES GARANTIES DE QUALITÉ MARCHANDE, D'ADAPTATION À UN USAGE PARTICULIER ET DE NON-VIOLATION. EN AUCUN CAS LES AUTEURS OU LES TITULAIRES DES DROITS D'AUTEUR NE SERONT RESPONSABLES DE TOUTE RÉCLAMATION, DOMMAGES OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS UNE ACTION CONTRACTUELLE, DÉLIT OU AUTRE, DÉCOULANT DE, DE OU EN RELATION AVEC LE LOGICIEL OU L'UTILISATION OU D'AUTRES TRANSACTIONS DANS LE LOGICIEL.
