Python多处理崩溃了docker容器

Question

当我在控制台中运行它时，有一个简单的python多处理代码，就像魅力一样：

# mp.py
import multiprocessing as mp


def do_smth():
    print('something')


if __name__ == '__main__':
    ctx = mp.get_context("spawn")
    p = ctx.Process(target=do_smth, args=tuple())
    p.start()
    p.join()

结果：

> $ python3 mp.py
something

然后我用Dockerfile创建了一个简单的Docker容器：

FROM python:3.6

ADD . /app
WORKDIR /app

和docker-compose.yml：

version: '3.6'

services:
  bug:
    build:
      context: .
    environment:
      - PYTHONUNBUFFERED=1
    command: su -c "python3.6 forever.py"

forever.py在哪里：

from time import sleep

if __name__ == '__main__':
    i = 0
    while True:
        sleep(1.0)
        i += 1
        print(f'hello {i:3}')

现在我用docker compose运行forever.py：

> $ docker-compose build && docker-compose up 
...
some output
...
Attaching to mpbug_bug_1
bug_1  | hello   1
bug_1  | hello   2
bug_1  | hello   3
bug_1  | hello   4

到目前为止，一切都很好，可以理解。但是当我试图在docker容器中运行mp.py时，它崩溃而没有任何消息：

> $ docker exec -it mpbug_bug_1 /bin/bash
root@09779ec47f9d:/app# python mp.py 
something
root@09779ec47f9d:/app# % 

可以在这里找到代码的要点：https://gist.github.com/ilalex/83649bf21ef50cb74a2df5db01686f18

你能解释为什么docker容器崩溃以及怎么做而不会崩溃？

先感谢您！

Answer 1

为了快速修复，不要使用spawn启动方法，和/或不使用su -c ...，两者都是不必要的IMO。改成：

p = mp.Process(target=do_smth, args=tuple())

或者你可以用--init选项启动容器。

使用spawn启动方法，Python也将启动semaphore tracker process以防止信号量泄漏，你可以通过在中间暂停mp.py看到这个过程，它看起来像：

472   463 /usr/local/bin/python3 -c from multiprocessing.semaphore_tracker import main;main(3)

这个过程由mp.py开始，但在mp.py之后退出，因此它不会被mp.py收获，但应该由init设计收获。

问题是这个容器（命名空间）中没有init，而不是init，PID 1是su -c，因此su采用了死信号量跟踪器进程。

似乎su认为死子进程是命令进程（forever.py）错误，没有检查关系，所以su盲目退出，作为PID 1退出，内核杀死容器中的所有其他进程，包括forever.py。

用strace可以观察到这种行为：

docker run --security-opt seccomp:unconfined --rm -it ex_bug strace -e trace=process -f su -c 'python3 forever.py'

将输出错误信息，如：

strace: Exit of unknown pid 14 ignored

ref：Docker and the PID 1 zombie reaping problem (phusion.nl)

Answer 2

mp.py看起来不像forever.py。 mp.py将运行新的工作进程，它将只打印something然后它将退出=> join()在主进程中将立即退出，此工作进程完成。

更好的等价于forever.py：worker进程在无限循环中打印hello消息，主进程将等待join()中的这个worker进程退出 - forever-mp.py：

import multiprocessing as mp
from time import sleep

def do_smth():
    i = 0
    while True:
        sleep(1.0)
        i += 1
        print(f'hello {i:3}')

if __name__ == '__main__':
    ctx = mp.get_context("spawn")
    p = ctx.Process(target=do_smth, args=tuple())
    p.start()
    p.join()

更新了docker-compose.yml：

version: '3.6'

services:
  bug:
    build:
      context: .
    environment:
      - PYTHONUNBUFFERED=1
    command: su -c "python3.6 forever-mp.py"

测试：

$ docker-compose build && docker-compose up 
...
some output
...
Attaching to multiprcs_bug_1_72681117a752
bug_1_72681117a752 | hello   1
bug_1_72681117a752 | hello   2
bug_1_72681117a752 | hello   3
bug_1_72681117a752 | hello   4

检查容器中的进程：

$ docker top multiprcs_bug_1_72681117a752
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                38235               38217               0                   21:36               ?                   00:00:00            su -c python3.6 forever-mp.py
root                38297               38235               0                   21:36               ?                   00:00:00            python3.6 forever-mp.py
root                38300               38297               0                   21:36               ?                   00:00:00            /usr/local/bin/python3.6 -c from multiprocessing.semaphore_tracker import main;main(3)
root                38301               38297               0                   21:36               ?                   00:00:00            /usr/local/bin/python3.6 -c from multiprocessing.spawn import spawn_main; spawn_main(tracker_fd=4, pipe_handle=6) --multiprocessing-fork