Laravel queue rate limiting or throttling

问题:

I am working on an app that requires fetching data from a third-party server and that server allows max 1 request per seconds.

Now, all request send as job and I am trying to implement Laravel "Rate Limiting" to release 1 job per second but unable to figure out why it should be implemented and there is no real-life example in the web.

Did anyone implement it?

Any hint of this?

回答1:

I'm the author of mxl/laravel-queue-rate-limit Composer package.

It allows you to rate limit jobs on specific queue without using Redis.

1. Install it with:

   $ composer require mxl/laravel-queue-rate-limit:^1.0
   

2. This package is compatible with Laravel 5.5+ and uses auto-discovery feature to add MichaelLedin\LaravelQueueRateLimit\QueueServiceProvider::class to providers.

3. Add rate limit settings to config/queue.php:

   'rateLimit' => [
       'mail' => [
           'allows' => 1,
           'every' => 5
       ]
   ]
   

   These settings allow to run 1 job every 5 seconds on mail queue. Make sure that default queue driver (default property in config/queue.php) is set to any value except sync.

4. Run queue worker with --queue mail option:

   $ php artisan queue:work --queue mail
   

   You can run worker on multiple queues, but only queues referenced in rateLimit setting will be rate limited:

   $ php artisan qeueu:work --queue mail,default
   

   Jobs on default queue will be executed without rate limiting.

5. Queue some jobs to test rate limiting:

   SomeJob::dispatch()->onQueue('mail');
   SomeJob::dispatch()->onQueue('mail');
   SomeJob::dispatch()->onQueue('mail');
   SomeJob::dispatch();
   

回答2:

Assuming you have only single worker you can do something like this:

• do what has to be done
• get time (with microseconds)
• sleep time that is 1s minus difference between finish time and start time

so basically:

doSomething()
$time = microtime(true);
usleep(1000 - ($time - LARAVEL_START));

回答3:

I am rate limiting a job que to max out at 100 jobs per day. I chose to use the 'delay' feature.

1. I have an ORM class for the jobs table.
2. I lookup the last job on the throttled queue.
3. Increment $last_job->available_at by 15 minutes
4. pass the result into the new job as a delay before it goes on the queue.

Job Class

<?php
namespace FuquIo\LaravelJobs\Orm;

use Illuminate\Database\Eloquent\Model;

class Job extends Model{
    protected $dateFormat = 'U';
    protected $dates = ['reserved_at', 'available_at'];
}

Sample delay without much context...

$que = config(ServiceProvider::SHORT_NAME . '.job-queue');


$preceeding_job = Job::whereQueue($que['name'])
                     ->orderBy('available_at', 'DESC')
                     ->first();

if(!empty($preceeding_job)){
    $available = $preceeding_job->available_at;
}else{
    $available = Carbon::now();
}


ProbeGoogle::dispatch($obj)
           ->onConnection($que['connection'])
           ->onQueue($que['name'])
           ->delay($available->addMinutes(15));

Note that completed jobs are removed from the jobs table, so you need another means of tracking them and a bit more logic to calculate $available. I use https://github.com/imTigger/laravel-job-status for that. For this example, I went with simple logic. It will either fire 15 min after the last job in the queue, or 15 min from now. That helps pace things out just in case the last job fired and disappeared 2 seconds ago.

回答4:

If you need "throttling" and are not using Redis as your queue driver you can try to use the following code:

public function throttledJobDispatch( $delayInSeconds = 1 ) 
{
   $lastJobDispatched = Cache::get('lastJobDispatched');

   if( !$lastJobDispatched ) {
      $delay_until = now();
   } else { 
      if ($lastJobDispatched->addSeconds($delayInSeconds) < now()) {
         $delay_until = now();
      } else {
         $delay_until = $lastJobDispatched->addSeconds($delayInSeconds);
      }
   }
   Job::dispatch()->onQueue('YourQueue')->delay($delay_until);
   Cache::put('lastJobDispatched', $delay_until, now()->addYears(1) );
}

What this code does is release a job to the queue and set the start time X seconds after the last dispatched job's start time. I successully tested this with database as queue-driver and file as cache driver.

There are two minor problems I have encountered so far:

1) When you use only 1 second as a delay, depending on your queue worker - the queue worker may actually only "wake up" once every couple of seconds. So, if it wakes up every 3 seconds, it will perform 3 jobs at once and then "sleep" 3 seconds again. But on average you will still only perform one job every second.

2) In Laravel 5.7 it is not possible to use Carbon to set the job delay to less than a second because it does not support milli- or microseconds yet. That should be possible with Laravel 5.8 - just use addMilliseconds instead of addSeconds.

回答5:

You could use this package to use rate limiting with Redis or another source, like a file. Uses settings to set bucket size and rate as fractions of the time limit, so very small storage.

composer require bandwidth-throttle/token-bucket

https://github.com/bandwidth-throttle/token-bucket

It allows you to wrap the check in an if, so it will wait for a free token to be available, 1 a minute in your example. In effect, it makes the service sleep for the required amount of time until a new minute.