Go语言中启动独立子进程并指定用户/组与I/O控制教程

func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error)

process, err := os.StartProcess(...)
if err == nil {
    err = process.Release() // 分离子进程
    if err != nil {
        fmt.Println("Error releasing process:", err)
    }
}

import "syscall"

const (
    UID = 501 // 示例用户ID
    GID = 100 // 示例组ID
)

// 创建Credential结构体
var cred = &syscall.Credential{UID: UID, GID: GID, Groups: []uint32{}}

// 创建SysProcAttr结构体，并将Credential赋值给它
var sysproc = &syscall.SysProcAttr{Credential: cred}

// 将sysproc赋值给os.ProcAttr的Sys字段
var attr = os.ProcAttr{
    // ... 其他属性
    Sys: sysproc,
}

// 继承父进程所有环境变量
var attr = os.ProcAttr{
    Env: os.Environ(),
    // ...
}

// 或者设置自定义环境变量
var customEnv = []string{
    "PATH=/usr/local/bin:/usr/bin:/bin",
    "MY_VAR=hello",
}
var attr = os.ProcAttr{
    Env: customEnv,
    // ...
}

// 将标准输入连接到父进程的stdin，标准输出和错误重定向到文件
stdoutFile, _ := os.OpenFile("stdout.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
stderrFile, _ := os.OpenFile("stderr.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)

var attr = os.ProcAttr{
    Files: []*os.File{
        os.Stdin,     // 子进程继承父进程的stdin
        stdoutFile,   // 子进程的stdout输出到stdout.log
        stderrFile,   // 子进程的stderr输出到stderr.log
    },
    // ...
}
// 记得在不再需要时关闭文件句柄
defer stdoutFile.Close()
defer stderrFile.Close()

// 如果设置为nil，例如 Files: []*os.File{os.Stdin, nil, nil}，
// 则子进程的stdout和stderr将不会有连接，通常行为是写入/dev/null。

package main

import (
    "fmt"
    "os"
    "syscall"
    "time"
)

const (
    // 注意：这些UID和GID需要实际存在于你的Linux系统上，
    // 并且运行本程序的用户需要有足够的权限（通常是root）来设置它们。
    // 示例：可以尝试使用nobody用户（UID 65534）和nogroup组（GID 65534）
    // 或者在你的系统上创建一个专门的用户和组。
    TARGET_UID = 65534 // 示例：nobody用户
    TARGET_GID = 65534 // 示例：nogroup组
)

func main() {
    fmt.Println("父进程开始运行...")

    // 1. 配置子进程的用户和组ID
    // Credential字段用于设置进程的UID, GID和附加GIDS。
    // 注意：这通常需要以root权限运行程序才能成功设置。
    var cred = &syscall.Credential{
        Uid: TARGET_UID,
        Gid: TARGET_GID,
        Groups: []uint32{}, // 可以指定附加组ID
    }

    // 2. 配置系统特定的进程属性
    // Noctty标志用于将进程从父进程的控制终端分离。
    // 虽然Release()是主要的分离机制，Noctty可以提供额外的健壮性。
    var sysproc = &syscall.SysProcAttr{
        Credential: cred,
        Noctty:     true, // 从控制终端分离
    }

    // 3. 配置os.ProcAttr结构体
    // Dir: 子进程的工作目录。
    // Env: 子进程的环境变量，这里继承父进程所有环境变量。
    // Files: 子进程的文件描述符。
    //   - Files[0]: os.Stdin (继承父进程的stdin)
    //   - Files[1]: nil (关闭stdout，或重定向到/dev/null)
    //   - Files[2]: nil (关闭stderr，或重定向到/dev/null)
    // Sys: 包含系统特定的属性，如UID/GID。
    var attr = os.ProcAttr{
        Dir: ".", // 子进程在当前目录运行
        Env: os.Environ(),
        Files: []*os.File{
            os.Stdin, // 继承父进程的stdin
            nil,      // 关闭stdout
            nil,      // 关闭stderr
        },
        Sys: sysproc,
    }

    // 4. 启动子进程
    // 我们启动一个'sleep 60'进程，它将持续运行60秒。
    process, err := os.StartProcess("/bin/sleep", []string{"sleep", "60"}, &attr)
    if err != nil {
        fmt.Printf("启动子进程失败: %v\n", err)
        return
    }

    fmt.Printf("子进程已启动，PID: %d\n", process.Pid)

    // 5. 分离子进程
    // Release()方法将子进程从父进程中分离，确保父进程退出后子进程仍然运行。
    err = process.Release()
    if err != nil {
        fmt.Printf("分离子进程失败: %v\n", err)
        // 即使分离失败，子进程可能也已经启动，但其生命周期会受父进程影响
    } else {
        fmt.Println("子进程已成功分离。")
    }

    fmt.Println("父进程等待5秒后退出，子进程应继续运行...")
    time.Sleep(5 * time.Second)
    fmt.Println("父进程退出。")
}