docker execコマンドの実行時に起きていること

  • 6
    いいね
  • 0
    コメント

Usage: docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

記事を書く背景

私は普段職場でLinuxでWebアプリケーションの開発をしていて、実行環境にDockerのコンテナを使っていました。
元々使っていたネットワークマネージャのnetwork-managerが再接続をしてくれないという問題があったのでwicdに変えたところ、コンテナに設定されていたDNSサーバが応答しなくなり、コンテナを再度作成しました。

(後で調べたところ、wicdのインストール時の自動検知によって有線LANのインターフェースがdocker0に設定されていたため、外部に送出したパケットがコンテナにそのまま戻っているという状態でした。)

alt

そのコンテナ内のbashを開く際、docker execコマンドのオプションに-iを付けるのを忘れていたため、コマンドラインからの入力を受け付けませんでした。

私が試したこと

そこで私が思いついたのは、正常なコンテナの作成に失敗しているか、コンテナ内のbashを開く時のコマンドが間違っているという可能性でした。私は以下の2つを試しましたが、1の結果docker runは正常に動作していることが分かったので、結局はdocker execコマンドの挙動から答えにたどり着きました。

  1. 正常に動作している他のコンテナと同じイメージを使ってコンテナを作成し、コマンドラインからの入力を試す
  2. docker rundocker execコマンドの挙動について調べる

docker execコマンドの挙動

docker/docker/cli/command/container/exec.go
type execOptions struct {
    detachKeys  string
    interactive bool
    tty         bool
    detach      bool
    user        string
    privileged  bool
    env         *options.ListOpts
}

func newExecOptions() *execOptions {
    var values []string
    return &execOptions{
        env: options.NewListOptsRef(&values, runconfigopts.ValidateEnv),
    }
}

func NewExecCommand(dockerCli *command.DockerCli) *cobra.Command {
    opts := newExecOptions()

    cmd := &cobra.Command{
        Use:   "exec [OPTIONS] CONTAINER COMMAND [ARG...]",
        Short: "Run a command in a running container",
        Args:  cli.RequiresMinArgs(2),
        RunE: func(cmd *cobra.Command, args []string) error {
            container := args[0]
            execCmd := args[1:]
            return runExec(dockerCli, opts, container, execCmd)
        },
    }

    flags := cmd.Flags()
    flags.SetInterspersed(false)

    flags.StringVarP(&opts.detachKeys, "detach-keys", "", "", "Override the key sequence for detaching a container")
    flags.BoolVarP(&opts.interactive, "interactive", "i", false, "Keep STDIN open even if not attached")
    flags.BoolVarP(&opts.tty, "tty", "t", false, "Allocate a pseudo-TTY")
    flags.BoolVarP(&opts.detach, "detach", "d", false, "Detached mode: run command in the background")
    flags.StringVarP(&opts.user, "user", "u", "", "Username or UID (format: <name|uid>[:<group|gid>])")
    flags.BoolVarP(&opts.privileged, "privileged", "", false, "Give extended privileges to the command")
    flags.VarP(opts.env, "env", "e", "Set environment variables")
    flags.SetAnnotation("env", "version", []string{"1.25"})

    return cmd
}

func runExec(dockerCli *command.DockerCli, opts *execOptions, container string, execCmd []string) error {
    execConfig, err := parseExec(opts, execCmd)
    // just in case the ParseExec does not exit
    if container == "" || err != nil {
        return cli.StatusError{StatusCode: 1}
    }

    if opts.detachKeys != "" {
        dockerCli.ConfigFile().DetachKeys = opts.detachKeys
    }

    // Send client escape keys
    execConfig.DetachKeys = dockerCli.ConfigFile().DetachKeys

    ctx := context.Background()
    client := dockerCli.Client()

    response, err := client.ContainerExecCreate(ctx, container, *execConfig)
    if err != nil {
        return err
    }

    execID := response.ID
    if execID == "" {
        fmt.Fprintf(dockerCli.Out(), "exec ID empty")
        return nil
    }

    //Temp struct for execStart so that we don't need to transfer all the execConfig
    if !execConfig.Detach {
        if err := dockerCli.In().CheckTty(execConfig.AttachStdin, execConfig.Tty); err != nil {
            return err
        }
    } else {
        execStartCheck := types.ExecStartCheck{
            Detach: execConfig.Detach,
            Tty:    execConfig.Tty,
        }

        if err := client.ContainerExecStart(ctx, execID, execStartCheck); err != nil {
            return err
        }
        // For now don't print this - wait for when we support exec wait()
        // fmt.Fprintf(dockerCli.Out(), "%s\n", execID)
        return nil
    }

    // Interactive exec requested.
    var (
        out, stderr io.Writer
        in          io.ReadCloser
        errCh       chan error
    )

    if execConfig.AttachStdin {
        in = dockerCli.In()
    }
    if execConfig.AttachStdout {
        out = dockerCli.Out()
    }
    if execConfig.AttachStderr {
        if execConfig.Tty {
            stderr = dockerCli.Out()
        } else {
            stderr = dockerCli.Err()
        }
    }

    resp, err := client.ContainerExecAttach(ctx, execID, *execConfig)
    if err != nil {
        return err
    }
    defer resp.Close()
    errCh = promise.Go(func() error {
        return holdHijackedConnection(ctx, dockerCli, execConfig.Tty, in, out, stderr, resp)
    })

    if execConfig.Tty && dockerCli.In().IsTerminal() {
        if err := MonitorTtySize(ctx, dockerCli, execID, true); err != nil {
            fmt.Fprintf(dockerCli.Err(), "Error monitoring TTY size: %s\n", err)
        }
    }

    if err := <-errCh; err != nil {
        logrus.Debugf("Error hijack: %s", err)
        return err
    }

    var status int
    if _, status, err = getExecExitCode(ctx, client, execID); err != nil {
        return err
    }

    if status != 0 {
        return cli.StatusError{StatusCode: status}
    }

    return nil
}

func parseExec(opts *execOptions, execCmd []string) (*types.ExecConfig, error) {
    execConfig := &types.ExecConfig{
        User:       opts.user,
        Privileged: opts.privileged,
        Tty:        opts.tty,
        Cmd:        execCmd,
        Detach:     opts.detach,
    }

    // If -d is not set, attach to everything by default
    if !opts.detach {
        execConfig.AttachStdout = true
        execConfig.AttachStderr = true
        if opts.interactive {
            execConfig.AttachStdin = true
        }
    }

    if opts.env != nil {
        execConfig.Env = opts.env.GetAll()
    }

    return execConfig, nil
}
docker/docker/opts/opts.go
func NewListOptsRef(values *[]string, validator ValidatorFctType) *ListOpts {
    return &ListOpts{
        values:    values,
        validator: validator,
    }
}

docker/docker/client/container_exec.goはこちらを参照 docker/docker
spf13/cobra/command.goはこちらを参照 spf13/cobra

各関数の挙動

func newExecOptions(): opts.go内のfunc NewListOptsRef()の返り値を返します

func NewExecCommand():
1. func newExecOptions()をコールし、オプションリストを取得します
2. spf13/cobracommand.go内のCommand構造体を取得します
3. spf13/pflagflag.go内でオプションに関して定義を行います
4. cobra.Command構造体を返します

func runExec():
1. コマンド情報をパースして取得します
2. デタッチキーの指定があれば上書きします
3. 環境変数を取得します
4. dockerCli.Client()からexecIDを取得します
5. デタッチキーとttyを渡してclient.ContainerExecStart()をコールします (ttyとは - teratail)
6. dockerCliからstdin stdout stderrを取得します
7. client.ContainerExecAttach()をコールします

func parseExec(): コマンド情報をパースして返します

原因

docker/docker/cli/command/container/exec.go
if opts.interactive {
    execConfig.AttachStdin = true
}

オプションに-iが無い場合はコマンドラインから入力できないという仕様にここで気づきました。

参考

docker/docker - Github
spf13/cobra - Github
spf13/pflag - Github
ttyとは - teratail