Restart all stopped Docker containers with one command

Restart all stopped Docker containers with one command

docker ps -a | grep Exited

View all stopped containers

docker ps -a | grep Exited | awk '{print $1}'

Get the ID of a stopped container

docker ps -a | grep Exited | awk '{print $1}' |xargs docker start

Pass the ID of the stopped container to the container start command

Stop all running Docker containers with one command

docker ps -a | grep Up | awk '{print $1}' |xargs docker stop

Additional knowledge: Docker learning notes: Get the image & start the container & stop the container

Get the image

By default, the docker pull command will pull the image from the official Docker Hub repository to the local computer.

First, let me introduce the format of this command:

docker pull [OPTIONS] <warehouse name>: <tag>

in:

docker pull: command keyword for Docker to pull images;

[OPTIONS]: command options;

Warehouse name: The format of the warehouse name is generally <user name>/<software name>. For Docker Hub, if you do not specify a username, the default is library, which is the official image;

Tag: Tag is an important parameter to distinguish different versions of images. <warehouse name>:<tag> will uniquely identify an image. The default is latest.

For example, we want to pull an official image of Ubuntu 14.04 from the official Docker Hub repository, and the statement is as follows:

docker pull ubuntu:14.04

What's going on behind the scenes of the docker pull command

First, if the tag value is empty, that is, no tag is specified, the default tag, which is latest, will be used. If the tag value is not empty, the specified tag will be used.

Then, by default, it will look for a repository named "repoName" in Docker Hub, and return an error message if the repository does not exist. If the repository exists, pull the image of the corresponding tag from the repository. For example, if you execute docker pull ubuntu:14.04, the image with tag 14.04 will be pulled from the "ubuntu" repository, and if you execute docker pull ubuntu, the image with tag latest will be pulled from the "ubuntu" repository.

(There are many image repositories in Docker Hub. Generally, images of the same type are placed in the same repository. For example, an ubuntu repository consists of many ubuntu images, including ubuntu:14.04, ubuntu:16.04, ubuntu:latest, and so on).

Finally, store the pulled image to the specified location locally.

Setting up the Mirror Accelerator

Due to the "Great Wall", the speed of pulling images from Docker Hub in China may be slow. Many domestic cloud service providers provide image accelerator services, such as Alibaba, NetEase, etc.

Taking the configuration of Alibaba Cloud Accelerator on Linux system as an example, you only need to copy the following command to the Linux terminal and execute it as the root user to successfully configure Alibaba Cloud Accelerator!

# Perform the following operations as root user

mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{#The following URL can be replaced with your own Alibaba Cloud acceleration address "registry-mirrors": ["https://jxus37ad.mirror.aliyuncs.com"]
}
EOF
systemctl daemon-reload
systemctl restart docker

Start the container

After pulling an image, the operating environment is prepared for the container.

There are two ways to start a container. One is to create a new container based on the image and start it, and the other is to restart a stopped container.

The first method: Create and start

The docker run command creates a container based on the specified image and starts it. The basic syntax of docker run is as follows:

docker run [OPTIONS] image name [COMMAND] [ARG]

in:

docker run: Docker command keyword to create and start the container;

OPTIONS: command options, the most commonly used ones include -d to run the container in the background and return the container ID, -i to run the container in interactive mode, -t to assign a pseudo input terminal to the container, and –name to specify the name of the started container. For more options, please refer to the Docker help documentation;

Image name: specified in the form of <warehouse name>:<tag>;

COMMAND: Set the startup command, which is executed after the container is started;

ARG: Some other parameters.

What's going on behind the scenes of docker run

The standard operations that Docker runs in the background include:

Check whether the specified image exists locally. If not, download it from the public repository and start it.

Create and start a container using the image;

Allocate a file system and mount a readable and writable layer outside the read-only image layer;

Bridge a virtual interface from the host host's configured bridge interface to the container;

Configure an IP address for the container from the address pool;

Execute the startup command specified by the user;

After execution is complete the container is terminated.

Docker run example 1

Create and start a container with the Ubuntu operating environment and output hello docker.

Just one command: docker run ubuntu:14.04 echo 'hello docker', and the problem is solved.

First, since the ubuntu:14.04 image does not exist locally, download the image from Docker Hub first; (in fact, it means executing docker pull ubuntu:14.04 first)

Then after downloading the image, use the image to create. Since an Ubuntu image contains all the contents of an Ubuntu system, after starting the container using the image, the Ubuntu operating environment will be available in the container.

After starting the container, execute the echo 'hello docker' startup command and terminate the container after the startup command is executed.

Docker run example 2

Create and start a container with the Ubuntu operating environment. The container is named firstContainer and a terminal is assigned to the container to interact with the user.

The -i option tells Docker to keep the standard input and output streams open to the container, and the -t option lets Docker allocate a pseudo-terminal (pseudo-tty) and bind it to the standard input of the container. –name sets the container name for the container.

Note that docker run creates a new container and starts it, so the container created by this command is not the same container as the container created in the previous instance. And because the ubuntu:latest image already exists locally, there is no need to download it from Docker Hub again. Instead, the local ubuntu:latest image is used directly to build the container.

After starting the container, we enter the container and interact with the container in the terminal. We can determine whether we are inside the container based on the command prompt on the left. For example, in the above example, when the command prompt on the left is root@localhost, it means we are outside the container, and when the command prompt is: root@fe263c9359dd/, it means we are inside the container and the container ID is fe263c9359dd. We can exit the current container through exit.

The second method: start a terminated container

Although Docker containers are very lightweight, this means that in general, we will delete the container after starting it and completing the operation. But sometimes we will enter the container created before, and docker run will create a new container each time, which obviously does not meet our needs. In this case, you can use the docker start command to start a terminated container using the container name or container id.

docker start [OPTIONS] container [container2...]

in:

docker start: The command keyword for Docker to start the container;

OPTIONS: command options;

Container: The container to be started. The container is represented by "container ID" or "container name". If multiple containers are specified, all containers will be started.

Suppose a container named firstContainer is in a terminated state and you need to start it. You can do this by executing docker start firstContainer. After the command is executed, try to start the firstContainer container and execute the startup command of the container.

But if you want to start the container created by the first instance, you don’t know the name of the container (because I didn’t specify it) nor its id. What to do?

View container information

There is a command in Docker called docker ps, which can be used to view container information, including container ID, base image, startup command, creation time, current status, port number, and container name.

If you execute docker ps without any parameters, all running containers will be displayed. For example, execute docker ps. As shown in the figure below, in the current Docker environment, there is only one running container. Its container ID is fe263c9359dd, based on the ubuntu:latest image, the startup command is "/bin/bash", the creation time is 2 minutes ago, and the current status is "Up 2 minutes", which means it has been running for 2 minutes. The container name is: firstContainer.

If you use the docker ps –a command, you can view all containers in the Docker environment, including stopped containers. After executing docker ps –a, as shown in the following figure: In addition to the container named firstContainer, you can also see a container named ee826f1d58ff (the container id is randomly generated). However, the current status of this container is Exited (0) 3 minutes ago, which means that it is in the terminated state and exited 3 minutes ago.

For this terminated container, you can start it with docker start ee826f1d58ff or docker start g\fracious_lewin.

In actual situations, use docker start ee826f1d58ff to start the container of the first instance, and then use docker ps to view it, but you will not see the container. This means that when executing docker ps, the container with container ID ee826f1d58ff is not in the running state, but in the terminated state.

The execution result of docker ps is as follows: The current status of the container with container ID ee826f1d58ff is Exited (0) 2 seconds ago! ! ! This means that the ee826f1d58ff container is indeed in a terminated state, but it was exited 2 seconds ago. Note that it was 2 seconds ago! This indicates that the container was started 2 seconds ago, but for some reason, the container was terminated! !

In actual situation, execute docker start ee826f1d58ff to start the container with container ID ee826f1d58ff! ! But after executing the start command, the container ends immediately.

Stop the container

Stop a container using docker stop

docker stop can be used to terminate a running container. Its command format is as follows:

docker stop [OPTIONS] Container [Container ...]

in:

docker stop: The command keyword for Docker to stop the container;

OPTIONS: command options, where -t specifies how many seconds to wait before forcing the container to stop if it has not terminated. The default waiting time is 10 seconds;

Container: The container to be started. The container is represented by "container ID" or "container name". If multiple containers are specified, all containers will be started.

For example, if you want to stop a container named firstContainer, you can execute docker stop firstContainer. After the command is executed, firstContainer will be in terminated state. The terminated container can be viewed using docker ps –a.

In actual work, executing docker stop may not terminate the container immediately, but may require waiting for a while.

A container is actually a process. After executing docker stop, a SIGTERM signal is first sent to the main process of the container, allowing the main process to release resources, save status, and try to terminate itself. However, when the waiting time exceeds the time set by -t, a SIGKILL signal will be sent to the main process of the container, causing the container to terminate immediately.

Under what circumstances will the container terminate immediately after it is started?

In actual situations, in addition to using the docker stop command to forcibly terminate a container, the container will also terminate automatically when the container's start command ends.

Taking docker run --name testcontainer ubuntu echo 'hello docker' as an example, echo 'hello docker' is the startup command of the container. In fact, after executing this command, execute docker ps -a, you can find that the testcontainer container is in a terminated state, as shown below:

[root@localhost Desktop]# docker run --name testcontainer ubuntu echo 'hello docker'
hello docker
[root@localhost Desktop]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
da14116bf641 ubuntu "echo 'hello docker'" 6 seconds ago Exited (0) 4 seconds ago testcontainer

When the container starts, the container startup command is executed. After executing the above command to create and start the container, the container is terminated because the container startup command echo 'hello docker' is executed immediately. Therefore, use docker ps -a to check the status of the container, which is the terminated state.

The Docker container is a process, which actually uses sh as the main process. If the main process stops, the container stops too. However, if the container's "start command" is executed, the main process will stop because there is no command to continue executing, and the container will also stop.

How can I prevent the container from terminating immediately after it is started?

If the sh main process of the container does not stop, does it mean that the container will not stop? The answer is yes. Therefore, if the startup command cannot be executed to completion, or the container's sh main process does not stop after the startup command is executed, the container will not terminate immediately after startup!

Here are two examples that can prevent the container from stopping immediately after starting:

Set the startup command to an infinite loop

docker run ubuntu:14.04 /bin/sh -c "while true; do echo hello world; sleep 1; done"

After creating and starting the container, this command will execute /bin/sh -c "while true; do echo hello world; sleep 1; done". Since this command will never be completed unless it is forcibly terminated, the main process sh of the container will not stop, and therefore the container will not stop either. However, if you do this, you cannot operate the container normally, and it will occupy resources, so this approach is not very meaningful in actual work.

Set the startup command to "Start a subprocess that runs forever"

docker run --name first_container -it ubuntu /bin/bash

After executing this command, the container is created and started, and /bin/bash is executed, a child process will be started. At this time, the parent process (that is, the main process sh of the container) will enter the sleep state. Since the sleep state is not the termination state, the container will continue to run.

Why does the container terminate after entering exit or executing ctrl D in the container? This is because exit will exit (end) the current process, that is, /bin/bash. Since the child process ends, the sh main process returns to the running state. However, since there is no command to continue executing, the sh main process ends, and the container terminates.

The above one command to restart all stopped docker containers is all the content that the editor shares with you. I hope it can give you a reference. I also hope that you will support 123WORDPRESS.COM.