Over a million developers have joined DZone.

How to Build Microservices in Python

DZone's Guide to

How to Build Microservices in Python

In this article, learn how to deploy microservices that are created using either Python and Django on both Nginx and uWSGI.

· Integration Zone ·
Free Resource

WSO2 is the only open source vendor to be named a leader in The Forrester Wave™: API Management Solutions, Q4 2018 Report. Download the report now or try out our product for free.

Microservices design helps alleviate some problems associated with the monolithic model. Implementing microservices is perhaps one of the greatest ways to improve the productivity of a software engineering team. This is especially true if the following takes place: 

  • You deploy only the component that was changed (as opposed to the whole application). This keeps the deployments and the tests manageable.
  • If multiple team members are working on the application, they need to wait until everyone is done with development and testing and ready to move forward. However, with the microservices services model, whenever each piece of functionality is ready, it could be deployed.
  • Each microservice runs in its own process space, so if we want to scale for any reason, we can scale the particular microservice that needs more resources instead of scaling the entire application.
  • When one microservice needs to communicate with another micro-service, it uses a lightweight protocol such as HTTP.

This post examines how to deploy microservices created using Python and Django on Nginx and uWSGI.

Before going into the details of a microservices design, let's understand and examine how a typical monolithic application looks.

Monolithic Design


However, with breaking the functionality into logically isolated micro-services, this is how the design would like.

Microservices Design


Now, let's examine how the configuration would look for a Python and Django application that runs on Nginx on a typical Linux server.

Because the application code is spread across multiple repos (or subrepos) grouped by logically independent code, this will be the typical organization of the application directories on the server.

[ec2-user@ip-172-31-34-107 www]$ pwd
[ec2-user@ip-172-31-34-107 www]$ ls -lrt
total 8
drwxr-xr-x. 5 root root 4096 Oct 12 14:09 microservice1
drwxr-xr-x. 7 root root 4096 Oct 12 19:00 microservice2
drwxr-xr-x. 5 root root 4096 Oct 12 14:09 microservice3
drwxr-xr-x. 7 root root 4096 Oct 12 19:00 microservice4

Nginx, which is typically deployed a front-end gateway or a reverse proxy, will have this configuration:

[ec2-user@ip-172-31-34-107 serviceA]$ cat /etc/nginx/conf.d/service.conf 
upstream django1 {
    server unix:///opt/www/service1/uwsgi.sock; # for a file socket

upstream django2 {
    server unix:///opt/www/service2/uwsgi.sock; # for a file socket

upstream django3 {
    server unix:///opt/www/service3/uwsgi.sock; # for a file socket

upstream django4 {
    server unix:///opt/www/service4/uwsgi.sock; # for a file socket

server {
    # the port your site will be served on
    listen      80;
    # the domain name it will serve for
    server_name localhost;
    charset     utf-8;

    # max upload size
    client_max_body_size 75M;   # adjust to taste

    location /api/service1/ {
    uwsgi_pass  django1; 
    include     /etc/nginx/uwsgi_params; 

   location /api/service2/ {
            uwsgi_pass  django2;
            include     /etc/nginx/uwsgi_params; 

    location /api/service3/ {
    uwsgi_pass  django3; 
    include     /etc/nginx/uwsgi_params; 

   location /api/service4/ {
            uwsgi_pass  django4;
            include     /etc/nginx/uwsgi_params; 

Multiple uWSGI processes have to be created that would process the request for each microservice:

/usr/bin/uwsgi --socket=/opt/www/service1/uwsgi.sock --module=microservice-test.wsgi --master=true --chdir=/opt/www/service1

/usr/bin/uwsgi --socket=/opt/www/service2/uwsgi.sock --module=microservice-test.wsgi --master=true --chdir=/opt/www/service2

/usr/bin/uwsgi --socket=/opt/www/service3/uwsgi.sock --module=microservice-test.wsgi --master=true --chdir=/opt/www/service3

/usr/bin/uwsgi --socket=/opt/www/service4/uwsgi.sock --module=microservice-test.wsgi --master=true --chdir=/opt/www/service4

Read the WSO2 Methodology for Agility to see how you can transform your integration projects from semi-agile to a scalable continuous agile approach.

python ,integration ,microservices

Published at DZone with permission of

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}