Port mapping with -p flag in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Understanding basic port mapping with Docker -p flag

What is the output when you run the command docker run -d -p 8080:80 nginx and then check the port mapping with docker port <container_id>?

A 80/tcp -> 0.0.0.0:8080

B 8080/tcp -> 127.0.0.1:80

C 80/tcp -> 127.0.0.1:8080

D 8080/tcp -> 0.0.0.0:80

💡 Hint

Remember the format is :.

The -p 8080:80 flag maps port 8080 on the host to port 80 inside the container. The docker port command shows this mapping as 80/tcp -> 0.0.0.0:8080.

🧠 Conceptual

intermediate

Effect of omitting host IP in port mapping

When using docker run -p 127.0.0.1:8080:80 nginx, what is the difference compared to docker run -p 8080:80 nginx?

A The container port 80 is accessible from any IP on the host network.

B The container port 80 is only accessible from localhost (127.0.0.1) on the host.

C The container port 80 is not accessible at all.

D The container port 80 is mapped to port 127.0.0.1 on the container.

💡 Hint

Think about binding to a specific IP address on the host.

Specifying 127.0.0.1:8080:80 binds the port only to localhost on the host machine, so it is not accessible from other machines on the network.

❓ Troubleshoot

advanced

Diagnosing port conflict error with Docker -p flag

You run docker run -p 80:80 nginx but get an error: Bind for 0.0.0.0:80 failed: port is already allocated. What is the most likely cause?

A Another process on the host is already using port 80.

B The container image does not expose port 80.

C Docker daemon is not running.

D The container port 80 is blocked by firewall inside the container.

💡 Hint

Check what is using port 80 on your host machine.

The error means the host port 80 is busy, so Docker cannot bind the container port 80 to it. You can check with sudo lsof -i :80 or similar.

🔀 Workflow

advanced

Correct order to expose and map ports in Dockerfile and run command

Which is the correct order of steps to expose port 5000 in a Dockerfile and map it to host port 3000 when running the container?

A 2,1,3,4

B 3,1,2,4

C 1,3,2,4

D 1,2,3,4

💡 Hint

Think about building the image after editing the Dockerfile.

You first add EXPOSE in the Dockerfile, then build the image, then run the container with port mapping, and finally verify the mapping.

✅ Best Practice

expert

Choosing the safest port mapping for a public web app

You want to run a web app in Docker accessible from the internet on port 80, but avoid exposing the container port directly to all interfaces. Which command is the safest choice?

A docker run -p 0.0.0.0:80:80 mywebapp

B docker run -p 127.0.0.1:80:80 mywebapp

C docker run -p 192.168.1.100:80:80 mywebapp

D docker run -p 80:80 mywebapp

💡 Hint

Consider binding to a specific public IP address of your host.

Binding to 192.168.1.100 (a specific host IP) exposes the app only on that interface, reducing risk compared to binding to all interfaces (0.0.0.0). Binding to localhost (127.0.0.1) would block external access.

Practice

1.

What does the -p flag do in the docker run command?

easy

A. Names the container

B. Sets the container's CPU limit

C. Maps a port on the host to a port in the container

D. Specifies the container's environment variables

Solution

1. Step 1: Understand the purpose of the -p flag

   The -p flag is used to connect a port on your computer (host) to a port inside the Docker container.

2. Step 2: Identify what port mapping means

   This mapping allows you to access services running inside the container from your host machine using the specified port.

3. Final Answer:

   Maps a port on the host to a port in the container -> Option C

4. Quick Check:

   -p flag = port mapping [OK]

Hint: Remember: -p connects host port to container port [OK]

Common Mistakes:

• Confusing -p with CPU or memory limits
• Thinking -p sets container name
• Assuming -p sets environment variables

2.

Which of the following is the correct syntax to map host port 8080 to container port 80?

docker run -p ??? image_name

easy

A. -p 8080:80

B. -p 80:8080

C. -p 8080-80

D. -p 80-8080

Solution

1. Step 1: Recall the port mapping format

   The correct format is -p host_port:container_port, so the host port comes first.

2. Step 2: Apply the ports given

   Host port is 8080, container port is 80, so it should be -p 8080:80.

3. Final Answer:

   -p 8080:80 -> Option A

4. Quick Check:

   Host port first, container port second [OK]

Hint: Host port comes before container port in -p [OK]

Common Mistakes:

• Swapping host and container ports
• Using dash (-) instead of colon (:)
• Using invalid port range syntax

3.

What will happen if you run this command?
docker run -p 5000:80 nginx
Then open http://localhost:5000 in your browser?

medium

A. Nothing happens because port 5000 is not mapped

B. You will see the default Nginx welcome page

C. You will see a Docker error about port mapping

D. Connection refused error because port 80 is blocked

Solution

1. Step 1: Understand the port mapping

   The command maps host port 5000 to container port 80 where Nginx serves its default page.

2. Step 2: Accessing the service

   Opening http://localhost:5000 accesses the container's port 80 service, showing Nginx's default page.

3. Final Answer:

   You will see the default Nginx welcome page -> Option B

4. Quick Check:

   Port 5000 maps to Nginx port 80, page loads [OK]

Hint: Host port maps to container port, access via host port [OK]

Common Mistakes:

• Thinking port 80 on host is used
• Assuming port mapping causes errors
• Not realizing Nginx serves on port 80 inside container

4.

What is wrong with this command?
docker run -p 80:8080 myapp

The app inside the container listens on port 8080.

medium

A. Host port 80 is mapped to container port 8080, which is correct

B. The ports are reversed; it should be -p 8080:80

C. The container port should be 80 if the app listens on 8080

D. Nothing is wrong; this command works as expected

Solution

1. Step 1: Check the app's listening port

   The app listens on container port 8080, so container port must be 8080 in mapping.

2. Step 2: Verify the port mapping syntax

   The command maps host port 80 to container port 8080, which is correct to expose app on host port 80.

3. Final Answer:

   Host port 80 is mapped to container port 8080, which is correct -> Option A

4. Quick Check:

   Host:container = 80:8080 is valid [OK]

Hint: Remember: host port first, container port second [OK]

Common Mistakes:

• Swapping host and container ports
• Assuming container port must be 80
• Confusing app listening port with host port

5.

You want to run two containers from the same image that both expose port 80 inside the container. How can you map their ports so both are accessible on your host machine?

hard

A. You cannot run two containers exposing the same port

B. Use -p 80:80 for both containers

C. Use -p 80:8080 for the first and -p 80:8081 for the second

D. Use -p 8080:80 for the first and -p 8081:80 for the second container

Solution

1. Step 1: Understand port conflicts on host

   Two containers cannot map the same host port (like 80) simultaneously because the host port must be unique.

2. Step 2: Assign different host ports

   Map the first container's port 80 to host port 8080, and the second container's port 80 to host port 8081 to avoid conflicts.

3. Final Answer:

   Use -p 8080:80 for the first and -p 8081:80 for the second container -> Option D

4. Quick Check:

   Different host ports avoid conflicts [OK]

Hint: Use different host ports for multiple containers [OK]

Common Mistakes:

• Trying to map both containers to host port 80
• Swapping host and container ports
• Thinking containers can share the same host port