Managing API Rate Limits in Laravel Through Job Throttling

When working with external services like AWS SES for email delivery, preventing API flooding is crucial. Laravel provides an elegant solution through Redis::throttle to manage your rate limits effectively. Let’s explore how to implement this to maintain optimal API usage.

Understanding Redis::throttle

The Redis::throttle method in Laravel offers a powerful way to control the flow of your queued jobs. This ensures you stay within API rate limits and avoid temporary or permanent service blocks.

Redis::throttle('key-name')
    ->allow(10)
    ->every(5)
    ->then(function () {
        // Your job logic here
    });

Real-World Implementation

Let’s build a practical example for managing email sending rates with AWS SES. We’ll create a complete middleware system to handle rate limiting:

<?php

namespace AppHttpMiddleware;

use Closure;
use IlluminateSupportFacadesRedis;

class EmailRateLimit
{
    public function handle($job, Closure $next)
    {
        Redis::throttle('email-throttle')
            ->block(2)
            ->allow(10)
            ->every(2)
            ->then(
                function () use ($job, $next) {
                    $next($job);
                },
                function () use ($job) {
                    $job->release(30);
                }
            );
    }
}

To apply this in your notification system:

<?php

namespace AppNotifications;

use IlluminateBusQueueable;
use IlluminateContractsQueueShouldQueue;
use IlluminateNotificationsNotification;
use IlluminateNotificationsMessagesMailMessage;
use AppHttpMiddlewareEmailRateLimit;

class EmailDispatch extends Notification implements ShouldQueue
{
    use Queueable;

    protected $content;

    public function __construct($content)
    {
        $this->content = $content;
    }

    public function via($notifiable)
    {
        return ['mail'];
    }

    public function toMail($notifiable)
    {
        return (new MailMessage)
            ->subject($this->content['subject'])
            ->line($this->content['body']);
    }

    public function middleware(): array
    {
        return [new EmailRateLimit];
    }
}

And finally, implementing it in your controller:

<?php

namespace AppHttpControllers;

use AppModelsUser;
use AppNotificationsEmailDispatch;
use IlluminateHttpRequest;

class MailController extends Controller
{
    public function dispatch(Request $request)
    {
        $content = [
            'subject' => 'Important Update',
            'body' => 'Your account has been updated successfully.'
        ];

        $user = User::find($request->user_id);
        $user->notify(new EmailDispatch($content));

        return response()->json(['message' => 'Email queued for delivery']);
    }
}

This implementation ensures your application respects API rate limits while maintaining efficient email delivery through AWS SES or any other email service provider.

The post Managing API Rate Limits in Laravel Through Job Throttling appeared first on Laravel News.

Join the Laravel Newsletter to get all the latest
Laravel articles like this directly in your inbox.

Source: Read More