Building a Docker Image for a Python Flask App: A Step-by-Step Guide

Docker is a popular containerization tool that allows you to package your application along with all its dependencies into a standardized unit called a Docker image. In this tutorial, we will walk you through the process of building a Docker image for a Python Flask application.

Step 1: Write your Flask application
Before we can build a Docker image for our Python Flask app, we first need to have a Flask application to work with. For the purposes of this tutorial, we will create a simple "Hello World" Flask application. Here’s a basic Flask app that we can work with:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, World!"

if __name__ == "__main__":
    app.run(debug=True, host='0.0.0.0')

Save this code in a file named app.py in a directory of your choice.

Step 2: Create a Dockerfile
Next, we need to create a Dockerfile. The Dockerfile is a text file that contains instructions for building a Docker image. Here is an example Dockerfile for our Python Flask application:

# Use the official Python image as a base image
FROM python:3.8-slim

# Set the working directory in the container
WORKDIR /app

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

# Install any dependencies specified in the requirements.txt file
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application code into the container at /app
COPY . .

# Expose port 5000 to the outside world
EXPOSE 5000

# Command to run the Flask application
CMD ["python", "app.py"]

Save this code in a file named Dockerfile in the same directory as your Flask application.

Step 3: Create a requirements.txt file
In order to install the required dependencies for our Flask application, we need to create a requirements.txt file. This file should list all the Python packages that our Flask application depends on. Here’s an example requirements.txt file for our Flask application:

Flask==2.0.2

Save this code in a file named requirements.txt in the same directory as your Flask application.

Step 4: Build the Docker image
Now that we have our Flask application, Dockerfile, and requirements.txt file in place, we can proceed to build the Docker image. Open a terminal window and navigate to the directory where your Flask application, Dockerfile, and requirements.txt file are located.

To build the Docker image, run the following command:

docker build -t flask-app .

This command builds a Docker image with the tag flask-app using the current directory (.) as the build context.

Step 5: Run the Docker container
Once the Docker image has been successfully built, we can run a Docker container based on that image. To do this, run the following command:

docker run -p 5000:5000 flask-app

This command runs a Docker container based on the flask-app image and maps port 5000 from the container to port 5000 on the host machine.

Step 6: Test the Flask application
With the Docker container running, you can now access your Flask application by opening a web browser and navigating to http://localhost:5000. You should see the message "Hello, World!" displayed in the browser, indicating that your Flask application is up and running successfully in the Docker container.

Congratulations! You have successfully built a Docker image for a Python Flask application. Docker provides a convenient and portable way to package and deploy your applications, making it easier to manage dependencies and ensure consistent behavior across different environments.