Creating a Docker Image for Python Flask on Ubuntu

By /

Introduction to Docker and Flask

Creating a Docker image for a Python Flask application can greatly enhance your deployment process, making it more efficient and reliable. Docker provides a platform that allows developers to package applications in containers, ensuring that they run consistently across different computing environments.

Flask, a lightweight web framework for Python, is perfect for building web applications and APIs. By using Docker, you can isolate your Flask app and all its dependencies, avoiding issues that may arise from running it on different machines or environments. In this article, we will walk through the process of creating a Docker image for a Flask application on Ubuntu.

This guide is aimed not only at those beginning their journey with Flask but also at seasoned developers looking to streamline their application deployment. We will cover the necessary tools, the required setup steps, and provide you with practical examples to ensure you can follow along seamlessly.

Prerequisites

Before diving into the process of creating a Docker image for your Flask application, it is important to have the following prerequisites in place:

  • Ubuntu Operating System: This guide assumes you are running Ubuntu. Ensure your system is updated by running sudo apt update && sudo apt upgrade.
  • Docker Installed: You need to have Docker installed on your machine. You can install Docker by following the official documentation or using commands like sudo apt install docker.io.
  • Basic Knowledge of Flask: Familiarity with Flask is essential. You should understand how to set up a basic Flask application.
  • Understanding of Command Line Interface (CLI): Basic command line knowledge will be required to execute commands throughout this process.

Once these requirements are fulfilled, you are ready to begin creating your Docker image.

Setting up a Basic Flask Application

To build a Docker image, we first need a simple Flask application. If you already have one, you can skip this section. If not, let’s create a basic Flask app:

# app.py
from flask import Flask

app = Flask(__name__)

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

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Save the above code in a file named app.py. This application sets up a very simple endpoint that returns ‘Hello, World!’ when the root URL is accessed.

Now, let’s create a requirements file that lists all dependencies for our Flask app. Create a file named requirements.txt and add the following content:

Flask==2.0.1

This tells Docker which Python packages it will need to install to run your application.

Creating a Dockerfile

The next step is to create a Dockerfile, which is a script that contains all commands to assemble an image. In the same directory as your app.py and requirements.txt files, create a file named Dockerfile with no file extension and add the following content:

FROM python:3.9-slim

# Set the working directory
WORKDIR /usr/src/app

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

# Copy the rest of the application code
COPY . .

# Expose the port the app runs on
EXPOSE 5000

# The command to run the application
CMD ["python", "app.py"]

Let’s break down what each line in the Dockerfile does:

  • FROM: This specifies the base image we are using. In this case, we are using a slim version of Python 3.9.
  • WORKDIR: This sets the working directory inside the container, which will host our application files.
  • COPY: This command copies files from your local directory into the container.
  • RUN: This executes the command to install the requirements necessary for your Flask app.
  • EXPOSE: This informs Docker that the container listens on the specified network port at runtime.
  • CMD: This specifies the default command to run when the container starts, which in our case is starting the Flask app.

With the Dockerfile completed, you are ready to build your Docker image!

Building the Docker Image

To build the Docker image, you will need to execute a command in your terminal. Navigate to the directory where your Dockerfile is located and run the following command:

docker build -t flask-app .

Here, -t flask-app tags your new image with the name flask-app. The . at the end indicates that the Docker build context is the current directory.

The output will show the build process, including each step defined in the Dockerfile. Once the build process is complete, you can verify that your Docker image has been created successfully by running:

docker images

Look for flask-app in the list of images. This confirms that your Docker image has been built and is ready to be run.

Running Your Flask Application in Docker

Now that you have built your Docker image, the next step is to run your Flask application inside a Docker container. Use the following command to run your container:

docker run -d -p 5000:5000 flask-app

In this command:

  • -d: This option runs the container in detached mode, allowing it to run in the background.
  • -p 5000:5000: This maps port 5000 on your host to port 5000 on the container, making your Flask app accessible via localhost.
  • flask-app: This specifies the Docker image to use for creating the container.

After executing this command, you should see the container running. You can check this by executing:

docker ps

Now, open a web browser and navigate to http://localhost:5000. You should see ‘Hello, World!’ displayed on the page, indicating that your Flask application is running inside a Docker container!

Best Practices for Dockerizing Flask Applications

While the steps above will get you up and running with a Dockerized Flask app, here are some best practices to keep in mind:

  • Multi-Stage Builds: If your application becomes more complex, consider implementing multi-stage builds to keep your image size small. This involves separating the build process from the runtime environment.
  • Environment Variables: Use environment variables for configuration settings. Docker allows you to set these variables on the command line when running your container.
  • Volume Mapping: When developing, use Docker volumes to persist your changes without needing to rebuild your image each time.

By following these best practices, you can enhance your development workflow and optimize your Docker containers for deployment.

Troubleshooting Common Issues

Even experienced developers face challenges when working with Docker and Flask. Here are some common issues you might encounter and how to troubleshoot them:

  • Port Conflicts: If you receive an error about port conflicts, ensure that port 5000 is not already in use by another process on your machine.
  • Dependency Issues: If you encounter problems related to missing dependencies, make sure that your requirements.txt file is correctly defined and matches the packages your application needs.
  • Container Not Starting: If your container stops immediately, check the logs using docker logs to see any error messages that could point to the issue.

By being aware of these potential issues and knowing how to address them, you can improve your experience with Docker and Flask.

Conclusion

In this article, we have covered the process of creating a Docker image for a Python Flask application on Ubuntu. We started from setting up a simple Flask app, creating a Dockerfile, building the image, and finally running the application inside a Docker container. Docker’s containerization offers numerous benefits, including environmental consistency, making your deployment process more manageable.

By following the steps outlined here, you can successfully dockerize your Flask applications, paving the way for efficient development and deployment practices. Remember to explore Docker’s full potential by experimenting with more advanced configurations and best practices. Happy coding!

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top