When I started building web applications with Laravel, I noticed that some tasks, like sending emails or processing large files, slowed down my app’s performance. That’s when I learned about Laravel Queues, a fantastic feature that lets you run time-consuming tasks in the background, keeping your app fast and responsive.

In this beginner-friendly guide, I’ll share how I set up Laravel Queue on a Linux server using the database driver. Whether you’re new to Laravel or managing a production server, this step-by-step tutorial will help you get started with queues. Let’s dive in

Step-by-Step Guide to Setting Up Laravel Queue on a Linux Server

Step 1: Connect to Your Linux Server

I begin by connecting to my Linux server via SSH. In my terminal, I run:

ssh username@server-ip

Replace username and server-ip with your server’s credentials. Once logged in, I ensure my server is ready for the setup.

Step 2: Update Your Server

To avoid compatibility issues, I update the server’s package lists and software. For Ubuntu or Debian-based systems, I use:

sudo apt update
sudo apt upgrade -y

This ensures my server has the latest packages before installing dependencies.

Step 3: Verify Laravel Installation

I assume you already have a Laravel application set up on your server. If not, install Laravel using Composer. Navigate to your project directory (e.g., /var/www/myapp) and verify it’s working:

cd /var/www/myapp
php artisan --version

This confirms Laravel is installed and accessible. I also ensure PHP, Composer, and a database (like MySQL) are set up.

Step 4: Choose and Configure a Queue Driver

Laravel supports multiple queue drivers like database, Redis, and Amazon SQS. For simplicity, I use the database driver, which is easy to set up and great for small to medium projects. To configure it, I open the env file in my Laravel project:

nano .env

I set the QUEUE_CONNECTION variable to database:

QUEUE_CONNECTION=database

This tells Laravel to use the database driver for queue jobs. Save and exit the file.

Step 5: Create the Jobs Table

Laravel’s database driver requires a jobs table to store queued tasks. I generate the migration for this table using Artisan:

php artisan queue:table
php artisan migrate

The first command creates a migration file, and the second runs it to create the jobs table in my database. I ensure my database credentials in the env file are correct to avoid errors.

Step 6: Create a Job Class

Next, I create a job class to define a task that will run in the background. For example, I might want to send a welcome email. I use Artisan to generate a job:

php artisan make:job SendWelcomeEmail

This creates a SendWelcomeEmail.php file in the app/Jobs directory. I open it and add my task logic in the handle method. Here’s a simple example:

<?php
namespace App\Jobs;
use App\Models\User;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Mail;

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

    protected $user;

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

    public function handle()
    {
        Mail::to($this->user->email)->send(new \App\Mail\WelcomeEmail($this->user));
    }
}

This job sends a welcome email to a user. I ensure my mail configuration in env is set up.

Step 7: Dispatch a Job

To test the queue, I dispatch the job from a controller or route. For example, in a controller:

use App\Jobs\SendWelcomeEmail;
use App\Models\User;

public function create(Request $request)
{
    $user = User::create([
        'name' => $request->name,
        'email' => $request->email,
        'password' => bcrypt($request->password),
    ]);

    SendWelcomeEmail::dispatch($user);

    return response()->json(['message' => 'User created and email queued']);
}

This dispatches the SendWelcomeEmail job to the queue, which will be processed in the background.

Step 8: Run the Queue Worker

To process queued jobs, I start a queue worker. In my terminal, I run:

php artisan queue:work

This command starts a worker that processes jobs from the jobs table. For testing, I keep the terminal open. The worker will process the SendWelcomeEmail job and send the email.

Step 9: Set Up a Process Manager (Production)

In a production environment, I don’t want to keep the terminal open, so I use a process manager like Supervisor to keep the queue worker running. First, I install Supervisor:

sudo apt install supervisor

Then, I create a configuration file for my queue worker:

sudo nano /etc/supervisor/conf.d/laravel-worker.conf

I add the following configuration:

[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/myapp/artisan queue:work --sleep=3 --tries=3
autostart=true
autorestart=true
user=www-data
numprocs=1
redirect_stderr=true
stdout_logfile=/var/www/myapp/storage/logs/worker.log

Replace /var/www/myapp with your project path and www-data with your server user. Save and exit, then update Supervisor:

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

This ensures the queue worker runs continuously and restarts if it crashes.

Step 10: Monitor and Handle Failed Jobs

Sometimes jobs fail (e.g., due to a database error). I set up a failed_jobs table to track them:

php artisan queue:failed-table
php artisan migrate

In the env file, I set QUEUE_FAILED_DRIVER=database. To retry failed jobs, I use:

php artisan queue:retry all

I also check logs in storage/logs/laravel.log to debug issues.

Conclusion

Setting up Laravel Queue on a Linux server has transformed how I manage time-consuming tasks in my applications. By moving tasks like email sending to the background, my app stays fast and user-friendly. This guide walked you through configuring the database driver, creating jobs, and setting up a queue worker with Supervisor for production. With Laravel Queues, I can scale my app efficiently and ensure a smooth user experience. Try it out, and let me know how it works for you!

Frequently Asked Questions(FAQs)

Q1: What is a Laravel Queue, and why should I use it?
A: A Laravel Queue allows you to defer time-consuming tasks, like sending emails or processing files, to run in the background. I use it to keep my app responsive and improve user experience.

Q2: Can I use a different queue driver like Redis?
A: Yes, Laravel supports Redis, Amazon SQS, and more. I chose the database driver for simplicity, but for high-traffic apps, I’d use Redis by setting QUEUE_CONNECTION=redis in env and configuring Redis in config/database.php.

Q3: How do I check if my queue worker is running?
A: I use ps aux | grep queue:work to see if the worker process is active. In production, I check Supervisor’s status with sudo supervisorctl status.

Q4: What happens if a job fails?
A: Failed jobs are stored in the failed_jobs table if configured. I can retry them with php artisan queue:retry all or debug using logs in storage/logs/laravel.log.

Q5: Is the database driver suitable for large-scale apps?
A: For small to medium apps, it’s fine, but for large-scale apps, I recommend Redis or Amazon SQS for better performance and scalability.

---

You might also like :

• Read Also: Send Email using Queue in Laravel 12
• Read Also: How to Install MySQL Workbench on Ubuntu
• Read Also: How to Export CSV File using Queue in Laravel 11
• Read Also: How to Set Up PM2 on Linux Server: A Step-by-Step Guide