Setting Up Django as the Gateway
In our microservices architecture, Django will serve as the gateway responsible for routing requests to the appropriate microservices. Let’s go through the steps of setting up Django as the gateway.
Project Structure
Let’s begin by organizing our projects:
- Gateway Project:
- Project Name: gateway_project
- Django App: gateway_app
- User Microservice Project:
- Project Name: user_project
- Django App: users_app
- Product Microservice Project:
- Project Name: product_project
- Django App: products_app
Step 1: Create folder of MS
| mkdir MS-Blog | |
| cd MS-Blog |
Step 2: Start Project and App for Gateway MS
| django-admin startproject gateway_project | |
| cd gateway_project | |
| python3 manage.py startapp gateway_app |
Step 3: Start Project and App for User MS
| django-admin startproject user_project | |
| cd user_project | |
| python3 manage.py startapp users_app |
Step 4: Start Project and App for Product MS
| django-admin startproject product_project | |
| cd product_project | |
| python3 manage.py startapp products_app |
Step 5: Install Django Rest Framework
| pip install djangorestframework |
Step 6: Configure Django Settings For Gateway MS
Update the INSTALLED_APPS in settings.py to include ‘rest_framework’:
| INSTALLED_APPS = [ | |
| # ... | |
| 'rest_framework', | |
| 'gateway', | |
| ] | |
| # Add CORS settings if necessary | |
| CORS_ORIGIN_ALLOW_ALL = True |
Step 7: Configure URLs for Gateway MS
gateway_project/urls.py
| from django.contrib import admin | |
| from django.urls import path, include | |
| from gateway.views import UserMicroserviceView, ProductMicroserviceView | |
| urlpatterns = [ | |
| path('admin/', admin.site.urls), | |
| path('api/users/', UserMicroserviceView.as_view(), name='user_microservice'), | |
| path('api/products/', ProductMicroserviceView.as_view(), name='product_microservice'), | |
| ] |
Step 8: Configure Business Logic for Gateway MS
gateway_project/gateway/views.py
Create a views.py file and define views that will communicate with the microservices:
| from rest_framework.views import APIView | |
| from rest_framework.response import Response | |
| from rest_framework import status | |
| import requests | |
| class UserMicroserviceView(APIView): | |
| def get(self, request): | |
| response = requests.get('http://localhost:8001/api/users/') | |
| return Response(response.json()) | |
| class ProductMicroserviceView(APIView): | |
| def get(self, request): | |
| response = requests.get('http://localhost:8002/api/products/') | |
| return Response(response.json()) |
Step 9: Configure Django Settings For User MS
user_project/settings.py
| INSTALLED_APPS = [ | |
| # ... | |
| 'rest_framework', | |
| 'users', | |
| ] | |
| # Add CORS settings if necessary | |
| CORS_ORIGIN_ALLOW_ALL = True |
Step 10: Configure URLs for User MS
user_project/urls.py
| from django.urls import path | |
| from users.views import UserListView, UserDetailView | |
| urlpatterns = [ | |
| path('api/users/', UserListView.as_view(), name='user-list'), | |
| path('api/users/<int:pk>/', UserDetailView.as_view(), name='user-detail'), | |
| ] |
Step 11: Configure Business Logic for User MS
user_project/users/views.py
| from rest_framework import generics | |
| from .models import User | |
| from .serializers import UserSerializer | |
| class UserListView(generics.ListCreateAPIView): | |
| queryset = User.objects.all() | |
| serializer_class = UserSerializer | |
| class UserDetailView(generics.RetrieveUpdateDestroyAPIView): | |
| queryset = User.objects.all() | |
| serializer_class = UserSerializer |
Step 12: Configure Django Settings For Product MS
product_project/settings.py
| INSTALLED_APPS = [ | |
| # ... | |
| 'rest_framework', | |
| 'products', | |
| ] | |
| # Add CORS settings if necessary | |
| CORS_ORIGIN_ALLOW_ALL = True |
Step 13: Configure URLs for Product MS
product_project/urls.py
| from django.urls import path | |
| from products.views import ProductListView, ProductDetailView | |
| urlpatterns = [ | |
| path('api/products/', ProductListView.as_view(), name='product-list'), | |
| path('api/products/<int:pk>/', ProductDetailView.as_view(), name='product-detail'), | |
| ] |
Step 14: Configure Business Logic for User MS
product_project/products/views.py
| from rest_framework import generics | |
| from .models import Product | |
| from .serializers import ProductSerializer | |
| class ProductListView(generics.ListCreateAPIView): | |
| queryset = Product.objects.all() | |
| serializer_class = ProductSerializer | |
| class ProductDetailView(generics.RetrieveUpdateDestroyAPIView): | |
| queryset = Product.objects.all() | |
| serializer_class = ProductSerializer |
Step 15 Configure Models.py file for User MS
user_project/users/models.py
| # users/models.py | |
| from django.db import models | |
| class User(models.Model): | |
| # User model fields | |
| name = models.CharField(max_length=100) | |
| email = models.EmailField(unique=True) | |
| # ... | |
| # users/serializers.py | |
| from rest_framework import serializers | |
| from .models import User | |
| class UserSerializer(serializers.ModelSerializer): | |
| class Meta: | |
| model = User | |
| fields = '__all__' |
Step 16 Configure Models.py file for Product MS
product_project/products/models.py
| # products/models.py | |
| from django.db import models | |
| class Product(models.Model): | |
| # Product model fields | |
| name = models.CharField(max_length=100) | |
| price = models.DecimalField(max_digits=10, decimal_places=2) | |
| # ... | |
| # products/serializers.py | |
| from rest_framework import serializers | |
| from .models import Product | |
| class ProductSerializer(serializers.ModelSerializer): | |
| class Meta: | |
| model = Product | |
| fields = '__all__' |
Running and Scaling Microservices
Step 1: Run Microservices Locally
- Start the User Microservice:
Parallelly start the Product microservice in different terminal:
| cd product_project | |
| python manage.py runserver 8002 |
Parallelly start the gateway microservice in different terminal:
| cd gateway_project | |
| python manage.py runserver |
Now, the gateway project should be accessible at http://localhost:8000/. It will route requests to the user microservice (http://localhost:8001/api/users/) and the product microservice (http://localhost:8002/api/products/). Adjust the URLs and ports as needed based on your setup.
Step 2: Scaling Microservices
To scale microservices, consider the following steps:
- Deploy microservices on separate servers or containers.
- Utilize container orchestration tools like Docker Compose or Kubernetes for managing multiple instances.
- Implement load balancing to distribute incoming traffic across multiple instances of a microservice.
Conclusion
In this comprehensive guide, we explored the foundations of microservices architecture and demonstrated how to implement a microservices system using Python Django as the gateway and Django Rest Framework for communication. The modular and independent nature of microservices provides flexibility, scalability, and resilience, making them an ideal choice for modern web applications.
As you delve deeper into microservices, you may encounter challenges such as service discovery, load balancing, and event-driven communication. Additionally, consider exploring advanced topics like API versioning, authentication, and authorization within a microservices context.
Microservices offer a powerful solution for building robust and scalable applications in today’s dynamic development landscape. By following the steps outlined in this blog, you’ll gain a solid understanding of microservices and be well-equipped to embark on your microservices journey.
Feel free to customize and expand upon this content based on your specific preferences and the depth you want to go into each section. Additionally, include code snippets, diagrams, and real-world examples to make the content more engaging and informative.
References
https://www.djangoproject.com/
https://www.javatpoint.com/microservices
https://www.w3schools.com/python/python_intro.asp
https://www.geeksforgeeks.org/python-programming-language/
