Frequenzbegrenzung

{note} Diese Funktion erfordert, dass Ihre Anwendung den Redis-Server verwenden kann

Wenn Ihre Anwendung Redis verwendet, können Sie Zeit oder Parallelität verwenden Grenzwerte für Ihre Warteschlangenaufgaben. Diese Funktion ist hilfreich, wenn Ihre Warteschlangenaufgaben über eine API verarbeitet werden, die ebenfalls ratenbegrenzt ist.

Mit der Methode throttle können Sie beispielsweise die Ausführung einer Aufgabe eines bestimmten Typs auf nur 10 Mal alle 60 Sekunden beschränken. Wenn die Sperre nicht erlangt wird, sollten Sie die Aufgabe generell wieder in die Warteschlange stellen, damit sie später erneut versucht werden kann.

Redis::throttle('key')->allow(10)->every(60)->then(function () {
    // 任务逻辑...
  },
 function () { 
   // 无法获得锁...    
  return $this->release(10);
});

{tip} Im obigen Beispiel kann key eine beliebige eindeutige identifizierende Zeichenfolge für den Aufgabentyp sein, dessen Häufigkeit Sie begrenzen möchten. Verwenden Sie beispielsweise den Schlüssel eines Widgets basierend auf dem Namen der Aufgabenklasse oder der ID des Eloquent-Modells, mit dem es arbeitet.

{note} Durch die Freigabe eingeschränkter Jobs wieder in der Warteschlange erhöht sich immer noch die Gesamtzahl der Jobs attempts.

Alternativ können Sie die maximale Anzahl an Aufgaben angeben, die gleichzeitig ausgeführt werden können. Dies kann nützlich sein, wenn eine Aufgabe in einer Warteschlange eine Ressource ändert, die jeweils nur von einer Aufgabe geändert werden kann. Mit der funnel-Methode können Sie beispielsweise eine Aufgabe eines bestimmten Typs auf jeweils nur einen Prozessor beschränken:

Redis::funnel('key')->limit(1)->then(function () {
    // 任务逻辑...},
    function () {  
      // 无法获得锁...   
     return $this->release(10);
 });

{tip} Bei Verwendung der Häufigkeitsbegrenzung die Anzahl erfolgreicher Aufgaben Die Zahl der Hinrichtungsversuche ist möglicherweise schwer zu ermitteln. Daher ist es sinnvoll, Häufigkeitsgrenzen mit Zeitgrenzen zu kombinieren.

Fehlerbehandlung

Wenn während der Aufgabenausführung eine Ausnahme auftritt, wird die Aufgabe automatisch freigegeben Warteschlange, um es erneut zu versuchen. Die Aufgabe wird freigegeben, bis die von der Anwendung maximal zulässige Anzahl von Wiederholungsversuchen erreicht ist. Der maximale Wiederholungswert wird durch die Option queue:work des Artisan-Befehls oder in der Task-Klasse definiert. Weitere Informationen zu Ausführungswarteschlangenhandlern finden Sie --tries unten.

Sie können die Schließung auch direkt aufrufen, anstatt die Aufgabenklasse in die Warteschlange einzuplanen. Dies ist nützlich für schnelle, einfache Aufgaben, die ausgeführt werden müssen:

$podcast = App\Podcast::find(1);
dispatch(function () use ($podcast) { 
   $podcast->publish();
});

Wenn ein Abschluss an eine Warteschlange gesendet wird, wird der Codeinhalt des Abschlusses kryptografisch signiert, sodass er während der Übertragung nicht geändert werden kann.

Ausführen eines Warteschlangenhandlers

Laravel enthält einen Warteschlangenhandler zum Ausführen von Aufgaben, die in die Warteschlange verschoben werden. Sie können den Befehl queue:work Artisan verwenden, um den Prozessor auszuführen. Beachten Sie, dass der queue:work-Befehl, sobald er ausgeführt wird, so lange weiter ausgeführt wird, bis er manuell gestoppt oder das Terminal geschlossen wird.

php artisan queue:work

{Tipp} Damit der queue:work-Prozess im Hintergrund läuft, sollten Sie einen Prozessmanager wie Supervisor verwenden, um sicherzustellen, dass der Warteschlangenprozessor nicht aufhört zu laufen

Denken Sie daran, dass der Warteschlangenhandler ein residenter Prozess ist und den Status der gestarteten Anwendung im Speicher hält. Daher werden sie nach dem Start keine Änderungen an Ihrem Code bemerken. Denken Sie also bei Ihrer erneuten Bereitstellung daran, Ihre Warteschlangenhandler neu zu starten.

Verbindungen und Warteschlangen angeben

Sie können auch angeben, welche Warteschlangenverbindung die Warteschlange hat welcher Prozessor verwendet werden soll. Der an work übergebene Verbindungsname sollte mit einer der in Ihrer config/queue.php-Konfigurationsdatei definierten Verbindungen übereinstimmen.

php artisan queue:work redis

Sie können Ihren Warteschlangenhandler sogar so anpassen, dass er nur die in der Verbindung angegebene Warteschlange ausführt. Wenn beispielsweise alle Ihre E-Mails von der durch redis verbundenen emails-Warteschlange verarbeitet werden, können Sie mit dem folgenden Befehl einen Prozessor starten, der nur für diese Warteschlange ausgeführt wird:

php artisan queue:work redis --queue=emails

ausführen Die Option „Einzelaufgabe“

--once wird verwendet, um den Warteschlangenprozessor zu veranlassen, nur eine einzelne Aufgabe in der Warteschlange zu verarbeiten.

php artisan queue:work --once

Alle Aufgaben in der Warteschlange verarbeiten und dann beenden

--stop-when-empty Mit der Option kann der Warteschlangenprozessor so verarbeitet werden, dass er alle Aufgaben verarbeitet und dann ordnungsgemäß beendet wird. Diese Option ist nützlich, wenn Sie eine Laravel-Warteschlange in einem Docker-Container ausführen, wenn Sie den Container herunterfahren möchten, nachdem die Warteschlange leer ist:

php artisan queue:work --stop-when-empty

Ressourcenhinweise

Hintergrundaufbewahrung Die verbleibenden Warteschlangenhandler „starten“ das Framework nicht neu, nachdem jede Aufgabe ausgeführt wurde. Daher sollten Sie nach Abschluss jeder Aufgabe überschüssige Ressourcen freigeben. Wenn Sie beispielsweise eine Bildverarbeitung mit der GD-Bibliothek durchführen, sollten Sie imagedestroy verwenden, um den Speicher freizugeben, wenn Sie fertig sind.

Warteschlangenpriorität

Manchmal möchten Sie möglicherweise die Warteschlangenausführung priorisieren. Beispielsweise können Sie in config/queue.php die Priorität der redis-Warteschlange der queue-Verbindung von default auf low festlegen. Gelegentlich möchten Sie jedoch möglicherweise eine Aufgabe wie folgt in die high-Warteschlange verschieben:

dispatch((new Job)->onQueue('high'));

muss einen Handler ausführen, um die Aufgaben in der low-Warteschlange zu bestätigen, bis alle high-Warteschlangenaufgaben abgeschlossen sind . Wenn Sie die Ausführung fortsetzen, können Sie eine durch Kommas getrennte Liste von Warteschlangennamen als Argumente an den Befehl work übergeben.

php artisan queue:work --queue=high,low

Warteschlangenprozessoren und Bereitstellung

Da Warteschlangenprozessoren residente Prozesse sind, werden sie nicht von Ihren Codeänderungen betroffen sein angewandt. Daher besteht die einfachste Möglichkeit zum Bereitstellen einer Anwendung, die einen Warteschlangenprozessor verwendet, darin, den Warteschlangenprozessor während des Bereitstellungsprozesses neu zu starten. Sie können alle Warteschlangenprozessoren mithilfe der Methode queue:restart ordnungsgemäß neu starten:

php artisan queue:restart

Dieser Befehl weist alle Warteschlangenprozessoren an, nach Abschluss der aktuellen Aufgabe ordnungsgemäß abzubrechen, sodass keine Aufgaben verloren gehen. Da der Warteschlangenhandler nach der Ausführung von queue:restart beendet wird, sollten Sie einen Prozessmanager wie Supervisor ausführen, um den Warteschlangenhandler automatisch neu zu starten.

{tip} Die Warteschlange verwendet Cache, um Neustartsignale zu speichern. Sie sollten daher sicherstellen, dass Sie den Cache-Treiber konfigurieren, bevor Sie diese Funktion verwenden.

Aufgabenablauf und Zeitüberschreitung

Aufgabenablauf

In deinemconfig/queue.php In der Konfigurationsdatei definiert jede Warteschlangenverbindung eine retry_after-Option. Diese Option gibt an, wie lange die Warteschlangenverbindung auf eine Aufgabe warten soll, bevor sie sie erneut versucht. Wenn beispielsweise der Wert von retry_after auf 90 gesetzt ist, wird die Aufgabe nach 90 Sekunden Ausführungszeit wieder in die Warteschlange gestellt, anstatt sie zu löschen. Im Allgemeinen sollten Sie den Wert von retry_after auf den Wert festlegen, von dem Sie glauben, dass die Ausführung Ihrer Aufgabe wahrscheinlich am längsten dauert.

{note} Der Wert retry_after existiert nicht nur in Amazon SQS. SQS wird die Aufgabe basierend auf dem in der AWS-Konsole konfigurierten Standardwert für das sichtbare Zeitlimit wiederholen.

Prozessor-Timeout

queue:work Der Artisan-Befehl enthält eine --timeout-Option. Die Option --timeout gibt an, wie lange der Warteschlangenmaster von Laravel wartet, bevor er einen untergeordneten Prozess abbricht, der eine Aufgabe ausführt. Manchmal kann ein untergeordneter Prozess aus verschiedenen Gründen „einfrieren“, beispielsweise weil er nicht auf eine externe HTTP-Anfrage reagiert. Die Option --timeout entfernt Prozesse, die länger als die angegebene Zeit eingefroren waren. Das Konfigurationselement

php artisan queue:work --timeout=60

retry_after und die Befehlszeilenkonfiguration --timeout unterscheiden sich nicht, aber ihre gemeinsame Verwendung kann sicherstellen, dass die Aufgabe nicht verloren geht und die Aufgabe nur einmal erfolgreich ausgeführt wird.

{note} Der Wert von --timeout sollte mindestens ein paar Sekunden kürzer sein als der Wert, den Sie in retry_after konfiguriert haben. Dadurch wird sichergestellt, dass der Prozessor immer abbricht, bevor eine Aufgabe erneut versucht werden kann. Wenn Ihr --timeout-Wert länger als der retry_after-Wert ist, wird Ihre Aufgabe möglicherweise zweimal ausgeführt.

Ruhezeit des Warteschlangenprozesses

Wenn eine Aufgabe in der Warteschlange verfügbar ist, verarbeitet der Prozessor die Aufgabe ohne Unterbrechung weiter. Die Option sleep definiert jedoch, wie lange der Prozessor „schläft“, wenn keine neuen Aufgaben anstehen. Während der Prozessor schläft, verarbeitet er keine neuen Aufgaben – Aufgaben werden ausgeführt, wenn der Warteschlangenprozessor erneut gestartet wird.

php artisan queue:work --sleep=3

Supervisor-Konfiguration

Install Supervisor

Supervisor ist Linux Ein Prozessmonitor unter dem Betriebssystem, der sein kann queue:work Automatischer Neustart, wenn es hängt. Um Supervisor unter Ubuntu zu installieren, können Sie den folgenden Befehl verwenden:

sudo apt-get install supervisor

{Tipps} Wenn Sie Schwierigkeiten haben, Supervisor zu konfigurieren, können Sie die Verwendung von Laravel Forge in Betracht ziehen Installieren und konfigurieren Sie Supervisor automatisch für Ihr Laravel-Projekt.

Supervisor konfigurieren

Supervisor-Konfigurationsdateien befinden sich normalerweise im Verzeichnis /etc/supervisor/conf.d. In diesem Verzeichnis können Sie eine beliebige Anzahl von Konfigurationsdateien erstellen, um zu steuern, wie der Supervisor Ihren Prozess überwacht. Erstellen Sie beispielsweise eine laravel-worker.conf-Datei, um einen queue:work-Prozess zu starten und zu überwachen:

[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /home/forge/app.com/artisan queue:work sqs --sleep=3 --tries=3
autostart=true
autorestart=true
user=forge
numprocs=8
redirect_stderr=true
stdout_logfile=/home/forge/app.com/worker.log

In diesem Beispiel gibt die numprocs-Direktive Supervisor an, 8 queue:work-Prozesse automatisch auszuführen und zu überwachen Starten Sie sie neu, wenn sie hängen bleiben. Sie sollten den command-Teil der queue：work sqs-Optionen ändern, um Ihre gewünschte Warteschlangenverbindung darzustellen.

Supervisor starten

Nachdem die Konfigurationsdatei erstellt wurde, können Sie den folgenden Befehl verwenden, um die Supervisor-Konfiguration zu aktualisieren und den Vorgang zu starten:

sudo supervisorctl reread

sudo supervisorctl update

sudo supervisorctl start laravel-worker:*

Weitere Informationen zu Supervisor finden Sie hier Vorgesetzter Dokumentation.

Umgang mit fehlgeschlagenen Aufgaben

Manchmal werden Ihre Aufgaben in der Warteschlange nicht ausgeführt. Entspanne deinen Geist, gute Dinge kommen nur mit der Zeit. Laravel enthält eine praktische Methode, um anzugeben, wie oft eine Aufgabe maximal versucht werden soll. Wenn eine Aufgabe die maximale Anzahl an Versuchen erreicht hat, wird sie in die Datenbanktabelle failed_jobs eingefügt. Um die Datenbankmigrationstabelle failed_jobs zu erstellen, können Sie den Befehl queue:failed-table verwenden:

php artisan queue:failed-table

php artisan migrate

. Wenn Sie dann den Warteschlangenarbeiter ausführen, sollten Sie queue：work im verwenden --tries Befehl Der Schalter gibt an, wie oft die Aufgabe maximal ausgeführt werden soll. Wenn für die Option --tries kein Wert angegeben ist, wird eine Endlosschleife versuchen, die Aufgabe auszuführen:

php artisan queue:work redis --tries=3

Aufräumen danach Aufgabenfehler

Sie können es direkt in der Aufgabenklasse definierenfailed Methode, mit der Sie Bereinigungsarbeiten für eine Aufgabe durchführen können, wenn diese fehlschlägt. Dies ist ein hervorragender Ort, um Benachrichtigungen an den Benutzer zu senden oder alle von der Aufgabe ausgeführten Aktionen fortzusetzen. Das Exception, das zum Fehlschlagen der Aufgabe geführt hat, wird an die Methode failed übergeben:

<?php
    namespace App\Jobs;
    use Exception;use App\Podcast;
    use App\AudioProcessor;
    use Illuminate\Bus\Queueable;
    use Illuminate\Queue\SerializesModels;
    use Illuminate\Queue\InteractsWithQueue;
    use Illuminate\Contracts\Queue\ShouldQueue;
    class ProcessPodcast implements ShouldQueue{ 
       use InteractsWithQueue, Queueable, SerializesModels;    
       protected $podcast;   
     /**
     * 创建任务实例
     *
     * @param  Podcast  $podcast
     * @return void
     */   
     public function __construct(Podcast $podcast)  
       {       
        $this->podcast = $podcast;  
        }   
    /**
     * 执行任务
     *
     * @param  AudioProcessor  $processor
     * @return void
     */  
     public function handle(AudioProcessor $processor) 
        {     
           // 上传播客……   
         }  
    /**
     * 任务失败的处理过程
     *
     * @param  Exception  $exception
     * @return void
     */   
     public function failed(Exception $exception) 
        {     
          // 给用户发送任务失败的通知，等等……   
         }
      }

Aufgabenfehlerereignis

Wenn Sie ein aufrufbares Ereignis registrieren möchten, wenn eine Aufgabe fehlschlägt, können Sie die Methode Queue::failing verwenden. Diese Veranstaltung ist ein guter Zeitpunkt, um Ihr Team per E-Mail oder Slack zu benachrichtigen. Beispielsweise können wir in Laravel ein Rückrufereignis an AppServiceProvider anhängen:

<?php
    namespace App\Providers;
    use Illuminate\Support\Facades\Queue;
    use Illuminate\Queue\Events\JobFailed;
    use Illuminate\Support\ServiceProvider;
    class AppServiceProvider extends ServiceProvider{   
     /**
     * 启动任意服务。
     *
     * @return void
     */    
    public function boot()   
     {       
      Queue::failing(function (JobFailed $event) {     
             // $event->connectionName            
             // $event->job            
             // $event->exception        
           }); 
       }    
    /**
     * 注册服务提供者。
     *
     * @return void
     */    
    public function register()    { 
           //   
           }
    }

Retry the failed task

Um alle Aufgaben anzuzeigen, die in der Datentabelle failed_jobs platziert wurden, können Sie verwenden Artisan-Befehl queue:failed: Der Befehl

php artisan queue:failed

queue:failed listet die Aufgaben-ID, die Warteschlange und die Fehlerzeit auf. Die Aufgaben-ID kann verwendet werden, um fehlgeschlagene Aufgaben erneut zu versuchen. Um beispielsweise eine Aufgabe mit der Aufgaben-ID 5 erneut zu versuchen, verwenden Sie den folgenden Befehl:

php artisan queue:retry 5

Um alle fehlgeschlagenen Aufgaben erneut zu versuchen, führen Sie den Befehl queue:retry aus und übergeben Sie all als ID:

php artisan queue:retry all

Wenn Sie eine fehlgeschlagene Aufgabe löschen möchten, verwenden Sie queue:forget Befehl:

php artisan queue:forget 5

Um alle fehlgeschlagenen Aufgaben zu löschen, verwenden Sie queue:flush Befehl:

php artisan queue:flush

Fehlende Modelle ignorieren

Beim Einfügen eines Eloquent-Modells in eine Aufgabe wird das Modell automatisch serialisiert, bevor es in die Warteschlange gestellt und wiederhergestellt wird, wenn die Aufgabe ausgeführt wird. Wenn das Modell jedoch gelöscht wird, während die Aufgabe auf ihre Ausführung wartet, schlägt die Aufgabe möglicherweise fehl und löst ModelNotFoundException aus.

Der Einfachheit halber können Sie Aufgaben mit fehlenden Modellen automatisch löschen, indem Sie das deleteWhenMissingModels-Attribut der Aufgabe auf true setzen.

/**
 * 如果模型缺失即删除任务。
 *
 * @var bool
 */
 public $deleteWhenMissingModels = true;

Aufgabenereignis

Durch Verwendung der Methoden Queue und before in der after-Fassade , Sie können einen Rückruf vor und nach der Ausführung einer Warteschlangenaufgabe angeben. Diese Rückrufe sind eine hervorragende Gelegenheit, zusätzliche Protokolle hinzuzufügen oder Statistiken zu verbessern. Normalerweise sollten Sie diese Methoden im Dienstanbieter aufrufen. Zum Beispiel können wir Laravels AppServiceProvider verwenden:

<?php
    namespace App\Providers;
    use Illuminate\Support\Facades\Queue;
    use Illuminate\Support\ServiceProvider;
    use Illuminate\Queue\Events\JobProcessed;
    use Illuminate\Queue\Events\JobProcessing;
    class AppServiceProvider extends ServiceProvider{    
     /**
     * 引导启动任意应用服务。
     *
     * @return void
     */    
    public function boot()   
     {       
        Queue::before(function (JobProcessing $event) {   
                // $event->connectionName            
                // $event->job            
                // $event->job->payload()      
              });      
        Queue::after(function (JobProcessed $event) {      
              // $event->connectionName            
              // $event->job            
              // $event->job->payload()       
            });    }   
    /**
     * 注册服务提供者。
     *
     * @return void
     */   
    public function register()   
   {      
    //  
     }
  }

Mit der Queue-Methode an der looping-Fassade kann ein Rückruf ausgeführt werden, bevor der Prozessor versucht, die Aufgabe abzurufen. Beispielsweise möchten Sie möglicherweise einen Abschluss verwenden, um eine zuvor fehlgeschlagene Aufgabe rückgängig zu machen, bei der die Transaktion noch nicht abgeschlossen wurde:

Queue::looping(function () { 
   while (DB::transactionLevel() > 0) { 
          DB::rollBack();   
       }
    });