Skip to main content


Set up your component repository to use the Python/pip/Flask stack. With the Docker Generic scaffolder, developers can create a Dockerfile that allows using Python in connection with the Flask web framework.


  • You have already created your application.
  • You have viewer and developer permissions on the deployment cluster.
  • You have deployer permission on the deployment environment.
  • If the Dockerfile introduced in this article does not fit your needs, you may need to update that Dockerfile.


  1. Navigate to your application.
  2. Create a new application component with the Docker Generic scaffolder.
  3. Clone the repository created to hold the component's code to your local laptop.
  4. Replace the contents of the Dockerfile file in the home directory with the following:
# Source image
FROM python:3.9.12-alpine3.15

# Create a virtual environment for all the Python dependencies
RUN python3 -m venv /opt/venv

# Make sure we use the virtualenv
ENV PATH="/opt/venv/bin:$PATH"

# Change workdir to app directory

# Copy content of src directory into /app dir
COPY src/ .

# Install Python dependencies
RUN pip3 install -r requirements.txt

# Expose application port

# start the application
CMD [ "python3", "-m" , "flask", "run", "--host=", "--port=80"]

This is it! Put your source code in the /src directory; commit; push; you are then ready to build and deploy your component in CodeNOW. The previous Dockerfile reflects default configuration choices:

  • Programs will run with the 3.9 version of the Python interpreter.
  • All your Python code must be in /src.
  • The Python interpreter will look for an file and run that file.
  • pip3 is used as package manager. For more information about pip, see its official documentation.
  • requirements.txt holds the dependencies for the Python code that you want to run. For more information, cf. How to install Python packages with pip and requirements.txt.
  • The application starts on port 80.
  • The application uses the Flask web framework.

Customize further to reflect additional constraints or requirements:


Let's write, build, and deploy a simple Python web application that leverages the previous Python Dockerfile.

  1. Create an file in /src with the following contents:

    from flask import Flask
    app = Flask(__name__)
def hello():
return 'Hello World'

if __name__ == '__main__':
  1. Create a requirements.txt file in the /src directory with the following contents:

  2. Check that your directory structure looks like this:

    ├── codenow
    │ └── config
    │ └── config.yaml
    ├── Dockerfile
    ├── src
    │ ├──
    │ └── requirements.txt
  3. Commit and push your code to the remote origin

  4. Build and deploy your application

The following animated image illustrates the previous steps: