run

Documentation

Index

• Variables
• func NewContainer(ctx gocontext.Context, client *containerd.Client, context *cli.Context) (containerd.Container, error)

Variables

var Command = cli.Command{
	Name:      "run",
	Usage:     "run a container",
	ArgsUsage: "[flags] Image|RootFS ID [COMMAND] [ARG...]",
	Flags: append([]cli.Flag{
		cli.BoolFlag{
			Name:  "rm",
			Usage: "remove the container after running",
		},
		cli.BoolFlag{
			Name:  "null-io",
			Usage: "send all IO to /dev/null",
		},
		cli.BoolFlag{
			Name:  "detach,d",
			Usage: "detach from the task after it has started execution",
		},
		cli.StringFlag{
			Name:  "fifo-dir",
			Usage: "directory used for storing IO FIFOs",
		},
	}, append(commands.SnapshotterFlags, ContainerFlags...)...),
	Action: func(context *cli.Context) error {
		var (
			err error

			id     = context.Args().Get(1)
			ref    = context.Args().First()
			tty    = context.Bool("tty")
			detach = context.Bool("detach")
		)

		if ref == "" {
			return errors.New("image ref must be provided")
		}
		if id == "" {
			return errors.New("container id must be provided")
		}
		client, ctx, cancel, err := commands.NewClient(context)
		if err != nil {
			return err
		}
		defer cancel()
		container, err := NewContainer(ctx, client, context)
		if err != nil {
			return err
		}
		if context.Bool("rm") && !detach {
			defer container.Delete(ctx, containerd.WithSnapshotCleanup)
		}
		opts := getNewTaskOpts(context)
		ioOpts := []cio.Opt{cio.WithFIFODir(context.String("fifo-dir"))}
		task, err := tasks.NewTask(ctx, client, container, context.String("checkpoint"), tty, context.Bool("null-io"), ioOpts, opts...)
		if err != nil {
			return err
		}
		var statusC <-chan containerd.ExitStatus
		if !detach {
			defer task.Delete(ctx)
			if statusC, err = task.Wait(ctx); err != nil {
				return err
			}
		}
		if context.IsSet("pid-file") {
			if err := commands.WritePidFile(context.String("pid-file"), int(task.Pid())); err != nil {
				return err
			}
		}
		var con console.Console
		if tty {
			con = console.Current()
			defer con.Reset()
			if err := con.SetRaw(); err != nil {
				return err
			}
		}
		if err := task.Start(ctx); err != nil {
			return err
		}
		if detach {
			return nil
		}
		if tty {
			if err := tasks.HandleConsoleResize(ctx, task, con); err != nil {
				logrus.WithError(err).Error("console resize")
			}
		} else {
			sigc := commands.ForwardAllSignals(ctx, task)
			defer commands.StopCatch(sigc)
		}
		status := <-statusC
		code, _, err := status.Result()
		if err != nil {
			return err
		}
		if _, err := task.Delete(ctx); err != nil {
			return err
		}
		if code != 0 {
			return cli.NewExitError("", int(code))
		}
		return nil
	},
}

Command runs a container

var ContainerFlags = []cli.Flag{
	cli.StringFlag{
		Name:  "config,c",
		Usage: "path to the runtime-specific spec config file",
	},
	cli.StringFlag{
		Name:  "checkpoint",
		Usage: "provide the checkpoint digest to restore the container",
	},
	cli.StringFlag{
		Name:  "cwd",
		Usage: "specify the working directory of the process",
	},
	cli.StringSliceFlag{
		Name:  "env",
		Usage: "specify additional container environment variables (i.e. FOO=bar)",
	},
	cli.StringSliceFlag{
		Name:  "label",
		Usage: "specify additional labels (i.e. foo=bar)",
	},
	cli.StringSliceFlag{
		Name:  "mount",
		Usage: "specify additional container mount (ex: type=bind,src=/tmp,dst=/host,options=rbind:ro)",
	},
	cli.BoolFlag{
		Name:  "net-host",
		Usage: "enable host networking for the container",
	},
	cli.BoolFlag{
		Name:  "privileged",
		Usage: "run privileged container",
	},
	cli.BoolFlag{
		Name:  "read-only",
		Usage: "set the containers filesystem as readonly",
	},
	cli.StringFlag{
		Name:  "runtime",
		Usage: "runtime name (io.containerd.runtime.v1.linux, io.containerd.runtime.v1.windows, io.containerd.runtime.v1.com.vmware.linux)",
		Value: fmt.Sprintf("io.containerd.runtime.v1.%s", runtime.GOOS),
	},
	cli.BoolFlag{
		Name:  "tty,t",
		Usage: "allocate a TTY for the container",
	},
	cli.StringSliceFlag{
		Name:  "with-ns",
		Usage: "specify existing Linux namespaces to join at container runtime (format '<nstype>:<path>')",
	},
	cli.StringFlag{
		Name:  "pid-file",
		Usage: "file path to write the task's pid",
	},
}

ContainerFlags are cli flags specifying container options

Functions

func NewContainer

func NewContainer(ctx gocontext.Context, client *containerd.Client, context *cli.Context) (containerd.Container, error)

NewContainer creates a new container