Proxy avec express.js

Pour éviter les problèmes AJAX de même domaine, je veux que mon serveur Web node.js transfère toutes les demandes de l'URL /api/BLABLAvers un autre serveur, par exemple other_domain.com:3000/BLABLA, et renvoie à l'utilisateur la même chose que ce serveur distant a renvoyé, de manière transparente.

Toutes les autres URL (à côté /api/*) doivent être servies directement, pas de proxy.

Comment puis-je y parvenir avec node.js + express.js? Pouvez-vous donner un exemple de code simple?

(le serveur Web et le 3000serveur distant sont sous mon contrôle, tous deux exécutant node.js avec express.js)

Jusqu'à présent, j'ai trouvé cela https://github.com/http-party/node-http-proxy , mais la lecture de la documentation ne m'a pas rendu plus sage. J'ai fini avec

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

mais rien n'est retourné au serveur Web d'origine (ou à l'utilisateur final), donc pas de chance.

Vous souhaitez utiliser http.requestpour créer une demande similaire à l'API distante et renvoyer sa réponse.

Quelque chose comme ça:

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

Remarque: je n'ai pas vraiment essayé ce qui précède, il peut donc contenir des erreurs d'analyse, j'espère que cela vous donnera un indice sur la façon de le faire fonctionner.

La demande est obsolète depuis février 2020, je laisserai la réponse ci-dessous pour des raisons historiques, mais veuillez envisager de passer à une alternative répertoriée dans ce numéro .

Archiver

J'ai fait quelque chose de similaire mais j'ai utilisé la requête à la place:

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

J'espère que cela aide, il m'a fallu un certain temps pour réaliser que je pouvais le faire :)

J'ai trouvé une solution plus courte et très simple qui fonctionne de manière transparente, et avec l'authentification également, en utilisant 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
});

Et puis simplement:

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

Remarque: comme mentionné par @MaxPRafferty, utilisez req.originalUrlà la place de baseUrlpour conserver la chaîne de requête:

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

Mise à jour: Comme mentionné par Andrew (merci!), Il existe une solution toute faite utilisant le même principe:

npm i --save http-proxy-middleware

Puis:

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

Documentation: http-proxy-middleware sur Github

Je sais que je suis en retard pour rejoindre cette fête, mais j'espère que cela aidera quelqu'un.

Pour étendre la réponse de trigoman (tous les crédits à lui) pour travailler avec POST (pourrait aussi faire fonctionner avec 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);
});

J'ai utilisé la configuration suivante pour tout diriger /restvers mon serveur principal (sur le port 8080), et toutes les autres demandes vers le serveur frontal (un serveur Webpack sur le port 3001). Il prend en charge toutes les méthodes HTTP, ne perd aucune méta-info de requête et prend en charge les websockets (dont j'ai besoin pour le rechargement à chaud)

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

Installez d'abord express et http-proxy-middleware

npm install express http-proxy-middleware --save

Puis dans votre 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');
});

Dans cet exemple, nous servons le site sur le port 3000, mais lorsqu'une requête se termine par / api, nous la redirigeons vers localhost: 8080.

http: // localhost: 3000 / api / login redirection vers http: // localhost: 8080 / api / login

Ok, voici une réponse prête à copier-coller utilisant le module npm require ('request') et une variable d'environnement * au lieu d'un proxy codé en dur):

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

J'ai trouvé une solution plus courte qui fait exactement ce que je veux https://github.com/http-party/node-http-proxy

Après l'installation http-proxy

npm install http-proxy --save

Utilisez-le comme ci-dessous dans votre serveur / index / app.js

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

J'ai vraiment passé des jours à chercher partout pour éviter ce problème, j'ai essayé de nombreuses solutions et aucune d'entre elles n'a fonctionné à part celle-ci.

J'espère que cela aidera aussi quelqu'un d'autre :)

Je n'ai pas d'échantillon express, mais un avec un http-proxyemballage simple . Une version très dépouillée du proxy que j'ai utilisé pour mon blog.

En bref, tous les packages proxy http de nodejs fonctionnent au niveau du protocole http, et non au niveau tcp (socket). Ceci est également vrai pour les middlewares express et tous les middleware express. Aucun d'entre eux ne peut faire de proxy transparent, ni de NAT, ce qui signifie conserver l'adresse IP de la source du trafic entrant dans le paquet envoyé au serveur Web principal.

Cependant, le serveur Web peut récupérer l'adresse IP d'origine des en-têtes http x-forwarded et l'ajouter au journal.

La fonctionnalité d' xfwd: trueen proxyOption-tête in enable x-forward pour 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();

Référence pour l'en-tête X-Forwarded: https://en.wikipedia.org/wiki/X-Forwarded-For

Version complète de mon proxy: https://github.com/J-Siu/ghost-https-nodejs-proxy