Manette des gaz et la file d'attente des requêtes à l'API en raison par seconde cap

Je suis l'utiliser mikeal/demande de faire des appels de l'API. L'une des API que j'utilise le plus souvent (le Shopify API). Récemment sortir une nouvelle appel limite, je vais voir des erreurs comme: 

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

J'ai déjà eu droit à une mise à niveau, mais quelle que soit la quantité de bande passante je se que je dois tenir compte de cela. Une grande majorité de la demande de la Shopify API sont dans async.map() fonctions de la boucle de requêtes asynchrones, et de recueillir les corps.

Je suis à la recherche d'aide, peut-être une bibliothèque qui existe déjà, qui tourne autour de la demande en module et en fait bloc, le sommeil, le gaz, l'attribution, la gestion, le nombre de demandes simultanées de tirer de manière asynchrone et de les limiter à dire 6 demandes à la fois. Je n'ai aucun problème à travailler sur un tel projet s'il n'existe pas. Je ne sais pas comment gérer ce genre de situation, et j'espère que pour certains type de standard.

J'ai fait un billet avec mikeal/demande.

  • Pas de blague. J'ai finalement eu marre de la ElasticTranscoder de l'INTERFACE utilisateur et de construire le code à utiliser l'API via le JS SDK et instantanément frappé de ces limites.
  • En 2018, il est taux d'-limiteur-flexible le paquet qui fait le travail
InformationsquelleAutor ThomasReggi | 2013-11-27
  1. 14

    J'ai couru dans le même problème avec les différentes Api. AWS est célèbre pour la limitation ainsi.

    Un couple d'approches peuvent être utilisées. Vous avez mentionné asynchrone.map() fonction. Avez-vous essayé async.la file d'attente()? La file d'attente méthode devrait vous permettre de définir une solide limite (6) et rien de plus de ce montant sera placé dans la file d'attente.

    Un autre outil utile est oibackoff. Cette bibliothèque vous permettra de l'interruption de votre demande si vous obtenez une erreur depuis le serveur et essayez à nouveau.

    Il peut être utile d'envelopper les deux bibliothèques assurez-vous que vos deux bases sont couvertes: async.file d'attente pour vous assurer de ne pas aller dessus de la limite, et oibackoff pour vous assurer d'obtenir une autre chance de faire votre demande si le serveur vous dit il y a une erreur.

    • Je vais creuser profondément dans ces deux suggestions. Le seul problème que j'ai c'est que mon async.maps sont répartis et imbriquées les unes dans les autres. Donc je ne peux pas il suffit de les remplacer avec async.queue parce que je ne serait toujours pas de garantie que les requêtes à l'API serait de 6 à la fois. Ils seraient 6 * chaque async.queue. Mais je pense que la balle roule?
    • caolan.github.io/async/docs.html#file d'attente ne des gaz (par sec/ min). C'est seulement le nombre d'opérations asynchrones.
    InformationsquelleAutor Dan
  2. 33

    Pour une solution alternative, j'ai utilisé le nœud-taux-limiteur de pour envelopper la fonction de demande comme ceci:

    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);
    });
};
    • Je vais chercher dans cette! Merci beaucoup!
    • Auteur de nœud-taux-limiteur de ici. Cette bibliothèque est probablement va être un meilleur ajustement pour le problème posé, depuis asynchrone.la file d'attente() seulement impose des limites sur la simultanéité et n'a pas de notion de temps. API limites de fréquence sont généralement basés sur le temps (c'est à dire avec un maximum de 6 appels par seconde), ce qui peut être exprimé comme var limiter = new RateLimiter(6, 'second'); Elle est complémentaire à une solution comme oibackoff qui va changer de comportement après une limite de taux a été atteint.
    • Puis-je faire pour demander que tout ou besoin de le faire individuellement ? Je veux dire, puis-je le mettre à l'intérieur de mon middleware ? Si oui, comment il sera appliqué, pour tous les postes de travail ou pour chacun des points de terminaison ?
    • Ne présente que les limites des appels ou fonctionne également comme un mécanisme de mise en queue. Sens si je dépasse la limite, il aura la file d'attente de la demande et de commencer à appeler encore une fois que la limite est actualisé?
    • Oui, il mettra en file d'attente. Je pense que ce qui se passe est node-rate-limiter vous appelle en arrière une fois que le jeton devient disponible
    InformationsquelleAutor Dmitry Chornyi
  3. 22

    La npm paquet simple-tarif-limiteur de semble être une très bonne solution à ce problème.

    En outre, il est plus facile à utiliser que node-rate-limiter et async.queue.

    Voici un extrait de code qui montre comment le fait de limiter les demandes à dix par seconde.

    var limit = require("simple-rate-limiter");
var request = limit(require("request")).to(10).per(1000);
    InformationsquelleAutor Camilo Sanchez
  4. 8

    Dans async module, cette demande de fonctionnalité est fermé comme "l'habitude de fixer"

    Il y a une solution à l'aide de leakybucket ou token bucket modèle, il est mis en œuvre "limiteur" npm module RateLimiter.

    RateLimiter, voir l'exemple ici: https://github.com/caolan/async/issues/1314#issuecomment-263715550

    Un autre moyen est d'utiliser PromiseThrottle, j'ai utilisé cette, travail exemple ci-dessous:

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

    De sortie:

    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

    Nous pouvons clairement voir que le taux de sortie, c'est à dire 5 appels pour chaque seconde.

    InformationsquelleAutor Manohar Reddy Poreddy
  5. 2

    Voici ma solution utiliser une bibliothèque request-promise ou axios et encapsuler l'appel à cette promesse.

    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 ThomasReggi
  6. 1

    Les autres solutions n'ont pas été à mon goût. Recherche en outre, j'ai trouvé promesse-ratelimit qui vous donne une api que vous pouvez simplement await:

    var rate = 2000 //in milliseconds
var throttle = require('promise-ratelimit')(rate)

async function queryExampleApi () {
  await throttle()
  var response = await get('https://api.example.com/stuff')
  return response.body.things
}

    L'exemple ci-dessus va vous assurer que faire des requêtes sur api.example.com chaque 2000ms au plus. En d'autres termes, la première requête ne attendre 2000ms.

    InformationsquelleAutor mindeavor
  7. 0

    Ma solution à l'aide de moyens modernes de vanille JS:

    function throttleAsync(fn, wait) {
  let lastRun = 0;

  async function throttled(...args) {
    const currentWait = lastRun + wait - Date.now();
    const shouldRun   = currentWait <= 0;

    if (shouldRun) {
      lastRun = Date.now();
      return await fn(...args);
    } else {
      return await new Promise(function(resolve) {
        setTimeout(function() {
          resolve(throttled());
        }, currentWait);
      });
    }
  }

  return throttled;
}

    Utilisation:

    const throttledRun = throttleAsync(run, 1000);
    InformationsquelleAutor djanowski