Proxy con express.js

Para evitar problemas de AJAX en el mismo dominio, quiero que mi servidor web node.js reenvíe todas las solicitudes de URL /api/BLABLAa otro servidor, por ejemplo other_domain.com:3000/BLABLA, y devuelva al usuario lo mismo que devolvió este servidor remoto, de forma transparente.

Todas las demás URL (al lado /api/*) se deben servir directamente, sin proxy.

¿Cómo logro esto con node.js + express.js? ¿Puedes dar un ejemplo de código simple?

(tanto el servidor web como el 3000servidor remoto están bajo mi control, ambos ejecutan node.js con express.js)

Hasta ahora encontré este https://github.com/http-party/node-http-proxy , pero leer la documentación allí no me hizo más sabio. Terminé con

var proxy = new httpProxy.RoutingProxy();
app.all("/api/*", function(req, res) {
    console.log("old request url " + req.url)
    req.url = '/' + req.url.split('/').slice(2).join('/'); // remove the '/api' part
    console.log("new request url " + req.url)
    proxy.proxyRequest(req, res, {
        host: "other_domain.com",
        port: 3000
    });
});

pero no se devuelve nada al servidor web original (o al usuario final), así que no tuvimos suerte.

Quieres usar http.request para crear una solicitud similar a la API remota y devolver su respuesta.

Algo como esto:

const http = require('http');
// or use import http from 'http';


/* your app config here */

app.post('/api/BLABLA', (oreq, ores) => {
  const options = {
    // host to forward to
    host: 'www.google.com',
    // port to forward to
    port: 80,
    // path to forward to
    path: '/api/BLABLA',
    // request method
    method: 'POST',
    // headers to send
    headers: oreq.headers,
  };

  const creq = http
    .request(options, pres => {
      // set encoding
      pres.setEncoding('utf8');

      // set http status code based on proxied response
      ores.writeHead(pres.statusCode);

      // wait for data
      pres.on('data', chunk => {
        ores.write(chunk);
      });

      pres.on('close', () => {
        // closed, let's end client request as well
        ores.end();
      });

      pres.on('end', () => {
        // finished, let's finish client request as well
        ores.end();
      });
    })
    .on('error', e => {
      // we got an error
      console.log(e.message);
      try {
        // attempt to set error message and http status
        ores.writeHead(500);
        ores.write(e.message);
      } catch (e) {
        // ignore
      }
      ores.end();
    });

  creq.end();
});

Aviso: Realmente no he probado lo anterior, por lo que podría contener errores de análisis, con suerte, esto le dará una pista sobre cómo hacerlo funcionar.

la solicitud ha quedado en desuso a partir de febrero de 2020, dejaré la respuesta a continuación por razones históricas, pero considere pasar a una alternativa que figura en este número .

Archivo

Hice algo similar pero usé request en su lugar:

var request = require('request');
app.get('/', function(req,res) {
  //modify the url in any way you want
  var newurl = 'http://google.com/';
  request(newurl).pipe(res);
});

Espero que esto ayude, me tomó un tiempo darme cuenta de que podía hacer esto :)

Encontré una solución más corta y sencilla que funciona a la perfección, y también con autenticación, usando express-http-proxy:

const url = require('url');
const proxy = require('express-http-proxy');

// New hostname+path as specified by question:
const apiProxy = proxy('other_domain.com:3000/BLABLA', {
    proxyReqPathResolver: req => url.parse(req.baseUrl).path
});

Y luego simplemente:

app.use('/api/*', apiProxy);

Nota: como lo menciona @MaxPRafferty, use req.originalUrlen lugar de baseUrlpara preservar la cadena de consulta:

    forwardPath: req => url.parse(req.baseUrl).path

Actualización: como mencionó Andrew (¡gracias!), Hay una solución preparada que utiliza el mismo principio:

npm i --save http-proxy-middleware

Y entonces:

const proxy = require('http-proxy-middleware')
var apiProxy = proxy('/api', {target: 'http://www.example.org/api'});
app.use(apiProxy)

Documentación: http-proxy-middleware en Github

Sé que llego tarde a unirme a esta fiesta, pero espero que esto ayude a alguien.

Para extender la respuesta de trigoman (créditos completos para él) para trabajar con POST (también podría hacer que funcione con PUT, etc.):

app.use('/api', function(req, res) {
  var url = 'YOUR_API_BASE_URL'+ req.url;
  var r = null;
  if(req.method === 'POST') {
     r = request.post({uri: url, json: req.body});
  } else {
     r = request(url);
  }

  req.pipe(r).pipe(res);
});

Utilicé la siguiente configuración para dirigir todo /resta mi servidor back-end (en el puerto 8080), y todas las demás solicitudes al servidor frontend (un servidor webpack en el puerto 3001). Admite todos los métodos HTTP, no pierde ninguna metainformación de solicitud y admite sockets web (que necesito para la recarga en caliente)

var express  = require('express');
var app      = express();
var httpProxy = require('http-proxy');
var apiProxy = httpProxy.createProxyServer();
var backend = 'http://localhost:8080',
    frontend = 'http://localhost:3001';

app.all("/rest/*", function(req, res) {
  apiProxy.web(req, res, {target: backend});
});

app.all("/*", function(req, res) {
    apiProxy.web(req, res, {target: frontend});
});

var server = require('http').createServer(app);
server.on('upgrade', function (req, socket, head) {
  apiProxy.ws(req, socket, head, {target: frontend});
});
server.listen(3000);

Primero instale express y http-proxy-middleware

npm install express http-proxy-middleware --save

Luego en su server.js

const express = require('express');
const proxy = require('http-proxy-middleware');

const app = express();
app.use(express.static('client'));

// Add middleware for http proxying 
const apiProxy = proxy('/api', { target: 'http://localhost:8080' });
app.use('/api', apiProxy);

// Render your site
const renderIndex = (req, res) => {
  res.sendFile(path.resolve(__dirname, 'client/index.html'));
}
app.get('/*', renderIndex);

app.listen(3000, () => {
  console.log('Listening on: http://localhost:3000');
});

En este ejemplo, servimos el sitio en el puerto 3000, pero cuando una solicitud finaliza con / api, lo redirigimos a localhost: 8080.

http: // localhost: 3000 / api / login redirige a http: // localhost: 8080 / api / login

Ok, aquí hay una respuesta lista para copiar y pegar usando el módulo require ('request') npm y una variable de entorno * en lugar de un proxy codificado):

coffeescript

app.use (req, res, next) ->                                                 
  r = false
  method = req.method.toLowerCase().replace(/delete/, 'del')
  switch method
    when 'get', 'post', 'del', 'put'
      r = request[method](
        uri: process.env.PROXY_URL + req.url
        json: req.body)
    else
      return res.send('invalid method')
  req.pipe(r).pipe res

javascript:

app.use(function(req, res, next) {
  var method, r;
  method = req.method.toLowerCase().replace(/delete/,"del");
  switch (method) {
    case "get":
    case "post":
    case "del":
    case "put":
      r = request[method]({
        uri: process.env.PROXY_URL + req.url,
        json: req.body
      });
      break;
    default:
      return res.send("invalid method");
  }
  return req.pipe(r).pipe(res);
});

Encontré una solución más corta que hace exactamente lo que quiero https://github.com/http-party/node-http-proxy

Después de instalar http-proxy

npm install http-proxy --save

Úselo como a continuación en su servidor / index / app.js

var proxyServer = require('http-route-proxy');
app.use('/api/BLABLA/', proxyServer.connect({
  to: 'other_domain.com:3000/BLABLA',
  https: true,
  route: ['/']
}));

Realmente he pasado días buscando en todas partes para evitar este problema, probé muchas soluciones y ninguna funcionó excepto esta.

Espero que ayude a alguien más también :)

No tengo una muestra exprés, pero una simple http-proxy paquete . Una versión muy simple del proxy que utilicé para mi blog.

En resumen, todos los paquetes proxy proxy de nodejs funcionan en el nivel de protocolo http, no en el nivel tcp (socket). Esto también es cierto para express y todos los middleware express. Ninguno de ellos puede hacer proxy transparente, ni NAT, lo que significa mantener la IP de la fuente de tráfico entrante en el paquete enviado al servidor web de fondo.

Sin embargo, el servidor web puede recoger la IP original de los encabezados http x-reenviados y agregarla al registro.

La función xfwd: truede proxyOptionactivación de encabezado x-forward para http-proxy.

const url = require('url');
const proxy = require('http-proxy');

proxyConfig = {
    httpPort: 8888,
    proxyOptions: {
        target: {
            host: 'example.com',
            port: 80
        },
        xfwd: true // <--- This is what you are looking for.
    }
};

function startProxy() {

    proxy
        .createServer(proxyConfig.proxyOptions)
        .listen(proxyConfig.httpPort, '0.0.0.0');

}

startProxy();

Referencia para el encabezado X-Fordered: https://en.wikipedia.org/wiki/X-Forwards-For

Versión completa de mi proxy: https://github.com/J-Siu/ghost-https-nodejs-proxy