Language and Framework Guides
Run a Django Container App

16min
 Back4app Containers is a powerful platform for hosting Django applications. With its ability to automatically deploy Dockerized Django apps, you can launch your project in a scalable and flexible environment with ease. In this guide, we will walk you through the process of preparing and deploying your Django application on Back4app Containers.
In this comprehensive guide, we will walk you through the process of preparing and deploying your Django application on Back4app Containers, covering everything from simple projects to more complex setups.
If you have any questions or comments, feel free to join the conversation in the #Containers channel on the Back4app Community on Slack for discussions specific to Django on Back4app Containers. Anytime you can also contact us at [email protected].
At anytime if you want to check a sample working Django project on Back4app containers go to : ﻿https://github.com/templates-back4app/containers-python-django﻿﻿
﻿
﻿
1-Prepare your Django application:
Ensure that your Django application is structured properly, and all necessary files, including templates and static files, are organized in the project directory. For more complex projects, make sure you have a proper app factory setup and follow Django best practices.
2-Create a requirements.txt file:
List all required dependencies and their versions in a requirements.txt file. This file will be used by the Dockerfile to install the necessary packages when building the Docker image.
Here's a sample requirements.txt file for a Django application, including some common dependencies you might use in various projects. Feel free to add or remove packages as needed for your specific application:
requirements.txt
Django==3.2.10
gunicorn==20.1.0
psycopg2-binary==2.9.1
djangorestframework==3.12.4
django-cors-headers==3.9.0
django-environ==0.4.5
django-extensions==3.1.3
django-filter==21.1
django-rest-auth==0.9.5
django-allauth==0.47.0
requests==2.27.1

Django==3.2.10
gunicorn==20.1.0
psycopg2-binary==2.9.1
djangorestframework==3.12.4
django-cors-headers==3.9.0
django-environ==0.4.5
django-extensions==3.1.3
django-filter==21.1
django-rest-auth==0.9.5
django-allauth==0.47.0
requests==2.27.1
﻿
3-Create a Dockerfile
Write a Dockerfile to define your application's Docker image. Make sure to use a suitable base image (such as python:3.x-slim), install dependencies from the requirements.txt file, copy your project files, expose the correct port, and specify the appropriate command to start your Django application (e.g., using gunicorn or uWSGI).
Example 1: Basic Django Application with Gunicorn
This Dockerfile is for a simple Django application using Gunicorn as the WSGI server. It installs the necessary packages from the requirements.txt file, copies the project files, and exposes port 8000 for the Gunicorn server. The CMD specifies the command to start the Gunicorn server, binding to 0.0.0.0:8000.
Dockerfile
# Base image
FROM python:3.9-slim

# Working directory
WORKDIR /app

# Copy requirements file and install dependencies
COPY requirements.txt requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the project files
COPY . .

# Expose the server port
EXPOSE 8000

# Command to start the server
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "myproject.wsgi"]
# Base image
FROM python:3.9-slim

# Working directory
WORKDIR /app

# Copy requirements file and install dependencies
COPY requirements.txt requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the project files
COPY . .

# Expose the server port
EXPOSE 8000

# Command to start the server
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "myproject.wsgi"]
﻿
Example 2:  Django Application with uWSGI and Nginx
This Dockerfile is for a more complex Django application that uses uWSGI as the WSGI server and Nginx as the reverse proxy server. It installs build dependencies for uWSGI and Nginx, and then installs those packages along with uwsgi using pip. It then copies the project files and requirements.txt file, and exposes port 8000 for the uWSGI server. The CMD specifies the command to start uWSGI, using a separate configuration file called "myproject_uwsgi.ini".
The Dockerfile also configures Nginx by removing the default configuration file, copying a custom Nginx configuration file called "myproject_nginx.conf" to the appropriate directory, and creating a symlink to enable the configuration. The Nginx configuration file specifies that Nginx should listen on port 8000 and proxy requests to the uWSGI server running on the same Docker container.
Dockerfile
# Base image
FROM python:3.9-slim

# Install build dependencies and curl
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    libssl-dev \
    libpcre3-dev \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Install uWSGI and Nginx
RUN pip install uwsgi
RUN apt-get update && apt-get install -y --no-install-recommends nginx

# Configure Nginx
RUN rm /etc/nginx/sites-enabled/default
COPY myproject_nginx.conf /etc/nginx/sites-available/
RUN ln -s /etc/nginx/sites-available/myproject_nginx.conf /etc/nginx/sites-enabled/

# Copy requirements file and install dependencies
COPY requirements.txt requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the project files
COPY . .

# Expose the server port
EXPOSE 8000

# Start uWSGI
CMD ["uwsgi", "--ini", "/app/myproject_uwsgi.ini"]

# Base image
FROM python:3.9-slim

# Install build dependencies and curl
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    libssl-dev \
    libpcre3-dev \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Install uWSGI and Nginx
RUN pip install uwsgi
RUN apt-get update && apt-get install -y --no-install-recommends nginx

# Configure Nginx
RUN rm /etc/nginx/sites-enabled/default
COPY myproject_nginx.conf /etc/nginx/sites-available/
RUN ln -s /etc/nginx/sites-available/myproject_nginx.conf /etc/nginx/sites-enabled/

# Copy requirements file and install dependencies
COPY requirements.txt requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the project files
COPY . .

# Expose the server port
EXPOSE 8000

# Start uWSGI
CMD ["uwsgi", "--ini", "/app/myproject_uwsgi.ini"]
﻿
Make sure to replace "myproject" with your actual project name in the Dockerfiles. Also, for the uWSGI and Nginx setup, you need to create a "myproject_nginx.conf" file and a "myproject_uwsgi.ini" file in your project directory, which contain the appropriate configuration for Nginx and uWSGI.
4- Test your application locally
After creating your Dockerfile, you can test your Django application locally before deploying it to Back4App Containers. This is an important step to ensure that everything is working as expected and to avoid any issues or errors during deployment.
MacOS
# 1. Navigate to the directory where your Dockerfile is located.
cd /path/to/your/project/

# 2. Build the Docker image using the following command:
docker build -t myproject:latest .

# This command will build a Docker image with the tag "myproject:latest" 
# from the current directory, using the Dockerfile located there.

# 3. Run a container from the Docker image using the following command:
docker run --name myproject_container -p 8000:8000 myproject:latest

# This command will run a Docker container with the name "myproject_container",
# mapping port 8000 on your local machine to port 8000 in the container, and
# using the "myproject:latest" image that you just built.

# 4. Access your Django application by visiting http://localhost:8000/ in your web browser.
# You should see your application running as expected.

# 5. To stop the container, use the following command:
docker stop myproject_container

# This will stop the container with the name "myproject_container".

# 1. Navigate to the directory where your Dockerfile is located.
cd /path/to/your/project/

# 2. Build the Docker image using the following command:
docker build -t myproject:latest .

# This command will build a Docker image with the tag "myproject:latest" 
# from the current directory, using the Dockerfile located there.

# 3. Run a container from the Docker image using the following command:
docker run --name myproject_container -p 8000:8000 myproject:latest

# This command will run a Docker container with the name "myproject_container",
# mapping port 8000 on your local machine to port 8000 in the container, and
# using the "myproject:latest" image that you just built.

# 4. Access your Django application by visiting http://localhost:8000/ in your web browser.
# You should see your application running as expected.

# 5. To stop the container, use the following command:
docker stop myproject_container

# This will stop the container with the name "myproject_container".
﻿
By testing your application locally, you can catch any issues or errors before deploying to Back4App Containers. If you encounter any issues, be sure to address them before moving on to the next step.
Text
docker build -t your-app-name .
docker run -p 8080:8080 your-app-name
docker build -t your-app-name .
docker run -p 8080:8080 your-app-name
﻿
5-Push your project to a Git repository
Create a .gitignore file to exclude unnecessary or sensitive files from your repository (e.g., __pycache__, .env, *.pyc, etc.). Initialize a Git repository, commit your project files, and push them to a remote repository (e.g., on GitHub).
﻿
6-Deploy your application on Back4app Containers
After creating your Back4app account you can follow the steps listed on the Docs:
﻿1- Connect you GitHub repo with Back4app﻿
﻿2- Prepare your project for deployment﻿
In summary containers will follow the instructions detailed on your Dockerfile and start to create your App.
7-Monitor deployment
Keep an eye on the deployment logs and status on the Back4app Containers dashboard. Address any errors or issues that arise during deployment. In case of more complex projects, ensure that all necessary services (such as databases or external APIs) are correctly configured and accessible.
Notice that you also have a section called Logs which lists all the running logs for your app and its also important to keep an eye on it to check if you have any problem with your App.
﻿
8-Troubleshooting
Common deployments errors are listed here. Other possible common errors when deploying Flask Applications are:
Incorrect host configuration:
Django applications should be configured to run on host 0.0.0.0 when deployed on Back4App Containers. If your application is using localhost or 127.0.0.1, it might not be accessible externally.
Make sure your Django settings file (settings.py) contains the following line: ALLOWED_HOSTS = ['*']
If your application is still not accessible, check your Dockerfile to make sure the correct port is exposed (e.g., EXPOSE 8000 for port 8000).
Incompatible or missing dependencies:
Ensure that all required dependencies are listed in your requirements.txt file and that their versions are compatible with each other and your application code. Missing or incompatible dependencies can lead to runtime errors.
Make sure all the required dependencies are installed in your Docker container by running the docker run command with the -it flags and opening a shell inside the container: docker run -it myproject_container /bin/bash
Once inside the container, check that all the required dependencies are installed using pip list. If a dependency is missing, install it using pip install <dependency>
Database connection issues:
If your Django application relies on a database, ensure that the connection string and credentials are correctly set up in the application configuration. Also, verify that the database is reachable from the Back4App Containers environment.
Check your Django settings file (settings.py) to make sure the database configuration is correct. You may need to specify the database host, port, name, user, and password depending on your configuration.
Make sure your Docker container has access to the database by verifying that the database is reachable from inside the container. You can do this by opening a shell inside the container (docker run -it myproject_container /bin/bash) and using ping or telnet to connect to the database.
Application crashes or unhandled exceptions:
Unhandled exceptions or crashes in your Django application code can cause deployment failures or unexpected behavior. Examine your application logs for any error messages, and address any issues in your code.
Check the container logs by running docker logs myproject_container to see if there are any errors or exceptions being thrown.
Use a tool like Sentry to track and monitor errors in your application.
Incorrectly configured WSGI server:
Make sure that your WSGI server (e.g., Gunicorn or uWSGI) is correctly configured in your Dockerfile and that it starts your Django application using the right entry point (e.g., myproject.wsgi:application).
Verify that the correct server is installed and listed as a dependency in your requirements.txt file.
Invalid environment variables or configuration:
Check if your application relies on specific environment variables or configuration files, and ensure they are correctly set up in the Back4App Containers environment.
Set any necessary environment variables in your Dockerfile using the ENV command.
Verify that any configuration files required by your application are correctly mounted as volumes in the Docker container.
﻿
If you encounter any other issues while deploying your Django application on Back4App Containers, contact us at [email protected].
9-Scale your application
For more complex projects that require additional resources or horizontal/vertical scaling, consider upgrading your Back4app Containers plan to handle increased traffic and load.
10-Sample Application
For a sample Django application project you can go to : https://github.com/templates-back4app/containers-python-django﻿
Updated 17 May 2023
Did this page help you?
Run a Flask Container App
Run a ReactJS Container App