关于docker:如何在golang代码里面解析容器镜像

简介：容器镜像在咱们日常的开发工作中占据着极其重要的地位。通常状况下咱们是将应用程序打包到容器镜像并上传到镜像仓库中，在生产环境将其拉取下来。而后用 docker/containerd 等容器运行时将镜像启动，开始执行利用。然而对于一些运维平台来说，对于一个镜像制品自身的扫描和剖析才是真正的关注点。本文简略介绍下如何在代码中解析一个容器镜像。

作者 | 牧琦
起源 | 阿里技术公众号

一背景

容器镜像在咱们日常的开发工作中占据着极其重要的地位。通常状况下咱们是将应用程序打包到容器镜像并上传到镜像仓库中，在生产环境将其拉取下来。而后用 docker/containerd 等容器运行时将镜像启动，开始执行利用。然而对于一些运维平台来说，对于一个镜像制品自身的扫描和剖析才是真正的关注点。本文简略介绍下如何在代码中解析一个容器镜像。

二 go-containerregistry

go-containerregistry 是 google 公司的一个开源我的项目，它提供了一个对镜像的操作接口，这个接口背地的资源能够是镜像仓库的近程资源，镜像的tar包，甚至是 docker daemon 过程。上面咱们就简略介绍下如何应用这个我的项目来实现咱们的指标—— 在代码中解析镜像。

除了对外提供了三方包，该我的项目外面还提供了 crane （与远端镜像交互的客户端）gcrane (与 gcr 交互的客户端)。

三根本接口

1 镜像基本概念

在介绍具体接口之间先介绍几个简略概念

ImageIndex，依据 OCI 标准，是为了兼容多架构（amd64, arm64）镜像而发明进去的数据结构, 咱们能够在一个ImageIndex 外面关联多个镜像，应用同一个镜像tag，客户端（docker，ctr）会依据客户端所在的操作系统的基础架构拉取对应架构的镜像下来
Image Manifest 基本上对应了一个镜像，外面蕴含了一个镜像的所有layers digest，客户端拉取镜像的时候个别都是先获取manifest 文件，在依据 manifest 文件外面的内容拉取镜像各个层（tar+gzip）
Image Config 跟 ImageManifest 是一一对应的关系，Image Config 次要蕴含一些镜像的根本配置，例如创立工夫，作者，该镜像的基础架构，镜像层的 diffID（未压缩的 ChangeSet），ChainID 之类的信息。个别在宿主机上执行 docker image 看到的ImageID就是 ImageConfig 的hash值。
layer 就是镜像层，镜像层信息不蕴含任何的运行时信息（环境变量等）只蕴含文件系统的信息。镜像是通过最底层 rootfs 加上各层的 changeset（对上一层的 add, update, delete 操作）组合而成的。
layer diffid 是未压缩的层的hash值，常见于本地环境，应用看到的便是diffid。因为客户端个别下载 ImageConfig, ImageConfig 外面是援用的diffid。
layer digest 是压缩后的层的hash值，常见于镜像仓库应用看到的layers 个别都是 digest. 因为 manifest 援用都是 layer digest。
两者没有能够间接转换的形式，目前的惟一形式就是依照程序来对应。

用一张图来总结一下。

// ImageIndex 定义与 OCI ImageIndex 交互的接口type ImageIndex interface {  // 返回以后 imageIndex 的 MediaType  MediaType() (types.MediaType, error)  // 返回这个 ImageIndex manifest 的 sha256值。  Digest() (Hash, error)  // 返回这个 ImageIndex manifest 的大小  Size() (int64, error)  // 返回这个 ImageIndex 的 manifest 构造  IndexManifest() (*IndexManifest, error)  // 返回这个 ImageIndex 的 manifest 字节数组  RawManifest() ([]byte, error)  // 返回这个 ImageIndex 援用的 Image  Image(Hash) (Image, error)  // 返回这个 ImageIndex 援用的 ImageIndex  ImageIndex(Hash) (ImageIndex, error)}// Image  定义了与 OCI Image 交互的接口type Image interface {  // 返回了以后镜像的所有层级， 最老/最根底的层在数组的后面，最下面/最新的层在数组的前面  Layers() ([]Layer, error)  // 返回以后 image 的 MediaType  MediaType() (types.MediaType, error)  // 返回这个 Image manifest 的大小  Size() (int64, error)  // 返回这个镜像 ConfigFile 的hash值，也是这个镜像的 ImageID  ConfigName() (Hash, error)  // 返回这个镜像的 ConfigFile  ConfigFile() (*ConfigFile, error)  // 返回这个镜像的 ConfigFile 的字节数组  RawConfigFile() ([]byte, error)  // 返回这个Image Manifest 的sha256 值  Digest() (Hash, error)  // 返回这个Image Manifest  Manifest() (*Manifest, error)  // 返回 ImageManifest 的bytes数组  RawManifest() ([]byte, error)  // 返回这个镜像中的某一层layer， 依据 digest（压缩后的hash值） 来查找  LayerByDigest(Hash) (Layer, error)  // 返回这个镜像中的某一层layer， 依据 diffid （未压缩的hash值） 来查找  LayerByDiffID(Hash) (Layer, error)}// Layer 定义了拜访 OCI Image 特定 Layer 的接口type Layer interface {  // 返回了压缩后的layer的sha256 值  Digest() (Hash, error)  // 返回了 未压缩的layer 的sha256值.  DiffID() (Hash, error)  // 返回了压缩后的镜像层  Compressed() (io.ReadCloser, error)  // 返回了未压缩的镜像层  Uncompressed() (io.ReadCloser, error)  // 返回了压缩后镜像层的大小  Size() (int64, error)  // 返回以后 layer 的 MediaType  MediaType() (types.MediaType, error)}

相干接口性能已在正文中阐明，不再赘述。

四获取镜像相干元信息

咱们以 remote 形式(拉取近程镜像) 举例说明下如何应用。

package mainimport (  "github.com/google/go-containerregistry/pkg/authn"  "github.com/google/go-containerregistry/pkg/name"  "github.com/google/go-containerregistry/pkg/v1/remote")func main() {  ref, err := name.ParseReference("xxx")  if err != nil {    panic(err)  }  tryRemote(context.TODO(), ref, GetDockerOption())  if err != nil {    panic(err)  }  // do stuff with img}type DockerOption struct {  // Auth  UserName string  Password string  // RegistryToken is a bearer token to be sent to a registry  RegistryToken string  // ECR  AwsAccessKey    string  AwsSecretKey    string  AwsSessionToken string  AwsRegion       string  // GCP  GcpCredPath string  InsecureSkipTLSVerify bool  NonSSL                bool  SkipPing              bool // this is ignored now  Timeout               time.Duration}func GetDockerOption() (types.DockerOption, error) {  cfg := DockerConfig{}  if err := env.Parse(&cfg); err != nil {    return types.DockerOption{}, fmt.Errorf("unable to parse environment variables: %w", err)  }  return types.DockerOption{    UserName:              cfg.UserName,    Password:              cfg.Password,    RegistryToken:         cfg.RegistryToken,    InsecureSkipTLSVerify: cfg.Insecure,    NonSSL:                cfg.NonSSL,  }, nil}func tryRemote(ctx context.Context, ref name.Reference, option types.DockerOption) (v1.Image, extender, error) {  var remoteOpts []remote.Option  if option.InsecureSkipTLSVerify {    t := &http.Transport{      TLSClientConfig: &tls.Config{InsecureSkipVerify: true},    }    remoteOpts = append(remoteOpts, remote.WithTransport(t))  }  domain := ref.Context().RegistryStr()  auth := token.GetToken(ctx, domain, option)  if auth.Username != "" && auth.Password != "" {    remoteOpts = append(remoteOpts, remote.WithAuth(&auth))  } else if option.RegistryToken != "" {    bearer := authn.Bearer{Token: option.RegistryToken}    remoteOpts = append(remoteOpts, remote.WithAuth(&bearer))  } else {    remoteOpts = append(remoteOpts, remote.WithAuthFromKeychain(authn.DefaultKeychain))  }  desc, err := remote.Get(ref, remoteOpts...)  if err != nil {    return nil, nil, err  }  img, err := desc.Image()  if err != nil {    return nil, nil, err  }  // Return v1.Image if the image is found in Docker Registry  return img, remoteExtender{    ref:        implicitReference{ref: ref},    descriptor: desc,  }, nil}

执行完 tryRemote 代码之后就能够获取 Image 对象的实例，进而对这个实例进行操作。明确以下几个关键点

remote.Get() 办法只会理论拉取镜像的manifestList/manifest，并不会拉取整个镜像。
desc.Image() 办法会判断 remote.Get() 返回的媒体类型。如果是镜像的话间接返回一个 Image interface, 如果是 manifest list 的状况会解析以后宿主机的架构，并且返回指定架构对应的镜像。同样这里并不会拉取镜像。
所有的数据都是lazy load。只有须要的时候才会去获取。

五读取镜像中系统软件的信息

通过下面的接口定义可知，咱们能够通过 Image.LayerByDiffID(Hash) (Layer, error) 获取一个 layer 对象，获取了layer对象之后咱们能够调用 layer.Uncompressed() 办法获取一个未被压缩的层的 io.Reader , 也就是一个 tar file。

// tarOnceOpener 读取文件一次并共享内容，以便分析器能够共享数据func tarOnceOpener(r io.Reader) func() ([]byte, error) {  var once sync.Once  var b []byte  var err error  return func() ([]byte, error) {    once.Do(func() {      b, err = ioutil.ReadAll(r)    })    if err != nil {      return nil, xerrors.Errorf("unable to read tar file: %w", err)    }    return b, nil  }}// 该办法次要是遍历整个 io stream，首先解析出文件的元信息 （path, prefix,suffix）, 而后调用 analyzeFn 办法解析文件内容func WalkLayerTar(layer io.Reader, analyzeFn WalkFunc) ([]string, []string, error) {  var opqDirs, whFiles []string  var result *AnalysisResult  tr := tar.NewReader(layer)  opq := ".wh..wh..opq"  wh  := ".wh."  for {    hdr, err := tr.Next()    if err == io.EOF {      break    }    if err != nil {      return nil, nil, xerrors.Errorf("failed to extract the archive: %w", err)    }    filePath := hdr.Name    filePath = strings.TrimLeft(filepath.Clean(filePath), "/")    fileDir, fileName := filepath.Split(filePath)    // e.g. etc/.wh..wh..opq    if opq == fileName {      opqDirs = append(opqDirs, fileDir)      continue    }    // etc/.wh.hostname    if strings.HasPrefix(fileName, wh) {      name := strings.TrimPrefix(fileName, wh)      fpath := filepath.Join(fileDir, name)      whFiles = append(whFiles, fpath)      continue    }    if hdr.Typeflag == tar.TypeSymlink || hdr.Typeflag == tar.TypeLink || hdr.Typeflag == tar.TypeReg {      analyzeFn(filePath, hdr.FileInfo(), tarOnceOpener(tr), result)      if err != nil {        return nil, nil, xerrors.Errorf("failed to analyze file: %w", err)      }    }  }  return opqDirs, whFiles, nil}// 调用不同的driver 对同一个文件进行解析func analyzeFn(filePath string, info os.FileInfo, opener analyzer.Opener,result *AnalysisResult) error {    if info.IsDir() {        return nil, nil    }        var wg sync.WaitGroup    for _, d := range drivers {      // filepath extracted from tar file doesn't have the prefix "/"      if !d.Required(strings.TrimLeft(filePath, "/"), info) {        continue      }      b, err := opener()      if err != nil {        return nil, xerrors.Errorf("unable to open a file (%s): %w", filePath, err)      }      if err = limit.Acquire(ctx, 1); err != nil {        return nil, xerrors.Errorf("semaphore acquire: %w", err)      }      wg.Add(1)      go func(a analyzer, target AnalysisTarget) {        defer limit.Release(1)        defer wg.Done()        ret, err := a.Analyze(target)        if err != nil && !xerrors.Is(err, aos.AnalyzeOSError) {          log.Logger.Debugf("Analysis error: %s", err)          return nil, err        }        result.Merge(ret)      }(d, AnalysisTarget{Dir: dir, FilePath: filePath, Content: b})    }            return result, nil}// drivers: 用于解析tar包中的文件func (a alpinePkgAnalyzer) Analyze(target analyzer.AnalysisTarget) (*analyzer.AnalysisResult, error) {  scanner := bufio.NewScanner(bytes.NewBuffer(target.Content))  var pkg types.Package  var version string  for scanner.Scan() {    line := scanner.Text()    // check package if paragraph end    if len(line) < 2 {      if analyzer.CheckPackage(&pkg) {        pkgs = append(pkgs, pkg)      }      pkg = types.Package{}      continue    }    switch line[:2] {    case "P:":      pkg.Name = line[2:]    case "V:":      version = string(line[2:])      if !apkVersion.Valid(version) {        log.Printf("Invalid Version Found : OS %s, Package %s, Version %s", "alpine", pkg.Name, version)        continue      }      pkg.Version = version    case "o:":      origin := line[2:]      pkg.SrcName = origin      pkg.SrcVersion = version    }  }  // in case of last paragraph  if analyzer.CheckPackage(&pkg) {    pkgs = append(pkgs, pkg)  }  parsedPkgs := a.uniquePkgs(pkgs)  return &analyzer.AnalysisResult{    PackageInfos: []types.PackageInfo{      {        FilePath: target.FilePath,        Packages: parsedPkgs,      },    },  }, nil}

以上代码的重点在于 Analyze(target analyzer.AnalysisTarget) 办法，在介绍这个办法之前，有两个非凡文件须要略微介绍下。家喻户晓，镜像是分层的，并且所有层都是只读的。当容器是以镜像为根底起来的时候，它会将所有镜像层蕴含的文件组合成为 rootfs 对容器临时，当咱们将容器 commit 成一个新的镜像的时候，容器内对文件批改会以新的layer 的形式笼罩到原有的镜像中。其中有如下两种非凡文件：

.wh..wh..opq: 代表这个文件所在的目录被删除了
.wh.：以这个词缀结尾的文件阐明这个文件在以后层曾经被删除

所以综上所述，所有容器内的文件删除均不是真正的删除。所以咱们在 WalkLayerTar 办法中将两个文件记录下来，跳过解析。

1 Analyze(target analyzer.AnalysisTarget)

首先咱们调用 bufio.scanner.Scan() 办法，他会一直扫描文件中的信息，当返回false 的时候代表扫描到文件结尾，如果这时在扫描过程中没有谬误，则 scanner 的 Err 字段为 nil
咱们通过 scanner.Text() 获取扫描文件的每一行，截取每一行的前两个字符，得出 apk package 的 package name & package version。

六读取镜像中的java 利用信息

上面咱们理论来看下如何读取java 利用中的依赖信息，包含利用依赖 & jar包依赖，首先咱们应用下面的形式读取某一层的文件信息。

如果发现文件是jar包
初始化 zip reader，开始读取 jar 包内容
开始通过 jar包名称进行解析 artifact的名称和版本，例如: spring-core-5.3.4-SNAPSHOT.jar => sprint-core, 5.3.4-SNAPSHOT
从 zip reader 读取被压缩的文件

判断文件类型

调用parseArtifact进行递归解析
将返回的innerLibs放到 libs对象中
从 MANIFEST.MF 文件中解析出manifest返回
从 properties 文件中解析 groupid, artifactid, version 并返回
将上述信息放到 libs 对象中
如果是 pom.properties
如果是 MANIFEST.MF
如果是 jar/war/ear 等文件

如果找不到 artifactid or groupid

依据jar sha256查问对应的包信息
找到间接返回
返回解析进去的libs

func parseArtifact(c conf, fileName string, r io.ReadCloser) ([]types.Library, error) {  defer r.Close()  b, err := ioutil.ReadAll(r)  if err != nil {    return nil, xerrors.Errorf("unable to read the jar file: %w", err)  }  zr, err := zip.NewReader(bytes.NewReader(b), int64(len(b)))  if err != nil {    return nil, xerrors.Errorf("zip error: %w", err)  }  fileName = filepath.Base(fileName)  fileProps := parseFileName(fileName)  var libs []types.Library  var m manifest  var foundPomProps bool  for _, fileInJar := range zr.File {    switch {    case filepath.Base(fileInJar.Name) == "pom.properties":      props, err := parsePomProperties(fileInJar)      if err != nil {        return nil, xerrors.Errorf("failed to parse %s: %w", fileInJar.Name, err)      }      libs = append(libs, props.library())      if fileProps.artifactID == props.artifactID && fileProps.version == props.version {        foundPomProps = true      }    case filepath.Base(fileInJar.Name) == "MANIFEST.MF":      m, err = parseManifest(fileInJar)      if err != nil {        return nil, xerrors.Errorf("failed to parse MANIFEST.MF: %w", err)      }    case isArtifact(fileInJar.Name):      fr, err := fileInJar.Open()      if err != nil {        return nil, xerrors.Errorf("unable to open %s: %w", fileInJar.Name, err)      }      // 递归解析 jar/war/ear       innerLibs, err := parseArtifact(c, fileInJar.Name, fr)      if err != nil {        return nil, xerrors.Errorf("failed to parse %s: %w", fileInJar.Name, err)      }      libs = append(libs, innerLibs...)    }  }  // 如果找到了 pom.properties 文件，则间接返回libs对象  if foundPomProps {    return libs, nil  }  // 如果没有找到 pom.properties 文件，则解析MANIFEST.MF 文件  manifestProps := m.properties()  if manifestProps.valid() {    // 这里即便找到了 artifactid or groupid 也有可能是非法的。这里会拜访 maven等仓库确认 jar包是否真正存在    if ok, _ := exists(c, manifestProps); ok {      return append(libs, manifestProps.library()), nil    }  }  p, err := searchBySHA1(c, b)  if err == nil {    return append(libs, p.library()), nil  } else if !xerrors.Is(err, ArtifactNotFoundErr) {    return nil, xerrors.Errorf("failed to search by SHA1: %w", err)  }  return libs, nil}

以上咱们便实现了从容器镜像中读取信息的性能。

原文链接
本文为阿里云原创内容，未经容许不得转载。

一 背景

二 go-containerregistry

三 根本接口

1 镜像基本概念

四 获取镜像相干元信息

五 读取镜像中系统软件的信息

1 Analyze(target analyzer.AnalysisTarget)

六 读取镜像中的java 利用信息

一背景

三根本接口

四获取镜像相干元信息

五读取镜像中系统软件的信息

六读取镜像中的java 利用信息