If you never wrote a micro service before but you know what is a micro service is, this post will introduce you by writing a μ-service. As it is a new “Buzz” floating around for last couple of years. Read details.
Micro service architecture has definitely many advantages over monolithic application, on the other hand it depends on several factors whether it make sense to go with micro service architecture or not. If you want to read more details about Micro service pattern and its pros and cons, please check this post for details. Specially micro service “Pros”, “Cons” section.
Let’s not get into the debate and start writing some code. In this post we will be doing the following:
- Building a REST API using Django (DRF)
- Docerize the newly developed REST API and run it via uwsgi
Step 1: Building the REST API using Django:
We will be using Django REST Framework (DRF). The API will be exposing data for Event Management company (imaginary) where the company uses the API to manage their events and performer. For sake of simplicity in our API we will be able to able Add new performers and events. And there will be listing endpoint where we will be listing recent events and associated performers name.
So lets write some code:
Django REST framework made easier to develop REST API on top of Django, all one need to do define serializers and the load query objects via Django models and thats it. DRF will take care rest of the staff. As the API is minimum and we are doing CRUD, in the serializers we need to extend serializers. Model and thats is. Finally Views.py looks like below:
class EventViewSet(viewsets.ModelViewSet): queryset = Event.objects.all() serializer_class = EventSerializer class PersonViewSet(viewsets.ModelViewSet): queryset = Person.objects.all() serializer_class = PersonSerializer
/event/ /event/:eventId /person/ /person/:personId
You can checkout the codebase from here.
Step 2: Dockerized μ-service:
Lets checkout the Dockerfile for details:
|ENV PYTHONUNBUFFERED 1|
|RUN git clone https://github.com/mushfiq/djmsc.git djmsc|
|RUN pip install -r requirements.txt|
|RUN python manage.py migrate|
|RUN python manage.py loaddata data/dummped.json|
|CMD ["uwsgi", "–module=djmsc.wsgi:application", "–env=DJANGO_SETTINGS_MODULE=djmsc.settings", "–master", "–pidfile=/tmp/djmsc.pid", "–http=0.0.0.0:8000", "–socket=0.0.0.0:8001", "–buffer-size=32768"]|
In the Dockerfile from Line 1-11 we are cloning the repo, updating the working directory, installing dependencies . From line 13-19 we creating db through manage.py, loading dummy data and running uwsgi to serve the API.
Let’s run the docker file like below:
docker-machine start default #starting docker virtual machine named default docker build -t mush/djmsc . #building docker image from the Docker file docker run -d -p 8000:8000 mush/djmsc #running the newly build docker image
List the IP of the docker machine and then make a cURL request to check whether the REST API is up or not
api=$(docker-machine ip default) #returns in which IP docker-machine is running curl $api:8000/person/?format=json | json_pp
And it returns json response like below:
You can pull the docker image from here and start your own container 🙂
Good read: Building Microservices