Port mapping in Compose in Docker - Commands & Configuration

Introduction

Port mapping in Docker Compose lets you connect your app running inside a container to your computer's network. This way, you can access the app from your browser or other tools outside the container.

When you want to run a web app inside a container and access it from your browser on your computer.

When multiple containers run on the same machine and you want to avoid port conflicts by mapping different ports.

When you need to expose a database or service running in a container to other apps on your local network.

When testing an app locally that listens on a specific port inside the container.

When sharing your app with teammates who connect to your machine's IP and port.

Config File - docker-compose.yml

docker-compose.yml

version: '3.8'
services:
  webapp:
    image: nginx:1.23
    ports:
      - "8080:80"

This file defines a service named webapp using the official nginx image version 1.23.

The ports section maps port 8080 on your computer to port 80 inside the container, where nginx listens by default.

This means when you open http://localhost:8080 in your browser, you see the nginx welcome page served from inside the container.

Commands

This command starts the containers defined in the docker-compose.yml file in detached mode, so they run in the background.

Terminal

docker-compose up -d

Expected Output

Creating network "default" with the default driver

Creating webapp ... done

→

-d - Run containers in the background (detached mode)

This command lists the running containers started by docker-compose, showing their status and port mappings.

Terminal

docker-compose ps

Expected Output

    Name                  Command               State           Ports         

----------------------------------------------------------------------------

webapp           nginx -g 'daemon off;'        Up      0.0.0.0:8080->80/tcp

This command fetches the default web page served by nginx inside the container through the mapped port 8080 on your computer.

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>

This command stops and removes the containers, networks, and other resources created by docker-compose.

Terminal

docker-compose down

Expected Output

Stopping webapp ... done

Removing webapp ... done

Removing network default

Key Concept

If you remember nothing else from port mapping in Compose, remember: the format "host_port:container_port" connects your computer's port to the container's port.

Common Mistakes

Using the wrong port order like "80:8080" instead of "8080:80"

This maps the container's port 8080 to host port 80, which may not be what your app listens on, causing connection failures.

Always write host port first, then container port, like "8080:80" to map host port 8080 to container port 80.

Not exposing the container port in the Dockerfile or app configuration

If the app inside the container does not listen on the port you map, the connection will fail even if port mapping is correct.

Ensure the app inside the container listens on the container port you map, e.g., port 80 for nginx.

Trying to map a host port already in use by another service

Docker will fail to start the container because the host port is busy, causing errors.

Choose a free host port or stop the service using that port before running docker-compose.

Summary

Create a docker-compose.yml file with a ports section to map host ports to container ports.

Use 'docker-compose up -d' to start containers in the background with port mapping active.

Verify running containers and port mappings with 'docker-compose ps'.

Access the app on your computer using the host port you mapped.

Stop and clean up containers with 'docker-compose down' when done.

Practice

1. What does the ports section in a Docker Compose file do?

easy

A. It defines the container's CPU and memory limits.

B. It sets environment variables inside the container.

C. It specifies the container's restart policy.

D. It maps ports from the host machine to the container ports.

Solution

1. Step 1: Understand the role of ports in Compose

   The ports section connects a port on your computer (host) to a port inside the container.

2. Step 2: Identify what ports does not do

   It does not set environment variables, resource limits, or restart policies.

3. Final Answer:

   It maps ports from the host machine to the container ports. -> Option D

4. Quick Check:

   Port mapping = connecting host to container ports [OK]

Hint: Ports section maps host ports to container ports [OK]

Common Mistakes:

• Confusing ports with environment variables
• Thinking ports set resource limits
• Mixing ports with restart policies

2. Which of the following is the correct syntax to map port 8080 on the host to port 80 in a Docker Compose service?

easy

A. ports:
- "8080:80"

B. ports:
- "80"

C. ports:
- "8080"

D. ports:
- "80:8080"

Solution

1. Step 1: Understand port mapping format

   The format is host_port:container_port. To map host 8080 to container 80, write "8080:80".

2. Step 2: Check each option

   ports: - "80:8080" reverses ports, mapping host 80 to container 8080, which is incorrect. Options B and C specify only one port, which publishes the container port to a randomly assigned host port, not specific host 8080.

3. Final Answer:

   ports: - "8080:80" -> Option A

4. Quick Check:

   Host port first, container port second [OK]

Hint: Remember format: host_port:container_port [OK]

Common Mistakes:

• Reversing host and container ports
• Using single port without mapping
• Incorrect YAML indentation

3. Given this Compose snippet:

services:
  web:
    image: nginx
    ports:
      - "5000:80"

What happens when you open http://localhost:5000 in your browser?

medium

A. You get a connection refused error because port 80 is not exposed.

B. You access the Nginx server running inside the container on port 80.

C. You access port 5000 inside the container, which is not running any service.

D. The browser will show the Docker Compose file content.

Solution

1. Step 1: Understand port mapping in the snippet

   Port 5000 on the host is mapped to port 80 inside the container where Nginx listens.

2. Step 2: Explain browser behavior

   Opening http://localhost:5000 sends requests to container's port 80, so you reach the Nginx server.

3. Final Answer:

   You access the Nginx server running inside the container on port 80. -> Option B

4. Quick Check:

   Host port 5000 maps to container port 80 [OK]

Hint: Host port connects to container port service [OK]

Common Mistakes:

• Thinking port 80 is not exposed
• Confusing host and container ports
• Expecting file content instead of service

4. You wrote this Compose ports mapping:

ports:
  - "80:8080"

But your app inside the container listens on port 8080. Why can't you access it via http://localhost:80?

medium

A. The container port 8080 is not exposed correctly to the host port 80.

B. The ports are reversed; host port should be 8080 and container port 80.

C. The app inside the container is not running on port 8080.

D. The Compose file syntax is invalid.

Solution

1. Step 1: Analyze the port mapping

   Mapping "80:8080" means host port 80 connects to container port 8080.

2. Step 2: Identify the problem

   If access fails, likely the container app is not listening on port 8080 or firewall blocks host port 80. The mapping syntax is correct.

3. Final Answer:

   The app inside the container is not running on port 8080. -> Option C

4. Quick Check:

   Check app listens on container port [OK]

Hint: Check app listens on container port, not just mapping [OK]

Common Mistakes:

• Assuming ports reversed when they are correct
• Ignoring app's actual listening port
• Blaming syntax without checking app

5. You want to run two services in Compose: a web app on container port 3000 and an API on container port 5000. You want to access them on host ports 3000 and 5000 respectively. Which Compose ports section is correct?

hard

A. web:
ports:
- "3000:3000"
api:
ports:
- "5000:5000"

B. web:
ports:
- "3000:80"
api:
ports:
- "5000:80"

C. web:
ports:
- "80:3000"
api:
ports:
- "80:5000"

D. web:
ports:
- "3000"
api:
ports:
- "5000"

Solution

1. Step 1: Match host and container ports

   To access web on host 3000 and container 3000, map "3000:3000". Similarly for API, map "5000:5000".

2. Step 2: Check other options

   web: ports: - "3000:80" api: ports: - "5000:80" maps container ports incorrectly to 80. web: ports: - "80:3000" api: ports: - "80:5000" reverses ports. web: ports: - "3000" api: ports: - "5000" uses short syntax without mapping, which assigns random host ports.

3. Final Answer:

   web: ports: - "3000:3000" api: ports: - "5000:5000" -> Option A

4. Quick Check:

   Host and container ports must match for access [OK]

Hint: Map host port to same container port for easy access [OK]

Common Mistakes:

• Reversing host and container ports
• Using single port without mapping
• Mapping both services to same container port