Ubuntu配置Go环境总失败？资深SRE拆解7大隐性陷阱：systemd限制、snap冲突、ARM64交叉编译兼容性

第一章：Ubuntu配置Go环境的典型失败现象与诊断起点

当在Ubuntu系统中配置Go开发环境时，开发者常遭遇看似成功实则失效的“伪配置”状态。最典型的失败现象包括：go version 命令返回 command not found，或虽能执行却显示错误版本；GOPATH 和 GOROOT 环境变量未被Shell会话识别；go run hello.go 报错 cannot find package "fmt"；以及使用 go mod init 时提示 go: modules disabled by GO111MODULE=off。

这些现象背后往往指向几个共性根源：

Go二进制未正确写入 $PATH（如仅解压但未将 bin/ 目录加入 ~/.bashrc 或 ~/.profile）
多版本Go混用导致 GOROOT 指向错误路径（例如从 apt install golang 安装的旧版与手动下载的新版冲突）
Shell配置文件未重新加载（修改 ~/.bashrc 后未执行 source ~/.bashrc）

快速诊断可从以下命令开始：

# 检查Go二进制是否存在且可执行
which go || echo "go not found in PATH"

# 查看当前Shell中是否已导出关键变量
env | grep -E '^(GOROOT|GOPATH|GO111MODULE)'

# 验证Go安装包完整性（以/usr/local/go为例）
ls -l /usr/local/go/bin/go  # 应为可执行文件

常见环境变量配置误区如下表所示：

错误写法	正确写法	说明
`export GOROOT=/usr/local/go/`	`export GOROOT=/usr/local/go`	末尾斜杠可能导致 `go env` 解析异常
`export PATH=$PATH:/usr/local/go/bin`	`export PATH="/usr/local/go/bin:$PATH"`	将Go置于PATH前端，避免系统旧版干扰
在 `~/.bashrc` 中设置但使用 `zsh` 终端	改为编辑 `~/.zshrc`	Shell配置文件需与当前终端匹配

若 go env 输出中 GOROOT 显示为空或 /usr/lib/go（apt安装路径），说明手动安装的Go未被识别——此时应检查 GOROOT 是否显式导出，且确认 /usr/local/go 下存在 src, pkg, bin 三个核心子目录。

第二章：systemd资源限制引发的Go构建失败深度剖析

2.1 systemd用户会话与系统服务的cgroup边界理论

systemd 通过 cgroup v2 统一管理资源隔离，但用户会话（user@.service）与系统服务（如 sshd.service）严格分属不同 cgroup 层级树。

用户会话的 cgroup 路径

# 查看当前登录用户的 cgroup 根路径
systemctl --user show --property=Slice
# 输出示例：Slice=user-1000.slice

该路径位于 /sys/fs/cgroup/user.slice/user-1000.slice/，与系统级 /sys/fs/cgroup/system.slice/ 完全隔离——内核禁止跨 slice 移动进程。

关键隔离机制对比

维度	用户会话（`user@.service`）	系统服务（`system.slice`）
cgroup 路径前缀	`/user.slice/user-*.slice`	`/system.slice/`
启动上下文	PAM `pam_systemd.so` 触发	`systemd --system` 直接托管
资源继承	继承 `user.slice` 默认限额	继承 `system.slice` 配置

cgroup 边界不可逾越性验证

# 尝试将用户进程迁入 system.slice（失败）
echo $$ | sudo tee /sys/fs/cgroup/system.slice/cgroup.procs
# → bash: echo: write error: Invalid argument

此错误源于内核 cgroup_attach_task() 对 CGROUP_THREAD 和 CGROUP_PROCESSES 的权限校验：用户会话进程无权写入系统 slice 的 cgroup.procs。

graph TD
    A[login process] -->|PAM + dbus| B[user@1000.service]
    B --> C[user-1000.slice]
    D[sshd.service] --> E[system.slice]
    C -.->|cgroup v2 mount barrier| E

2.2 查看go build进程实际受限资源（MemoryMax/CPUQuota）的实操命令链

定位 go build 所在 cgroup 路径

# 查找当前 shell 启动的 go build 进程（含子进程）的 cgroup v2 路径
pidof go | xargs -I{} cat /proc/{}/cgroup | grep -o '/sys/fs/cgroup/[^[:space:]]*'

该命令通过 pidof go 获取进程 PID，再读取 /proc/<pid>/cgroup 提取 v2 统一层次路径，是后续资源查询的入口。

提取实时资源限制

# 假设 cgroup 路径为 /sys/fs/cgroup/user.slice/user-1000.slice/session-1.scope
cgpath="/sys/fs/cgroup/user.slice/user-1000.slice/session-1.scope"
cat "$cgpath/memory.max" 2>/dev/null || echo "n/a"
cat "$cgpath/cpu.max" 2>/dev/null | awk '{print "CPUQuota: " $1 "/" $2 " (us per period)"}'

memory.max 直接返回字节数（如 536870912 = 512MiB）；cpu.max 返回 max period 格式，需换算为百分比（如 50000 100000 → 50%）。

关键字段对照表

cgroup 文件	含义	典型值	说明
`memory.max`	内存硬上限	`536870912`	`max` 为 `max`，`-1` 表示无限制
`cpu.max`	CPU 时间配额（ns/period）	`50000 100000`	`50%` 使用率上限

验证流程示意

graph TD
  A[启动 go build] --> B[内核分配至某 cgroup]
  B --> C[读取 /proc/PID/cgroup 定位路径]
  C --> D[cat memory.max & cpu.max]
  D --> E[解析数值并换算为可读配额]

2.3 修改systemd user slice限制并持久化配置的完整流程

创建用户级资源限制配置

在 ~/.config/systemd/user.conf 中启用用户 slice 控制：

# 启用用户会话 slice 并允许资源限制
DefaultLimitCPU=80%
DefaultLimitMemory=2G

此配置使 user-$(UID).slice 自动继承设定值，但需重启用户 session 生效（loginctl terminate-user $USER）。

持久化 slice 级别限制

创建覆盖文件 /etc/systemd/system/user-*.slice.d/limits.conf：

[Slice]
MemoryMax=3G
CPUQuota=75%
TasksMax=512

MemoryMax 强制硬限制；CPUQuota 是周期内 CPU 时间占比（非核心数）；TasksMax 防止 fork 炸弹。

验证与生效机制

项目	命令	说明
查看当前 slice 限制	`systemctl --user show -p MemoryMax,CPUSchedulingPolicy user.slice`	显示运行时生效值
重载配置	`systemctl --user daemon-reload && systemctl --user restart user.slice`	必须重启 slice 才应用新 limit

graph TD
    A[修改 ~/.config/systemd/user.conf] --> B[启用 DefaultLimit*]
    C[创建 /etc/.../user-*.slice.d/limits.conf] --> D[设置 Slice 级硬限]
    B & D --> E[daemon-reload + restart user.slice]
    E --> F[loginctl show-user $USER \| grep MemoryMax]

2.4 验证Go编译器在受限cgroup中内存分配行为的调试技巧

观察实时内存分配节拍

使用 go tool trace 捕获运行时事件，配合 cgroup 内存限制：

# 在 memory.max=128M 的 cgroup v2 中运行
sudo cgexec -g memory:/go-test ./main &
go tool trace -http=:8080 trace.out

此命令强制 Go 程序在严格内存边界内执行，go tool trace 可捕获 GC, heap alloc, stack growth 等关键事件，揭示分配器是否因 cgroup 压力提前触发 GC。

关键指标比对表

指标	正常环境	cgroup(128M)	差异原因
`sys:memstats:alloc`	85MB	32MB	分配器主动降速防 OOM
`gc:pause:avg`	120μs	410μs	更频繁的增量 GC

内存压力下 runtime 调试流程

graph TD
    A[启动带 memory.max 的 cgroup] --> B[运行 go build -gcflags='-m' 观察逃逸分析]
    B --> C[设置 GODEBUG=madvdontneed=1 避免页回收干扰]
    C --> D[读取 /sys/fs/cgroup/memory.events 观察 oom_kill]

2.5 混合部署场景下systemd与Docker/Containerd资源策略冲突规避方案

在混合部署中，systemd 与 containerd 均尝试管理 cgroups v2 资源边界，易引发 CPU、内存配额覆盖或 OOM 优先级错乱。

核心冲突根源

systemd 默认启用 Delegate=yes，将子进程 cgroup 控制权下放；
containerd 默认启用 systemd_cgroup = true，依赖 systemd 管理容器 cgroup；
双重委托导致资源路径嵌套混乱（如 /system.slice/docker.service/kubepods-burstable-podxxx/...）。

资源策略对齐表

维度	systemd 管理方式	containerd 推荐方式
CPU 配额	`CPUQuota=80%`	`--cpus=0.8`（运行时传入）
内存限制	`MemoryMax=2G`	`--memory=2g`
OOMScoreAdj	`OOMScoreAdjust=-900`	容器内不设，由 Pod QoS 统一控制

# 验证 cgroup 层级纯净性
ls /sys/fs/cgroup/system.slice/docker.service/ | head -3
# 输出应无嵌套容器路径，表明 delegation 已解耦

该命令确认容器未被挂载至 docker.service 子 cgroup 下，验证 delegation 隔离生效。

第三章：Snap包管理器对Go工具链的静默劫持机制

3.1 Snap沙箱路径隔离原理与/usr/bin/go符号链接劫持路径分析

Snap 应用默认运行在 strict 模式沙箱中，通过 mount --bind 和 namespaces 实现文件系统视图隔离。/usr/bin/go 在宿主机中常为指向 /snap/go/current/bin/go 的符号链接，但 Snap 运行时会覆盖 $PATH 并注入自己的 /usr/bin 视图。

沙箱内路径解析流程

# 查看 Snap 运行时实际解析路径
$ snap run --shell my-go-app -c 'echo $PATH; ls -l /usr/bin/go'
# 输出示例：
# /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
# lrwxrwxrwx 1 root root 22 Apr 10 12:00 /usr/bin/go -> /snap/go/current/bin/go

该命令揭示 Snap 运行时仍沿用宿主机符号链接——因 --classic 模式未启用，且 /usr/bin 未被完全重映射，导致路径解析逃逸沙箱约束。

关键路径劫持条件

宿主机 /usr/bin/go 符号链接目标可被恶意 snap 修改（需 sudo snap refresh go --channel=... 权限）
应用未显式指定 go 绝对路径（如 /snap/go/current/bin/go）
core22 基础镜像未启用 layout 覆盖 /usr/bin

风险等级	触发条件	缓解方式
高	classic 模式 + 外部 snap 控制	强制使用 `--jailmode`
中	strict 模式 + 符号链接未锁定	在 snapcraft.yaml 中声明 layout

graph TD
    A[用户执行 go build] --> B{Snap runtime 解析 /usr/bin/go}
    B --> C[读取宿主机符号链接]
    C --> D[跳转至 /snap/go/current/bin/go]
    D --> E[实际执行非沙箱校验的二进制]

3.2 识别当前go二进制真实来源（snap vs apt vs manual install）的三步检测法

第一步：定位可执行文件路径

which go
# 输出示例：/usr/bin/go 或 /snap/bin/go 或 /usr/local/go/bin/go

which 返回 $PATH 中首个匹配项，但无法区分符号链接源头。需结合 readlink -f 进一步解析。

第二步：追溯符号链接与包管理元数据

readlink -f $(which go) | head -c 50  # 查看实际路径前缀
dpkg -S $(which go) 2>/dev/null       # apt 安装时返回包名
snap list --all | grep -i go          # snap 安装时显示版本与通道

dpkg -S 仅对 Debian/Ubuntu 的 apt 包有效；snap list 对 snap 安装唯一有效；手动安装通常无对应包记录。

第三步：交叉验证安装特征

来源类型	典型路径前缀	`/proc/self/exe` 指向	是否含 `snap` mount namespace
apt	`/usr/bin/go`	`/usr/lib/go-1.21/bin/go`	否
snap	`/snap/bin/go`	`/snap/go/1234/usr/bin/go`	是（`ls /proc/$(pidof go)/ns/` 含 `mnt` 变更）
手动	`/usr/local/go/bin/go`	原始路径，无重定向	否

graph TD
  A[which go] --> B{readlink -f}
  B --> C[/usr/bin/go?]
  B --> D[/snap/bin/go?]
  B --> E[/usr/local/go/bin/go?]
  C --> F[dpkg -S → apt]
  D --> G[snap list → snap]
  E --> H[无包管理器记录 → manual]

3.3 安全卸载snap版go并重建PATH优先级的原子化操作脚本

Snap包管理器安装的Go常驻/snap/bin/go，与系统级/usr/local/go/bin/go冲突，导致which go返回非预期路径。需原子化完成卸载、清理残留、重置PATH三步。

原子性保障策略

使用set -euxo pipefail启用严格错误中断
所有路径操作前校验存在性与权限
PATH重写仅作用于当前shell会话，避免污染全局环境

核心执行脚本

#!/bin/bash
set -euxo pipefail

# 1. 卸载snap版go（静默失败亦继续）
snap remove --purge go 2>/dev/null || true

# 2. 清理snap残留符号链接
rm -f /snap/bin/go

# 3. 临时提升/usr/local/go/bin优先级（仅当前shell）
export PATH="/usr/local/go/bin:$(echo $PATH | sed 's|/snap/bin||g')"

# 4. 验证结果
go version && echo "✅ PATH updated, snap-go removed"

逻辑分析：snap remove --purge彻底删除包及用户数据；sed 's|/snap/bin||g'安全剔除PATH中/snap/bin（避免误删含/snap/bin子串的路径）；export PATH=...前置本地Go路径，确保which go返回/usr/local/go/bin/go。

第四章：ARM64平台交叉编译兼容性陷阱与Go模块生态适配

4.1 Ubuntu ARM64系统中CGO_ENABLED=1与libc版本错配的根本原因解析

当 CGO_ENABLED=1 时，Go 编译器会链接宿主机的 C 运行时库（glibc），而 Ubuntu ARM64 官方镜像（如 ubuntu:24.04）默认使用 glibc 2.39，但部分交叉构建环境或容器内嵌工具链仍依赖旧版头文件或符号（如 GLIBC_2.34）。

根本诱因：动态链接时符号版本不兼容

# 查看目标二进制依赖的 glibc 符号版本
readelf -V ./myapp | grep -A5 "Version definition"
# 输出示例：
# 0x0001: Rev: 1  Flags: BASE  Index: 1  Cnt: 2  Name: libpthread.so.0
# 0x0002: Rev: 1  Flags: none  Index: 1  Cnt: 1  Name: GLIBC_2.34

该命令揭示可执行文件硬编码了 GLIBC_2.34 符号需求，但运行时系统仅提供 GLIBC_2.39 ——注意：glibc 向后兼容，但不向前兼容；缺失低版本符号（如 GLIBC_2.34）将触发 Symbol not found 错误。

典型错配场景对比

环境类型	编译时 libc 版本	运行时 libc 版本	是否安全
Ubuntu 22.04 宿主机编译 → 24.04 容器运行	2.35	2.39	✅
Alpine（musl）交叉编译 → Ubuntu ARM64 运行	musl	glibc 2.39	❌（ABI 不兼容）

graph TD
    A[CGO_ENABLED=1] --> B[调用 gcc 链接 libc]
    B --> C{libc 头文件 & 符号表来源}
    C -->|来自构建环境 sysroot| D[可能含旧版 symbol version]
    C -->|来自运行环境| E[glibc 版本 ≥ 编译时？]
    D -->|否| F[undefined symbol: __libc_start_main@GLIBC_2.34]

4.2 构建x86_64目标二进制时GOOS/GOARCH/CC_FOR_TARGET协同配置实践

构建跨平台 Go 二进制时，三者需严格对齐：GOOS 定义目标操作系统（如 linux），GOARCH 指定 CPU 架构（如 amd64），而 CC_FOR_TARGET 则指向适配该目标的 C 交叉编译器（如 x86_64-linux-gnu-gcc）。

环境变量协同示例

# 正确配置：生成 Linux x86_64 原生二进制（含 cgo）
GOOS=linux GOARCH=amd64 CC_FOR_TARGET=x86_64-linux-gnu-gcc go build -o app-linux-amd64 .

✅ GOARCH=amd64 在 Go 中等价于 x86_64；CC_FOR_TARGET 必须与 GOOS/GOARCH 语义一致，否则 cgo 调用将链接失败。

关键约束对照表

变量	合法值示例	作用说明
`GOOS`	`linux`, `windows`	决定系统调用接口与 ABI
`GOARCH`	`amd64`, `386`	控制指令集、寄存器布局与大小
`CC_FOR_TARGET`	`aarch64-linux-gnu-gcc`	提供目标平台 C 标准库与链接器

构建流程逻辑

graph TD
    A[设置 GOOS/GOARCH] --> B[Go 工具链选择目标运行时]
    B --> C[若启用 cgo，读取 CC_FOR_TARGET]
    C --> D[调用对应交叉编译器链接 C 依赖]
    D --> E[输出目标平台可执行文件]

4.3 使用qemu-user-static实现跨架构go test的容器化验证方案

在多架构CI/CD流程中，需在x86_64宿主机上验证ARM64目标平台的Go单元测试。qemu-user-static提供用户态二进制翻译能力，使ARM64 Go测试可原生执行。

核心原理

qemu-user-static注册/proc/sys/fs/binfmt_misc/qemu-aarch64，内核自动调用QEMU解释ARM64 ELF；
Docker通过--privileged或--device=/dev/fuse启用binfmt支持（推荐docker run --rm --privileged multiarch/qemu-user-static --reset）。

验证步骤

注册QEMU静态二进制：
```
# 拉取并注册ARM64模拟器（需root）
docker run --rm --privileged multiarch/qemu-user-static --reset
```
此命令向/proc/sys/fs/binfmt_misc/写入ARM64处理器描述，后续execve()调用ARM64可执行文件时由内核透明转发至QEMU。

构建并运行跨架构测试容器：

FROM golang:1.22-alpine AS builder
RUN apk add --no-cache qemu-user-static
COPY . /src
WORKDIR /src
# 编译为ARM64目标（非交叉编译，依赖QEMU运行时）
RUN CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go test -c -o test-arm64 .

支持架构对照表

宿主架构	目标架构	QEMU注册名	是否需FUSE
x86_64	arm64	qemu-aarch64	否
x86_64	ppc64le	qemu-ppc64le	是（部分场景）

graph TD
    A[x86_64宿主机] -->|go test -o test-arm64| B[ARM64可执行文件]
    B -->|内核binfmt触发| C[qemu-aarch64]
    C --> D[执行Go测试逻辑]
    D --> E[返回exit code + stdout]

4.4 Go module proxy与ARM64私有仓库证书链信任的TLS握手调试指南

当Go在ARM64架构下通过GOPROXY访问自签名或企业CA签发的私有模块仓库时，常因证书链不完整或系统级信任库缺失导致x509: certificate signed by unknown authority错误。

常见根因定位步骤

检查目标仓库证书链完整性：openssl s_client -connect repo.internal:443 -showcerts
验证ARM64宿主机是否加载了企业CA证书（路径通常为/etc/ssl/certs/ca-certificates.crt）
确认Go进程是否读取SSL_CERT_FILE或GODEBUG=x509ignoreCN=1等调试变量

Go侧证书信任链覆盖方式

# 将私有CA证书追加至Go内置信任库（需重新编译或使用GOROOT/src/crypto/x509/root_linux.go）
cp internal-ca.pem /usr/local/go/src/crypto/x509/root_ca.crt
# 或更推荐：通过环境变量注入（Go 1.18+）
export SSL_CERT_FILE="/etc/ssl/certs/ca-certificates.crt:/opt/myorg/ca-bundle.pem"

此配置使crypto/tls在握手时合并多个PEM文件中的CA证书；SSL_CERT_FILE支持冒号分隔路径（Linux/macOS），Go会按序解析并构建信任链。

ARM64平台特异性验证表

检查项	ARM64注意事项	验证命令
OpenSSL版本兼容性	部分旧版不支持`-servername` SNI扩展	`openssl version; openssl s_client -connect ... -servername repo.internal`
交叉编译Go工具链	`go env GOHOSTARCH`需为`arm64`，否则`go mod download`可能跳过证书校验	`go env GOHOSTARCH GOARCH`

graph TD
    A[go mod download] --> B{TLS握手发起}
    B --> C[读取SSL_CERT_FILE]
    C --> D[解析PEM证书链]
    D --> E[验证签名与有效期]
    E -->|失败| F[返回x509 error]
    E -->|成功| G[完成模块拉取]

第五章：面向生产环境的Go环境黄金配置检查清单

Go版本与长期支持策略

生产环境必须使用已进入维护期（Maintenance Mode）或仍受官方支持的Go版本。截至2024年，Go 1.21.x 是当前推荐的LTS基线（官方承诺12个月安全更新），禁止使用已EOL的Go 1.19及更早版本。可通过以下命令验证一致性：

go version && go env GOPATH GOROOT GOOS GOARCH

所有构建节点（CI runner、打包镜像、K8s initContainer）须强制校验 GOVERSION 环境变量与预期一致，避免因CI缓存导致隐性降级。

构建参数与可重现性保障

启用 -trimpath（剥离绝对路径）、-buildmode=exe（明确二进制类型）、-ldflags 统一注入版本信息：

go build -trimpath -buildmode=exe \
  -ldflags="-X 'main.BuildTime=$(date -u +%Y-%m-%dT%H:%M:%SZ)' \
            -X 'main.GitCommit=$(git rev-parse --short HEAD)' \
            -s -w" \
  -o myapp ./cmd/myapp

该配置确保二进制哈希在相同源码下完全可复现，满足FedRAMP与SOC2审计要求。

容器化运行时最小化配置

Dockerfile 必须基于 gcr.io/distroless/static:nonroot 或 cgr.dev/chainguard/go-runtime:latest 等无包管理器镜像，并显式声明非root用户：

FROM cgr.dev/chainguard/go-runtime:latest
WORKDIR /app
COPY myapp /app/
USER nonroot:nonroot
EXPOSE 8080
CMD ["/app/myapp"]

关键环境变量硬性约束

变量名	推荐值	强制要求	说明
`GOMAXPROCS`	`$(nproc)`	✅	避免调度器争用，尤其在K8s多vCPU Pod中
`GODEBUG`	`madvdontneed=1`	✅	减少Linux内存回收延迟（适用于≥Go1.22）
`GOTRACEBACK`	`system`	✅	panic时输出完整系统调用栈，便于内核级问题定位

日志与可观测性初始化

应用启动时必须注入结构化日志上下文：

logger := zerolog.New(os.Stderr).
    With().Timestamp().
    Str("service", "payment-api").
    Str("env", os.Getenv("ENVIRONMENT")).
    Logger()
log.Info().Msg("server starting")

同时通过 pprof 启用 /debug/pprof/ 路由，但仅限 127.0.0.1:6060 绑定，禁止暴露至公网。

内存与GC行为调优

在高吞吐微服务中，设置 GOGC=30（默认100）降低GC频率，配合 GOMEMLIMIT=2GiB（Go1.19+）防止OOM Killer误杀：

# Kubernetes Deployment 中的容器资源限制必须与之对齐
resources:
  limits:
    memory: "2560Mi"
  requests:
    memory: "1280Mi"

安全编译标志启用

启用 -gcflags="all=-d=checkptr"（仅开发阶段）和 -buildmode=pie（位置无关可执行文件），并验证符号表剥离：

readelf -d myapp | grep -q "TEXTREL" && echo "ERROR: PIE not enabled" || echo "OK"

依赖供应链完整性验证

go.mod 必须包含 // indirect 标记的间接依赖，且每日CI流水线执行：

go list -m -json all | jq -r '.Path + "@" + .Version' | sort > deps.lock
go mod verify && sha256sum deps.lock

输出哈希需与Git仓库中 deps.lock.sha256 文件比对。

K8s就绪与存活探针设计

存活探针（livenessProbe）应调用独立健康端点（如 /healthz），不依赖数据库连接；就绪探针（readinessProbe）需检查下游依赖（如Redis、PostgreSQL）：

livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 30
readinessProbe:
  exec:
    command: ["/bin/sh", "-c", "curl -sf http://localhost:8080/readyz && nc -z redis:6379"]
  initialDelaySeconds: 10

运行时指标采集标准化

集成 prometheus/client_golang 并暴露 /metrics，强制注册以下基础指标：

go_goroutines（goroutine数量突增预示泄漏）
process_resident_memory_bytes（RSS内存趋势）
http_request_duration_seconds_bucket（按status_code与handler标签分组）

flowchart LR
A[Go Binary] --> B[HTTP Server]
B --> C[/metrics endpoint]
C --> D{Prometheus Scraping}
D --> E[Alert on go_goroutines > 5000 for 5m]
D --> F[Alert on process_resident_memory_bytes > 2GiB]