Ready to Start Learning?

Django Deployment Pipeline

This series is all about sustainably deploying Django into production on virtual machines we control. Production can get rather messy so we're going to limit the amount of manual work and opt for as much automation work as possible. To do this, we're going to be focusing on these core areas:

CI / CD with Git, GitHub, and GitHub Actions
Django on Docker & DockerHub (as well as using WatchTower)
Load Balancing with NGINX
Production Databases with managed MySQL by Linode
Local/Development use of production-like Databases
Terraform to provision Infrastructure on Linode
Ansible to configure infrastructure on Linode (in tandem with Terraform)
Django-based File Uploads & Django Static Files on Linode Object Storage

This course focuses on getting Django into production, but most of what we cover can be adapted for many other technologies as well. The reason? Our Django project will run through Docker with Docker containers. Docker is a massive key to putting many, many different applications in production. It's a great tool, and we'll use it as the backbone that Django sits on.

Before all the branded names for the tech stack start to scare you off, I want you to remember that so much of what we'll do here is writing a bunch of documents with a specific syntax and goal. Just because it's called Docker or Python or Terraform, they are still all just documents that describe... something.

With that in mind, I want you to think of the above list like this:

GitHub: a place to store our code, almost like a folder on your computer.
GitHub Actions: an app that automatically starts a chain of events related to testing (verifying the document does what the writer intended), building (let's put a stamp on this code and say that this version is done), and running our code in production (find the code that should run the best, is ready, and let's and run that)
Django: A bunch of python documents to handle the logic of an HTML website, store data, and handle user data.
Docker: essentially a document that we write to describe, on the operating system level, how our Django app needs to run. Docker itself does more than this, but we mostly work on the document part (a Dockerfile).
Load Balancing with NGINX: a document that we write to tell nginx to send incoming website traffic to the different servers running our Docker-based Django app. Managed databases: a powerful spreadsheet that you never need to open or touch (thanks to Linode & Django).
Terraform: a document describing all of the products and services we need from Linode (like virtual machines) to run our Django project.
Ansible: a few documents we use to tell all of the products and services what software our Django project needs is needed to run.
Linode Object Storage: a file system (sort of) that allows us to store files that don't change very often like images and videos as well as other documents like CSS and some kinds of JavaScript.

If you read the above and thought to yourself, "well that's overly simplistic" -- you're right! If you read the above and thought to yourself, "oh no, what am I doing with my life" -- you're right!

The nice thing about what we're doing here is taking the guesswork out of making this list work, work correctly, and work reliably. Most of the technology we will cover here has been well established and will likely remain unchanged for the foreseeable future.

References

Lifetime access to this course

or get access to 500+ courses with a membership

Lessons

Welcome