Docker bash shell script does not catch SIGINT or SIGTERM

Actually, your Dockerfile and start.sh entrypoint script work as is for me with Ctrl+C, provided you run the container with one of the following commands:

• docker run --name tmp -it tmp
• docker run --rm -it tmp

Documentation details

As specified in docker run --help:

• the --interactive = -i CLI flag asks to keep STDIN open even if not attached
  (typically useful for an interactive shell, or when also passing the --detach = -d CLI flag)
• the --tty = -t CLI flag asks to allocate a pseudo-TTY
  (which notably forwards signals to the shell entrypoint, especially useful for your use case)

Related remarks

For completeness, note that there are several related issues that can make docker stop take too much time and "fall back" to docker kill, which can arise when the shell entrypoint starts some other process(es):

• First, when the last line of the shell entrypoint runs another, main program, don't forget to prepend this line with the exec builtin:
  exec prog arg1 arg2 ...
• But when the shell entrypoint is intended to run for a long time, trapping signals (at least INT / TERM, but not KILL) is very important;
  {see also this SO question: Docker Run Script to catch interruption signal}
• Otherwise, if the signals are not forwarded to the children processes, we run the risk of hitting the "PID 1 zombie reaping problem", for instance
  {see also this SO question for details: Speed up docker-compose shutdown}

The reason is that bash will not handle signals until the foreground process terminates, the sleep 10000 in your case. Your traps do work, but you would have to wait 10000 seconds first.

Your fix is

#!/bin/bash
pid=
trap 'echo SIGINT; [[ $pid ]] && kill $pid; exit' SIGINT
trap 'echo SIGTERM; [[ $pid ]] && kill $pid; exit' SIGTERM
echo Starting script
sleep 10000 & pid=$!
wait
pid=

Also you probably want to replace trapping specific signals with trapping any exit

trap 'echo EXIT; [[ $pid ]] && kill $pid; exit' EXIT

These and more are very well explained at http://mywiki.wooledge.org/SignalTrap#When_is_the_signal_handled.3F

The solution I found was to just use the --init flag.

docker run --init [MORE OPTIONS] IMAGE [COMMAND] [ARG...]

Per their docs...

CTRL+C sends a signal to docker running on that console.
To send a signal to the script you could use

docker exec -it <containerId> /bin/sh -c "pkill -INT -f 'start\.sh'"

Or include echo "my PID: $$" on your script and send

docker exec -it <containerId> /bin/sh -c "kill -INT <script pid>"

Some shell implementations in docker might ignore the signal. This script will correctly react to pkill -15. Please note that signals are specified without the SIG prefix.

#!/bin/sh
trap "touch SIGINT.tmp; ls -l; exit" INT TERM
trap "echo 'really exiting'; exit" EXIT
echo Starting script
while true; do sleep 1; done

The long sleep command was replaced by an infinite loop of short ones since sleep may ignore some signals.

Try with something like the following script as your ENTRYPOINT:

#!/bin/bash

# Start the main process and save its PID
# Use exec to replace the shell script process with the main process
exec my_main_process &
pid=$!

# Trap the SIGTERM signal and forward it to the main process
trap 'kill -SIGTERM $pid; wait $pid' SIGTERM

# Wait for the main process to complete
wait $pidh

Source: https://www.linkedin.com/pulse/propagating-sigterm-signal-main-process-kubernetes-pod-chidambaram/

For anyone following the following and still not catching the signals, it may be that your entry command is not running in exec form (i.e. CMD ["/app/start.sh"] with square braces in your dockerfile!), see below answer: https://stackoverflow.com/a/72308559/2939369