Kubernetes for Django: Scaling and Security with HTTPS

Django offers a powerful web framework for Python with numerous features. We'll show you how to deploy a Django Polls application in a Kubernetes cluster.

In this tutorial, we will deploy a containerized Django Polls application in a Kubernetes cluster. Django is a powerful web framework that helps you quickly launch your Python application. It includes several convenient features, such as an object-relational mapper, user authentication, and a customizable administrative interface for your application. It also includes a caching framework and promotes a clean app design through its URL dispatcher and template system.

Prerequisites

To follow this tutorial, you will need:

• A Kubernetes cluster 1.15+ with role-based access control (RBAC) enabled.
• The `kubectl` command-line tool installed and configured on your local machine to connect to your cluster.
• A registered domain name.
• An ingress-nginx Ingress controller and the cert-manager TLS certificate manager installed and configured in your cluster to issue TLS certificates.
• An S3 object storage bucket, such as a centron Space, to store the static files of your Django project.
• A PostgreSQL server instance, database, and user for your Django app.
• A Docker Hub account and a public repository.
• The Docker engine installed on your local machine.

Step 1 — Cloning and Configuring the Application

In this step, we will clone the application code from GitHub and configure settings like database credentials and object storage keys. Start by cloning the application code from GitHub to your local machine and navigating to the appropriate directory.

git clone --single-branch --branch polls-docker https://github.com/do-community/django-polls.git

cd django-polls

The application code includes a Dockerfile that defines the container configuration. You can open this file with an editor of your choice and make adjustments as needed.

FROM python:3.7.4-alpine3.10

ADD django-polls/requirements.txt /app/requirements.txt

RUN set -ex \

&& apk add --no-cache --virtual .build-deps postgresql-dev build-base \

&& python -m venv /env \

&& /env/bin/pip install --upgrade pip \

&& /env/bin/pip install --no-cache-dir -r /app/requirements.txt \

&& runDeps="$(scanelf --needed --nobanner --recursive /env \

| awk '{ gsub(/,/, "\nso:", $2); print "so:" $2 }' \

| sort -u \

| xargs -r apk info --installed \

| sort -u)" \

&& apk add --virtual rundeps $runDeps \

&& apk del .build-deps

ADD django-polls /app

WORKDIR /app

ENV VIRTUAL_ENV /env

ENV PATH /env/bin:$PATH

EXPOSE 8000

CMD ["gunicorn", "--bind", ":8000", "--workers", "3", "mysite.wsgi"]

Step 2 — Creating the Database Schema and Uploading Assets to Object Storage

After creating and configuring the container, use `docker run` to override the CMD set in the Dockerfile and create the database schema using the `manage.py makemigrations` and `manage.py migrate` commands.

docker run --env-file env polls sh -c "python manage.py makemigrations && python manage.py migrate"

Then, you can create a superuser for the Django application:

docker run -i -t --env-file env polls sh

python manage.py createsuperuser

Next, generate the static files for the application and upload them to the centron Space:

docker run --env-file env polls sh -c "python manage.py collectstatic --noinput"

Step 3 — Pushing the Django App Image to Docker Hub

To deploy your app on Kubernetes, your app image must be uploaded to a repository such as Docker Hub. Start by logging into Docker Hub on your local machine.

docker login

Then tag the image with your Docker Hub username and repository name and push it to the repo.

docker tag polls:latest your_dockerhub_username/your_dockerhub_repo_name:latest

docker push your_dockerhub_username/your_dockerhub_repo_name:latest

Step 4: Configuring the ConfigMap

To inject configuration variables into the runtime environment, we use ConfigMaps and Secrets in Kubernetes. ConfigMaps are used for non-sensitive information like app settings, while Secrets are suitable for sensitive data such as API keys and database credentials. The configuration is done by creating a YAML file and applying it with `kubectl apply`.

apiVersion: v1

kind: ConfigMap

metadata:

name: polls-config

data:

DJANGO_ALLOWED_HOSTS: "*"

STATIC_ENDPOINT_URL: "https://your_space_name.space_region.centronspaces.com"

STATIC_BUCKET_NAME: "your_space_name"

DJANGO_LOGLEVEL: "info"

DEBUG: "True"

DATABASE_ENGINE: "postgresql_psycopg2"

Step 5: Setting Up the Secret

Secret values must be base64 encoded. We create a Secret object in our cluster by extracting values from an environment variable file and encoding them in base64. This is done similarly to configuring the ConfigMap, but using the `kubectl create secret` command.

apiVersion: v1

kind: Secret

metadata:

name: polls-secret

type: Opaque

data:

DJANGO_SECRET_KEY: ""

DATABASE_NAME: ""

DATABASE_USERNAME: ""

DATABASE_PASSWORD: ""

DATABASE_HOST: ""

DATABASE_PORT: ""

STATIC_ACCESS_KEY_ID: ""

STATIC_SECRET_KEY: ""

STATIC_BUCKET_NAME: ""

STATIC_ENDPOINT_URL: ""

DJANGO_LOGLEVEL: ""

Step 6: Deploying the Django App with a Deployment File

A Kubernetes deployment is used to deploy our Django app. Here, we set the number of replicas and define the container configurations. The configuration is done in a YAML file, which is then applied using `kubectl apply`.

apiVersion: apps/v1

kind: Deployment

metadata:

name: polls-app

labels:

app: polls

spec:

replicas: 2

selector:

matchLabels:

app: polls

template:

metadata:

labels:

app: polls

spec:

containers:

- image: your_dockerhub_username/app_repo_name:latest

name: polls

envFrom:

- secretRef:

name: polls-secret

- configMapRef:

name: polls-config

ports:

- containerPort: 8000

name: gunicorn

Step 7: Enabling External Access with a Service

A Kubernetes service is created to provide a stable endpoint for our app, which persists even with pod changes. Here, we define a NodePort service to temporarily access the Django app. The configuration is also done in a YAML file, which is then applied.

apiVersion: v1

kind: Service

metadata:

name: polls

labels:

app: polls

spec:

type: NodePort

selector:

app: polls

ports:

- port: 8000

targetPort: 8000

Step 8: Configuring HTTPS with Nginx Ingress and cert-manager

Finally, we set up HTTPS encryption for our app. This is achieved using Ingress objects and the cert-manager add-on. Once the configuration is complete, the deployment of the Django app with HTTPS encryption in our Kubernetes cluster will be finalized.

apiVersion: networking.k8s.io/v1beta1

kind: Ingress

metadata:

name: polls-ingress

annotations:

kubernetes.io/ingress.class: "nginx"

cert-manager.io/cluster-issuer: "letsencrypt-staging"

spec:

tls:

- hosts:

- your_domain.com

secretName: polls-tls

rules:

- host: your_domain.com

http:

paths:

- backend:

serviceName: polls

servicePort: 8000

Conclusion

Deploying a Django app on Kubernetes requires several steps to configure ConfigMaps, Secrets, Deployments, Services, and Ingresses. Following these steps, you can create a scalable and securely deployed application in your Kubernetes environment.