Go 中使用 CGroup 實現進程內存控制

【導讀】Cgroup 支持對進程內存進行隔離和限制，go 進程如何實現內存限制？本文通過文件操作 cgroup，詳細介紹了 cgroup 的使用。

背景

從 Linux 內核 2.6.25 開始，CGroup 支持對進程內存的隔離和限制，這也是 Docker 等容器技術的底層支撐。

使用 CGroup 有如下好處：

在共享的機器上，進程相互隔離，互不影響，對其它進程是種保護。對於存在內存泄漏的進程，可以設置內存限制，通過系統 OOM 觸發的 Kill 信號量來實現重啓。

CGroup 快速入門

默認掛載分組

Linux 系統默認支持 CGroup, 而且默認掛載所有選項，可以使用 mount -t cgroup 來查看：

$ mount -t cgroup

cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd)
cgroup on /sys/fs/cgroup/net_cls type cgroup (rw,nosuid,nodev,noexec,relatime,net_cls)
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)
cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event)
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpuacct,cpu)
cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,nosuid,nodev,noexec,relatime,hugetlb)
cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)
cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)

CGroup 相關的資源包括 cpu,memory,blkio等，而我們今天主要關心的是內存，即 /sys/fs/cgroup/memory。

創建 climits 內存分組
我們可以使用 mkdir /sys/fs/cgroup/memory/climits 來創建屬於自己的內存組 climits:

$ mkdir /sys/fs/cgroup/memory/climits

此時系統已經在目錄 /sys/fs/cgroup/memory/climits 下爲我們生成了內存相關的所有配置：

$ ls -la /sys/fs/cgroup/memory/climits

cgroup.clone_children  memory.kmem.limit_in_bytes          memory.kmem.tcp.usage_in_bytes  memory.memsw.max_usage_in_bytes  memory.soft_limit_in_bytes  tasks
cgroup.event_control   memory.kmem.max_usage_in_bytes      memory.kmem.usage_in_bytes      memory.memsw.usage_in_bytes      memory.stat
cgroup.procs           memory.kmem.slabinfo                memory.limit_in_bytes           memory.move_charge_at_immigrate  memory.swappiness
memory.failcnt         memory.kmem.tcp.failcnt             memory.max_usage_in_bytes       memory.numa_stat                 memory.usage_in_bytes
memory.force_empty     memory.kmem.tcp.limit_in_bytes      memory.memsw.failcnt            memory.oom_control               memory.use_hierarchy
memory.kmem.failcnt    memory.kmem.tcp.max_usage_in_bytes  memory.memsw.limit_in_bytes     memory.pressure_level            notify_on_release

主要配置含義：

cgroup.procs: 使用該組配置的進程列表。
memory.limit_in_bytes：內存使用限制。
memory.memsw.limit_in_bytes：內存和交換分區總計限制。
memory.swappiness: 交換分區使用比例。
memory.usage_in_bytes：當前進程內存使用量。
memory.stat: 內存使用統計信息。
memory.oom_control: OOM 控制參數。

設置內存限制

假設有進程 pid 1234，希望設置內存限制爲 10MB，我們可以這樣操作：

limit_in_bytes 設置爲 10MB:

echo 10M > /sys/fs/cgroup/memory/climits/memory.limit_in_bytes

swappiness 設置爲 0，表示禁用交換分區，實際生產中可以配置合適的比例:

echo 0 > /sys/fs/cgroup/memory/climits/memory.swappiness

添加控制進程:

echo 1234 > /sys/fs/cgroup/memory/climits/cgroup.procs

當進程 1234 使用內存超過 10MB 的時候，默認進程 1234 會觸發 OOM，被系統 Kill 掉。

Go 實現進程內存限制

上面我們已經講到 CGroup 內存限制的原理，接下來我們就用 Go 代碼來實現一個簡單的進程內存限制以及守護（被 Kill 能夠自動重啓）。

進程測試代碼:

該代碼主要邏輯是每隔一秒申請 1MB 存儲空間，並且不釋放，然後再打印下 Go 的內存申請情況。

// example/simple_app.go
package main

import (
    "fmt"
    "os"
    "runtime"
    "time"
)

const (
    MB = 1024 * 1024
)

func main() {
    blocks := make([][MB]byte, 0)
    fmt.Println("Child pid is", os.Getpid())

    for i := 0; ; i++ {
        blocks = append(blocks, [MB]byte{})
        printMemUsage()
        time.Sleep(time.Second)
    }
}

func printMemUsage() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
    fmt.Printf("\tSys = %v MiB \n", bToMb(m.Sys))
}

func bToMb(b uint64) uint64 {
    return b / MB
}

通過 GOOS=linux GOARCH=amd64 go build -o simpleapp example/simple_app.go 命令，編譯一個 Linux 版本的可執行程序 simpleapp。

進程守護程序

該守護程序主要實現進程內存限制和進程守護（自動重啓），代碼如下：

// main.go
package main

import (
    "flag"
    "fmt"
    "io/ioutil"
    "log"
    "os"
    "os/exec"
    "os/signal"
    "path/filepath"
    "syscall"
)

var (
    rssLimit   int
    cgroupRoot string
)

const (
    procsFile       = "cgroup.procs"
    memoryLimitFile = "memory.limit_in_bytes"
    swapLimitFile   = "memory.swappiness"
)

func init() {
    flag.IntVar(&rssLimit, "memory", 10, "memory limit with MB.")
    flag.StringVar(&cgroupRoot, "root", "/sys/fs/cgroup/memory/climits", "cgroup root path")
}

func main() {
    flag.Parse()

    // set memory limit
    mPath := filepath.Join(cgroupRoot, memoryLimitFile)
    whiteFile(mPath, rssLimit*1024*1024)

    // set swap memory limit to zero
    sPath := filepath.Join(cgroupRoot, swapLimitFile)
    whiteFile(sPath, 0)

    go startCmd("./simpleapp")

    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt)
    s := <-c
    fmt.Println("Got signal:", s)
}

func whiteFile(path string, value int) {
    if err := ioutil.WriteFile(path, []byte(fmt.Sprintf("%d", value)), 0755); err != nil {
        log.Panic(err)
    }
}

type ExitStatus struct {
    Signal os.Signal
    Code   int
}

func startCmd(command string) {
    restart := make(chan ExitStatus, 1)

    runner := func() {
        cmd := exec.Cmd{
            Path: command,
        }

        cmd.Stdout = os.Stdout

        // start app
        if err := cmd.Start(); err != nil {
            log.Panic(err)
        }

        fmt.Println("add pid", cmd.Process.Pid, "to file cgroup.procs")

        // set cgroup procs id
        pPath := filepath.Join(cgroupRoot, procsFile)
        whiteFile(pPath, cmd.Process.Pid)

        if err := cmd.Wait(); err != nil {
            fmt.Println("cmd return with error:", err)
        }

        status := cmd.ProcessState.Sys().(syscall.WaitStatus)

        options := ExitStatus{
            Code: status.ExitStatus(),
        }

        if status.Signaled() {
            options.Signal = status.Signal()
        }

        cmd.Process.Kill()

        restart <- options
    }

    go runner()

    for {
        status := <-restart

        switch status.Signal {
        case os.Kill:
            fmt.Println("app is killed by system")
        default:
            fmt.Println("app exit with code:", status.Code)
            return
        }

        fmt.Println("restart app..")
        go runner()
    }
}

這段代碼的主要邏輯爲：

通過配置參數 memory ，修改 memory.limit_in_bytes 和 memory.swappiness 來設置最大內存使用量。
通過 cmd.Start() 啓動一個進程。
將新生成的進程號 cmd.Process.Pid 寫到 cgroup.procs。
通過 cmd.Wait() 接收命令輸出結果。
如果返回結果爲 Kill 信號的時候，能夠重啓任務。
通過 GOOS=linux GOARCH=amd64 go build -o climits main.go 命令，編譯一個 Linux 版本的可執行程序 climits。

運行示例

我們已經提前創建了一個叫做 climits 的內存相關 CGroup，並且目錄下包含 climits, simpleapp 兩個可執行程序。

此時運行命令 ./climits -memory 60，可以看到如下輸出：

[root@A04-R08-I197-202-3DGCDB2 climits]# ./climit -memory 60
add pid 48189 to file cgroup.procs
Child pid is 48189
Alloc = 1 MiB   Sys = 66 MiB 
Alloc = 3 MiB   Sys = 66 MiB 
Alloc = 8 MiB   Sys = 68 MiB 
Alloc = 8 MiB   Sys = 68 MiB 
Alloc = 16 MiB  Sys = 68 MiB 
Alloc = 16 MiB  Sys = 68 MiB 
...
Alloc = 32 MiB  Sys = 134 MiB 
Alloc = 32 MiB  Sys = 134 MiB 
cmd return with error: signal: killed
app is killed by system
restart app..
add pid 48256 to file cgroup.procs
Child pid is 48256
Alloc = 1 MiB   Sys = 66 MiB 
Alloc = 3 MiB   Sys = 68 MiB 
Alloc = 4 MiB   Sys = 68 MiB 
Alloc = 12 MiB  Sys = 68 MiB 
^CGot signal: interrupt

通過輸出可以看出，當內存超過一定限制後，進程 48189 會被 Kill 掉，守護程序收到 Kill 信號後，會先關閉老進程，再重啓新進程 48256。

總結

這篇文章主要簡單介紹了 CGroup 控制進程內存的原理，並通過 Go 代碼實現一個簡單的進程守護，支持內存限制和進程重啓。我們還可以通過它來查看進程內存使用詳細信息，以此完成一個簡易內存 container。

轉自：51reboot 運維開發

zhuanlan.zhihu.com/p/79859598

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/D2nmrQtFm9XsFOcDIZjc9g

背景

使用 CGroup 有如下好處：

CGroup 快速入門

設置內存限制

Go 實現進程內存限制

運行示例

總結

猜你喜歡