Starting and stopping containers in Docker - Deep Dive

Overview - Starting and stopping containers

What is it?

Starting and stopping containers means turning on and off small, isolated environments called containers that run applications. Starting a container launches the application inside it, while stopping it pauses or ends the application without deleting the container. This lets you control when your app runs and saves resources when it doesn't. Containers are like mini-computers inside your main computer that you can switch on or off quickly.

Why it matters

Without the ability to start and stop containers easily, managing applications would be slow and wasteful. You would have to keep everything running all the time, using up memory and processing power. This would make your computer or server slower and more expensive to run. Starting and stopping containers lets you save resources, test changes safely, and keep your system organized.

Where it fits

Before learning this, you should understand what containers are and how Docker works at a basic level. After mastering starting and stopping containers, you can learn about container orchestration, scaling, and managing container networks.

Mental Model

Core Idea

Starting and stopping containers is like turning on and off small, self-contained computers that run your apps inside your main computer.

Think of it like...

Imagine a container as a portable mini-fridge that keeps your food fresh. Starting the container is like plugging in the fridge to power it on, and stopping it is like unplugging it to save electricity without throwing away the food inside.

┌───────────────┐       start       ┌───────────────┐
│ Stopped       │ ───────────────▶ │ Running       │
│ Container    │                  │ Container    │
└───────────────┘                  └───────────────┘
       ▲                                  │
       │             stop                 │
       └──────────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

What is a Docker container

Concept: Introduce the basic idea of a container as a lightweight, isolated environment.

A Docker container is a small package that holds everything an application needs to run: code, system tools, libraries, and settings. It runs isolated from other containers and the main system, so it behaves the same everywhere. Think of it as a mini-computer inside your computer.

Result

You understand that containers are isolated environments that run applications consistently.

Understanding containers as isolated mini-computers helps grasp why starting and stopping them controls app execution without affecting the main system.

2

Foundation

Basic Docker commands overview

Concept: Learn the commands to list, start, and stop containers.

To see containers, use: docker ps -a To start a container: docker start To stop a container: docker stop These commands let you control container states simply from the command line.

Result

You can list all containers and start or stop any container by its ID or name.

Knowing these commands is essential to control container lifecycles and manage running applications.

3

Intermediate

Difference between stopping and killing containers

🤔Before reading on: do you think 'docker stop' and 'docker kill' do the same thing? Commit to your answer.

Concept: Understand the difference between graceful stopping and forceful killing of containers.

docker stop sends a signal to the container to shut down gracefully, allowing it to finish tasks. docker kill immediately stops the container without cleanup. Use stop for normal shutdowns and kill only if stop fails.

Result

You know when to use stop versus kill to avoid data loss or corruption.

Knowing the difference prevents accidental data loss and helps maintain container stability.

4

Intermediate

Starting containers with options

🤔Before reading on: do you think you can start a container with extra settings like port mapping? Commit to your answer.

Concept: Learn how to start containers with options like port forwarding and environment variables.

You can start containers with options using docker run, for example: docker run -d -p 8080:80 --name webserver nginx This starts a new container in detached mode, maps port 8080 on your computer to port 80 in the container, and names it 'webserver'.

Result

You can launch containers configured to interact with your system and network.

Starting containers with options lets you customize how apps run and communicate, essential for real-world use.

5

Intermediate

Restart policies for automatic container start

🤔Before reading on: do you think containers restart automatically after a system reboot by default? Commit to your answer.

Concept: Understand how to configure containers to restart automatically after crashes or reboots.

Docker lets you set restart policies like: --restart no (default, no restart) --restart on-failure (restart if container exits with error) --restart always (always restart container) Example: docker run --restart always nginx This keeps your app running without manual intervention.

Result

You can ensure important containers stay running automatically.

Knowing restart policies helps maintain app availability and reduces manual management.

6

Advanced

Stopping containers without losing data

🤔Before reading on: do you think stopping a container deletes its data? Commit to your answer.

Concept: Learn how to stop containers safely without losing data by using volumes and proper shutdown.

Containers store data inside or outside. Data inside the container is lost if the container is removed. Use volumes to keep data outside: docker run -v mydata:/data nginx Stopping the container keeps the volume intact. Always stop containers gracefully to avoid data corruption.

Result

You can stop containers safely while preserving important data.

Understanding data persistence prevents accidental data loss during container lifecycle operations.

7

Expert

Internal container state during start and stop

🤔Before reading on: do you think starting a container always creates a new instance? Commit to your answer.

Concept: Explore what happens inside Docker when containers start and stop, including container states and resource allocation.

Starting a container changes its state from 'exited' to 'running' by allocating resources like CPU and memory and launching the main process. Stopping sends a signal to terminate the process but keeps the container filesystem intact. Docker tracks container states internally to manage lifecycle efficiently.

Result

You understand container lifecycle states and resource management during start and stop.

Knowing internal states helps debug lifecycle issues and optimize container management in production.

Under the Hood

Docker uses a container runtime to manage container lifecycle. When you start a container, Docker allocates system resources, sets up namespaces and control groups for isolation, and launches the container's main process. Stopping sends a termination signal to this process, allowing it to exit cleanly. The container's filesystem and metadata remain until explicitly removed. Docker tracks container states (created, running, exited) to manage commands and resource cleanup.

Why designed this way?

Docker was designed to provide lightweight, fast, and consistent environments. Separating start and stop commands allows users to control app execution without losing container setup or data. This design balances flexibility and resource efficiency, unlike virtual machines which are heavier and slower to start/stop. The state model helps Docker manage many containers efficiently.

┌───────────────┐
│ Docker Client │
└──────┬────────┘
       │ docker start/stop
       ▼
┌─────────────────────┐
│ Docker Daemon        │
│ - Manages container  │
│   lifecycle          │
│ - Tracks states      │
└──────┬───────────────┘
       │
       ▼
┌─────────────────────┐
│ Container Runtime   │
│ - Allocates CPU,    │
│   memory            │
│ - Sets namespaces   │
│ - Launches process  │
└─────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: does 'docker stop' delete the container? Commit yes or no.

Common Belief: Stopping a container deletes it completely from the system.

Reality: Stopping only pauses or ends the container's process; the container still exists and can be restarted.

Why it matters: Believing this causes users to lose work by removing containers unnecessarily or confusion about container states.

Quick: does 'docker kill' allow the container to shut down gracefully? Commit yes or no.

Common Belief: docker kill is the same as docker stop and lets the container close safely.

Reality: docker kill immediately terminates the container process without cleanup, risking data loss.

Why it matters: Using kill instead of stop can cause corrupted data or incomplete shutdowns.

Quick: do containers restart automatically after reboot by default? Commit yes or no.

Common Belief: Containers always restart automatically after the host system reboots.

Reality: By default, containers do not restart automatically unless a restart policy is set.

Why it matters: Assuming automatic restart leads to unexpected downtime and broken services after reboots.

Quick: does stopping a container delete its data stored inside? Commit yes or no.

Common Belief: Stopping a container deletes all data inside it permanently.

Reality: Stopping preserves the container's filesystem; data is lost only if the container is removed or not using volumes.

Why it matters: Misunderstanding this causes unnecessary data backups or fear of stopping containers.

Expert Zone

1

Restart policies interact with container dependencies; improper use can cause restart loops or deadlocks.

2

Stopping containers gracefully depends on the application inside handling termination signals correctly; otherwise, data loss can occur.

3

Docker tracks container states in a lightweight metadata store, enabling fast start/stop without full reinitialization.

When NOT to use

Starting and stopping containers manually is not ideal for large-scale systems; use orchestration tools like Kubernetes or Docker Swarm for automated lifecycle management and scaling.

Production Patterns

In production, containers are often started with health checks and restart policies to ensure uptime. Stopping is done carefully during deployments or scaling down, often coordinated by orchestration systems to avoid downtime.

Connections

Virtual Machines

Similar concept of isolated environments but heavier and slower to start/stop.

Understanding containers as lightweight alternatives to virtual machines clarifies why start/stop is faster and more resource-efficient.

Operating System Processes

Containers run processes isolated by namespaces and cgroups, similar to how OS manages processes.

Knowing OS process management helps understand container lifecycle signals and resource allocation.

Power Management in Electronics

Starting and stopping containers is like powering devices on and off to save energy and extend lifespan.

This connection highlights the importance of managing resource usage efficiently by controlling container states.

Common Pitfalls

#1 Trying to start a container that does not exist.

Wrong approach:

docker start unknown_container

Correct approach:

docker run -d --name known_container nginx

Root cause:

Confusing starting an existing container with creating and running a new one.

#2 Using docker kill instead of docker stop for normal shutdown.

Wrong approach:

docker kill my_container

Correct approach:

docker stop my_container

Root cause:

Not understanding the difference between forceful kill and graceful stop.

#3 Assuming containers restart automatically after reboot without setting restart policy.

Wrong approach:

docker run -d nginx

Correct approach:

docker run -d --restart always nginx

Root cause:

Not configuring restart policies leads to unexpected downtime.

Key Takeaways

Starting and stopping containers controls when your app runs inside isolated mini-computers on your system.

Stopping a container pauses it without deleting it, allowing you to restart later without losing setup.

Using restart policies ensures containers stay running automatically after crashes or reboots.

Graceful stopping prevents data loss, while forceful killing should be used only when necessary.

Understanding container states and lifecycle commands is essential for managing applications efficiently.