Defining services in Docker - Step-by-Step Execution

Process Flow - Defining services

Write docker-compose.yml

↓

Define service name

↓

Specify image or build

↓

Set ports, volumes, environment

↓

Save and run 'docker-compose up'

↓

Docker creates containers for each service

↓

Services start and communicate

This flow shows how you write a docker-compose file to define services, then run them as containers.

Execution Sample

Docker

version: '3.8'
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"

Defines a single service named 'web' using the nginx image and maps port 8080 on the host to port 80 in the container.

Process Table

Step	Action	Details	Result
1	Read docker-compose.yml	Parse version and services	Recognizes 'web' service with nginx image
2	Create container for 'web'	Pull nginx:latest image if missing	Image downloaded or found locally
3	Map ports	Host 8080 to container 80	Port forwarding set up
4	Start container	Run nginx inside container	Container running and listening on port 80
5	Verify service	Access localhost:8080	Nginx welcome page served
6	Exit	No more steps	Setup complete, services running

💡 All services defined and started successfully

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
services.web.image	undefined	nginx:latest	nginx:latest	nginx:latest	nginx:latest
services.web.ports	undefined	undefined	["8080:80"]	["8080:80"]	["8080:80"]
container.web.status	not created	created	created	running	running

Key Moments - 3 Insights

Why do we specify ports in the service definition?

Ports map the container's internal port to the host machine so you can access the service from outside. See execution_table step 3 where port 8080 is mapped to 80.

What happens if the image is not on the local machine?

Docker pulls the image from the registry before creating the container, as shown in execution_table step 2.

How does Docker know which services to start?

Docker reads the 'services' section in the compose file and creates containers for each service listed, shown in step 1 and 4.

Visual Quiz - 3 Questions

Look at the execution table, at which step is the container actually started?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Check the 'Action' and 'Result' columns for when the container status changes to running.

According to the variable tracker, what is the status of the container after step 3?

A not created

B running

C created

D stopped

💡 Hint

Look at 'container.web.status' value under 'After Step 3' column.

If we remove the ports section from the service, what changes in the execution?

A Container will not start

B Service will start but not accessible from host

C Image will not be pulled

D Docker-compose will throw an error

💡 Hint

Refer to the role of ports in execution_table step 3 and key moments about port mapping.

Concept Snapshot

Defining services in docker-compose:
- Use 'services:' to list containers
- Each service needs an image or build context
- Map ports to access services externally
- Run with 'docker-compose up' to start all services
- Docker pulls images if missing and creates containers
- Services communicate via network automatically

Full Transcript

Defining services in Docker means writing a docker-compose.yml file where you list each service by name. For each service, you specify an image or build instructions, ports to expose, and other settings like volumes or environment variables. When you run 'docker-compose up', Docker reads this file, pulls any missing images, creates containers for each service, sets up port forwarding, and starts the containers. This lets you run multiple connected services easily. The execution table shows each step from reading the file to starting the container. The variable tracker shows how service properties and container status change step by step. Key moments clarify why ports are needed and how images are pulled. The quiz tests understanding of when containers start, container status, and the effect of removing ports.

Practice

1. What is the main purpose of defining services in a Docker Compose file?

easy

A. To install software inside containers manually

B. To write shell scripts for container startup

C. To group containers with their settings for easy management

D. To create virtual machines inside Docker

Solution

1. Step 1: Understand the role of services in Docker Compose

   Services define how containers run, including images, ports, and environment variables.

2. Step 2: Recognize the benefit of grouping containers

   Grouping containers with their settings allows easy start, stop, and management of multiple containers together.

3. Final Answer:

   To group containers with their settings for easy management -> Option C

4. Quick Check:

   Services group containers = D [OK]

Hint: Services group containers and settings in one file [OK]

Common Mistakes:

• Confusing services with scripts
• Thinking services create virtual machines
• Believing services install software manually

2. Which of the following is the correct way to define a service named web using the image nginx in a Docker Compose YAML file?

easy

A. services:
web:
image: nginx

B. services:
web:
image nginx

C. service:
web:
image: nginx

D. services:
web:
img: nginx

Solution

1. Step 1: Check the correct YAML key for services

   The top-level key must be services (plural), not service.

2. Step 2: Verify the syntax for image definition

   The correct syntax is image: nginx with a colon and proper indentation.

3. Final Answer:

   services: web: image: nginx -> Option A

4. Quick Check:

   Correct YAML keys and syntax = B [OK]

Hint: Use 'services:' plural and 'image:' with colon [OK]

Common Mistakes:

• Using 'service' instead of 'services'
• Missing colon after 'image'
• Using 'img' instead of 'image'

3. Given this Docker Compose snippet, what port will be accessible on the host machine?

services:
  app:
    image: myapp
    ports:
      - "8080:80"

medium

A. Port 80 on the host

B. Port 8080 on the host

C. Port 80 inside the container only

D. Port 8080 inside the container only

Solution

1. Step 1: Understand port mapping syntax

   The format "host_port:container_port" means host port 8080 maps to container port 80.

2. Step 2: Identify which port is exposed on the host

   Port 8080 on the host machine will forward traffic to port 80 inside the container.

3. Final Answer:

   Port 8080 on the host -> Option B

4. Quick Check:

   Host port is first in mapping = A [OK]

Hint: Host port is before colon in ports mapping [OK]

Common Mistakes:

• Confusing host and container ports
• Thinking container port is exposed on host
• Ignoring quotes around ports

4. Identify the error in this Docker Compose service definition:

services:
  db:
    image: postgres
    ports:
      - "5432:"
    environment:
      POSTGRES_PASSWORD: example

medium

A. Missing container port in ports mapping

B. Environment variable name is incorrect

C. Image name should be capitalized

D. Service name cannot be 'db'

Solution

1. Step 1: Check ports syntax

   Ports must be mapped as "host_port:container_port" or just container port. Here, "5432:" is invalid because missing container port after colon.

2. Step 2: Confirm environment and image correctness

   Environment variable and image name are correct; service name 'db' is valid.

3. Final Answer:

   Missing container port in ports mapping -> Option A

4. Quick Check:

   Ports need host:container or container port only = A [OK]

Hint: Ports need host:container or container port only [OK]

Common Mistakes:

• Using only one port number with quotes
• Assuming environment variable names are wrong
• Thinking service names have restrictions

5. You want to define two services, frontend and backend, where frontend depends on backend to start first. Which is the correct way to express this dependency in Docker Compose?

hard

A. services:
frontend:
image: frontend-image
backend:
image: backend-image
depends_on:
- frontend

B. services:
backend:
image: backend-image
depends_on:
- frontend
frontend:
image: frontend-image

C. services:
frontend:
image: frontend-image
links:
- backend
backend:
image: backend-image

D. services:
frontend:
image: frontend-image
depends_on:
- backend
backend:
image: backend-image

Solution

1. Step 1: Understand 'depends_on' usage

   The depends_on key under a service lists services that must start before it.

2. Step 2: Identify correct dependency direction

   Since frontend depends on backend, frontend should have depends_on: - backend.

3. Step 3: Check other options for correctness

   The incorrect options either reverse the dependency direction or use the deprecated links for dependency control.

4. Final Answer:

   services: frontend: image: frontend-image depends_on: - backend backend: image: backend-image -> Option D

5. Quick Check:

   depends_on under dependent service = C [OK]

Hint: Put depends_on under service that waits for others [OK]

Common Mistakes:

• Reversing dependency direction
• Using links instead of depends_on
• Placing depends_on under wrong service