Python-Serverprogrammierung: Aufgabenwarteschlange mit Django-Cellery

Python-Serverprogrammierung: Aufgabenwarteschlange mit Django-Cellery

Angesichts der zunehmenden Beliebtheit von Webanwendungen und der steigenden Anzahl von Benutzern müssen moderne Webanwendungen durch die Bewältigung komplexer und zeitkritischer Aufgaben Produktivität und Stabilität aufrechterhalten. Von der Bestellabwicklung auf E-Commerce-Websites und der Verarbeitung von Systemprotokolldateien bis hin zu fortgeschrittenen Anwendungen der Computer Vision und der Verarbeitung natürlicher Sprache erfordern diese Aufgaben unabhängige Prozesse zur Bewältigung.

Der herkömmliche Ansatz besteht darin, cron oder einen ähnlichen Jobplaner zu verwenden, es gibt jedoch folgende Probleme:

• Es ist schwierig, Aufgaben dynamisch zu verwalten und zuzuweisen.
• Es ist schwierig, fehlgeschlagene Aufgaben erneut zu versuchen.
• Aufgaben können nicht einfach auf mehrere Server verteilt werden.
• Keine Möglichkeit, den Status von Jobs und Aufgaben zu verfolgen und zu überwachen.

Um diese Probleme zu lösen, benötigen wir einen Aufgabenwarteschlangendienst.

Im Python-Ökosystem ist Celery die am häufigsten verwendete Aufgabenwarteschlange. Es handelt sich um eine Aufgabenwarteschlange, die für verteilte Systeme entwickelt wurde und sich für Webanwendungen mit hoher Parallelität und hohem Durchsatz eignet.

In diesem Artikel stellen wir vor, wie man mit Celery und Django einen Aufgabenwarteschlangendienst entwickelt. Wir werden Django-Celery als Django-Integration für Celery verwenden.

1. Zugehörige Abhängigkeiten installieren

Zuerst müssen wir die Abhängigkeiten von Celery und Django-Celery im Projekt installieren. Sie können sie mit dem Pip-Tool installieren.

pip install celery django-celery

2. Cellery konfigurieren

Bevor wir Celery verwenden, müssen wir Celery konfigurieren. Erstellen Sie dazu eine Datei namens celery.py, die sich im Stammverzeichnis Ihres Projekts befinden sollte. Der Inhalt der Datei lautet wie folgt:

from __future__ import absolute_import, unicode_literals

import os

from celery import Celery

# Set the default Django settings module for the 'celery' program.
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'example.settings')

app = Celery('example')

# Using a string here means the worker will not have to
# pickle the object when using Windows.
app.config_from_object('django.conf:settings', namespace='CELERY')

# Load task modules from all registered Django app configs.
app.autodiscover_tasks()

Hinweis: Wenn Sie Celery mit der in der Datei „settings.py“ angegebenen Konfiguration konfigurieren möchten, ersetzen Sie bitte „example.settings“ durch Ihren tatsächlichen Django-Projektnamen.

3. Django konfigurieren

Jetzt müssen wir Django in der Datei „settings.py“ so konfigurieren, dass es Celery unterstützt.

# Celery Configuration
CELERY_BROKER_URL = 'redis://localhost:6379/0'
CELERY_RESULT_BACKEND = 'redis://localhost:6379/0'

CELERY_ACCEPT_CONTENT = ['application/json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'

# app注册
INSTALLED_APPS = (
    ...
    'django_celery_results',
    'django_celery_beat',
    ...
)

Hier konfigurieren wir zwei wichtige Einstellungen. (1) CELERY_BROKER_URL – Dies weist Celery an, Redis als Middleware-Dienst zu verwenden. (2) INSTALLED_APPS – Wir müssen zwei Anwendungen von Django-Celery in unserer Anwendung registrieren.

4. Eine Aufgabe erstellen

Da wir nun Celery und Django konfiguriert haben, können wir mit der Definition einiger Aufgaben beginnen. Wir erstellen eine Beispielaufgabe, um die Aufgabenstruktur und -syntax zu demonstrieren. Fügen Sie in der Datei app/tasks.py den folgenden Inhalt hinzu.

from django.core.mail import send_mail
from celery import shared_task
from datetime import datetime


@shared_task
def send_email_task():
    subject = 'Celery Email Demo'
    message = 'This email is sent using celery!'
    from_email = 'demo@example.com'
    recipient_list = ['recipient@example.com']
    send_mail(subject, message, from_email, recipient_list)

    print('Email Sent Successfully')
    return None


@shared_task
def print_time():
    now = datetime.now()
    current_time = now.strftime("%H:%M:%S")
    print("Current Time =", current_time)

    return None

Hier definieren wir zwei Aufgaben. Es handelt sich um send_email_task- bzw. print_time-Aufgaben. Beachten Sie dies, wir dekorieren die Aufgabe mit dem shared_task-Dekorator. Dadurch sind unsere Aufgaben von überall aus zugänglich und können von mehreren Prozessen aufgerufen werden.

5. Worker-Prozesse starten

Da wir nun die Aufgaben definiert haben, müssen wir Worker-Prozesse starten und ihnen sagen, welche Aufgaben sie ausführen sollen.

Öffnen Sie ein Terminalfenster und geben Sie den folgenden Befehl ein:

$ celery -A example worker --loglevel=info

Beachten Sie, dass das Beispiel den Namen des Django-Projekts darstellt. Hier verwenden wir --loglevel=info, um die Protokollebene des Workers zu steuern.

6. Aufgaben über die Django-Administratoroberfläche planen

Django-Celery unterstützt die Verwaltung und Planung von Aufgaben über die Django-Administratoroberfläche. Wir müssen zwei Anwendungen bei Django-Celery registrieren. Wir können den folgenden Code in die Datei admin.py einfügen.

from django.contrib import admin
from django_celery_beat.admin import PeriodicTaskAdmin, IntervalScheduleAdmin
from django_celery_results.models import TaskResult
from django_celery_results.admin import TaskResultAdmin
from core.tasks import send_email_task, print_time


class Tasks(admin.ModelAdmin):
    actions = ['send_email_task', 'print_time']

    def send_email_task(self, request, queryset):
        send_email_task.delay()

    send_email_task.short_description = "Send Email Task"

    def print_time(self, request, queryset):
        print_time.delay()

    print_time.short_description = "Print Current Time"


admin.site.unregister(TaskResult)
admin.site.register(TaskResult, TaskResultAdmin)
admin.site.register(IntervalSchedule, IntervalScheduleAdmin)
admin.site.register(PeriodicTask, PeriodicTaskAdmin)
admin.site.register(Tasks)

Hier fügen wir unsere Aufgaben zur Admin-Oberfläche hinzu. Wir können diese Aufgaben ausführen, indem wir auf die Schaltflächen „Mail-Aufgabe ausführen“ und „Aktuelle Zeit drucken“ klicken.

Jetzt haben wir mit Django-Celery erfolgreich einen Aufgabenwarteschlangendienst eingerichtet. Wir können es für verschiedene Anwendungen verwenden und mithilfe von Kommunikationsprotokollen wie WebSocket- und HTTP-Protokollen an mehrere Server verteilen.

Fazit

In diesem Artikel wird vorgestellt, wie man mit Celery und Django einen Aufgabenwarteschlangendienst entwickelt. Wir verwenden Django-Celery als Django-Integration für Celery und zeigen, wie man Aufgaben definiert, Celery konfiguriert, Worker startet, Aufgaben plant und Aufgaben verwaltet. Aufgabenwarteschlangendienste bieten eine hervorragende Möglichkeit, komplexe und zeitaufwändige Aufgaben zu bewältigen und ermöglichen eine bessere Leistung und Zuverlässigkeit von Webanwendungen.

Das obige ist der detaillierte Inhalt vonPython-Serverprogrammierung: Aufgabenwarteschlange mit Django-Cellery. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!