Demo Creating a new Docker Image

In this lesson you’ll build a small custom Docker image for a Flask web application. The workflow is:

Run the app interactively inside an Ubuntu container to enumerate the exact installation and runtime steps.
Convert those verified steps into a Dockerfile.
Build, inspect, and run the image from the host.

This approach ensures the image performs only the required actions and helps avoid surprises during image builds.

Goals

Verify the Flask app runs inside a container.
Capture the steps required to install dependencies and run the app.
Convert the manual steps to a reproducible Dockerfile and build the image.
Run the container and expose the application port to the host.

Overview (manual process)

Start an Ubuntu container and open a shell.
Update the apt package index and install Flask for Python 3.
Create or copy the application source code inside the container.
Set the FLASK_APP environment variable to point to the application file.
Run the Flask development server binding to all interfaces (0.0.0.0).
Verify the app is reachable from the host using a port mapping.

Manual run (verify the app works)

Start an interactive Ubuntu container:

docker run -it --rm ubuntu bash

Inside the container, update apt and install the Flask package for Python 3:

apt-get update
apt-get install -y python3-flask

Create the application source file /opt/app.py (use cat or an editor):

# /opt/app.py
from flask import Flask
app = Flask(__name__)

@app.route("/")
def main():
    return "Welcome!"

@app.route("/how-are-you")
def hello():
    return "I am good, how about you?"

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

Set the environment variable and run the server:

export FLASK_APP=/opt/app.py
flask run --host=0.0.0.0

Sample server output inside the container (trimmed):

* Serving Flask app '/opt/app.py'
* Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on all addresses (0.0.0.0)
* Running on http://127.0.0.1:5000
* Running on http://172.17.0.2:5000
Press CTRL+C to quit

From the host (when you map ports) verify the endpoints:

http://localhost:5000/ → “Welcome!”
http://localhost:5000/how-are-you → “I am good, how about you?”

When installing packages interactively you may encounter debconf prompts (timezone, etc.). When building images, set DEBIAN_FRONTEND=noninteractive in the Dockerfile to avoid interactive prompts. This lesson shows that approach.

Converting manual steps into a Dockerfile

Key considerations when writing the Dockerfile:

Combine apt-get update and apt-get install in a single RUN instruction to keep image layers smaller and avoid stale apt caches.
Use ENV DEBIAN_FRONTEND=noninteractive to prevent interactive package configuration prompts during build.
Use the exec form (["cmd", "arg"]) for ENTRYPOINT or CMD to ensure proper signal handling and avoid shell parsing issues.

Create a file named Dockerfile with the following contents:

FROM ubuntu

# Prevent interactive prompts during package installation
ENV DEBIAN_FRONTEND=noninteractive

# Update and install Flask (single RUN to reduce image layers)
RUN apt-get update && \
    apt-get install -y --no-install-recommends python3-flask && \
    rm -rf /var/lib/apt/lists/*

# Copy application source into image
COPY app.py /opt/app.py

# Set Flask entrypoint environment variable
ENV FLASK_APP=/opt/app.py

# Document the port the app listens on
EXPOSE 5000

# Use exec form for ENTRYPOINT (recommended)
ENTRYPOINT ["python3", "-m", "flask", "run", "--host=0.0.0.0"]

What each Dockerfile line does

Instruction	Purpose
`FROM ubuntu`	Use Ubuntu as the base image. Consider using `python:3` for smaller, Python-optimized images in production.
`ENV DEBIAN_FRONTEND=noninteractive`	Prevents interactive prompts during package installation at build time.
`RUN apt-get update && apt-get install -y --no-install-recommends python3-flask && rm -rf /var/lib/apt/lists/*`	Updates apt, installs Flask without recommended packages, and clears apt caches to reduce image size.
`COPY app.py /opt/app.py`	Adds your application source into the image.
`ENV FLASK_APP=/opt/app.py`	Sets the Flask entrypoint environment variable.
`EXPOSE 5000`	Documents the port the container listens on.
`ENTRYPOINT ["python3","-m","flask","run","--host=0.0.0.0"]`	Uses the exec form to run Flask and bind it to all interfaces.

Build the Docker image

From the directory containing Dockerfile and app.py, build and tag the image webapp:

docker build -t webapp .

Trimmed example of build progress (informational):

$ docker build -t webapp .
[+] Building 6.1s (6/6) FINISHED
 => [internal] load build definition from Dockerfile     0.0s
 => [internal] load .dockerignore                        0.0s
 => [1/4] FROM docker.io/library/ubuntu:latest            0.0s
 => [2/4] RUN apt-get update && apt-get install -y ...   4.3s
 => [3/4] COPY app.py /opt/app.py                        0.0s
 => [4/4] ENV FLASK_APP=/opt/app.py                       0.0s
 => exporting to image                                   0.3s
 => => naming to docker.io/library/webapp                0.0s

Inspect local images:

docker images

Sample output (sizes will vary):

REPOSITORY   TAG       IMAGE ID       SIZE
ubuntu       latest    9b515734d83b   120MB
webapp       latest    5793d07cd0e1   247MB

Run the container and expose the port

If you run the container without mapping ports, the app runs inside the container but is not reachable from the host. Map container port 5000 to host port 5000:

docker run -p 5000:5000 webapp

Then open the following in your browser:

You should see the responses returned by the Flask app.

Useful commands (quick reference)

Task	Command
Build image	`docker build -t webapp .`
Run image (map port)	`docker run -p 5000:5000 webapp`
Run interactive Ubuntu shell	`docker run -it --rm ubuntu bash`
List images	`docker images`
Remove image	`docker rmi webapp`

Callouts and best-practice notes

The Dockerfile shown reduces interactive prompts during build via DEBIAN_FRONTEND=noninteractive, and keeps image layers smaller by combining apt-get update and apt-get install in a single RUN and clearing apt lists. For production, avoid Flask’s built-in development server — use a production WSGI server like Gunicorn and consider an official Python or Alpine-based image to reduce final image size. See Flask docs and Gunicorn.

The Flask built-in server is for development only. Before using containers in production, replace the development server with a production-ready WSGI server, apply container security best practices, and minimize the image footprint.

Next steps

Replace Flask’s built-in server with a production WSGI server (e.g., Gunicorn) and update the Dockerfile ENTRYPOINT accordingly.
Use a smaller base image (for example, python:3-slim or an Alpine-based image) to reduce image size.
Add a .dockerignore file to keep unnecessary files out of the build context.
Review Docker best practices: Dockerfile reference and Docker documentation.

Introduction

Docker Commands

Docker Images

Docker Compose

Docker Engine, Storage

Docker Networking

Docker Registry

Docker on Mac & Windows

Container Orchestration - Docker Swarm & Kubernetes

Conclusion

Docker Run Commands

Demo Creating a new Docker Image

Goals

Overview (manual process)

Manual run (verify the app works)

Converting manual steps into a Dockerfile

What each Dockerfile line does

Build the Docker image

Run the container and expose the port

Useful commands (quick reference)

Callouts and best-practice notes

Next steps

Watch Video

​Goals

​Overview (manual process)

​Manual run (verify the app works)

​Converting manual steps into a Dockerfile

​What each Dockerfile line does

​Build the Docker image

​Run the container and expose the port

​Useful commands (quick reference)

​Callouts and best-practice notes

​Next steps

Watch Video

Goals

Overview (manual process)

Manual run (verify the app works)

Converting manual steps into a Dockerfile

What each Dockerfile line does

Build the Docker image

Run the container and expose the port

Useful commands (quick reference)

Callouts and best-practice notes

Next steps