lxd

package module
v0.0.0-...-b66d4f6 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 4, 2015 License: Apache-2.0 Imports: 23 Imported by: 0

README

LXD

REST API, command line tool and OpenStack integration plugin for LXC.

LXD is pronounced lex-dee.

CI status

  • Travis: Build Status
  • Jenkins: Build Status

Getting started with LXD

Since LXD development is happening at such a rapid pace, we only provide daily builds right now. They're available via:

sudo add-apt-repository ppa:ubuntu-lxc/lxd-git-master && sudo apt-get update
sudo apt-get install lxd

After you've got LXD installed, you can take your first steps.

Building from source

We recommend having the latest versions of liblxc (>= 1.1 required) and CRIU (>= 1.7 recommended) available for LXD development. Additionally, LXD requires Golang 1.3 or later to work. All the right verisons dependencies are available via the LXD PPA:

sudo apt-get install software-properties-common
sudo add-apt-repository ppa:ubuntu-lxc/lxd-git-master
sudo apt-get update
sudo apt-get install golang lxc lxc-dev mercurial git pkg-config protobuf-compiler golang-goprotobuf-dev xz-utils tar acl

There are a few storage backends for LXD besides the default "directory" backend. Installing these tools adds a bit to initramfs and may slow down your host boot, but are needed if you'd like to use a particular backend:

sudo apt-get install lvm2 thin-provisioning-tools
sudo apt-get install btrfs-tools

To run the testsuite, you'll also need:

sudo apt-get install curl gettext jq sqlite3 uuid-runtime pyflakes pep8 shellcheck bzr
Building the tools

LXD consists of two binaries, a client called lxc and a server called lxd. These live in the source tree in the lxc/ and lxd/ dirs, respectively. To get the code, set up your go environment:

mkdir -p ~/go
export GOPATH=~/go

And then download it as usual:

go get github.com/lxc/lxd
cd $GOPATH/src/github.com/lxc/lxd
make

...which will give you two binaries in $GOPATH/bin, lxd the daemon binary, and lxc a command line client to that daemon.

Machine Setup

You'll need sub{u,g}ids for root, so that LXD can create the unprivileged containers:

echo "root:1000000:65536" | sudo tee -a /etc/subuid /etc/subgid

Now you can run the daemon (the --group sudo bit allows everyone in the sudo group to talk to LXD; you can create your own group if you want):

sudo -E $GOPATH/bin/lxd --group sudo

First steps

LXD has two parts, the daemon (the lxd binary), and the client (the lxc binary). Now that the daemon is all configured and running (either via the packaging or via the from-source instructions above), you can import an image:

$GOPATH/src/github.com/lxc/lxd/scripts/lxd-images import ubuntu --alias ubuntu

With that image imported into LXD, you can now start containers:

$GOPATH/bin/lxc launch ubuntu

Alternatively, you can also use a remote LXD host as a source of images. Those will be automatically cached for you for up at container startup time:

$GOPATH/bin/lxc remote add images images.linuxcontainers.org
$GOPATH/bin/lxc launch images:centos/7/amd64 centos

Bug reports

Bug reports can be filed at https://github.com/lxc/lxd/issues/new

Contributing

Fixes and new features are greatly appreciated but please read our contributing guidelines first.

Contributions to this project should be sent as pull requests on github.

Hacking

Sometimes it is useful to view the raw response that LXD sends; you can do this by:

lxc config set core.trust_password foo
lxc remote add local 127.0.0.1:8443
wget --no-check-certificate https://127.0.0.1:8443/1.0 --certificate=$HOME/.config/lxc/client.crt --private-key=$HOME/.config/lxc/client.key -O - -q

Support and discussions

We use the LXC mailing-lists for developer and user discussions, you can find and subscribe to those at: https://lists.linuxcontainers.org

If you prefer live discussions, some of us also hang out in #lxcontainers on irc.freenode.net.

FAQ

When I do a lxc remote add over https, it asks for a password?

By default, LXD has no password for security reasons, so you can't do a remote add this way. In order to set a password, do:

lxc config set core.trust_password SECRET

on the host LXD is running on. This will set the remote password that you can then use to do lxc remote add.

How can I live migrate a container using LXD?

NOTE: in order to have a migratable container, you need to disable almost all of the seciruty that LXD provides. We are working on fixing this, but it requires several kernel changes that take time. You should not use migratable containers for untrusted workloads right now.

In order to create a migratable container, LXD provides a built in profile called "migratable". First, launch your container with the following,

 lxc launch -p default -p migratable ubuntu $somename

Ensure you have criu installed on both hosts (sudo apt-get install criu for Ubuntu), and do:

lxc move host1:$somename host2:$somename

And with luck you'll have migrated the container :)

Can I bind mount my home directory in a container?

Yes. The easiest way to do that is using a privileged container:

lxc launch ubuntu priv -c security.privileged=true
lxc config device add priv homedir disk source=/home/$USER path=/home/ubuntu

Documentation

Index

Constants

This section is empty.

Variables

View Source
var ConfigDir = "$HOME/.config/lxc"
View Source
var DefaultConfig = Config{
	Remotes:       defaultRemote,
	DefaultRemote: "local",
	Aliases:       map[string]string{},
}
View Source
var (
	// LXDErrors are special errors; the client library hoists error codes
	// to these errors internally so that user code can compare against
	// them. We probably shouldn't hoist BadRequest or InternalError, since
	// LXD passes an error string along which is more informative than
	// whatever static error message we would put here.
	LXDErrors = map[int]error{
		http.StatusNotFound: fmt.Errorf("not found"),
	}
)
View Source
var LocalRemote = RemoteConfig{
	Addr:   "unix://",
	Public: false}

Functions

func ConfigPath

func ConfigPath(file string) string

func SaveConfig

func SaveConfig(c *Config) error

SaveConfig writes the provided configuration to the config file.

func ServerCertPath

func ServerCertPath(name string) string

func WebsocketDial

func WebsocketDial(dialer websocket.Dialer, url string) (*websocket.Conn, error)

WebsocketDial attempts to dial a websocket to a LXD instance, parsing LXD-style errors and returning them as go errors.

Types

type Client

type Client struct {
	Remote *RemoteConfig

	BaseURL   string
	BaseWSURL string
	Transport string
	// contains filtered or unexported fields
}

Client can talk to a LXD daemon.

func NewClient

func NewClient(config *Config, remote string) (*Client, error)

NewClient returns a new LXD client.

func (*Client) Action

func (c *Client) Action(name string, action shared.ContainerAction, timeout int, force bool) (*Response, error)

func (*Client) AddMyCertToServer

func (c *Client) AddMyCertToServer(pwd string) error

func (*Client) Addresses

func (c *Client) Addresses() ([]string, error)

func (*Client) AmTrusted

func (c *Client) AmTrusted() bool

func (*Client) ApplyProfile

func (c *Client) ApplyProfile(container, profile string) (*Response, error)

func (*Client) AsyncWaitMeta

func (c *Client) AsyncWaitMeta(resp *Response) (*shared.Jmap, error)

func (*Client) CertificateAdd

func (c *Client) CertificateAdd(cert *x509.Certificate, name string) error

func (*Client) CertificateList

func (c *Client) CertificateList() ([]shared.CertInfo, error)

func (*Client) CertificateRemove

func (c *Client) CertificateRemove(fingerprint string) error

func (*Client) ContainerDeviceAdd

func (c *Client) ContainerDeviceAdd(container, devname, devtype string, props []string) (*Response, error)

func (*Client) ContainerDeviceDelete

func (c *Client) ContainerDeviceDelete(container, devname string) (*Response, error)

func (*Client) ContainerListDevices

func (c *Client) ContainerListDevices(container string) ([]string, error)

func (*Client) ContainerStatus

func (c *Client) ContainerStatus(name string) (*shared.ContainerState, error)

func (*Client) CopyImage

func (c *Client) CopyImage(image string, dest *Client, copy_aliases bool, aliases []string, public bool) error

func (*Client) Delete

func (c *Client) Delete(name string) (*Response, error)

func (*Client) DeleteAlias

func (c *Client) DeleteAlias(alias string) error

func (*Client) DeleteImage

func (c *Client) DeleteImage(image string) error

func (*Client) Exec

func (c *Client) Exec(name string, cmd []string, env map[string]string,
	stdin io.ReadCloser, stdout io.WriteCloser,
	stderr io.WriteCloser, controlHandler func(*Client, *websocket.Conn)) (int, error)

Exec runs a command inside the LXD container. For "interactive" use such as `lxc exec ...`, one should pass a controlHandler that talks over the control socket and handles things like SIGWINCH. If running non-interactive, passing a nil controlHandler will cause Exec to return when all of the command output is sent to the output buffers.

func (*Client) ExportImage

func (c *Client) ExportImage(image string, target string) (*Response, string, error)

func (*Client) Finger

func (c *Client) Finger() error

func (*Client) GetAlias

func (c *Client) GetAlias(alias string) string

func (*Client) GetContainerConfig

func (c *Client) GetContainerConfig(container string) ([]string, error)

* return string array representing a container's full configuration

func (*Client) GetImageInfo

func (c *Client) GetImageInfo(image string) (*shared.ImageInfo, error)

func (*Client) GetLog

func (c *Client) GetLog(container string, log string) (io.Reader, error)

func (*Client) GetMigrationSourceWS

func (c *Client) GetMigrationSourceWS(container string) (*Response, error)

func (*Client) GetProfileConfig

func (c *Client) GetProfileConfig(profile string) (map[string]string, error)

func (*Client) GetServerConfig

func (c *Client) GetServerConfig() (*Response, error)

func (*Client) GetServerConfigString

func (c *Client) GetServerConfigString() ([]string, error)

func (*Client) ImageFromContainer

func (c *Client) ImageFromContainer(cname string, public bool, aliases []string, properties map[string]string) (string, error)

func (*Client) Init

func (c *Client) Init(name string, imgremote string, image string, profiles *[]string, config map[string]string, ephem bool) (*Response, error)

Init creates a container from either a fingerprint or an alias; you must provide at least one.

func (*Client) IsAlias

func (c *Client) IsAlias(alias string) (bool, error)

func (*Client) IsPublic

func (c *Client) IsPublic() bool

func (*Client) ListAliases

func (c *Client) ListAliases() ([]shared.ImageAlias, error)

func (*Client) ListContainers

func (c *Client) ListContainers() ([]shared.ContainerInfo, error)

func (*Client) ListImages

func (c *Client) ListImages() ([]shared.ImageInfo, error)

func (*Client) ListProfiles

func (c *Client) ListProfiles() ([]string, error)

func (*Client) ListSnapshots

func (c *Client) ListSnapshots(container string) ([]string, error)

func (*Client) LocalCopy

func (c *Client) LocalCopy(source string, name string, config map[string]string, profiles []string, ephemeral bool) (*Response, error)

func (*Client) MigrateFrom

func (c *Client) MigrateFrom(name string, operation string, secrets map[string]string, config map[string]string, profiles []string, baseImage string, ephemeral bool) (*Response, error)

func (*Client) PostAlias

func (c *Client) PostAlias(alias string, desc string, target string) error

func (*Client) PostImage

func (c *Client) PostImage(imageFile string, rootfsFile string, properties []string, public bool, aliases []string) (string, error)

func (*Client) ProfileConfig

func (c *Client) ProfileConfig(name string) (*shared.ProfileConfig, error)

func (*Client) ProfileCopy

func (c *Client) ProfileCopy(name, newname string, dest *Client) error

func (*Client) ProfileCreate

func (c *Client) ProfileCreate(p string) error

func (*Client) ProfileDelete

func (c *Client) ProfileDelete(p string) error

func (*Client) ProfileDeviceAdd

func (c *Client) ProfileDeviceAdd(profile, devname, devtype string, props []string) (*Response, error)

func (*Client) ProfileDeviceDelete

func (c *Client) ProfileDeviceDelete(profile, devname string) (*Response, error)

func (*Client) ProfileListDevices

func (c *Client) ProfileListDevices(profile string) ([]string, error)

func (*Client) PullFile

func (c *Client) PullFile(container string, p string) (int, int, os.FileMode, io.ReadCloser, error)

func (*Client) PushFile

func (c *Client) PushFile(container string, p string, gid int, uid int, mode os.FileMode, buf io.ReadSeeker) error

func (*Client) PutImageInfo

func (c *Client) PutImageInfo(name string, p shared.BriefImageInfo) error

func (*Client) PutProfile

func (c *Client) PutProfile(name string, profile shared.ProfileConfig) error

func (*Client) Rename

func (c *Client) Rename(name string, newName string) (*Response, error)

func (*Client) RestoreSnapshot

func (c *Client) RestoreSnapshot(container string, snapshotName string, stateful bool) (*Response, error)

func (*Client) ServerStatus

func (c *Client) ServerStatus() (*shared.ServerState, error)

func (*Client) SetContainerConfig

func (c *Client) SetContainerConfig(container, key, value string) error

func (*Client) SetProfileConfigItem

func (c *Client) SetProfileConfigItem(profile, key, value string) error

func (*Client) SetServerConfig

func (c *Client) SetServerConfig(key string, value string) (*Response, error)

func (*Client) Snapshot

func (c *Client) Snapshot(container string, snapshotName string, stateful bool) (*Response, error)

func (*Client) UpdateContainerConfig

func (c *Client) UpdateContainerConfig(container string, st shared.BriefContainerState) error

func (*Client) UserAuthServerCert

func (c *Client) UserAuthServerCert(name string, acceptCert bool) error

func (*Client) WaitFor

func (c *Client) WaitFor(waitURL string) (*shared.Operation, error)

Wait for an operation

func (*Client) WaitForSuccess

func (c *Client) WaitForSuccess(waitURL string) error

type Config

type Config struct {
	// DefaultRemote holds the remote daemon name from the Remotes map
	// that the client should communicate with by default.
	// If empty it defaults to "local".
	DefaultRemote string `yaml:"default-remote"`

	// Remotes defines a map of remote daemon names to the details for
	// communication with the named daemon.
	// The implicit "local" remote is always available and communicates
	// with the local daemon over a unix socket.
	Remotes map[string]RemoteConfig `yaml:"remotes"`

	// Command line aliases for `lxc`
	Aliases map[string]string `yaml:"aliases"`
}

Config holds settings to be used by a client or daemon.

func LoadConfig

func LoadConfig() (*Config, error)

LoadConfig reads the configuration from the config path.

func (*Config) ParseRemote

func (c *Config) ParseRemote(raw string) string

func (*Config) ParseRemoteAndContainer

func (c *Config) ParseRemoteAndContainer(raw string) (string, string)

type RemoteConfig

type RemoteConfig struct {
	Addr   string `yaml:"addr"`
	Public bool   `yaml:"public"`
}

RemoteConfig holds details for communication with a remote daemon.

type Response

type Response struct {
	Type ResponseType `json:"type"`

	/* Valid only for Sync responses */
	Status     string `json:"status"`
	StatusCode int    `json:"status_code"`

	/* Valid only for Async responses */
	Operation string              `json:"operation"`
	Resources map[string][]string `json:"resources"`

	/* Valid only for Error responses */
	Code  int    `json:"error_code"`
	Error string `json:"error"`

	/* Valid for Sync and Error responses */
	Metadata json.RawMessage `json:"metadata"`
}

func HoistResponse

func HoistResponse(r *http.Response, rtype ResponseType) (*Response, error)

HoistResponse hoists a regular http response into a response of type rtype or returns a golang error.

func ParseResponse

func ParseResponse(r *http.Response) (*Response, error)

ParseResponse parses a lxd style response out of an http.Response. Note that this does _not_ automatically convert error responses to golang errors. To do that, use ParseError. Internal client library uses should probably use HoistResponse, unless they are interested in accessing the underlying Error response (e.g. to inspect the error code).

func (*Response) MetadataAsMap

func (r *Response) MetadataAsMap() (*shared.Jmap, error)

func (*Response) MetadataAsOperation

func (r *Response) MetadataAsOperation() (*shared.Operation, error)

type ResponseType

type ResponseType string
const (
	Sync  ResponseType = "sync"
	Async ResponseType = "async"
	Error ResponseType = "error"
)

Directories

Path Synopsis
* * This file is a bit funny.
* * This file is a bit funny.
lxd-bridge
This is a FLEXible file which can be used by both client and daemon.
This is a FLEXible file which can be used by both client and daemon.
gnuflag
Package flag implements command-line flag parsing in the GNU style.
Package flag implements command-line flag parsing in the GNU style.
test
deps
* An example of how to use lxd's golang /dev/lxd client.
* An example of how to use lxd's golang /dev/lxd client.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL