How to stop docker container

Stop and delete Docker container if it’s running

I am looking to pragmatically stop and delete a Docker container if it is running. This is for a build script.

Take the following example. How would I stop and delete the Docker container «rabbitmq» as seen under the NAMES column in a bash script?

The following command will delete the container and does what I’m looking to do

However, it’s combing it into a script that I would like to know? I think it would look something like this.

14 Answers 14

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

As you have probably noticed, docker stop as well as docker rm exit with a status code indicating failure if the container is not existent or not running. This results in your build failing.

If you can cope with the error messages in your build log you can do this little trick to prevent the shell command of failing:

In the case that one of the docker command fails, true is called which always exits with a status code indicating success.

I have a similar problem, but didn’t like the accepted answer as it suppresses all errors from the commands, rather than just the «not found» error.

The following command is also useful for testing filter definitions:

My actual use case was in defining a pair of Ansible tasks that deleted all currently existing containers (whether running or not) from a list of names generated in an earlier task:

This is my preferred way to stop and remove a docker container. The piping of true is there to ensure that it always outputs a success. Without it, any bash scripts would exit and error if the container name did not exist.

I suggest this incantation in bash:

A general form based on some answers here:

Copy this code in your script.sh if you want stop and remove all

Call it: remove_previous_instance «CNAME»

Easy way to do this issue

In the Below scenario:-

In this case, you can use the below command for preventing the build from failing.

In a CI/CD pipeline or something that you don’t need the output, the way I use is this:

but as I undertand &> is not part of the official POSIX spec so we shoud use:

Force the removal of a running container (uses SIGKILL)

instead of docker stop that sends:

.. SIGTERM, and after a grace period, SIGKILL

1> /dev/nul redirect the output 1 (stdout) to /dev/null and 2>&1 redirect the error 2 (stderr) to the same «file». & as the firs example redirect both 1 and 2.

Gracefully Stopping Docker Containers

Brian DeHamer

Well, depending on your application, the process by which you stop your app could be very important. If your application is serving HTTP requests you may want to complete any outstanding requests before you shutdown your container. If your application writes to a file, you probably want to ensure that the data is properly flushed and the file is closed before your container exits.

Monthly Docker Tips

Things would be easy if you simply started a container and it ran forever, but there’s a good chance that your application will need to be stopped and restarted at some point to facilitate an upgrade or a migration to another host. For those times when you need to stop a running container, it would be preferable if the process could shutdown smoothly instead of abruptly disconnecting users and corrupting files.

So, let’s look at some of the things you can do to gracefully stop your Docker containers.

Sending Signals

There are a number of different Docker commands you can use to stop a running container.

docker stop

When you issue a docker stop command Docker will first ask nicely for the process to stop and if it doesn’t comply within 10 seconds it will forcibly kill it. If you’ve ever issued a docker stop and had to wait 10 seconds for the command to return you’ve seen this in action

The docker stop command attempts to stop a running container first by sending a SIGTERM signal to the root process (PID 1) in the container. If the process hasn’t exited within the timeout period a SIGKILL signal will be sent.

Whereas a process can choose to ignore a SIGTERM, a SIGKILL goes straight to the kernel which will terminate the process. The process never even gets to see the signal.

When using docker stop the only thing you can control is the number of seconds that the Docker daemon will wait before sending the SIGKILL:

docker kill

For example, if you wanted to send a SIGINT (the equivalent of a Ctrl-C on the terminal) to the container «foo» you could use the following:

Handling Signals

While the operating system defines a set list of signals, the way in which a process responds to a particular signal is application-specific.

For example, if you want to initiate a graceful shutdown of an nginx server, you should send a SIGQUIT. None of the Docker commands issue a SIGQUIT by default so you’d need use the docker kill command as follows:

The nginx log output upon receiving the SIGQUIT would look something like this:

In contrast, Apache uses SIGWINCH to trigger a graceful shutdown:

According to the Apache documentation a SIGTERM will cause the server to immediately exit and terminate any in-progress requests, so you may not want to use docker stop on an Apache container.

If you’re running a third-party application in a container you may want to review the app’s documentation to understand how it responds to different signals. Simply running a docker stop may not give you the result you want.

When running your own application in a container, you must decide how the different signals will be interpreted by your app. You will need to make sure you are trapping the relevant signals in your application code and taking the necessary actions to cleanly shutdown the process.

If you know that you’re going to package your application in a Docker image you might consider using SIGTERM as your graceful shutdown signal since this is what the docker stop command sends.

No matter which language you’re using, there is a good chance that it supports some form of signal handling. I’ve collected links to the relevant package/module/library for a handful of languages in the list below:

If you’re using Go for your application, take a look at the tylerb/graceful package which automatically enables the graceful shutdown of http.Handler servers in response to SIGINT or SIGTERM signals.

Receiving Signals

To demonstrate, let’s create a simple application that we’ll run inside a Docker container:

This trivial bash script simply goes into an infinite loop, but will exit with a 0 status if it receives a SIGTERM.

We’ll package this into a Docker image with the following Dockerfile:

This will simply copy our loop.sh bash script into an Ubuntu-based image and set it as the default command for the running container.

Now, let’s build this image, start a container, and then immediately stop it.

We can validate this by looking at the container’s exit status.

So, what happened here? Our application is coded to trap SIGTERM and exit gracefully. We know that docker stop sends a SIGTERM to the container process. Yet it appears that the signal never made it to our app.

To understand what happened here, let’s start another container and take a peek at the running processes.

The important thing to note in the output above is that our loop.sh script is NOT running as PID 1 inside the container. The script is actually running as a child of the /bin/sh process running at PID 1.

When you use docker stop or docker kill to signal a container, that signal is sent only to the container process running as PID 1.

Since /bin/sh doesn’t forward signals to any child processes, the SIGTERM we sent never reached our script. Clearly, if we want our app to be able to receive signals from the host we need to find a way to run it as PID 1.

To do this we need to go back to our Dockerfile and look at the CMD instruction used to launch our script. There are actually a few different forms the CMD instruction can take. In our Dockerfile above we used the shell form which looks like this:

Luckily, Docker also supports an exec form of the CMD instruction which looks like this:

Note that the content appearing after the CMD instruction in this case is formatted as a JSON array.

When the exec form of the CMD instruction is used the command will be executed without a shell.

Let’s change our Dockerfile to see this in action:

Rebuild the image and look at the processes running in the container:

Now, our script is running as PID 1. Let’s send a SIGTERM to the container and look at the exit status:

This is exactly the result we were expecting! Our script received the SIGTERM sent by the docker stop command and exited cleanly with a 0 status.

The bottom line is that you should audit the processes inside your container to make sure they’re in a position to receive the signals you intend to send. Using the exec form of the CMD (or ENTRYPOINT) instruction in your Dockerfile is a good start.

Conclusion

It’s pretty easy to terminate a Docker container with a docker kill command, but if you actually want to wind-down your applications in an orderly fashion there is a little more work involved. You should now understand how to send signals to your containers, how to handle those signals in your custom applications and how to ensure that your apps can even receive those signals in the first place.

In this article we will discuss how to stop and remove a running container by filtering on ID and Name.

To completely remove a running container, first we have to stop it and then remove it.

Suppose we have a running container whose Status is ‘UP’ i.e

To stop a running container we need to pass the container id or name to stop command i.e.

Now let’s stop the above mentioned running container by container ID i.e.

Alternatively to stop the container we can pass the container name too i.e.

Both the above commands will stop the running container, but container is not removed from the system yet. It still exists in system and its status is ‘Exited‘. Let’s fetch the list of all containers to check the status of stopped container i.e.

In the first line we can see the status of container with ID d857536373e3 is ‘Exited‘.

Now to remove the container completely from the system we need to use docker rm command i.e.

It will remove the one or more stopped containers based on IDs or Names provided.

Let’s remove the recently stopped container by container ID i.e.

Alternatively to remove the container we can pass the container name too i.e.

Both the above commands will remove the container with ID d857536373e3 from our docker engine. If we try to remove any running container (status – UP) using docker rm command, then it will through error like this,

So one way is to stop and then remove container. Also, as mentioned in above error string, there is an an another way to directly remove a running container.

Directly Stop & Remove a running container by force in single command

Suppose we have a running container i.e.

PS C:\Varun> docker ps

Now let’s forcefully remove this container without first stopping it,

It will directly stop & remove the container from docker engine. Now if we fetch the list of all containers in our system, then this container will not be there i.e.

We can also remove multiple containers using docker rm command i.e.

Suppose we have two running containers with ID 1a600547f8f5 and 3ab005456123. Now to remove both the containers we can pass their ID to rm command i.e.

It will forcefully remove both the containers.

Dry run of above used commands:

Get list of all containers,

Now remove running container with ID 8b38ae16205a

Now remove running container with Name : agitated_chaplygin,

Check if both the above mentioned running containers are removed i.e.

Containers with ID 8b38ae16205a and Name agitated_chaplygin are not found now. So deleted completely.

It will delete 5 containers which were in exited state.

But if want to delete 100 containers or remove containers based on conditional filtering then it will be really difficult to pass their container ID one by one. So, in next article we will discuss how to stop & remove multiple containers in a single command.

Docker stop or kill command

In this tutorial we will learn about how we can stop or kill the running docker containers. We will be using docker run command to create and start a container if you do not know about anything regarding this command please read below article first:

How to create and run a container from docker image?

First of all to learn about stopping or killing a running container we first need to create and then start a container. Let’s create a new container from docker image called busybox.

This image allow us to run some linux command inside the container. Open your terminal window and run following command:

If you do not want to use above command you can do the same thing by running following sets of command:

Alright now we have busy box image on our local machine. This image does nothing however we can run some linux command by adding an argument to docker command.

Let’s create a new container out of busybox docker image and add a ping command so that our container is constantly running.

So far we have a container that is running. Now, we want to stop or kill this container.

How to stop the running container?

Docker stop command sends SIGTERM signal to running container process. It will stop the process however it takes a while to shutdown the container completely.

Let’s look at the syntax of this command:

Let’s now stop our running container and make sure it is stopped. Open your terminal window and type following commands:

After running docker ps command you will see no container is running because we stopped the container using docker stop command. One thing to notice here that it takes some pause before it actually stops the container.

How to kill the running container?

Docker kill command is kind of similar to docker stop command however it sends SIGKILL signal to our running container process. SIGKILL signal immediately shuts the container down without taking any pause.

Let’s look at the syntax of this command:

Let’s now use docker kill command to shutdown our running container. Run following commands to start the container and then kill the running container and notice time it takes to shutdown the container compare to docker stop command:

What is the difference between docker stop and kill command?

Get Notified

On Ubuntu 14.04 (Trusty Tahr) I’m looking for a way to stop a running container and the only information I have is the image name that was used in the Docker run command.

Is there a command to find all the matching running containers that match that image name and stop them?

20 Answers 20

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

If you know the image:tag exact container version

Following issue 8959, a good start would be:

Since name refers to the container and not the image name, you would need to use the more recent Docker 1.9 filter ancestor, mentioned in koekiebox’s answer.

As commented below by kiril, to remove those containers:

stop returns the containers as well.

So chaining stop and rm will do the job:

If you know only the image name (not image:tag )

Alex proposes a solution, but the one I managed to run, when you have multiple containers running from the same image is (in your

/.bashrc for instance):

Then I just call in my bash session (after sourcing

And any container running from alpine.*:xxx would stop.

From there, of course:

And a drmi alpine would stop and remove any alpine:xxx container.

The previous answers did not work for me, but this did:

You could start the container setting a container name:

The same image could be used to spin up multiple containers, so this is a good way to start a container. Then you could use this container-name to stop, attach. the container:

This code will stop all containers with the image centos:6. I couldn’t find an easier solution for that.

Or even shorter:

Two ways to stop running a container:

You can get running containers using the following command:

Following links for more information:

Stop docker container by image name:

Stop docker container by image name and tag:

If you created the image, you can add a label to it and filter running containers by label

Unreliable methods

filters by container name, not image name

is problematic since the image name may appear in other columns for other images

I made a /usr/local/bin/docker.stop that takes in the image name (assumes you only have one running).

list all containers with info and ID

For Docker version 18.09.0 I found that format flag won’t be needed

I was trying to wrap my Docker commands in gulp tasks and realised that you can do the following:

This might not work for scenarios where you have multiple containers with the same name (if that’s possible), but for my use case it was perfect.

Then in your command line, simply do dockstop myImageName and it will stop and remove all containers that were started from an image called myImageName.

This is my script to rebuild docker container, stop and start it again

Here’s a concise command which doesn’t require you to specify the image tag (as most of these answers do):

This should be enough.

If you want to prefer a simple AWK approach, here Is my take:

For example, removing all running containers of ubuntu image, can be done simply as:

PS: Remember to include the image tag in AWK, since it’s a equal comparator.