Dockerize Your Django Project: A Beginner's Tutorial

Dockerize Your Django Project: A Beginner's Tutorial" is a good title that gives a clear overview of the content of the tutorial. It suggests that the tutorial is aimed at beginners, covers the process of setting up a Django project with Docker, and provides a step-by-step guide to installing and configuring Docker for Django.

Here is a step-by-step tutorial for installing Docker and Django using different operating systems:

Install Docker on Windows:

Download the Docker Desktop for Windows installer from the official website: https://docs.docker.com/docker-for-windows/install/

Run the installer and follow the prompts to install Docker on your Windows machine.

Install Docker on Mac:

Download the Docker Desktop for Mac installer from the official website: https://docs.docker.com/docker-for-mac/install/

Run the installer and follow the prompts to install Docker on your Mac machine.

Install Docker on Linux:

Depending on your Linux distribution, installation instructions can vary. You can find the official instructions for Ubuntu, Debian, Fedora, and CentOS on the Docker website: https://docs.docker.com/engine/install/

here is an example of how to create a new Django project, integrate it with Docker, create a database migration, and create a superuser:

Create a new Django project:

/'''To create a requirements.txt file, you can use the pip freeze command, which will output the currently installed packages and their versions to a file. Here is an example of how to do that:'''/

$ mkdir myproject # new dir
$ cd myproject # moving into new dir
$ pip install django
$ pip install psycopg2

# Then you can use the following command to update the requirements file:
pip freeze > requirements.txt
$ pip freeze > requirements.txt
$ pip list
   Django==3.2.7
   psycopg2==2.8.6

$ python manage.py startapp myapp

Add the new app to the project's INSTALLED_APPS list in settings.py:

INSTALLED_APPS = [
    ...
    'myapp',
]

Create a Dockerfile in the root of the project directory with the following contents:

#without superuser creation and migrationscommand
FROM python:3.9-alpine
ENV PYTHONUNBUFFERED 1
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]


#use this one for superuser creation and migrations
FROM python:3.9-alpine
ENV PYTHONUNBUFFERED 1
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
RUN python manage.py makemigrations
RUN python manage.py migrate
RUN echo "from django.contrib.auth.models import User; User.objects.create_superuser('admin', 'admin@example.com', 'password')" 
| python manage.py shell
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Here, in the above Dockerfile, when the image is built, it will run the command python manage.py makemigrations, python manage.py migrate and python manage.py shell which will create the database migration, apply the migration to the database, and create a superuser with the specified username, email and password.

Build the Docker image:

$ docker build -t myproject .

Run the Docker container:

$ docker run -p 8000:8000 myproject

Note : You can also use docker-compose to run the project instead of running each command individually. docker-compose is a tool for defining and running multi-container Docker applications. You can find more information about docker-compose in the official documentation: https://docs.docker.com/compose/

To add PostgreSQL in the Dockerfile, you can use the official PostgreSQL image from the Docker Hub, and then link it to the Django container. Here is an example of how to do that:

FROM python:3.9-alpine
ENV PYTHONUNBUFFERED 1

# Install PostgreSQL and wait-for-it script
RUN apk update && apk add postgresql-dev postgresql-client

COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt

# Create a new PostgreSQL user and database
RUN echo "CREATE USER django WITH PASSWORD 'password';" | su - postgres -c psql
RUN echo "CREATE DATABASE django OWNER django;" | su - postgres -c psql

# Run migrations and create superuser
RUN python manage.py makemigrations
RUN python manage.py migrate
RUN echo "from django.contrib.auth.models import User; User.objects.create_superuser('admin', 'admin@example.com', 'password')" | python manage.py shell

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

The PostgreSQL image is installed by running apk update && apk add postgresql-dev postgresql-client command. Then, it creates a new PostgreSQL user and database by running the commands `echo "CREATE USER django WITH PASSWORD 'password';" | su - postgres -c p

To configure Django to use PostgreSQL, you will need to update the DATABASES setting in your settings.py file. Here is an example of how to do that:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'django',
        'USER': 'django',
        'PASSWORD': 'password',
        'HOST': 'db',
        'PORT': '',
    }
}

The ENGINE setting is set to django.db.backends.postgresql, indicating that we are using PostgreSQL as the database. The NAME setting is set to django, which is the name of the database we created in the Dockerfile. The USER and PASSWORD settings are set to django and password, respectively, which are the credentials we used to create the PostgreSQL user in the Dockerfile. The HOST is set to 'db' which is the name of the postgres container.

You can also use env variables to read the values from the env and pass it to the settings : 

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.environ.get('DB_NAME', 'django'),
        'USER': os.environ.get('DB_USER', 'django'),
        'PASSWORD': os.environ.get('DB_PASSWORD', 'password'),
        'HOST': os.environ.get('DB_HOST', 'db'),
        'PORT': '',
    }
}

In this example, the DATABASES setting is reading the values from the env variables like DB_NAME, DB_USER, DB_PASSWORD, DB_HOST.

Also, make sure that your requirements.txt file includes the psycopg2 package which is the PostgreSQL adapter for Python.

psycopg2==2.8.6

conclusion :

In conclusion, setting up a Django project with Docker involves several steps, including creating a Dockerfile to define the environment and dependencies, configuring the settings.py file to connect to a PostgreSQL database, and creating a requirements.txt file to list all the necessary packages for the project. It is important to keep the requirements.txt file up to date, include all necessary packages, and ensure compatibility between the packages and the version of Python used. By following these steps, you can easily set up and run a Django project using Docker, making it easy to manage dependencies and deploy your application in different environments.

DigitalOcean Sign Up : If you don't have a DigitalOcean account yet, you can sign up using the link below and receive $200 credit for 60 days to get started: Start your free trial with a $200 credit for 60 days link below: Get $200 free credit on DigitalOcean ( Note: This is a referral link, meaning both you and I will get credit.)