build

type Base ¶ added in v0.10.0

type Base struct {
	Image string // image identifier
	Stage string // optional internal name used for multi-stage builds
}

Base is a concrete build instruction for declaring the base container image to start with.

func (base Base) Compile() []string

type Copy ¶

type Copy struct {
	Sources     []string // source file/directory paths
	Destination string   // destination path
}

Copy is a concrete build instruction for copying source files/directories from the build host into the image.

func (copy Copy) Compile() []string

type CopyAs ¶ added in v0.3.0

type CopyAs struct {
	UID string // owner UID
	GID string // owner GID
	Instruction
}

CopyAs is a concrete build instruction for copying source files/directories and setting their ownership to the given UID/GID.

While it can technically wrap any build.Instruction, it is meant to be used with build.Copy and build.CopyFrom to enforce file/directory ownership.

func (ca CopyAs) Compile() []string

type CopyFrom ¶

type CopyFrom struct {
	From string // source variant name
	Copy
}

CopyFrom is a concrete build instruction for copying source files/directories from one variant image to another.

func (cf CopyFrom) Compile() []string

type EntryPoint ¶ added in v0.3.0

type EntryPoint struct {
	Command []string // command and arguments
}

EntryPoint is a build instruction for declaring a container's default runtime process.

func (ep EntryPoint) Compile() []string

type Env ¶

type Env struct {
	Definitions map[string]string // number of key/value pairs
}

Env is a concrete build instruction for declaring a container's runtime environment variables.

func Home(name string) Env

func (env Env) Compile() []string

type Instruction ¶

type Instruction interface {
	Compile() []string
}

Instruction defines a common interface that all concrete build types must implement.

func ApplyUser(uid string, gid string, instructions []Instruction) []Instruction

type Label ¶

type Label struct {
	Definitions map[string]string // number of meta-data key/value pairs
}

Label is a concrete build instruction for declaring a number of meta-data key/value pairs to be included in the image.

func (label Label) Compile() []string

type Phase ¶

type Phase int

Phase enum type

const (
	PhasePrivileged       Phase = iota // first, copies/execution done as root
	PhasePrivilegeDropped              // second, copies/execution done as unprivileged user from here on
	PhasePreInstall                    // third, before application files and artifacts are copied
	PhaseInstall                       // fourth, application files and artifacts are copied
	PhasePostInstall                   // fifth, after application files and artifacts are copied
)

func Phases() []Phase

type PhaseCompileable ¶

type PhaseCompileable interface {
	InstructionsForPhase(phase Phase) []Instruction
}

PhaseCompileable defines and interface that all configuration types should implement if they want to inject build instructions into any of the defined build phases.

type Run ¶

type Run struct {
	Command   string   // command string (e.g. "useradd -d %s -u %s")
	Arguments []string // command arguments both inner and final (e.g. ["/home/user", "123", "user"])
}

Run is a concrete build instruction for passing any number of arguments to a shell command.

The command string may contain inner argument placeholders using the "%s" format verb and will be appended with the quoted values of any arguments that remain after interpolation of the command string.

func Chown(uid string, gid string, path string) Run

func CreateDirectories(paths []string) Run

func CreateDirectory(path string) Run

func CreateUser(name string, uid string, gid string) []Run

func (run Run) Compile() []string

type RunAll ¶

type RunAll struct {
	Runs []Run // multiple Run instructions to be executed together
}

RunAll is a concrete build instruction for declaring multiple Run instructions that will be executed together in a `cmd1 && cmd2` chain.

func (runAll RunAll) Compile() []string

type ScratchBase ¶ added in v0.10.0

type ScratchBase struct {
	Stage string // optional internal name used for multi-stage builds
}

ScratchBase is a concrete build instruction for declaring no base image.

func (sb ScratchBase) Compile() []string

type StringArg ¶ added in v0.10.0

type StringArg struct {
	Name    string // argument name
	Default string // argument default value
}

StringArg is a build instruction defining a build-time replaceable argument with a string value.

func NewStringArg(varname string, value string) StringArg

func (arg StringArg) Compile() []string

type UintArg ¶ added in v0.10.0

type UintArg struct {
	Name    string // argument name
	Default uint   // argument default value
}

UintArg is a build instruction defining a build-time replaceable argument with an integer value.

func NewUintArg(varname string, value uint) UintArg

func (arg UintArg) Compile() []string

type User ¶ added in v0.3.0

type User struct {
	UID string // user ID
}

User is a build instruction for setting which user will run future commands.

func (user User) Compile() []string

type WorkingDirectory ¶ added in v0.3.0

type WorkingDirectory struct {
	Path string // working directory path
}

WorkingDirectory is a build instruction for defining the working directory for future command and entrypoint instructions.

func (wd WorkingDirectory) Compile() []string