Laravel में Queues का प्रयोग करके Deferring Tasks

Hindi (हिंदी) translation by Ashish Rampal (you can also view the original English article)

इस आर्टिकल में, हम Laravel वेब फ्रेमवर्क में Queue API को एक्स्प्लोर करने जा रहे हैं। यह पुरे एन्ड यूजर के अनुभव को बढ़ाने के लिए स्क्रिप्ट एक्सेक्यूशन के दौरान रिसोर्स-इंटेंसिव कार्यों को अलग करने की अनुमति देता है। बेसिक शब्दावली को पेश करने के बाद, मैं एक वास्तविक दुनिया के उदाहरण को बनाकर इसे प्रदर्शित करूंगा।

पेज लोड का समय किसी भी सफल वेबसाइट का एक महत्वपूर्ण पहलू है, और किसी को इसके महत्व को अनदेखा नहीं करना चाहिए क्योंकि यह साइट के SEO और पुरे एन्ड यूजर एक्सपीरियंस को भी प्रभावित करता है। कभी कभार, आप को लंबे पेज लोड बार के साथ वेब पेज डीबग (Debug) करने की ज़रूरत होती है। बेशक, आप इस मुद्दे को सुधारने के लिए अलग अलग एप्रोच इस्तेमाल कर सकते हैं।

जांच के बाद, आप अक्सर यह महसूस करते हैं कि कुछ कोड ब्लॉक के कारन पेज के एक्सेक्यूशन में देरी होती हैं। अगली बात जो आप करने की कोशिश कर सकते हैं वह है उन ब्लॉकों की पहचान करना जिन्हें प्रोसेसिंग के लिए स्थगित किया जा सकता है और जिसका वर्तमान पेज के अंतिम परिणाम पर कोई वास्तविक प्रभाव नहीं पड़ना। यह वास्तव में वेब पेज की कुल गति को सुधार देगा क्योंकि हमने उन कोड ब्लॉक को समाप्त कर दिया है, जो देरी पैदा कर रहे थे।

आज, हम इसी तरह के कांसेप्ट को Laravel वेब फ्रेमवर्क के संदर्भ में देखने जा रहे हैं। वास्तव में, Laravel पहले से ही एक उपयोगी इनबिल्ट API प्रदान करता है जो हमें टास्क के प्रोसेसिंग को स्थगित करने की अनुमति देता है-Queue API। अपना अधिक समय बर्बाद किए बिना, मैं आगे बढ़ूंगा और Queue API के बुनियादी एलिमेंट्स पर चर्चा करूंगा।

Drivers, Connections, Queues, और Jobs

Queue API का मूल उद्देश्य उन jobs को चलाने का है, जो queue में जुड़े हैं। इसके बाद, queue एक विशिष्ट कनेक्शन से संबंधित हो सकती है, और वह कनेक्शन एक विशिष्ट queue driver से संबंधित हो सकता है जो उस कनेक्शन के साथ कॉन्फ़िगर किया गया था। चलो संक्षेप में समझने की कोशिश करते हैं कि मैंने अभी क्या कहा है।

Queue Drivers

इसी तरह से आप अपने डेटाबेस कनेक्शन के लिए एक अलग driver का इस्तेमाल कर चुके होंगे, आप विभिन्न प्रकार के queue ड्राइवरों से भी चुन सकते हैं। Queue API डाटाबेस, beanstalkd, sqs और redis जैसे विभिन्न एडेप्टर का समर्थन करता है।

Queue ड्राइवर केवल एक ऐसा स्थान है जो queue से संबंधित जानकारी को संग्रहीत करने के लिए उपयोग किया जाता है। तो यदि आप डेटाबेस queue ड्राइवर का उपयोग कर रहे हैं, उदाहरण के लिए, नई जॉब डेटाबेस में jobs टेबल में जोड़ दी जाएगी। दूसरी तरफ, अगर आपने डिफॉल्ट queue ड्रायवर के रूप में redis को कॉन्फ़िगर किया है, तो job redis सर्वर में जोड़ दी जाएगी।

Queue API टेस्ट करने के उदेश्य से दो ख़ास queue ड्राइवर उपलब्ध कराता है - sync और null। Sync queue driver को तुरंत queue जॉब को एक्सेक्यूट करने के लिए प्रयोग किया जाता है, जबकि null queue ड्राइवर का उपयोग जॉब को छोड़ने के लिए किया जाता है ताकि यह बिल्कुल एक्सेक्यूट न हो सके।

Connections

जब आप पहली बार Queue API को कॉन्फ़िगर करते हैं, तो आपको डिफ़ॉल्ट कनेक्शन को उल्लेखित करना होगा जिसे कि डिफ़ॉल्ट queue प्रोसेसिंग के लिए उपयोग किया जाना चाहिए। कम से कम, कनेक्शन को निम्न जानकारी प्राप्त करने की उम्मीद होती है:

queue ड्राइवर जिसका उपयोग किया जाएगा
queue ड्राइवर की विशिष्ट कॉन्फ़िगरेशन वैल्यू
डिफ़ॉल्ट queue का नाम जिसमें जॉब को जोड़ा जायेगा

Queue

जब आप किसी queue में कोई जॉब जोड़ते हैं, तो इसे डिफ़ॉल्ट queue में जोड़ दिया जाएगा। वास्तव में, अधिकांश मामलों में यह ठीक होता है, जब तक कि आपके पास वो जॉब नहीं होती है, जिसे अन्य जॉब्स पर उच्च प्राथमिकता दी जाए। उस स्थिति में, आप high नाम का एक queue बना सकते हैं और इस विशेष queue में उच्च प्राथमिकता वाली जॉब को डाल सकते हैं।

जब आप एक queue वर्कर चलाते हैं जो queue जॉब को प्रोसेस करता है, तो आप वैकल्पिक रूप से --queue पैरामीटर पास कर सकते हैं, जो आपको queue नामों को उस क्रम में सूचीबद्ध करने की अनुमति देता है जिसमें उन्हें प्रोसेस करना होता है। उदाहरण के लिए, यदि आप --queue=high,default उल्लेखित करते हैं, यह सबसे पहले high queue को प्रोसेस करता है, और एक बार इसे पूरा करने के बाद यह डिफ़ॉल्ट queue में जॉब को निकालता है।

Jobs

Queue API में job एक ऐसा कार्य है जो मुख्य एक्सेक्यूशन फ्लो से बाहर है। उदाहरण के लिए, यदि आप यूजर के फ्रंट-एंड से एक इमेज अपलोड करते समय थंबनेल बनाना चाहते हैं, तो आप एक नई जॉब बना सकते हैं जो थंबनेल प्रोसेस को संभाले। इस तरह, आप मुख्य एक्सेक्यूशन फ्लो से थंबनेल प्रोसेस का कार्य बाहर कर सकते हैं।

यह queue API टर्मिनोलॉजी के लिए एक बुनियादी परिचय था। अगले सेक्शन से, हम एक कस्टम queue जॉब बनाने और एक Laravel queue वर्कर का उपयोग करके इसे चलाने के तरीके की खोज करेंगे।

अपनी पहली queue जॉब बनाएँ

अब तक, आपको queue जॉब्स के बारे में कॉंफिडेंट होना चाहिए। इस सेक्शन के बाद से, हम वास्तविक दुनिया के उदाहरण को लागू करने जा रहे हैं जो Laravel में queue जॉब्स के कांसेप्ट को दर्शाता है।

कभी कभार, आप उस स्थिति में पड़ जाते हैं, जहां आपको किसी यूजर द्वारा अपलोड की गई इमेज के अलग अलग थंबनेल वर्जन बनाने की आवश्यकता होती है। अधिकांश मामलों में, डेवलपर इसे वास्तविक समय में प्रोसेस करने का प्रयास करता है ताकि इमेजेज के विभिन्न वर्जन तुरंत बनाए जा सकें जब कोई यूजर इमेज अपलोड करता है।

यदि आप एक दो वर्जन बनाने जा रहे हैं और यह पहली बार में बहुत अधिक समय नहीं लेता है तो यह एक उचित तरीका होता है। दूसरी तरफ, यदि आप किसी ऐसे एप्लिकेशन में काम कर रहे हैं जिसके लिए भारी प्रोसेस की आवश्यकता है और इसलिए इसे अधिक रिसोर्सेज की जरूरत है, तो रियल टाइम प्रोसेस यूजर के लिए एक खराब अनुभव के तौर पर समाप्त हो सकता है।

वो पहला विकल्प जो आपके दिमाग में सबसे पहले आता है, थंबनेल जनरेशन के प्रोसेस को जितना हो सके उतनी देर तक रोकना है। इस विशिष्ट सिनेरियो में आप जो सरलतम एप्रोच कर सकते हैं वो है एक क्रॉन जॉब सेट करना जो नियमित अंतराल पर प्रोसेस को चालू करता है, और आप एकदम ठीक रहेंगे।

दूसरी तरफ, एक काफी बेहतर एप्रोच है, की टास्क को एक queue में स्थगित करना और पुश करना, और queue वर्कर को जब ऐसा करने का मौका मिलता है, तो उसे प्रोसेस करने दे। प्रोडक्शन एनवायरनमेंट में, queue वर्कर एक डेमॉन स्क्रिप्ट है जो queue में हमेशा चलती रहती है और टास्क को प्रोसेस करती है। इस अप्प्रोच से स्पष्ट तौर पर एन्ड यूजर एक्सपीरियंस में लाभ होता है, और आपको क्रॉन रन की प्रतीक्षा करने की ज़रूरत नहीं है क्योंकि जॉब जितनी जल्दी हो सके प्रोसेस हो जाएगी।

मुझे लगता है कि एक वास्तविक इम्प्लीमेंटेशन को आरंभ करने के लिए यह पर्याप्त थ्योरी है।

हमारे मामले में, हम database queue ड्रायवर का उपयोग करने जा रहे हैं, और इसके लिए हमें डेटाबेस में jobs टेबल बनाने की आवश्यकता है। jobs टेबल में सभी jobs होती हैं जिन्हे अगले queue वर्कर के चलने पर प्रोसेस करने की जरूरत है।

इससे पहले कि हम आगे बढ़ें और jobs टेबल बनाएं, चलो config/queue.php फ़ाइल में डिफ़ॉल्ट queue कॉन्फ़िगरेशन को sync से database में बदलते हैं।

...
...
/*
|--------------------------------------------------------------------------
| Default Queue Driver
|--------------------------------------------------------------------------
|
| Laravel's queue API supports an assortment of back-ends via a single
| API, giving you convenient access to each back-end using the same
| syntax for each one. Here you may set the default queue driver.
|
| Supported: "sync", "database", "beanstalkd", "sqs", "redis", "null"
|
*/

'default' => env('QUEUE_DRIVER', 'database'),
...
...

असल में, Laravel पहले ही एक artisan कमांड प्रदान करता है जो हमें jobs की टेबल बनाने में मदद करता है। अपने Laravel एप्लीकेशन के रूट में निम्न कमांड को चलाएं, और यह आवश्यक डेटाबेस माइग्रेशन बना देगा जो jobs टेबल बनाता है।

$php artisan queue:table

माइग्रेशन फ़ाइल जो database/migrations/YYYY_MM_DD_HHMMSS_create_jobs_table.php पर जेनरेट की गई है उसे इस प्रकार दिखना चाहिए:

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateJobsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('jobs', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('queue');
            $table->longText('payload');
            $table->unsignedTinyInteger('attempts');
            $table->unsignedInteger('reserved_at')->nullable();
            $table->unsignedInteger('available_at');
            $table->unsignedInteger('created_at');

            $table->index(['queue', 'reserved_at']);
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('jobs');
    }
}

आगे, चलिए migrate कमांड चलते हैं, ताकि यह वास्तव में एक डाटाबेस में jobs टेबल बना सके।

php artisan migrate

जहां तक jobs माइग्रेशन का संबंध है यह काफी है।

इसके बाद, चलिए Image मॉडल बनाते हैं जो एन्ड यूजर द्वारा अपलोड की गई इमेजेज को मैनेज करने के लिए उपयोग किया जाएगा। Image मॉडल को इसी से सम्बंधित एक डेटाबेस टेबल की आवश्यकता होती है, इसलिए हम Image मॉडल का निर्माण करते समय --migrate ऑप्शन का उपयोग करेंगे।

php artisan make:model Image --migration

उपरोक्त कमांड को Image मॉडल क्लास और इससे सम्बंधित डेटाबेस माइग्रेशन भी बनाना चाहिए।

Image मॉडल क्लास कुछ इस तरह दिखनी चाहिए:

<?php
// app/Image.php
namespace App;

use Illuminate\Database\Eloquent\Model;

class Image extends Model
{
    //
}

और डेटाबेस माइग्रेशन फ़ाइल database/migrations/YYYY_MM_DD_HHMMSS_create_images_table.php पर बनना चाहिए। हम एन्ड यूजर द्वारा अपलोड की गई इमेज के ओरिजिनल पाथ को भी स्टोर करना चाहते हैं। निम्नलिखित जैसा दिखने के लिए आईये Image डेटाबेस माइग्रेशन फाइल के कोड को संशोधित करें।

<?php
// database/migrations/YYYY_MM_DD_HHMMSS_create_images_table.php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateImagesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('images', function (Blueprint $table) {
            $table->increments('id');
            $table->timestamps();
            $table->string('org_path');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('images');
    }
}

जैसा कि आप देख सकते हैं, हमने ओरिजिनल इमेज के पाथ को स्टोर करने के लिए $table->string('org_path') कॉलम जोड़ दिया है। इसके बाद, आपको डाटाबेस में वास्तव में उस टेबल को बनाने के लिए migrate कमांड को चलाने की जरूरत है।

$php artisan migrate

और बस यही है जहां तक Image मॉडल का संबंध है।

इसके बाद, आइए एक वास्तविक queue जॉब बनाते हैं जो इमेज थंबनेल को प्रोसेस करने के लिए ज़िम्मेदार है। थंबनेल को प्रोसेस करने के लिए, हम एक बहुत लोकप्रिय इमेज प्रोसेसिंग लाइब्रेरी—Intervention Image का उपयोग करने जा रहे हैं।

इंटरवेंशन इमेज लायब्रेरी को इनस्टॉल करने के लिए, बड़े और अपने एप्लीकेशन के रुट में निम्न कमांड को चलाएं।

$php composer.phar require intervention/image

अब, यह Job क्लास बनाने का समय है, और हम ऐसा करने के लिए एक artisan कमांड का उपयोग करेंगे।

$php artisan make:job ProcessImageThumbnails

इससे app/Jobs/ProcessImageThumbnails.php पर Job क्लास टेम्प्लेट बनना चाहिए। चलिए उस फ़ाइल के कंटेंट को निम्नलिखित के साथ बदलें।

<?php
// app/Jobs/ProcessImageThumbnails.php
namespace App\Jobs;

use App\Image as ImageModel;
use Illuminate\Bus\Queueable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Support\Facades\DB;

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

    protected $image;

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

    /**
     * Execute the job.
     *
     * @return void
     */
    public function handle()
    {
        // access the model in the queue for processing
        $image = $this->image;
        $full_image_path = public_path($image->org_path);
        $resized_image_path = public_path('thumbs' . DIRECTORY_SEPARATOR .  $image->org_path);

        // create image thumbs from the original image
        $img = \Image::make($full_image_path)->resize(300, 200);
        $img->save($resized_image_path);
    }
}

जब queue वर्कर किसी भी जॉब को प्रोसेस करना शुरू करते हैं, तो यह handle मेथड को ढूंढ़ता है। तो यह handle मेथड ही है जो आपकी जॉब का मुख्य लॉजिक रखता है।

हमारे मामले में, हमें यूजर द्वारा अपलोड की गई इमेज का एक थंबनेल बनाने की जरूरत है। handle मेथड का कोड बहुत सरल है - हम ImageModel मॉडल से एक इमेज को प्राप्त करते हैं और इंटरवेंशन इमेज लाइब्रेरी का उपयोग करके एक थंबनेल बनाते हैं। बेशक, जब हम अपनी जॉब को डिस्पैच करते हैं तो हमें इसी Image मॉडल को पास करना होगा, और हम इसे एक पल में देखेंगे।

हमारी नई बनाई गई जॉब का परीक्षण करने के लिए, हम एक सरल अपलोड फ़ॉर्म बनायेंगे जो यूजर को एक इमेज अपलोड करने की अनुमति देता है। बेशक, हम तुरंत इमेज थंबनेल नहीं बनाएंगे; हम इस टास्क को स्थगित कर देंगे ताकि यह queue वर्कर द्वारा प्रोसेस किया जा सके।

आइए, app/Http/Controllers/ImageController.php में एक कंट्रोलर फाइल बनाएं जैसा कि नीचे दिखाया गया है।

<?php
namespace App\Http\Controllers;

use App\Image;
use App\Jobs\ProcessImageThumbnails;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Redirect;
use App\Http\Controllers\Controller;
use Validator;

class ImageController extends Controller
{
    /**
     * Show Upload Form
     *
     * @param  Request  $request
     * @return Response
     */
    public function index(Request $request)
    {
        return view('upload_form');
    }

    /**
     * Upload Image
     *
     * @param  Request  $request
     * @return Response
     */
    public function upload(Request $request)
    {
        // upload image
        $this->validate($request, [
          'demo_image' => 'required|image|mimes:jpeg,png,jpg,gif,svg|max:2048',
        ]);
        $image = $request->file('demo_image');
        $input['demo_image'] = time().'.'.$image->getClientOriginalExtension();
        $destinationPath = public_path('/images');
        $image->move($destinationPath, $input['demo_image']);

        // make db entry of that image
        $image = new Image;
        $image->org_path = 'images' . DIRECTORY_SEPARATOR . $input['demo_image'];
        $image->save();

        // defer the processing of the image thumbnails
        ProcessImageThumbnails::dispatch($image);

        return Redirect::to('image/index')->with('message', 'Image uploaded successfully!');
    }
}

resources/views/upload_form.blade.php पर आईये एक संबंधित व्यू फ़ाइल बनाते हैं।

<!DOCTYPE html>
<html lang="{{ config('app.locale') }}">
    <head>
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta name="csrf-token" content="{{ csrf_token() }}" />
        <title>Laravel</title>

        <!-- Fonts -->
        <link href="https://fonts.googleapis.com/css?family=Raleway:100,600" rel="stylesheet" type="text/css">

        <!-- Styles -->
        <style>
            html, body {
                background-color: #fff;
                color: #636b6f;
                font-family: 'Raleway', sans-serif;
                font-weight: 100;
                height: 100vh;
                margin: 0;
            }

            .full-height {
                height: 100vh;
            }

            .flex-center {
                align-items: center;
                display: flex;
                justify-content: center;
            }

            .position-ref {
                position: relative;
            }

            .top-right {
                position: absolute;
                right: 10px;
                top: 18px;
            }

            .content {
                text-align: center;
            }

            .title {
                font-size: 84px;
            }

            .links > a {
                color: #636b6f;
                padding: 0 25px;
                font-size: 12px;
                font-weight: 600;
                letter-spacing: .1rem;
                text-decoration: none;
                text-transform: uppercase;
            }

            .m-b-md {
                margin-bottom: 30px;
            }
            
            .alert {
                color: red;
                font-weight: bold;
                margin: 10px;
            }
            .success {
                color: blue;
                font-weight: bold;
                margin: 10px;
            }
        </style>
    </head>
    <body>
        <div class="flex-center position-ref full-height">
            @if (Route::has('login'))
                <div class="top-right links">
                    @if (Auth::check())
                        <a href="{{ url('/home') }}">Home</a>
                    @else
                        <a href="{{ url('/login') }}">Login</a>
                        <a href="{{ url('/register') }}">Register</a>
                    @endif
                </div>
            @endif

            <div class="content">
                <div class="m-b-md">
                    <h1 class="title">Demo Upload Form</h1>
                    
                    @if ($errors->any())
                        <div class="alert alert-danger">
                            <ul>
                                @foreach ($errors->all() as $error)
                                    <li>{{ $error }}</li>
                                @endforeach
                            </ul>
                        </div>
                    @endif
                    
                    @if (session('message'))
                        <div class="success">
                            {{ session('message') }}
                        </div>
                    @endif
                    
                    <form method="post" action="{{ url('/image/upload') }}" enctype="multipart/form-data">
                      <div>
                        <input type="file" name="demo_image" />
                      </div>
                      <br/>
                      <div>
                        <input type="hidden" name="_token" value="{{ csrf_token() }}">
                        <input type="submit" value="Upload Image"/>
                      </div>
                    </form>
                </div>
            </div>
        </div>
    </body>
</html>

आखिरकार, routes/web.php फ़ाइल में index और upload एक्शन्स के लिए रूट्स जोड़ें।

Route::get('image/index', 'ImageController@index');
Route::post('image/upload', 'ImageController@upload');

ImageController कंट्रोलर में, एक अपलोड फॉर्म को प्रस्तुत करने के लिए index मेथड का उपयोग किया जाता है।

public function index(Request $request)
{
    return view('upload_form');
}

जब यूजर एक फ़ॉर्म को सबमिट करता है, तो upload मेथड को चलाया जाता है।

public function upload(Request $request)
{
    // upload image
    $this->validate($request, [
        'demo_image' => 'required|image|mimes:jpeg,png,jpg,gif,svg|max:2048',
    ]);
    $image = $request->file('demo_image');
    $input['demo_image'] = time().'.'.$image->getClientOriginalExtension();
    $destinationPath = public_path('/images');
    $image->move($destinationPath, $input['demo_image']);

    // make db entry of that image
    $image = new Image;
    $image->org_path = 'images' . DIRECTORY_SEPARATOR . $input['demo_image'];
    $image->save();

    // defer the processing of the image thumbnails
    ProcessImageThumbnails::dispatch($image);

    return Redirect::to('image/index')->with('message', 'Image uploaded successfully!');
}

upload मेथड की शुरुआत में, आप सामान्य फ़ाइल अपलोड कोड पर ध्यान देंगे जो अपलोड की गई फ़ाइल को public/images डायरेक्टरी में ले जाता है। इसके बाद, हम App/Image मॉडल का इस्तेमाल करते हुए डाटाबेस रिकॉर्ड डालेंगे।

अंत में, हम थंबनेल प्रोसेसिंग टास्क को स्थगित करने के लिए ProcessImageThumbnails जॉब का उपयोग करते हैं। यह नोट करना महत्वपूर्ण है कि यह dispatch मेथड है जो किसी टास्क को स्थगित करने के लिए उपयोग किया जाता है। अंत में, यूजर को एक सक्सेस मैसेज के साथ अपलोड पेज पर रीडायरेक्ट किया जाता है।

इस पॉइंट में समय पर, प्रोसेसिंग के लिए jobs टेबल में जॉब जोड़ दी जाती है। निम्नलिखित क्वेरी जारी करके इसकी कन्फर्म करें।

mysql> select * FROM lvl_jobs;
|  1 | default | {"displayName":"App\\Jobs\\ProcessImageThumbnails","job":"Illuminate\\Queue\\CallQueuedHandler@call","maxTries":null,"timeout":null,"data":{"commandName":"App\\Jobs\\ProcessImageThumbnails","command":"O:31:\"App\\Jobs\\ProcessImageThumbnails\":5:{s:8:\"\u0000*\u0000image\";O:45:\"Illuminate\\Contracts\\Database\\ModelIdentifier\":2:{s:5:\"class\";s:9:\"App\\Image\";s:2:\"id\";i:2;}s:6:\"\u0000*\u0000job\";N;s:10:\"connection\";N;s:5:\"queue\";N;s:5:\"delay\";N;}"}} |        0 |        NULL |   1510219099 | 1510219099 |

आप सोच रहे होंगे कि जॉब को प्रोसेस करने के लिए क्या लगता है? चिंता न करें- यही हम एकदम अगले भाग में चर्चा करने जा रहे हैं।

Queue Worker

Laravel queue वर्कर की जॉब queue में प्रोसेसिंग के लिए जॉब्स को प्रोसेस करने की है। वास्तव में, एक artisan कमांड है जो हमें queue वर्कर प्रोसेस को शुरू करने में मदद करती है।

$php artisan queue:work

जैसे ही आप उस कमांड को चलाते हैं, यह लंबित जॉब्स की प्रोसेस करता है। हमारे मामले में, यह ProcessImageThumbnails जॉब को प्रोसेस करेगा जो यूजर द्वारा एक इमेज अपलोड करते समय queue में हो।

$php artisan queue:work
[YYYY-MM-DD HHMMSS] Processing: App\Jobs\ProcessImageThumbnails
[YYYY-MM-DD HHMMSS] Processed:  App\Jobs\ProcessImageThumbnails

आप ने देखा होगा कि जब आप एक queue वर्कर को शुरू करते हैं, यह तब तक चलता रहता है जब तक कि आप इसे मैन्युअल रूप से किल नहीं करते या टर्मिनल बंद नहीं करते। वास्तव में, यह अगली जॉब को प्रोसेस में आने की प्रतीक्षा कर रहा होता है। जैसे ही queue में एक नई जॉब मिलती है, तो यदि queue वर्कर चल रहा है, तो इसे तुरंत प्रोसेस किया जाएगा।

बेशक, हम उसे इस तरह से चलते नहीं रख सकते हैं, इसलिए हमें queue वर्कर को बैकग्राउंड में स्थायी रूप से चलाने के लिए एक रास्ता खोजना होगा।

हमारे बचाव के लिए, आपकी चुनने के लिए बहुत से प्रोसेस मैनेजमेंट टूल यहाँ मिल जाएंगे। कुछ नाम देना चाहें तो, यहां एक सूची है:

Circus
daemontools
Monit
Supervisor
Upstart

आपको एक ऐसा टूल चुनना चाहिए जिसके साथ आप Laravel के queue वर्कर को आराम से मैनेज कर सकते हैं। असल में, हमे यह सुनिश्चित करना होगा कि queue वर्कर को अनिश्चित काल तक चलना चाहिए ताकि यह queue की जॉब्स को प्रोसेस कर सके।

इसलिए आपके पास queue API है। आप इसे अपने दिन-प्रतिदिन के डेवलपमेंट में उपयोग कर सकते हैं ताकि एन्ड यूजर एक्सपीरियंस को अच्छा करने के लिए टाइम-कोन्सुमिंग टास्कस को स्थगित कर सकें।

निष्कर्ष

इस आर्टिकल में, हमने Laravel में queue API पर चर्चा की, जो वास्तव में मददगार है यदि आप रिसोर्स-कोन्सुमिंग टास्कस के प्रोसेस को स्थगित करना चाहें।

हमने queue API के एक बुनियादी परिचय के साथ शुरू किया, जिसमें कनेक्शन, queue और जॉब्स की चर्चा शामिल थी। आर्टिकल के दूसरे हाफ में, हमने एक कस्टम queue जॉब को बनाया जो यह दिखाता है की वास्तविक दुनिया में queue API का उपयोग कैसे कर सकते है।

आप में से जो लोग या तो Laravel के साथ शुरू कर रहे हैं या अपने ज्ञान, साइट या एप्लीकेशन को एक्सटेंशन के साथ का विस्तार करने की तलाश में हैं, हमारे पास कई तरह की चीजें हैं जो आप एन्वाटो मार्केट में पढ़ सकते हैं।

अपने प्रश्नों और सुझावों को पोस्ट करने के लिए नीचे फ़ीडबैक फ़ॉर्म का उपयोग करने के लिए स्वतंत्र महसूस करें।