Docker Part 1: Installation and Hello World

Mel Wang — Fri, 06 Mar 2026 14:10:39 +0000

This is a post for myself to take notes on Udemy's course "Complete Docker and Kubernetes Course - learn all core Docker features including Dockerfiles and Docker Compose"

Download Docker
Run hello-world image in Docker
Run ubuntu image in Docker

Download Docker

I have a mac, so I installed it from this link: https://docs.docker.com/desktop/setup/install/mac-install/
A docker.dmg file is downloaded. After it's done downloading, double click it and move it in the Applications folder.
Run: docker --help. If it shows the following then you installed docker successfully.

Note: if it returns:
zsh: command not found: docker
then it may not be pointed correctly in the path. Run:
echo $PATH to see if docker is present. If not, run:
export PATH="/Applications/Docker.app/Contents/Resources/bin:$PATH" and try docker --help again.

Run hello-world image in Docker

When learning a new programming language, people often start with a Hello World program. In Docker, we do something similar using the hello-world container.

Running this container helps verify that Docker is installed correctly and introduces the basic components of Docker.

Step 1: The Command

We start with the following command in the terminal:

docker run hello-world

So what happened here?

Step 2: Actors

Before we walk through the steps, it helps to understand the actors involved in the process.

1. Docker Client (CLI)

The Docker client is the program you interact with in the terminal.

Example:

docker run
docker ps
docker build

The client’s job is to:

receive commands from the user
send requests to the Docker daemon
display the results back to the terminal

Think of it like a remote control for Docker.

2. Docker Daemon (Docker Engine)

The Docker daemon is the background service that does the real work. It:

downloads images
builds containers
starts containers
manages networks and storage

The daemon is always running in the background once Docker is installed.

3. Docker Registry (Docker Hub)

Docker images are stored in a registry. The default public registry is Docker Hub. Docker Hub contains thousands of images such as:

nginx
redis
postgres
hello-world

If Docker can't find an image locally, it will download it from Docker Hub.

4. Docker Image

An image is a template used to create containers. You can think of it as a blueprint for an application. Images are read-only and contain:

application code
runtime
dependencies

5. Docker Container

A container is a running instance of an image.

Relationship:

Image → Blueprint
Container → Running program

Multiple containers can be created from the same image.

Step 3 — What Happens When You Run the Command

You type the command in the terminal. docker run hello-world.
The Docker client sends this request to the Docker daemon.
The Docker daemon checks whether the hello-world image already exists on your computer.
If the image exists locally, it'll use local image. If not, the daemon will pull image from Docker Hub.
The Docker daemon pulls (downloads) the image from Docker Hub. Once downloaded, the image is stored locally. You might see output like:

Pulling from library/hello-world
Digest: sha256:...
Status: Downloaded newer image

After the image is available locally, Docker creates a new container from that image. Think of it like:

Image = blueprint
Container = running machine

The hello-world container runs a very small program. Its only job is to print the following message:

Hello from Docker!
This message shows that your installation appears to be working correctly.

Once the message is printed, the container finishes execution.

The container exits automatically. You can confirm there are no running containers with:

docker ps

Output will be empty.

Run ubuntu image in Docker

Step 1: The Command

Run the command in the terminal:

docker run ubuntu

Notice that nothing is done and the container is stopped after running /bin/bash. Why?

This is because there was no command that was executed inside of this ubuntu container. We can check that the ubuntu container is exited by running either of the following to see docker container run history (both yields the same results):

docker ps -a
docker container ls -a

Then how do we start ubuntu and let it keep running? The following command does the trick:

docker run -it ubuntu       // "i" - interactive mode (user can key in input)
                            // "t" - pseudo-TTY (terminal)

Now you're inside the ubuntu container! You can treat it as a Linux shell and can run any Linux command.

To exit the ubuntu container, run exit. As soon as you exit, the process bash of ubuntu gets terminated, and the container will stop running.

Additional Information:

busybox is smallest Linux image with minimal Linux utilities
alpine is based on top of busybox

Rate Limiting Explained Simply - Part 1

Mel Wang — Wed, 11 Feb 2026 18:43:44 +0000

It’s a normal day. Your API is running smoothly. Then suddenly…

CPU spikes
Database connections max out
Latency explodes
Users start seeing errors

What happened?

Maybe a bot started hammering your endpoint.
Maybe a client had a retry bug.
Maybe you just went viral.

Whatever the reason, your system was not prepared for the flood. What you needed was a way to control how fast requests are allowed in. That’s where rate limiting comes in.

What Is Rate Limiting?

A rate limiter controls how many requests are allowed within a specific time window. It protects your system from overload and ensures fair usage.

Think of it like:

A toll booth controlling traffic on a highway
A dam regulating water flow
A bouncer letting people into a club at a controlled pace

It’s not about blocking users. It’s about keeping your system alive.

Why Do We Need Rate Limiting?

Rate limiting isn’t just a “nice-to-have.” It solves very real problems.

1. Protect Infrastructure

Without limits, a sudden spike can:

Exhaust database connections
Overwhelm CPU
Trigger cascading failures
Rate limiting acts as a safety valve.

2. Prevent Abuse

Attackers and bots don’t politely slow down.
Common abuse scenarios:
- Brute-force login attempts
- Credential stuffing
- Scraping
- DDoS-style request floods
- Rate limiting is often your first line of defense.

3. Ensure Fair Usage

If one client sends 10,000 requests per second and another sends 5. Should the first client consume everything? Probably not. Rate limiting ensures that no single user can monopolize your resources.

4. Control Costs

Many systems rely on:

Paid third-party APIs
Database operations
Cloud compute
Uncontrolled traffic = higher bills

Rate limiting protects your wallet too.

So How Do I Add It Into My App?

At this point you might be thinking:

“This all makes sense. But how do I actually add rate limiting to my system?”

There are three common approaches. Which one you choose depends on how your app is structured.

1. Add It Inside Your Application

The simplest way is to implement it directly in your backend code.

You keep a counter per user (or IP), track how many requests they’ve made, and reset it every time window.

This works great if:

You have a single server
You’re building something small

But the moment you scale to multiple instances behind a load balancer, each instance keeps its own counter. Your “100 requests per second” limit can quietly turn into 500. That’s usually not what you intended.

2. Let Your API Gateway Handle It

In many production systems, rate limiting lives at the gateway level. Tools like NGINX, API Gateway, or Cloudflare can enforce limits before traffic even reaches your application.

This has a big advantage: You don’t touch your code.

You configure rules like:

100 requests per minute per IP
1000 requests per minute per API key And the gateway enforces them consistently.

For many teams, this is the cleanest solution.

3. Use a Shared Store (Like Redis)

Once you’re running multiple instances, you need shared state. That’s where something like Redis comes in.

Instead of each server counting independently, they all increment the same counter stored in Redis. Because Redis operations can be atomic, you avoid race conditions and keep your limits accurate. This is the typical solution in distributed systems.

Stay tuned for Part 2!

DEV Community: Mel Wang

Docker Part 1: Installation and Hello World

Table of Contents

Download Docker

Run hello-world image in Docker

Step 1: The Command

Step 2: Actors

1. Docker Client (CLI)

2. Docker Daemon (Docker Engine)

3. Docker Registry (Docker Hub)

4. Docker Image

5. Docker Container

Step 3 — What Happens When You Run the Command

Run ubuntu image in Docker

Step 1: The Command

Rate Limiting Explained Simply - Part 1

What Is Rate Limiting?

Why Do We Need Rate Limiting?

1. Protect Infrastructure

2. Prevent Abuse

3. Ensure Fair Usage

4. Control Costs

So How Do I Add It Into My App?

1. Add It Inside Your Application

2. Let Your API Gateway Handle It

3. Use a Shared Store (Like Redis)