Deploying Your Python Application on Docker: A Simple Guide

Have you ever struggled to configure and deploy your existing web application? Worry no more! This guide will lead you through deploying an application on docker, mainly for python applications.

Prerequisites

Before diving in, make sure you have:

Your application in a Git repository
Basic understanding of Python and Docker
Docker CLI installed
A working application ready for deployment

Dockerfile – Building the Foundation

A Dockerfile at the root of your repository will define how to build your application. Start with a base image appropriate for your application. For a Python app, you might use:

FROM python:3.8
WORKDIR /app
COPY . /app

Install any required system-level dependencies. For a Debian-based image, you can run:

RUN apt-get update && apt-get install -y

Application-level Dependencies

Install application-level dependencies with a command tailored to your application. For Python, you might use:

RUN pip install -r requirements.txt

Don’t forget to pin dependencies to maintain consistency.

File-building Operations

Include any file-building operations within the Dockerfile. This may involve compiling or collecting JavaScript or CSS.

EXPOSE and CMD

EXPOSE informs Docker about the container’s listening ports:

EXPOSE 80

And CMD launches a server on the specified port:

CMD gunicorn -w 4 --bind=0.0.0.0:80 --forwarded-allow-ips="*" "flask:create_app()"

Environment Configuration

Avoid hard-coding values. Use environment variables to manage your application’s configuration. Use the provided variables to access services like databases and media. Parse these variables to configure your application accordingly.

Static and Media Files Handling

You have various options to handle static files. You might serve them directly from the application or configure a web server to handle them. For media files, utilize a media object store, configuring it with the provided MINIO_URL.

Local Container Orchestration with docker-compose.yml

Utilize docker-compose.yml to replicate your cloud environment locally. This enhances productivity during development and testing. Here’s an example of what this file might look like:

version: "2.4"
services:
  web:
    build: "."
    ports:
      - "8000:80"
    volumes:
      - ".:/app:rw"
      - "./data:/data:rw"
    
    env_file: .env-local
  # Database configuration...
  postgres:
    image: postgres:13.5-alpine
    environment:
      POSTGRES_DB: "db"
      POSTGRES_HOST_AUTH_METHOD: "trust"
    volumes:
      - ".:/app:rw"

network:
  app-net:
    name: app-network

Remember, this setup is only for local development and will not affect your cloud deployment.

Local Configuration using .env-local

Create a .env-local file for local environment variables. This will help your application find necessary variables during local development. For example:

DATABASE_URL=postgres://postgres@database_default:5432/db
MINIO_URL=some-url

Building and Running

Finally, build and run the application containers locally:

docker-compose build
docker-compose up

Access the site at http://127.0.0.1:8000/.

Final Thoughts

By leveraging Docker, you can build a resilient and scalable application following the Twelve-factor design principles. While we’ve provided a general overview, Docker also offers containers specific to frameworks like Django and Flask to facilitate your deployment process.

Remember, Git is essential, and you must exclude unnecessary files using .gitignore.

Now, with this guide in hand, you are ready to take your existing application and deploy it on docker. Happy deploying!