Vengala Vinay

Having 12+ Years of Experience in Software Development

Home » Scaling Laravel on AWS to Handle 50,000+ Concurrent Requests

Scaling Laravel on AWS to Handle 50,000+ Concurrent Requests

Architectural Foundation: Decoupling and Asynchronous Processing

Achieving 50,000+ concurrent requests for a Laravel application on AWS isn’t a matter of simply throwing more EC2 instances at the problem. It requires a fundamental shift in architecture, prioritizing decoupling and asynchronous processing. The monolithic request-response cycle, while simple for smaller loads, becomes a bottleneck under heavy concurrency. We need to offload non-critical path operations and ensure that the web tier remains responsive.

Leveraging AWS Services for Scalability

Our AWS strategy will revolve around several key services:

  • Elastic Load Balancing (ELB): Specifically, an Application Load Balancer (ALB) to distribute incoming HTTP/S traffic across multiple EC2 instances.
  • Auto Scaling Groups (ASG): To automatically adjust the number of EC2 instances based on demand, ensuring high availability and cost-efficiency.
  • Amazon SQS (Simple Queue Service): For decoupling long-running or non-time-critical tasks from the web request lifecycle.
  • Amazon ElastiCache (Redis): For caching database queries, session data, and frequently accessed objects to reduce database load.
  • Amazon RDS (Relational Database Service) / Aurora: A managed relational database solution, scaled appropriately.
  • Amazon CloudFront: For serving static assets and caching API responses at the edge.

Implementing Asynchronous Jobs with SQS and Laravel Queues

The core of handling high concurrency lies in moving work off the request thread. Laravel’s queue system is a perfect fit for this. We’ll configure it to use SQS as the driver.

AWS SQS Setup

First, create an SQS queue in your AWS account. For this example, let’s name it my-laravel-jobs. Ensure you have appropriate IAM permissions for your EC2 instances to send and receive messages from this queue.

Laravel Queue Configuration

In your Laravel application’s .env file, configure the queue driver:

QUEUE_CONNECTION=sqs
AWS_ACCESS_KEY_ID=YOUR_AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY=YOUR_AWS_SECRET_ACCESS_KEY
AWS_DEFAULT_REGION=us-east-1
AWS_SQS_KEY=YOUR_AWS_ACCESS_KEY_ID
AWS_SQS_SECRET=YOUR_AWS_SECRET_ACCESS_KEY
AWS_SQS_PREFIX=https://sqs.us-east-1.amazonaws.com/YOUR_ACCOUNT_ID/
AWS_SQS_QUEUE=my-laravel-jobs

Next, in config/queue.php, ensure the SQS configuration is set up correctly. Laravel’s default configuration usually handles this well if the environment variables are present. You might want to adjust visibility timeouts and retry settings based on your job types.

Dispatching Jobs

Now, any time-consuming task that doesn’t need to be completed within the HTTP request can be dispatched to the queue. For instance, sending an email, processing an image, or generating a report.

// In your controller or service
use App\Jobs\ProcessUserData;
use Illuminate\Support\Facades\Queue;

// ...

ProcessUserData::dispatch($user); // Dispatches to the default queue (SQS in this case)

// Or to a specific queue if you have multiple
// Queue::connection('sqs')->dispatch(new ProcessUserData($user));

And the corresponding job class (e.g., app/Jobs/ProcessUserData.php):

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use App\Models\User;

class ProcessUserData implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $user;

    /**
     * Create a new job instance.
     *
     * @return void
     */
    public function __construct(User $user)
    {
        $this->user = $user;
    }

    /**
     * Execute the job.
     *
     * @return void
     */
    public function handle()
    {
        // Perform time-consuming operations here
        // e.g., send welcome email, update external systems, etc.
        \Log::info("Processing data for user ID: {$this->user->id}");
        // ... actual processing logic ...
    }
}

Running Queue Workers

On your EC2 instances (or dedicated worker instances), you need to run the queue workers. For production, use a process manager like Supervisor.

# Install Supervisor if you haven't already
sudo apt update
sudo apt install supervisor -y

# Create a Supervisor configuration file for your Laravel queue worker
sudo nano /etc/supervisor/conf.d/laravel-queue.conf

Add the following content to the configuration file, adjusting paths and user as necessary:

[program:laravel-queue]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/your-app/artisan queue:work sqs --queue=my-laravel-jobs --sleep=3 --tries=3 --max-time=600
directory=/var/www/your-app
user=www-data
numprocs=8 ; Adjust based on your server's CPU cores and memory
redirect_stderr=true
stdout_logfile=/var/log/supervisor/laravel-queue.log
autorestart=true
killasgroup=true
stopsignal=INT

Then, reload Supervisor and start the new process:

sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start laravel-queue:*

Ensure your Auto Scaling Group configuration includes these Supervisor processes to start automatically when new instances are launched.

Optimizing Database Performance and Caching

Database contention is a primary cause of performance degradation under load. We’ll employ aggressive caching and optimize our database setup.

Amazon ElastiCache for Redis

Redis is excellent for caching query results, sessions, and rate limiting data. Configure Laravel to use Redis for these purposes.

Configuration

In .env:

REDIS_HOST=your-redis-endpoint.cache.amazonaws.com
REDIS_PASSWORD=null
REDIS_PORT=6379

In config/cache.php:

'default' => env('CACHE_DRIVER', 'redis'),

'stores' => [
    // ... other stores
    'redis' => [
        'driver' => 'redis',
        'connection' => 'default',
    ],
    // ...
],

In config/session.php:

'driver' => env('SESSION_DRIVER', 'redis'),
'lifetime' => env('SESSION_LIFETIME', 120), // Increase session lifetime if needed

Strategic Caching in Laravel

Identify frequently accessed, relatively static data. Cache it using Laravel’s facade.

use Illuminate\Support\Facades\Cache;

// Example: Caching a list of active categories
$categories = Cache::remember('active_categories', now()->addHours(24), function () {
    return Category::where('is_active', true)->get();
});

// Example: Caching user profile data
$userId = 123;
$userProfile = Cache::remember("user_profile_{$userId}", now()->addMinutes(30), function () use ($userId) {
    return User::with('profile', 'roles')->findOrFail($userId);
});

Implement cache invalidation strategies carefully. For example, when a category is updated, clear the relevant cache key:

use Illuminate\Support\Facades\Cache;

// When updating a category
$category->update([...]);
Cache::forget('active_categories');

Database Scaling (RDS/Aurora)

For high-traffic applications, consider Amazon Aurora (MySQL or PostgreSQL compatible) for its performance and scalability. Ensure your database instance size is adequate and leverage read replicas.

Read Replicas: Configure your Laravel application to use read replicas for read-heavy operations. This can be managed via the database.php configuration and potentially a package like spatie/laravel-db-pure-selections or custom logic.

// config/database.php
'connections' => [
    'mysql' => [
        // ... primary connection details
    ],
    'mysql_read' => [
        'driver' => 'mysql',
        'host' => env('DB_READ_HOST', 'your-rds-read-replica-endpoint'),
        'port' => env('DB_READ_PORT', '3306'),
        'database' => env('DB_DATABASE', 'forge'),
        'username' => env('DB_USERNAME', 'forge'),
        'password' => env('DB_PASSWORD', 'secret'),
        'charset' => 'utf8mb4',
        'prefix' => '',
        'schema_prefix' => '',
        'strict' => true,
        'engine' => null,
    ],
],

// In your application logic
use Illuminate\Support\Facades\DB;

$users = DB::connection('mysql_read')->table('users')->get();

Connection Pooling: For very high concurrency, consider using a connection pooler like ProxySQL if you’re not using Aurora’s serverless capabilities, or ensure your RDS/Aurora configuration is optimized for connection handling.

Frontend Optimization with CloudFront

Offloading static assets and API responses to a Content Delivery Network (CDN) significantly reduces the load on your application servers.

CloudFront Distribution Setup

Create a CloudFront distribution pointing to your S3 bucket for static assets (e.g., compiled CSS, JS, images) and potentially your ALB for API caching.

Laravel Integration

Use Laravel’s asset helper and configure your .env file to point to your CloudFront URL.

ASSET_URL=https://your-cloudfront-domain.com

Now, when you use asset(), it will automatically use your CloudFront URL:

<link rel="stylesheet" href="{{ asset('css/app.css') }}">

For API response caching, you can configure CloudFront behaviors to cache specific API endpoints based on headers, query strings, and cookies. This requires careful consideration of cache invalidation strategies.

AWS Infrastructure Configuration

Application Load Balancer (ALB)

Configure an ALB with listeners for HTTP (port 80) and HTTPS (port 443). Set up target groups pointing to your EC2 instances. Use health checks to ensure traffic is only sent to healthy instances.

# Example ALB Listener Rule (Conceptual)
# Forward HTTP traffic on port 80 to target group 'my-laravel-tg'
# Forward HTTPS traffic on port 443 to target group 'my-laravel-tg'
# Configure SSL certificate for HTTPS

Auto Scaling Group (ASG)

Define a launch configuration or launch template for your EC2 instances. This template should include:

  • The AMI for your application server.
  • Instance type (e.g., t3.medium, m5.large, depending on load).
  • IAM role for accessing AWS services (SQS, S3, etc.).
  • User data script to install dependencies, pull code, and start Supervisor.

Configure scaling policies:

  • Target Tracking Scaling: e.g., maintain average CPU utilization at 60%.
  • Step Scaling: Define thresholds for adding/removing instances based on metrics like ALB request count per target.
  • Scheduled Scaling: For predictable traffic patterns (e.g., scale up during business hours).

Set minimum and maximum instance counts to control costs and ensure availability.

Monitoring and Alerting

Robust monitoring is crucial for identifying bottlenecks and reacting to issues before they impact users.

Key Metrics to Monitor

  • EC2: CPU Utilization, Network In/Out, Disk I/O.
  • ALB: Request Count, Target Response Time, HTTP 4xx/5xx errors, Healthy/Unhealthy Host Count.
  • SQS: ApproximateNumberOfMessagesVisible, ApproximateAgeOfOldestMessage.
  • ElastiCache: CPU Utilization, Memory Usage, Cache Hits/Misses.
  • RDS/Aurora: CPU Utilization, Database Connections, Read/Write IOPS, Latency.
  • Laravel Logs: Application errors, queue job failures.

Set up CloudWatch Alarms for critical metrics. For example:

# CloudWatch Alarm Example (Conceptual)
# Alarm Name: High SQS Queue Depth
# Metric: ApproximateNumberOfMessagesVisible (SQS)
# Threshold: Greater than 100 messages for 5 minutes
# Action: Trigger SNS topic to notify operations team and potentially scale up workers.

# Alarm Name: High ALB 5xx Errors
# Metric: HTTPCode_Target_5XX_Count (ALB)
# Threshold: Greater than 10 errors in 1 minute
# Action: Trigger SNS topic and potentially trigger ASG scaling policy.

Security Considerations

Ensure your VPC security groups are configured to allow only necessary traffic. Use IAM roles instead of access keys where possible. Encrypt sensitive data at rest and in transit. Regularly review and update security patches.

Conclusion

Scaling Laravel to handle 50,000+ concurrent requests on AWS is an iterative process. It involves a well-architected system that leverages AWS managed services for decoupling, asynchronous processing, caching, and elastic scaling. By implementing these strategies, you can build a robust and performant application capable of handling significant traffic loads.

Recent Posts

Top Categories

Our Products

Our Services