Why Docker improves development workflow - Why It Works

Introduction

Developers often face problems when their apps work on their computer but not on others or on servers. Docker solves this by packaging apps with everything they need to run, making the app behave the same everywhere.

When you want to share your app with teammates and ensure it runs the same on their computers.

When you need to run multiple apps on one machine without them interfering with each other.

When you want to test your app in an environment identical to the production server.

When you want to quickly start and stop your app without installing many dependencies.

When you want to deploy your app easily to cloud servers or other machines.

Config File - Dockerfile

Dockerfile

FROM python:3.11-slim
WORKDIR /app
COPY . /app
RUN pip install --no-cache-dir flask
CMD ["python", "app.py"]

This Dockerfile starts from a small Python image.

It sets the working folder inside the container to /app.

It copies your app files into the container.

It installs Flask, a Python web framework.

Finally, it runs your app using Python.

Commands

This command builds a Docker image named 'my-flask-app' from the Dockerfile in the current folder. It packages your app and its environment.

Terminal

docker build -t my-flask-app .

Expected Output

Sending build context to Docker daemon  4.096kB

Step 1/5 : FROM python:3.11-slim

 ---> 123abc456def

Step 2/5 : WORKDIR /app

 ---> Using cache

 ---> 789def012abc

Step 3/5 : COPY . /app

 ---> Using cache

 ---> 345ghi678jkl

Step 4/5 : RUN pip install --no-cache-dir flask

 ---> Running in abc123def456

Collecting flask

  Downloading Flask-2.3.2-py3-none-any.whl (96 kB)

Installing collected packages: flask

Successfully installed flask-2.3.2

Removing intermediate container abc123def456

 ---> 901mno234pqr

Step 5/5 : CMD ["python", "app.py"]

 ---> Running in stu567vwx890

Removing intermediate container stu567vwx890

 ---> 345yz123abc

Successfully built 345yz123abc

Successfully tagged my-flask-app:latest

→

-t - Names and tags the image for easy reference

This command runs your app inside a container and maps port 5000 of your computer to port 5000 inside the container so you can access the app in your browser.

Terminal

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

Expected Output

* Serving Flask app 'app'

* Debug mode: off

WARNING: This is a development server. Do not use it in a production deployment.

* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

→

-p - Maps container port to host port for access

This command lists running containers so you can check that your app container is running.

Terminal

docker ps

Expected Output

CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                    NAMES

345yz123abc    my-flask-app   "python app.py"          10 seconds ago   Up 9 seconds    0.0.0.0:5000->5000/tcp   loving_morse

This command stops the running container named 'loving_morse' to free resources or update the app.

Terminal

docker stop loving_morse

Expected Output

loving_morse

Key Concept

Docker packages your app with everything it needs so it runs the same everywhere, avoiding 'it works on my machine' problems.

Common Mistakes

Not mapping ports with -p when running the container

Without port mapping, you cannot access the app from your computer's browser.

Always use -p host_port:container_port to expose the app port.

Forgetting to rebuild the image after changing app files

The container runs the old code because the image was not updated.

Run 'docker build' again to create a new image with changes.

Running containers without stopping old ones

Multiple containers may use the same ports causing conflicts.

Stop old containers with 'docker stop' before starting new ones.

Summary

Build a Docker image to package your app and its environment.

Run the image as a container with port mapping to access the app.

Use 'docker ps' to check running containers and 'docker stop' to stop them.

Practice

1. Why does Docker improve the development workflow?

easy

A. It creates the same environment on any computer, avoiding setup issues.

B. It automatically writes code for developers.

C. It replaces the need for version control systems.

D. It slows down application deployment to ensure safety.

Solution

1. Step 1: Understand environment consistency

   Docker packages apps with all needed parts so they run the same everywhere.

2. Step 2: Recognize impact on workflow

   This consistency avoids setup problems and saves time during development.

3. Final Answer:

   It creates the same environment on any computer, avoiding setup issues. -> Option A

4. Quick Check:

   Consistent environment = Faster, error-free development [OK]

Hint: Docker ensures apps run the same everywhere [OK]

Common Mistakes:

• Thinking Docker writes code automatically
• Confusing Docker with version control
• Believing Docker slows deployment

2. Which Docker command is used to start a container from an image?

easy

A. docker build

B. docker push

C. docker commit

D. docker run

Solution

1. Step 1: Identify command purpose

   "docker run" starts a container from an image to run the app.

2. Step 2: Differentiate other commands

   "docker build" creates an image, "docker push" uploads it, "docker commit" saves container changes.

3. Final Answer:

   docker run -> Option D

4. Quick Check:

   Start container = docker run [OK]

Hint: Use 'docker run' to start containers [OK]

Common Mistakes:

• Using 'docker build' to start containers
• Confusing 'docker push' with running
• Thinking 'docker commit' starts containers

3. What will be the output of the command docker ps right after starting a new container?

medium

A. List of all running containers including the new one

B. List of all images on the system

C. Error: command not found

D. List of stopped containers only

Solution

1. Step 1: Understand 'docker ps' command

   It shows all currently running containers on the system.

2. Step 2: Analyze state after starting container

   After starting a container, it will appear in the running list shown by 'docker ps'.

3. Final Answer:

   List of all running containers including the new one -> Option A

4. Quick Check:

   docker ps = running containers list [OK]

Hint: 'docker ps' lists running containers [OK]

Common Mistakes:

• Thinking 'docker ps' lists images
• Expecting stopped containers in 'docker ps'
• Assuming 'docker ps' gives an error

4. You tried to run docker run myapp but got an error saying the image was not found. What is the likely fix?

medium

A. Restart Docker service

B. Use docker push to upload the image

C. Run docker build to create the image first

D. Delete all containers

Solution

1. Step 1: Understand the error cause

   The error means Docker cannot find the image locally to start the container.

2. Step 2: Fix by building the image

   Use 'docker build' to create the image from a Dockerfile before running it.

3. Final Answer:

   Run docker build to create the image first -> Option C

4. Quick Check:

   Image missing? Build it first [OK]

Hint: Build image before running container [OK]

Common Mistakes:

• Trying to push image before building
• Restarting Docker without reason
• Deleting containers unrelated to image error

5. How does Docker help teams avoid the 'works on my machine' problem during development?

hard

A. By forcing all developers to use the same operating system

B. By packaging the app with its environment so it runs identically on all machines

C. By automatically fixing code bugs across different computers

D. By requiring developers to install all dependencies manually

Solution

1. Step 1: Identify the 'works on my machine' issue

   This problem happens when code runs on one computer but fails on another due to environment differences.

2. Step 2: Explain Docker's solution

   Docker packages the app with all needed software and settings, so it runs the same everywhere, avoiding this problem.

3. Final Answer:

   By packaging the app with its environment so it runs identically on all machines -> Option B

4. Quick Check:

   Package environment = fix 'works on my machine' [OK]

Hint: Docker packages app + environment for consistency [OK]

Common Mistakes:

• Thinking Docker forces OS uniformity
• Believing Docker fixes code bugs automatically
• Assuming manual dependency installs are needed