How does Go write code and execute system commands to start a new terminal as a result?

When I execute an ordinary command in Go code, for example ls -ls, it can be executed normally and return the result:

// Error handling is omitted, in fact there is error handling in my code

func main() {
	for {
		var stdout bytes.Buffer
		cmd := exec.Command("sh","-c","ls -ls")
		cmd.Stdout = &stdout
		cmd.Run()
		fmt.Println(stdout.String())
	}
}

The execution results are as follows：

[root@10-x-x-xx /root]# go run main.go
/usr/bin/sh -c ls -ls
stdout: total 8
4 -rw-r--r-- 1 root root 358 Aug 14 23:09 main.go
4 -rw-r--r-- 1 root root 167 Aug 14 16:07 temp.yaml

But when I execute a command to start a new terminal (not sure if my understanding is correct), the program returns normally with no errors, no output, and no jump to the new terminal.

For example: nsenter -n --target PID. This is a command to enter the network namespace. Normally, it will return to a "#" and enter successfully.

// Error handling is omitted, in fact there is error handling in my code

func main() {
	for {
		var stdout bytes.Buffer
		cmd := exec.Command("sh","-c","nsenter -n --target 123")
		cmd.Stdout = &stdout
		cmd.Run()
		fmt.Println(stdout.String())
	}
}

The program exits after the execution is complete, but does not actually enter the network namespace.

But when I use python, there is no such problem, it is executable.

import os
os.system("nsenter -n --target 24347")

Or another question, how to write code in Go, so that I can execute this code to ssh to other hosts, I feel that this seems to be the same problem.

You've got a couple of problems there.

First, you're trying to spawn an interactive command (nsenter will by default start a shell in the target namespace), but you're also connecting stdout to a variable, which means even if it works you wouldn't be able to see any output until after the command exits, which is probably not what you want.

Secondly, you're not connecting stdin to anything useful, which means that most interactive commands will simply exit.

To start an interactive subcommand in Go, you would write something like this:

package main

import (
	"os"
	"os/exec"
)

func main() {
	cmd := exec.Command("bash", "--norc")
	cmd.Stdout = os.Stdout
	cmd.Stdin = os.Stdin
	cmd.Stderr = os.Stderr
	cmd.Env = os.Environ()
	cmd.Env = append(cmd.Env, "PS1=example$ ")
	cmd.Run()
}

(This starts a bash shell with the prompt example$ )

The key here is that we're connecting stdin, stdout, and stderr
to the corresponding descriptors of the parent process, which allows
us to interact with the subprocess.

If you weren't trying to start an interactive shell, what you have now
would work. That is, you could write:

package main

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

func main() {
	var stdout bytes.Buffer
	cmd := exec.Command("sudo", "nsenter", "-n", "--target", "2399896", "ip", "addr")
	cmd.Stdout = &stdout
	cmd.Run()
	fmt.Println(stdout.String())
}

The above works just fine and displays the results of running ip
addr inside the target network namespace.

Note that you might more typically using the Output method from the
execmodule:

package main

import (
	"fmt"
	"os/exec"
)

func main() {
	cmd := exec.Command("sudo", "nsenter", "-n", "--target", "2399896", "ip", "addr")
	stdout, err := cmd.Output()
	if err != nil {
		panic(err)
	}
	fmt.Println(string(stdout))
}