nodejs gleichzeitige mehrere Anfragen 502

Kürzlich bin ich bei der Verwendung von nodejs auf ein Problem gestoßen: Beim Senden mehrerer gleichzeitiger Anfragen wurde ein 502-Fehler zurückgegeben. Ich habe einige Zeit damit verbracht, dieses Problem zu untersuchen und schließlich eine Lösung gefunden. In diesem Artikel teile ich meine Erfahrungen in der Hoffnung, anderen mit dem gleichen Problem helfen zu können.

Zunächst müssen wir verstehen, was ein 502-Fehler ist. Ein 502-Fehler bedeutet, dass der Server eine Anfrage eines Clients nicht korrekt verarbeiten kann, normalerweise weil während der Anfrage ein Fehler oder eine Zeitüberschreitung aufgetreten ist. In NodeJS wird dieser Fehler normalerweise dadurch verursacht, dass die Anfrage blockiert wird oder das Zeitlimit der Anfrage falsch eingestellt ist.

Als nächstes schauen wir uns an, wie man mehrere gleichzeitige Anfragen in NodeJS sendet. In nodejs können wir async.parallel verwenden, um mehrere gleichzeitige Anfragen zu senden. Der Beispielcode lautet wie folgt:

const async = require('async');
const request = require('request');

const urls = [
  'https://www.example.com/page1',
  'https://www.example.com/page2',
  'https://www.example.com/page3',
  // Add more URLs here.
];

async.parallel(
  urls.map(url => callback => request(url, (err, res, body) => callback(err, body))),
  (err, results) => {
    if (err) {
      console.error(err);
      return;
    }

    console.log(results);
  },
);

Im obigen Code verwenden wir async.parallel, um mehrere Anfragen parallel zu senden. Wir fügen die URLs, die wir anfordern möchten, in ein Array ein und verwenden dann die Kartenfunktion, um sie in eine Reihe von Anfragen umzuwandeln. Anschließend verwenden wir async.parallel, um diese Anfragen parallel zu senden und die Ergebnisse zu sammeln, wenn die Anfrage abgeschlossen ist.

Jetzt wollen wir sehen, wie wir den 502-Fehler beheben können. Bei meinen Recherchen habe ich herausgefunden, dass 502-Fehler in der Regel durch eine blockierte Anfrage oder ein falsch eingestelltes Timeout für die Anfrage verursacht werden. Wenn eine Anfrage blockiert wird, liegt das möglicherweise daran, dass wir keine Rückruffunktion haben, die die Anfrage korrekt verarbeitet, oder daran, dass wir die Ressource während der Anfrage nicht freigeben.

Eine Möglichkeit besteht darin, die von der Anforderungsbibliothek bereitgestellte Keep-Alive-Option zu verwenden. Die Keep-Alive-Option ermöglicht es, Anfragen im Verbindungspool zu behalten und bestehende TCP-Verbindungen wiederzuverwenden, wodurch die Belastung des Servers reduziert und die Leistung verbessert wird. Wir können dies zu den Anfrageoptionen hinzufügen:

const request = require('request').defaults({ forever: true });

Eine andere Möglichkeit besteht darin, das Blockieren der Anfrage zu vermeiden, indem wir der Anfrage eine Timeout-Option hinzufügen. Wir können die Timeout-Option zu den Anfrageoptionen hinzufügen:

const request = require('request').defaults({ timeout: 5000 });

Der obige Code setzt das Timeout auf 5000 Millisekunden, was bedeutet, dass ein Timeout-Fehler ausgegeben wird, wenn die Anfrage 5 Sekunden überschreitet.

Wenn Sie schließlich auch auf 502-Fehler stoßen, können Sie versuchen, die Anfragen in Stapeln statt auf einmal zu senden. Dadurch kann die Belastung des Servers verringert und die Wahrscheinlichkeit von 502-Fehlern verringert werden. Der Beispielcode lautet wie folgt:

const async = require('async');
const request = require('request').defaults({ timeout: 5000 });

const urls = [
  'https://www.example.com/page1',
  'https://www.example.com/page2',
  'https://www.example.com/page3',
  // Add more URLs here.
];

const chunkSize = 2; // Set the maximum number of requests to send at once.

async.eachLimit(
  urls,
  chunkSize,
  (url, callback) => request(url, (err, res, body) => callback(err, body)),
  (err) => {
    if (err) {
      console.error(err);
      return;
    }

    console.log('All requests completed successfully.');
  },
);

Im obigen Code haben wir die Anfragen in Zweiergruppen aufgeteilt und async.eachLimit verwendet, um die maximale Anzahl der gleichzeitig gesendeten Anfragen zu begrenzen. Dadurch kann die Belastung des Servers verringert und die Wahrscheinlichkeit von 502-Fehlern verringert werden.

Kurz gesagt: Wenn Sie auf das Problem des NodeJS-Fehlers 502 bei gleichzeitiger Anforderung stoßen, können Sie versuchen, es mit der oben genannten Methode zu lösen. Indem Sie auf die Rückruffunktionen und Timeout-Einstellungen für Anfragen achten, können Sie die Möglichkeit einer Anforderungsblockierung verringern. Darüber hinaus können durch das Senden von Anfragen in Stapeln Überlastungssituationen vermieden und die Wahrscheinlichkeit von 502-Fehlern verringert werden.

Das obige ist der detaillierte Inhalt vonnodejs gleichzeitige mehrere Anfragen 502. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!