Docker basics review in Microservices - System Design Exercise

Design: Microservices Application with Docker

Focus on Docker containerization basics for microservices including image creation, container lifecycle, networking, and volume management. Out of scope: advanced orchestration (Kubernetes), CI/CD pipelines, and cloud deployment specifics.

Functional Requirements

FR1: Package multiple microservices independently using Docker containers

FR2: Ensure each microservice can be built, tested, and deployed separately

FR3: Allow easy scaling of individual microservices

FR4: Enable communication between microservices securely

FR5: Support local development and production deployment using Docker

Non-Functional Requirements

NFR1: Each container should start within 5 seconds

NFR2: System should support scaling up to 1000 concurrent users

NFR3: Containers must be isolated to avoid conflicts

NFR4: Images should be optimized to reduce size and startup time

NFR5: Use Docker features only, no external orchestration tools

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

Dockerfile for building images

Docker CLI commands for container management

Docker networking for inter-container communication

Docker volumes for persistent data

Docker Compose for multi-container setups

Design Patterns

Microservice containerization

Service discovery via Docker networking

Immutable container images

Layered image builds for optimization

Container health checks

Reference Architecture

 +----------------+      +----------------+      +----------------+
 | Microservice A | <--> | Docker Network | <--> | Microservice B |
 +----------------+      +----------------+      +----------------+
         |                        |                        |
         v                        v                        v
 +----------------+      +----------------+      +----------------+
 | Docker Volume  |      | Docker Host OS |      | Docker Volume  |
 +----------------+      +----------------+      +----------------+

Components

Dockerfile

Docker

Defines how to build a container image for each microservice

Docker CLI

Docker

Manages container lifecycle: build, run, stop, remove

Docker Network

Docker

Enables communication between containers securely

Docker Volume

Docker

Provides persistent storage for containers

Docker Compose

Docker

Defines and runs multi-container Docker applications

Request Flow

1. Developer writes Dockerfile for each microservice specifying base image, dependencies, and startup commands.

2. Docker CLI builds images from Dockerfiles, creating layered, reusable images.

3. Containers are started from images using Docker run commands or Docker Compose.

4. Docker Network connects containers allowing microservices to communicate via service names.

5. Docker Volumes attach to containers for persistent data storage beyond container lifecycle.

6. Requests from users reach microservices through exposed container ports mapped to host ports.

7. Microservices communicate internally over Docker Network using container DNS names.

8. Containers can be stopped, updated, and restarted independently without affecting others.

Database Schema

Not applicable as this design focuses on Docker containerization basics for microservices, not on database design.

Scaling Discussion

Bottlenecks

Single Docker host limits number of containers and resources

Network congestion if many containers communicate heavily

Large image sizes slow down container startup and deployment

Manual container management becomes complex with many microservices

Solutions

Use multiple Docker hosts or orchestration tools (out of scope here) to distribute load

Optimize Docker images by minimizing layers and dependencies

Use Docker overlay networks or bridge networks to improve container communication

Automate container lifecycle management with scripts or Docker Compose files

Interview Tips

Time: Spend 10 minutes understanding requirements and clarifying scope, 20 minutes designing Docker-based microservices architecture, 10 minutes discussing scaling and optimizations, 5 minutes summarizing.

Explain containerization benefits: isolation, consistency, portability

Describe Dockerfile structure and image layering

Discuss container networking and how microservices communicate

Mention persistent storage with Docker volumes

Highlight how Docker Compose simplifies multi-container setups

Address scaling challenges and basic solutions within Docker capabilities

Practice

1. What is the main purpose of Docker in microservices architecture?

easy

A. To replace the need for servers entirely

B. To write application code faster

C. To package applications with all dependencies for consistent deployment

D. To monitor network traffic between services

Solution

1. Step 1: Understand Docker's role

   Docker packages applications with their dependencies to ensure they run the same everywhere.

2. Step 2: Compare options

   Only To package applications with all dependencies for consistent deployment describes packaging apps with dependencies; others describe unrelated tasks.

3. Final Answer:

   To package applications with all dependencies for consistent deployment -> Option C

4. Quick Check:

   Docker packages apps = B [OK]

Hint: Docker bundles apps and dependencies for consistent runs [OK]

Common Mistakes:

• Thinking Docker replaces servers
• Confusing Docker with coding tools
• Assuming Docker monitors network

2. Which Docker command is used to create a new image from a Dockerfile?

easy

A. docker run

B. docker start

C. docker push

D. docker build

Solution

1. Step 1: Identify command purpose

   docker build creates an image from a Dockerfile.

2. Step 2: Eliminate other commands

   docker run starts containers, docker start restarts stopped containers, docker push uploads images to a registry.

3. Final Answer:

   docker build -> Option D

4. Quick Check:

   Build = create image [OK]

Hint: Build creates images; run starts containers [OK]

Common Mistakes:

• Using docker run to create images
• Confusing docker start with build
• Thinking docker push creates images

3. Given this Docker command sequence, what happens?

docker build -t myapp .
docker run -d --name app1 myapp

medium

A. Builds an image named myapp and runs it detached as container app1

B. Runs a container named myapp and builds app1 image

C. Builds a container named myapp and runs it interactively

D. Fails because -d and --name cannot be used together

Solution

1. Step 1: Analyze docker build command

   docker build -t myapp . creates an image tagged 'myapp' from current directory.

2. Step 2: Analyze docker run command

   docker run -d --name app1 myapp runs container named 'app1' in detached mode from image 'myapp'.

3. Final Answer:

   Builds an image named myapp and runs it detached as container app1 -> Option A

4. Quick Check:

   Build image then run container detached = A [OK]

Hint: Build tags image; run starts container with name and mode [OK]

Common Mistakes:

• Mixing image and container names
• Thinking -d disables naming
• Confusing build and run order

4. Identify the error in this Docker command:

docker run --name mycontainer -p 8080 myimage

medium

A. Port mapping syntax is incomplete

B. Missing container name

C. Image name is missing

D. Cannot use -p with --name

Solution

1. Step 1: Check port mapping syntax

   -p 8080 is incomplete; it should specify host and container ports like -p 8080:80.

2. Step 2: Verify other parts

   Container name and image name are present; no restriction on using -p with --name.

3. Final Answer:

   Port mapping syntax is incomplete -> Option A

4. Quick Check:

   Port mapping needs host:container format [OK]

Hint: Port mapping needs host:container format [OK]

Common Mistakes:

• Omitting container port in -p
• Assuming image name is missing
• Thinking -p and --name conflict

5. You want to deploy multiple microservices using Docker containers on one host. Which approach best ensures isolation and easy management?

hard

A. Run all microservices inside a single container

B. Use separate containers for each microservice with individual Dockerfiles

C. Install all microservices directly on the host OS without containers

D. Use one container per microservice but share the same network and volumes without isolation

Solution

1. Step 1: Understand container isolation

   Each microservice should run in its own container for isolation and independent management.

2. Step 2: Evaluate options

   Use separate containers for each microservice with individual Dockerfiles uses separate containers with individual Dockerfiles, enabling isolation and scalability. Run all microservices inside a single container mixes services, reducing isolation. Install all microservices directly on the host OS without containers lacks container benefits. Use one container per microservice but share the same network and volumes without isolation shares resources without isolation.

3. Final Answer:

   Use separate containers for each microservice with individual Dockerfiles -> Option B

4. Quick Check:

   Separate containers = isolation + management [OK]

Hint: One container per microservice for isolation and scaling [OK]

Common Mistakes:

• Running all services in one container
• Skipping containers and installing on host
• Sharing networks and volumes without isolation