背景
從 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。
參考鏈接:
作者:宋佳洋
出處:http://www.songjiayang.com/posts/shi-yong-cgroup-shi-xian-nei-cun-kong-zhi