If I understand correctly, what you want to do here is to capture the interrupt request of the program.
The reason(I think) why you can't capture it is the -it argument. When you use that, the docker process needs to "steal away" all std inputs and outputs to be interactive, so your Go program is not in control anymore.

This isn't an issue with the os/signal package. To prove that, let me show you an example.
Imagine you have this go program that only says hi every 20 milliseconds

// Suppose we build this into a binary "hi"
package main

import (
	"fmt"
	"time"
)

func main() {
	for {
		fmt.Println("HI!")
		time.Sleep(20 * time.Millisecond)
	}
}

Then we modify your program a bit to be:

package main

import (
	"fmt"
	"os"
	"os/exec"
	"os/signal"
)

func main() {
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	go func() {
		<-c
		fmt.Println("[SIGINT force quit]")
		os.Exit(0)
	}()
	err := Run()
	fmt.Println(err)
}

func Run() error {
	cmd := exec.Command("./hi")
	cmd.Stderr = os.Stderr
	cmd.Stdout = os.Stdout
	cmd.Stdin = os.Stdin
	return cmd.Run()
}

If you run this, you'll see that os/signal is able to read the interrupt signal and print [SIGINT] force quit] so the package is successfully catching signals when the std inputs and outputs are connected to a subcommand.

In conclusion, the issue seems to be with how the docker run -it command works. What do you think? :)

/cc Mr. Signals @ianlancetaylor

Let's not all start calling me Mr. Signals....

I don't know much about docker, but @matipan 's comment looks plausible to me. I'm going to close this issue, since it doesn't seem that there is anything we can do to fix it in Go. @mbertschler please comment if you disagree.