it-swarm.com.de

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

Ich möchte einen ausgehenden HTTP-Aufruf von node.js mit dem Standard http.Client ausführen. 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?

118
Christian Berg

Tim Macfarlane 's answer stand in Bezug auf die Verwendung eines HTTP-Proxys nahe.

Die Verwendung eines HTTP-Proxys (für nicht sichere Anfragen) ist sehr einfach. Sie stellen eine Verbindung zum Proxy her und führen die Anforderung normal aus, mit der Ausnahme, dass der Pfadteil die vollständige URL enthält und der Hostheader auf den Host gesetzt ist, zu dem Sie eine Verbindung herstellen möchten.
Tim war sehr nahe 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, ob der Host-Header falsch ist.

132
Samuel

Sie können request , .__ verwenden. Ich habe gerade festgestellt, dass es einfach ist, den Proxy auf node.js zu verwenden, nur mit einem externen "Proxy" -Parameter. Noch mehr unterstützt er 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);
  }
})
44
Imskull

Eine Sache, die eine Weile brauchte, um herauszufinden, verwenden Sie 'http', um auf den Proxy zuzugreifen, selbst wenn Sie versuchen, einen Proxy an einen https-Server zu senden. Dies funktioniert für mich 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);
});
31
Chris

Wie @Renat hier bereits erwähnt wurde, kommt der Proxy-HTTP-Verkehr in ziemlich 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);
});
15
Tim Macfarlane

Ich dachte, ich würde dieses Modul hinzufügen, das ich gefunden habe: https://www.npmjs.org/package/global-tunnel , was für mich sehr gut funktionierte (arbeitete sofort mit meinem gesamten Code und Modulen von Drittanbietern mit nur dem folgenden Code ).

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

Tun Sie dies einmal und alle HTTP (und https) in Ihrer Anwendung durchlaufen den Proxy.

Alternativ rufen Sie an

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

Verwendet die Umgebungsvariable http_proxy

9
major-mann

Das http-Paket "request" scheint diese Funktion zu haben: 

https://github.com/mikeal/request

Das unten angegebene 'r' -Anforderungsobjekt verwendet beispielsweise localproxy für den Zugriff auf seine Anforderungen:

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, so dass Benutzer von Bibliotheken, die dies verwenden, den Proxy nicht ändern können, es sei denn, die Bibliothek gibt die http-Optionen weiter.

HTH, Chris

7
Chris Kimpton

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 node.js-Dokumenten):

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

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

5
Renat

Wenn Sie die Basisberechtigung für Ihren Proxy-Provider verwenden möchten, verwenden Sie einfach die folgenden Anweisungen:

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 Umgebungsvariable http_proxy unterstützen. Die Plattform ist plattformübergreifend und arbeitet mit Systemeinstellungen, anstatt eine anwendungsspezifische Konfiguration zu erfordern.

Mit den bereitgestellten Lösungen würde ich Folgendes empfehlen:

Kaffeescript

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

Usage Um die Methode zu verwenden, ersetzen Sie einfach http.get, indem Sie beispielsweise die Indexseite von Google in eine Datei namens test.htm schreiben:

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"
3
Luke

Ich kaufte einen privaten Proxy-Server, nach dem Kauf bekam ich:

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. Erste Antwort und Zweite Antwort funktionierte nur für http (Proxy) -> http (Ziel), jedoch wollte ich http (Proxy) -> https (Ziel).

Und für das https-Ziel wäre es besser, HTTP-Tunnel direkt zu verwenden. Ich fand die Lösung hier . Schlusscode:

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

Die Antwort von Imskull funktionierte fast für mich, aber ich musste einige Änderungen vornehmen. Die einzige wirkliche Änderung besteht darin, den Benutzernamen, das Kennwort und die Einstellung von rejectUnauthorized auf false zu setzen. Ich konnte nicht kommentieren, also habe ich dies in eine Antwort gesteckt. 

Wenn Sie den Code ausführen, erhalten Sie die Titel der aktuellen Storys in Hacker News. Dieses Tutorial enthält folgende Informationen: http://smalljs.org/package-managers/npm/

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

request({
    'url': 'https://news.ycombinator.com/',
    'proxy': 'http://Username:[email protected]: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.');
    }
});
1
Vasily Kushakov

Vielleicht ist es nicht genau der One-Liner, auf den Sie gehofft haben, aber Sie könnten einen Blick auf http://github.com/nodejitsu/node-http-proxy werfen, da dies möglicherweise ein wenig Licht auf die Verwendung Ihres Systems werfen könnte App mit http.Client.

0
fullstacklife

Ich denke, es gibt eine bessere Alternative zu den Antworten ab 2019. Wir können das global-tunnel-ng-Paket verwenden, um den Proxy zu initialisieren und den http- oder https-basierten Code nicht überall zu verschmutzen. Also zuerst das global-tunnel-ng Paket installieren:

npm install global-tunnel-ng

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

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

globalTunnel.initialize({
  Host: 'proxy.Host.name.or.ip',
  port: 8080
});
0
ring bearer

Wenn Sie über das Basic http-Authentifizierungsschema verfügen, müssen Sie eine base64-Zeichenfolge aus myuser:mypassword erstellen und am Anfang "Basic" hinzufügen. Das ist der Wert von Proxy-Authorization Header, 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 Kodieren verwenden 

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

console.log(encodedData);

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

var encodedData = btoa('myuser:mypassword')

console.log(encodedData);

Wie finde ich heraus, welches Schema den Proxy-Server akzeptiert? 

Wenn wir kein benutzerdefiniertes DNS konfiguriert haben (das etwa ERR_NAME_NOT_RESOLVED auslösen würde), sollte die Antwort (Code 407) beim Ausführen einer Anforderung in den Antwortheadern angeben, welches HTTP-Authentifizierungsschema der Proxy verwendet.

0
Emeeus

Um einen Proxy mit https zu verwenden, habe ich den Rat auf dieser Website ausprobiert (mit der Abhängigkeit https-proxy-agent) und es funktionierte für mich:

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

0
Jonathan Benn

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)=>{...});
0
Bad Green

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 so, als könnten Sie proxychains Verwenden, um node.js über den Proxy-Server auszuführen:
$ proxychains /path/to/node application.js 

Ich persönlich konnte keine der proxychains - Versionen in der Cygwin/Windows - Umgebung installieren und konnte sie daher nicht testen.

Darüber hinaus sprachen sie auch über die Verwendung von connect-proxy, aber ich konnte keine Dokumentation dazu finden.

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

0
ddallala