Automating Django deployments – DZone

Implementing Continuous Integration/Continuous Deployment (CI/CD) for a Python application using Django involves several steps to automate the testing and deployment process. This guide will walk you through setting up a basic CI/CD pipeline using GitHub Actions, a popular CI/CD tool that integrates seamlessly with GitHub repositories.

Step 1: Setting up your Django project

Make sure your Django project is in a Git repository hosted on GitHub. This repository will be the basis for setting up your CI/CD pipeline.

Step 2: Creating the virtual environment and dependency file

1. Virtual environment

It is good practice to use a virtual environment for your Django project to manage dependencies.

python3 -m venv venv

source venv/bin/activate  # On Windows use `venv\Scripts\activate`

2. Dependency file

To create `requirements.txt` file in the root of your project that lists all of your project’s dependencies, including Django itself.

pip freeze > requirements.txt

Step 3: Configure GitHub actions for continuous integration

1. Create a workflow file

In your repository, create a directory and file for your GitHub Actions workflow: `.github/workflows/django-ci.yml`.

2. Define the workflow

Populate `django-ci.yml` with the necessary steps to install dependencies, run tests, and any other checks you want as part of your CI process. Here’s a simple example:

Here’s a breakdown of each section in the `django-ci.yml` file:

name: Django CI



on: [push, pull_request]

• name: This is a descriptive name for your workflow. It will appear in the GitHub Actions section of your repository.
• on: This key specifies the events that will trigger the workflow. In this case, the workflow continues `push` events in any branch and beyond `pull_request` events.

jobs:

  build:

    runs-on: ubuntu-latest

• jobs: Jobs are a set of steps that are executed on the same launcher. Here, we have a job called `build`.
• build: This is the identifier for the job. You can name it anything, but `build` describes its purpose.
• runs-on: Specifies the type of machine on which the job will be run. `ubuntu-latest` means that the job will run on the latest version of Ubuntu Linux.

steps:

- uses: actions/checkout@v2

- name: Set up Python 3.x

  uses: actions/setup-python@v2

  with:

    python-version: 3.x

• steps: Steps are individual tasks that trigger commands in a job. Each step can trigger a script or action.
• uses: actions/checkout@v2: This step uses `checkout` action to check your repository under `$GITHUB_WORKSPACE`so your workflow can access it.
• uses: actions/setup-python@v2: This action sets up the Python environment for the job, specifying that we want to use Python 3.x.

- name: Install Dependencies

  run: |

    python -m pip install --upgrade pip

    pip install -r requirements.txt

• name: Gives a descriptive name for the step.
• run: Executes command line programs. Here it is used to upgrade `pip` and install the dependencies listed in the `requirements.txt`.

- name: Run Django Tests

  run: |

    python manage.py test

Run Django Tests: This step starts the Django test suite by executing `manage.py test`. This is where the unit tests of your Django application are executed, ensuring that your codebase is working as expected.

Step 4: Configure continuous deployment

Continuous Deployment can be configured to automatically deploy your Django application to a hosting service such as Heroku, AWS, or any other service provider of your choice. For this example we will use Heroku.

Preparing your Django project for Heroku deployment

Before integrating the deployment process into your CI/CD pipeline, make sure your Django project is ready for Heroku deployment. This preparation includes:

1. Profile

To create `Procfile` in the root directory of your Django project. This file tells Heroku how to run your application. For a typical Django application, `Procfile` it may look like this:

web: gunicorn myproject.wsgi --log-file -

To replace `myproject` with the name of your Django project.

2. Runtime specification

If your application requires a specific version of Python, please specify this version ua `runtime.txt` file in the root directory of your project, like this:

Note: Any version of Python python-3.x

3. Database configuration

Check yours `settings.py` is configured to use Heroku’s database when deployed. Heroku sets an environment variable called `DATABASE_URL` for the database, which you can use with `dj-database-url`:

import dj_database_url

DATABASES['default'] = dj_database_url.config(conn_max_age=600, ssl_require=True)

Extending the GitHub Actions deployment workflow

Once you’ve prepared your Django project for Heroku deployment, expand yours `.github/workflows/django-ci.yml` file to include the deployment steps. Here’s how you can do it:

- name: Install Heroku CLI

  run: |

    curl https://cli-assets.heroku.com/install.sh | sh



- name: Deploy to Heroku

  if: github.ref == 'refs/heads/main'

  run: |

    heroku git:remote -a $ secrets.HEROKU_APP_NAME 

    git push heroku HEAD:master -f

  env:

    HEROKU_API_KEY: $ secrets.HEROKU_API_KEY 

Failure

1. Install the Heroku CLI

This step installs the Heroku CLI on the runner, allowing you to interact with Heroku from the command line.

2. Deploy to Heroku

• Conditional execution: The `if: github.ref == 'refs/heads/main'` condition ensures that deployment occurs only when changes are pushed to the `main` branch office.
• Heroku Remote Setup:`heroku git:remote -a $ secrets.HEROKU_APP_NAME ` sets up the Heroku app as a remote for git. To replace `HEROKU_APP_NAME` with the name of your Heroku app.
• Implementation: `git push heroku HEAD:master -f` pushes the code to Heroku, triggering the deployment. The `-f` flag forces a push, which might be necessary if you’re overwriting history.

Managing secrets for Heroku deployments

For the deployment steps to work, you need to configure`HEROKU_API_KEY` and `HEROKU_APP_NAME` as secrets in your GitHub repository:

1. Go to your GitHub repository, click “Settings” > “Secrets”.
2. Click on “New Secret Repository.”
3. To add `HEROKU_API_KEY` as the name and your Heroku API key as the value. Repeat the process for `HEROKU_APP_NAME`adding the name of your Heroku application as a value.

Step 5: Manage secrets

GitHub secrets

Go to your GitHub repository settings, find the “Secrets” section and add your Heroku API key (`HEROKU_API_KEY`) and application name (`HEROKU_APP_NAME`) as secrets.

Conclusion

This tutorial describes the basic steps for setting up a CI/CD pipeline for a Django application using GitHub Actions, from automated testing to deployment on Heroku. The CI process ensures that your code is automatically tested, while the CD process enables a seamless deployment to your hosting platform, ensuring that your application is always up to date with the latest changes in your code base.

Cheers, happy coding!!