Proxy avec express.js

Question

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

Toutes les autres URLs (à l'exception de /api/*) doivent être servies directement, sans proxy.

Comment puis-je réaliser cela avec node.js + express.js ? Pouvez-vous donner un exemple de code simplifié ?

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

---

Jusqu'à présent, j'ai trouvé ceci https://github.com/http-party/node-http-proxy , mais la lecture de la documentation là-bas 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 renvoyé au serveur web d'origine (ou à l'utilisateur final), donc pas de chance.

Answer 1

Notez que request a été obsolète en février 2020, je laisse donc la réponse ci-dessous pour des raisons historiques, mais veuillez envisager de passer à une alternative répertoriée dans ce problème, passer à l'API Fetch intégrée nativement (à partir de Node 18), ou utiliser express-http-proxy.

Réponse originale

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

var request = require('request');
app.get('/', function(req,res) {
  //modifier l'url de la manière que vous voulez
  var newurl = 'http://google.com/';
  request(newurl).pipe(res);
});

Answer 2

J'ai trouvé une solution plus courte et très directe qui fonctionne parfaitement, et avec l'authentification aussi, en utilisant express-http-proxy:

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

// Nouveau nom d'hôte+chemin tel que spécifié dans la question:
const apiProxy = proxy('other_domain.com:3000/BLABLA', {
    proxyReqPathResolver: req => url.parse(req.baseUrl).path
});

Et ensuite simplement :

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

Remarque : comme indiqué par @MaxPRafferty, utilisez req.originalUrl à la place de baseUrl pour préserver la chaîne de requête :

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

Mise à jour : Comme l'a mentionné Andrew (merci!), il existe une solution prête à l'emploi utilisant le même principe :

npm i --save http-proxy-middleware

Et ensuite :

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

Answer 3

Vous voulez utiliser http.request pour créer une requête similaire à l'API distante et renvoyer sa réponse.

Quelque chose comme ceci :

const http = require('http');
// ou utilisez import http from 'http';

/* votre configuration d'application ici */

app.post('/api/BLABLA', (oreq, ores) => {
  const options = {
    // hôte de renvoi
    host: 'www.google.com',
    // port de renvoi
    port: 80,
    // chemin de renvoi
    path: '/api/BLABLA',
    // méthode de requête
    method: 'POST',
    // en-têtes à envoyer
    headers: oreq.headers,
  };

  const creq = http
    .request(options, pres => {
      // définir l'encodage
      pres.setEncoding('utf8');

      // définir le code d'état HTTP en fonction de la réponse renvoyée
      ores.writeHead(pres.statusCode);

      // attendre les données
      pres.on('data', chunk => {
        ores.write(chunk);
      });

      pres.on('close', () => {
        // fermé, terminons également la demande du client
        ores.end();
      });

      pres.on('end', () => {
        // terminé, terminons également la demande du client
        ores.end();
      });
    })
    .on('error', e => {
      // nous avons eu une erreur
      console.log(e.message);
      try {
        // tentative de définir le message d'erreur et le code d'état HTTP
        ores.writeHead(500);
        ores.write(e.message);
      } catch (e) {
        // ignorer
      }
      ores.end();
    });

  creq.end();
});

Remarque : Je n'ai pas vraiment essayé ce qui précède, donc cela pourrait contenir des erreurs d'analyse ; espérons que cela vous donnera une indication sur la façon de le faire fonctionner.

Answer 4

Pour étendre la réponse de trigoman (tous les crédits lui reviennent) pour fonctionner avec POST (peut également fonctionner avec PUT etc) :

app.use('/api', function(req, res) {
  var url = 'VOTRE_URL_DE_BASE_API'+ 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);
});

Answer 5

J'ai utilisé la configuration suivante pour rediriger tout sur /rest vers mon serveur backend (sur le port 8080), et toutes les autres requêtes vers le serveur frontend (un serveur webpack sur le port 3001). Il prend en charge toutes les méthodes HTTP, ne perd aucune information méta-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);