Container Lifecycle Language

Docker container states: created → running → (paused) → exited → removed.

The Docker container lifecycle states are:
• created — the container has been created (docker create) but not started
• running — the main process (ENTRYPOINT/CMD) is executing; the container is alive
• paused — processes are suspended via SIGSTOP (docker pause); memory is preserved but CPU is not consumed
• exited (stopped) — the main process has terminated; container metadata and filesystem still exist until docker rm
• dead — Docker could not properly stop or remove the container; a rare error state requiring manual cleanup

docker ps shows only running containers. docker ps -a shows containers in all states including exited. A container must be explicitly removed with docker rm to free all resources.

Key vocabulary:
• container state — the current lifecycle phase (created / running / paused / exited / dead)
• exited — a stopped container whose main process has terminated; metadata persists until removed
• docker ps -a — lists all containers including stopped ones; without -a, shows only running containers
• docker rm — removes a stopped container and frees its filesystem and metadata

unless-stopped combines crash recovery with respect for deliberate maintenance stops.

Docker restart policies:
• no (default) — never restart automatically
• always — always restart, even after docker stop and even after Docker daemon restart
• on-failure[:max-retries] — restart only when the exit code is non-zero (a crash); clean exits and deliberate stops are not retried
• unless-stopped — restart on crash or daemon restart, but NOT if the container was deliberately stopped with docker stop

For a production database, unless-stopped is the right choice: it survives crashes and host reboots, but allows operators to run maintenance windows by simply stopping the container — it won't bounce back automatically until manually started again.

Key vocabulary:
• restart policy — a Docker container setting controlling automatic restart behaviour
• unless-stopped — restart always except after a deliberate docker stop
• on-failure — restart only on non-zero exit codes (crashes)
• always — restart regardless of how the container stopped
• maintenance window — a planned period where a service is deliberately taken offline for updates or repair

Exit code 137 = 128 + SIGKILL (9) — the process was force-killed, most often by the OOM killer.

Linux exit codes for signal-killed processes follow the convention: 128 + signal_number.
• SIGKILL = signal 9, so 128 + 9 = 137
• SIGTERM = signal 15, so 128 + 15 = 143

The OOM (Out-Of-Memory) killer is the Linux kernel component that sends SIGKILL to processes when overall or cgroup memory is exhausted. In Docker, if a container's process exceeds its --memory limit, the kernel OOM-kills it and Docker reports exit code 137.

Resolution: increase the memory limit, fix a memory leak in the application, or add memory profiling to understand the growth.

Key vocabulary:
• exit code 137 — 128 + SIGKILL (9); process was force-killed, typically by the OOM killer
• OOM killer — the Linux kernel mechanism that kills memory-hungry processes to prevent system collapse
• SIGKILL — signal 9; unconditional kill that cannot be caught or ignored by the process
• memory limit — the --memory container flag setting the cgroup memory ceiling
• cgroup — Linux control group; enforces resource limits (memory, CPU) for container processes

Orchestrators automatically replace unhealthy containers — plain Docker only flags them.

Docker health check states:
• starting — within the initial grace period; health check results don't count yet
• healthy — the health check command is passing
• unhealthy — the health check has failed --retries consecutive times

In plain Docker (no orchestration): the container stays running but is marked unhealthy in docker ps. Docker itself takes no corrective action — you must intervene.

In Docker Swarm: the Swarm manager detects unhealthy tasks and schedules replacements to maintain the desired replica count. In Kubernetes, a failing liveness probe triggers a pod restart. This automated healing is the primary reason orchestration is used for production workloads.

Key vocabulary:
• health check — a periodic command Docker executes inside a running container to assess application health
• starting — the health check grace period; failures during this phase don't count toward unhealthy
• healthy / unhealthy — the passing and failing health check states
• liveness probe — Kubernetes equivalent of a Docker health check; triggers pod restart on failure
• self-healing — an orchestrator's ability to automatically replace failed containers to maintain desired state

Standard exit code conventions: 0 = success, 1 = error, 137 = SIGKILL, 143 = SIGTERM.

Linux exit code rules:
• 0 — success; the process completed normally
• 1 — general application error; the most common non-zero exit for app bugs or config errors
• 137 — 128 + 9 (SIGKILL); force-killed by the OOM killer or docker kill
• 143 — 128 + 15 (SIGTERM); the process received SIGTERM (from docker stop) and exited

The docker stop workflow: Docker sends SIGTERM to PID 1 → waits for the grace period (default 10 s) → if the process hasn't exited, sends SIGKILL. A well-behaved container catches SIGTERM, completes in-flight work, and exits with code 143. An unresponsive container gets SIGKILL'd and exits with code 137.

Key vocabulary:
• exit code — an integer returned by a process when it terminates; 0 = success, non-zero = failure or signal
• SIGTERM — signal 15; polite shutdown request from docker stop; catchable by the application
• SIGKILL — signal 9; forceful, uncatchable kill; sent after grace period expires
• graceful shutdown — catching SIGTERM, draining in-flight requests, then exiting cleanly
• PID 1 — the first process in the container; must handle signals correctly for clean shutdowns

Containers don't start directly after deployment; they first need to pull the image from the registry. This initial stage is represented as Pending – Docker is actively downloading the new image layers. Only after the image has been successfully pulled and the container's configuration is applied does it transition into a Running state, ready to execute its processes. It's crucial to understand this pull-and-configure sequence, as issues here are frequently the root cause of deployment problems.

Initially, when you run docker run after pulling an image, Docker doesn't immediately start the container. It goes through several stages: it first creates the container (indicated by 'Created'), then performs a health check to ensure the application inside is running correctly and ready to serve requests. This health check can take some time, especially if it involves network connectivity or initial data setup – so 'Created' represents this preparatory phase before the actual process starts.

The 'Pending' state signifies that Docker hasn't yet allocated resources to the container. This typically happens when the Docker daemon needs to perform tasks like setting up networking, allocating memory, or performing other initial setup actions before the container can actually start running. Option A accurately reflects this process; options B, C, and D misrepresent the cause of a 'Pending' state.

Containers don't start directly after deployment; they first need to pull the image from the registry. This initial stage is represented as Pending – Docker is actively downloading the new image layers. Only after the image has been successfully pulled and the container's configuration is applied does it transition into a Running state, ready to execute its processes. It's crucial to understand this pull-and-configure sequence, as issues here are frequently the root cause of deployment problems.

Initially, when you run docker run after pulling an image, Docker doesn't immediately start the container. It goes through several stages: it first creates the container (indicated by 'Created'), then performs a health check to ensure the application inside is running correctly and ready to serve requests. This health check can take some time, especially if it involves network connectivity or initial data setup – so 'Created' represents this preparatory phase before the actual process starts.

The 'Pending' state signifies that Docker hasn't yet allocated resources to the container. This typically happens when the Docker daemon needs to perform tasks like setting up networking, allocating memory, or performing other initial setup actions before the container can actually start running. Option A accurately reflects this process; options B, C, and D misrepresent the cause of a 'Pending' state.

Containers don't start directly after deployment; they first need to pull the image from the registry. This initial stage is represented as Pending – Docker is actively downloading the new image layers. Only after the image has been successfully pulled and the container's configuration is applied does it transition into a Running state, ready to execute its processes. It's crucial to understand this pull-and-configure sequence, as issues here are frequently the root cause of deployment problems.

Initially, when you run docker run after pulling an image, Docker doesn't immediately start the container. It goes through several stages: it first creates the container (indicated by 'Created'), then performs a health check to ensure the application inside is running correctly and ready to serve requests. This health check can take some time, especially if it involves network connectivity or initial data setup – so 'Created' represents this preparatory phase before the actual process starts.

The 'Pending' state signifies that Docker hasn't yet allocated resources to the container. This typically happens when the Docker daemon needs to perform tasks like setting up networking, allocating memory, or performing other initial setup actions before the container can actually start running. Option A accurately reflects this process; options B, C, and D misrepresent the cause of a 'Pending' state.

Containers don't start directly after deployment; they first need to pull the image from the registry. This initial stage is represented as Pending – Docker is actively downloading the new image layers. Only after the image has been successfully pulled and the container's configuration is applied does it transition into a Running state, ready to execute its processes. It's crucial to understand this pull-and-configure sequence, as issues here are frequently the root cause of deployment problems.

Initially, when you run docker run after pulling an image, Docker doesn't immediately start the container. It goes through several stages: it first creates the container (indicated by 'Created'), then performs a health check to ensure the application inside is running correctly and ready to serve requests. This health check can take some time, especially if it involves network connectivity or initial data setup – so 'Created' represents this preparatory phase before the actual process starts.

The 'Pending' state signifies that Docker hasn't yet allocated resources to the container. This typically happens when the Docker daemon needs to perform tasks like setting up networking, allocating memory, or performing other initial setup actions before the container can actually start running. Option A accurately reflects this process; options B, C, and D misrepresent the cause of a 'Pending' state.

This question tests understanding of a critical error signal. The comment correctly focuses on diagnosing the *host* machine as the source of the problem, rather than assuming application code is at fault. It's crucial to differentiate between application-level and infrastructure problems when debugging containers.

Alex describes a common problem – connectivity issues. The most helpful response is to direct Alex towards investigating the *other* endpoint (the database) as that's where the issue likely resides. Simply restarting the database may not solve the underlying network configuration problems.

A good PR description should concisely communicate *what* changed. This response accurately captures the core elements: image updates, automation (Jenkins), and successful testing – all crucial aspects of a deployment. It's not just about the process; it's about the changes made within the container.

Ben's description of the 'Pending' state and subsequent delay strongly suggests an issue with either the image pull process or the container's startup. These are common causes for containers remaining in a non-running state after deployment – it's a critical piece of information to share during a standup.

A 503 error indicates that the service is temporarily unavailable. Given the context of a health check probing an HTTP endpoint, it's almost certainly the application code *within* the container itself experiencing transient issues or downtime – the most common cause for this scenario.

Containers in the 'Created' state indicate that Docker has successfully pulled the image but hasn't yet started the process. This often happens when the container isn't automatically linked to a network or if there are dependencies missing. Incorrect image tags will also cause this behavior as Docker attempts to pull a different version.

This scenario strongly suggests a networking issue. Containers often need explicit network configuration to be accessible from outside their isolated environment. A 'Connection refused' error indicates that the container isn't listening on any port or the firewall rules aren't permitting connections.

The PR description clearly points to a missing environment variable. The CI/CD pipeline is responsible for configuring the container, so it's crucial to verify that all required variables are being passed correctly during the build and deployment process. Restarting or rebooting won't fix the root cause.

A 'Container create failed' event typically indicates a resource constraint. Containers require CPU and memory to run, and if these resources are exhausted before the container starts, Docker will report this failure. Incorrect image tags can also cause failures but usually result in different error messages.

A failing health check usually indicates an issue with the application itself – it's not responding to the probe correctly. This could be due to a bug in the code or a misconfiguration that prevents the endpoint from being accessible. The other options are potential causes for general container issues, but less directly related to a failing health check.