import "github.com/containerd/containerd"
client.go client_opts.go container.go container_opts.go container_opts_unix.go containerstore.go content_reader.go content_store.go content_writer.go diff.go events.go grpc.go image.go image_store.go lease.go namespaces.go process.go services.go snapshot.go snapshotter_default_linux.go task.go task_opts.go task_opts_linux.go
const (
// DefaultSnapshotter will set the default snapshotter for the platform.
// This will be based on the client compilation target, so take that into
// account when choosing this value.
DefaultSnapshotter = "overlayfs"
)const UnknownExitStatus = 255UnknownExitStatus is returned when containerd is unable to determine the exit status of a process. This can happen if the process never starts or if an error was encountered when obtaining the exit status, it is set to 255.
func NewContentStoreFromClient(client contentapi.ContentClient) content.Store
NewContentStoreFromClient returns a new content store
func NewImageStoreFromClient(client imagesapi.ImagesClient) images.Store
NewImageStoreFromClient returns a new image store client
func NewNamespaceStoreFromClient(client api.NamespacesClient) namespaces.Store
NewNamespaceStoreFromClient returns a new namespace store
func NewRemoteContainerStore(client containersapi.ContainersClient) containers.Store
NewRemoteContainerStore returns the container Store connected with the provided client
func NewSnapshotterFromClient(client snapshotsapi.SnapshotsClient, snapshotterName string) snapshots.Snapshotter
NewSnapshotterFromClient returns a new Snapshotter which communicates over a GRPC connection.
func WithExit(r *CheckpointTaskInfo) error
WithExit causes the task to exit after a successful checkpoint
WithKillAll kills all processes for a task
WithNoPivotRoot instructs the runtime not to you pivot_root
WithProcessKill will forcefully kill and delete a process
func WithPullUnpack(_ *Client, c *RemoteContext) error
WithPullUnpack is used to unpack an image after pull. This uses the snapshotter, content store, and diff service configured for the client.
func WithSchema1Conversion(client *Client, c *RemoteContext) error
WithSchema1Conversion is used to convert Docker registry schema 1 manifests to oci manifests on pull. Without this option schema 1 manifests will return a not supported error.
WithSnapshotCleanup deletes the rootfs snapshot allocated for the container
func WithStdinCloser(r *IOCloseInfo)
WithStdinCloser closes the stdin of a process
type CheckpointTaskInfo struct {
Name string
// ParentCheckpoint is the digest of a parent checkpoint
ParentCheckpoint digest.Digest
// Options hold runtime specific settings for checkpointing a task
Options interface{}
}CheckpointTaskInfo allows specific checkpoint information to be set for the task
type CheckpointTaskOpts func(*CheckpointTaskInfo) error
CheckpointTaskOpts allows the caller to set checkpoint options
func WithCheckpointName(name string) CheckpointTaskOpts
WithCheckpointName sets the image name for the checkpoint
type Client struct {
// contains filtered or unexported fields
}Client is the client to interact with containerd and its various services using a uniform interface
New returns a new containerd client that is connected to the containerd instance provided by address
NewWithConn returns a new containerd client that is connected to the containerd instance provided by the connection
Close closes the clients connection to containerd
func (c *Client) ContainerService() containers.Store
ContainerService returns the underlying container Store
Containers returns all containers created in containerd
ContentStore returns the underlying content Store
CreateLease creates a new lease
func (c *Client) DiffService() DiffService
DiffService returns the underlying Differ
func (c *Client) EventService() EventService
EventService returns the underlying event service
func (c *Client) Export(ctx context.Context, exporter images.Exporter, desc ocispec.Descriptor, opts ...ExportOpt) (io.ReadCloser, error)
Export exports an image to a Tar stream. OCI format is used by default. It is up to caller to put "org.opencontainers.image.ref.name" annotation to desc. TODO(AkihiroSuda): support exporting multiple descriptors at once to a single archive stream.
GetImage returns an existing image
func (c *Client) HealthService() grpc_health_v1.HealthClient
HealthService returns the underlying GRPC HealthClient
ImageService returns the underlying image Store
func (c *Client) Import(ctx context.Context, importer images.Importer, reader io.Reader, opts ...ImportOpt) ([]Image, error)
Import imports an image from a Tar stream using reader. Caller needs to specify importer. Future version may use oci.v1 as the default. Note that unreferrenced blobs may be imported to the content store as well.
func (c *Client) IntrospectionService() introspectionapi.IntrospectionClient
IntrospectionService returns the underlying Introspection Client
IsServing returns true if the client can successfully connect to the containerd daemon and the healthcheck service returns the SERVING response. This call will block if a transient error is encountered during connection. A timeout can be set in the context to ensure it returns early.
func (c *Client) LeasesService() leasesapi.LeasesClient
LeasesService returns the underlying Leases Client
ListImages returns all existing images
ListLeases lists active leases
LoadContainer loads an existing container from metadata
func (c *Client) NamespaceService() namespaces.Store
NamespaceService returns the underlying Namespaces Store
func (c *Client) NewContainer(ctx context.Context, id string, opts ...NewContainerOpts) (Container, error)
NewContainer will create a new container in container with the provided id the id must be unique within the namespace
Pull downloads the provided content into containerd's content store
func (c *Client) Push(ctx context.Context, ref string, desc ocispec.Descriptor, opts ...RemoteOpt) error
Push uploads the provided content to a remote resource
Reconnect re-establishes the GRPC connection to the containerd daemon
func (c *Client) SnapshotService(snapshotterName string) snapshots.Snapshotter
SnapshotService returns the underlying snapshotter for the provided snapshotter name
func (c *Client) Subscribe(ctx context.Context, filters ...string) (ch <-chan *events.Envelope, errs <-chan error)
Subscribe to events that match one or more of the provided filters.
Callers should listen on both the envelope and errs channels. If the errs channel returns nil or an error, the subscriber should terminate.
The subscriber can stop receiving events by canceling the provided context. The errs channel will be closed and return a nil error.
TaskService returns the underlying TasksClient
Version returns the version of containerd that the client is connected to
func (c *Client) VersionService() versionservice.VersionClient
VersionService returns the underlying VersionClient
func (c *Client) WithLease(ctx context.Context) (context.Context, func(context.Context) error, error)
WithLease attaches a lease on the context
ClientOpt allows callers to set options on the containerd client
WithDefaultNamespace sets the default namespace on the client
Any operation that does not have a namespace set on the context will be provided the default namespace
func WithDialOpts(opts []grpc.DialOption) ClientOpt
WithDialOpts allows grpc.DialOptions to be set on the connection
func WithServices(opts ...ServicesOpt) ClientOpt
WithServices sets services used by the client.
type Container interface {
// ID identifies the container
ID() string
// Info returns the underlying container record type
Info(context.Context) (containers.Container, error)
// Delete removes the container
Delete(context.Context, ...DeleteOpts) error
// NewTask creates a new task based on the container metadata
NewTask(context.Context, cio.Creator, ...NewTaskOpts) (Task, error)
// Spec returns the OCI runtime specification
Spec(context.Context) (*specs.Spec, error)
// Task returns the current task for the container
//
// If cio.Attach options are passed the client will reattach to the IO for the running
// task. If no task exists for the container a NotFound error is returned
//
// Clients must make sure that only one reader is attached to the task and consuming
// the output from the task's fifos
Task(context.Context, cio.Attach) (Task, error)
// Image returns the image that the container is based on
Image(context.Context) (Image, error)
// Labels returns the labels set on the container
Labels(context.Context) (map[string]string, error)
// SetLabels sets the provided labels for the container and returns the final label set
SetLabels(context.Context, map[string]string) (map[string]string, error)
// Extensions returns the extensions set on the container
Extensions(context.Context) (map[string]prototypes.Any, error)
// Update a container
Update(context.Context, ...UpdateContainerOpts) error
}Container is a metadata object for container resources and task creation
DeleteOpts allows the caller to set options for the deletion of a container
DiffService handles the computation and application of diffs
func NewDiffServiceFromClient(client diffapi.DiffClient) DiffService
NewDiffServiceFromClient returns a new diff service which communicates over a GRPC connection.
EventService handles the publish, forward and subscribe of events.
func NewEventServiceFromClient(client eventsapi.EventsClient) EventService
NewEventServiceFromClient returns a new event service which communicates over a GRPC connection.
type ExitStatus struct {
// contains filtered or unexported fields
}ExitStatus encapsulates a process' exit status. It is used by `Wait()` to return either a process exit code or an error
func (s ExitStatus) Error() error
Error returns the error, if any, that occurred while waiting for the process.
func (s ExitStatus) ExitCode() uint32
ExitCode returns the exit code of the process. This is only valid is Error() returns nil
func (s ExitStatus) ExitTime() time.Time
ExitTime returns the exit time of the process This is only valid is Error() returns nil
Result returns the exit code and time of the exit status. An error may be returned here to which indicates there was an error
at some point while waiting for the exit status. It does not signify an error with the process itself.
If an error is returned, the process may still be running.
ExportOpt allows the caller to specify export-specific options
IOCloseInfo allows specific io pipes to be closed on a process
type IOCloserOpts func(*IOCloseInfo)
IOCloserOpts allows the caller to set specific pipes as closed on a process
type Image interface {
// Name of the image
Name() string
// Target descriptor for the image content
Target() ocispec.Descriptor
// Unpack unpacks the image's content into a snapshot
Unpack(context.Context, string) error
// RootFS returns the unpacked diffids that make up images rootfs.
RootFS(ctx context.Context) ([]digest.Digest, error)
// Size returns the total size of the image's packed resources.
Size(ctx context.Context) (int64, error)
// Config descriptor for the image.
Config(ctx context.Context) (ocispec.Descriptor, error)
// IsUnpacked returns whether or not an image is unpacked.
IsUnpacked(context.Context, string) (bool, error)
// ContentStore provides a content store which contains image blob data
ContentStore() content.Store
}Image describes an image used by containers
NewImage returns a client image object from the metadata image
ImportOpt allows the caller to specify import specific options
type KillInfo struct {
// All kills all processes inside the task
// only valid on tasks, ignored on processes
All bool
// ExecID is the ID of a process to kill
ExecID string
}KillInfo contains information on how to process a Kill action
KillOpts allows options to be set for the killing of a process
WithKillExecID specifies the process ID
type Lease struct {
// contains filtered or unexported fields
}Lease is used to hold a reference to active resources which have not been referenced by a root resource. This is useful for preventing garbage collection of resources while they are actively being updated.
CreatedAt returns the time at which the lease was created
Delete deletes the lease, removing the reference to all resources created during the lease.
ID returns the lease ID
NewContainerOpts allows the caller to set additional options when creating a container
func WithCheckpoint(im Image, snapshotKey string) NewContainerOpts
WithCheckpoint allows a container to be created from the checkpointed information provided by the descriptor. The image, snapshot, and runtime specifications are restored on the container
func WithContainerExtension(name string, extension interface{}) NewContainerOpts
WithContainerExtension appends extension data to the container object. Use this to decorate the container object with additional data for the client integration.
Make sure to register the type of `extension` in the typeurl package via `typeurl.Register` or container creation may fail.
func WithContainerLabels(labels map[string]string) NewContainerOpts
WithContainerLabels adds the provided labels to the container
func WithImage(i Image) NewContainerOpts
WithImage sets the provided image as the base for the container
func WithNewSnapshot(id string, i Image) NewContainerOpts
WithNewSnapshot allocates a new snapshot to be used by the container as the root filesystem in read-write mode
func WithNewSnapshotView(id string, i Image) NewContainerOpts
WithNewSnapshotView allocates a new snapshot to be used by the container as the root filesystem in read-only mode
func WithNewSpec(opts ...oci.SpecOpts) NewContainerOpts
WithNewSpec generates a new spec for a new container
func WithRemappedSnapshot(id string, i Image, uid, gid uint32) NewContainerOpts
WithRemappedSnapshot creates a new snapshot and remaps the uid/gid for the filesystem to be used by a container with user namespaces
func WithRemappedSnapshotView(id string, i Image, uid, gid uint32) NewContainerOpts
WithRemappedSnapshotView is similar to WithRemappedSnapshot but rootfs is mounted as read-only.
func WithRuntime(name string, options interface{}) NewContainerOpts
WithRuntime allows a user to specify the runtime name and additional options that should be used to create tasks for the container
func WithSnapshot(id string) NewContainerOpts
WithSnapshot uses an existing root filesystem for the container
func WithSnapshotter(name string) NewContainerOpts
WithSnapshotter sets the provided snapshotter for use by the container
This option must appear before other snapshotter options to have an effect.
WithSpec sets the provided spec on the container
NewTaskOpts allows the caller to set options on a new task
func WithRootFS(mounts []mount.Mount) NewTaskOpts
WithRootFS allows a task to be created without a snapshot being allocated to its container
func WithTaskCheckpoint(im Image) NewTaskOpts
WithTaskCheckpoint allows a task to be created with live runtime and memory data from a previous checkpoint. Additional software such as CRIU may be required to restore a task from a checkpoint
type Process interface {
// ID of the process
ID() string
// Pid is the system specific process id
Pid() uint32
// Start starts the process executing the user's defined binary
Start(context.Context) error
// Delete removes the process and any resources allocated returning the exit status
Delete(context.Context, ...ProcessDeleteOpts) (*ExitStatus, error)
// Kill sends the provided signal to the process
Kill(context.Context, syscall.Signal, ...KillOpts) error
// Wait asynchronously waits for the process to exit, and sends the exit code to the returned channel
Wait(context.Context) (<-chan ExitStatus, error)
// CloseIO allows various pipes to be closed on the process
CloseIO(context.Context, ...IOCloserOpts) error
// Resize changes the width and heigh of the process's terminal
Resize(ctx context.Context, w, h uint32) error
// IO returns the io set for the process
IO() cio.IO
// Status returns the executing status of the process
Status(context.Context) (Status, error)
}Process represents a system process
ProcessDeleteOpts allows the caller to set options for the deletion of a task
type ProcessInfo struct {
// Pid is the process ID
Pid uint32
// Info includes additional process information
// Info varies by platform
Info *google_protobuf.Any
}ProcessInfo provides platform specific process information
ProcessStatus returns a human readable status for the Process representing its current status
const (
// Running indicates the process is currently executing
Running ProcessStatus = "running"
// Created indicates the process has been created within containerd but the
// user's defined process has not started
Created ProcessStatus = "created"
// Stopped indicates that the process has ran and exited
Stopped ProcessStatus = "stopped"
// Paused indicates that the process is currently paused
Paused ProcessStatus = "paused"
// Pausing indicates that the process is currently switching from a
// running state into a paused state
Pausing ProcessStatus = "pausing"
// Unknown indicates that we could not determine the status from the runtime
Unknown ProcessStatus = "unknown"
)type RemoteContext struct {
// Resolver is used to resolve names to objects, fetchers, and pushers.
// If no resolver is provided, defaults to Docker registry resolver.
Resolver remotes.Resolver
// Platforms defines which platforms to handle when doing the image operation.
// If this field is empty, content for all platforms will be pulled.
Platforms []string
// Unpack is done after an image is pulled to extract into a snapshotter.
// If an image is not unpacked on pull, it can be unpacked any time
// afterwards. Unpacking is required to run an image.
Unpack bool
// Snapshotter used for unpacking
Snapshotter string
// Labels to be applied to the created image
Labels map[string]string
// BaseHandlers are a set of handlers which get are called on dispatch.
// These handlers always get called before any operation specific
// handlers.
BaseHandlers []images.Handler
// ConvertSchema1 is whether to convert Docker registry schema 1
// manifests. If this option is false then any image which resolves
// to schema 1 will return an error since schema 1 is not supported.
ConvertSchema1 bool
}RemoteContext is used to configure object resolutions and transfers with remote content stores and image providers.
type RemoteOpt func(*Client, *RemoteContext) error
RemoteOpt allows the caller to set distribution options for a remote
WithImageHandler adds a base handler to be called on dispatch.
WithPlatform allows the caller to specify a platform to retrieve content for
WithPullLabel sets a label to be associated with a pulled reference
WithPullLabels associates a set of labels to a pulled reference
WithPullSnapshotter specifies snapshotter name used for unpacking
WithResolver specifies the resolver to use.
type ServicesOpt func(c *services)
ServicesOpt allows callers to set options on the services
func WithContainerService(containerService containersapi.ContainersClient) ServicesOpt
WithContainerService sets the container service.
func WithContentStore(contentStore content.Store) ServicesOpt
WithContentStore sets the content store.
func WithDiffService(diffService diff.DiffClient) ServicesOpt
WithDiffService sets the diff service.
func WithEventService(eventService EventService) ServicesOpt
WithEventService sets the event service.
func WithImageService(imageService imagesapi.ImagesClient) ServicesOpt
WithImageService sets the image service.
func WithLeasesService(leasesService leases.LeasesClient) ServicesOpt
WithLeasesService sets the lease service.
func WithNamespaceService(namespaceService namespacesapi.NamespacesClient) ServicesOpt
WithNamespaceService sets the namespace service.
func WithSnapshotters(snapshotters map[string]snapshots.Snapshotter) ServicesOpt
WithSnapshotters sets the snapshotters.
func WithTaskService(taskService tasks.TasksClient) ServicesOpt
WithTaskService sets the task service.
type Status struct {
// Status of the process
Status ProcessStatus
// ExitStatus returned by the process
ExitStatus uint32
// ExitedTime is the time at which the process died
ExitTime time.Time
}Status returns process status and exit information
type Task interface {
Process
// Pause suspends the execution of the task
Pause(context.Context) error
// Resume the execution of the task
Resume(context.Context) error
// Exec creates a new process inside the task
Exec(context.Context, string, *specs.Process, cio.Creator) (Process, error)
// Pids returns a list of system specific process ids inside the task
Pids(context.Context) ([]ProcessInfo, error)
// Checkpoint serializes the runtime and memory information of a task into an
// OCI Index that can be push and pulled from a remote resource.
//
// Additional software like CRIU maybe required to checkpoint and restore tasks
Checkpoint(context.Context, ...CheckpointTaskOpts) (Image, error)
// Update modifies executing tasks with updated settings
Update(context.Context, ...UpdateTaskOpts) error
// LoadProcess loads a previously created exec'd process
LoadProcess(context.Context, string, cio.Attach) (Process, error)
// Metrics returns task metrics for runtime specific metrics
//
// The metric types are generic to containerd and change depending on the runtime
// For the built in Linux runtime, github.com/containerd/cgroups.Metrics
// are returned in protobuf format
Metrics(context.Context) (*types.Metric, error)
}Task is the executable object within containerd
type TaskInfo struct {
// Checkpoint is the Descriptor for an existing checkpoint that can be used
// to restore a task's runtime and memory state
Checkpoint *types.Descriptor
// RootFS is a list of mounts to use as the task's root filesystem
RootFS []mount.Mount
// Options hold runtime specific settings for task creation
Options interface{}
}TaskInfo sets options for task creation
UpdateContainerOpts allows the caller to set additional options when updating a container
type UpdateTaskInfo struct {
// Resources updates a tasks resource constraints
Resources interface{}
}UpdateTaskInfo allows updated specific settings to be changed on a task
UpdateTaskOpts allows a caller to update task settings
func WithResources(resources *specs.LinuxResources) UpdateTaskOpts
WithResources sets the provided resources for task updates
type Version struct {
// Version number
Version string
// Revision from git that was built
Revision string
}Version of containerd
| Path | Synopsis |
|---|---|
| api/events | Package events is a generated protocol buffer package. |
| api/services/containers/v1 | Package containers is a generated protocol buffer package. |
| api/services/content/v1 | Package content is a generated protocol buffer package. |
| api/services/diff/v1 | Package diff is a generated protocol buffer package. |
| api/services/events/v1 | Package events defines the event pushing and subscription service. |
| api/services/images/v1 | Package images is a generated protocol buffer package. |
| api/services/introspection/v1 | Package introspection is a generated protocol buffer package. |
| api/services/leases/v1 | Package leases is a generated protocol buffer package. |
| api/services/namespaces/v1 | Package namespaces is a generated protocol buffer package. |
| api/services/snapshots/v1 | Package snapshots is a generated protocol buffer package. |
| api/services/tasks/v1 | Package tasks is a generated protocol buffer package. |
| api/services/version/v1 | Package version is a generated protocol buffer package. |
| api/types | Package types is a generated protocol buffer package. |
| api/types/task | Package task is a generated protocol buffer package. |
| archive | |
| archive/compression | |
| cio | |
| cmd/containerd | |
| cmd/containerd/command | |
| cmd/containerd-release | |
| cmd/containerd-shim | |
| cmd/containerd-stress | |
| cmd/ctr | |
| cmd/ctr/app | |
| cmd/ctr/command | |
| cmd/ctr/commands | |
| cmd/ctr/commands/containers | |
| cmd/ctr/commands/content | |
| cmd/ctr/commands/events | |
| cmd/ctr/commands/images | |
| cmd/ctr/commands/namespaces | |
| cmd/ctr/commands/plugins | |
| cmd/ctr/commands/pprof | |
| cmd/ctr/commands/run | |
| cmd/ctr/commands/shim | |
| cmd/ctr/commands/snapshots | |
| cmd/ctr/commands/tasks | |
| cmd/ctr/commands/version | |
| cmd/protoc-gen-gogoctrd | |
| containers | |
| content | |
| content/local | |
| content/testsuite | |
| contrib/apparmor | |
| contrib/seccomp | |
| debug | |
| defaults | Package defaults provides several common defaults for interacting wtih containerd. |
| dialer | |
| diff | |
| diff/apply | |
| diff/walking | |
| diff/walking/plugin | |
| diff/windows | |
| errdefs | Package errdefs defines the common errors used throughout containerd packages. |
| events | |
| events/exchange | |
| filters | Package filters defines a syntax and parser that can be used for the filtration of items across the containerd API. |
| gc | Package gc experiments with providing central gc tooling to ensure deterministic resource removal within containerd. |
| gc/scheduler | |
| identifiers | Package identifiers provides common validation for identifiers and keys across containerd. |
| images | |
| images/oci | Package oci provides the importer and the exporter for OCI Image Spec. |
| labels | |
| leases | |
| linux | |
| linux/proc | |
| linux/runctypes | Package runctypes is a generated protocol buffer package. |
| linux/shim | |
| linux/shim/client | |
| linux/shim/v1 | Package shim is a generated protocol buffer package. |
| log | |
| metadata | |
| metadata/boltutil | |
| metrics/cgroups | |
| mount | |
| mount/lookup_test | |
| namespaces | Package namespaces provides tools for working with namespaces across containerd. |
| oci | |
| platforms | Package platforms provides a toolkit for normalizing, matching and specifying container platforms. |
| plugin | |
| progress | Package progress assists in displaying human readable progress information. |
| protobuf/google/rpc | Package rpc is a generated protocol buffer package. |
| protobuf/plugin | Package plugin is a generated protocol buffer package. |
| protobuf/plugin/fieldpath | |
| reaper | |
| reference | |
| remotes | |
| remotes/docker | |
| remotes/docker/schema1 | |
| rootfs | |
| runtime | |
| server | |
| services/containers | |
| services/content | |
| services/diff | |
| services/events | |
| services/healthcheck | |
| services/images | |
| services/introspection | |
| services/leases | |
| services/namespaces | |
| services/snapshots | |
| services/tasks | |
| services/version | |
| snapshots | |
| snapshots/btrfs | |
| snapshots/native | |
| snapshots/overlay | |
| snapshots/storage | Package storage provides a metadata storage implementation for snapshot drivers. |
| snapshots/testsuite | |
| snapshots/windows | |
| sys | |
| testutil | |
| version | |
| windows | |
| windows/hcsshimtypes | Package hcsshimtypes holds the windows runtime specific types |
Package containerd imports 58 packages (graph) and is imported by 74 packages. Updated 2018-04-24. Refresh now. Tools for package owners.