3 Best Django Hosting Providers 2020 – Django App Deploying on Live Server

3 Best Django Web Hosting

Django Hosting Compare based on reviews and user experiences. With us you compare various companies and choose the Best Django Web Hosting that suits you. Use our expertise and read the user experiences to choose the best Django Hosting.

siteground SiteGround

Storage: Start From 10 GB SSD

Experiences: Best

Price: $3.95/mo. (70% OFF NowRegular $11.95/mo.

 

SiteGround has extensive expertise around Python Django Hosting WordPress and Joomla, choose your website from 4 Server locations incl. USA. For extra speed you use: SuperCacher, SSD and NGINX as standard.

Score: 9.6

Visit website

 

Storage: Unlimited SSD

Experiences: Best / Control panel Cpanel

Price: $3.92/mo. (51% OFF NowRegular $7.99/mo.

Server Location: United States, United Kingdom, Canada, France, Australia

A2 Hosting is one of the most reliable Django Hosting  web hosting providers in the market.For more than a decade, this hosting company has delivered:High,speed performance,High quality development tools Reliable uptime, The best customer satisfaction. The most important feature that companies demand today is the loading time of the site. The A2 Hosting SwiftServer platform has been developed in the last 10 years by the company’s IT gurus.

Score: 9.7

 

Storage: Start From 25 GB SSD

Experiences: Best VPS

Price: $5/mo. (Get 100$ free Now/1 Month

DigitalOcean  is undoubtedly one of the best VPS hosting providers in the world . Founded in 2011, DigitalOcean  has as its principle, to bring customer satisfaction to 100% . So much so that one of its best qualities is the excellent customer service. They offer Django web hosting services, cloud hosting, managed Database and VPS.

Score: 9.9 but unmanaged (aka Developer Friendly)

Visit website

Cheap = Expensive

Personally, I also believe that with web hosting you often get what you pay for. This certainly also applies in the very competitive market of Django web hosting. Just reading what is indicated on the various websites does not help you with this enough. Ask acquaintances for experiences and consult reviews and comparison websites online. What is good one year ago can suddenly be known as slow. Therefore, visit this website every time before choosing a new Django host. Of course there are other aspects that you should take into account, in particular the price is not specifically mentioned here. However, the price is an aspect that everyone automatically watches and that can often be found. We hope that the articles and reviews on this comparison site will provide a little more insight into the differences in the market.

django

Django App Deploying

After we’ve created a Django app, and we’ve finished our testing, we’ll start thinking about deploying our app to production. There are couple of directions we can take with this, and it will depend on the level of skills and effort we can invest, the cost we’re able to outlay, the flexibility we need in putting together our server software stack, and other variables.

Different Options

If we don’t want to spend a lot, or we aren’t ready to put together or maintain the software stack, we can choose to deploy to managed, shared hosting. These days, there are many shared hosts that allow for Python and Django applications-even providing one-click installations and allowing for SSH access.

Shared Hosting

This may be the quickest and most worry-free solution for many needs, but it doesn’t stand out in terms of flexibility. Usually, the server, Python and Django versions, caching solutions and database are predetermined, and we can’t change them, meaning that we don’t have direct control over our hardware resources. However, for certain applications this will be a budget-effective solution, which may be the primary objective.

A2 Hosting, SiteGround, and Bluehost are examples of this sort of web host.

VPS and Linux Hosting

In recent times, there’s been a proliferation of polished, user-friendly, VPS-based hosts like DigitalOcean and Cloudways, who are trying to bridge the skills gap that deploying onto raw Linux servers presents, making it easier and easier to deploy to VPS systems without being an expert.

In addition to vendors like Cloudways (which is actually specialized in bootstrapping PHP applications), VPS and cloud vendors provide quick-install interfaces for all sorts of stacks-lower or higher level-that offer developers different levels of flexibility.

The entry barrier is a lot lower than it was in Django’s early years, but managing apps on VPS or dedicated Linux physical servers requires some Linux command-line skills regardless of the one-click solutions that hosting vendors provide. This range of products is commonly referred to asInfrastructure as a Service(IaaS).

Platform as a Service

For those developers who know what they’re doing, and yet don’t wish to have to deal with the entire software stack underlying their Django application, there’s PaaS.

cloud

The illustration above shows the difference between three prevalent cloud models, differentiated by how much control is left to the customer and how much of the infrastructure is handled by the vendor. WithPlatform as a Service(PaaS), every single bit of software infrastructure-on top of the hardware-is handled by the vendor. This usually includes the framework itself-in our case, Django, WSGI (or, as we will discuss, ASGI), server software, database server, middleware, and so on.

Vendors like Google App Engine, Heroku, and platforms such asPythonanywhereandPlatform.shusually provide customers with the tooling, conventions and workflow needed to deploy Python web apps to their infrastructure. The customer provides the application logic and the vendor provides the platform.Other cloud vendors such as Microsoft Azure and Amazon also provide this model. Each vendor differs in the level of management, tooling and so on they provide to developers, so do your homework before choosing one.

Server Interfaces

Web applications essentially respond to different (web) route requests by clients, by outputting some kind of code. Usually it’s a combination of static files, HTML markup, CSS, JSON data and other formats. What makes web apps different from mere web pages is their dynamic output.

 

These applications aren’t equipped or optimized to serve web pages in production, to handle the HTTP protocol, to serve static files, to cache content in an optimized way that web servers like NGINX or Apache are.

 

That’s why we have web server interfaces. If we deal with Python web app deployments in any significant way, we need to know about WSGI, and the newer web server interface ASGI.

Web Server Gateway Interface

PEP (or Python Enhanced Proposal) 3333from 2010 defines the Python Web Server Gateway Interface, an interface specification for communication between python web apps and servers. WSGI applications, compliant to the specification, are stackable, and pass on the requests and responses between the application and the server.

From Python release 2.5, in 2006, Python implements its own WSGI server.

 

The stackable nature of WSGI apps means that apps in the middle must implement both sides of the interface-server and application-and the top and bottom ones need to behave as server and application, respectively. This also means practically unlimited extendibility through middleware.

 

mod_python and mod_wsgi

With Django apps, for years the standard has been Apache server +mod_wsgi. mod_wsgi is an Apache server module first publicly released in 2007, when it replaced another module,mod_python, which worked by embedding a Python interpreter into the Apache server process.

 

Just as mod_python was a successor to CGI interface with Python in terms of efficiency, mod_wsgi succeeded mod_python.

 

uWSGI

Another implementation of the WSGI standard is uWSGI, an application server compliant with the WSGI standard, which has gained popularity in recent years. It’s capable of running as a standalone server, but it’s usually deployed behind NGINX as a reverse proxy. As thedocssay:

 

uWSGI supports several methods of integrating with web servers. It is also capable of serving HTTP requests by itself.

We wroteabout deployment flow of a Django app with uWSGI withMina, which is a capable and minimal deployment tool specialized for Rails apps, along with ascreencast.

 

Another tutorial by the author, describing deployment of a Flask web app on Alibaba Cloud, and which can be used to deploy web apps on any Linux server,can be found here.

 

uWSGI has extensive documentation that covers a wide range of scenarios, from standard cases likedeployment of standard Django apps behind NGINXanddeployment on Herokuto usingWebSockets, and includes discussions about the separation of resources usingLinux namespacesversus LXC containers. uWSGI is currently one of the more robust server options for the WSGI stack.

 

Other WSGI implementations to mention areGunicorn, a Python web server installable via pip, which also recommends deployment behind a web server like NGINX,werkzeug,CherryPy,gevent-fastcgiand numerous others.

 

If we deploy a WSGI application and server behind a server like NGINX, our virtual host file will simply proxy the requests to the dynamic part of our app to the WSGI server running on a certain port on localhost, by using the proxy_pass directive:

by using the proxy_pass directive:

server {
listen 80;
server_name website.xyz;
access_log /var/log/nginx/websitexyz.log;
location / {
proxy_pass http://127.0.0.1:8000;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}

When we use uWSGI as an application server, according tothe docs, we can also pass requests via Unix sockets, using theuwsgi_passdirective:

uwsgi_pass unix:///tmp/uwsgi.sock;
include uwsgi_params;

More information about the WSGI standard can be foundhere, and the documentation hasuser guides for a wide range of cases.

Asynchronous Web Server Interface

 

Asynchronous Web Server Interface, or ASGI, is described inits documentationas “a spiritual successor to WSGI”. It aims to be backward-compatible with WSGI, but to provide support or interface for asynchronous applications and web servers.

This interface is meant to provide for long-polling and WebSocket connections.The asynchronous ASGI server works as an event loop, so a simple application, to borrowfrom the docs, might look like this:

async def application(scope, receive, send):
event = await receive()

await send({“type”: “websocket.send”, …})

Aside from the async event loop, the ASGI specification also provides for WSGI applications, so that compatibility is maintained.

The project that the entire specification originates from isDjango Channels, which aims tobring asynchronous support to Django.

The implementations recommended by the Django docs includeDaphne, which is a reference implementation of the spec written on top ofTwisted, an event-based, lower-level server or engine, andUvicorn, an ASGI web server that supports WebSockets, includes Gunicorn worker class, and is wsgi-compatible.

According to some benchmarks, Uvicorn is faster even thanNode.js, but for a real benchmark, we would have to have very similar, almost identical applications to compare on top of Uvicorn and Node.

Deployment: Some Method to the Madness

Heroku, one of the main PaaS cloud vendors today, started in 2007 mainly as a platform for Ruby applications. By 2010, when it wasacquired by Salesforce, Heroku supported most modern server-side languages.

Its developers, led by Adam Wiggins, came up with a methodology framework for server applications deployment in 2011 that addresses many, if not most, deployment problems.

It’s now available as anonline and EPUB bookand can be read for free. Many developers have found these twelve considerations very useful, so we’ll mention them here and later discuss Django deployment in light of them.

The rules, paraphrased, are as follows:

There should exist a single codebase, tracked by a source-control system like Git, for many different deployments, such as development, staging, and production.

Dependencies should be explicit. Even implicit reliance on system tools like cURL should be avoided.

App configuration that differs from one deployment environment to the other needs to be separate from the deployed code (not stored as hard-coded constants).

Services such as databases, queueing systems, and email of caching systems, are treated as swappable resources that can be replaced, depending on the deployment environment, without code changes. All the data needed should be in the configuration.

There are three stages to deploying an app to production:build,release, andrun.

Thebuildstage prepares the codebase to be executed. It fetches the dependencies, compiles static assets, and so on.

Thereleasestage takes the build and combines it with the deployment configuration so that it can be executed in the target environment.

Therunstage launches the app into execution, so that app isliveandrunning.

According to this framework, there is-or should be-a clear separation between these three stages of deployment. Releases have their unique identifiable IDs. All changes to the codebase or configuration should mean that there’s a newrelease.

The app is executed as one or more processes that are stateless: data doesn’t rely on memory of the process or disk cache for any longer time. Processes share nothing and data is outsourced to outside services like a database.

Port binding means that the web server can be decoupled from the application, and the application is self-contained: it lives at a certain port receiving requests.

Concurrency and assigning different types of tasks to different processes is required. Also, the ability to scale our application horizontally via stateless processes.

Since these processes should not be daemonized or written to PID files, there will need to be a process manager such assupervisord or systemd, each having their own advantages.

Disposable processes means that processes can be shut down or started fast, and that graceful shutdowns guarantee that already started requests/tasks will finish while the app will stop creating new processes.

Parity between development and production greatly reduces complexity of deployments. Best practices mean reducing the time gap between development and production (small and frequent deployments), reducing the personnel gap (the same people developing the application are closely involved in deploying it in production) and reducing the tooling gap-by keeping the software stack similar between development and production environments. This keeps the complexities and possible issues resulting from different stacks between development and production at a minimum.

Logs should be treated as event streams, and consuming them should be left out of the application itself (sometimes sent to a specialized piece of software for more detailed and useful analysis).

Administrative tasks and management processes should be run in the deployment environment. Admin code should be part of deployed code.

These principles should be taken as guidelines, not hard rules, because they are there to make the lives of developers, DevOps engineers and administrators easier.

How does Django stack up against these demands, and how can we apply these when deploying our apps?

Regarding the first rule, which says that we should have a single, version-control-tracked codebase for multiple deployment environments, Django settings are, by default, in the settings.py file-meaning that we would need to change this file for deployment to each environment. We would be deploying different code to each environment, and our deployment flow wouldn’t be as smooth.

WSGI isthestandard with Python web apps, including Django. This means that when we start our project, the subfolder that contains our base app (the one with the name of our project, which we here named xyz_app ) will have a wsgi.py file:

 

 

The project that the entire specification originates from is Django Channels, which aims tobring asynchronous support to Django.

 

The implementations recommended by the Django docs includeDaphne, which is a reference implementation of the spec written on top ofTwisted, an event-based, lower-level server or engine, andUvicorn, an ASGI web server that supports WebSockets, includes Gunicorn worker class, and is wsgi-compatible.

 

According to some benchmarks, Uvicorn is faster even thanNode.js, but for a real benchmark, we would have to have very similar, almost identical applications to compare on top of Uvicorn and Node.

 

Deployment: Some Method to the Madness

Heroku, one of the main PaaS cloud vendors today, started in 2007 mainly as a platform for Ruby applications. By 2010, when it was acquired by Salesforce, Heroku supported most modern server-side languages.

Its developers, led by Adam Wiggins, came up with a methodology framework for server applications deployment in 2011 that addresses many, if not most, deployment problems.

It’s now available as anonline and EPUB book and can be read for free. Many developers have found these twelve considerations very useful, so we’ll mention them here and later discuss Django deployment in light of them.

The rules, paraphrased, are as follows:

  • There should exist a single codebase, tracked by a source-control system like Git, for many different deployments, such as development, staging, and production.

  • Dependencies should be explicit. Even implicit reliance on system tools like cURL should be avoided.

  • App configuration that differs from one deployment environment to the other needs to be separate from the deployed code (not stored as hard-coded constants).

  • Services such as databases, queueing systems, and email of caching systems, are treated as swappable resources that can be replaced, depending on the deployment environment, without code changes. All the data needed should be in the configuration.

  • There are three stages to deploying an app to production:build,release, andrun.

    The build stage prepares the codebase to be executed. It fetches the dependencies, compiles static assets, and so on.

    The release stage takes the build and combines it with the deployment configuration so that it can be executed in the target environment.

    Therunstage launches the app into execution, so that app isliveandrunning.

    According to this framework, there is-or should be-a clear separation between these three stages of deployment. Releases have their unique identifiable IDs. All changes to the codebase or configuration should mean that there’s a newrelease.

  • The app is executed as one or more processes that are stateless: data doesn’t rely on memory of the process or disk cache for any longer time. Processes share nothing and data is outsourced to outside services like a database.

  • Port binding means that the web server can be decoupled from the application, and the application is self-contained: it lives at a certain port receiving requests.

  • Concurrency and assigning different types of tasks to different processes is required. Also, the ability to scale our application horizontally via stateless processes.

    Since these processes should not be daemonized or written to PID files, there will need to be a process manager such assupervisord or systemd, each having their own advantages.

  • Disposable processes means that processes can be shut down or started fast, and that graceful shutdowns guarantee that already started requests/tasks will finish while the app will stop creating new processes.

  • Parity between development and production greatly reduces complexity of deployments. Best practices mean reducing the time gap between development and production (small and frequent deployments), reducing the personnel gap (the same people developing the application are closely involved in deploying it in production) and reducing the tooling gap-by keeping the software stack similar between development and production environments. This keeps the complexities and possible issues resulting from different stacks between development and production at a minimum.

  • Logs should be treated as event streams, and consuming them should be left out of the application itself (sometimes sent to a specialized piece of software for more detailed and useful analysis).

  • Administrative tasks and management processes should be run in the deployment environment. Admin code should be part of deployed code.

These principles should be taken as guidelines, not hard rules, because they are there to make the lives of developers, DevOps engineers and administrators easier.

How does Django stack up against these demands, and how can we apply these when deploying our apps?

Regarding the first rule, which says that we should have a single, version-control-tracked codebase for multiple deployment environments, Django settings are, by default, in the settings.py file-meaning that we would need to change this file for deployment to each environment. We would be deploying different code to each environment, and our deployment flow wouldn’t be as smooth.

WSGI isthestandard with Python web apps, including Django. This means that when we start our project, the subfolder that contains our base app (the one with the name of our project, which we here named xyz_app ) will have a wsgi.py file:

"""WSGI config for xyz_app project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/2.2/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'xyz_app.settings')

One environment variable here comes to our rescue: DJANGO_SETTINGS_MODULE . We could change the filename and path to our settings.py file here and make it custom.