Deploying a Django Rest Framework (DRF) application to Kubernetes

This tutorial is going to provide you with a comprehensive guide on deploying a Django Rest Framework (DRF) application to Kubernetes. In this tutorial, you'll be taken through a step-by-step tutorial covering the entire process, starting from setting up the development environment, building the DRF application, containerizing it, and finally deploying it to Kubernetes.

By the end of this tutorial, you'll have a clear understanding of how to take your Django Rest Framework application from development to production, leveraging Kubernetes to manage and scale the application efficiently.

Let's get started and dive into the world of deploying DRF applications on Kubernetes!

Overview of the DRF

Django Rest Framework (DRF) is a robust and widely-used web framework, built on Django, the renowned Python web development framework. DRF specializes in streamlining the development of RESTful APIs (Application Programming Interfaces) for web applications. By leveraging DRF, developers can efficiently handle data serialization, authentication, and various other features essential for modern web development. With its user-friendly design and extensive toolkit, DRF empowers developers to create high-performance APIs with ease and flexibility.

Prerequisites

Before getting started, there are some prerequisites you’ll need to have in place:

• Python 3.7+ installed on your local machine: You can check the Python version by running the command `python --version` in your terminal.
• Docker installed: Docker is used to containerize the application and can be installed by following the official documentation.
• Civo account: We will be using Civo in this tutorial as it provides a managed Kubernetes cluster for deploying our application.
• Launched cluster on Civo: Download the credentials to access the cluster.
• Basic understanding of Python: Familiarity with the Python programming language is required to understand and follow along with the tutorial.

Setting up the development environment

Follow these steps to set up the development environment:

Step 1: Open a terminal or command prompt.

Step 2: Verify if you have virtualenv installed by running the following command:

1pip install virtualenv

Step 3: Create and activate a virtual environment:

1virtualenv venv

On macOS/Linux:

1source venv/bin/activate

On Windows:

1venv\Scripts\activate

Step 4: Create a project directory for the Django Rest Framework application:

1mkdir drf_kubernetes
2cd drf_kubernetes

Step 5: Install the required packages.

Create a requirements.txt file and add the following contents:

1djangorestframework==3.13.1
2Django==4.1.2

Run the command below to install the packages:

1pip install -r requirements.txt

Step 6: Create a Django Project.

With the virtual environment activated, create the Django project. In this case, we'll name the project drf_kubernetes:

1django-admin startproject drf_kubernetes  .

Note: Take note of the . after the django-admin startproject drf_kubernetes command.

Building the DRF application

With the development environment set up and the project created, let's proceed to build the DRF application. We will create a REST API for a sample Movie database model, which will involve implementing all CRUD operations.

Step 1: Create the Movie App

Run the following command to create a Django app named Movie:

1django-admin startapp Movie

Step 2: Edit the settings.py file:

Add restframework and the created app Movie to the INSTALLEDAPPS in the settings.py file:

1INSTALLED_APPS = [
2    # Other installed apps
3    'rest_framework',  # Add this line
4    'Movie.apps.MovieConfig',  # Add this line
5]

Step 3: Update the urls.py in the drf_kubernetes directory to include the Movie app URLs:

1from django.contrib import admin
2from django.urls import path, include
3
4urlpatterns = [
5    path('admin/', admin.site.urls),
6    path('', include('Movie.urls')), 
7]

Step 4: Add the following code to the models.py file inside the Movie app directory:

1from django.db import models
2
3class Movie(models.Model):
4    class Genre(models.TextChoices):
5        ACTION = 'action'
6        FANTASY = 'fantasy'
7        ADVENTURE = 'adventure'
8        ROMANCE = 'romance'
9        SCI_FI = 'sci-fi'
10        Anime = 'anime'
11
12    title = models.CharField(max_length=100)
13    producer = models.CharField(max_length=50)
14    genre = models.CharField(max_length=20, choices=Genre.choices)
15    release_date = models.DateField()
16
17    def __str__(self):
18        return self.title

The Movie class represents the database model for a movie in our API. It includes columns for the movie's title, producer, genre, and release date.

Step 5: Create a serializers.py file inside the Movie app directory with the following code:

1from rest_framework import serializers
2from .models import Movie
3
4class MovieSerializer(serializers.ModelSerializer):
5    id = serializers.IntegerField(read_only=True)
6
7    class Meta:
8        model = Movie
9        fields = [
10            'id',
11            'title',
12            'producer',
13            'genre',
14            'release_date',
15        ]
16

The MovieSerializer defines a serializer that allows us to convert the Movie model data into Python data types for API requests and responses.

Step 6: Update the views.py file in the Movie app with the following code:

1from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView
2from .models import Movie
3from .serializers import MovieSerializer
4
5class MovieListCreate(ListCreateAPIView):
6    queryset = Movie.objects.all()
7    serializer_class = MovieSerializer
8
9class MovieRetrieveUpdateDestroy(RetrieveUpdateDestroyAPIView):
10    queryset = Movie.objects.all()
11    serializer_class = MovieSerializer

The MovieListCreate class defines the views for creating and getting all movies, while the MovieRetrieveUpdateDestroy class handles retrieving, updating, and deleting movies.

Step 7: Create a urls.py file inside the Movie app with the following code:

1from django.urls import path
2from . import views
3
4urlpatterns = [
5    path('movies/', views.MovieListCreate.as_view(), name='movie-list-create'),
6    path('movies//', views.MovieRetrieveUpdateDestroy.as_view(), name='movie-retrieve-update-destroy'),
7]

Step 8: Run migrations:

To create the necessary database tables, run the following commands in your terminal:

1python manage.py makemigrations
2python manage.py migrate

Step 9: Start the development server to test the Django Rest Framework application:

1python manage.py runserver

Now the Django Rest Framework application is up and running! You can access the API endpoints for the `Movie` model at the following URLs:

• List and Create: http://localhost:8000/movies/
• Retrieve, Update, and Destroy: http://localhost:8000/movies//

Containerization of Django Rest Framework (DRF) with Docker

Before proceeding with containerizing the Django Rest Framework application, some changes need to be made.

Step 1: Update SECRET_KEY and DEBUG handling:

In the settings.py file, modify the SECRET_KEY and DEBUG settings to use environment variables. This helps keep sensitive information separate from the codebase and enhances security. Use the following code:

1import os
2
3SECRET_KEY = os.getenv('SECRET_KEY')
4DEBUG = bool(os.getenv('DEBUG', 'True'))

Step 2: Update the database settings in the settings.py file to use PostgreSQL:

Replace the existing DATABASES section with the following:

1DATABASES = {
2    'default': {
3        'ENGINE': 'django.db.backends.postgresql',
4        'USER': os.getenv('POSTGRES_USER'),
5        'NAME': os.getenv('POSTGRES_NAME'),
6        'PASSWORD': os.getenv('POSTGRES_PASSWORD'),
7        'HOST': os.getenv('POSTGRES_HOST'),
8        'PORT': os.getenv('POSTGRES_PORT'),
9    }
10}

Step 3: Update allowed hosts:

In the settings.py file, update the ALLOWED_HOSTS setting to allow all hosts:

1ALLOWED_HOSTS = ['*']

Step 4: Enable static files:

Static files need to be served correctly in our containerized environment. In the settings.py file, add the following code to set the STATIC_ROOT:

1STATIC_ROOT= ‘/static/’

Additionally, update the urls.py file in the drf_kubernetes directory to correctly handle static file serving:

1from django.contrib import admin
2from django.urls import path, include
3from django.conf import settings
4from django.contrib.staticfiles.urls import static
5urlpatterns = [
6    path('admin/', admin.site.urls),
7    path('', include('Movie.urls'))
8] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT) # add this 

Step 5: Update the requirements.txt file with the following content:

1djangorestframework==3.13.1
2Django==4.1.2
3gunicorn==20.1.0
4psycopg2-binary==2.9.3

The psycopg2-binary package has been added to enable the PostgreSQL database connection.
The gunicorn package has been added as a production-ready WSGI server, which will serve the Django application efficiently.

Step 6: Create a file named script.sh in the project directory and add the following content:

1#!/bin/sh
2
3# Change to the app directory
4cd /app
5
6# Apply database migrations
7echo "Applying database migrations"
8python manage.py makemigrations
9python manage.py migrate --noinput
10
11# Collect static files
12echo "Collecting static files"
13python manage.py collectstatic --noinput
14
15# Start the server using gunicorn
16echo "Starting the server"
17gunicorn drf_kubernetes.wsgi:application --bind 0.0.0.0:8000

This script will be executed when the container starts and will take care of necessary setup tasks.

Docker configuration and deployment

Now, let's proceed with containerizing the application:

Step 1: Ensure that Docker is installed on your system. If you don't have it installed, refer to the Docker installation guide and install Docker.

Step 2: Create a Dockerfile in the project directory and include the following contents:

1FROM python:3.9-alpine
2WORKDIR /app
3COPY ./requirements.txt .
4RUN pip install -r requirements.txt
5COPY . .
6RUN chmod +x /app/script.sh
7CMD ["./script.sh"]

The Dockerfile starts with the base image of Python 3.9-alpine.
WORKDIR command: Sets the working directory inside the container as /app, which will be the root directory for the application.
COPY ./requirements.txt .: Copies the requirements.txt file from the local directory to the container's /app directory.
RUN pip install -r requirements.txt: Installs the Python dependencies specified in requirements.txt using pip.
The second COPY command: Copies the entire project directory (including the application code) into the container's /app directory.
RUN chmod +x /app/script.sh: Gives execution permissions to the script.sh script.
CMD ["./script.sh"]: Specifies the command to run when the container starts. In this case, it executes the script.sh script, which applies database migrations, collects static files, and starts the server using gunicorn.

Step 3: Build the Docker image by running the following command in the terminal: Replace your-username and your-repository-name with the appropriate values:

1docker build -t /:drf-app .

-t specifies the tag for the image.
It builds the Docker image with the name drf-app (you can change this name if desired).
. points to the current directory containing the Dockerfile.

Step 4: Once the image is built, push it to a Docker repository. Here are the steps to push the image to Docker Hub:

1. Sign up for a Docker Hub account.
2. Log in to the Docker repository using the following command and provide your credentials when prompted: docker login
3. Push the repository to the container registry using the following command: docker push /:drf-app
   Replace and with your Docker Hub username and the repository name where you want to push the image.

Step 5: Finally, before proceeding with deployment, you need to provision a PostgreSQL database on Civo:

1. Sign in to your Civo account.
2. Create a new PostgreSQL instance with the desired specifications, such as CPU and RAM.
3. Make a note of the connection details, including the hostname, port, database name, user, and password.

Deploying the DRF application on Civo

To successfully deploy your Django Rest Framework (DRF) application on a managed Kubernetes cluster using Civo, you can follow these steps:

Step 1: Begin by making sure you have completed the initial setup, including launching a cluster on Civo, downloading the cluster's kubeconfig credential, and installing the Kubernetes command-line tool, kubectl on your local machine.

Step 2: Configure your local kubectl with the cluster credentials you've downloaded by executing the following commands:

1export KUBECONFIG=/path/to/downloaded/kubeconfig/credential

Note: Replace /path/to/downloaded/kubeconfig/credential with the actual path to your downloaded kubeconfig cluster credential.

Step 3: In your project directory, create a .env file with the necessary environment variables:

1POSTGRES_HOST=
2POSTGRES_PORT=
3POSTGRES_NAME=
4POSTGRES_USER=
5POSTGRES_PASSWORD=
6SECRET_KEY=

Note: Replace the placeholders with actual details from your managed PostgreSQL database on Civo and your Django SECRET_KEY.

Step 4: Create a Kubernetes secret using the command below to securely manage the secrets:

1kubectl create secret generic --from-env-file .env drf-app-secret

Step 5: Create a drf.yaml file that outlines both the service and deployment manifests required for deploying the DRF application:

1apiVersion: v1
2kind: Service
3metadata:
4   name: drf-app
5spec:
6   type: LoadBalancer
7   ports:
8   - protocol: TCP
9     port: 80
10     targetPort: 8000
11   selector:
12      app: drf-app
13      type: api
14---
15apiVersion: apps/v1
16kind: Deployment
17metadata:
18  name: drf-app
19spec:
20  replicas: 2
21  selector:
22    matchLabels:
23      app: drf
24      type: api
25  template:
26    metadata:
27      labels:
28        app: drf-app
29        type: api
30    spec:
31      containers:
32      - name: drf-app
33        image: your-username/your-repository-name:drf-app
34        imagePullPolicy: Always
35        ports:
36        - containerPort: 8000
37        envFrom:
38          - secretRef:
39              name: drf-app-secret
40        env:
41        - name: DEBUG
42          value: "False"

The drf.yaml file contains Kubernetes manifest definitions that outline how your Django Rest Framework (DRF) application should be deployed and managed within a Kubernetes cluster. It consists of two main parts:

• Service Manifest: This section defines a Kubernetes Service, which acts to enable network communication to your application. Specifically, it configures a LoadBalancer type service that listens on port 80 and directs traffic to port 8000 on the application pods. The service is associated with pods that have the labelsapp: drf-appand type: api.
• Deployment Manifest: This section specifies a Kubernetes Deployment, which orchestrates the management of your application's pods. It sets up two replicas of your application to ensure high availability. The deployment is linked to pods labeled with app: drf and type: api.

Inside the deployment's template, the containers section defines the main application container named drf-app. It pulls the application image from a specified container registry (e.g., your-username/your-repository-name:drf-app). The container listens on port 8000 and is configured with environment variables obtained from the secret drf-app-secret`.

The env section also includes an environment variable named DEBUG set to "False", which indicates that the DRF application is not in debugging mode.

Step 6: Deploying with a Private Repository:

If your repository is private, you need to create an image pull secret to allow Kubernetes to access the private images. Use the following command to create the necessary image pull secret:

1kubectl create secret docker-registry registry-secret --docker-server=https://index.docker.io/v1/ --docker-username= --docker-password= --docker-email=

Replace your-name, your-password and your-email with your actual Docker username, email and password.

Next, modify the drf.yaml file to include the newly created image pull secret. Add the imagePullSecrets field under the deployment spec.template.spec section:

1   spec:
2     containers:
3     - name: drf-app
4       image: your-username/your-repository-name:drf-app
5       imagePullPolicy: Always
6       ports:
7       - containerPort: 8000
8       envFrom:
9         - secretRef:
10             name: drf-app-secret
11       env:
12       - name: DEBUG
13         value: "False"
14     imagePullSecrets:
15     - name: registry-secret

By adding the image pull secret, Kubernetes will be able to retrieve images from your private repository.

Step 7: Apply the defined resources to your cluster using the following command:

1kubectl apply -f drf.yaml

Step 8: Retrieve the external IP assigned to the DRF application service using:

1kubectl get service drf-app

With the external IP in hand, you can access the Django Rest Framework Application Movie APIs through your browser:

List and Create:

http://(external-ip-address)/movies

Retrieve, update, and destroy:

http://(external-ip-address)/movies

By following these steps, you'll have your DRF application up and running on Civo's managed Kubernetes cluster.

Summary

This tutorial provided you with a comprehensive guide to deploying a Django Rest Framework (DRF) application to Kubernetes. Throughout the tutorial, we have covered all the necessary steps, from setting up the development environment to containerizing the application and deploying it to a Kubernetes Cluster on Civo.

Further resources

To further enhance your skills and expand your knowledge, consider exploring the following resources:

• Django Rest Framework Official Documentation
• Kubernetes Documentation
• Docker Documentation
• Civo Documentation