example of exec in k8s's pod by using go client

I want to use k8s go client to exec command in a pod. However I cannot find any example about this. So I read kubectl exec source code, and write code as below. And err = exec.Stream(sopt) always get an error without any message. Can anyone tell me how to debug this problem, or give me a correct example.

config := &restclient.Config{
	Host:     "http://192.168.8.175:8080",
	Insecure: true,
}

config.ContentConfig.GroupVersion = &api.Unversioned
config.ContentConfig.NegotiatedSerializer = api.Codecs

restClient, err := restclient.RESTClientFor(config)
if err != nil {
	panic(err.Error())
}

req := restClient.Post().Resource("pods").Name("wordpress-mysql-213049546-29s7d").Namespace("default").SubResource("exec").Param("container", "mysql")
req.VersionedParams(&api.PodExecOptions{
	Container: "mysql",
	Command:   []string{"ls"},
	Stdin:     true,
	Stdout:    true,
}, api.ParameterCodec)

exec, err := remotecommand.NewExecutor(config, "POST", req.URL())
if err != nil {
	panic(err.Error())
}
sopt := remotecommand.StreamOptions{
	SupportedProtocols: remotecommandserver.SupportedStreamingProtocols,
	Stdin:              os.Stdin,
	Stdout:             os.Stdout,
	Stderr:             os.Stderr,
	Tty:                false,
}

err = exec.Stream(sopt)
if err != nil {
	panic(err.Error())
}

package k8s
import (
"io"
v1 "k8s.io/api/core/v1"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/kubernetes/scheme"
restclient "k8s.io/client-go/rest"
"k8s.io/client-go/tools/remotecommand"
)
// ExecCmd exec command on specific pod and wait the command's output.
func ExecCmdExample(client kubernetes.Interface, config *restclient.Config, podName string,
command string, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
cmd := []string{
"sh",
"-c",
command,
}
req := client.CoreV1().RESTClient().Post().Resource("pods").Name(podName).
Namespace("default").SubResource("exec")
option := &v1.PodExecOptions{
Command: cmd,
Stdin:   true,
Stdout:  true,
Stderr:  true,
TTY:     true,
}
if stdin == nil {
option.Stdin = false
}
req.VersionedParams(
option,
scheme.ParameterCodec,
)
exec, err := remotecommand.NewSPDYExecutor(config, "POST", req.URL())
if err != nil {
return err
}
err = exec.Stream(remotecommand.StreamOptions{
Stdin:  stdin,
Stdout: stdout,
Stderr: stderr,
})
if err != nil {
return err
}
return nil
}

It works to me.

Command: []string{"/bin/sh", "-c", "ls", "-ll", "."}

The array of strings should start with /bin/sh (the path to the shell executable).

Then -c flag can be added as the second element to indicate that the subsequent string will be interpreted as a command to be executed by the shell.

Finally, any additional arguments for the command can be added as subsequent elements in the array.

you miss .CoreV1() when create request!