kaniko源码走读

kaniko是一个通过Dockerfile构建镜像的工具，是OCI image标准的一个实现、功能单一、代码量相对较少，了解kaniko源码实现可以更好的理解容器镜像的构建方法和构建流程。

基本流程

主程序入口kaniko/cmd/root.go，实现基于Cobra的命令行（cli）交互接口，解析命令行输入构建参数，传入executor.DoBuild(opts)方法并执行镜像构建过程，然后执行executor.DoPush(image, opts)将构建好的镜像push到镜像仓库。

镜像构建核心方法

DoBuild方法是构建核心方法：

func DoBuild(opts *config.KanikoOptions) (v1.Image, error) {
        // 调用buildkit的stage docker-file解析代码，方法解析得到buildkit的stages
    stages, metaArgs, err := dockerfile.ParseStages(opts)
       // 转化为kaniko内部config.KanikoStage结构
    kanikoStages, err := dockerfile.MakeKanikoStages(opts, stages, metaArgs)
        ...
        ...
    for index, stage := range kanikoStages {
        // 构建 stageBuilder
        sb, err := newStageBuilder(opts, stage, crossStageDependencies, digestToCacheKey, stageIdxToDigest, stageNameToIdx, fileContext)
        // 执行build
        sb.build()
    }
    ....
}

func (s *stageBuilder) build() error {
    // Take initial snapshot if command does not expect to return
    // a list of files.
    // 对 RunCommand （对应docker-file中run）无法直接得到变化的文件要执行全局Snapshot对比扫描来获取变化的文件（change-sets）。
    s.initSnapshotWithTimings()
    // 对于其他类型的command，执行命令
    if err := command.ExecuteCommand(&s.cf.Config, s.args); err != nil {
        return errors.Wrap(err, "failed to execute command")
    }
      // 得到要执行快照的文件
    files = command.FilesToSnapshot()
    // 通过Snapshotter对这些文件执行Snapshot，将变化的文件通过tarball写入tar文件
    tarPath, err := s.takeSnapshot(files, command.ShouldDetectDeletedFiles())
    // 通过tar文件构建镜像。
    s.saveSnapshotToImage(command.String(), tarPath);
}

func (s *stageBuilder) saveSnapshotToImage(createdBy string, tarPath string) error {
    layer, err := s.saveSnapshotToLayer(tarPath)
        ...
        ...
    return s.saveLayerToImage(layer, createdBy)
}

func (s *stageBuilder) saveSnapshotToLayer(tarPath string) (v1.Layer, error) {
       
    layer, err := tarball.LayerFromFile(tarPath, tarball.WithCompressedCaching)

    return layer, nil
}

func (s *stageBuilder) saveLayerToImage(layer v1.Layer, createdBy string) error {
    var err error
    s.image, err = mutate.Append(s.image,
        mutate.Addendum{
            Layer: layer,
            History: v1.History{
                Author:    constants.Author,
                CreatedBy: createdBy,
            },
        },
    )
    return err
}

基本数据结构

一个muti-stage的docker-file，会被转成对应的Stage列表，Stage则是由多个由docker-file中的命令解析转化而成Command结构组成。

type Stage struct {
    Name       string
    Commands   []Command
    BaseName   string
    SourceCode string
    Platform   string
}

文件列表快照实现

kaniko是通过计算文件的hash值来判断当前文件是否变化，核心是计算hash的算法法结构

func getHasher(snapshotMode string) (func(string) (string, error), error) {
    switch snapshotMode {
    case constants.SnapshotModeTime:
        logrus.Info("Only file modification time will be considered when snapshotting")
        return util.MtimeHasher(), nil
    case constants.SnapshotModeFull:
        return util.Hasher(), nil
    case constants.SnapshotModeRedo:
        return util.RedoHasher(), nil
    default:
        return nil, fmt.Errorf("%s is not a valid snapshot mode", snapshotMode)
    }
}

通过工厂方法获取对应算法的Hasher，然后通过计算比较hash值来比较文件是否被修改，如果被修改就存入NewLayeredMap

type LayeredMap struct {
    layers         []map[string]string
    whiteouts      []map[string]struct{}
    layerHashCache map[string]string
    hasher         func(string) (string, error)
    // cacheHasher doesn't include mtime in it's hash so that filesystem cache keys are stable
    cacheHasher func(string) (string, error)
}

为镜像的逻辑结构，方便得到文件变化列表（change-sets）。