Skip to content

Deploy a Django App

Deploying a Django App with Caddy and Docker: A Complete Guide

In this example, we'll walk through how to deploy a Django app using Docker and Caddy. This combination offers a streamlined setup for development and production, allowing you to focus on building your app rather than managing infrastructure.

Understanding Docker and Caddy: A Quick Overview

Before diving into the deployment process, it’s important to understand what Docker and Caddy bring to the table.

Docker is a platform that packages applications and their dependencies into containers. This makes it easier to move your application between different environments without worrying about compatibility issues. Docker is especially useful for deploying Django apps because it ensures your application will run the same way, regardless of the underlying system.

Caddy is an HTTP/2 web server with automatic HTTPS, flexible configuration, and built-in reverse proxy support. One of Caddy’s biggest advantages is its simplicity. Unlike more traditional servers like Nginx or Apache, Caddy is incredibly easy to configure, and it handles SSL certificates automatically, eliminating the need for manual renewal of Let's Encrypt certificates.

Together, Docker and Caddy can help you streamline your deployment pipeline and reduce potential headaches.

Setting Up Your Django App for Deployment

Before containerizing your Django app, ensure that it’s ready for deployment. You will need to configure a few settings specific to the production environment.

First, update your settings.py file in your Django project. Set DEBUG = False to ensure that your app is running in production mode. It's crucial to define the ALLOWED_HOSTS variable to avoid deployment errors. This variable restricts the hosts that your app will respond to, so set it to include the domain or IP address you will use for deployment, as well as localhost for testing purposes.

You’ll also want to ensure that static files are correctly handled. In production, Django doesn’t serve static files by default, so you’ll need to collect them and configure a web server (like Caddy) to serve them. You can collect static files using the collectstatic management command.

python manage.py collectstatic

This command gathers all static files into a single directory, which you can then serve through your web server.

Creating a Dockerfile for Your Django App

Once your Django app is production-ready, the next step is to containerize it using Docker. A Dockerfile is a script that contains a series of instructions on how to build your Docker image. Let’s break down a basic Dockerfile for a Django app.

# Use an official Python runtime as a parent image
FROM python:3.10-slim

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Set the working directory inside the container
WORKDIR /app

# Copy the requirements file into the container
COPY requirements.txt /app/

# Install any necessary dependencies
RUN pip install --upgrade pip
RUN pip install -r requirements.txt

# Copy the current directory contents into the container
COPY . /app/

# Run database migrations and collect static files
RUN python manage.py migrate
RUN python manage.py collectstatic --noinput

# Expose the port your app runs on
EXPOSE 8000

# Define the command to run the application
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "myproject.wsgi:application"]

Let’s walk through what each part of this Dockerfile does:

  • The FROM directive specifies the base image we are using. In this case, it’s the official Python 3.10 image, which provides everything we need to run a Python-based app.
  • Environment variables are set to make Python output more manageable and avoid writing .pyc files.
  • The WORKDIR command sets the working directory inside the container to /app, which is where all subsequent commands will be run.
  • We copy over the requirements.txt file, install dependencies, and then copy the rest of the app’s code into the container.
  • The RUN commands handle any necessary database migrations and collect static files.
  • The EXPOSE command exposes port 8000, which is the default port for Django apps. Caddy will later proxy traffic to this port.
  • Finally, the CMD command specifies that we want to run our app using Gunicorn, a production-ready WSGI HTTP server for Python.

Setting Up Docker Compose

Docker Compose is a tool that allows you to define and manage multi-container Docker applications. For a Django deployment, we’ll use Docker Compose to spin up both the Django app and Caddy. First, create a docker-compose.yml file at the root of your project directory:

version: '3'

services:
  web:
    build: .
    command: gunicorn myproject.wsgi:application --bind 0.0.0.0:8000
    volumes:
      - .:/app
    ports:
      - "8000:8000"
    env_file:
      - .env
    depends_on:
      - db
  db:
    image: postgres:13
    volumes:
      - postgres_data:/var/lib/postgresql/data/
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
  caddy:
    image: caddy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config
    depends_on:
      - web
    networks:
      - default

volumes:
  postgres_data:
  caddy_data:
  caddy_config:

This configuration defines three services: web for the Django application, db for PostgreSQL, and caddy for the Caddy server. We specify the necessary ports, mount volumes for persistence, and use an .env file for environment variables like database credentials.

In this example, we use Gunicorn to serve the Django app, which is a good choice for production. PostgreSQL is used as the database service, and Caddy will act as the reverse proxy and handle HTTPS.

Configuring Caddy for Your Django App

Now, let’s configure Caddy as a reverse proxy to serve our Django app. Caddy’s configuration is defined in a Caddyfile, which should be placed in the root directory of your project. Here’s an example of a simple Caddyfile:

yourdomain.com {
    reverse_proxy web:8000
}

In this configuration, replace yourdomain.com with your actual domain. Caddy will proxy incoming requests to the Django app running on port 8000, which is the port we exposed in both the Dockerfile and Docker Compose configuration.

Caddy’s automatic HTTPS feature will automatically acquire and renew SSL certificates from Let’s Encrypt for your domain. This means you don’t need to worry about certificate management at all—Caddy takes care of it.

Once your Caddyfile is set up, your Docker containers are ready to work together. The Caddy service in the Docker Compose configuration will listen on ports 80 and 443, routing requests to your Django app running inside the web container.

Running the Application

With everything configured, the final step is to start the application using Docker Compose. From your project directory, run:

docker-compose up --build

This command builds the Docker images and starts all the services defined in your docker-compose.yml file. Caddy will handle incoming traffic and reverse proxy it to the Django app, which is running on Gunicorn.

You can now visit your domain in a web browser to see your Django app live and running. Caddy will automatically handle the SSL certificates, and Docker ensures that your app runs consistently across different environments.

Monitoring and Scaling Your Django App

Once your app is deployed, it’s important to monitor its performance and scale it as needed. Docker makes it easy to scale services using Docker Compose. For example, if you want to run multiple instances of your Django app to handle more traffic, you can scale the web service by running:

docker-compose up --scale web=3

This command will start three instances of the Django app, and Caddy will automatically load-balance incoming requests across them. This approach allows for horizontal scaling, which is useful for handling large amounts of traffic without changing your codebase.

You can also monitor the logs for your Django app and other services by running:

docker-compose logs -f

This provides real-time feedback from all running services, allowing you to spot issues quickly.

Conclusion

Deploying a Django app with Docker and Caddy is a powerful and efficient way to streamline your deployment pipeline. Docker ensures that your app runs consistently in different environments, while Caddy simplifies the process of serving your app with HTTPS and reverse proxy capabilities.

By combining these two tools, you can focus more on developing your Django app and less on managing infrastructure. Whether you’re deploying a small project or preparing for large-scale production, this setup provides a solid foundation for your app to grow and scale.