Wie kann ich einen http-Proxy mit node.js http.Client verwenden?

Ich möchte einen ausgehenden HTTP-Aufruf von node.js unter Verwendung des Standards tätigen http.Client. Ich kann den Remote-Server jedoch nicht direkt von meinem Netzwerk aus erreichen und muss einen Proxy verwenden.

Wie kann ich node.js anweisen, den Proxy zu verwenden?

Die Antwort von Tim Macfarlane war in Bezug auf die Verwendung eines HTTP-Proxys nah.

Die Verwendung eines HTTP-Proxys (für nicht sichere Anforderungen) ist sehr einfach. Sie stellen eine Verbindung zum Proxy her und stellen die Anforderung normal, mit der Ausnahme, dass der Pfadteil die vollständige URL enthält und der Host-Header auf den Host festgelegt ist, zu dem Sie eine Verbindung herstellen möchten.
Tim war sehr nah an seiner Antwort, aber er vermisste es, den Host-Header richtig einzustellen.

var http = require("http");

var options = {
  host: "proxy",
  port: 8080,
  path: "http://www.google.com",
  headers: {
    Host: "www.google.com"
  }
};
http.get(options, function(res) {
  console.log(res);
  res.pipe(process.stdout);
});

Für die Aufzeichnung funktioniert seine Antwort mit http://nodejs.org/, aber das liegt daran, dass es ihrem Server egal ist, dass der Host-Header falsch ist.

Sie können request verwenden . Ich habe gerade festgestellt, dass es unglaublich einfach ist, Proxy auf node.js zu verwenden, nur mit einem externen "Proxy" -Parameter. Außerdem unterstützt es HTTPS über einen http-Proxy.

var request = require('request');

request({
  'url':'https://anysite.you.want/sub/sub',
  'method': "GET",
  'proxy':'http://yourproxy:8087'
},function (error, response, body) {
  if (!error && response.statusCode == 200) {
    console.log(body);
  }
})

Eine Sache, die ich eine Weile gebraucht habe, um herauszufinden, verwenden Sie 'http', um auf den Proxy zuzugreifen, selbst wenn Sie versuchen, einen Proxy zu einem https-Server durchzuführen. Dies funktioniert bei mir mit Charles (osx protocol analyzer):

var http = require('http');

http.get ({
    host: '127.0.0.1',
    port: 8888,
    path: 'https://www.google.com/accounts/OAuthGetRequestToken'
}, function (response) {
    console.log (response);
});

Wie hier bereits erwähnt, kommt der Proxy-HTTP-Verkehr in ganz normalen HTTP-Anforderungen. Stellen Sie die Anforderung an den Proxy und übergeben Sie die vollständige URL des Ziels als Pfad.

var http = require ('http');

http.get ({
    host: 'my.proxy.com',
    port: 8080,
    path: 'http://nodejs.org/'
}, function (response) {
    console.log (response);
});

Ich dachte, ich würde dieses Modul hinzufügen, das ich gefunden habe: https://www.npmjs.org/package/global-tunnel , was für mich großartig funktioniert hat (funktionierte sofort mit allen meinen Code- und Drittanbieter-Modulen mit nur dem folgenden Code).

require('global-tunnel').initialize({
  host: '10.0.0.10',
  port: 8080
});

Wenn Sie dies einmal tun, durchlaufen alle http (und https) in Ihrer Anwendung den Proxy.

Alternativ anrufen

require('global-tunnel').initialize();

Verwendet die http_proxyUmgebungsvariable

Ich habe einen privaten Proxyserver gekauft und nach dem Kauf Folgendes erhalten:

255.255.255.255 // IP address of proxy server
99999 // port of proxy server
username // authentication username of proxy server
password // authentication password of proxy server

Und ich wollte es benutzen. Die erste und die zweite Antwort funktionierten nur für http (Proxy) -> http (Ziel), ich wollte jedoch http (Proxy) -> https (Ziel).

Und für das https-Ziel ist es besser, den HTTP-Tunnel direkt zu verwenden. Ich habe hier eine Lösung gefunden . Endgültiger Code:

const http = require('http')
const https = require('https')
const username = 'username'
const password = 'password'
const auth = 'Basic ' + Buffer.from(username + ':' + password).toString('base64')

http.request({
  host: '255.255.255.255', // IP address of proxy server
  port: 99999, // port of proxy server
  method: 'CONNECT',
  path: 'kinopoisk.ru:443', // some destination, add 443 port for https!
  headers: {
    'Proxy-Authorization': auth
  },
}).on('connect', (res, socket) => {
  if (res.statusCode === 200) { // connected to proxy server
    https.get({
      host: 'www.kinopoisk.ru',
      socket: socket,    // using a tunnel
      agent: false,      // cannot use a default agent
      path: '/your/url'  // specify path to get from server
    }, (res) => {
      let chunks = []
      res.on('data', chunk => chunks.push(chunk))
      res.on('end', () => {
        console.log('DONE', Buffer.concat(chunks).toString('utf8'))
      })
    })
  }
}).on('error', (err) => {
  console.error('error', err)
}).end()

Das http-Paket 'request' scheint folgende Funktion zu haben:

https://github.com/mikeal/request

Das folgende Anforderungsobjekt 'r' verwendet beispielsweise localproxy, um auf seine Anforderungen zuzugreifen:

var r = request.defaults({'proxy':'http://localproxy.com'})

http.createServer(function (req, resp) {
  if (req.url === '/doodle.png') {
    r.get('http://google.com/doodle.png').pipe(resp)
  }
})

Leider gibt es keine "globalen" Standardeinstellungen, sodass Benutzer von Bibliotheken, die diese verwenden, den Proxy nur ändern können, wenn die Bibliothek die http-Optionen durchläuft ...

HTH, Chris

Grundsätzlich benötigen Sie keine explizite Proxy-Unterstützung. Das Proxy-Protokoll ist ziemlich einfach und basiert auf dem normalen HTTP-Protokoll. Sie müssen nur Ihren Proxy-Host und -Port verwenden, wenn Sie eine Verbindung mit HTTPClient herstellen. Beispiel (aus den Dokumenten von node.js):

var http = require('http');
var google = http.createClient(3128, 'your.proxy.host');
var request = google.request('GET', '/',
  {'host': 'www.google.com'});
request.end();
...

Sie stellen also im Grunde eine Verbindung zu Ihrem Proxy her, stellen jedoch eine Anfrage an "http://www.google.com".

Wenn Sie die Basisberechtigung für Ihren Proxy-Anbieter verwenden müssen, verwenden Sie einfach Folgendes:

var http = require("http");

var options = {
    host:       FarmerAdapter.PROXY_HOST,
    port:       FarmerAdapter.PROXY_PORT,
    path:       requestedUrl,
    headers:    {
        'Proxy-Authorization':  'Basic ' + new Buffer(FarmerAdapter.PROXY_USER + ':' + FarmerAdapter.PROXY_PASS).toString('base64')
    }
};

var request = http.request(options, function(response) {
    var chunks = [];
    response.on('data', function(chunk) {
        chunks.push(chunk);
    });
    response.on('end', function() {
        console.log('Response', Buffer.concat(chunks).toString());
    });
});

request.on('error', function(error) {
    console.log(error.message);
});

request.end();

Der Knoten sollte die Verwendung der Umgebungsvariablen http_proxy unterstützen. Sie ist also plattformübergreifend und funktioniert mit Systemeinstellungen, anstatt eine Konfiguration pro Anwendung zu erfordern.

Unter Verwendung der bereitgestellten Lösungen würde ich Folgendes empfehlen:

Coffeescript

get_url = (url, response) ->
  if process.env.http_proxy?
    match = process.env.http_proxy.match /^(http:\/\/)?([^:\/]+)(:([0-9]+))?/i
    if match
      http.get { host: match[2], port: (if match[4]? then match[4] else 80), path: url }, response
      return
  http.get url, response

Javascript

get_url = function(url, response) {
  var match;
  if (process.env.http_proxy != null) {
    match = process.env.http_proxy.match(/^(http:\/\/)?([^:\/]+)(:([0-9]+))?/i);
    if (match) {
      http.get({
        host: match[2],
        port: (match[4] != null ? match[4] : 80),
        path: url
      }, response);
      return;
    }
  }
  return http.get(url, response);
};

Verwendung Um die Methode zu verwenden, ersetzen Sie einfach http.get. Beispiel: Im Folgenden wird die Indexseite von Google in eine Datei namens test.htm geschrieben:

file = fs.createWriteStream path.resolve(__dirname, "test.htm")
get_url "http://www.google.com.au/", (response) ->
  response.pipe file
  response.on "end", ->
    console.log "complete"

Imskulls Antwort hat fast für mich funktioniert, aber ich musste einige Änderungen vornehmen. Die einzige wirkliche Änderung besteht darin, Benutzername, Passwort und die Einstellung "RejectUnauthorized" auf "false" zu setzen. Ich konnte keinen Kommentar abgeben, also habe ich dies in eine Antwort eingefügt.

Wenn Sie den Code ausführen, erhalten Sie die Titel der aktuellen Geschichten in Hacker News gemäß diesem Tutorial: http://smalljs.org/package-managers/npm/

var cheerio = require('cheerio');
var request = require('request');

request({
    'url': 'https://news.ycombinator.com/',
    'proxy': 'http://Username:Password@YourProxy:Port/',
    'rejectUnauthorized': false
}, function(error, response, body) {
    if (!error && response.statusCode == 200) {
        if (response.body) {
            var $ = cheerio.load(response.body);
            $('td.title a').each(function() {
                console.log($(this).text());
            });
       }
    } else {
        console.log('Error or status not equal 200.');
    }
});

Ich denke, es gibt eine bessere Alternative zu den Antworten ab 2019. Wir können das global-tunnel-ngPaket verwenden, um den Proxy zu initialisieren und den httpoder httpsbasierten Code nicht überall zu verschmutzen . Installieren Sie also zuerst das global-tunnel-ngPaket:

npm install global-tunnel-ng

Ändern Sie dann Ihre Implementierungen, um den Proxy bei Bedarf wie folgt zu initialisieren:

const globalTunnel = require('global-tunnel-ng');

globalTunnel.initialize({
  host: 'proxy.host.name.or.ip',
  port: 8080
});

Möglicherweise ist dies nicht der genaue Einzeiler, auf den Sie gehofft haben, aber Sie können einen Blick auf http://github.com/nodejitsu/node-http-proxy werfen, da dies möglicherweise Aufschluss darüber gibt, wie Sie Ihre App mit http verwenden können. Klient.

http://groups.google.com/group/nodejs/browse_thread/thread/d5aadbcaa00c3f7/12ebf01d7ec415c3?lnk=gst&q=proxy#12ebf01d7ec415c3

Basierend auf den Antworten aus diesem Thread scheint es, als könnten Sie Proxy- Ketten verwenden , um node.js über den Proxyserver auszuführen:
$ proxychains /path/to/node application.js

Persönlich konnte ich keine der Proxy-Chains- Versionen in einer Cygwin / Windows- Umgebung installieren und konnte sie daher nicht testen.

Außerdem wurde über die Verwendung von Connect-Proxy gesprochen, aber ich konnte keine Dokumentation dazu finden.

Kurz gesagt, ich stecke immer noch fest, aber vielleicht kann jemand diese Informationen verwenden, um eine geeignete Lösung zu finden.

Für die Verwendung eines Proxys mit https habe ich den Rat auf dieser Website (unter Verwendung der Abhängigkeit https-proxy-agent ) ausprobiert und es hat bei mir funktioniert:

http://codingmiles.com/node-js-making-https-request-via-proxy/

Verwenden Sie 'https-proxy-agent' wie folgt

var HttpsProxyAgent = require('https-proxy-agent');
var proxy = process.env.https_proxy || 'other proxy address';
var agent = new HttpsProxyAgent(proxy);

options = {
    //...
    agent : agent
}

https.get(options, (res)=>{...});

Wenn Sie über das Basic http-Authentifizierungsschema verfügen, müssen Sie eine base64-Zeichenfolge erstellen myuser:mypasswordund dann am Anfang "Basic" hinzufügen. Das ist der Wert des Proxy-Authorization- Headers, hier ein Beispiel:

var Http = require('http');

var req = Http.request({
    host: 'myproxy.com.zx',
    port: 8080,
    headers:{"Proxy-Authorization": "Basic bXl1c2VyOm15cGFzc3dvcmQ="},
    method: 'GET',
    path: 'http://www.google.com/'
    }, function (res) {
        res.on('data', function (data) {
        console.log(data.toString());
    });
});

req.end();

In nodejs können Sie Buffer zum Codieren verwenden

var encodedData = Buffer.from('myuser:mypassword').toString('base64');

console.log(encodedData);

In Browsern können Sie beispielsweise in base64 mit btoa () codieren. Dies ist nützlich bei Ajax-Anforderungen in einem Browser, ohne dass Proxy-Einstellungen eine Anforderung mit Proxy ausführen.

var encodedData = btoa('myuser:mypassword')

console.log(encodedData);

Wie finde ich heraus, welches Schema den Proxyserver akzeptiert?

Wenn wir kein benutzerdefiniertes DNS konfiguriert haben (das so etwas wie ERR_NAME_NOT_RESOLVED auslösen würde), sollte die Antwort (Code 407) bei der Ausführung einer Anforderung in den Antwortheadern angeben, welches http-Authentifizierungsschema der Proxy verwendet.