Proxy com express.js

Para evitar problemas de AJAX no mesmo domínio, desejo que meu servidor da web node.js. encaminhe todas as solicitações da URL /api/BLABLApara outro servidor, por exemplo other_domain.com:3000/BLABLA, e retorne ao usuário a mesma coisa que esse servidor remoto retornou de forma transparente.

Todos os outros URLs (ao lado /api/*) devem ser veiculados diretamente, sem proxy.

Como conseguir isso com o node.js + express.js? Você pode dar um exemplo de código simples?

(o servidor da Web e o 3000servidor remoto estão sob meu controle, ambos executando o node.js com o express.js)

Até agora, encontrei este https://github.com/http-party/node-http-proxy , mas ler a documentação lá não me deixou mais sábio. Acabei com

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
    });
});

mas nada é retornado ao servidor Web original (ou ao usuário final), portanto, não há sorte.

Você deseja usar http.requestpara criar uma solicitação semelhante à API remota e retornar sua resposta.

Algo assim:

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: eu realmente não tentei o acima, por isso pode conter erros de análise, espero que isso lhe dê uma dica de como fazê-lo funcionar.

solicitação foi descontinuada em fevereiro de 2020, deixarei a resposta abaixo por motivos históricos, mas considere a possibilidade de mudar para uma alternativa listada nesta edição .

Arquivo

Fiz algo semelhante, mas usei request :

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 isso ajude, demorei um pouco para perceber que eu poderia fazer isso :)

Encontrei uma solução mais curta e direta que funciona perfeitamente e com autenticação, 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
});

E então simplesmente:

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

Nota: conforme mencionado por @MaxPRafferty, use req.originalUrlno lugar de baseUrlpara preservar a string de consulta :

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

Atualização: Como mencionado por Andrew (obrigado!), Há uma solução pronta usando o mesmo princípio:

npm i --save http-proxy-middleware

E depois:

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

Documentação: http-proxy-middleware no Github

Sei que estou atrasado para participar desta festa, mas espero que isso ajude alguém.

Para estender a resposta do trigoman (créditos completos para ele) para trabalhar com o POST (também pode funcionar com o 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);
});

Usei a seguinte configuração para direcionar tudo /restpara o servidor back-end (na porta 8080) e todas as outras solicitações ao servidor front-end (um servidor webpack na porta 3001). Ele suporta todos os métodos HTTP, não perde nenhuma meta-informação de solicitação e suporta websockets (que eu preciso para recarregar a quente)

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);

Primeiro instale express e http-proxy-middleware

npm install express http-proxy-middleware --save

Em seguida, no seu 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');
});

Neste exemplo, servimos o site na porta 3000, mas quando uma solicitação termina com / api, a redirecionamos para localhost: 8080.

http: // localhost: 3000 / api / login redirecione para http: // localhost: 8080 / api / login

Ok, aqui está uma resposta pronta para copiar e colar usando o módulo require ('request') npm e uma variável de ambiente * em vez de um 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);
});

Encontrei uma solução mais curta que faz exatamente o que eu quero https://github.com/http-party/node-http-proxy

Depois de instalar http-proxy

npm install http-proxy --save

Use-o como abaixo em seu server / index / app.js

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

Eu realmente passei dias procurando em todos os lugares para evitar esse problema, tentei muitas soluções e nenhuma delas funcionou além desta.

Espero que ajude alguém também :)

Não tenho uma amostra expressa, mas uma com http-proxyembalagem simples . Uma versão simplificada do proxy que usei no meu blog.

Em resumo, todos os pacotes proxy proxy nodejs funcionam no nível do protocolo http, não no nível tcp (soquete). Isso também se aplica ao middleware expresso e a todos os expressos. Nenhum deles pode fazer proxy transparente, nem NAT, o que significa manter o IP da origem do tráfego de entrada no pacote enviado ao servidor da web de back-end.

No entanto, o servidor da Web pode coletar o IP original de cabeçalhos http x encaminhados e adicioná-lo ao log.

O recurso xfwd: truein proxyOptionenable x-forward header 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();

Referência para o cabeçalho X-Forwarded: https://en.wikipedia.org/wiki/X-Forwarded-For

Versão completa do meu proxy: https://github.com/J-Siu/ghost-https-nodejs-proxy