关于prometheus:龙芯loong64架构prometheus二进制编译和镜像构建

龙芯 CPU 的架构有 Mips 架构和 loong64 架构(如龙芯 3C5000L)。

对于 Mips 架构，能够应用 golang 的穿插编译，指定 GOARCH=mips64le 编译出 prometheus 的可执行文件。

对于 loong64 架构，golang 的穿插编译 尚不反对 ，通常须要在龙芯的 OS 上装置 golang，而后将 prometheus 的 git repoc 拷贝过来，而后 本机编译。

# go version
go version go1.15.6 linux/loong64

本文探讨 loong64 架构下，prometheus 二进制编译和镜像构建的办法。

龙芯 loong64 提供了 GOPROXY，外面蕴含了罕用的依赖，然而不全：

go env -w GOPROXY=http://goproxy.loongnix.cn:3000,direct

配置 direct 后，当 GOPROXY 没有找到依赖时，会间接去源地址拉取。

在开发机器中，应用 go mod vendor，将依赖搁置 vendor 目录，而后将整个 prometheus 我的项目 (含 vendor) 拷贝至龙芯机器，再到龙芯机器上应用 vendor 进行本地编译(go build -mod vendor)。

在编译过程中，通常会报 vendor 目录下 golang.org/x/sys、golang.org/x/net 库失败，此时须要将龙芯机器本地的 golang.org/x/sys 和 golang.org/x/net 包替换到 vendor 目录即可。

prometheus 二进制构建，依赖构建工具 promu，故要先 build 进去 promu。

构建过程：

开发机器：git clone github.com/prometheus/promu
开发机器：go mod vendor
将我的项目目录 promu 拷贝至龙芯机器；
龙芯机器：make build 生成 promu

构建过程：

开发机器：git clone github.com/prometheus/prometheus
开发机器：go mod vendor
将我的项目目录 prometheus 拷贝至龙芯机器；
龙芯机器：将 /root/go/pkg/mod/golang.org/x/sys 和 x /net，替换 vendor 目录下的 golang.org/x/sys 和 x /net；
将上一步构建进去的 promu 可执行文件，拷贝至 prometheus 我的项目根目录；

龙芯机器：批改 Dockerfile.common，应用本地的 promu 工具

...
$(PROMU):
      #$(eval PROMU_TMP := $(shell mktemp -d))
      #curl -s -L $(PROMU_URL) | tar -xvzf - -C $(PROMU_TMP)
      #mkdir -p $(FIRST_GOPATH)/bin
      #cp $(PROMU_TMP)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM)/promu $(FIRST_GOPATH)/bin/promu
      #rm -r $(PROMU_TMP)
      cp ./promu $(FIRST_GOPATH)/bin/promu
...

龙芯机器：

vendor/github.com/prometheus/procfs 目录，减少 cpuinfo_loong64.go 文件

// +build linux

package procfs

var parseCPUInfo = parseCPUInfoLoong64

vendor/github.com/prometheus/procfs 目录，批改 cpuinfo.go 文件，减少上面的内容

  scanner := bufio.NewScanner(bytes.NewReader(info))

  // find the first "processor" line
  firstLine := firstNonEmptyLine(scanner)
  if !strings.HasPrefix(firstLine, "system type") || !strings.Contains(firstLine, ":") {return nil, errors.New("invalid cpuinfo file:" + firstLine)
  }
  field := strings.SplitN(firstLine, ":", 2)
  cpuinfo := []CPUInfo{}
  systemType := field[1]

  for scanner.Scan() {line := scanner.Text()
      if strings.TrimSpace(line) == "" {break}
  }

  i := 0
  for scanner.Scan() {line := scanner.Text()
      if !strings.Contains(line, ":") {continue}
      field := strings.SplitN(line, ":", 2)
      switch strings.TrimSpace(field[0]) {
      case "processor":
          v, err := strconv.ParseUint(field[1], 0, 32)
          if err != nil {return nil, err}
          i = int(v)
          cpuinfo = append(cpuinfo, CPUInfo{}) // start of the next processor
          cpuinfo[i].Processor = uint(v)
          cpuinfo[i].VendorID = systemType
      case "cpu family":
          cpuinfo[i].CPUFamily = field[1]
      case "BogoMIPS":
          v, err := strconv.ParseFloat(field[1], 64)
          if err != nil {return nil, err}
          cpuinfo[i].BogoMips = v
      }
  }
  return cpuinfo, nil
}

龙芯机器：在 prometheus 我的项目根目录，执行 make build，编译出 prometheu 二进制文件

Dockfile 中根底镜像为 quay.io/prometheus/busybox，须要替换为龙芯下的 busybox: harbor.loongnix.cn/mirrorloongsoncontainers/busybox，龙芯 harbor 的拜访办法参考 2。

在龙芯机器上，docker build 构建镜像

docker build -t "harbor.mycompany.org/kubernetes/loong64/prometheus:v2.20.0" -f Dockerfile .

1. 龙芯 golang: http://doc.loongnix.cn/web/#/…
2. 龙芯 harbor: http://doc.loongnix.cn/web/#/…

关于prometheus:龙芯loong64架构prometheus二进制编译和镜像构建

GOPROXY

编译办法

prometheus 编译过程

promu

prometheus

prometheus 镜像

参考