Introduction aux tâches Cron

Une tâche cron est une tâche planifiée qui s'exécute automatiquement à des intervalles spécifiés. Ces tâches sont utiles pour automatiser des opérations répétitives comme l'envoi d'e-mails de rappel, la génération de rapports ou le nettoyage de bases de données. Dans un projet Django, les tâches cron peuvent être configurées à l'aide d'outils comme Celery, ce qui rend la planification et la gestion des tâches faciles et efficaces.

Configuration de votre projet Django

Commençons par créer un projet Django, installer les packages nécessaires, puis conteneuriser le projet avec Docker.

Créez un environnement virtuel et installez Django et DRF

• Ouvrez votre terminal et accédez au répertoire de votre projet.
• Créer et activer un environnement virtuel :

python -m venv myenv
source myenv/bin/activate  # On Windows, use myenv\Scripts\activate

• Installez Django et Django REST Framework :

pip install django djangorestframework

Créer un projet et une application Django

• Créez un nouveau projet Django :

django-admin startproject myproject
cd myproject

• Créez une nouvelle application Django :

python manage.py startapp myapp

• Ajoutez l'application à vos paramètres.py :

# myproject/settings.py

INSTALLED_APPS = [
    ...
    'myapp',
    'rest_framework',
]

Installer le céleri et Redis

• Installez Celery et Redis :

pip install celery redis

• Configurez Celery dans votre projet en créant un fichier celery.py :

# myproject/celery.py
from __future__ import absolute_import, unicode_literals
import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

app = Celery('myproject')
app.config_from_object('django.conf:settings', namespace='CELERY')
app.autodiscover_tasks()

app.conf.beat_schedule = {
    'run-this-task-every-day': {
        'task': 'myapp.tasks.my_scheduled_task',
        'schedule': crontab(minute="00", hour="7"),  # Executes every day at 7 AM
    },
}

app.conf.timezone = 'UTC'

• Modifiez init.py pour charger Celery avec Django :

# myproject/__init__.py
from __future__ import absolute_import, unicode_literals
from .celery import app as celery_app

__all__ = ('celery_app',)

• Configurez le céleri dans settings.py :

CELERY_BROKER_URL = os.environ.get('REDIS_URL')
CELERY_RESULT_BACKEND = os.environ.get('REDIS_URL')
CELERY_ACCEPT_CONTENT = ['json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'
CELERY_TIMEZONE = 'UTC'
CELERY_BROKER_CONNECTION_RETRY_ON_STARTUP = True

Créer une tâche de céleri

Dans votre application Django, définissez la tâche dans Tasks.py :

# myapp/tasks.py
from celery import shared_task

@shared_task
def my_scheduled_task():
    print("This task runs every every day.")

Créer une configuration Docker

• Créez un Dockerfile pour votre Django pour l'API (nommé : Dockerfile.myapi) :

FROM python:3.8-alpine3.15

ENV PYTHONUNBUFFERED=1
ENV PYTHONDONTWRITEBYTECODE=1

WORKDIR /app

COPY requirements.txt /app

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 9000

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8000", "myproject.wsgi:application"]

• Créez un Dockerfile pour le céleri (nommé : Dockerfile.myjob)

FROM python:3.8-alpine3.15

ENV PYTHONUNBUFFERED=1
ENV PYTHONDONTWRITEBYTECODE=1

WORKDIR /app
COPY requirements.txt /app
RUN pip install --no-cache-dir -r requirements.txt
COPY . /app

CMD ["celery", "-A", "myproject", "worker", "--loglevel=info", "--concurrency=4", "-E", "-B"]

• Créez un fichier Requirements.txt pour répertorier vos dépendances :

Django==4.2
djangorestframework==3.14.0
celery==5.3.1
redis==5.0.0

• Créez un fichier docker-compose.yml pour gérer les services :

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.myapi
    container_name: myapp_api
    ports:
      - 7000:7000
    env_file:
      - .env

  celery:
    build:
      context: .
      dockerfile: Dockerfile.myjob
    container_name: myapp_job
    depends_on:
      - app
    env_file:
      - .env

• Créez un fichier .env et ajoutez-y la valeur de l'URL Redis :

REDIS_URL=

Créer et exécuter les conteneurs Docker

• Créez et exécutez les images Docker :

docker-compose up --build

Cela démarrera votre application Django, ainsi que le travailleur Celery et le planificateur de battements Celery.

Vérifier le travail Cron

Vos tâches Céleri devraient maintenant s'exécuter selon le calendrier que vous avez défini. Vous pouvez consulter les journaux à l'heure spécifiée pour confirmer que la tâche est en cours d'exécution.

Conclusion

L'exécution de tâches cron dans Django à l'aide de Celery, Docker et Redis offre une solution robuste et évolutive pour gérer les tâches en arrière-plan. Docker garantit que votre application s'exécute de manière cohérente dans différents environnements, ce qui facilite le déploiement. En suivant les étapes ci-dessus, vous pouvez automatiser efficacement les tâches et gérer facilement votre projet Django.