Run multiple services in a container

Estimated reading time: 4 minutes
A container’s main running process is the ENTRYPOINT and/or CMD at the end of the Dockerfile. It is generally recommended that you separate areas of concern by using one service per container. That service may fork into multiple processes (for example, Apache web server starts multiple worker processes). It’s ok to have multiple processes, but to get the most benefit out of Docker, avoid one container being responsible for multiple aspects of your overall application. You can connect multiple containers using user-defined networks and shared volumes.

容器的主要运行过程是 Dockerfile 末尾的 ENTRYPOINT 和/或 CMD。通常建议您通过每个容器使用一个服务来分离关注的领域。该服务可以分叉为多个进程 (例如，Apache web 服务器启动多个工作进程)。有多个流程是可以的，但是为了从 Docker 中获得最大的好处，避免一个容器负责整个应用程序的多个方面。您可以使用用户定义的网络和共享卷连接多个容器。
The container’s main process is responsible for managing all processes that it starts. In some cases, the main process isn’t well-designed, and doesn’t handle “reaping” (stopping) child processes gracefully when the container exits. If your process falls into this category, you can use the --init option when you run the container. The --init flag inserts a tiny init-process into the container as the main process, and handles reaping of all processes when the container exits. Handling such processes this way is superior to using a full-fledged init process such as sysvinit, upstart, or systemd to handle process lifecycle within your container.
容器的主进程负责管理它启动的所有进程。在某些情况下，主进程设计得不好，当容器退出时，不会优雅地处理 “收获” (停止) 子进程。如果您的进程属于此类别，则可以在运行容器时使用-init 选项。—Init 标志将一个微小的 init 进程作为主进程插入到容器中，并在容器退出时处理所有进程的收获。这种方式处理此类进程优于使用成熟的 init 进程 (如 sysvinit 、 upstart 或 systemd) 来处理容器内的进程生命周期。
If you need to run more than one service within a container, you can accomplish this in a few different ways.
如果您需要在一个容器内运行多个服务，您可以通过几种不同的方式来完成。

  • Put all of your commands in a wrapper script, complete with testing and debugging information. Run the wrapper script as your CMD. This is a very naive example. First, the wrapper script:

将所有命令放入包装脚本中，完成测试和调试信息。运行包装脚本作为你的 CMD。这是一个非常天真的例子。首先，包装脚本:

  1. #!/bin/bash
  2. # Start the first process
  3. ./my_first_process -D
  4. status=$?
  5. if [ $status -ne 0 ]; then
  6.   echo "Failed to start my_first_process: $status"
  7.   exit $status
  8. fi
  9. # Start the second process
  10. ./my_second_process -D
  11. status=$?
  12. if [ $status -ne 0 ]; then
  13.   echo "Failed to start my_second_process: $status"
  14.   exit $status
  15. fi
  16. # Naive check runs checks once a minute to see if either of the processes exited.
  17. # This illustrates part of the heavy lifting you need to do if you want to run
  18. # more than one service in a container. The container exits with an error
  19. # if it detects that either of the processes has exited.
  20. # Otherwise it loops forever, waking up every 60 seconds
  21. while sleep 60; do
  22.   ps aux |grep my_first_process |grep -q -v grep
  23.   PROCESS_1_STATUS=$?
  24.   ps aux |grep my_second_process |grep -q -v grep
  25.   PROCESS_2_STATUS=$?
  26.   # If the greps above find anything, they exit with 0 status
  27.   # If they are not both 0, then something is wrong
  28.   if [ $PROCESS_1_STATUS -ne 0 -o $PROCESS_2_STATUS -ne 0 ]; then
  29.     echo "One of the processes has already exited."
  30.     exit 1
  31.   fi
  32. done

  • Next, the Dockerfile:

    1. FROM ubuntu:latest
    2. COPY my_first_process my_first_process
    3. COPY my_second_process my_second_process
    4. COPY my_wrapper_script.sh my_wrapper_script.sh
    5. CMD ./my_wrapper_script.sh

  • If you have one main process that needs to start first and stay running but you temporarily need to run some other processes (perhaps to interact with the main process) then you can use bash’s job control to facilitate that. First, the wrapper script:

如果你有一个主进程需要先开始并保持运行，但是你暂时需要运行一些其他进程 (也许是为了与主进程交互) 然后，您可以使用 bash 的作业控制来实现这一点。首先，包装脚本:

  1. #!/bin/bash
  2. # turn on bash's job control
  3. set -m
  4. # Start the primary process and put it in the background
  5. ./my_main_process &
  6. # Start the helper process
  7. ./my_helper_process
  8. # the my_helper_process might need to know how to wait on the
  9. # primary process to start before it does its work and returns
  10. # now we bring the primary process back into the foreground
  11. # and leave it there
  12. fg %1
  1. FROM ubuntu:latest
  2. COPY my_main_process my_main_process
  3. COPY my_helper_process my_helper_process
  4. COPY my_wrapper_script.sh my_wrapper_script.sh
  5. CMD ./my_wrapper_script.sh
  • Use a process manager like supervisord. This is a moderately heavy-weight approach that requires you to package supervisord and its configuration in your image (or base your image on one that includes supervisord), along with the different applications it manages. Then you start supervisord, which manages your processes for you. Here is an example Dockerfile using this approach, that assumes the pre-written supervisord.conf, my_first_process, and my_second_process files all exist in the same directory as your Dockerfile.
  1. FROM ubuntu:latest
  2. RUN apt-get update && apt-get install -y supervisor
  3. RUN mkdir -p /var/log/supervisor
  4. COPY supervisord.conf /etc/supervisor/conf.d/supervisord.conf
  5. COPY my_first_process my_first_process
  6. COPY my_second_process my_second_process
  7. CMD ["/usr/bin/supervisord"]

docker, supervisor, process management