{"id":572,"date":"2024-05-02T12:37:02","date_gmt":"2024-05-02T12:37:02","guid":{"rendered":"https:\/\/blog.ngocha.biz\/?p=572"},"modified":"2024-05-02T12:37:02","modified_gmt":"2024-05-02T12:37:02","slug":"dockerize-python-flask-application","status":"publish","type":"post","link":"https:\/\/blog.ngocha.biz\/?p=572","title":{"rendered":"Dockerize Flask Application: A Step-by-Step Guide"},"content":{"rendered":"

In this guide, we will look at a step-by-step guide to Dockerize Flask Application.<\/p>\n

I will cover everything from creating a basic Flask application to creating a production-grade Flask application Docker image that uses the Gunicorn<\/strong> server.<\/p>\n

By default, Flask uses the built-in development server<\/strong> provided by Werkzeug that can be used for development and testing purposes.<\/p>\n

So we will use Gunicorn<\/strong>, a production-grade server for Flask application that is capable of handling a higher volume of traffic, supporting multiple worker processes or threads, and provides better performance and scalability<\/strong>.<\/p>\n

Also, we will look at some of the best practices you can follow in the image-building process for your image-building CI pipeline.<\/p>\n

Prerequisites & Repository<\/h2>\n

Here are the prerequisites for Dockerizing the Python Flask application:<\/p>\n

    \n
  1. Docker installed<\/a> in your system.<\/li>\n
  2. A Python Flask application file that has to be Dockerized.<\/li>\n<\/ol>\n

    All the code and configuration files used in this blog are hosted in the docker image examples repository.<\/a><\/p>\n

    Clone\/Fork the repository to make use of it.<\/p>\n

    git clone https:\/\/github.com\/techiescamp\/docker-image-examples<\/code><\/pre>\n
    How to Dockerize Python Flask Application?<\/h2>\n
    Follow the steps given below to build a Docker image for a Flask application.<\/p>\n
    Step 1: Build a Flask Application<\/h3>\n
    Note<\/strong>: Ignore this step if you have an existing Flask application.<\/p><\/blockquote>\n
    For demonstration purposes, I am going to use a simple Hello World Flask application. The Python file is given below<\/p>\n
    from flask import Flask, render_template\n\napp = Flask(__name__)\n\n@app.route('\/')\ndef hello_world():\n    return render_template('index.html')\n\nif __name__ == '__main__':\n    app.run(host='0.0.0.0')<\/code><\/pre>\n
    This file creates a Python Flask application that will display a custom message in the Homepage.<\/p>\n
    Next, create a new HTML file named index.html<\/code> in a directory named templates<\/code> within your project directory. The templates<\/code> directory is where Flask looks for HTML templates by default.<\/p>\n
    <!DOCTYPE html>\n<html>\n<head>\n    <title>Hello DevOps Engineer<\/title>\n    <link rel=\"stylesheet\" href=\"https:\/\/maxcdn.bootstrapcdn.com\/bootstrap\/4.5.2\/css\/bootstrap.min.css\">\n    <style>\n        body {\n            background-color: #f8f9fa;\n        }\n        .header {\n            background-color: #343a40;\n            color: white;\n            padding: 20px;\n            text-align: center;\n            margin-bottom: 20px;\n        }\n        .message-box {\n            background-color: #fff;\n            border-radius: 5px;\n            padding: 20px;\n            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);\n        }\n    <\/style>\n<\/head>\n<body>\n    <div class=\"header\">\n        <h1>Welcome to My Flask App<\/h1>\n    <\/div>\n    <div class=\"container\">\n        <div class=\"row justify-content-center\">\n            <div class=\"col-md-6\">\n                <div class=\"message-box\">\n                    <h2 class=\"text-center\">Hello DevOps Engineer<\/h2>\n                    <p class=\"text-center\">This is a sample Flask application with Bootstrap styling.<\/p>\n                <\/div>\n            <\/div>\n        <\/div>\n    <\/div>\n<\/body>\n<\/html><\/code><\/pre>\n
    Create a requirements.txt<\/code> file in the project directory.<\/p>\n
    #requirements.txt\n\nflask\ngunicorn<\/code><\/pre>\n
    Step 2: Create Dockerfile<\/h3>\n
    Now, create a Dockerfile<\/code> with the following content. You can also use the docker init command utility to generate a Dockerfile.<\/p>\n
    ARG PYTHON_VERSION=3.11.6\nFROM python:${PYTHON_VERSION}-slim as base\n\nENV PYTHONDONTWRITEBYTECODE=1\nENV PYTHONUNBUFFERED=1\n\nWORKDIR \/app\n\nARG UID=10001\nRUN adduser \\\n    --disabled-password \\\n    --gecos \"\" \\\n    --home \"\/nonexistent\" \\\n    --shell \"\/sbin\/nologin\" \\\n    --no-create-home \\\n    --uid \"${UID}\" \\\n    appuser\n\n# Install the dependencies\nRUN --mount=type=cache,target=\/root\/.cache\/pip \\\n    --mount=type=bind,source=requirements.txt,target=requirements.txt \\\n    python -m pip install -r requirements.txt\n\nUSER appuser\n\nCOPY . .\n\nEXPOSE 8000\n\n# Run the application using Gunicorn\nCMD [\"gunicorn\", \"--bind\", \"0.0.0.0:8000\", \"hello:app\"]<\/code><\/pre>\n
    Here is the Dockerfile explanation.<\/p>\n
      \n
    1. This Dockerfile builds a container image with Python Slim<\/strong> as its base image. Which is a minimal image.<\/li>\n
    2. Then we set the \/app<\/strong> directory as the working directory.<\/li>\n
    3. Next, we setup a non-root user named appuser that the app will run under (security Best practice)<\/li>\n
    4. –mount=type=cache,target=\/root\/.cache\/pip<\/strong>: This option creates a cache mount for the pip cache directory at \/root\/.cache\/pip<\/code>. By using a cache mount, the pip cache is stored outside the container’s filesystem and can be reused across multiple builds.<\/li>\n
    5. –mount=type=bind,source=requirements.txt,target=requirements.txt<\/strong>: This option creates a bind mount that mounts the applications requirements.txt<\/code> file from the host filesystem into the container at the same path. It allows the pip install<\/code> command to access the requirements.txt<\/code> file without copying it into the container’s filesystem. It ensures that the latest version of the requirements.txt<\/code> file is always used during the build.<\/li>\n
    6. python -m pip install -r requirements.t<\/strong>xt installs the required python dependencies.<\/li>\n
    7. Then we copy the hello.py<\/strong> (application code) to the working directory.<\/li>\n
    8. Since we are using Gunicorn, we will expose port 8000.<\/strong> The default Flask app port is 5000.<\/li>\n
    9. Finally using the CMD instruction, we run the gunicorn executable binding to 0.0.0.0<\/strong>.<\/li>\n<\/ol>\n
      Step 3: Build Docker Image<\/h3>\n
      To create the Docker image<\/a>, run the following command in the same directory where the Dockerfile is<\/p>\n
      docker build -t flask-application:1.0.0 .<\/code><\/pre>\n
      To view the docker image, use the docker images<\/strong> command as shown below<\/p>\n
      \"docker<\/figure>\n
      Step 4: Run the Docker Image<\/h3>\n
      Once the Docker image build has been finished, run the Docker image using the command below.<\/p>\n
      docker run -d -p 8000:8000 flask-application:1.0.0<\/code><\/pre>\n
      Once you run the docker image, use the docker ps<\/strong> command to verify if the container is running properly.<\/p>\n
      Now, check your application on the browser using localhost:8000<\/strong>. If you expose your application on a different port make sure to change the port number you exposed the application to.<\/p>\n
      \"Validating<\/figure>\n
      You can also build a Docker image of any Python Flask application using these steps.<\/p>\n
      Best Practices for Optimizing Docker Images<\/h2>\n
      When working with Docker images for production workloads, ensure you follow the Docker image best practices given below.<\/p>\n
      These are particularly required in the CI pipeline where you build the flask image for production use cases.<\/p>\n
      1. Lint Dockerfile<\/h3>\n
      Use Hadolint<\/a> to check your Dockerfile for possible errors, security vulnerabilities, and performance problems. Install Hadolint and use the below command to lint your Dockerfile<\/p>\n
      hadolint Dockerfile<\/code><\/pre>\n
      Make sure to run this command in the same directory where your Dockerfile is and you will get the output as shown below to improve your Dockerfile<\/p>\n
      \"linting<\/figure>\n
      2. Scan for Vulnerabilities<\/h3>\n
      Use tools like Trivy<\/a> or Docker Scout to scan the Docker images for vulnerabilities. Install trivy in your system and use the below command to scan your Docker image<\/p>\n
      trivy image flask-application:1.0.0<\/code><\/pre>\n
      Trivy will scan your Docker image and show the vulnerability in your Docker image as shown below<\/p>\n
      \"scan<\/figure>\n
      3. Optimize Docker Image Size<\/h3>\n
      Optimizing Docker images<\/a> is very much important in project environments, you can also use SlimToolkit<\/a> to reduce the size of your Docker image.<\/p>\n
      First, create a <\/code>preserved-paths.txt<\/strong> file with the file name or file path you don\u2019t want to get removed during the slim process.<\/p>\n
      \/app\n\/usr\/bin\/python3\n\/usr\/local\/bin\/flask<\/code><\/pre>\n
      In my Txt<\/strong> file, I have specified the path where my application and files needed to run the Flask application are present. Now, run the below command to slim the Docker image with the Txt file.<\/p>\n
      slim build --http-probe=false --preserve-path-file preserved-paths.txt --target flask-application:1.0.0 --tag slimmed-flask-application:1.0.0<\/code><\/pre>\n
      This command will slim the Docker images without affecting the file or file path mentioned in the txt<\/strong> file with a new name you specify in the –tag<\/strong> flag.<\/p>\n
      Now if you you check the docker image size, it will be considerably reduced as shown below.<\/p>\n
      \"size<\/figure>\n
      You can see the size of the Docker image has been reduced from 480MB to 21MB<\/strong> and it works properly without any issue.<\/p>\n
      4. Versioning Docker Image<\/h3>\n
      Use Semantic Versioning<\/a> when tagging Docker images to ensure clarity and consistency in versioning practices. An example is given below,<\/p>\n
      flask-application:1.0.0<\/code><\/pre>\n
      In the above example, 1.0.0<\/strong> is the semantic version.<\/p>\n
      Conclusion<\/h2>\n
      In this blog, we can see about the Dockerize Python Flask application and best practices for building secure Docker images.<\/p>\n
      Make sure to follow the best practices whenever you build Docker images.<\/p>\n
      If you need a tutorial blog to Dockerize Java Applications, refer this<\/a> blog.<\/p>\n
      \n
      Ngu\u1ed3n:<\/strong> Dockerize Flask Application: A Step-by-Step Guide \u2014 DevOpsCube<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
      Source: https:\/\/devopscube.com\/dockerize-python-flask-application\/<\/p>\n","protected":false},"author":1,"featured_media":573,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-572","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-devops"],"_links":{"self":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts\/572","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=572"}],"version-history":[{"count":0,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts\/572\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/media\/573"}],"wp:attachment":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=572"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=572"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=572"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}