What Happen When Docker Service Is Restarted

Why Does My Docker Container Terminate?

Later a container finishes executing its default command, it volition cease.

When yous run a container epitome yous've pulled from a registry similar Docker Hub, yous're launching a process. This process volition, somewhen, consummate. That means that, sooner or afterward, your Docker container will come to a complete stop, whether by choice or accident.

A Docker container exiting doesn't ordinarily indicate that something is wrong. But, nevertheless, you might exist wondering why it's exited!

This is especially the example if you're using Kubernetes, which will restart failed containers, and give you lot that dreaded CrashLoopBackOff error.

To empathise why containers exit, it'due south actually helpful to understand the difference between containers and VMs.

Containers are non similar virtual machines.

You probably know that VMs are like virtual computers that keep running until you tell them to stop.

But containers don't run an entire operating system. They only run (comprise) a specific process. When this process finishes, the container exits.

And then why does a container stop?

The lifecycle of a container

To understand why and when a container stops, we demand to wait at the lifecycle of a container. A Docker container goes through various stages of life - similar a bee 🐝.

Diagram showing the states of a Docker container — Docker container lifecycle

A container is simply an isolated process running on your computer. A Docker container tin can be in one of several core states:

Created - The Docker container has been created, only not started (e.grand. after using docker create)
Upwards - The Docker container is currently running. That is, the process inside the container is running. Can happen using docker beginning or docker run.
Paused - The Docker container has been paused, usually with the command docker pause.
Exited - The Docker container has exited, commonly because the process within the container has exited.

Why a Docker container terminates

So why does a container terminate, or go out? There are several reasons why a Docker container might end:

The main procedure inside the container has ended successfully: This is the most mutual reason for a Docker container to terminate! When the process running inside your container ends, the container will exit.

Here are a couple of examples:
- You run a container, which runs a shell script to perform some tasks. When the crush script completes, the container will go out, considering there's cypher left for the container to run.
- You run a utility which is packaged as a Docker container, like the Busybox or Maven images. When the utility finishes, the container exits.
You're running a shell in a container, simply you haven't assigned a terminal: If you're running a container with a shell (like bash) as the default command, and then the container volition go out immediately if you oasis't attached an interactive terminal. If in that location'southward no terminal fastened, then your shell process will go out, and then the container will leave. You tin finish this past calculation --interactive --tty (or just -it) to your docker run ... control, which will let you type commands into the shell.
The procedure inside the container has been terminated: This is when the program that runs inside the container is given a betoken to shut down. This happens if you run a foreground container (using docker run), and then press Ctrl+C when the program is running. When this happens, the program will stop, and the container will exit.
The container has been stopped using docker stop: You can manually finish a container using the docker stop control.
The Docker daemon has restarted, and it terminated and restarted the container: Docker can restart containers if you demand it to. Past default, Docker doesn't automatically restart containers when they exit, or when Docker itself restarts. To configure Docker to restart containers automatically, utilize a restart policy using the --restart switch, when you run a container using docker run.
The container has consumed too much memory, and has been killed by the host Bone: If the operating system detects that it's running out of retentivity, it might kickoff killing processes to free up memory. If a container is using a lot of memory or resources, it might be killed by the OS. You tin set hard memory limits on your container by using the -m switch with docker run.

Game Over on a video game screen — When the process ends, it'south game over for your Docker container

How to find out why a Docker container exits

If you run a container and information technology's terminating unexpectedly, and y'all're not sure why, yous need to think almost what the container is doing when it starts. Is the script that is running inside the container exiting? Is the application crashing?

i. Await at the logs

The best fashion to explore what goes on inside a Docker container is to expect at the logs using docker logs <container_id>:

Do the logs show the application starting up properly?
Can you see any helpful debug letters from the awarding?
Does the application crash with a stack trace (e.g. Java) or another debugging information?

Y'all'll need to figure out whether the logs give you a clue as to why the process is exiting unexpectedly.

2. Cheque the state of the container

You tin can view details about a container by using docker inspect <container_id>. This command shows a lot of data almost the container, including its state. The land includes data like the container's leave code and perhaps the error message that was returned:

                              "State"                :                                                {                                                "Condition"                :                                                "exited"                ,                                                "Running"                :                                                false                ,                                                "Paused"                :                                                fake                ,                                                "Restarting"                :                                                false                ,                                                "OOMKilled"                :                                                false                ,                                                "Expressionless"                :                                                imitation                ,                                                "Pid"                :                                                0                ,                                                "ExitCode"                :                                                0                ,                                                "Mistake"                :                                                ""                ,                                                "StartedAt"                :                                                "2020-10-30T11:44:56.344308725Z"                ,                                                "FinishedAt"                :                                                "2020-x-30T11:48:23.434250526Z"                ,                                                "Healthcheck"                :                                                {                                                "Condition"                :                                                ""                ,                                                "FailingStreak"                :                                                0                ,                                                "Log"                :                                                null                                                }                                                }

Wait at the container's exit code. In this example, the container's get out lawmaking was 0. An go out lawmaking or exit status of 0 generally means that the awarding successfully completed. But whatever other exit lawmaking indicates an unsuccessful exit. Some exit codes take further, specific meanings, which you might need to check with the person who wrote the program.

If you run a container and it terminates immediately, information technology is frustrating to figure out what's going on. Only fearfulness non. You tin debug this situation by creating a beat in the container, to requite you fourth dimension to run the offending script, and troubleshoot the issue.

To debug this situation and find out why the container is stopping, create and starting time a container from the aforementioned failing image, and override the entrypoint with a shell, like sh or bash. This will start the container, and drop you in to a crush session, where you can run your script, and run into whether it is exiting unexpectedly.

Attempt starting a new container and dropping into a shell

Example: The following command runs the nginx:latest image, merely overrides its default entrypoint. The default entrypoint will unremarkably start the nginx spider web server. But when we run this command, the container starts, and opens a trounce, so that you can do some debugging inside the container. Perhaps yous would use the beat out to run the usual entrypoint startup script, and encounter what's happening, or impress out some surround variables:

              docker run --interactive --tty --entrypoint /bin/sh nginx:latest

How to prevent a container from stopping

And so how exercise you foreclose a container from stopping?

Peradventure you lot have a script which runs in a container, and it'southward terminating too early.

Or maybe you want to run a few commands in a container, and keep it running in the groundwork when yous're not using information technology. (This isn't the ideal use for containers, but sometimes it'southward useful.)

There are a few ways that you can prevent a container from stopping - all of these are simply ways to keep a process alive:

Run a long-lived service inside the container: Most containers run a long-living service, similar a database or a web server. These processes keep running until they receive a shutdown bespeak. This is the usual way that a container runs for an extended menstruum without stopping – because the underlying process keeps running.
Add an artificial sleep or intermission to the entrypoint: If your container is running a brusque-lived procedure, the container will stop when it completes. You tin artificially extend this by adding some lawmaking to the entrypoint script (if you have one), to look or slumber for a while. You could tell the script to sleep for a fixed menstruum, or maybe tell information technology to sleep indefinitely. For instance, in bash, you tin use this to create an infinite pause: while true; do slumber i; done.
Change the entrypoint to an interactive beat out: This is useful if you want to use a container like a virtual automobile, and keep information technology running in the background when you lot're not using it. If you lot override the entrypoint to the container with a shell, like sh or fustigate, and run the container with the -itd switches, Docker will run the container, detach information technology (run it in the background), and attach an interactive concluding. Note that this won't run the container'southward default entrypoint script, but run a trounce instead. Effectively, you will have a container that stays running permanently. For example: docker run --entrypoint /bin/sh -itd mycontainer:latest

In the real globe

When people use containers in the real world, how practice they continue them alive?

Docker containers are used, literally, to contain an existing application. They are a way of putting an application in its own box, so it has limited access to resources. Containers are frequently used for long-running processes, like web servers or database servers, or for short-lived utilities, like fetching a web site or copying a file.

Containers aren't unremarkably used like general-purpose virtual machines. They are designed to run, or incorporate, a single application. This allows them to start up fast, and to get out when no longer needed (which usually happens when the main procedure inside the container has finished).

Yet you choose to continue your container live, call back that Docker containers are at their simplest and most powerful when they are used to contain a single process, from startup to completion.

Want to acquire more than? The Containers Fundamentals form will teach you lot how to install, spin up, manage and troubleshoot containers.

Tutorial Works is a participant in the Amazon.com Services LLC Associates Program. Every bit an Amazon Acquaintance we earn from qualifying purchases. Amazon and the Amazon logo are trademarks of Amazon.com, Inc. or its affiliates.