Drosseln und warten Sie API-Anfragen aufgrund der pro-Sekunde-Obergrenze

Ich verwende mikeal/Anfrageum API-Aufrufe. Eines der API ' s die ich am häufigsten verwenden (Shopify API). Vor kurzem eine neue Aufruf limitsehe ich Fehler wie:


Exceeded 6.0 calls per second for api client. Slow your requests or contact support for higher limits.

Habe ich schon bekommen ein upgrade, aber unabhängig davon, wie viel Bandbreite ich bekommen, die ich haben, um für dieses Konto. Eine große Mehrheit der Anträge auf Shopify API sind innerhalb async.anzeigen() Funktionen, die Schleife asynchrone requests, und sammeln die Leichen.

Ich bin auf der Suche für jede Hilfe, vielleicht eine Bibliothek, die bereits existiert, wäre das wrap-around-das Anfrage-Modul und tatsächlich blockieren, Schlaf -, Drossel -, zuweisen, verwalten, die viele gleichzeitige Anforderungen, die das versenden asynchron und beschränken zu sagen 6 Anforderungen gleichzeitig. Ich habe kein problem mit der Arbeit an einem solchen Projekt, wenn es nicht vorhanden ist. Ich weiß nur nicht, wie Sie zu behandeln diese Art von situation, und ich bin der Hoffnung, für eine Art standard.

Machte ich ein ticket mit mikeal/Anfrage.

InformationsquelleAutor der Frage ThomasReggi | 2013-11-27

  1. 12

    Ich habe laufen in das gleiche Problem mit verschiedenen APIs. AWS ist berühmt für die Drosselung als gut.

    Ein paar Ansätze verwendet werden können. Sie erwähnt async.map () - Funktion. Haben Sie versucht,async.queue()? Die Warteschlange Methode sollte Ihnen ermöglichen, um eine Feste Grenze (wie 6) und alles, was über diesen Betrag wird in die Warteschlange gestellt werden.

    Ein weiteres hilfreiches Werkzeug ist oibackoff. Dieser Bibliothek ermöglichen Ihnen die backoff Ihre Anfrage, wenn Sie einen Fehler erhalten, wieder aus dem server und versuchen Sie es erneut.

    Kann es nützlich sein, legen Sie die beiden Bibliotheken, um sicherzustellen, dass beide Ihre Basen bedeckt sind: async.Warteschlange, um sicherzustellen, dass Sie nicht gehen über die Grenze, und oibackoff, um sicherzustellen, Sie bekommen eine weitere Chance auf immer Ihre Anfrage, wenn der server sagt Ihnen, es ein Fehler war.

    InformationsquelleAutor der Antwort Dan

  2. 29

    Für eine alternative Lösung, die ich verwendet, die Knoten-rate-limiter wickeln Sie das Anfrage-Funktion wie diese:

    var request = require('request');
var RateLimiter = require('limiter').RateLimiter;

var limiter = new RateLimiter(1, 100); //at most 1 request every 100 ms
var throttledRequest = function() {
    var requestArgs = arguments;
    limiter.removeTokens(1, function() {
        request.apply(this, requestArgs);
    });
};

    InformationsquelleAutor der Antwort Dmitry Chornyi

  3. 17

    Den npm Paket einfache rate-limiter scheint eine sehr gute Lösung für dieses problem.

    Darüber hinaus ist es einfacher zu verwenden als node-rate-limiter und async.queue.

    Hier ist ein Ausschnitt, der zeigt, wie begrenzen alle Anfragen zu zehn pro Sekunde.

    var limit = require("simple-rate-limiter");
var request = limit(require("request")).to(10).per(1000);

    InformationsquelleAutor der Antwort Camilo Sanchez

  4. 4

    Im async-Modul, dieses angeforderte feature ist geschlossen als "wont fix"

    Gibt es eine Lösung mit leakybucket oder token-bucket-Modell, dass es umgesetzt wird "limiter" npm-Modul als RateLimiter.

    Siehe Beispiel hier: https://github.com/caolan/async/issues/1314#issuecomment-263715550

    var PromiseThrottle = require('promise-throttle');
let RATE_PER_SECOND = 5; //5 = 5 per second, 0.5 = 1 per every 2 seconds

var pto = new PromiseThrottle({
    requestsPerSecond: RATE_PER_SECOND, //up to 1 request per second
    promiseImplementation: Promise  //the Promise library you are using
});

let timeStart = Date.now();
var myPromiseFunction = function (arg) {
    return new Promise(function (resolve, reject) {
        console.log("myPromiseFunction: " + arg + ", " + (Date.now() - timeStart) / 1000);
        let response = arg;
        return resolve(response);
    });
};

let NUMBER_OF_REQUESTS = 15;
let promiseArray = [];
for (let i = 1; i <= NUMBER_OF_REQUESTS; i++) {
    promiseArray.push(
            pto
            .add(myPromiseFunction.bind(this, i)) //passing am argument using bind()
            );
}

Promise
        .all(promiseArray)
        .then(function (allResponsesArray) { //[1 .. 100]
            console.log("All results: " + allResponsesArray);
        });

    Ausgabe:

    myPromiseFunction: 1, 0.031
myPromiseFunction: 2, 0.201
myPromiseFunction: 3, 0.401
myPromiseFunction: 4, 0.602
myPromiseFunction: 5, 0.803
myPromiseFunction: 6, 1.003
myPromiseFunction: 7, 1.204
myPromiseFunction: 8, 1.404
myPromiseFunction: 9, 1.605
myPromiseFunction: 10, 1.806
myPromiseFunction: 11, 2.007
myPromiseFunction: 12, 2.208
myPromiseFunction: 13, 2.409
myPromiseFunction: 14, 2.61
myPromiseFunction: 15, 2.811
All results: 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15

    Können wir deutlich sehen, die rate von der Ausgabe, also 5 Anrufe für jede Sekunde.

    InformationsquelleAutor der Antwort Manohar Reddy Poreddy

  5. 2

    Hier ist meine Lösung verwenden Sie eine Bibliothek request-promise oder axios und wickeln Sie den Aufruf in dieser Verheißung.

    var Promise = require("bluebird")

//http://stackoverflow.com/questions/28459812/way-to-provide-this-to-the-global-scope#28459875
//http://stackoverflow.com/questions/27561158/timed-promise-queue-throttle

module.exports = promiseDebounce

function promiseDebounce(fn, delay, count) {
  var working = 0, queue = [];
  function work() {
    if ((queue.length === 0) || (working === count)) return;
    working++;
    Promise.delay(delay).tap(function () { working--; }).then(work);
    var next = queue.shift();
    next[2](fn.apply(next[0], next[1]));
  }
  return function debounced() {
    var args = arguments;
    return new Promise(function(resolve){
      queue.push([this, args, resolve]);
      if (working < count) work();
    }.bind(this));
  }

    InformationsquelleAutor der Antwort ThomasReggi

Schreibe einen Kommentar