共计 10771 个字符，预计需要花费 27 分钟才能阅读完成。
简介：容器镜像在咱们日常的开发工作中占据着极其重要的地位。通常状况下咱们是将应用程序打包到容器镜像并上传到镜像仓库中，在生产环境将其拉取下来。而后用 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 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)
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
}以上咱们便实现了从容器镜像中读取信息的性能。
原文链接
本文为阿里云原创内容，未经容许不得转载。
正文完