如何在golang代码里面解析容器镜像-阿里云开发者社区

开发者社区> 牧琦> 正文

如何在golang代码里面解析容器镜像

简介: 背景容器镜像在我们日常的开发工作中占据着极其重要的位置。通常情况下我们是将应用程序打包到容器镜像并上传到镜像仓库中,在生产环境将其拉取下来。然后用 docker/containerd 等运行时将镜像启动,开始执行应用。但是对于一些运维平台来说,对于一个镜像(制品)的扫描,分析,过滤,拦截才是真正的关注点。本文简单介绍下如何在代码中解析一个容器镜像go-containerregistrygo-con
+关注继续查看

背景

容器镜像在我们日常的开发工作中占据着极其重要的位置。通常情况下我们是将应用程序打包到容器镜像并上传到镜像仓库中,在生产环境将其拉取下来。然后用 docker/containerd 等运行时将镜像启动,开始执行应用。但是对于一些运维平台来说,对于一个镜像(制品)的扫描,分析,过滤,拦截才是真正的关注点。本文简单介绍下如何在代码中解析一个容器镜像

go-containerregistry

go-containerregistry 是 google 公司的一个开源项目,它提供了一个对镜像的操作接口,这个接口背后的资源可以是 镜像仓库的远程资源,镜像的tar包,甚至是 docker daemon 进程。下面我们就简单介绍下如何使用这个项目来完成我们的目标—— 在代码中解析镜像

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

项目地址: https://github.com/google/go-containerregistry

基本接口

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

  • ImageIndex, 根据 OCI 规范,是为了兼容多架构(amd64, arm64)镜像而创造出来的数据结构, 我们可以在一个ImageIndex 里面关联多个镜像,使用同一个镜像tag,客户端会根据客户端所在的操作系统的基础架构拉取对应架构的镜像下来
  • Image Manifest 基本上对应了一个镜像,里面包含了一个镜像的所有layers digest,客户端拉取镜像的时候一般都是先获取manifest 文件,在根据 manifest 文件里面的内容拉取镜像各个层的tar(tar+gzip)包.
  • Image Config 跟 ImageManifest 是一一对应的关系,Image Config 主要包含一些 镜像的基本配置,例如 创建时间,作者,该镜像的基础架构,镜像层的 diffID(未压缩的 ChangeSet),ChainID 之类的信息。一般在宿主机上执行 docker image 看到的ImageID就是 ImageConfig 的hash值
  • layer 就是镜像层,镜像层信息不包含任何的运行时信息(环境变量等)只包含文件系统的信息。镜像是通过最底层 rootfs 加上各层的 changeset(对上一层的 add, update, delete 操作)组合而成的。
  • layer diffid 是未压缩的层的hash值,常见于 本地环境,使用 docker inspect <docker-id> 看到的便是diffid。因为客户端一般下载 ImageConfig, ImageConfig 里面是引用的diffid
  • layer digest 是压缩后的层的hash值,常见于镜像仓库 使用 <docker manifest inspect xxx > 看到的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 main

import (
	"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)
	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 isIgnored(filePath) {
			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包中的文件。用 rpm 来简单介绍下
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
}

以上我们便完成了从容器镜像中读取信息的功能

参考:

https://github.com/google/go-containerregistry

https://github.com/aquasecurity/fanal

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
阿里云服务器怎么设置密码?怎么停机?怎么重启服务器?
如果在创建实例时没有设置密码,或者密码丢失,您可以在控制台上重新设置实例的登录密码。本文仅描述如何在 ECS 管理控制台上修改实例登录密码。
9890 0
golang多进程测试代码
package main import ( "fmt" "runtime" ) func test(c chan bool, n int) { x := 0 for i := 0; i < 1000000000; ...
1227 0
兼容IE、火狐、谷歌及所有浏览器的悬浮代码
                                                                                        var csdnScrollTop=function(){         return document.
812 0
两行代码修复了解析MySQL8.x binlog错位的问题!!
MySQL是互联网行业使用的最多的关系型数据库之一,而且MySQL又是开源的,对于MySQL的深入研究,能够加深我们对于数据库原理的理解。自从开源了mykit-data之后,不少小伙伴试用后,反馈mykit-data无法正确的解析MySQL8的binlog。于是我测试了下,mykit-data在解析MySQL5.x的binlog时,没有啥问题,能够正确的解析出结果数据。然而,在解析MySQL8.x的binlog时,总是与binlog日志位数相差12位而导致解析失败。
16 0
Netty业务代码执行流程源码解析
Netty业务代码执行流程源码解析
11 0
阿里云服务器如何登录?阿里云服务器的三种登录方法
购买阿里云ECS云服务器后如何登录?场景不同,阿里云优惠总结大概有三种登录方式: 登录到ECS云服务器控制台 在ECS云服务器控制台用户可以更改密码、更换系.
13622 0
JAVA对XML文件的读写(有具体的代码和解析)
XML 指可扩展标记语言(EXtensible Markup Language),是独立于软件和硬件的信息传输工具,应用于 web 开发的许多方面,常用于简化数据的存储和共享。 xml指令 处理指令,简称PI (processing instruction)。
1131 0
+关注
牧琦
ACK 开发
4
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载