Optimiser le processus de traitement des tâches asynchrones à l'aide de Celery Redis Django

Utilisez Celery Redis Django pour optimiser le processus de traitement des tâches asynchrones

Pendant le processus de développement, vous rencontrez souvent des tâches fastidieuses qui doivent être traitées, telles que les requêtes réseau, les téléchargements de fichiers, le traitement des données, etc. Si vous attendez que ces tâches soient terminées lors du traitement de la demande, l’expérience utilisateur sera dégradée voire la demande sera bloquée. Pour résoudre ce problème, le traitement des tâches asynchrones peut être utilisé pour améliorer les performances et la vitesse de réponse du système.

Celery est un framework de traitement de tâches asynchrones Python couramment utilisé. Il utilise un middleware de messages pour implémenter la distribution et la réception des tâches. Redis est un middleware de messagerie populaire qui peut servir de proxy de messagerie pour Celery. Django est un framework Web Python couramment utilisé qui peut être intégré de manière transparente à Celery et Redis pour offrir une meilleure expérience de développement.

Cet article expliquera comment utiliser Celery, Redis et Django pour optimiser le processus de traitement des tâches asynchrones et fournira des exemples de code spécifiques.

Tout d'abord, vous devez installer Celery et Redis et les ajouter à votre projet Django. Vous pouvez utiliser la commande pip pour installer les bibliothèques requises :

pip install Celery Redis

Après l'installation, ajoutez la configuration suivante dans le fichier settings.py du projet Django :

# settings.py

CELERY_BROKER_URL = 'redis://localhost:6379/0'
CELERY_RESULT_BACKEND = 'redis://localhost:6379/0'

Parmi elles, CELERY_BROKER_URL précise l'adresse de connexion et le port de Redis, et CELERY_RESULT_BACKEND spécifie l'adresse Redis de stockage du résultat de la tâche.

Ensuite, créez un fichier tâches.py qui définit les tâches qui doivent être traitées de manière asynchrone :

# tasks.py

from celery import shared_task

@shared_task
def process_file(file_path):
    # 处理文件的耗时操作
    # ...

@shared_task
def request_api(url):
    # 发送网络请求的耗时操作
    # ...

Dans Django, utilisez le décorateur @shared_task pour déclarer la fonction comme tâche partagée. Ces tâches seront automatiquement découvertes et traitées par Celery. @shared_task装饰器将函数声明为共享任务。这些任务将会被Celery自动发现并处理。

在views.py中，可以调用这些任务来进行异步处理：

# views.py

from .tasks import process_file, request_api

def upload_file(request):
    if request.method == 'POST':
        file = request.FILES['file']
        # 将上传的文件保存到磁盘
        with open(file_path, 'wb+') as destination:
            for chunk in file.chunks():
                destination.write(chunk)
        # 异步处理文件
        process_file.delay(file_path)
    return render(request, 'upload.html')

def send_request(request):
    if request.method == 'POST':
        url = request.POST['url']
        # 异步发送网络请求
        request_api.delay(url)
    return render(request, 'request.html')

在上述示例中，upload_file视图函数保存上传的文件到磁盘，并通过调用process_file.delay()方法将任务提交给Celery进行异步处理。同样，send_request视图函数通过调用request_api.delay()方法将任务提交给Celery。这样，这些耗时的任务将在后台异步处理，从而提高了系统的响应速度。

最后，需要启动Celery的工作节点，让其监听并处理任务：

celery -A your_project_name worker --loglevel=info

其中，your_project_name

Dans vues.py, ces tâches peuvent être appelées pour un traitement asynchrone :

rrreee

Dans l'exemple ci-dessus, la fonction de vue upload_file enregistre le fichier téléchargé sur le disque et le traite en appelant process_file.delay() La méthode soumet des tâches à Celery pour un traitement asynchrone. De même, la fonction de vue send_request soumet la tâche à Celery en appelant la méthode request_api.delay(). De cette manière, ces tâches chronophages seront traitées de manière asynchrone en arrière-plan, améliorant ainsi la réactivité du système.

Enfin, vous devez démarrer le nœud de travail Celery et le laisser écouter et traiter les tâches :

rrreee

Où, your_project_name fait référence au nom du projet Django.

Grâce aux étapes ci-dessus, vous pouvez utiliser Celery Redis Django pour optimiser le processus de traitement des tâches asynchrones. Grâce à cette méthode, les tâches fastidieuses peuvent être placées dans la file d'attente des messages et Celery est responsable du traitement, améliorant ainsi les performances de concurrence et la vitesse de réponse du système.

1. Résumé :
2. L'optimisation du processus de traitement des tâches asynchrones est un moyen important d'améliorer les performances du système et la vitesse de réponse. Cet article explique comment utiliser la combinaison Celery Redis Django pour implémenter le traitement des tâches asynchrones. En soumettant des tâches fastidieuses à Celery pour un traitement asynchrone, le blocage des requêtes peut être évité et les performances de concurrence et la vitesse de réponse du système peuvent être améliorées.

Référence : 🎜🎜🎜Documentation Céleri : https://docs.celeryproject.org/en/stable/🎜🎜Documentation Redis : https://redis.io/documentation🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!