Stopping Docker containers by image name - Ubuntu

Question

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?

Answer 1

If you know the image:tag exact container version

Following issue 8959, a good start would be:

docker ps -a -q --filter="name=<containerName>"

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.

docker ps -a -q  --filter ancestor=<image-name>

---

As commented below by kiril, to remove those containers:

stop returns the containers as well.

So chaining stop and rm will do the job:

docker rm $(docker stop $(docker ps -a -q --filter ancestor=<image-name> --format="{{.ID}}"))

---

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

As Alex Jansen points out in the comments:

The ancestor option does not support wildcard matching.

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):

dsi() { docker stop $(docker ps -a | awk -v i="^$1.*" '{if($2~i){print$1}}'); }

Then I just call in my bash session (after sourcing ~/.bashrc):

dsi alpine

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

Meaning: any image whose name is starting with alpine.
You might need to tweak the awk -v i="^$1.*" if you want ^$1.* to be more precise.

From there, of course:

drmi() { docker rm $(dsi $1  | tr '\n' ' '); }

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

Answer 2

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

docker stop $(docker ps -q --filter ancestor=<image-name> )

Answer 3

You could start the container setting a container name:

docker run -d --name <container-name> <image-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:

docker exec -it <container-name> bash
docker stop <container-name>
docker rm <container-name>

Answer 4

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

docker ps | grep centos:6 | awk '{print $1}' | xargs docker stop

Or even shorter:

docker stop $(docker ps -a | grep centos:6 | awk '{print $1}')

Answer 5

Two ways to stop running a container:

1. $docker stop container_ID

2. $docker kill container_ID

You can get running containers using the following command:

$docker ps

Following links for more information:

• https://docs.docker.com/engine/reference/commandline/stop/
• https://docs.docker.com/v1.8/reference/commandline/kill/

Answer 6

This will only stop all containers with image = "yourImgName" :

sudo docker stop $(sudo docker ps | grep "yourImgName" | cut -d " " -f 1)

This will stop and remove all containers with image = "yourImgName" :

sudo docker rm $(sudo docker stop $(sudo docker ps -a | grep "yourImgName" | cut -d " " -f 1))

Answer 7

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

docker stop $(docker ps -q -f "name=$1")

Answer 8

Stop docker container by image name:

imagename='mydockerimage'
docker stop $(docker ps | awk '{split($2,image,":"); print $1, image[1]}' | awk -v image=$imagename '$2 == image {print $1}')

Stop docker container by image name and tag:

imagename='mydockerimage:latest'
docker stop $(docker ps | awk -v image=$imagename '$2 == image {print $1}')

---

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

docker ps -q --filter "label=image=$image"

---

Unreliable methods

docker ps -a -q  --filter ancestor=<image-name>

does not always work

docker ps -a -q --filter="name=<containerName>"

filters by container name, not image name

docker ps | grep <image-name> | awk '{print $1}'

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

Answer 9

list all containers with info and ID

docker ps

docker stop CONTAINER ID

Answer 10

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

docker rm $(docker stop $(docker ps -a -q -f ancestor=<image-name>))

Answer 11

Adding on top of @VonC superb answer, here is a ZSH function that you can add into your .zshrc file:

dockstop() {
  docker rm $(docker stop $(docker ps -a -q --filter ancestor="$1" --format="{{.ID}}"))
}

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.

Answer 12

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

docker stop container-name
docker rm container-name

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.

Answer 13

In my case --filter ancestor=<image-name> was not working, so the following command cleaned up the Docker container for me:

docker rm $(docker stop $(docker ps -a -q --filter "name=container_name_here" --format="{{.ID}}"))

Answer 14

use: docker container stop $(docker container ls -q --filter ancestor=mongo)

    (base) :~ user$ docker ps
    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                      NAMES
    d394144acf3a        mongo               "docker-entrypoint.s…"   15 seconds ago      Up 14 seconds       0.0.0.0:27017->27017/tcp   magical_nobel
    (base) :~ user$ docker container stop $(docker container ls -q --filter ancestor=mongo)
    d394144acf3a
    (base) :~ user$ docker ps
    CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
    (base) :~ user$

Answer 15

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

docker pull [registry]/[image]:latest
docker build --no-cache -t [localregistry]/[localimagename]:latest -f compose.yaml context/
docker ps --no-trunc | grep [localimagename] | awk '{print $1}' | xargs docker stop
docker run -d -p 8111:80 [localregistry]/[localimagename]:latest

note --no-trunc argument which shows the image name or other info in full lenght in the output

Answer 16

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

docker stop $(docker ps -a | awk -v i="^${image_name}.*" '{if($2~i){print$1}}')

Answer 17

docker stop $(docker ps -a | grep "zalenium")
docker rm $(docker ps -a | grep "zalenium")

This should be enough.

Answer 18

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

docker rm -f $(docker ps | awk '{ if($2 == "<your image name>") { print $NF}}')

$(docker ps | awk '{ if($2 == "<your image name>") { print $NF}}') - prints the docker container names based on input image

docker ps - list all containers

awk '{ if($2 == "<your-image-name>") { print $NF}}' - The second parsed column of docker ps gives the image name. Comparing it with your image name will execute print $NF which prints the container name.

docker rm -f removes the containers

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

docker rm -f $(docker ps | awk '{ if($2 == "ubuntu:latest") { print $NF}}')

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

Answer 19

if you know a part of the container name you can use AWK with docker as following :

  CONTAINER_IDS=$(docker ps -a | awk '($2 ~ /container.*/) {print $1}')
  if [ -z "$CONTAINER_IDS" -o "$CONTAINER_IDS" == " " ]; then
    echo "No containers available for deletion"
  else
    docker rm -f $CONTAINER_IDS
  fi

Answer 20

image: docker
services:
  - docker:dind
stages:
  - deploy
step-deploy-prod:
  stage: deploy
  tags:
  - docker
  script:
    - container_id=$(docker ps -q -a -f status=running --filter name=todoapp)
    - if [ -n "$container_id" ]; then 
        docker stop $container_id; 
        docker rm -f $container_id;
      fi
    - container_id=$(docker ps -q -a -f status=exited --filter name=todoapp)
    - if [ -n "$container_id" ]; then 
        docker rm -f $container_id;
      fi
    - docker build -t app/creative .
    - docker run -d -p 8081:80 --name todoapp app/creative

First, check for a running container with the command docker ps -q -a -f status=running --filter name=todoapp , if it finds one it stops and deletes the running container then check for any containers that are stopped and have the name todoapp using the command docker ps -q -a -f status=exited --filter name=todoapp, then it will remove the container if it's found. Then it will build a new image and start a new container with the new build image.

As I have found out, if you stop the container, it can't be found with docker rm just incase anyone stumbles across this if you are wanting to replace a newly deployed image via gitlab-ci

There is an option in docker ps command -f status=exited which shows all the containers which are in stopped state.

container_id=$(docker ps -q -a -f status=exited --filter name=todoapp)

This command would only return container ids that are stopped and has name todoapp

Also, a better way to remove the stopped container is by using the -f or --force option with the docker rm command. This option will remove the container even if it is in a stopped state.

Answer 21

You can use the ps command to take a look at the running containers:

docker ps -a

From there you should see the name of your container along with the container ID that you're looking for. Here's more information about docker ps.