Mastering Django ORM Update Queries — From Basics to Pro Level

Updating data properly is just as important as selecting data. In this guide, you will learn how to update records correctly in Django ORM — from basic .save() usage to pro techniques like atomic updates, bulk updates, F expressions, and best practices! 📚 1. Basic Update Using .save() Fetch and modify a single object user = NewUser.objects.get(pk=1) user.email = 'newemail@example.com' user.save() ⚡ 2. Updating Specific Fields with .save(update_fields=[...]) user = NewUser.objects.get(pk=1) user.email = 'newemail@example.com' user.save(update_fields=['email']) 🎯 3. Updating Multiple Records at Once Using .update() NewUser.objects.filter(user_type=2).update(is_active=False) 🧠 4. .save() vs .update() — Key Differences Aspect .save() .update() Works on Single object QuerySet (multiple) Triggers signals? ✅ Yes ❌ No Auto-updates auto_now fields? ✅ Yes ❌ No Custom logic inside save() runs? ✅ Yes ❌ No Speed for bulk ❌ Slow ✅ Fast 🔥 5. Upda...
Post a Comment

A Complete Tutorial: Using RabbitMQ + Celery with Multiple Django Projects

In this post, we’ll walk through how to set up RabbitMQ on one server and run Celery across multiple Django projects, with clean project isolation, scalable architecture, and best practices.

✅ Step 1: Install RabbitMQ (Server A)

➡️ On Ubuntu (Server A):

sudo apt update
sudo apt install rabbitmq-server -y
sudo systemctl enable rabbitmq-server
sudo systemctl start rabbitmq-server

➡️ Enable RabbitMQ Management UI:

sudo rabbitmq-plugins enable rabbitmq_management

Visit: http://server-a-ip:15672 (default guest/guest).

➡️ Create RabbitMQ User:

sudo rabbitmqctl add_user admin strongpasswordhere
sudo rabbitmqctl set_user_tags admin administrator
sudo rabbitmqctl set_permissions -p / admin ".*" ".*" ".*"
sudo rabbitmqctl delete_user guest  # For security

➡️ Open Ports:

  • 5672 (for Celery workers)
  • 15672 (for admin UI, restricted IPs recommended)

✅ Step 2: Project Structure (Multiple Django Projects Example)

/var/www/
├── project_v1/
├── dealer_portal/
└── analytics_dashboard/

✅ Step 3: Celery Setup in Each Django Project

📂 In project_v1/celery.py:

from __future__ import absolute_import, unicode_literals
import os
from celery import Celery

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

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

📂 In project_v1/__init__.py:

from .celery import app as celery_app
__all__ = ('celery_app',)

✅ Repeat for each Django project with unique names and queues.

✅ Step 4: Celery Settings (in settings.py)

CELERY_BROKER_URL = 'amqp://admin:strongpassword@server-a-ip:5672//'
CELERY_ACCEPT_CONTENT = ['application/json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_TASK_QUEUES = {
'project_v1_queue': {
    'exchange': 'project_v1_exchange',
    'binding_key': 'project_v1_queue',
},
}
CELERY_BROKER_CONNECTION_RETRY_ON_STARTUP = True

✅ Step 5: Start Celery Workers

celery -A project_v1 worker -l info -Q project_v1_queue

✅ Step 6: Add Celery Beat (if needed)

celery -A project_v1 beat -l info --scheduler django_celery_beat.schedulers:DatabaseScheduler

✅ Step 7: Supervisor Configuration (to run worker & beat as services)

📄 Example: /etc/supervisor/conf.d/project_v1_celery.conf

[program:project_v1_worker]
command=/path/to/venv/bin/celery -A project_v1 worker -l info -Q project_v1_queue
directory=/var/www/project_v1
user=ubuntu
numprocs=1
stdout_logfile=/var/www/project_v1/celery-worker.log
stderr_logfile=/var/www/project_v1/celery-worker-err.log
autostart=true
autorestart=true
startsecs=10
stopwaitsecs=60
priority=999

[program:project_v1_beat]
command=/path/to/venv/bin/celery -A project_v1 beat -l info --scheduler django_celery_beat.schedulers:DatabaseScheduler
directory=/var/www/project_v1
user=ubuntu
numprocs=1
stdout_logfile=/var/www/project_v1/celery-beat.log
stderr_logfile=/var/www/project_v1/celery-beat-err.log
autostart=true
autorestart=true
startsecs=10
stopwaitsecs=60
priority=998

✅ Repeat this config for each Django project.

✅ Step 8: Reload Supervisor

sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start all

✅ Step 9: Monitor

  • RabbitMQ UI: http://server-a-ip:15672
  • Optional Flower monitoring:
celery -A project_v1 flower --port=5555

✅ Conclusion:

  • ✅ Install RabbitMQ on a dedicated server.
  • ✅ Multiple Django projects connect to the same RabbitMQ.
  • ✅ Each project has its own queue, Celery app name, and worker.
  • ✅ Manage processes with Supervisor.
  • ✅ Monitor queues with RabbitMQ UI and Flower.

Comments

Post a Comment

Popular posts from this blog

Implementing Throttling in Django REST Framework.

Implementing Throttling in Django REST Framework to Manage High Traffic and Prevent Abuse Introduction In high-traffic applications, it’s essential to protect server resources and ensure fair usage among users. Throttling is a method used in Django REST Framework (DRF) to limit the rate of requests, helping prevent abuse and manage load. In this article, we’ll explore how to implement throttling in DRF, including ways to apply it to specific views and dynamically whitelist IPs. What is Throttling? Throttling controls the rate of requests an API endpoint can receive from a single client. It’s a valuable tool for: Preventing abuse by limiting request rates for each user or IP address. Managing server load by avoiding high request volumes that can overwhelm the application. In Django REST Framework, throttling is easy to configure with built-in classes like UserRateThrottl...
Read more

Leveraging Asynchronous Views in Django REST Framework for High-Performance APIs

As web applications grow, handling a high volume of concurrent requests becomes essential. Traditional Django views, which are synchronous, can slow down the system by tying up resources for each request. Fortunately, starting with Django 3.1, asynchronous views were introduced. By leveraging async views, Django can serve more requests concurrently, improving scalability and responsiveness. Understanding Asynchronous Views in Django Asynchronous views allow Django to handle tasks that involve waiting, like database queries or API calls, without blocking threads. This approach allows the server to handle additional requests in the meantime. In Django, async views use the async and await keywords to enable non-blocking behavior. Example: Fetching Data from an External API Here’s an example of an asynchronous view in Django that fetches weather data from an external API. Instead of blocking while waiting for the API response, Django can handle oth...
Read more

Differences Between List, Dictionary, and Tuple in Python

In Python, lists, dictionaries, and tuples are all built-in data structures that store collections of items. While they share similarities, each has its distinct characteristics and use cases. This post provides a comprehensive comparison. Comparison Table Aspect List Dictionary Tuple Definition An ordered collection of elements. A collection of key-value pairs. An ordered and immutable collection of elements. Access Method Index-based access ( my_list[0] ). Key-based access ( my_dict['key'] ). Index-based access ( my_tuple[0] ). Mutability Mutable: Elements can be added, removed, or changed. Mutable (for values): Keys/values can be added, modified, or removed, but keys must be immutable. Immutable: Elements cannot be changed once assigned. Order Guarantee Maintains th...
Read more