bootfromvolume

Documentation

Overview

Package bootfromvolume extends a server create request with the ability to specify block device options. This can be used to boot a server from a block storage volume as well as specify multiple ephemeral disks upon creation.

It is recommended to refer to the Block Device Mapping documentation to see all possible ways to configure a server's block devices at creation time:

https://docs.openstack.org/nova/latest/user/block-device-mapping.html

Note that this package implements `block_device_mapping_v2`.

Example of Creating a Server From an Image

This example will boot a server from an image and use a standard ephemeral disk as the server's root disk. This is virtually no different than creating a server without using block device mappings.

blockDevices := []bootfromvolume.BlockDevice{
	bootfromvolume.BlockDevice{
		BootIndex:           0,
		DeleteOnTermination: true,
		DestinationType:     bootfromvolume.DestinationLocal,
		SourceType:          bootfromvolume.SourceImage,
		UUID:                "image-uuid",
	},
}

serverCreateOpts := servers.CreateOpts{
	Name:      "server_name",
	FlavorRef: "flavor-uuid",
	ImageRef:  "image-uuid",
}

createOpts := bootfromvolume.CreateOptsExt{
	CreateOptsBuilder: serverCreateOpts,
	BlockDevice:       blockDevices,
}

server, err := bootfromvolume.Create(client, createOpts).Extract()
if err != nil {
	panic(err)
}

Example of Creating a Server From a New Volume

This example will create a block storage volume based on the given Image. The server will use this volume as its root disk.

blockDevices := []bootfromvolume.BlockDevice{
	bootfromvolume.BlockDevice{
		DeleteOnTermination: true,
		DestinationType:     bootfromvolume.DestinationVolume,
		SourceType:          bootfromvolume.SourceImage,
		UUID:                "image-uuid",
		VolumeSize:          2,
	},
}

serverCreateOpts := servers.CreateOpts{
	Name:      "server_name",
	FlavorRef: "flavor-uuid",
}

createOpts := bootfromvolume.CreateOptsExt{
	CreateOptsBuilder: serverCreateOpts,
	BlockDevice:       blockDevices,
}

server, err := bootfromvolume.Create(client, createOpts).Extract()
if err != nil {
	panic(err)
}

Example of Creating a Server From an Existing Volume

This example will create a server with an existing volume as its root disk.

blockDevices := []bootfromvolume.BlockDevice{
	bootfromvolume.BlockDevice{
		DeleteOnTermination: true,
		DestinationType:     bootfromvolume.DestinationVolume,
		SourceType:          bootfromvolume.SourceVolume,
		UUID:                "volume-uuid",
	},
}

serverCreateOpts := servers.CreateOpts{
	Name:      "server_name",
	FlavorRef: "flavor-uuid",
}

createOpts := bootfromvolume.CreateOptsExt{
	CreateOptsBuilder: serverCreateOpts,
	BlockDevice:       blockDevices,
}

server, err := bootfromvolume.Create(client, createOpts).Extract()
if err != nil {
	panic(err)
}

Example of Creating a Server with Multiple Ephemeral Disks

This example will create a server with multiple ephemeral disks. The first block device will be based off of an existing Image. Each additional ephemeral disks must have an index of -1.

blockDevices := []bootfromvolume.BlockDevice{
	bootfromvolume.BlockDevice{
		BootIndex:           0,
		DestinationType:     bootfromvolume.DestinationLocal,
		DeleteOnTermination: true,
		SourceType:          bootfromvolume.SourceImage,
		UUID:                "image-uuid",
		VolumeSize:          5,
	},
	bootfromvolume.BlockDevice{
		BootIndex:           -1,
		DestinationType:     bootfromvolume.DestinationLocal,
		DeleteOnTermination: true,
		GuestFormat:         "ext4",
		SourceType:          bootfromvolume.SourceBlank,
		VolumeSize:          1,
	},
	bootfromvolume.BlockDevice{
		BootIndex:           -1,
		DestinationType:     bootfromvolume.DestinationLocal,
		DeleteOnTermination: true,
		GuestFormat:         "ext4",
		SourceType:          bootfromvolume.SourceBlank,
		VolumeSize:          1,
	},
}

serverCreateOpts := servers.CreateOpts{
	Name:      "server_name",
	FlavorRef: "flavor-uuid",
	ImageRef:  "image-uuid",
}

createOpts := bootfromvolume.CreateOptsExt{
	CreateOptsBuilder: serverCreateOpts,
	BlockDevice:       blockDevices,
}

server, err := bootfromvolume.Create(client, createOpts).Extract()
if err != nil {
	panic(err)
}

Index

• Constants
• func Create(client *gophercloud.ServiceClient, opts servers.CreateOptsBuilder) (r servers.CreateResult)
• type BlockDevice
• type CreateOptsExt
  • func (opts CreateOptsExt) ToServerCreateMap() (map[string]interface{}, error)
• type CreateResult
• type DestinationType
• type SourceType

Constants

const (
	// DestinationLocal DestinationType is for using an ephemeral disk as the
	// destination.
	DestinationLocal DestinationType = "local"

	// DestinationVolume DestinationType is for using a volume as the destination.
	DestinationVolume DestinationType = "volume"

	// SourceBlank SourceType is for a "blank" or empty source.
	SourceBlank SourceType = "blank"

	// SourceImage SourceType is for using images as the source of a block device.
	SourceImage SourceType = "image"

	// SourceSnapshot SourceType is for using a volume snapshot as the source of
	// a block device.
	SourceSnapshot SourceType = "snapshot"

	// SourceVolume SourceType is for using a volume as the source of block
	// device.
	SourceVolume SourceType = "volume"
)

Functions

func Create

func Create(client *gophercloud.ServiceClient, opts servers.CreateOptsBuilder) (r servers.CreateResult)

Create requests the creation of a server from the given block device mapping.

Types

type BlockDevice

type BlockDevice struct {
	// SourceType must be one of: "volume", "snapshot", "image", or "blank".
	SourceType SourceType `json:"source_type" required:"true"`

	// UUID is the unique identifier for the existing volume, snapshot, or
	// image (see above).
	UUID string `json:"uuid,omitempty"`

	// BootIndex is the boot index. It defaults to 0.
	BootIndex int `json:"boot_index"`

	// DeleteOnTermination specifies whether or not to delete the attached volume
	// when the server is deleted. Defaults to `false`.
	DeleteOnTermination bool `json:"delete_on_termination"`

	// DestinationType is the type that gets created. Possible values are "volume"
	// and "local".
	DestinationType DestinationType `json:"destination_type,omitempty"`

	// GuestFormat specifies the format of the block device.
	// Not specifying this will cause the device to be formatted to the default in Nova
	// which is currently vfat.
	// https://opendev.org/openstack/nova/src/commit/d0b459423dd81644e8d9382b6c87fabaa4f03ad4/nova/privsep/fs.py#L257
	GuestFormat string `json:"guest_format,omitempty"`

	// VolumeSize is the size of the volume to create (in gigabytes). This can be
	// omitted for existing volumes.
	VolumeSize int `json:"volume_size,omitempty"`

	// DeviceType specifies the device type of the block devices.
	// Examples of this are disk, cdrom, floppy, lun, etc.
	DeviceType string `json:"device_type,omitempty"`

	// DiskBus is the bus type of the block devices.
	// Examples of this are ide, usb, virtio, scsi, etc.
	DiskBus string `json:"disk_bus,omitempty"`

	// VolumeType is the volume type of the block device.
	// This requires Compute API microversion 2.67 or later.
	VolumeType string `json:"volume_type,omitempty"`

	// Tag is an arbitrary string that can be applied to a block device.
	// Information about the device tags can be obtained from the metadata API
	// and the config drive, allowing devices to be easily identified.
	// This requires Compute API microversion 2.42 or later.
	Tag string `json:"tag,omitempty"`
}

BlockDevice is a structure with options for creating block devices in a server. The block device may be created from an image, snapshot, new volume, or existing volume. The destination may be a new volume, existing volume which will be attached to the instance, ephemeral disk, or boot device.

type CreateOptsExt

type CreateOptsExt struct {
	servers.CreateOptsBuilder
	BlockDevice []BlockDevice `json:"block_device_mapping_v2,omitempty"`
}

CreateOptsExt is a structure that extends the server `CreateOpts` structure by allowing for a block device mapping.

func (CreateOptsExt) ToServerCreateMap

func (opts CreateOptsExt) ToServerCreateMap() (map[string]interface{}, error)

ToServerCreateMap adds the block device mapping option to the base server creation options.

type CreateResult

type CreateResult struct {
	os.CreateResult
}

CreateResult temporarily contains the response from a Create call. It embeds the standard servers.CreateResults type and so can be used the same way as a standard server request result.

type DestinationType

type DestinationType string

DestinationType represents the type of medium being used as the destination of the bootable device.

type SourceType

type SourceType string

SourceType represents the type of medium being used as the source of the bootable device.