Celery is a distributed task queue that can process vast amounts of messages, while Django is a high-level web framework for Python. Integrating Celery with Django allows you to execute asynchronous tasks, which is particularly useful for long-running operations that you don't want to run during a typical HTTP request-response cycle.
Here's how to integrate Celery with Django:
Celery requires a solution to send and receive messages, typically a message broker. RabbitMQ is a widely-used broker, but Redis can also be used.
pip install celery[redis] # for Redis as the broker
Or if you're using RabbitMQ:
pip install celery
celery.py in your Django project's main folder:If your project is named myproject, then inside the myproject/ directory (the same level as settings.py), create a celery.py file.
from __future__ import absolute_import, unicode_literals
import os
from celery import Celery
from django.conf import settings
# Set the default Django settings module for the 'celery' program.
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')
app = Celery('myproject')
# Use a string here to represent the broker URL.
app.config_from_object('django.conf:settings', namespace='CELERY')
# Autodiscover tasks in all installed apps.
app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)
@app.task(bind=True)
def debug_task(self):
print('Request: {0!r}'.format(self.request))
settings.py:Include the broker URL and other configurations if needed.
For Redis:
CELERY_BROKER_URL = 'redis://localhost:6379/0'
For RabbitMQ:
CELERY_BROKER_URL = 'pyamqp://guest:guest@localhost//'
In the celery.py, we've mentioned the autodiscover_tasks function, which will discover tasks from all of your installed apps. For this to work, ensure that each app with Celery tasks has a tasks.py file.
Navigate to your project directory (where manage.py resides) and start a Celery worker:
celery -A myproject worker --loglevel=info
In any of your Django apps, you can now create a tasks.py file and define tasks. For example:
from celery import shared_task
@shared_task
def add(x, y):
return x + y
Tasks can be called from anywhere in your Django project:
from myapp.tasks import add result = add.delay(4, 4)
The delay method sends the task to the queue and returns immediately without waiting for the task to complete. If you want to wait for the result, you can use:
result_value = result.get(timeout=3) # wait for 3 seconds at most
Remember to monitor and manage your tasks, especially in a production environment. Tools like Flower can be used to monitor Celery tasks.
Lastly, while Celery with Django offers powerful asynchronous capabilities, ensure you handle exceptions and failures gracefully, especially when dealing with tasks that are critical to your application's operation.
To update a Haystack search index with Django and Celery, you can create a Celery task that triggers the index update asynchronously. This is useful when you want to update the search index without blocking the main application. Here's a step-by-step guide:
Set Up Celery:
If you haven't already set up Celery in your Django project, you can do so by following the official documentation: Celery - Getting Started
Ensure you have Celery configured with your Django project, including the necessary broker (e.g., RabbitMQ, Redis) and task settings.
Create a Celery Task:
In your Django app, create a Celery task that performs the index update. You can use the @shared_task decorator provided by Celery for this purpose. Here's an example:
# myapp/tasks.py
from celery import shared_task
from haystack.management.commands import update_index
@shared_task
def async_update_search_index():
update_index.Command().handle()
In this example, we define a shared_task named async_update_search_index that runs the update_index management command provided by Haystack.
Trigger the Task:
You can trigger the async_update_search_index task whenever you want to update the search index asynchronously. For example, you can call this task from a view, a model's save method, or any other appropriate location in your Django code.
# myapp/views.py
from myapp.tasks import async_update_search_index
def some_view(request):
# ... Your view logic ...
# Trigger the Celery task to update the search index
async_update_search_index.delay()
# ... Continue with your view logic ...
Run Celery Workers:
Make sure you have Celery workers running to process tasks. You can start Celery workers with the following command:
celery -A your_project_name worker --loglevel=info
Replace your_project_name with the actual name of your Django project.
Now, when you call async_update_search_index.delay() from your code, Celery will enqueue the task to update the search index asynchronously. This ensures that the index update process doesn't block your main application and runs in the background.
Remember to configure your Haystack settings appropriately, including specifying the search engine backend (e.g., Elasticsearch, Solr) and the index models you want to update.
Additionally, ensure that your Celery configuration is set up correctly and that the Celery workers are running and connected to the message broker.
Razorpay is a popular payment gateway that offers a seamless payment experience. Integrating Razorpay into a Django application involves a few key steps. Here's a step-by-step guide:
1.1 Install Razorpay Python SDK:
pip install razorpay
1.2 Setup Razorpay Account:
Settings -> API Keys, generate the keys. You'll get a Key ID and Key Secret.2.1 Add your keys to Django's settings:
# settings.py RAZORPAY_KEY_ID = 'your_key_id' RAZORPAY_KEY_SECRET = 'your_key_secret'
2.2 Create a view for payment: In this view, you'll create an order using Razorpay's API and then render the payment form.
import razorpay
from django.shortcuts import render
def payment(request):
client = razorpay.Client(auth=(RAZORPAY_KEY_ID, RAZORPAY_KEY_SECRET))
# Create a Razorpay Order
data = {
'amount': 50000, # Amount in paise
'currency': 'INR',
'receipt': 'order_rcptid_11',
'payment_capture': '1'
}
order = client.order.create(data=data)
context = {
'order_id': order['id'],
'key_id': RAZORPAY_KEY_ID
}
return render(request, 'payment.html', context)
2.3 Create the payment form (payment.html):
<form action="/success/" method="POST">
<script
src="https://checkout.razorpay.com/v1/checkout.js"
data-key="{{ key_id }}"
data-amount="50000"
data-currency="INR"
data-buttontext="Pay with Razorpay"
data-name="Your Company Name"
data-description="Test payment"
data-image="https://example.com/path/to/logo.png"
data-prefill.name="Gaurav Kumar"
data-prefill.email="[email protected]"
data-theme.color="#F37254"
></script>
<input type="hidden" name="razorpay_order_id" value="{{ order_id }}">
</form>
2.4 Handle Payment Success: You should also have a view to handle the successful payment and to verify its integrity.
from django.views.decorators.csrf import csrf_exempt
@csrf_exempt
def success(request):
params_dict = {
'razorpay_order_id': request.POST['razorpay_order_id'],
'razorpay_payment_id': request.POST['razorpay_payment_id'],
'razorpay_signature': request.POST['razorpay_signature']
}
client = razorpay.Client(auth=(RAZORPAY_KEY_ID, RAZORPAY_KEY_SECRET))
# Check for payment's integrity
check = client.utility.verify_payment_signature(params_dict)
if check is None:
print("Payment successful")
else:
print("Payment verification failed")
return HttpResponse("Payment successful!")
2.5 URL Configuration:
Add the views to your URL configuration (urls.py).
Always make sure to test your integration in Razorpay's test mode before going live. You can simulate different payment outcomes and ensure your application is handling them appropriately.
Once you're satisfied with the testing, you can switch to the live mode on Razorpay. Remember to replace the test Key ID and Key Secret with the live ones in your Django settings.
This is a basic integration guide. Depending on your application's needs, you might have to implement more advanced features, error checks, and other functionalities. Always refer to the official Razorpay documentation for a comprehensive understanding.