Docker basics review in Microservices - System Design Guide

Problem Statement

Deploying applications directly on servers often leads to inconsistent environments, causing software to work on one machine but fail on another. This inconsistency slows down development and causes unexpected failures in production.

Solution

Docker packages applications and their dependencies into containers that run the same way everywhere. Containers isolate the app from the host system, ensuring consistent behavior across development, testing, and production environments.

Architecture

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Developer PC  │──────▶│ Docker Engine  │──────▶│ Containerized  │
│ (Build & Test)│       │ (Host System) │       │ Application    │
└───────────────┘       └───────────────┘       └───────────────┘

This diagram shows how a developer builds and tests an application on their PC, which runs inside a Docker Engine on the host system, creating a containerized application isolated from the host.

Trade-offs

✓ Pros

→

Ensures consistent environments across development, testing, and production.

→

Speeds up deployment by packaging all dependencies together.

→

Improves resource efficiency compared to full virtual machines.

→

Simplifies scaling and management of microservices.

✗ Cons

→

Containers share the host OS kernel, so they are less isolated than virtual machines.

→

Requires learning Docker commands and concepts, adding initial complexity.

→

Improper container configuration can lead to security risks.

Use Docker when you need consistent environments across multiple stages, want faster deployment cycles, or are building microservices that require isolated runtime environments.

Avoid Docker if your application requires full OS-level isolation or when running on systems where Docker is unsupported or adds unacceptable overhead.

Real World Examples

Netflix

Netflix uses Docker containers to package microservices, enabling rapid deployment and consistent environments across their cloud infrastructure.

Uber

Uber uses Docker to isolate services and manage dependencies, allowing teams to develop and deploy independently without environment conflicts.

Shopify

Shopify employs Docker containers to streamline development workflows and ensure that applications behave the same from developer laptops to production servers.

Code Example

Before Docker, the app runs directly on the host, which may have different Python versions or missing dependencies. After Docker, the Dockerfile defines a container with a specific Python version and app code, ensuring consistent runtime everywhere.

Microservices

### Before Docker: Running app directly
import time

def run_app():
    print("App is running")
    time.sleep(10)

run_app()

### After Docker: Dockerfile to containerize app
# Use official Python image
FROM python:3.11-slim

# Copy app code
COPY app.py /app/app.py

# Set working directory
WORKDIR /app

# Run the app
CMD ["python", "app.py"]

Alternatives

Virtual Machines

Virtual machines emulate entire operating systems, providing stronger isolation but with higher resource use and slower startup times.

Use when: Choose VMs when you need complete OS isolation or must run different operating systems on the same hardware.

Serverless Functions

Serverless abstracts infrastructure completely, running code in response to events without managing containers or servers.

Use when: Choose serverless for event-driven workloads with unpredictable scale and when you want to avoid managing infrastructure.

Summary

Docker solves environment inconsistency by packaging apps with their dependencies into containers.

Containers are lightweight and share the host OS kernel, enabling fast startup and efficient resource use.

Using Docker improves deployment speed and reliability, especially for microservices architectures.

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