Exposing ports to host in Docker - Commands & Configuration

Introduction

Sometimes, you run an app inside a container, but you want to use it from your computer or other devices. Exposing ports lets your computer talk to the app inside the container through specific doors called ports.

When you want to access a web server running inside a container from your browser on your computer.

When you run a database in a container and want your local apps to connect to it.

When you develop an API inside a container and need to test it from outside the container.

When you want to share a service running in a container with other devices on your network.

When you need to debug or monitor a containerized app by connecting to its exposed ports.

Commands

This command runs an Nginx web server container in the background and exposes port 80 inside the container to port 8080 on your computer. This means you can open your browser and go to localhost:8080 to see the web page.

Terminal

docker run -d -p 8080:80 nginx

Expected Output

a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z6a7b8c9d0e1f2

→

-d - Run the container in detached mode (in the background).

→

-p - Map a port on the host to a port in the container.

This command lists all running containers so you can check if your Nginx container is running and see the port mapping.

Terminal

docker ps

Expected Output

CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                   NAMES

a1b2c3d4e5f6   nginx     "/docker-entrypoint.…"   10 seconds ago   Up 9 seconds    0.0.0.0:8080->80/tcp    loving_morse

This command fetches the web page served by Nginx through the exposed port 8080 on your computer, showing that the port mapping works.

Terminal

curl http://localhost:8080

Expected Output

<!DOCTYPE html>

<html>

<head>

<title>Welcome to nginx!</title>

</head>

<body>

<h1>Welcome to nginx!</h1>

</body>

</html>

Key Concept

If you remember nothing else from this pattern, remember: exposing ports with -p lets your computer talk to apps inside containers through specific ports.

Common Mistakes

Not using the -p flag when running the container.

Without -p, the container's ports are not accessible from your computer, so you cannot reach the app.

Always use -p host_port:container_port to expose the container's port to your computer.

Using the same host port for multiple containers without changing it.

Host ports must be unique; otherwise, Docker will give an error because the port is already in use.

Use different host ports for each container, like -p 8080:80 and -p 8081:80.

Exposing the wrong container port (e.g., -p 8080:8080 when the app listens on 80).

If the container port does not match the app's listening port, the app won't be reachable through the mapped port.

Check the app's internal port and map that port to a host port, like -p 8080:80 for Nginx.

Summary

Use docker run with -p host_port:container_port to expose container ports to your computer.

Check running containers and port mappings with docker ps.

Test access to the containerized app through the exposed host port using curl or a browser.

Practice

1.

What does the Docker option -p 8080:80 do when running a container?

easy

A. It maps port 8080 inside the container to port 80 on the host machine.

B. It maps port 80 inside the container to port 8080 on the host machine.

C. It exposes port 8080 inside the container without mapping to the host.

D. It blocks port 80 on the host machine.

Solution

1. Step 1: Understand Docker port mapping syntax

   The syntax -p host_port:container_port means the host port is on the left and container port is on the right.

2. Step 2: Apply to given ports

   Given -p 8080:80, port 80 inside the container is accessible via port 8080 on the host.

3. Final Answer:

   It maps port 80 inside the container to port 8080 on the host machine. -> Option B

4. Quick Check:

   host_port:container_port = 8080:80 [OK]

Hint: Remember host port is before colon, container port after [OK]

Common Mistakes:

• Confusing host and container ports order
• Thinking ports are blocked instead of mapped
• Assuming ports are exposed but not mapped

2.

Which of the following is the correct Docker command to expose container port 5000 to host port 3000?

docker run ... myapp

easy

A. docker run -p 3000:5000 myapp

B. docker run -p 5000 myapp

C. docker run --expose 3000:5000 myapp

D. docker run -p 5000:3000 myapp

Solution

1. Step 1: Recall port mapping syntax

   The correct syntax is -p host_port:container_port.

2. Step 2: Match ports to command

   To expose container port 5000 on host port 3000, use -p 3000:5000.

3. Final Answer:

   docker run -p 3000:5000 myapp -> Option A

4. Quick Check:

   host_port:container_port = 3000:5000 [OK]

Hint: Host port is always before colon in -p option [OK]

Common Mistakes:

• Swapping host and container ports
• Using --expose with port mapping syntax
• Omitting container port in -p option

3.

What will be the output when running this command and then accessing http://localhost:8080?

docker run -d -p 8080:80 nginx

medium

A. Docker will throw a syntax error and not run.

B. Connection refused error because port 80 is not exposed.

C. The container will run but port 8080 will be closed.

D. You will see the default Nginx welcome page in your browser.

Solution

1. Step 1: Understand the command

   The command runs Nginx container detached with port 80 inside mapped to host port 8080.

2. Step 2: Accessing localhost:8080

   Since port 8080 on host maps to container's port 80 where Nginx serves, accessing localhost:8080 shows Nginx default page.

3. Final Answer:

   You will see the default Nginx welcome page in your browser. -> Option D

4. Quick Check:

   Port mapping works, Nginx serves on port 80 [OK]

Hint: Map container port 80 to host to access web server [OK]

Common Mistakes:

• Assuming port 80 is not exposed automatically
• Expecting syntax error from correct command
• Thinking container runs but ports are closed

4.

Identify the error in this Docker command that tries to expose port 3306:

docker run -p 3306: mysql

medium

A. Missing container port in the -p option.

B. Port 3306 is not allowed to be exposed.

C. The image name 'mysql' is incorrect.

D. The command should use --expose instead of -p.

Solution

1. Step 1: Check -p option syntax

   The -p option requires both host and container ports in host_port:container_port format.

2. Step 2: Analyze given command

   The command uses -p 3306: without specifying container port, which is invalid syntax.

3. Final Answer:

   Missing container port in the -p option. -> Option A

4. Quick Check:

   -p requires host_port:container_port [OK]

Hint: Always specify both host and container ports with -p [OK]

Common Mistakes:

• Using only one port number with -p
• Confusing --expose and -p options
• Assuming image name causes port errors

5.

You want to run two containers both exposing port 80 inside, but accessible on host ports 8081 and 8082 respectively. Which Docker commands correctly achieve this?

hard

A. docker run -d -p 8081:8081 app1 && docker run -d -p 8082:8082 app2

B. docker run -d -p 80:8081 app1 && docker run -d -p 80:8082 app2

C. docker run -d -p 8081:80 app1 && docker run -d -p 8082:80 app2

D. docker run -d --expose 8081:80 app1 && docker run -d --expose 8082:80 app2

Solution

1. Step 1: Understand port mapping for multiple containers

   Each container exposes port 80 internally. To avoid conflict, map to different host ports like 8081 and 8082.

2. Step 2: Check each option's correctness

   docker run -d -p 8081:80 app1 && docker run -d -p 8082:80 app2 correctly maps host ports 8081 and 8082 to container port 80 for app1 and app2 respectively. Others misuse port order or --expose.

3. Final Answer:

   docker run -d -p 8081:80 app1 && docker run -d -p 8082:80 app2 -> Option C

4. Quick Check:

   Host ports differ, container ports 80 mapped correctly [OK]

Hint: Map different host ports to same container port for multiple containers [OK]

Common Mistakes:

• Swapping host and container ports
• Using same host port for multiple containers
• Confusing --expose with port mapping