Consistent environments across teams in Docker - Commands & Configuration

Introduction

Different team members often have different software versions and settings on their computers. This causes apps to work on one machine but fail on another. Docker solves this by packaging the app and its environment together, so everyone runs the same setup.

When developers want to avoid the 'it works on my machine' problem.

When you want to share your app with testers who have different computers.

When you need to deploy the app to servers that might have different software installed.

When you want to quickly onboard new team members with the exact environment.

When you want to run multiple apps on the same machine without conflicts.

Config File - Dockerfile

Dockerfile

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

This Dockerfile creates a small Python 3.11 environment.

FROM python:3.11-slim sets the base image with Python installed.

WORKDIR /app sets the working folder inside the container.

COPY requirements.txt ./ copies the list of Python packages.

RUN pip install installs the packages inside the container.

COPY . . copies your app code into the container.

CMD runs your app when the container starts.

Commands

This command builds a Docker image named 'my-app' with tag '1.0' using the Dockerfile in the current folder. It packages your app and its environment together.

Terminal

docker build -t my-app:1.0 .

Expected Output

Sending build context to Docker daemon  5.12kB

Step 1/6 : FROM python:3.11-slim

 ---> 123abc456def

Step 2/6 : WORKDIR /app

 ---> Using cache

 ---> 789def012abc

Step 3/6 : COPY requirements.txt ./

 ---> Using cache

 ---> 345ghi678jkl

Step 4/6 : RUN pip install --no-cache-dir -r requirements.txt

 ---> 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/6 : COPY . .

 ---> Using cache

 ---> stu567vwx890

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

 ---> Running in xyz123abc456

Removing intermediate container xyz123abc456

 ---> 789stu012vwx

Successfully built 789stu012vwx

Successfully tagged my-app:1.0

→

-t - Assigns a name and tag to the image for easy reference

This command runs the 'my-app:1.0' image in a container, removes it after stopping, and maps port 5000 inside the container to port 5000 on your computer so you can access the app.

Terminal

docker run --rm -p 5000:5000 my-app:1.0

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)

→

--rm - Automatically removes the container when it stops

→

-p - Maps a port from the container to the host machine

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

Terminal

docker ps

Expected Output

CONTAINER ID   IMAGE       COMMAND                  CREATED          STATUS          PORTS                    NAMES

789stu012vwx   my-app:1.0  "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 end the app.

Terminal

docker stop loving_morse

Expected Output

loving_morse

Key Concept

If you remember nothing else from this pattern, remember: Docker packages your app and its environment together so everyone runs the exact same setup.

Common Mistakes

Not copying all necessary files into the Docker image.

The app will fail inside the container because required files or code are missing.

Use COPY commands in the Dockerfile to include all needed files and folders.

Forgetting to map ports when running the container.

You cannot access the app from your computer because the container's ports are isolated.

Use the -p flag to map container ports to your computer's ports.

Running the app without building the image first.

Docker will not find the image and the run command will fail.

Always run docker build before docker run to create the image.

Summary

Create a Dockerfile to define your app environment and dependencies.

Build the Docker image with docker build to package your app and environment.

Run the container with docker run, mapping ports to access the app.

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

Practice

1. Why is Docker useful for maintaining consistent environments across teams?

easy

A. It packages the app and its environment together in a container.

B. It automatically writes code for the team.

C. It replaces the need for version control systems.

D. It runs apps only on Windows machines.

Solution

1. Step 1: Understand Docker container purpose

   Docker containers bundle the app with all its dependencies and environment settings.

2. Step 2: Compare options to Docker's role

   Only the option stating "It packages the app and its environment together in a container." describes packaging app and environment together, ensuring consistency.

3. Final Answer:

   It packages the app and its environment together in a container. -> Option A

4. Quick Check:

   Docker = consistent app environment [OK]

Hint: Docker bundles app + environment for all team members [OK]

Common Mistakes:

• Thinking Docker writes code automatically
• Confusing Docker with version control
• Believing Docker only works on Windows

2. Which of the following is the correct way to start a Docker container named webapp from an image called myapp:latest?

easy

A. docker build webapp myapp:latest

B. docker start myapp:latest webapp

C. docker create webapp myapp:latest

D. docker run --name webapp myapp:latest

Solution

1. Step 1: Recall Docker run syntax

   The command to start a container with a name is: docker run --name [container_name] [image]

2. Step 2: Match the correct command

   docker run --name webapp myapp:latest matches this syntax exactly, starting container 'webapp' from image 'myapp:latest'.

3. Final Answer:

   docker run --name webapp myapp:latest -> Option D

4. Quick Check:

   docker run --name = start container with name [OK]

Hint: Use 'docker run --name' to start named container [OK]

Common Mistakes:

• Using 'docker start' to create container
• Confusing 'docker create' with 'docker run'
• Using 'docker build' to start containers

3. Given this Dockerfile snippet:

FROM python:3.12-slim
WORKDIR /app
COPY . /app
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

What happens when you build and run this Docker image on different team members' machines?

medium

A. The app runs only if all team members have Python installed locally.

B. The app will fail because Python versions differ on each machine.

C. Each team member runs the app in the exact same environment regardless of their OS.

D. The app runs slower on Windows than Linux due to Docker limitations.

Solution

1. Step 1: Analyze Dockerfile purpose

   The Dockerfile sets up a Python 3.12 environment inside a container, independent of host OS.

2. Step 2: Understand container consistency

   Because the container includes Python and dependencies, all team members get the same environment.

3. Final Answer:

   Each team member runs the app in the exact same environment regardless of their OS. -> Option C

4. Quick Check:

   Docker container = consistent environment [OK]

Hint: Dockerfile builds same environment on all machines [OK]

Common Mistakes:

• Assuming local Python is needed
• Believing OS affects container environment
• Thinking Docker slows app on Windows

4. A team member runs docker run myapp but gets an error: Cannot find image 'myapp' locally. What is the likely cause and fix?

medium

A. Docker is not installed; install Docker to fix this.

B. The image 'myapp' is not built locally; run docker build -t myapp . first.

C. The container name is missing; add --name myapp to the command.

D. The Dockerfile is missing; create a Dockerfile to fix this.

Solution

1. Step 1: Understand error meaning

   The error means Docker cannot find the image 'myapp' locally or on Docker Hub.

2. Step 2: Identify fix

   Building the image locally with docker build -t myapp . creates the image for use.

3. Final Answer:

   The image 'myapp' is not built locally; run docker build -t myapp . first. -> Option B

4. Quick Check:

   Image missing? Build it first [OK]

Hint: Build image before running container [OK]

Common Mistakes:

• Thinking Docker is not installed
• Confusing container name with image name
• Assuming Dockerfile absence causes this error

5. Your team wants to ensure everyone uses the same database version inside Docker containers. Which approach best guarantees this consistency?

hard

A. Create a Docker Compose file specifying the exact database image version and share it with the team.

B. Ask each team member to install the database manually on their machine.

C. Use environment variables to let each member choose their preferred database version.

D. Run the database directly on the host OS instead of in Docker.

Solution

1. Step 1: Understand Docker Compose role

   Docker Compose lets you define multi-container setups with exact image versions in one file.

2. Step 2: Evaluate options for consistency

   Sharing a Compose file with fixed database image version ensures all run the same version easily.

3. Step 3: Reject other options

   Manual installs or letting members choose versions cause inconsistency; running on host loses container benefits.

4. Final Answer:

   Create a Docker Compose file specifying the exact database image version and share it with the team. -> Option A

5. Quick Check:

   Compose file = consistent multi-container setup [OK]

Hint: Use Docker Compose with fixed image versions [OK]

Common Mistakes:

• Relying on manual installs for consistency
• Allowing different versions via environment variables
• Running services outside Docker containers