先问大家问题，containerd的snapshot是什么鬼？ 难道是给容器做快照的吗？

讯享网
答案是： 是也不是

为什么说是呢？它的确可以实现部分快照的功能，但他和常规意义的虚拟机快照又不是一回事。
我们先看一下containerd是干嘛的？譬如我们拉镜像

可以看到snapshot的服务作用是准备rootfs的，就是通过mount各个层，提供容器的rootfs。所有。content只是保存tar和mainfest和config文件的，是OCI那套东西，我们需要将他们逐一解压、mount后提供给容器。
所以push操作就和snapshot没有毛关系了。如下所示：

当我们理解snapshot是干嘛的以后，
我们通过源码看一下containerd目前的snapshot有哪些实现

那么大家可能又有疑惑了，为啥他们可以加入snapshot，因为这些文件系统都有一个共同的特性就是：支持快照。这就是这个模块的名称叫做snapshot了。每个文件系统的接入就需要实现下面的接口。

type Snapshotter interface { 
    // Stat returns the info for an active or committed snapshot by name or // key. // // Should be used for parent resolution, existence checks and to discern // the kind of snapshot. Stat(ctx context.Context, key string) (Info, error) // Update updates the info for a snapshot. // // Only mutable properties of a snapshot may be updated. Update(ctx context.Context, info Info, fieldpaths ...string) (Info, error) // Usage returns the resource usage of an active or committed snapshot // excluding the usage of parent snapshots. // // The running time of this call for active snapshots is dependent on // implementation, but may be proportional to the size of the resource. // Callers should take this into consideration. Implementations should // attempt to honer context cancellation and avoid taking locks when making // the calculation. Usage(ctx context.Context, key string) (Usage, error) // Mounts returns the mounts for the active snapshot transaction identified // by key. Can be called on an read-write or readonly transaction. This is // available only for active snapshots. // // This can be used to recover mounts after calling View or Prepare. Mounts(ctx context.Context, key string) ([]mount.Mount, error) // Prepare creates an active snapshot identified by key descending from the // provided parent. The returned mounts can be used to mount the snapshot // to capture changes. // // If a parent is provided, after performing the mounts, the destination // will start with the content of the parent. The parent must be a // committed snapshot. Changes to the mounted destination will be captured // in relation to the parent. The default parent, "", is an empty // directory. // // The changes may be saved to a committed snapshot by calling Commit. When // one is done with the transaction, Remove should be called on the key. // // Multiple calls to Prepare or View with the same key should fail. Prepare(ctx context.Context, key, parent string, opts ...Opt) ([]mount.Mount, error) // View behaves identically to Prepare except the result may not be // committed back to the snapshot snapshotter. View returns a readonly view on // the parent, with the active snapshot being tracked by the given key. // // This method operates identically to Prepare, except that Mounts returned // may have the readonly flag set. Any modifications to the underlying // filesystem will be ignored. Implementations may perform this in a more // efficient manner that differs from what would be attempted with // `Prepare`. // // Commit may not be called on the provided key and will return an error. // To collect the resources associated with key, Remove must be called with // key as the argument. View(ctx context.Context, key, parent string, opts ...Opt) ([]mount.Mount, error) // Commit captures the changes between key and its parent into a snapshot // identified by name. The name can then be used with the snapshotter's other // methods to create subsequent snapshots. // // A committed snapshot will be created under name with the parent of the // active snapshot. // // After commit, the snapshot identified by key is removed. Commit(ctx context.Context, name, key string, opts ...Opt) error // Remove the committed or active snapshot by the provided key. // // All resources associated with the key will be removed. // // If the snapshot is a parent of another snapshot, its children must be // removed before proceeding. Remove(ctx context.Context, key string) error // Walk will call the provided function for each snapshot in the // snapshotter which match the provided filters. If no filters are // given all items will be walked. // Filters: // name // parent // kind (active,view,committed) // labels.(label) Walk(ctx context.Context, fn WalkFunc, filters ...string) error // Close releases the internal resources. // // Close is expected to be called on the end of the lifecycle of the snapshotter, // but not mandatory. // // Close returns nil when it is already closed. Close() error } 

当我们通过pull下载镜像的时候就会apply每一层

讯享网func applyLayers(ctx context.Context, layers []Layer, chain []digest.Digest, sn snapshots.Snapshotter, a diff.Applier, opts []snapshots.Opt, applyOpts []diff.ApplyOpt) error { 
    mounts, err = sn.Prepare(ctx, key, parent.String(), opts...) diff, err = a.Apply(ctx, layer.Blob, mounts, applyOpts...) if err = sn.Commit(ctx, chainID.String(), key, opts...); err != nil { 
    err = errors.Wrapf(err, "failed to commit snapshot %s", key) return err } return nil } 

通过prepare --》 apply --》commit 三步完成layer的构建。其中prepare只返回了具体mount列表，并不做具体的mount操作，具体实现在apply这个方法，

func apply(ctx context.Context, mounts []mount.Mount, r io.Reader) error { 
    return mount.WithTempMount(ctx, mounts, func(root string) error { 
    _, err := archive.Apply(ctx, root, r) return err }) } 

其中archive.Apply 就是解压tar包写层的”archive/tar.go“

讯享网func applyNaive(ctx context.Context, root string, tr *tar.Reader, options ApplyOptions) (size int64, err error) { 
    . . . 

总结一下，snapshot目的是为了给容器的提供rootfs，通过实现snapshot的接口，就可以接入不同的具有快照功能的文件系统。