5.4. CMD и ENTRYPOINT

CMD ["python", "-m", "$MODULE"]     # запустит модуль с именем "$MODULE"
CMD python -m $MODULE               # подставит значение переменной

CMD exec python -m $MODULE

#!/bin/sh
set -e

# 1. Подготовка: ожидание зависимостей, миграции, генерация конфигурации
wait_for_database
apply_migrations

# 2. Передача управления приложению
exec "$@"

docker run <image> [аргументы]        # заменяют CMD
docker run --entrypoint <cmd> <image> # заменяет ENTRYPOINT

docker run --entrypoint ls myimage

docker run --entrypoint ls myimage -la /app

{
  "config": {
    "Entrypoint": ["/entrypoint.sh"],
    "Cmd": ["python", "app.py"]
  }
}

CMD python app.py
      ↓
"Cmd": ["/bin/sh", "-c", "python app.py"]

FROM python:3.13-slim
# CMD не задан — наследуется ["python3"] из базового образа

mkdir -p /tmp/cmd-entry && cd /tmp/cmd-entry

build_and_run() {
    local name="$1" dockerfile="$2" shift 2
    printf '%s' "$dockerfile" > "Dockerfile.$name"
    docker build -q -f "Dockerfile.$name" -t "ce:$name" . > /dev/null 2>&1
    printf '  без аргументов: '
    docker run --rm "ce:$name" 2>&1 | head -1
    printf '  с аргументом:   '
    docker run --rm "ce:$name" ARG1 2>&1 | head -1
}

echo "=== Только CMD (exec form) ==="
build_and_run cmd-exec 'FROM alpine:3.21
CMD ["echo", "значение-из-CMD"]
'

echo
echo "=== Только ENTRYPOINT (exec form) ==="
build_and_run ent-exec 'FROM alpine:3.21
ENTRYPOINT ["echo", "ENTRYPOINT:"]
'

echo
echo "=== ENTRYPOINT + CMD (оба exec form) ==="
build_and_run both 'FROM alpine:3.21
ENTRYPOINT ["echo", "ENTRYPOINT:"]
CMD ["значение-из-CMD"]
'

=== Только CMD (exec form) ===
  без аргументов: значение-из-CMD
  с аргументом:   ARG1
=== Только ENTRYPOINT (exec form) ===
  без аргументов: ENTRYPOINT:
  с аргументом:   ENTRYPOINT: ARG1
=== ENTRYPOINT + CMD (оба exec form) ===
  без аргументов: ENTRYPOINT: значение-из-CMD
  с аргументом:   ENTRYPOINT: ARG1

echo "=== ENTRYPOINT в shell form ==="
build_and_run ent-shell 'FROM alpine:3.21
ENTRYPOINT echo "ENTRYPOINT-shell:"
CMD ["значение-из-CMD"]
'

=== ENTRYPOINT в shell form ===
  без аргументов: ENTRYPOINT-shell:
  с аргументом:   ENTRYPOINT-shell:

docker image inspect ce:ent-shell --format 'Entrypoint: {{json .Config.Entrypoint}}'
docker image inspect ce:ent-shell --format 'Cmd:        {{json .Config.Cmd}}'

Entrypoint: ["/bin/sh","-c","echo \"ENTRYPOINT-shell:\""]
Cmd:        ["значение-из-CMD"]

cat > Dockerfile.pid-exec <<'EOF'
FROM alpine:3.21
CMD ["sleep", "300"]
EOF

cat > Dockerfile.pid-shell <<'EOF'
FROM alpine:3.21
CMD sleep 300
EOF

docker build -q -f Dockerfile.pid-exec  -t ce:pid-exec  . > /dev/null
docker build -q -f Dockerfile.pid-shell -t ce:pid-shell . > /dev/null

for v in exec shell; do
    docker run -d --name "pid-$v" "ce:pid-$v" > /dev/null
    sleep 1
    printf '%-6s PID 1: %s\n' "$v" "$(docker exec "pid-$v" ps -o args= -p 1)"
done

exec   PID 1: sleep 300
shell  PID 1: /bin/sh -c sleep 300

for v in exec shell; do
    s="$(date +%s.%N)"
    docker stop "pid-$v" > /dev/null
    e="$(date +%s.%N)"
    printf '%-6s время stop: %.2f c, код: %s\n' "$v" \
        "$(awk -v a="$s" -v b="$e" 'BEGIN{printf "%.2f", b-a}')" \
        "$(docker inspect "pid-$v" --format '{{.State.ExitCode}}')"
    docker rm "pid-$v" > /dev/null
done

exec   время stop: 0.31 c, код: 0
shell  время stop: 10.28 c, код: 137

cat > Dockerfile.var-exec <<'EOF'
FROM alpine:3.21
ENV GREETING="привет из ENV"
CMD ["echo", "$GREETING"]
EOF

cat > Dockerfile.var-shell <<'EOF'
FROM alpine:3.21
ENV GREETING="привет из ENV"
CMD echo $GREETING
EOF

cat > Dockerfile.var-fixed <<'EOF'
FROM alpine:3.21
ENV GREETING="привет из ENV"
CMD exec echo $GREETING
EOF

for v in exec shell fixed; do
    docker build -q -f "Dockerfile.var-$v" -t "ce:var-$v" . > /dev/null
    printf '%-6s -> %s\n' "$v" "$(docker run --rm "ce:var-$v")"
done

exec   -> $GREETING
shell  -> привет из ENV
fixed  -> привет из ENV

cat > Dockerfile.var-pid <<'EOF'
FROM alpine:3.21
ENV SLEEP_TIME=300
CMD exec sleep $SLEEP_TIME
EOF

docker build -q -f Dockerfile.var-pid -t ce:var-pid . > /dev/null
docker run -d --name var-pid ce:var-pid > /dev/null
sleep 1
# busybox ps не знает -p, а в python:*-slim ps нет вовсе — читаем /proc
docker exec var-pid cat /proc/1/cmdline | tr '\0' ' '; echo
docker rm -f var-pid > /dev/null

sleep 300

cat > Dockerfile.inherit <<'EOF'
FROM python:3.13-slim
# ни CMD, ни ENTRYPOINT не заданы
EOF

docker build -q -f Dockerfile.inherit -t ce:inherit . > /dev/null
docker image inspect ce:inherit --format 'Cmd: {{json .Config.Cmd}}'
docker image inspect python:3.13-slim --format 'база Cmd: {{json .Config.Cmd}}'

Cmd: ["python3"]
база Cmd: ["python3"]

cat > Dockerfile.reset <<'EOF'
FROM python:3.13-slim
ENTRYPOINT ["python", "-c"]
EOF

docker build -q -f Dockerfile.reset -t ce:reset . > /dev/null
docker image inspect ce:reset --format 'Entrypoint: {{json .Config.Entrypoint}}  Cmd: {{json .Config.Cmd}}'

Entrypoint: ["python","-c"]  Cmd: null

cat > entrypoint.sh <<'SH'
#!/bin/sh
set -e

echo "[entrypoint] подготовка окружения" >&2

# Пример подготовки: проверка обязательной переменной
if [ -z "${APP_MODE:-}" ]; then
    echo "[entrypoint] APP_MODE не задан, использую default" >&2
    export APP_MODE=default
fi

echo "[entrypoint] режим: $APP_MODE" >&2
echo "[entrypoint] передаю управление: $*" >&2

# exec обязателен: заменяет процесс скрипта процессом приложения
exec "$@"
SH
chmod +x entrypoint.sh

cat > app.py <<'PY'
import os
import signal
import sys
import time

def handle(signum, frame):
    print("[app] получен SIGTERM, завершаюсь", flush=True)
    sys.exit(0)

signal.signal(signal.SIGTERM, handle)
print(f"[app] запущен, PID={os.getpid()}, аргументы={sys.argv[1:]}", flush=True)
while True:
    time.sleep(0.2)
PY

cat > Dockerfile.entry <<'EOF'
FROM python:3.13-slim
COPY --chmod=755 entrypoint.sh /entrypoint.sh
COPY app.py /app.py
ENTRYPOINT ["/entrypoint.sh"]
CMD ["python", "-u", "/app.py", "--default-arg"]
EOF

docker build -q -f Dockerfile.entry -t ce:entry . > /dev/null

echo "=== запуск с CMD по умолчанию ==="
docker run -d --name entry-1 ce:entry > /dev/null
sleep 1
docker logs entry-1
echo "--- PID 1 ---"
docker exec entry-1 ps -o args= -p 1

=== запуск с CMD по умолчанию ===
[entrypoint] подготовка окружения
[entrypoint] APP_MODE не задан, использую default
[entrypoint] режим: default
[entrypoint] передаю управление: python -u /app.py --default-arg
[app] запущен, PID=1, аргументы=['--default-arg']
--- PID 1 ---
python -u /app.py --default-arg

s="$(date +%s.%N)"; docker stop entry-1 > /dev/null; e="$(date +%s.%N)"
printf 'время stop: %.2f c, код: %s\n' \
    "$(awk -v a="$s" -v b="$e" 'BEGIN{printf "%.2f", b-a}')" \
    "$(docker inspect entry-1 --format '{{.State.ExitCode}}')"
docker logs entry-1 2>&1 | tail -1
docker rm entry-1 > /dev/null

время stop: 0.38 c, код: 0
[app] получен SIGTERM, завершаюсь

docker run --rm -e APP_MODE=production ce:entry \
    python -u /app.py --custom-arg --verbose 2>&1 | tail -2

[entrypoint] передаю управление: python -u /app.py --custom-arg --verbose
[app] запущен, PID=1, аргументы=['--custom-arg', '--verbose']

cat > entrypoint-bad.sh <<'SH'
#!/bin/sh
set -e
echo "[entrypoint] подготовка" >&2
# ОШИБКА: нет exec
"$@"
SH
chmod +x entrypoint-bad.sh

cat > Dockerfile.entry-bad <<'EOF'
FROM python:3.13-slim
COPY --chmod=755 entrypoint-bad.sh /entrypoint.sh
COPY app.py /app.py
ENTRYPOINT ["/entrypoint.sh"]
CMD ["python", "-u", "/app.py"]
EOF

docker build -q -f Dockerfile.entry-bad -t ce:entry-bad . > /dev/null
docker run -d --name entry-bad ce:entry-bad > /dev/null
sleep 1

echo "--- дерево процессов ---"
docker exec entry-bad ps -o pid,args

s="$(date +%s.%N)"; docker stop entry-bad > /dev/null; e="$(date +%s.%N)"
printf 'время stop: %.2f c, код: %s\n' \
    "$(awk -v a="$s" -v b="$e" 'BEGIN{printf "%.2f", b-a}')" \
    "$(docker inspect entry-bad --format '{{.State.ExitCode}}')"
echo "--- обработчик вызывался? ---"
docker logs entry-bad 2>&1 | grep -c 'получен SIGTERM' || echo "0 — не вызывался"
docker rm entry-bad > /dev/null

--- дерево процессов ---
PID   COMMAND
    1 /bin/sh /entrypoint.sh python -u /app.py
    7 python -u /app.py
   14 ps -o pid,args
время stop: 10.31 c, код: 137
--- обработчик вызывался? ---
0 — не вызывался

echo "=== обычный запуск ==="
docker run --rm ce:entry python -u -c "print('обычный')" 2>&1 | tail -1

echo "=== --entrypoint без явных аргументов ==="
docker run --rm --entrypoint ls ce:entry 2>&1 | head -3

echo "=== --entrypoint с явными аргументами ==="
docker run --rm --entrypoint ls ce:entry -la /app.py

=== обычный запуск ===
обычный
=== --entrypoint без явных аргументов ===
ls: python: No such file or directory
ls: /app.py: ... 
=== --entrypoint с явными аргументами ===
-rw-r--r-- 1 root root 331 Jul 30 11:40 /app.py

docker run --rm -it --entrypoint sh ce:entry -c 'echo "внутри образа"; ls /'

внутри образа
app.py  bin  boot  dev  entrypoint.sh  etc  home ...

cd /tmp
docker rmi -f $(docker images -q --filter 'reference=ce:*') 2>/dev/null || true
rm -rf /tmp/cmd-entry

mkdir -p /tmp/vc && cd /tmp/vc
printf 'FROM alpine:3.21\nENTRYPOINT ["echo", "EP:"]\nCMD ["default"]\n' > Dockerfile
docker build -q -t vc:1 . > /dev/null
echo -n "без аргументов: "; docker run --rm vc:1
echo -n "с аргументом:   "; docker run --rm vc:1 custom
docker rmi -f vc:1 > /dev/null; cd /tmp && rm -rf /tmp/vc