Introduction to docker

Hi, this is the first part of series where we will be dockerizing a django application with PostgreSQL database and deploying in server. For production environment we'll use Gunicorn and Nginx. In this post we will write a Dockerfile to build a container running a Django application. Dockerize django application with PostgreSQL database.

What is docker?

Docker is a platform for building, running and shipping applications in consistent manner. It helps to package our application and run it in any machine anywhere. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly.

Advantages of using docker

Flexible resource sharing.
Scalability - many containers can be placed in a single host.
Running your service on hardware that is much cheaper than standard servers.
Fast deployment, ease of creating new instances, and faster migrations.
Ease of moving and maintaining your applications.
Better security, less access needed to work with the code running inside containers, and fewer software dependencies.

Images

An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization.

Container

Docker provides the ability to package and run an application in a loosely isolated environment called a container. Containers are isolated environment for running the application. The isolation and security allows you to run many containers simultaneously on a given host. Containers are lightweight and contain everything needed to run the application, so you do not need to rely on what is currently installed on the host. You can create, start, stop, move, or delete a container using the Docker API or CLI. By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container’s network, storage, or other underlying subsystems are from other containers or from the host machine. Difference between containers and virtual machines is that virtual machines virtualize an entire machine down to the hardware layers and containers only virtualize software layers above the operating system level.

Pros of using containers over virtual machine:

Containers are lightweight than virtual machine.
Containers allows isolation.
Containers are fast and use less hardware resource than virtual machines.

Prerequisites for starting dockerizing django applications

Docker
Python
Django
PIP

Starting the project

If you already have running django application you can skip this part to writing a Dockerfile here. If not let's create new django project.

creating a django project

django-admin startproject DjangoWithDocker

Run and test django app

cd DjangoWithDocker
python manage.py runserver

Add psycopg2 in requirements for postgres db.

pip install psycopg2-binary==2.9.3

Create reqirements.txt file for dependency

pip freeze > requirements.txt

Now, lets create a Dockerfile.

While running Docker run command docker uses Dockerfile to build the image. It is a text document that contains commands to build a docker image.

Now, create Dockerfile (no any extension) on the root of you project and add code below in file.

FROM python:3.10-alpine

ENV PYTHONUNBUFFERED=1
ENV PYTHONDONTWRITEBYTECODE=1

RUN pip install --upgrade pip

ENV APP_DIR /home/DockerWithDjango

WORKDIR ${APP_DIR}

ADD requirements.txt ${APP_DIR}/

RUN pip install -r ${APP_DIR}/requirements.txt

COPY . ${APP_DIR}

EXPOSE 8000

CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Build docker image

docker build -t django-with-docker .

Run and test the application

docker run django-with-docker

To run django application in browser run following command and visit localhost:8000 in browser.

docker run --publish 8000:8000 django-with-docker

Add docker-compose.yml file in root of the project

version: "3.9"

volumes:
  dbdata:

networks:
  django_withdocker:
    driver: bridge

services:
  web:
    build: 
      context: .
    volumes:
      - .:/home/django-with-docker
    ports:
      - 8000:8000
    command: python manage.py runserver 0.0.0.0:8000
    container_name: django_with_docker_web
    restart: always
    depends_on:
      - db
    links:
      - db
    networks:
      - django_withdocker
  db:
    image: postgres
    volumes:
      - dbdata:/var/lib/postgresql
    environment:
      - POSTGRES_DB=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    networks:
      - django_withdocker

Now update your database settings on django application settings.

DB_NAME = 'postgres',
DB_USER = 'postgres',
DB_PASSWORD = 'postgres',
DB_HOST = 'db',
DB_PORT = 5432

Run and build command

docker-compose build
docker-compose up

Or just run following code to build and run

docker-compose up --build

Make migrations command

docker-compose run web python manage.py makemigrations

Migrate command

docker-compose run web python manage.py migrate

Avik